03 large weave merge

examples/message-layer/Makefile

@@ -0,0 +1,70 @@
+#
+#
+#   Copyright (c) 2020 Project CHIP Authors
+#   Copyright (c) 2019 Google LLC.
+#   All rights reserved.
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an "AS IS" BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+
+#
+#   @file
+#         Makefile for building the CHIP Standalone Example Application.
+#
+
+PROJECT_ROOT := $(realpath .)
+
+CHIP_ROOT = $(realpath $(PROJECT_ROOT)/third_party/connectedhomeip)
+BUILD_SUPPORT_DIR = $(CHIP_ROOT)/config/standalone
+
+include $(BUILD_SUPPORT_DIR)/standalone-app.mk
+include $(BUILD_SUPPORT_DIR)/standalone-chip.mk
+
+APP = chip-message-layer-demo
+
+STD_LIBS +=                           \
+   -lChipCrypto                       \
+   $(OPENSSL_LDFLAGS) $(OPENSSL_LIBS) \
+   $(CRYPTO_LDFLAGS) $(CRYPTO_LIBS)   \
+   $(MBEDTLS_LDFLAGS) $(MBEDTLS_LIBS)
+
+# TODO: find out why above is not sufficient
+STD_LIBS += -lcrypto
+
+SRCS = \
+    $(PROJECT_ROOT)/main.cpp \
+    $(NULL)
+
+INC_DIRS = \
+    $(PROJECT_ROOT) \
+    $(PROJECT_ROOT)/include \
+    $(CHIP_ROOT)/src/lib \
+    $(CHIP_ROOT)/src/ \
+    $(CHIP_ROOT)/src/system \
+    $(CHIP_ROOT)/src/controller \
+    $(CHIP_ROOT)/config/standalone \
+    $(NULL)
+
+DEFINES = \
+    USE_APP_CONFIG \
+    $(NULL)
+
+ifdef BUILD_RELEASE
+    DEFINES += BUILD_RELEASE=1
+else
+    DEFINES += BUILD_RELEASE=0
+endif
+
+CHIP_PROJECT_CONFIG = $(PROJECT_ROOT)/include/CHIPProjectConfig.h
+
+$(call GenerateBuildRules)

examples/message-layer/main.cpp

