diff --git a/examples/common/chip-app-server/RendezvousServer.cpp b/examples/common/chip-app-server/RendezvousServer.cpp index 1bf3a980285764..ead0cf85d46088 100644 --- a/examples/common/chip-app-server/RendezvousServer.cpp +++ b/examples/common/chip-app-server/RendezvousServer.cpp @@ -62,7 +62,7 @@ void RendezvousServer::OnRendezvousMessageReceived(const PacketHeader & packetHe void RendezvousServer::OnRendezvousComplete() { ChipLogProgress(AppServer, "Device completed Rendezvous process"); - if (mRendezvousSession.GetLocalNodeId().HasValue() && mRendezvousSession.GetRemoteNodeId().HasValue()) + if (mRendezvousSession.GetRemoteNodeId().HasValue()) { SessionManager().NewPairing(Optional{}, mRendezvousSession.GetRemoteNodeId().Value(), &mRendezvousSession.GetPairingSession()); diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp index 5c429e80768913..26af9b6b3f7dcd 100644 --- a/src/controller/CHIPDeviceController.cpp +++ b/src/controller/CHIPDeviceController.cpp @@ -473,18 +473,24 @@ CHIP_ERROR DeviceCommissioner::PairDevice(NodeId remoteDeviceId, RendezvousParam VerifyOrExit(mState == State::Initialized, err = CHIP_ERROR_INCORRECT_STATE); VerifyOrExit(mDeviceBeingPaired == kNumMaxActiveDevices, err = CHIP_ERROR_INCORRECT_STATE); -#if CONFIG_DEVICE_LAYER && CONFIG_NETWORK_LAYER_BLE - if (!params.HasBleLayer()) + // TODO: We need to specify the peer address for BLE transport in bindings. + if (params.GetPeerAddress().GetTransportType() == Transport::Type::kBle || + params.GetPeerAddress().GetTransportType() == Transport::Type::kUndefined) { - params.SetBleLayer(DeviceLayer::ConnectivityMgr().GetBleLayer()); - params.SetPeerAddress(Transport::PeerAddress::BLE()); - } +#if CONFIG_DEVICE_LAYER && CONFIG_NETWORK_LAYER_BLE + if (!params.HasBleLayer()) + { + params.SetBleLayer(DeviceLayer::ConnectivityMgr().GetBleLayer()); + params.SetPeerAddress(Transport::PeerAddress::BLE()); + } #endif // CONFIG_DEVICE_LAYER && CONFIG_NETWORK_LAYER_BLE + } mDeviceBeingPaired = GetInactiveDeviceIndex(); VerifyOrExit(mDeviceBeingPaired < kNumMaxActiveDevices, err = CHIP_ERROR_NO_MEMORY); device = &mActiveDevices[mDeviceBeingPaired]; + mIsIPRendezvous = (params.GetPeerAddress().GetTransportType() != Transport::Type::kBle); mRendezvousSession = chip::Platform::New(this); VerifyOrExit(mRendezvousSession != nullptr, err = CHIP_ERROR_NO_MEMORY); err = mRendezvousSession->Init(params.SetLocalNodeId(mLocalDeviceId).SetRemoteNodeId(remoteDeviceId), mTransportMgr); @@ -492,6 +498,14 @@ CHIP_ERROR DeviceCommissioner::PairDevice(NodeId remoteDeviceId, RendezvousParam device->Init(mTransportMgr, mSessionManager, mInetLayer, remoteDeviceId, remotePort, interfaceId); + // TODO: BLE rendezvous and IP rendezvous should have same logic in the future after BLE becomes a transport and network + // provisiong cluster is ready. + if (params.GetPeerAddress().GetTransportType() != Transport::Type::kBle) + { + device->SetAddress(params.GetPeerAddress().GetIPAddress()); + mRendezvousSession->OnRendezvousConnectionOpened(); + } + exit: if (err != CHIP_NO_ERROR) { @@ -675,7 +689,7 @@ void DeviceCommissioner::OnRendezvousStatusUpdate(RendezvousSessionDelegate::Sta ChipLogDetail(Controller, "Remote device completed SPAKE2+ handshake\n"); mRendezvousSession->GetPairingSession().ToSerializable(device->GetPairing()); - if (mPairingDelegate != nullptr) + if (!mIsIPRendezvous && mPairingDelegate != nullptr) { mPairingDelegate->OnNetworkCredentialsRequested(mRendezvousSession); } diff --git a/src/controller/CHIPDeviceController.h b/src/controller/CHIPDeviceController.h index 3c7050a97de52b..e69c4f621e2679 100644 --- a/src/controller/CHIPDeviceController.h +++ b/src/controller/CHIPDeviceController.h @@ -297,6 +297,12 @@ class DLL_EXPORT DeviceCommissioner : public DeviceController, public Rendezvous If no device is currently being paired, this value will be kNumMaxPairedDevices. */ uint16_t mDeviceBeingPaired; + /* TODO: BLE rendezvous and IP rendezvous should share the same procedure, so this is just a + workaround-like flag and should be removed in the future. + When using IP rendezvous, we need to disable network provisioning. In the future, network + provisioning will no longer be a part of rendezvous procedure. */ + bool mIsIPRendezvous; + /* This field is true when device pairing information changes, e.g. a new device is paired, or the pairing for a device is removed. The DeviceCommissioner uses this to decide when to persist the device list */ diff --git a/src/controller/CHIPDeviceController_deprecated.cpp b/src/controller/CHIPDeviceController_deprecated.cpp index d143507b065bc5..6793799dc655a5 100644 --- a/src/controller/CHIPDeviceController_deprecated.cpp +++ b/src/controller/CHIPDeviceController_deprecated.cpp @@ -113,6 +113,9 @@ CHIP_ERROR ChipDeviceController::ConnectDevice(NodeId remoteDeviceId, Rendezvous mOnComplete.Response = onMessageReceived; mOnError = onError; + // TODO: Should call mOnNewConnected when rendezvous completed + mOnNewConnection(this, nullptr, mAppReqState); + exit: return err; } diff --git a/src/controller/python/BUILD.gn b/src/controller/python/BUILD.gn index b04a9d9f95fa66..992a1bea325935 100644 --- a/src/controller/python/BUILD.gn +++ b/src/controller/python/BUILD.gn @@ -41,6 +41,7 @@ shared_library("ChipDeviceCtrl") { "ChipDeviceController-ScriptBinding.cpp", "ChipDeviceController-ScriptDevicePairingDelegate.cpp", "ChipDeviceController-ScriptDevicePairingDelegate.h", + "ChipDeviceController-StorageDelegate.h", ] public_deps = [ diff --git a/src/controller/python/ChipDeviceController-ScriptBinding.cpp b/src/controller/python/ChipDeviceController-ScriptBinding.cpp index 3518f94600ab92..5f605732aeee47 100644 --- a/src/controller/python/ChipDeviceController-ScriptBinding.cpp +++ b/src/controller/python/ChipDeviceController-ScriptBinding.cpp @@ -44,13 +44,16 @@ #endif /* CONFIG_NETWORK_LAYER_BLE */ #include "ChipDeviceController-ScriptDevicePairingDelegate.h" +#include "ChipDeviceController-StorageDelegate.h" #include #include #include #include +#include #include +using namespace chip; using namespace chip::Ble; using namespace chip::DeviceController; @@ -125,6 +128,7 @@ class BleDisconnectEvent : public BleEventBase static chip::System::Layer sSystemLayer; static chip::Inet::InetLayer sInetLayer; +static chip::Controller::PythonPersistentStorageDelegate sStorageDelegate; // NOTE: Remote device ID is in sync with the echo server device id // At some point, we may want to add an option to connect to a device without @@ -170,6 +174,9 @@ CHIP_ERROR nl_Chip_DeviceController_DeleteDeviceController(chip::DeviceControlle CHIP_ERROR nl_Chip_DeviceController_Connect(chip::DeviceController::ChipDeviceController * devCtrl, BLE_CONNECTION_OBJECT connObj, uint32_t setupPinCode, OnConnectFunct onConnect, OnMessageFunct onMessage, OnErrorFunct onError); +CHIP_ERROR nl_Chip_DeviceController_ConnectIP(chip::DeviceController::ChipDeviceController * devCtrl, const char * peerAddrStr, + uint32_t setupPINCode, OnConnectFunct onConnect, OnMessageFunct onMessage, + OnErrorFunct onError); // Network Provisioning CHIP_ERROR @@ -204,7 +211,7 @@ CHIP_ERROR nl_Chip_DeviceController_NewDeviceController(chip::DeviceController:: *outDevCtrl = new chip::DeviceController::ChipDeviceController(); VerifyOrExit(*outDevCtrl != NULL, err = CHIP_ERROR_NO_MEMORY); - err = (*outDevCtrl)->Init(kLocalDeviceId, &sSystemLayer, &sInetLayer); + err = (*outDevCtrl)->Init(kLocalDeviceId, &sSystemLayer, &sInetLayer, nullptr, &sStorageDelegate); SuccessOrExit(err); exit: @@ -531,14 +538,29 @@ CHIP_ERROR nl_Chip_DeviceController_Connect(chip::DeviceController::ChipDeviceCo uint32_t setupPINCode, OnConnectFunct onConnect, OnMessageFunct onMessage, OnErrorFunct onError) { - CHIP_ERROR err = CHIP_NO_ERROR; - chip::RendezvousParameters params = - chip::RendezvousParameters().SetSetupPINCode(setupPINCode).SetConnectionObject(connObj).SetBleLayer(&sBle); - err = devCtrl->ConnectDevice(kRemoteDeviceId, params, (void *) devCtrl, onConnect, onMessage, onError); - SuccessOrExit(err); + return devCtrl->ConnectDevice(kRemoteDeviceId, + chip::RendezvousParameters() + .SetPeerAddress(Transport::PeerAddress(Transport::Type::kBle)) + .SetSetupPINCode(setupPINCode) + .SetConnectionObject(connObj) + .SetBleLayer(&sBle), + (void *) devCtrl, onConnect, onMessage, onError); +} -exit: - return err; +CHIP_ERROR nl_Chip_DeviceController_ConnectIP(chip::DeviceController::ChipDeviceController * devCtrl, const char * peerAddrStr, + uint32_t setupPINCode, OnConnectFunct onConnect, OnMessageFunct onMessage, + OnErrorFunct onError) +{ + CHIP_ERROR err = CHIP_NO_ERROR; + chip::Inet::IPAddress peerAddr; + chip::Transport::PeerAddress addr; + chip::RendezvousParameters params = chip::RendezvousParameters().SetSetupPINCode(setupPINCode); + + VerifyOrReturnError(chip::Inet::IPAddress::FromString(peerAddrStr, peerAddr), err = CHIP_ERROR_INVALID_ARGUMENT); + // TODO: IP rendezvous should use TCP connection. + addr.SetTransportType(chip::Transport::Type::kUdp).SetIPAddress(peerAddr); + params.SetPeerAddress(addr).SetDiscriminator(0); + return devCtrl->ConnectDevice(kRemoteDeviceId, params, (void *) devCtrl, onConnect, onMessage, onError); } CHIP_ERROR diff --git a/src/controller/python/ChipDeviceController-StorageDelegate.h b/src/controller/python/ChipDeviceController-StorageDelegate.h new file mode 100644 index 00000000000000..29de2e62b178dc --- /dev/null +++ b/src/controller/python/ChipDeviceController-StorageDelegate.h @@ -0,0 +1,45 @@ +/* + * + * Copyright (c) 2020 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 + +class PythonPersistentStorageDelegate; + +typedef void (*GetKeyValueFunct)(const uint8_t * key, uint8_t * value, uint16_t * size); +typedef void (*SetKeyValueFunct)(const uint8_t * key, const uint8_t * value); +typedef void (*DeleteKeyValueFunct)(const uint8_t * key); + +namespace chip { +namespace Controller { + +// TODO: Implement this. +class PythonPersistentStorageDelegate : public PersistentStorageDelegate +{ +public: + PythonPersistentStorageDelegate() {} + void SetDelegate(PersistentStorageResultDelegate * delegate) override {} + void GetKeyValue(const char * key) override {} + CHIP_ERROR GetKeyValue(const char * key, char * value, uint16_t & size) override { return CHIP_ERROR_NOT_IMPLEMENTED; } + void SetKeyValue(const char * key, const char * value) override {} + void DeleteKeyValue(const char * key) override {} +}; + +} // namespace Controller +} // namespace chip diff --git a/src/controller/python/chip-device-ctrl.py b/src/controller/python/chip-device-ctrl.py index 6b07db4c43c10d..6921cc0a45f21f 100755 --- a/src/controller/python/chip-device-ctrl.py +++ b/src/controller/python/chip-device-ctrl.py @@ -365,7 +365,8 @@ def do_btpconnect(self, line): def do_connect(self, line): """ - connect (via BLE) + connect -ip + connect -ble connect command is used for establishing a rendezvous session to the device. currently, only connect using setupPinCode is supported. @@ -376,14 +377,18 @@ def do_connect(self, line): try: args = shlex.split(line) - if not args: + if len(args) <= 1: print("Usage:") self.do_help("connect SetupPinCode") return - if len(args) > 1: - print("Unexpected argument: " + args[1]) + if args[0] == "-ip" and len(args) == 3: + self.devCtrl.ConnectIP(args[1].encode("utf-8"), int(args[2])) + elif args[0] == "-ble" and len(args) == 2: + self.devCtrl.Connect(FAKE_CONN_OBJ_VALUE, int(args[1])) + else: + print("Usage:") + self.do_help("connect SetupPinCode") return - self.devCtrl.Connect(FAKE_CONN_OBJ_VALUE, int(args[0])) except ChipStack.ChipStackException as ex: print(str(ex)) return diff --git a/src/controller/python/chip/ChipDeviceCtrl.py b/src/controller/python/chip/ChipDeviceCtrl.py index 0e7a84b4e93c7a..ab484958616abe 100644 --- a/src/controller/python/chip/ChipDeviceCtrl.py +++ b/src/controller/python/chip/ChipDeviceCtrl.py @@ -94,12 +94,12 @@ def __init__(self, startNetworkThread=True): res = self._dmLib.nl_Chip_DeviceController_NewDeviceController(pointer(devCtrl)) if res != 0: raise self._ChipStack.ErrorToException(res) - + pairingDelegate = c_void_p(None) res = self._dmLib.nl_Chip_ScriptDevicePairingDelegate_NewPairingDelegate(pointer(pairingDelegate)) if res != 0: raise self._ChipStack.ErrorToException(res) - + res = self._dmLib.nl_Chip_DeviceController_SetDevicePairingDelegate(devCtrl, pairingDelegate) if res != 0: raise self._ChipStack.ErrorToException(res) @@ -108,9 +108,11 @@ def __init__(self, startNetworkThread=True): self.pairingDelegate = pairingDelegate self._ChipStack.devCtrl = devCtrl - self.blockingCB = None # set by other modules(BLE) that require service by thread while thread blocks. + # set by other modules(BLE) that require service by thread while thread blocks. + self.blockingCB = None self.cbHandleBleEvent = ( - None # set by other modules (BLE) that provide event callback to Chip. + # set by other modules (BLE) that provide event callback to Chip. + None ) self.cbHandleBleWriteChar = None self.cbHandleBleSubscribeChar = None @@ -118,9 +120,9 @@ def __init__(self, startNetworkThread=True): def DeviceCtrlHandleMessage(appReqState, buffer): pass - + self.cbHandleMessage = _OnMessageFunct(DeviceCtrlHandleMessage) - + def HandleRendezvousError(appState, reqState, err, devStatusPtr): if self.state == DCState.RENDEZVOUS_ONGOING: print("Failed to connect to device: {}".format(err)) @@ -128,7 +130,7 @@ def HandleRendezvousError(appState, reqState, err, devStatusPtr): self._ChipStack.completeEvent.set() elif self.state == DCState.RENDEZVOUS_CONNECTED: print("Disconnected from device") - + self.cbHandleRendezvousError = _OnRendezvousErrorFunct(HandleRendezvousError) if startNetworkThread: @@ -202,19 +204,33 @@ def ConnectBle(self, bleConnection): self._ChipStack.cbHandleError, ) ) - + def Connect(self, connObj, setupPinCode): def HandleComplete(dc, connState, appState): - print("Rendezvoud Complete") + print("Rendezvous Complete") + self.state = DCState.RENDEZVOUS_CONNECTED + self._ChipStack.callbackRes = True + self._ChipStack.completeEvent.set() + onConnectFunct = _OnConnectFunct(HandleComplete) + + self.state = DCState.RENDEZVOUS_ONGOING + return self._ChipStack.CallAsync( + lambda: self._dmLib.nl_Chip_DeviceController_Connect( + self.devCtrl, connObj, setupPinCode, onConnectFunct, self.cbHandleMessage, self.cbHandleRendezvousError) + ) + + def ConnectIP(self, ipaddr, setupPinCode): + def HandleComplete(dc, connState, appState): + print("Rendezvous Complete") self.state = DCState.RENDEZVOUS_CONNECTED self._ChipStack.callbackRes = True self._ChipStack.completeEvent.set() - onConnectFunct = _OnConnectFunct(HandleComplete) self.state = DCState.RENDEZVOUS_ONGOING return self._ChipStack.CallAsync( - lambda: self._dmLib.nl_Chip_DeviceController_Connect(self.devCtrl, connObj, setupPinCode, onConnectFunct, self.cbHandleMessage, self.cbHandleRendezvousError) + lambda: self._dmLib.nl_Chip_DeviceController_ConnectIP( + self.devCtrl, ipaddr, setupPinCode, onConnectFunct, self.cbHandleMessage, self.cbHandleRendezvousError) ) def Close(self): @@ -237,7 +253,7 @@ def GetLogFilter(self): def SetBlockingCB(self, blockingCB): self._ChipStack.blockingCB = blockingCB - + def SetWifiCredential(self, ssid, password): ret = self._dmLib.nl_Chip_ScriptDevicePairingDelegate_SetWifiCredential(self.pairingDelegate, ssid.encode("utf-8"), password.encode("utf-8")) if ret != 0: @@ -308,9 +324,14 @@ def _InitLib(self): self._dmLib.nl_Chip_DeviceController_SetLogFilter.argtypes = [c_uint8] self._dmLib.nl_Chip_DeviceController_SetLogFilter.restype = None - self._dmLib.nl_Chip_DeviceController_Connect.argtypes = [c_void_p, c_void_p, c_uint32, _OnConnectFunct, _OnMessageFunct, _OnRendezvousErrorFunct] + self._dmLib.nl_Chip_DeviceController_Connect.argtypes = [ + c_void_p, c_void_p, c_uint32, _OnConnectFunct, _OnMessageFunct, _OnRendezvousErrorFunct] self._dmLib.nl_Chip_DeviceController_Connect.restype = c_uint32 + self._dmLib.nl_Chip_DeviceController_ConnectIP.argtypes = [ + c_void_p, c_char_p, c_uint32, _OnConnectFunct, _OnMessageFunct, _OnRendezvousErrorFunct] + self._dmLib.nl_Chip_DeviceController_ConnectIP.restype = c_uint32 + self._dmLib.nl_Chip_ScriptDevicePairingDelegate_NewPairingDelegate.argtypes = [POINTER(c_void_p)] self._dmLib.nl_Chip_ScriptDevicePairingDelegate_NewPairingDelegate.restype = c_uint32 diff --git a/src/test_driver/linux-cirque/OnOffClusterTest.sh b/src/test_driver/linux-cirque/OnOffClusterTest.sh index 1be3d8612b84b4..2175893d40e1d4 100755 --- a/src/test_driver/linux-cirque/OnOffClusterTest.sh +++ b/src/test_driver/linux-cirque/OnOffClusterTest.sh @@ -39,7 +39,7 @@ function build_chip_lighting() { source "$REPO_DIR/scripts/activate.sh" >/dev/null set -x cd "$chip_light_dir" - gn gen --check --fail-on-unused-args out/debug --args='chip_bypass_rendezvous=true' + gn gen --check --fail-on-unused-args out/debug run_ninja -C out/debug docker build -t chip_server -f Dockerfile . 2>&1 set +x diff --git a/src/test_driver/linux-cirque/test-on-off-cluster.py b/src/test_driver/linux-cirque/test-on-off-cluster.py index 09e38fdd77cb68..94d3f5e32aae5c 100644 --- a/src/test_driver/linux-cirque/test-on-off-cluster.py +++ b/src/test_driver/linux-cirque/test-on-off-cluster.py @@ -46,6 +46,8 @@ } } +SETUPPINCODE = 12345678 +DISCRIMINATOR = 1 # Randomw number, not used CHIP_PORT = 11097 CIRQUE_URL = "http://localhost:5000" @@ -80,22 +82,30 @@ def run_data_model_test(self): command = "chip-tool onoff {} 1" for ip in server_ip_address: - ret = self.execute_device_cmd(tool_device_id, "chip-tool pairing bypass {} {}".format(ip, CHIP_PORT)) - self.assertEqual(ret['return_code'], '0', "{} command failure: {}".format("pairing bypass", ret['output'])) + ret = self.execute_device_cmd( + tool_device_id, "chip-tool pairing softap ssid_not_used passwd_not_used {} {} {} {}".format(SETUPPINCODE, DISCRIMINATOR, ip, CHIP_PORT)) + self.assertEqual(ret['return_code'], '0', "{} command failure: {}".format( + "pairing softap", ret['output'])) ret = self.execute_device_cmd(tool_device_id, command.format("on")) - self.assertEqual(ret['return_code'], '0', "{} command failure: {}".format("on", ret['output'])) + self.assertEqual( + ret['return_code'], '0', "{} command failure: {}".format("on", ret['output'])) - ret = self.execute_device_cmd(tool_device_id, command.format("off")) - self.assertEqual(ret['return_code'], '0', "{} command failure: {}".format("off", ret['output'])) + ret = self.execute_device_cmd( + tool_device_id, command.format("off")) + self.assertEqual( + ret['return_code'], '0', "{} command failure: {}".format("off", ret['output'])) - ret = self.execute_device_cmd(tool_device_id, "chip-tool pairing unpair") - self.assertEqual(ret['return_code'], '0', "{} command failure: {}".format("pairing unpair", ret['output'])) + ret = self.execute_device_cmd( + tool_device_id, "chip-tool pairing unpair") + self.assertEqual(ret['return_code'], '0', "{} command failure: {}".format( + "pairing unpair", ret['output'])) time.sleep(1) for device_id in server_ids: - self.logger.info("checking device log for {}".format(self.get_device_pretty_id(device_id))) + self.logger.info("checking device log for {}".format( + self.get_device_pretty_id(device_id))) self.assertTrue(self.sequenceMatch(self.get_device_log(device_id).decode('utf-8'), ["LightingManager::InitiateAction(ON_ACTION)", "LightingManager::InitiateAction(OFF_ACTION)"]), "Datamodel test failed: cannot find matching string from device {}".format(device_id)) diff --git a/src/transport/RendezvousSession.cpp b/src/transport/RendezvousSession.cpp index 7e1265ffea5dae..b696434f37ba73 100644 --- a/src/transport/RendezvousSession.cpp +++ b/src/transport/RendezvousSession.cpp @@ -181,7 +181,26 @@ void RendezvousSession::OnPairingComplete() return; } - UpdateState(State::kNetworkProvisioning); + // TODO: This check of BLE transport should be removed in the future, after we have network provisioning cluster and ble becomes + // a transport. + if (mParams.GetPeerAddress().GetTransportType() != Transport::Type::kBle || // For rendezvous initializer + mPeerAddress.GetTransportType() != Transport::Type::kBle) // For rendezvous target + { + if (mRendezvousRemoteNodeId.HasValue() && !mParams.HasRemoteNodeId()) + { + ChipLogProgress(Ble, "Completed rendezvous with %llu", mRendezvousRemoteNodeId.Value()); + mParams.SetRemoteNodeId(mRendezvousRemoteNodeId.Value()); + } + UpdateState(State::kRendezvousComplete); + if (!mParams.IsController()) + { + OnRendezvousConnectionClosed(); + } + } + else + { + UpdateState(State::kNetworkProvisioning); + } } void RendezvousSession::OnNetworkProvisioningError(CHIP_ERROR err) @@ -216,6 +235,7 @@ void RendezvousSession::OnRendezvousConnectionClosed() } mSecureSession.Reset(); + mRendezvousRemoteNodeId.ClearValue(); CHIP_ERROR err = WaitForPairing(mParams.GetLocalNodeId(), mParams.GetSetupPINCode()); if (err != CHIP_NO_ERROR) @@ -290,11 +310,17 @@ void RendezvousSession::OnRendezvousMessageReceived(const PacketHeader & packetH PacketBufferHandle msgBuf) { CHIP_ERROR err = CHIP_NO_ERROR; + mPeerAddress = peerAddress; // TODO: RendezvousSession should handle SecurePairing messages only switch (mCurrentState) { case State::kSecurePairing: + if (packetHeader.GetSourceNodeId().HasValue()) + { + ChipLogProgress(Ble, "Received rendezvous message from %llu", packetHeader.GetSourceNodeId().Value()); + mRendezvousRemoteNodeId.SetValue(packetHeader.GetSourceNodeId().Value()); + } err = HandlePairingMessage(packetHeader, peerAddress, std::move(msgBuf)); break; diff --git a/src/transport/RendezvousSession.h b/src/transport/RendezvousSession.h index 9fa4f7759f63e0..7a80affc68fc6b 100644 --- a/src/transport/RendezvousSession.h +++ b/src/transport/RendezvousSession.h @@ -152,6 +152,8 @@ class RendezvousSession : public SecurePairingSessionDelegate, SecurePairingSession mPairingSession; NetworkProvisioning mNetworkProvision; SecureSession mSecureSession; + Transport::PeerAddress mPeerAddress; // Current peer address we are doing rendezvous with. + Optional mRendezvousRemoteNodeId; TransportMgrBase * mTransportMgr; uint32_t mSecureMessageIndex = 0; uint16_t mNextKeyId = 0; diff --git a/src/transport/SecurePairingSession.cpp b/src/transport/SecurePairingSession.cpp index ed368aa0e648cf..dc370dd73467e5 100644 --- a/src/transport/SecurePairingSession.cpp +++ b/src/transport/SecurePairingSession.cpp @@ -405,6 +405,10 @@ CHIP_ERROR SecurePairingSession::HandleCompute_cA(const PacketHeader & header, c CHIP_ERROR err = CHIP_NO_ERROR; const uint8_t * hash = msg->Start(); + // We will set NextExpectedMsg to kSpake2pMsgTypeMax in all cases + // However, when we are using IP rendezvous, we might set it to kSpake2pCompute_pA. + mNextExpectedMsg = Spake2pMsgType::kSpake2pMsgTypeMax; + VerifyOrExit(hash != nullptr, err = CHIP_ERROR_MESSAGE_INCOMPLETE); VerifyOrExit(msg->TotalLength() == kMAX_Hash_Length, err = CHIP_ERROR_INVALID_MESSAGE_LENGTH); @@ -423,8 +427,6 @@ CHIP_ERROR SecurePairingSession::HandleCompute_cA(const PacketHeader & header, c mDelegate->OnPairingComplete(); exit: - - mNextExpectedMsg = Spake2pMsgType::kSpake2pMsgTypeMax; return err; }