Add Pairing Commands to chip-tool-darwin

examples/chip-tool-darwin/.gn

@@ -1,4 +1,4 @@
-# Copyright (c) 2020 Project CHIP Authors
+# Copyright (c) 2022 Project CHIP Authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.

examples/chip-tool-darwin/BUILD.gn

@@ -1,4 +1,4 @@
-# Copyright (c) 2020 Project CHIP Authors
+# Copyright (c) 2022 Project CHIP Authors
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -20,14 +20,24 @@ import("${chip_root}/build/chip/tools.gni")
 assert(chip_build_tools)
 
 executable("chip-tool-darwin") {
- sources = [ "main.m" ]
+ sources = [
+ "commands/common/CHIPCommandBridge.mm",
+ "commands/pairing/Commands.h",
+ "commands/pairing/PairingCommandBridge.mm",
+ "commands/pairing/PairingDelegateBridge.mm",
+ "main.mm",
+ ]
+
+ include_dirs = [ "." ]
 
  deps = [
+ "${chip_root}/examples/chip-tool:chip-tool-utils",
  "${chip_root}/src/app/server",
  "${chip_root}/src/darwin/Framework/CHIP",
  "${chip_root}/src/lib",
  "${chip_root}/src/platform",
  "${chip_root}/third_party/inipp",
+ "${chip_root}/third_party/jsoncpp",
  ]
 
  cflags = [
@@ -37,3 +47,21 @@ executable("chip-tool-darwin") {
 
  output_dir = root_out_dir
 }
+
+action("codesign") {
+ script = "entitlements/codesign.py"
+ sources = [ "entitlements/chip-tool-darwin.entitlements" ]
+ public_deps = [ ":chip-tool-darwin" ]
+
+ args = [
+ "--target_path",
+ rebase_path("${root_build_dir}/chip-tool-darwin", root_build_dir),
+ "--entitlements_path",
+ rebase_path("entitlements/chip-tool-darwin.entitlements", root_build_dir),
+ "--log_path",
+ rebase_path("${root_build_dir}/codesign_log.txt", root_build_dir),
+ ]
+
+ output_name = "codesign_log.txt"
+ outputs = [ "${root_build_dir}/${output_name}" ]
+}

examples/chip-tool-darwin/commands/common/CHIPCommandBridge.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2022 Project CHIP Authors
+ * 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.
+ *
+ */
+
+#pragma once
+#import <CHIP/CHIPDeviceController.h>
+#include <commands/common/Command.h>
+#include <commands/common/CredentialIssuerCommands.h>
+
+#pragma once
+
+class CHIPCommandBridge : public Command
+{
+public:
+ CHIPCommandBridge(const char * commandName) : Command(commandName) {}
+
+ CHIPCommandBridge(const char * commandName, CredentialIssuerCommands * credIssuerCmds) : CHIPCommandBridge(commandName) {}
+
+ /////////// Command Interface /////////
+ CHIP_ERROR Run() override;
+
+ void SetCommandExitStatus(CHIP_ERROR status)
+ {
+ mCommandExitStatus = status;
+ ShutdownCommissioner();
+ StopWaiting();
+ }
+
+protected:
+ // Will be called in a setting in which it's safe to touch the CHIP
+ // stack. The rules for Run() are as follows:
+ //
+ // 1) If error is returned, Run() must not call SetCommandExitStatus.
+ // 2) If success is returned Run() must either have called
+ // SetCommandExitStatus() or scheduled async work that will do that.
+ virtual CHIP_ERROR RunCommand() = 0;
+
+ // Get the wait duration, in seconds, before the command times out.
+ virtual chip::System::Clock::Timeout GetWaitDuration() const = 0;
+
+ // Shut down the command, in case any work needs to be done after the event
+ // loop has been stopped.
+ virtual void Shutdown() {}
+
+ void SetIdentity(const char * name);
+
+ // This method returns the commissioner instance to be used for running the command.
+ CHIPDeviceController * CurrentCommissioner();
+
+private:
+ CHIP_ERROR InitializeCommissioner(std::string key, chip::FabricId fabricId);
+ CHIP_ERROR ShutdownCommissioner();
+ uint16_t CurrentCommissionerIndex();
+
+ CHIP_ERROR mCommandExitStatus = CHIP_ERROR_INTERNAL;
+
+ CHIP_ERROR StartWaiting(chip::System::Clock::Timeout seconds);
+ void StopWaiting();
+ CHIPDeviceController * mController;
+
+#if CONFIG_USE_SEPARATE_EVENTLOOP
+ std::condition_variable cvWaitingForResponse;
+ std::mutex cvWaitingForResponseMutex;
+ bool mWaitingForResponse{ true };
+#endif // CONFIG_USE_SEPARATE_EVENTLOOP
+};

examples/chip-tool-darwin/commands/common/CHIPCommandBridge.mm

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2022 Project CHIP Authors
+ * 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.
+ *
+ */
+
+#include "CHIPCommandBridge.h"
+
+#import <CHIP/CHIPDeviceController.h>
+#include <core/CHIPBuildConfig.h>
+#include <lib/support/CodeUtils.h>
+
+const uint16_t kListenPort = 5541;
+
+CHIP_ERROR CHIPCommandBridge::Run()
+{
+ NSLog(@"Running Command");
+
+ mController = [CHIPDeviceController sharedController];
+ [mController setListenPort:kListenPort];
+ [mController startup:nil vendorId:0 nocSigner:nil];
+
+ RunCommand();
+ ReturnLogErrorOnFailure(StartWaiting(GetWaitDuration()));
+ return CHIP_NO_ERROR;
+}
+
+CHIPDeviceController * CHIPCommandBridge::CurrentCommissioner() { return mController; }
+
+CHIP_ERROR CHIPCommandBridge::ShutdownCommissioner()
+{
+ NSLog(@"Shutting down controller");
+ BOOL result = [CurrentCommissioner() shutdown];
+ if (!result) {
+ NSLog(@"Unable to shut down controller");
+ return CHIP_ERROR_INTERNAL;
+ }
+ return CHIP_NO_ERROR;
+}
+
+#if !CONFIG_USE_SEPARATE_EVENTLOOP
+static void OnResponseTimeout(chip::System::Layer *, void * appState)
+{
+ (reinterpret_cast<CHIPCommandBridge *>(appState))->SetCommandExitStatus(CHIP_ERROR_TIMEOUT);
+}
+#endif // !CONFIG_USE_SEPARATE_EVENTLOOP
+
+CHIP_ERROR CHIPCommandBridge::StartWaiting(chip::System::Clock::Timeout duration)
+{
+#if CONFIG_USE_SEPARATE_EVENTLOOP
+ chip::DeviceLayer::PlatformMgr().StartEventLoopTask();
+ auto waitingUntil = std::chrono::system_clock::now() + std::chrono::duration_cast<std::chrono::seconds>(duration);
+ {
+ std::unique_lock<std::mutex> lk(cvWaitingForResponseMutex);
+ if (!cvWaitingForResponse.wait_until(lk, waitingUntil, [this]() { return !this->mWaitingForResponse; })) {
+ mCommandExitStatus = CHIP_ERROR_TIMEOUT;
+ }
+ }
+ LogErrorOnFailure(chip::DeviceLayer::PlatformMgr().StopEventLoopTask());
+#else
+ ReturnLogErrorOnFailure(chip::DeviceLayer::SystemLayer().StartTimer(duration, OnResponseTimeout, this));
+ chip::DeviceLayer::PlatformMgr().RunEventLoop();
+#endif // CONFIG_USE_SEPARATE_EVENTLOOP
+
+ return mCommandExitStatus;
+}
+
+void CHIPCommandBridge::StopWaiting()
+{
+#if CONFIG_USE_SEPARATE_EVENTLOOP
+ {
+ std::lock_guard<std::mutex> lk(cvWaitingForResponseMutex);
+ mWaitingForResponse = false;
+ }
+ cvWaitingForResponse.notify_all();
+#else // CONFIG_USE_SEPARATE_EVENTLOOP
+ LogErrorOnFailure(chip::DeviceLayer::PlatformMgr().StopEventLoopTask());
+#endif // CONFIG_USE_SEPARATE_EVENTLOOP
+}

examples/chip-tool-darwin/commands/pairing/Commands.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2022 Project CHIP Authors
+ * 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.
+ *
+ */
+
+#pragma once
+
+#include "PairingCommandBridge.h"
+
+class Unpair : public PairingCommandBridge
+{
+public:
+ Unpair() : PairingCommandBridge("unpair", PairingMode::None) {}
+};
+
+class PairQRCode : public PairingCommandBridge
+{
+public:
+ PairQRCode() : PairingCommandBridge("qrcode", PairingMode::QRCode) {}
+};
+
+class PairManualCode : public PairingCommandBridge
+{
+public:
+ PairManualCode() : PairingCommandBridge("manualcode", PairingMode::ManualCode) {}
+};
+
+class PairWithIPAddress : public PairingCommandBridge
+{
+public:
+ PairWithIPAddress() : PairingCommandBridge("ethernet", PairingMode::Ethernet) {}
+};
+
+void registerCommandsPairing(Commands & commands)
+{
+ const char * clusterName = "Pairing";
+
+ commands_list clusterCommands = {
+ make_unique<Unpair>(),
+ make_unique<PairQRCode>(),
+ make_unique<PairManualCode>(),
+ make_unique<PairWithIPAddress>(),
+ };
+
+ commands.Register(clusterName, clusterCommands);
+}

examples/chip-tool-darwin/commands/pairing/PairingCommandBridge.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2022 Project CHIP Authors
+ * 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.
+ *
+ */
+
+#pragma once
+#include "../common/CHIPCommandBridge.h"
+#import <CHIP/CHIPClustersObjc.h>
+#import <CHIP/CHIPDevicePairingDelegate.h>
+
+enum class PairingMode
+{
+ None,
+ QRCode,
+ ManualCode,
+ Ethernet
+};
+
+class PairingCommandBridge : public CHIPCommandBridge
+{
+public:
+ PairingCommandBridge(const char * commandName, PairingMode mode) : CHIPCommandBridge(commandName), mPairingMode(mode)
+ {
+ AddArgument("node-id", 0, UINT64_MAX, &mNodeId);
+
+ switch (mode)
+ {
+ case PairingMode::None:
+ break;
+ case PairingMode::QRCode:
+ AddArgument("payload", &mOnboardingPayload);
+ break;
+ case PairingMode::ManualCode:
+ AddArgument("payload", &mOnboardingPayload);
+ break;
+ case PairingMode::Ethernet:
+ AddArgument("setup-pin-code", 0, 134217727, &mSetupPINCode);
+ AddArgument("discriminator", 0, 4096, &mDiscriminator);
+ AddArgument("device-remote-ip", &ipAddress);
+ AddArgument("device-remote-port", 0, UINT16_MAX, &mRemotePort);
+ break;
+ }
+ }
+
+ /////////// CHIPCommandBridge Interface /////////
+ CHIP_ERROR RunCommand() override;
+ chip::System::Clock::Timeout GetWaitDuration() const override { return chip::System::Clock::Seconds16(120); }
+
+private:
+ void PairWithCode(NSError * error);
+ void PairWithIPAddress(NSError * error);
+ void Unpair(NSError * error);
+ void SetUpPairingDelegate();
+
+ const PairingMode mPairingMode;
+ chip::NodeId mNodeId;
+ uint16_t mRemotePort;
+ uint16_t mDiscriminator;
+ uint32_t mSetupPINCode;
+ char * mOnboardingPayload;
+ char * ipAddress;
+};