@@ -0,0 +1,281 @@
+#include <iostream>
+#include <thread>
+#include <chrono>
+#include <string>
+
+#include <signal.h>
+
+#include <CHIPVersion.h>
+
+#include <core/CHIPBinding.h>
+#include <core/CHIPExchangeMgr.h>
+#include <core/CHIPMessageLayer.h>
+#include <inet/InetLayer.h>
+#include <support/CHIPArgParser.hpp>
+#include <support/CodeUtils.h>
+#include <system/SystemLayer.h>
+#include <controller/CHIPDeviceController.h>
+
+namespace {
+
+using namespace chip;
+using namespace chip::ArgParser;
+
+constexpr uint32_t kProfileId  = 100;
+constexpr uint8_t kMessageType = 123;
+
+#define kToolName "message-layer-demo"
+
+constexpr uint16_t kToolOptListen  = 'l';
+constexpr uint16_t kToolOptUDPIP   = 'u';
+constexpr uint16_t kToolOptNodeId  = 'n';
+constexpr uint16_t kToolOptMessage = 'm';
+
+OptionDef sToolOptionDefs[] = { //
+    { "listen", kNoArgument, kToolOptListen },
+    { "udp", kNoArgument, kToolOptUDPIP },
+    { "node", kArgumentRequired, kToolOptNodeId },
+    { "message", kArgumentRequired, kToolOptMessage },
+    {}
+};
+
+constexpr const char * sToolOptionHelp = //
+    "  -l, --listen\n         Act as a server (i.e., listen) for packets rather than send them.\n\n"
+    "  -u, --udp\n         Use UDP over IP.\n\n"
+    "  -n, --node <Id>\n           Use UDP over IP.\n\n"
+    "  -m, --message <Id>\n           Message to send over the wire.\n\n";
+
+bool HandleOption(const char * aProgram, OptionSet * aOptions, int aIdentifier, const char * aName, const char * aValue);
+bool HandleNonOptionArgs(const char * aProgram, int argc, char * argv[]);
+
+struct
+{
+    bool Listen         = false;
+    bool Udp            = false;
+    int64_t NodeId      = 1;
+    std::string Message = "This is a message";
+} ProgramArguments;
+
+OptionSet sToolOptions = { //
+    HandleOption,          //
+    sToolOptionDefs,       //
+    "GENERAL OPTIONS",     //
+    sToolOptionHelp
+};
+
+HelpOptions sHelpOptions(                                                         //
+    kToolName,                                                                    //
+    "Usage: " kToolName " [ <options> ] [ -g <group> [ ... ] -I <interface> ]\n", //
+    CHIP_VERSION_STRING "\nCopyright (c) 2020 Project CHIP Authors\nAll rights reserved.\n");
+
+static OptionSet * sToolOptionSets[] = { &sToolOptions, &sHelpOptions, NULL };
+
+bool HandleOption(const char * aProgram, OptionSet * aOptions, int aIdentifier, const char * aName, const char * aValue)
+{
+    switch (aIdentifier)
+    {
+    case kToolOptListen:
+        ProgramArguments.Listen = true;
+        break;
+    case kToolOptUDPIP:
+        ProgramArguments.Udp = true;
+        break;
+    case kToolOptNodeId:
+        ProgramArguments.NodeId = atoll(aValue);
+        break;
+    case kToolOptMessage:
+        ProgramArguments.Message = aValue;
+        break;
+    default:
+        return false;
+    }
+    return true;
+}
+
+bool HandleNonOptionArgs(const char * aProgram, int argc, char * argv[])
+{
+    if (argc > 0)
+    {
+        PrintArgError("%s: unexpected argument: %s\n", aProgram, argv[0]);
+        return false;
+    }
+
+    return true;
+}
+
+volatile bool programStopped = false;
+void StopHandler(int s)
+{
+    programStopped = true;
+}
+
+void RegisterStopHandler()
+{
+    signal(SIGHUP, StopHandler);
+    signal(SIGQUIT, StopHandler);
+    signal(SIGSTOP, StopHandler);
+    signal(SIGINT, StopHandler);
+}
+void HandleBindingEvent(void * appState, chip::Binding::EventType event, const chip::Binding::InEventParam & in,
+                        chip::Binding::OutEventParam & out)
+{
+
+    if (event != chip::Binding::EventType::kEvent_BindingReady)
+    {
+        return;
+    }
+    std::cout << "Binding ready. Can sent message." << std::endl;
+
+    CHIP_ERROR err;
+    chip::ExchangeContext * exchangeContext = NULL;
+
+    err = in.Source->NewExchangeContext(exchangeContext);
+    SuccessOrExit(err);
+
+    {
+        PacketBuffer * packet = PacketBuffer::NewWithAvailableSize(ProgramArguments.Message.size());
+        VerifyOrExit(packet != NULL, err = CHIP_ERROR_NO_MEMORY);
+
+        packet->SetDataLength(ProgramArguments.Message.size());
+        memcpy(packet->Start(), ProgramArguments.Message.data(), ProgramArguments.Message.size());
+        err = exchangeContext->SendMessage(kProfileId, kMessageType, packet);
+    }
+
+exit:
+    if (err != CHIP_NO_ERROR)
+    {
+        std::cout << "Sent message error: " << ErrorStr(err) << std::endl;
+    }
+    else
+    {
+        std::cout << "Message has been sent." << std::endl;
+    }
+}
+
+void ConnectToServer(ChipExchangeManager * exchangeMgr)
+{
+    CHIP_ERROR err = CHIP_NO_ERROR;
+
+    Binding * binding = exchangeMgr->NewBinding();
+    VerifyOrExit(binding != NULL, err = CHIP_ERROR_NO_MEMORY);
+
+    binding->SetEventCallback(HandleBindingEvent);
+
+    {
+
+        Binding::Configuration configuration = binding->BeginConfiguration();
+
+        if (ProgramArguments.Udp)
+        {
+            configuration.Transport_UDP();
+        }
+        else
+        {
+            configuration.Transport_TCP();
+        }
+
+        Inet::IPAddress address;
+        VerifyOrExit(Inet::IPAddress::FromString("::1", address), err = CHIP_ERROR_INVALID_ARGUMENT);
+
+        err = configuration                               //
+                  .Target_NodeId(ProgramArguments.NodeId) //
+                  .TargetAddress_IP(address, CHIP_PORT)   //
+                  .PrepareBinding();
+        SuccessOrExit(err);
+    }
+
+exit:
+    if (err != CHIP_NO_ERROR)
+    {
+        std::cout << "Sent message error: " << ErrorStr(err) << std::endl;
+    }
+}
+
+void ReceiveMessageHandler(ExchangeContext * ec, const IPPacketInfo * pktInfo, const ChipMessageInfo * msgInfo, uint32_t profileId,
+                           uint8_t msgType, PacketBuffer * payload)
+{
+    std::cout << "Received a message type " << static_cast<int>(msgType) << std::endl;
+
+    std::string data(reinterpret_cast<const char *>(payload->Start()), payload->DataLength());
+
+    std::cout << "Payload of size " << payload->DataLength() << ": '" << data << "'" << std::endl;
+}
+
+} // namespace
+
+int main(int argc, char * argv[])
+{
+
+    if (!ParseArgs(kToolName, argc, argv, sToolOptionSets, HandleNonOptionArgs))
+    {
+        std::cout << "Failed to parse arguments" << std::endl;
+        return 1;
+    }
+
+    CHIP_ERROR err = CHIP_NO_ERROR;
+
+    ChipExchangeManager exchangeMgr;
+    ChipMessageLayer messageLayer;
+    ChipFabricState fabricState;
+    chip::DeviceController::ChipDeviceController controller;
+
+    ChipMessageLayer::InitContext initContext;
+
+    err = fabricState.Init();
+    SuccessOrExit(err);
+
+    err = controller.Init();
+    SuccessOrExit(err);
+
+    initContext.systemLayer = controller.SystemLayer();
+    initContext.inet        = controller.InetLayer();
+    initContext.fabricState = &fabricState;
+    initContext.listenTCP   = ProgramArguments.Listen;
+    initContext.listenUDP   = ProgramArguments.Listen || ProgramArguments.Udp;
+
+    err = messageLayer.Init(&initContext);
+    SuccessOrExit(err);
+
+    err = exchangeMgr.Init(&messageLayer);
+    SuccessOrExit(err);
+
+    err = exchangeMgr.RegisterUnsolicitedMessageHandler(kProfileId, ReceiveMessageHandler, nullptr);
+    SuccessOrExit(err);
+
+    if (ProgramArguments.Listen)
+    {
+        std::cout << "Acting as a SERVER ..." << std::endl;
+        std::cout << "Node ID: " << fabricState.LocalNodeId << std::endl;
+    }
+    else
+    {
+        std::cout << "Acting as a CLIENT ..." << std::endl;
+        ConnectToServer(&exchangeMgr);
+    }
+
+    err = messageLayer.RefreshEndpoints();
+    SuccessOrExit(err);
+
+    RegisterStopHandler();
+    while (!programStopped)
+    {
+        std::this_thread::sleep_for(std::chrono::milliseconds(200));
+        controller.ServiceEvents();
+    }
+
+    // TODO(Andrei): RAII would be nice here
+    exchangeMgr.Shutdown();
+    controller.Shutdown();
+
+exit:
+    if (err != CHIP_NO_ERROR)
+    {
+        std::cout << "FAILED: " << ErrorStr(err) << std::endl;
+    }
+    else
+    {
+        std::cout << "DONE!" << std::endl;
+    }
+
+    return 0;
+}

examples/message-layer/third_party/connectedhomeip

@@ -0,0 +1 @@
+../../..