From f7ef595c36c1335be8efc864bdf8728c3753021d Mon Sep 17 00:00:00 2001 From: "Lo,Chin-Ran" Date: Fri, 14 Jun 2024 15:52:00 +0800 Subject: [PATCH 01/33] [NXP] Add --wifi-paf commission in chip-tool and apps of Linux platform * Need to enable the function by adding "chip_device_config_enable_wifipaf=true" * chip-tool: Add wifi-paf option for pairing. Example: $ chip-tool pairing wifi-paf 1 ap_ssid ap_pwd [setup-pin-code] [discriminator] * apps: Add --wifi-paf. Example: $ chip-all-clusters-app --wifi --wifi-paf Note: Need the usd functions of wpa_supplicant to run this option Signed-off-by: Lo,Chin-Ran --- .../chip-tool/commands/pairing/Commands.h | 13 + .../commands/pairing/PairingCommand.cpp | 5 + .../commands/pairing/PairingCommand.h | 10 + examples/platform/linux/AppMain.cpp | 13 + examples/platform/linux/Options.cpp | 17 ++ examples/platform/linux/Options.h | 3 + src/app/server/Server.cpp | 8 + src/app/server/Server.h | 7 + src/controller/AutoCommissioner.cpp | 9 +- src/controller/CHIPDeviceController.cpp | 81 ++++++ src/controller/CHIPDeviceController.h | 5 + .../CHIPDeviceControllerFactory.cpp | 7 + src/controller/CHIPDeviceControllerFactory.h | 3 + .../CHIPDeviceControllerSystemState.h | 14 + src/controller/SetUpCodePairer.cpp | 24 ++ src/controller/SetUpCodePairer.h | 7 + src/include/platform/CHIPDeviceConfig.h | 10 + src/include/platform/CHIPDeviceEvent.h | 11 +- src/include/platform/ConnectivityManager.h | 47 ++++ .../GenericConnectivityManagerImpl_WiFi.h | 3 + src/lib/shell/commands/OnboardingCodes.cpp | 7 + src/platform/BUILD.gn | 1 + .../Linux/ConnectivityManagerImpl.cpp | 265 +++++++++++++++++- src/platform/Linux/ConnectivityManagerImpl.h | 34 +++ .../Linux/dbus/wpa/DBusWpaInterface.xml | 17 ++ src/platform/device.gni | 3 + src/setup_payload/SetupPayload.cpp | 2 +- src/setup_payload/SetupPayload.h | 1 + src/transport/raw/BUILD.gn | 7 + src/transport/raw/PeerAddress.h | 6 + src/transport/raw/WiFiPAF.cpp | 96 +++++++ src/transport/raw/WiFiPAF.h | 118 ++++++++ 32 files changed, 849 insertions(+), 5 deletions(-) create mode 100644 src/transport/raw/WiFiPAF.cpp create mode 100644 src/transport/raw/WiFiPAF.h diff --git a/examples/chip-tool/commands/pairing/Commands.h b/examples/chip-tool/commands/pairing/Commands.h index 41a35bb6bae6ad..d85b5a5b0802f3 100644 --- a/examples/chip-tool/commands/pairing/Commands.h +++ b/examples/chip-tool/commands/pairing/Commands.h @@ -181,6 +181,16 @@ class PairSoftAP : public PairingCommand {} }; +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +class PairWiFiPAF : public PairingCommand +{ +public: + PairWiFiPAF(CredentialIssuerCommands * credsIssuerConfig) : + PairingCommand("wifi-paf", PairingMode::WiFiPAF, PairingNetworkType::WiFi, credsIssuerConfig) + {} +}; +#endif + class PairAlreadyDiscovered : public PairingCommand { public: @@ -243,6 +253,9 @@ void registerCommandsPairing(Commands & commands, CredentialIssuerCommands * cre make_unique(credsIssuerConfig), make_unique(credsIssuerConfig), make_unique(credsIssuerConfig), +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + make_unique(credsIssuerConfig), +#endif make_unique(credsIssuerConfig), make_unique(credsIssuerConfig), make_unique(credsIssuerConfig), diff --git a/examples/chip-tool/commands/pairing/PairingCommand.cpp b/examples/chip-tool/commands/pairing/PairingCommand.cpp index 35ce2ba1cc7aaa..a346b55e2813a4 100644 --- a/examples/chip-tool/commands/pairing/PairingCommand.cpp +++ b/examples/chip-tool/commands/pairing/PairingCommand.cpp @@ -80,6 +80,11 @@ CHIP_ERROR PairingCommand::RunInternal(NodeId remoteId) case PairingMode::SoftAP: err = Pair(remoteId, PeerAddress::UDP(mRemoteAddr.address, mRemotePort, mRemoteAddr.interfaceId)); break; +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + case PairingMode::WiFiPAF: + err = Pair(remoteId, PeerAddress::WiFiPAF()); + break; +#endif case PairingMode::AlreadyDiscovered: err = Pair(remoteId, PeerAddress::UDP(mRemoteAddr.address, mRemotePort, mRemoteAddr.interfaceId)); break; diff --git a/examples/chip-tool/commands/pairing/PairingCommand.h b/examples/chip-tool/commands/pairing/PairingCommand.h index 0cf4e1de2de713..c222ad5f9cd5ff 100644 --- a/examples/chip-tool/commands/pairing/PairingCommand.h +++ b/examples/chip-tool/commands/pairing/PairingCommand.h @@ -35,6 +35,9 @@ enum class PairingMode CodePaseOnly, Ble, SoftAP, +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + WiFiPAF, +#endif AlreadyDiscovered, AlreadyDiscoveredByIndex, AlreadyDiscoveredByIndexWithCode, @@ -127,6 +130,13 @@ class PairingCommand : public CHIPCommand, AddArgument("device-remote-port", 0, UINT16_MAX, &mRemotePort); AddArgument("pase-only", 0, 1, &mPaseOnly); break; +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + case PairingMode::WiFiPAF: + AddArgument("skip-commissioning-complete", 0, 1, &mSkipCommissioningComplete); + AddArgument("setup-pin-code", 0, 134217727, &mSetupPINCode); + AddArgument("discriminator", 0, 4096, &mDiscriminator); + break; +#endif case PairingMode::AlreadyDiscovered: AddArgument("skip-commissioning-complete", 0, 1, &mSkipCommissioningComplete); AddArgument("setup-pin-code", 0, 134217727, &mSetupPINCode.emplace()); diff --git a/examples/platform/linux/AppMain.cpp b/examples/platform/linux/AppMain.cpp index 6a6deae1473084..15f0625aebeb99 100644 --- a/examples/platform/linux/AppMain.cpp +++ b/examples/platform/linux/AppMain.cpp @@ -366,6 +366,8 @@ int ChipLinuxAppInit(int argc, char * const argv[], OptionSet * customOptions, CHIP_ERROR err = CHIP_NO_ERROR; #if CONFIG_NETWORK_LAYER_BLE RendezvousInformationFlags rendezvousFlags = RendezvousInformationFlag::kBLE; +#elif CHIP_DEVICE_CONFIG_ENABLE_WPA && CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + RendezvousInformationFlags rendezvousFlags = RendezvousInformationFlag::kWiFiPAF; #else // CONFIG_NETWORK_LAYER_BLE RendezvousInformationFlag rendezvousFlags = RendezvousInformationFlag::kOnNetwork; #endif // CONFIG_NETWORK_LAYER_BLE @@ -471,6 +473,17 @@ int ChipLinuxAppInit(int argc, char * const argv[], OptionSet * customOptions, } } #endif // CHIP_DEVICE_CONFIG_ENABLE_WPA +#if CHIP_DEVICE_CONFIG_ENABLE_WPA && CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + ChipLogProgress(NotSpecified, "WiFi-PAF: initialzing"); + if (LinuxDeviceOptions::GetInstance().mWiFi) + { + if (EnsureWiFiIsStarted()) + { + ChipLogProgress(NotSpecified, "Wi-Fi Management started"); + DeviceLayer::ConnectivityMgr().SetWiFiPAFAdvertisingEnabled(LinuxDeviceOptions::GetInstance().mWiFiPAF); + } + } +#endif #if CHIP_ENABLE_OPENTHREAD if (LinuxDeviceOptions::GetInstance().mThread) diff --git a/examples/platform/linux/Options.cpp b/examples/platform/linux/Options.cpp index 9d6edc8bc43846..5e32bf7eb4bfde 100644 --- a/examples/platform/linux/Options.cpp +++ b/examples/platform/linux/Options.cpp @@ -106,6 +106,9 @@ enum #if CHIP_WITH_NLFAULTINJECTION kDeviceOption_FaultInjection, #endif +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + kDeviceOption_WiFi_PAF = 0x1028, +#endif }; constexpr unsigned kAppUsageLength = 64; @@ -117,6 +120,9 @@ OptionDef sDeviceOptionDefs[] = { #if CHIP_DEVICE_CONFIG_ENABLE_WIFI { "wifi", kNoArgument, kDeviceOption_WiFi }, { "wifi-supports-5g", kNoArgument, kDeviceOption_WiFiSupports5g }, +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + { "wifi-paf", kNoArgument, kDeviceOption_WiFi_PAF }, +#endif // CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF #endif // CHIP_DEVICE_CONFIG_ENABLE_WPA #if CHIP_ENABLE_OPENTHREAD { "thread", kNoArgument, kDeviceOption_Thread }, @@ -189,6 +195,11 @@ const char * sDeviceOptionHelp = " --wifi-supports-5g\n" " Indicate that local Wi-Fi hardware should report 5GHz support.\n" #endif // CHIP_DEVICE_CONFIG_ENABLE_WIFI +#if (CHIP_DEVICE_CONFIG_ENABLE_WIFI && CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF) + "\n" + " --wifi-paf\n" + " Enable Wi-Fi PAF via wpa_supplicant.\n" +#endif // CHIP_DEVICE_CONFIG_ENABLE_WIFI && CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF #if CHIP_ENABLE_OPENTHREAD "\n" " --thread\n" @@ -588,6 +599,12 @@ bool HandleOption(const char * aProgram, OptionSet * aOptions, int aIdentifier, } break; } +#endif +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + case kDeviceOption_WiFi_PAF: { + LinuxDeviceOptions::GetInstance().mWiFiPAF = true; + break; + } #endif default: PrintArgError("%s: INTERNAL ERROR: Unhandled option: %s\n", aProgram, aName); diff --git a/examples/platform/linux/Options.h b/examples/platform/linux/Options.h index 51e60f0ab63eca..163ae916353dda 100644 --- a/examples/platform/linux/Options.h +++ b/examples/platform/linux/Options.h @@ -49,6 +49,9 @@ struct LinuxDeviceOptions bool wifiSupports5g = false; bool mWiFi = false; bool mThread = false; +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + bool mWiFiPAF = false; +#endif #if CHIP_DEVICE_CONFIG_ENABLE_BOTH_COMMISSIONER_AND_COMMISSIONEE || CHIP_DEVICE_ENABLE_PORT_PARAMS uint16_t securedDevicePort = CHIP_PORT; uint16_t unsecuredCommissionerPort = CHIP_UDC_PORT; diff --git a/src/app/server/Server.cpp b/src/app/server/Server.cpp index 33f657f7ec1030..5ca70e34ce09f8 100644 --- a/src/app/server/Server.cpp +++ b/src/app/server/Server.cpp @@ -56,6 +56,10 @@ #include #include +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +#include +#endif + #if defined(CHIP_SUPPORT_ENABLE_STORAGE_API_AUDIT) || defined(CHIP_SUPPORT_ENABLE_STORAGE_LOAD_TEST_AUDIT) #include #endif // defined(CHIP_SUPPORT_ENABLE_STORAGE_API_AUDIT) || defined(CHIP_SUPPORT_ENABLE_STORAGE_LOAD_TEST_AUDIT) @@ -214,6 +218,10 @@ CHIP_ERROR Server::Init(const ServerInitParams & initParams) TcpListenParameters(DeviceLayer::TCPEndPointManager()) .SetAddressType(IPAddressType::kIPv6) .SetListenPort(mOperationalServicePort) +#endif +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + , + Transport::WiFiPAFListenParameters(DeviceLayer::ConnectivityMgr().GetWiFiPAF()) #endif ); diff --git a/src/app/server/Server.h b/src/app/server/Server.h index 9e0216877fea61..2f6126a4ace635 100644 --- a/src/app/server/Server.h +++ b/src/app/server/Server.h @@ -65,6 +65,9 @@ #if CONFIG_NETWORK_LAYER_BLE #include #endif +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +#include +#endif #include #include #include @@ -104,6 +107,10 @@ using ServerTransportMgr = chip::TransportMgr +#endif +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + , + chip::Transport::WiFiPAFBase #endif >; diff --git a/src/controller/AutoCommissioner.cpp b/src/controller/AutoCommissioner.cpp index 8232292479ff3f..bc7ad342bcb99e 100644 --- a/src/controller/AutoCommissioner.cpp +++ b/src/controller/AutoCommissioner.cpp @@ -591,8 +591,13 @@ CHIP_ERROR AutoCommissioner::StartCommissioning(DeviceCommissioner * commissione mCommissioner = commissioner; mCommissioneeDeviceProxy = proxy; mNeedsNetworkSetup = - mCommissioneeDeviceProxy->GetSecureSession().Value()->AsSecureSession()->GetPeerAddress().GetTransportType() == - Transport::Type::kBle; + (mCommissioneeDeviceProxy->GetSecureSession().Value()->AsSecureSession()->GetPeerAddress().GetTransportType() == + Transport::Type::kBle) +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + || (mCommissioneeDeviceProxy->GetSecureSession().Value()->AsSecureSession()->GetPeerAddress().GetTransportType() == + Transport::Type::kWiFiPAF) +#endif + ; CHIP_ERROR err = CHIP_NO_ERROR; CommissioningStage nextStage = GetNextCommissioningStage(CommissioningStage::kSecurePairing, err); mCommissioner->PerformCommissioningStep(mCommissioneeDeviceProxy, nextStage, mParams, this, GetEndpoint(nextStage), diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp index 5212350c913696..1add5e05858f1f 100644 --- a/src/controller/CHIPDeviceController.cpp +++ b/src/controller/CHIPDeviceController.cpp @@ -66,6 +66,10 @@ #include #include #endif +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +#include +#endif + #include #include @@ -730,6 +734,12 @@ CHIP_ERROR DeviceCommissioner::EstablishPASEConnection(NodeId remoteDeviceId, Re peerAddress = Transport::PeerAddress::UDP(params.GetPeerAddress().GetIPAddress(), params.GetPeerAddress().GetPort(), params.GetPeerAddress().GetInterface()); } +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + else if (params.GetPeerAddress().GetTransportType() == Transport::Type::kWiFiPAF) + { + peerAddress = Transport::PeerAddress::WiFiPAF(); + } +#endif // CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF current = FindCommissioneeDevice(peerAddress); if (current != nullptr) @@ -804,6 +814,39 @@ CHIP_ERROR DeviceCommissioner::EstablishPASEConnection(NodeId remoteDeviceId, Re ExitNow(err = CHIP_ERROR_INVALID_ARGUMENT); } } +#endif +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + if (params.GetPeerAddress().GetTransportType() == Transport::Type::kWiFiPAF) + { + if (DeviceLayer::ConnectivityMgr().GetWiFiPAF()->GetWiFiPAFState() != Transport::WiFiPAFBase::State::kConnected) { + ChipLogProgress(Controller, "WiFi-PAF: Subscribing the NAN-USD devices"); + static constexpr useconds_t kWiFiStartCheckTimeUsec = WIFI_START_CHECK_TIME_USEC; + static constexpr uint8_t kWiFiStartCheckAttempts = WIFI_START_CHECK_ATTEMPTS; + + DeviceLayer::ConnectivityMgrImpl().StartWiFiManagement(); + { + for (int cnt = 0; cnt < kWiFiStartCheckAttempts; cnt++) + { + if (DeviceLayer::ConnectivityMgrImpl().IsWiFiManagementStarted()) + { + break; + } + usleep(kWiFiStartCheckTimeUsec); + } + } + if (!DeviceLayer::ConnectivityMgrImpl().IsWiFiManagementStarted()) { + ChipLogError(NotSpecified, "Wi-Fi Management taking too long to start - device configuration will be reset."); + } + mRendezvousParametersForDeviceDiscoveredOverWiFiPAF = params; + DeviceLayer::ConnectivityMgr().WiFiPAFConnect( + this, + OnWiFiPAFSubscribeComplete, + OnWiFiPAFSubscribeError + ); + ExitNow(CHIP_NO_ERROR); + } + ChipLogProgress(Controller, "WiFi-PAF: Request to subscrib the NAN-USD device complete"); + } #endif session = mSystemState->SessionMgr()->CreateUnauthenticatedSession(params.GetPeerAddress(), params.GetMRPConfig()); VerifyOrExit(session.HasValue(), err = CHIP_ERROR_NO_MEMORY); @@ -872,6 +915,44 @@ void DeviceCommissioner::OnDiscoveredDeviceOverBleError(void * appState, CHIP_ER } #endif // CONFIG_NETWORK_LAYER_BLE +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +void DeviceCommissioner::OnWiFiPAFSubscribeComplete(void * appState) +{ + auto self = static_cast(appState); + auto device = self->mDeviceInPASEEstablishment; + + ChipLogProgress(Controller, "WiFi-PAF: Subscription Completed!"); + if (nullptr != device && device->GetDeviceTransportType() == Transport::Type::kWiFiPAF) + { + auto remoteId = device->GetDeviceId(); + auto params = self->mRendezvousParametersForDeviceDiscoveredOverWiFiPAF; + + self->mRendezvousParametersForDeviceDiscoveredOverWiFiPAF = RendezvousParameters(); + self->ReleaseCommissioneeDevice(device); + DeviceLayer::ConnectivityMgr().GetWiFiPAF()->SetWiFiPAFState(Transport::WiFiPAFBase::State::kConnected); + chip::DeviceLayer::StackLock stackLock; + LogErrorOnFailure(self->EstablishPASEConnection(remoteId, params)); + } +} + +void DeviceCommissioner::OnWiFiPAFSubscribeError(void * appState, CHIP_ERROR err) +{ + auto self = static_cast(appState); + auto device = self->mDeviceInPASEEstablishment; + + ChipLogProgress(Controller, "WiFi-PAF: Subscription Error!"); + if (nullptr != device && device->GetDeviceTransportType() == Transport::Type::kWiFiPAF) + { + self->ReleaseCommissioneeDevice(device); + self->mRendezvousParametersForDeviceDiscoveredOverWiFiPAF = RendezvousParameters(); + if (self->mPairingDelegate != nullptr) + { + self->mPairingDelegate->OnPairingComplete(err); + } + } +} +#endif + CHIP_ERROR DeviceCommissioner::Commission(NodeId remoteDeviceId, CommissioningParameters & params) { if (mDefaultCommissioner == nullptr) diff --git a/src/controller/CHIPDeviceController.h b/src/controller/CHIPDeviceController.h index 1c4b490faa891a..98932cb4a62e5d 100644 --- a/src/controller/CHIPDeviceController.h +++ b/src/controller/CHIPDeviceController.h @@ -847,6 +847,11 @@ class DLL_EXPORT DeviceCommissioner : public DeviceController, static void OnDiscoveredDeviceOverBleError(void * appState, CHIP_ERROR err); RendezvousParameters mRendezvousParametersForDeviceDiscoveredOverBle; #endif +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + static void OnWiFiPAFSubscribeComplete(void * appState); + static void OnWiFiPAFSubscribeError(void * appState, CHIP_ERROR err); + RendezvousParameters mRendezvousParametersForDeviceDiscoveredOverWiFiPAF; +#endif static void OnBasicFailure(void * context, CHIP_ERROR err); static void OnBasicSuccess(void * context, const chip::app::DataModel::NullObjectType &); diff --git a/src/controller/CHIPDeviceControllerFactory.cpp b/src/controller/CHIPDeviceControllerFactory.cpp index 24f60ed9d8a50a..dbc55dd7b7327e 100644 --- a/src/controller/CHIPDeviceControllerFactory.cpp +++ b/src/controller/CHIPDeviceControllerFactory.cpp @@ -141,6 +141,9 @@ CHIP_ERROR DeviceControllerFactory::InitSystemState(FactoryInitParams params) #else stateParams.bleLayer = params.bleLayer; #endif // CONFIG_DEVICE_LAYER +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + stateParams.wifipaf_layer = params.wifipaf_layer; +#endif VerifyOrReturnError(stateParams.bleLayer != nullptr, CHIP_ERROR_INVALID_ARGUMENT); #endif @@ -167,6 +170,10 @@ CHIP_ERROR DeviceControllerFactory::InitSystemState(FactoryInitParams params) Transport::TcpListenParameters(stateParams.tcpEndPointManager) .SetAddressType(IPAddressType::kIPv6) .SetListenPort(params.listenPort) +#endif +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + , + Transport::WiFiPAFListenParameters() #endif )); diff --git a/src/controller/CHIPDeviceControllerFactory.h b/src/controller/CHIPDeviceControllerFactory.h index 474357ec4a4bde..16e2ad487126b9 100644 --- a/src/controller/CHIPDeviceControllerFactory.h +++ b/src/controller/CHIPDeviceControllerFactory.h @@ -145,6 +145,9 @@ struct FactoryInitParams #if CONFIG_NETWORK_LAYER_BLE Ble::BleLayer * bleLayer = nullptr; #endif +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + Transport::WiFiPAFLayer * wifipaf_layer = nullptr; +#endif // // Controls enabling server cluster interactions on a controller. This in turn diff --git a/src/controller/CHIPDeviceControllerSystemState.h b/src/controller/CHIPDeviceControllerSystemState.h index da8f25a75d2541..bec0eb403d366b 100644 --- a/src/controller/CHIPDeviceControllerSystemState.h +++ b/src/controller/CHIPDeviceControllerSystemState.h @@ -52,10 +52,17 @@ #include #include #endif +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +#include +#endif namespace chip { inline constexpr size_t kMaxDeviceTransportBlePendingPackets = 1; +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +inline constexpr size_t kMaxDeviceTransportWiFiPAFPendingPackets = 1; +#endif + #if INET_CONFIG_ENABLE_TCP_ENDPOINT inline constexpr size_t kMaxDeviceTransportTcpActiveConnectionCount = CHIP_CONFIG_MAX_ACTIVE_TCP_CONNECTIONS; @@ -76,6 +83,10 @@ using DeviceTransportMgr = #if INET_CONFIG_ENABLE_TCP_ENDPOINT , Transport::TCP +#endif +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + , + Transport::WiFiPAF /* WiFiPAF */ #endif >; @@ -93,6 +104,9 @@ struct DeviceControllerSystemStateParams FabricTable * fabricTable = nullptr; #if CONFIG_NETWORK_LAYER_BLE Ble::BleLayer * bleLayer = nullptr; +#endif +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + Transport::WiFiPAFLayer *wifipaf_layer = nullptr; #endif Credentials::GroupDataProvider * groupDataProvider = nullptr; Crypto::SessionKeystore * sessionKeystore = nullptr; diff --git a/src/controller/SetUpCodePairer.cpp b/src/controller/SetUpCodePairer.cpp index 17f2e5945eb1bf..08c6041d5e7ca8 100644 --- a/src/controller/SetUpCodePairer.cpp +++ b/src/controller/SetUpCodePairer.cpp @@ -129,6 +129,17 @@ CHIP_ERROR SetUpCodePairer::Connect(SetupPayload & payload) } VerifyOrReturnError(searchOverAll || CHIP_NO_ERROR == err || CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE == err, err); } +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + if (searchOverAll || payload.rendezvousInformation.Value().Has(RendezvousInformationFlag::kWiFiPAF)) + { + ChipLogProgress(Controller, "WiFi-PAF: has RendezvousInformationFlag::kWiFiPAF"); + if (CHIP_NO_ERROR == (err = StartDiscoverOverWiFiPAF(payload))) + { + isRunning = true; + } + VerifyOrReturnError(searchOverAll || CHIP_NO_ERROR == err || CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE == err, err); + } +#endif } // We always want to search on network because any node that has already been commissioned will use on-network regardless of the @@ -243,6 +254,19 @@ CHIP_ERROR SetUpCodePairer::StopConnectOverSoftAP() return CHIP_NO_ERROR; } +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +CHIP_ERROR SetUpCodePairer::StartDiscoverOverWiFiPAF(SetupPayload & payload) +{ + return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; +} + +CHIP_ERROR SetUpCodePairer::StopConnectOverWiFiPAF() +{ + mWaitingForDiscovery[kWiFiPAF] = false; + return CHIP_NO_ERROR; +} +#endif + bool SetUpCodePairer::ConnectToDiscoveredDevice() { if (mWaitingForPASE) diff --git a/src/controller/SetUpCodePairer.h b/src/controller/SetUpCodePairer.h index e177af7322d391..848fbfbb1400bc 100644 --- a/src/controller/SetUpCodePairer.h +++ b/src/controller/SetUpCodePairer.h @@ -111,6 +111,10 @@ class DLL_EXPORT SetUpCodePairer : public DevicePairingDelegate CHIP_ERROR StopConnectOverIP(); CHIP_ERROR StartDiscoverOverSoftAP(SetupPayload & payload); CHIP_ERROR StopConnectOverSoftAP(); +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + CHIP_ERROR StartDiscoverOverWiFiPAF(SetupPayload & payload); + CHIP_ERROR StopConnectOverWiFiPAF(); +#endif // Returns whether we have kicked off a new connection attempt. bool ConnectToDiscoveredDevice(); @@ -150,6 +154,9 @@ class DLL_EXPORT SetUpCodePairer : public DevicePairingDelegate kBLETransport = 0, kIPTransport, kSoftAPTransport, +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + kWiFiPAF, +#endif kTransportTypeCount, }; diff --git a/src/include/platform/CHIPDeviceConfig.h b/src/include/platform/CHIPDeviceConfig.h index 49a94d75c23fcc..65e3d6ee83ad22 100644 --- a/src/include/platform/CHIPDeviceConfig.h +++ b/src/include/platform/CHIPDeviceConfig.h @@ -425,6 +425,16 @@ #define CHIP_DEVICE_CONFIG_WIFI_STATION_IF_NAME "wlan0" #endif +/** + * CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + * + * Name of the WiFi PAF/DNAN-USD + */ +#ifndef CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +#define CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF 0 +#endif + + // -------------------- WiFi AP Configuration -------------------- /** diff --git a/src/include/platform/CHIPDeviceEvent.h b/src/include/platform/CHIPDeviceEvent.h index 437b20e670284f..611285fba4d4f3 100644 --- a/src/include/platform/CHIPDeviceEvent.h +++ b/src/include/platform/CHIPDeviceEvent.h @@ -281,7 +281,10 @@ enum InternalEventTypes * This event should populate CHIPoBLEConnectionError structure. */ kCHIPoBLEConnectionError, - kCHIPoBLENotifyConfirm + kCHIPoBLENotifyConfirm, +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + kCHIPoWiFiPAFWriteReceived, +#endif }; static_assert(kEventTypeNotSet == 0, "kEventTypeNotSet must be defined as 0"); @@ -491,6 +494,12 @@ struct ChipDeviceEvent final { BLE_CONNECTION_OBJECT ConId; } CHIPoBLENotifyConfirm; +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + struct + { + chip::System::PacketBuffer * Data; + } CHIPoWiFiPAFWriteReceived; +#endif struct { bool RoleChanged : 1; diff --git a/src/include/platform/ConnectivityManager.h b/src/include/platform/ConnectivityManager.h index 817019b3c1c63c..bb7be41a5b871c 100644 --- a/src/include/platform/ConnectivityManager.h +++ b/src/include/platform/ConnectivityManager.h @@ -35,6 +35,9 @@ #if INET_CONFIG_ENABLE_TCP_ENDPOINT #include #endif +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +#include +#endif namespace chip { @@ -171,6 +174,18 @@ class ConnectivityManager bool IsWiFiStationProvisioned(); void ClearWiFiStationProvision(); CHIP_ERROR GetAndLogWiFiStatsCounters(); +#if CHIP_DEVICE_CONFIG_ENABLE_WPA && CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + CHIP_ERROR SetWiFiPAFAdvertisingEnabled(bool val); + + typedef void (*OnConnectionCompleteFunct)(void * appState); + typedef void (*OnConnectionErrorFunct)(void * appState, CHIP_ERROR err); + CHIP_ERROR WiFiPAFConnect(void * appState, + OnConnectionCompleteFunct onSuccess, + OnConnectionErrorFunct onError); + CHIP_ERROR WiFiPAFSend(chip::System::PacketBufferHandle && msgBuf); + Transport::WiFiPAFBase * GetWiFiPAF(); + void SetWiFiPAF(Transport::WiFiPAFBase * pmWiFiPAF); +#endif // WiFi AP methods WiFiAPMode GetWiFiAPMode(); @@ -407,6 +422,26 @@ inline CHIP_ERROR ConnectivityManager::GetAndLogWiFiStatsCounters() return static_cast(this)->_GetAndLogWiFiStatsCounters(); } +#if CHIP_DEVICE_CONFIG_ENABLE_WPA && CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +inline CHIP_ERROR ConnectivityManager::SetWiFiPAFAdvertisingEnabled(bool val) +{ + return static_cast(this)->_SetWiFiPAFAdvertisingEnabled(val); +} + +inline CHIP_ERROR ConnectivityManager::WiFiPAFConnect( + void * appState, + OnConnectionCompleteFunct onSuccess, + OnConnectionErrorFunct onError) +{ + return static_cast(this)->_WiFiPAFConnect(appState, onSuccess, onError); +} + +inline CHIP_ERROR ConnectivityManager::WiFiPAFSend(chip::System::PacketBufferHandle && msgBuf) +{ + return static_cast(this)->_WiFiPAFSend(std::move(msgBuf)); +} +#endif + inline bool ConnectivityManager::IsThreadEnabled() { return static_cast(this)->_IsThreadEnabled(); @@ -451,6 +486,18 @@ inline void ConnectivityManager::ResetThreadNetworkDiagnosticsCounts() static_cast(this)->_ResetThreadNetworkDiagnosticsCounts(); } +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +inline Transport::WiFiPAFBase * ConnectivityManager::GetWiFiPAF() +{ + return static_cast(this)->_GetWiFiPAF(); +} + +inline void ConnectivityManager::SetWiFiPAF(Transport::WiFiPAFBase * pWiFiPAF) +{ + return static_cast(this)->_SetWiFiPAF(pWiFiPAF); +} +#endif + inline Ble::BleLayer * ConnectivityManager::GetBleLayer() { return static_cast(this)->_GetBleLayer(); diff --git a/src/include/platform/internal/GenericConnectivityManagerImpl_WiFi.h b/src/include/platform/internal/GenericConnectivityManagerImpl_WiFi.h index 24cc0032389280..4db7ea9bdb889d 100644 --- a/src/include/platform/internal/GenericConnectivityManagerImpl_WiFi.h +++ b/src/include/platform/internal/GenericConnectivityManagerImpl_WiFi.h @@ -77,6 +77,9 @@ class GenericConnectivityManagerImpl_WiFi bool _CanStartWiFiScan(); void _OnWiFiScanDone(); void _OnWiFiStationProvisionChange(); +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + CHIP_ERROR _SetWiFiPAFAdvertisingEnabled(bool val); +#endif // TODO ICD rework: ambiguous declaration of _SetPollingInterval when thread and wifi are both build together #if CHIP_CONFIG_ENABLE_ICD_SERVER && !CHIP_DEVICE_CONFIG_ENABLE_THREAD CHIP_ERROR _SetPollingInterval(System::Clock::Milliseconds32 pollingInterval); diff --git a/src/lib/shell/commands/OnboardingCodes.cpp b/src/lib/shell/commands/OnboardingCodes.cpp index 1e17812d183a3f..a08a63be68770f 100644 --- a/src/lib/shell/commands/OnboardingCodes.cpp +++ b/src/lib/shell/commands/OnboardingCodes.cpp @@ -128,6 +128,13 @@ static CHIP_ERROR RendezvousStringToFlag(char * str, chip::RendezvousInformation *aRendezvousFlags = chip::RendezvousInformationFlag::kOnNetwork; return CHIP_NO_ERROR; } +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + if (strcmp(str, "wifipaf") == 0) + { + *aRendezvousFlags = chip::RendezvousInformationFlag::kWiFiPAF; + return CHIP_NO_ERROR; + } +#endif return CHIP_ERROR_INVALID_ARGUMENT; } diff --git a/src/platform/BUILD.gn b/src/platform/BUILD.gn index 474e3c17ce284b..38becc7ede7471 100644 --- a/src/platform/BUILD.gn +++ b/src/platform/BUILD.gn @@ -140,6 +140,7 @@ if (chip_device_platform != "none" && chip_device_platform != "external") { "CHIP_USE_TRANSITIONAL_COMMISSIONABLE_DATA_PROVIDER=${chip_use_transitional_commissionable_data_provider}", "CHIP_USE_TRANSITIONAL_DEVICE_INSTANCE_INFO_PROVIDER=${chip_use_transitional_device_instance_info_provider}", "CHIP_DEVICE_CONFIG_ENABLE_DYNAMIC_MRP_CONFIG=${chip_device_config_enable_dynamic_mrp_config}", + "CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF=${chip_device_config_enable_wifipaf}", ] if (chip_device_platform == "linux" || chip_device_platform == "darwin" || diff --git a/src/platform/Linux/ConnectivityManagerImpl.cpp b/src/platform/Linux/ConnectivityManagerImpl.cpp index cd3922baaf2b02..312557fdba07ba 100644 --- a/src/platform/Linux/ConnectivityManagerImpl.cpp +++ b/src/platform/Linux/ConnectivityManagerImpl.cpp @@ -19,6 +19,7 @@ #include #include +#include #include #include #include @@ -64,6 +65,9 @@ #include #include #include +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +#include +#endif #endif using namespace ::chip; @@ -152,6 +156,15 @@ void ConnectivityManagerImpl::_OnPlatformEvent(const ChipDeviceEvent * event) #if CHIP_DEVICE_CONFIG_ENABLE_THREAD GenericConnectivityManagerImpl_Thread::_OnPlatformEvent(event); #endif +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + switch (event->Type) + { + case DeviceEventType::kCHIPoWiFiPAFWriteReceived: + ChipLogProgress(DeviceLayer, "WiFi-PAF: kCHIPoWiFiPAFWriteReceived"); + _GetWiFiPAF()->OnWiFiPAFMessageReceived(System::PacketBufferHandle::Adopt(event->CHIPoWiFiPAFWriteReceived.Data)); + break; + } +#endif //CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF } #if CHIP_DEVICE_CONFIG_ENABLE_WPA @@ -797,6 +810,83 @@ bool ConnectivityManagerImpl::IsWiFiManagementStarted() return ret; } +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +const char srv_name[]="_matterc._udp"; +/* + NAN-USD Service Protocol Type: ref: Table 58 of Wi-Fi Aware Specificaiton +*/ +#define MAX_PAF_PUBLISH_SSI_BUFLEN 128 +#define MAX_PAF_TX_SSI_BUFLEN 2048 +#define NAN_SRV_PROTO_MATTER 3 +#define NAM_PUBLISH_PERIOD 300u +#define NAN_PUBLISH_SSI_TAG "ssi=" + +#pragma pack(push, 1) +struct PAFPublishSSI +{ + uint8_t DevOpCode; + uint16_t DevInfo; + uint16_t ProductId; + uint16_t VendorId; +}; +#pragma pack(pop) + +CHIP_ERROR ConnectivityManagerImpl::_SetWiFiPAFAdvertisingEnabled(bool val) +{ + CHIP_ERROR ret; + GAutoPtr err; + gchar args[MAX_PAF_PUBLISH_SSI_BUFLEN]; + gint publish_id; + + snprintf(args, sizeof(args), "service_name=%s srv_proto_type=%u ttl=%u ", + srv_name, NAN_SRV_PROTO_MATTER, NAM_PUBLISH_PERIOD); + + struct PAFPublishSSI PafPublish_ssi; + VerifyOrReturnError((strlen(args) + strlen(NAN_PUBLISH_SSI_TAG) + (sizeof(struct PAFPublishSSI)*2) < MAX_PAF_PUBLISH_SSI_BUFLEN), + CHIP_ERROR_BUFFER_TOO_SMALL); + PafPublish_ssi.DevOpCode = 0; + VerifyOrDie(DeviceLayer::GetCommissionableDataProvider()->GetSetupDiscriminator(PafPublish_ssi.DevInfo) == CHIP_NO_ERROR); + if (DeviceLayer::GetDeviceInstanceInfoProvider()->GetProductId(PafPublish_ssi.ProductId) != CHIP_NO_ERROR) + { + PafPublish_ssi.ProductId = 0; + } + if (DeviceLayer::GetDeviceInstanceInfoProvider()->GetVendorId(PafPublish_ssi.VendorId) != CHIP_NO_ERROR) + { + PafPublish_ssi.VendorId = 0; + } + strcat(args, NAN_PUBLISH_SSI_TAG); + ret = chip::Encoding::BytesToUppercaseHexString((uint8_t*)&PafPublish_ssi, sizeof(PafPublish_ssi), &args[strlen(args)], + MAX_PAF_PUBLISH_SSI_BUFLEN-strlen(args)); + VerifyOrReturnError(ret == CHIP_NO_ERROR, ret); + ChipLogProgress(DeviceLayer, "WiFi-PAF: SetWiFiPAFAdvertisingEnabled(%d)", val); + wpa_fi_w1_wpa_supplicant1_interface_call_nanpublish_sync(mWpaSupplicant.iface, + args, + &publish_id, + nullptr, + &err.GetReceiver()); + ChipLogProgress(DeviceLayer, "WiFi-PAF: publish_id: %d ! ", publish_id); + + g_signal_connect( + mWpaSupplicant.iface, "nan-receive", + G_CALLBACK(+[](WpaFiW1Wpa_supplicant1Interface * proxy, GVariant * obj, ConnectivityManagerImpl * self) { + return self->OnNanReceive(obj); + }), + this); + return CHIP_NO_ERROR; +} + +Transport::WiFiPAFBase * ConnectivityManagerImpl::_GetWiFiPAF() +{ + return pmWiFiPAF; +} + +void ConnectivityManagerImpl::_SetWiFiPAF(Transport::WiFiPAFBase * pWiFiPAF) +{ + pmWiFiPAF = pWiFiPAF; + return; +} +#endif + void ConnectivityManagerImpl::StartNonConcurrentWiFiManagement() { StartWiFiManagement(); @@ -1226,6 +1316,179 @@ CHIP_ERROR ConnectivityManagerImpl::ConnectWiFiNetworkWithPDCAsync( return _ConnectWiFiNetworkAsync(args, connectCallback); } #endif // CHIP_DEVICE_CONFIG_ENABLE_WIFI_PDC +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +/* + NAN-USD Service Protocol Type: ref: Table 58 of Wi-Fi Aware Specificaiton +*/ +#define MAX_PAF_SUBSCRIBE_SSI_BUFLEN 128 +#define NAN_SRV_PROTO_MATTER 3 +#define NAM_SUBSCRIBE_PERIOD 30u +void ConnectivityManagerImpl::OnDiscoveryResult(gboolean success, GVariant * discov_info) +{ + ChipLogProgress(Controller, "WiFi-PAF: OnDiscoveryResult, %d", success); + + std::lock_guard lock(mWpaSupplicantMutex); + if (g_variant_n_children(discov_info) == 0) + { + return; + } + + GAutoPtr dataValue(g_variant_lookup_value(discov_info, "discov_info", G_VARIANT_TYPE_BYTESTRING)); + size_t bufferLen; + auto buffer = g_variant_get_fixed_array(dataValue.get(), &bufferLen, sizeof(uint8_t)); + + if (((struct wpa_dbus_discov_info*)buffer)->subscribe_id == mpaf_info.subscribe_id) + { + return; + } + memcpy(&mpaf_info, buffer, sizeof(struct wpa_dbus_discov_info)); + ChipLogProgress(DeviceLayer, "WiFi-PAF: subscribe_id: %u", mpaf_info.subscribe_id); + ChipLogProgress(DeviceLayer, "WiFi-PAF: peer_publish_id: %u", mpaf_info.peer_publish_id); + ChipLogProgress(DeviceLayer, "WiFi-PAF: peer_addr: [%02x:%02x:%02x:%02x:%02x:%02x]", + mpaf_info.peer_addr[0], mpaf_info.peer_addr[1], mpaf_info.peer_addr[2], + mpaf_info.peer_addr[3], mpaf_info.peer_addr[4], mpaf_info.peer_addr[5]); + if (mOnPafSubscribeComplete != nullptr) + { + mOnPafSubscribeComplete(mAppState); + } + + return; +} + +void ConnectivityManagerImpl::OnNanReceive(GVariant * obj) +{ + ChipLogProgress(Controller, "WiFi-PAF: OnNanReceive"); + + if (g_variant_n_children(obj) == 0) + { + return; + } + { + GAutoPtr dataValue(g_variant_lookup_value(obj, "nanrx_info", G_VARIANT_TYPE_BYTESTRING)); + size_t bufferLen; + auto buffer = g_variant_get_fixed_array(dataValue.get(), &bufferLen, sizeof(uint8_t)); + + memcpy(&mpaf_nanrx_info, buffer, sizeof(struct wpa_dbus_nanrx_info)); + mpaf_info.subscribe_id = mpaf_nanrx_info.id; + mpaf_info.peer_publish_id = mpaf_nanrx_info.peer_id; + memcpy(mpaf_info.peer_addr, mpaf_nanrx_info.peer_addr, 6); + } + if (mpaf_nanrx_info.ssi_len > 0) { + GAutoPtr dataValue(g_variant_lookup_value(obj, "ssi", G_VARIANT_TYPE_BYTESTRING)); + size_t bufferLen; + System::PacketBufferHandle buf; + auto rxbuf = g_variant_get_fixed_array(dataValue.get(), &bufferLen, sizeof(uint8_t)); + ChipLogProgress(DeviceLayer, "WiFi-PAF: wpa_supplicant:nan-rx: [buflen: %lu], preparing rxbuf", bufferLen); + buf = System::PacketBufferHandle::NewWithData(rxbuf, bufferLen); + + // Post an event to the Chip queue to deliver the data into the Chip stack. + { + ChipDeviceEvent event; + event.Type = DeviceEventType::kCHIPoWiFiPAFWriteReceived; + event.CHIPoWiFiPAFWriteReceived.Data = std::move(buf).UnsafeRelease(); + PlatformMgr().PostEventOrDie(&event); + } + } else { + ChipLogProgress(DeviceLayer, "WiFi-PAF: Skip, ssi length = %u", mpaf_nanrx_info.ssi_len); + } + + return; +} + + +CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFConnect(void *appState, + OnConnectionCompleteFunct onSuccess, + OnConnectionErrorFunct onError) +{ + ChipLogProgress(Controller, "WiFi-PAF: Try to subscribe the NAN-USD devices"); + gchar args[MAX_PAF_SUBSCRIBE_SSI_BUFLEN]; + snprintf(args, sizeof(args), "service_name=%s srv_proto_type=%u ttl=%u ", + srv_name, NAN_SRV_PROTO_MATTER, NAM_SUBSCRIBE_PERIOD); + mAppState = appState; + GAutoPtr err; + + wpa_fi_w1_wpa_supplicant1_interface_call_nansubscribe(mWpaSupplicant.iface, + args, + nullptr, + reinterpret_cast( + +[](GObject * sourceObject_, GAsyncResult * res_, ConnectivityManagerImpl * self) { + return ; + }), + &err.GetReceiver()); + mOnPafSubscribeComplete = onSuccess; + g_signal_connect( + mWpaSupplicant.iface, "discovery-result", + G_CALLBACK(+[](WpaFiW1Wpa_supplicant1Interface * proxy, gboolean success, GVariant * obj, ConnectivityManagerImpl * self) { + return self->OnDiscoveryResult(success, obj); + }), + this); + + + return CHIP_NO_ERROR; +} + +CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFSend(System::PacketBufferHandle && msgBuf) +{ + ChipLogProgress(Controller, "WiFi-PAF: sending PAF Follow-up packets, (%lu)", msgBuf->DataLength()); + CHIP_ERROR ret = CHIP_NO_ERROR; + + if (msgBuf.IsNull()) { + ChipLogError(Controller, "WiFi-PAF: Invalid Packet (%lu)", msgBuf->DataLength()); + return CHIP_ERROR_INVALID_ARGUMENT; + } + + // Ensure outgoing message fits in a single contiguous packet buffer, as currently required by the + // message fragmentation and reassembly engine. + if (msgBuf->HasChainedBuffer()) + { + msgBuf->CompactHead(); + + if (msgBuf->HasChainedBuffer()) + { + ret = CHIP_ERROR_OUTBOUND_MESSAGE_TOO_BIG; + ChipLogError(Controller, "WiFi-PAF: Outbound message too big (%lu), skip temporally", msgBuf->DataLength()); + return ret; + } + } + + // ================================================================================================================ + // Send the packets + GAutoPtr err; + gchar args[MAX_PAF_TX_SSI_BUFLEN]; + + snprintf(args, sizeof(args), "handle=%u req_instance_id=%u address=%02x:%02x:%02x:%02x:%02x:%02x ssi=", + mpaf_info.subscribe_id, mpaf_info.peer_publish_id, + mpaf_info.peer_addr[0], mpaf_info.peer_addr[1], mpaf_info.peer_addr[2], + mpaf_info.peer_addr[3], mpaf_info.peer_addr[4], mpaf_info.peer_addr[5]); + + ChipLogProgress(Controller, "===> %s(), (%lu, %u)", __FUNCTION__, + (strlen(args) + msgBuf->DataLength()), + MAX_PAF_TX_SSI_BUFLEN) + VerifyOrReturnError((strlen(args) + msgBuf->DataLength() < MAX_PAF_TX_SSI_BUFLEN), + CHIP_ERROR_BUFFER_TOO_SMALL); + + ret = chip::Encoding::BytesToUppercaseHexString(msgBuf->Start(), msgBuf->DataLength(), &args[strlen(args)], + MAX_PAF_TX_SSI_BUFLEN-strlen(args)); + VerifyOrReturnError(ret == CHIP_NO_ERROR, ret); + ChipLogProgress(DeviceLayer, "WiFi-PAF: ssi: [%s]", args); + + wpa_fi_w1_wpa_supplicant1_interface_call_nantransmit_sync(mWpaSupplicant.iface, + args, + nullptr, + &err.GetReceiver()); + + g_signal_connect( + mWpaSupplicant.iface, "nan-receive", + G_CALLBACK(+[](WpaFiW1Wpa_supplicant1Interface * proxy, GVariant * obj, ConnectivityManagerImpl * self) { + return self->OnNanReceive(obj); + }), + this); + + ChipLogProgress(Controller, "WiFi-PAF: Outbound message (%lu) done", msgBuf->DataLength()); + return ret; +} + +#endif //CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF void ConnectivityManagerImpl::_ConnectWiFiNetworkAsyncCallback(GObject * sourceObject, GAsyncResult * res) { @@ -1471,7 +1734,7 @@ CHIP_ERROR ConnectivityManagerImpl::GetConfiguredNetwork(NetworkCommissioning::N const gchar * networkPath = wpa_fi_w1_wpa_supplicant1_interface_get_current_network(mWpaSupplicant.iface); // wpa_supplicant DBus API: if network path of current network is "/", means no networks is currently selected. - if (strcmp(networkPath, "/") == 0) + if ((networkPath==nullptr) || (strcmp(networkPath, "/") == 0)) { return CHIP_ERROR_KEY_NOT_FOUND; } diff --git a/src/platform/Linux/ConnectivityManagerImpl.h b/src/platform/Linux/ConnectivityManagerImpl.h index ee5978faf6ff70..54f29170d20d21 100644 --- a/src/platform/Linux/ConnectivityManagerImpl.h +++ b/src/platform/Linux/ConnectivityManagerImpl.h @@ -48,6 +48,9 @@ #include #include +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +#include +#endif #endif #include @@ -137,6 +140,17 @@ class ConnectivityManagerImpl final : public ConnectivityManager, const Crypto::P256Keypair & clientIdentityKeypair, NetworkCommissioning::Internal::WirelessDriver::ConnectCallback * connectCallback); #endif // CHIP_DEVICE_CONFIG_ENABLE_WIFI_PDC +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + CHIP_ERROR _WiFiPAFConnect(void * appState, + OnConnectionCompleteFunct onSuccess, + OnConnectionErrorFunct onError); + void OnDiscoveryResult(gboolean success, GVariant * obj); + void OnNanReceive(GVariant * obj); + + CHIP_ERROR _WiFiPAFSend(chip::System::PacketBufferHandle && msgBuf); + Transport::WiFiPAFBase * _GetWiFiPAF(); + void _SetWiFiPAF(Transport::WiFiPAFBase * pWiFiPAF); +#endif void PostNetworkConnect(); CHIP_ERROR CommitConfig(); @@ -215,6 +229,26 @@ class ConnectivityManagerImpl final : public ConnectivityManager, void _OnWpaInterfaceReady(GObject * sourceObject, GAsyncResult * res); void _OnWpaInterfaceProxyReady(GObject * sourceObject, GAsyncResult * res); void _OnWpaBssProxyReady(GObject * sourceObject, GAsyncResult * res); +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + struct wpa_dbus_discov_info { + uint32_t subscribe_id; + uint32_t peer_publish_id; + uint8_t peer_addr[6]; + }; + struct wpa_dbus_discov_info mpaf_info; + struct wpa_dbus_nanrx_info { + uint32_t id; + uint32_t peer_id; + uint8_t peer_addr[6]; + uint32_t ssi_len; + }; + struct wpa_dbus_nanrx_info mpaf_nanrx_info; + + OnConnectionCompleteFunct mOnPafSubscribeComplete; + Transport::WiFiPAFBase * pmWiFiPAF; + void * mAppState; + CHIP_ERROR _SetWiFiPAFAdvertisingEnabled(bool val); +#endif bool _GetBssInfo(const gchar * bssPath, NetworkCommissioning::WiFiScanResponse & result); diff --git a/src/platform/Linux/dbus/wpa/DBusWpaInterface.xml b/src/platform/Linux/dbus/wpa/DBusWpaInterface.xml index ef86bdd3b17032..a9c2c0b51353e9 100644 --- a/src/platform/Linux/dbus/wpa/DBusWpaInterface.xml +++ b/src/platform/Linux/dbus/wpa/DBusWpaInterface.xml @@ -56,6 +56,16 @@ + + + + + + + + + + @@ -92,6 +102,13 @@ + + + + + + + diff --git a/src/platform/device.gni b/src/platform/device.gni index 332b4b3ee85716..87e2eb12e8d0d2 100644 --- a/src/platform/device.gni +++ b/src/platform/device.gni @@ -23,6 +23,9 @@ declare_args() { # Substitute fake platform when building with chip_device_platform=auto. chip_fake_platform = false + + # Include wifi-paf to commission the device or not + chip_device_config_enable_wifipaf = false } if (chip_device_platform == "auto") { diff --git a/src/setup_payload/SetupPayload.cpp b/src/setup_payload/SetupPayload.cpp index 1ef4795d571e4d..9683da21f8a7f9 100644 --- a/src/setup_payload/SetupPayload.cpp +++ b/src/setup_payload/SetupPayload.cpp @@ -62,7 +62,7 @@ bool PayloadContents::isValidQRCodePayload(ValidationMode mode) const if (mode == ValidationMode::kProduce) { chip::RendezvousInformationFlags valid(RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kOnNetwork, - RendezvousInformationFlag::kSoftAP); + RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kWiFiPAF); VerifyOrReturnValue(rendezvousInformation.Value().HasOnly(valid), false); } diff --git a/src/setup_payload/SetupPayload.h b/src/setup_payload/SetupPayload.h index dc67206dd51867..3d5d101fbf4c6e 100644 --- a/src/setup_payload/SetupPayload.h +++ b/src/setup_payload/SetupPayload.h @@ -101,6 +101,7 @@ enum class RendezvousInformationFlag : uint8_t kSoftAP = 1 << 0, ///< Device supports Wi-Fi softAP kBLE = 1 << 1, ///< Device supports BLE kOnNetwork = 1 << 2, ///< Device supports Setup on network + kWiFiPAF = 1 << 3, ///< Device supports Wi-Fi Public Action Frame for discovery }; using RendezvousInformationFlags = chip::BitFlags; diff --git a/src/transport/raw/BUILD.gn b/src/transport/raw/BUILD.gn index 3e8d3d4761dca3..130d68f86152ff 100644 --- a/src/transport/raw/BUILD.gn +++ b/src/transport/raw/BUILD.gn @@ -15,6 +15,7 @@ import("//build_overrides/chip.gni") import("${chip_root}/src/ble/ble.gni") import("${chip_root}/src/inet/inet.gni") +import("${chip_root}/src/platform/device.gni") static_library("raw") { output_name = "libRawTransport" @@ -44,6 +45,12 @@ static_library("raw") { "BLE.h", ] } + if (chip_device_config_enable_wifipaf) { + sources += [ + "WiFiPAF.cpp", + "WiFiPAF.h", + ] + } cflags = [ "-Wconversion" ] diff --git a/src/transport/raw/PeerAddress.h b/src/transport/raw/PeerAddress.h index 64588bc64c062f..da4f40fc130a8f 100644 --- a/src/transport/raw/PeerAddress.h +++ b/src/transport/raw/PeerAddress.h @@ -53,6 +53,7 @@ enum class Type : uint8_t kUdp, kBle, kTcp, + kWiFiPAF, }; /** @@ -167,6 +168,9 @@ class PeerAddress #endif snprintf(buf, bufSize, "TCP:[%s%s]:%d", ip_addr, interface, mPort); break; + case Type::kWiFiPAF: + snprintf(buf, bufSize, "WiFiPAF"); + break; case Type::kBle: // Note that BLE does not currently use any specific address. snprintf(buf, bufSize, "BLE"); @@ -209,6 +213,8 @@ class PeerAddress return TCP(addr).SetPort(port).SetInterface(interface); } + static PeerAddress WiFiPAF() { return PeerAddress(Type::kWiFiPAF); } + static PeerAddress Multicast(chip::FabricId fabric, chip::GroupId group) { constexpr uint8_t scope = 0x05; // Site-Local diff --git a/src/transport/raw/WiFiPAF.cpp b/src/transport/raw/WiFiPAF.cpp new file mode 100644 index 00000000000000..53729b7dce9ff7 --- /dev/null +++ b/src/transport/raw/WiFiPAF.cpp @@ -0,0 +1,96 @@ +/* + * + * Copyright (c) 2024 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. + */ + +/** + * @file + * This file implements the CHIP Connection object that maintains a BLE connection. + * + */ + +//#include +#include + +#include +#include +#include +#include + +#include + +using namespace chip::System; + +namespace chip { +namespace Transport { + +WiFiPAFBase::~WiFiPAFBase() +{ + ClearState(); +} + +void WiFiPAFBase::ClearState() +{ + mState = State::kNotReady; +} + +CHIP_ERROR WiFiPAFBase::Init(const WiFiPAFListenParameters & param) +{ + ChipLogDetail(Inet, "WiFiPAFBase::Init - setting/overriding transport"); + VerifyOrReturnError(mState == State::kNotReady, CHIP_ERROR_INCORRECT_STATE); + DeviceLayer::ConnectivityMgr().SetWiFiPAF(this); + mState = State::kInitialized; + + return CHIP_NO_ERROR; +} + +CHIP_ERROR WiFiPAFBase::SendMessage(const Transport::PeerAddress & address, System::PacketBufferHandle && msgBuf) +{ + ChipLogProgress(NotSpecified, "=====> WiFiPAFBase::SendMessage()"); + ReturnErrorCodeIf(address.GetTransportType() != Type::kWiFiPAF, CHIP_ERROR_INVALID_ARGUMENT); + ReturnErrorCodeIf(mState == State::kNotReady, CHIP_ERROR_INCORRECT_STATE); + + DeviceLayer::ConnectivityMgr().WiFiPAFSend(std::move(msgBuf)); + + ChipLogProgress(NotSpecified, "<===== WiFiPAFBase::SendMessage()"); + return CHIP_NO_ERROR; +} + +void WiFiPAFBase::OnWiFiPAFMessageReceived(System::PacketBufferHandle && buffer) +{ + HandleMessageReceived(Transport::PeerAddress(Transport::Type::kWiFiPAF), std::move(buffer)); + return; +} + +CHIP_ERROR WiFiPAFBase::SendAfterConnect(System::PacketBufferHandle && msg) +{ + CHIP_ERROR err = CHIP_ERROR_NO_MEMORY; + + for (size_t i = 0; i < mPendingPacketsSize; i++) + { + if (mPendingPackets[i].IsNull()) + { + mPendingPackets[i] = std::move(msg); + err = CHIP_NO_ERROR; + break; + } + } + + return err; +} + +} // namespace Transport +} // namespace chip diff --git a/src/transport/raw/WiFiPAF.h b/src/transport/raw/WiFiPAF.h new file mode 100644 index 00000000000000..2f4e774e179173 --- /dev/null +++ b/src/transport/raw/WiFiPAF.h @@ -0,0 +1,118 @@ +/* + * + * Copyright (c) 2024 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. + */ + +/** + * @file + * This file defines the CHIP Connection object that maintains a Wi-Fi PAF connection. + * + */ + +#pragma once + +#include + +#include +#include +#include +#include + +namespace chip { +namespace Transport { + +class WiFiPAFLayer +{ +public: + WiFiPAFLayer() = default; +}; +class WiFiPAFListenParameters; + + +/** + * Implements a transport using Wi-Fi-PAF + */ +class DLL_EXPORT WiFiPAFBase : public Base +{ +public: + /** + * The State of the Wi-Fi-PAF connection + * + */ + enum class State + { + kNotReady = 0, /**< State before initialization. */ + kInitialized = 1, /**< State after class is connected and ready. */ + kConnected = 2, /**< Endpoint connected. */ + }; + WiFiPAFBase()=default; + WiFiPAFBase(System::PacketBufferHandle * packetBuffers, size_t packetBuffersSize) : + mPendingPackets(packetBuffers), mPendingPacketsSize(packetBuffersSize) + {} + ~WiFiPAFBase() override; + + /** + * Initialize a Wi-Fi-PAF transport + * + * @param param Wi-Fi-PAF configuration parameters for this transport + */ + CHIP_ERROR Init(const WiFiPAFListenParameters & param); + CHIP_ERROR SendMessage(const Transport::PeerAddress & address, System::PacketBufferHandle && msgBuf) override; + bool CanSendToPeer(const Transport::PeerAddress & address) override + { + return (mState != State::kNotReady) && (address.GetTransportType() == Type::kWiFiPAF); + } + void OnWiFiPAFMessageReceived(System::PacketBufferHandle && buffer); + void SetWiFiPAFState(State state) { mState = state; }; + State GetWiFiPAFState() { return mState; }; + +private: + void ClearState(); + /** + * Sends the specified message once a connection has been established. + * @param msg - what buffer to send once a connection has been established. + */ + CHIP_ERROR SendAfterConnect(System::PacketBufferHandle && msg); + State mState = State::kNotReady; + + System::PacketBufferHandle * mPendingPackets; + size_t mPendingPacketsSize; +}; + +template +class WiFiPAF : public WiFiPAFBase +{ +public: + WiFiPAF() : WiFiPAFBase(mPendingPackets, kPendingPacketSize) {} + +private: + System::PacketBufferHandle mPendingPackets[kPendingPacketSize]; +}; + + +/** Defines parameters for setting up the Wi-Fi PAF transport */ +class WiFiPAFListenParameters +{ +public: + WiFiPAFListenParameters() = default; + explicit WiFiPAFListenParameters(WiFiPAFBase * layer) : mWiFiPAF(layer) {} +private: + WiFiPAFBase * mWiFiPAF; + +}; + +} // namespace Transport +} // namespace chip From d0310a8e4e7d6c71b4183ef78b50776419320601 Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Tue, 18 Jun 2024 07:43:14 +0000 Subject: [PATCH 02/33] Restyled by clang-format --- examples/platform/linux/Options.h | 2 +- src/app/server/Server.cpp | 2 +- src/controller/AutoCommissioner.cpp | 4 +- src/controller/CHIPDeviceController.cpp | 15 +- .../CHIPDeviceControllerSystemState.h | 3 +- src/controller/SetUpCodePairer.h | 4 +- src/include/platform/CHIPDeviceConfig.h | 1 - src/include/platform/CHIPDeviceEvent.h | 2 +- src/include/platform/ConnectivityManager.h | 14 +- .../Linux/ConnectivityManagerImpl.cpp | 168 ++++++++---------- src/platform/Linux/ConnectivityManagerImpl.h | 42 ++--- src/transport/raw/WiFiPAF.cpp | 4 +- src/transport/raw/WiFiPAF.h | 24 ++- 13 files changed, 128 insertions(+), 157 deletions(-) diff --git a/examples/platform/linux/Options.h b/examples/platform/linux/Options.h index 163ae916353dda..7e3c154e2260d3 100644 --- a/examples/platform/linux/Options.h +++ b/examples/platform/linux/Options.h @@ -50,7 +50,7 @@ struct LinuxDeviceOptions bool mWiFi = false; bool mThread = false; #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - bool mWiFiPAF = false; + bool mWiFiPAF = false; #endif #if CHIP_DEVICE_CONFIG_ENABLE_BOTH_COMMISSIONER_AND_COMMISSIONEE || CHIP_DEVICE_ENABLE_PORT_PARAMS uint16_t securedDevicePort = CHIP_PORT; diff --git a/src/app/server/Server.cpp b/src/app/server/Server.cpp index 5ca70e34ce09f8..22cd274ba87e39 100644 --- a/src/app/server/Server.cpp +++ b/src/app/server/Server.cpp @@ -220,7 +220,7 @@ CHIP_ERROR Server::Init(const ServerInitParams & initParams) .SetListenPort(mOperationalServicePort) #endif #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - , + , Transport::WiFiPAFListenParameters(DeviceLayer::ConnectivityMgr().GetWiFiPAF()) #endif ); diff --git a/src/controller/AutoCommissioner.cpp b/src/controller/AutoCommissioner.cpp index bc7ad342bcb99e..a7f7772a18681b 100644 --- a/src/controller/AutoCommissioner.cpp +++ b/src/controller/AutoCommissioner.cpp @@ -592,10 +592,10 @@ CHIP_ERROR AutoCommissioner::StartCommissioning(DeviceCommissioner * commissione mCommissioneeDeviceProxy = proxy; mNeedsNetworkSetup = (mCommissioneeDeviceProxy->GetSecureSession().Value()->AsSecureSession()->GetPeerAddress().GetTransportType() == - Transport::Type::kBle) + Transport::Type::kBle) #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF || (mCommissioneeDeviceProxy->GetSecureSession().Value()->AsSecureSession()->GetPeerAddress().GetTransportType() == - Transport::Type::kWiFiPAF) + Transport::Type::kWiFiPAF) #endif ; CHIP_ERROR err = CHIP_NO_ERROR; diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp index 1add5e05858f1f..8e48d3cda8c86f 100644 --- a/src/controller/CHIPDeviceController.cpp +++ b/src/controller/CHIPDeviceController.cpp @@ -70,7 +70,6 @@ #include #endif - #include #include #include @@ -818,7 +817,8 @@ CHIP_ERROR DeviceCommissioner::EstablishPASEConnection(NodeId remoteDeviceId, Re #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF if (params.GetPeerAddress().GetTransportType() == Transport::Type::kWiFiPAF) { - if (DeviceLayer::ConnectivityMgr().GetWiFiPAF()->GetWiFiPAFState() != Transport::WiFiPAFBase::State::kConnected) { + if (DeviceLayer::ConnectivityMgr().GetWiFiPAF()->GetWiFiPAFState() != Transport::WiFiPAFBase::State::kConnected) + { ChipLogProgress(Controller, "WiFi-PAF: Subscribing the NAN-USD devices"); static constexpr useconds_t kWiFiStartCheckTimeUsec = WIFI_START_CHECK_TIME_USEC; static constexpr uint8_t kWiFiStartCheckAttempts = WIFI_START_CHECK_ATTEMPTS; @@ -834,15 +834,12 @@ CHIP_ERROR DeviceCommissioner::EstablishPASEConnection(NodeId remoteDeviceId, Re usleep(kWiFiStartCheckTimeUsec); } } - if (!DeviceLayer::ConnectivityMgrImpl().IsWiFiManagementStarted()) { + if (!DeviceLayer::ConnectivityMgrImpl().IsWiFiManagementStarted()) + { ChipLogError(NotSpecified, "Wi-Fi Management taking too long to start - device configuration will be reset."); } mRendezvousParametersForDeviceDiscoveredOverWiFiPAF = params; - DeviceLayer::ConnectivityMgr().WiFiPAFConnect( - this, - OnWiFiPAFSubscribeComplete, - OnWiFiPAFSubscribeError - ); + DeviceLayer::ConnectivityMgr().WiFiPAFConnect(this, OnWiFiPAFSubscribeComplete, OnWiFiPAFSubscribeError); ExitNow(CHIP_NO_ERROR); } ChipLogProgress(Controller, "WiFi-PAF: Request to subscrib the NAN-USD device complete"); @@ -925,7 +922,7 @@ void DeviceCommissioner::OnWiFiPAFSubscribeComplete(void * appState) if (nullptr != device && device->GetDeviceTransportType() == Transport::Type::kWiFiPAF) { auto remoteId = device->GetDeviceId(); - auto params = self->mRendezvousParametersForDeviceDiscoveredOverWiFiPAF; + auto params = self->mRendezvousParametersForDeviceDiscoveredOverWiFiPAF; self->mRendezvousParametersForDeviceDiscoveredOverWiFiPAF = RendezvousParameters(); self->ReleaseCommissioneeDevice(device); diff --git a/src/controller/CHIPDeviceControllerSystemState.h b/src/controller/CHIPDeviceControllerSystemState.h index bec0eb403d366b..e040ad14616431 100644 --- a/src/controller/CHIPDeviceControllerSystemState.h +++ b/src/controller/CHIPDeviceControllerSystemState.h @@ -63,7 +63,6 @@ inline constexpr size_t kMaxDeviceTransportBlePendingPackets = 1; inline constexpr size_t kMaxDeviceTransportWiFiPAFPendingPackets = 1; #endif - #if INET_CONFIG_ENABLE_TCP_ENDPOINT inline constexpr size_t kMaxDeviceTransportTcpActiveConnectionCount = CHIP_CONFIG_MAX_ACTIVE_TCP_CONNECTIONS; @@ -106,7 +105,7 @@ struct DeviceControllerSystemStateParams Ble::BleLayer * bleLayer = nullptr; #endif #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - Transport::WiFiPAFLayer *wifipaf_layer = nullptr; + Transport::WiFiPAFLayer * wifipaf_layer = nullptr; #endif Credentials::GroupDataProvider * groupDataProvider = nullptr; Crypto::SessionKeystore * sessionKeystore = nullptr; diff --git a/src/controller/SetUpCodePairer.h b/src/controller/SetUpCodePairer.h index 848fbfbb1400bc..fd9956e1fc0f8b 100644 --- a/src/controller/SetUpCodePairer.h +++ b/src/controller/SetUpCodePairer.h @@ -112,8 +112,8 @@ class DLL_EXPORT SetUpCodePairer : public DevicePairingDelegate CHIP_ERROR StartDiscoverOverSoftAP(SetupPayload & payload); CHIP_ERROR StopConnectOverSoftAP(); #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - CHIP_ERROR StartDiscoverOverWiFiPAF(SetupPayload & payload); - CHIP_ERROR StopConnectOverWiFiPAF(); + CHIP_ERROR StartDiscoverOverWiFiPAF(SetupPayload & payload); + CHIP_ERROR StopConnectOverWiFiPAF(); #endif // Returns whether we have kicked off a new connection attempt. diff --git a/src/include/platform/CHIPDeviceConfig.h b/src/include/platform/CHIPDeviceConfig.h index 65e3d6ee83ad22..e7ad2dffe8ed39 100644 --- a/src/include/platform/CHIPDeviceConfig.h +++ b/src/include/platform/CHIPDeviceConfig.h @@ -434,7 +434,6 @@ #define CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF 0 #endif - // -------------------- WiFi AP Configuration -------------------- /** diff --git a/src/include/platform/CHIPDeviceEvent.h b/src/include/platform/CHIPDeviceEvent.h index 611285fba4d4f3..8d18e742c70729 100644 --- a/src/include/platform/CHIPDeviceEvent.h +++ b/src/include/platform/CHIPDeviceEvent.h @@ -495,7 +495,7 @@ struct ChipDeviceEvent final BLE_CONNECTION_OBJECT ConId; } CHIPoBLENotifyConfirm; #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - struct + struct { chip::System::PacketBuffer * Data; } CHIPoWiFiPAFWriteReceived; diff --git a/src/include/platform/ConnectivityManager.h b/src/include/platform/ConnectivityManager.h index bb7be41a5b871c..80513bd1592ddc 100644 --- a/src/include/platform/ConnectivityManager.h +++ b/src/include/platform/ConnectivityManager.h @@ -179,12 +179,10 @@ class ConnectivityManager typedef void (*OnConnectionCompleteFunct)(void * appState); typedef void (*OnConnectionErrorFunct)(void * appState, CHIP_ERROR err); - CHIP_ERROR WiFiPAFConnect(void * appState, - OnConnectionCompleteFunct onSuccess, - OnConnectionErrorFunct onError); + CHIP_ERROR WiFiPAFConnect(void * appState, OnConnectionCompleteFunct onSuccess, OnConnectionErrorFunct onError); CHIP_ERROR WiFiPAFSend(chip::System::PacketBufferHandle && msgBuf); - Transport::WiFiPAFBase * GetWiFiPAF(); - void SetWiFiPAF(Transport::WiFiPAFBase * pmWiFiPAF); + Transport::WiFiPAFBase * GetWiFiPAF(); + void SetWiFiPAF(Transport::WiFiPAFBase * pmWiFiPAF); #endif // WiFi AP methods @@ -428,10 +426,8 @@ inline CHIP_ERROR ConnectivityManager::SetWiFiPAFAdvertisingEnabled(bool val) return static_cast(this)->_SetWiFiPAFAdvertisingEnabled(val); } -inline CHIP_ERROR ConnectivityManager::WiFiPAFConnect( - void * appState, - OnConnectionCompleteFunct onSuccess, - OnConnectionErrorFunct onError) +inline CHIP_ERROR ConnectivityManager::WiFiPAFConnect(void * appState, OnConnectionCompleteFunct onSuccess, + OnConnectionErrorFunct onError) { return static_cast(this)->_WiFiPAFConnect(appState, onSuccess, onError); } diff --git a/src/platform/Linux/ConnectivityManagerImpl.cpp b/src/platform/Linux/ConnectivityManagerImpl.cpp index 312557fdba07ba..76213b7c1b10ea 100644 --- a/src/platform/Linux/ConnectivityManagerImpl.cpp +++ b/src/platform/Linux/ConnectivityManagerImpl.cpp @@ -19,9 +19,9 @@ #include #include -#include #include #include +#include #include #include #include @@ -159,12 +159,12 @@ void ConnectivityManagerImpl::_OnPlatformEvent(const ChipDeviceEvent * event) #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF switch (event->Type) { - case DeviceEventType::kCHIPoWiFiPAFWriteReceived: - ChipLogProgress(DeviceLayer, "WiFi-PAF: kCHIPoWiFiPAFWriteReceived"); - _GetWiFiPAF()->OnWiFiPAFMessageReceived(System::PacketBufferHandle::Adopt(event->CHIPoWiFiPAFWriteReceived.Data)); - break; + case DeviceEventType::kCHIPoWiFiPAFWriteReceived: + ChipLogProgress(DeviceLayer, "WiFi-PAF: kCHIPoWiFiPAFWriteReceived"); + _GetWiFiPAF()->OnWiFiPAFMessageReceived(System::PacketBufferHandle::Adopt(event->CHIPoWiFiPAFWriteReceived.Data)); + break; } -#endif //CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +#endif // CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF } #if CHIP_DEVICE_CONFIG_ENABLE_WPA @@ -811,38 +811,38 @@ bool ConnectivityManagerImpl::IsWiFiManagementStarted() } #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF -const char srv_name[]="_matterc._udp"; +const char srv_name[] = "_matterc._udp"; /* NAN-USD Service Protocol Type: ref: Table 58 of Wi-Fi Aware Specificaiton */ -#define MAX_PAF_PUBLISH_SSI_BUFLEN 128 -#define MAX_PAF_TX_SSI_BUFLEN 2048 -#define NAN_SRV_PROTO_MATTER 3 -#define NAM_PUBLISH_PERIOD 300u -#define NAN_PUBLISH_SSI_TAG "ssi=" +#define MAX_PAF_PUBLISH_SSI_BUFLEN 128 +#define MAX_PAF_TX_SSI_BUFLEN 2048 +#define NAN_SRV_PROTO_MATTER 3 +#define NAM_PUBLISH_PERIOD 300u +#define NAN_PUBLISH_SSI_TAG "ssi=" #pragma pack(push, 1) struct PAFPublishSSI { - uint8_t DevOpCode; - uint16_t DevInfo; - uint16_t ProductId; - uint16_t VendorId; + uint8_t DevOpCode; + uint16_t DevInfo; + uint16_t ProductId; + uint16_t VendorId; }; #pragma pack(pop) CHIP_ERROR ConnectivityManagerImpl::_SetWiFiPAFAdvertisingEnabled(bool val) { - CHIP_ERROR ret; + CHIP_ERROR ret; GAutoPtr err; gchar args[MAX_PAF_PUBLISH_SSI_BUFLEN]; gint publish_id; - snprintf(args, sizeof(args), "service_name=%s srv_proto_type=%u ttl=%u ", - srv_name, NAN_SRV_PROTO_MATTER, NAM_PUBLISH_PERIOD); + snprintf(args, sizeof(args), "service_name=%s srv_proto_type=%u ttl=%u ", srv_name, NAN_SRV_PROTO_MATTER, NAM_PUBLISH_PERIOD); struct PAFPublishSSI PafPublish_ssi; - VerifyOrReturnError((strlen(args) + strlen(NAN_PUBLISH_SSI_TAG) + (sizeof(struct PAFPublishSSI)*2) < MAX_PAF_PUBLISH_SSI_BUFLEN), + VerifyOrReturnError( + (strlen(args) + strlen(NAN_PUBLISH_SSI_TAG) + (sizeof(struct PAFPublishSSI) * 2) < MAX_PAF_PUBLISH_SSI_BUFLEN), CHIP_ERROR_BUFFER_TOO_SMALL); PafPublish_ssi.DevOpCode = 0; VerifyOrDie(DeviceLayer::GetCommissionableDataProvider()->GetSetupDiscriminator(PafPublish_ssi.DevInfo) == CHIP_NO_ERROR); @@ -855,23 +855,18 @@ CHIP_ERROR ConnectivityManagerImpl::_SetWiFiPAFAdvertisingEnabled(bool val) PafPublish_ssi.VendorId = 0; } strcat(args, NAN_PUBLISH_SSI_TAG); - ret = chip::Encoding::BytesToUppercaseHexString((uint8_t*)&PafPublish_ssi, sizeof(PafPublish_ssi), &args[strlen(args)], - MAX_PAF_PUBLISH_SSI_BUFLEN-strlen(args)); + ret = chip::Encoding::BytesToUppercaseHexString((uint8_t *) &PafPublish_ssi, sizeof(PafPublish_ssi), &args[strlen(args)], + MAX_PAF_PUBLISH_SSI_BUFLEN - strlen(args)); VerifyOrReturnError(ret == CHIP_NO_ERROR, ret); ChipLogProgress(DeviceLayer, "WiFi-PAF: SetWiFiPAFAdvertisingEnabled(%d)", val); - wpa_fi_w1_wpa_supplicant1_interface_call_nanpublish_sync(mWpaSupplicant.iface, - args, - &publish_id, - nullptr, - &err.GetReceiver()); + wpa_fi_w1_wpa_supplicant1_interface_call_nanpublish_sync(mWpaSupplicant.iface, args, &publish_id, nullptr, &err.GetReceiver()); ChipLogProgress(DeviceLayer, "WiFi-PAF: publish_id: %d ! ", publish_id); - g_signal_connect( - mWpaSupplicant.iface, "nan-receive", - G_CALLBACK(+[](WpaFiW1Wpa_supplicant1Interface * proxy, GVariant * obj, ConnectivityManagerImpl * self) { - return self->OnNanReceive(obj); - }), - this); + g_signal_connect(mWpaSupplicant.iface, "nan-receive", + G_CALLBACK(+[](WpaFiW1Wpa_supplicant1Interface * proxy, GVariant * obj, ConnectivityManagerImpl * self) { + return self->OnNanReceive(obj); + }), + this); return CHIP_NO_ERROR; } @@ -1320,9 +1315,9 @@ CHIP_ERROR ConnectivityManagerImpl::ConnectWiFiNetworkWithPDCAsync( /* NAN-USD Service Protocol Type: ref: Table 58 of Wi-Fi Aware Specificaiton */ -#define MAX_PAF_SUBSCRIBE_SSI_BUFLEN 128 -#define NAN_SRV_PROTO_MATTER 3 -#define NAM_SUBSCRIBE_PERIOD 30u +#define MAX_PAF_SUBSCRIBE_SSI_BUFLEN 128 +#define NAN_SRV_PROTO_MATTER 3 +#define NAM_SUBSCRIBE_PERIOD 30u void ConnectivityManagerImpl::OnDiscoveryResult(gboolean success, GVariant * discov_info) { ChipLogProgress(Controller, "WiFi-PAF: OnDiscoveryResult, %d", success); @@ -1337,16 +1332,16 @@ void ConnectivityManagerImpl::OnDiscoveryResult(gboolean success, GVariant * dis size_t bufferLen; auto buffer = g_variant_get_fixed_array(dataValue.get(), &bufferLen, sizeof(uint8_t)); - if (((struct wpa_dbus_discov_info*)buffer)->subscribe_id == mpaf_info.subscribe_id) + if (((struct wpa_dbus_discov_info *) buffer)->subscribe_id == mpaf_info.subscribe_id) { return; } memcpy(&mpaf_info, buffer, sizeof(struct wpa_dbus_discov_info)); ChipLogProgress(DeviceLayer, "WiFi-PAF: subscribe_id: %u", mpaf_info.subscribe_id); ChipLogProgress(DeviceLayer, "WiFi-PAF: peer_publish_id: %u", mpaf_info.peer_publish_id); - ChipLogProgress(DeviceLayer, "WiFi-PAF: peer_addr: [%02x:%02x:%02x:%02x:%02x:%02x]", - mpaf_info.peer_addr[0], mpaf_info.peer_addr[1], mpaf_info.peer_addr[2], - mpaf_info.peer_addr[3], mpaf_info.peer_addr[4], mpaf_info.peer_addr[5]); + ChipLogProgress(DeviceLayer, "WiFi-PAF: peer_addr: [%02x:%02x:%02x:%02x:%02x:%02x]", mpaf_info.peer_addr[0], + mpaf_info.peer_addr[1], mpaf_info.peer_addr[2], mpaf_info.peer_addr[3], mpaf_info.peer_addr[4], + mpaf_info.peer_addr[5]); if (mOnPafSubscribeComplete != nullptr) { mOnPafSubscribeComplete(mAppState); @@ -1364,16 +1359,17 @@ void ConnectivityManagerImpl::OnNanReceive(GVariant * obj) return; } { - GAutoPtr dataValue(g_variant_lookup_value(obj, "nanrx_info", G_VARIANT_TYPE_BYTESTRING)); - size_t bufferLen; - auto buffer = g_variant_get_fixed_array(dataValue.get(), &bufferLen, sizeof(uint8_t)); + GAutoPtr dataValue(g_variant_lookup_value(obj, "nanrx_info", G_VARIANT_TYPE_BYTESTRING)); + size_t bufferLen; + auto buffer = g_variant_get_fixed_array(dataValue.get(), &bufferLen, sizeof(uint8_t)); - memcpy(&mpaf_nanrx_info, buffer, sizeof(struct wpa_dbus_nanrx_info)); - mpaf_info.subscribe_id = mpaf_nanrx_info.id; - mpaf_info.peer_publish_id = mpaf_nanrx_info.peer_id; - memcpy(mpaf_info.peer_addr, mpaf_nanrx_info.peer_addr, 6); + memcpy(&mpaf_nanrx_info, buffer, sizeof(struct wpa_dbus_nanrx_info)); + mpaf_info.subscribe_id = mpaf_nanrx_info.id; + mpaf_info.peer_publish_id = mpaf_nanrx_info.peer_id; + memcpy(mpaf_info.peer_addr, mpaf_nanrx_info.peer_addr, 6); } - if (mpaf_nanrx_info.ssi_len > 0) { + if (mpaf_nanrx_info.ssi_len > 0) + { GAutoPtr dataValue(g_variant_lookup_value(obj, "ssi", G_VARIANT_TYPE_BYTESTRING)); size_t bufferLen; System::PacketBufferHandle buf; @@ -1384,45 +1380,38 @@ void ConnectivityManagerImpl::OnNanReceive(GVariant * obj) // Post an event to the Chip queue to deliver the data into the Chip stack. { ChipDeviceEvent event; - event.Type = DeviceEventType::kCHIPoWiFiPAFWriteReceived; - event.CHIPoWiFiPAFWriteReceived.Data = std::move(buf).UnsafeRelease(); + event.Type = DeviceEventType::kCHIPoWiFiPAFWriteReceived; + event.CHIPoWiFiPAFWriteReceived.Data = std::move(buf).UnsafeRelease(); PlatformMgr().PostEventOrDie(&event); } - } else { + } + else + { ChipLogProgress(DeviceLayer, "WiFi-PAF: Skip, ssi length = %u", mpaf_nanrx_info.ssi_len); } return; } - -CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFConnect(void *appState, - OnConnectionCompleteFunct onSuccess, - OnConnectionErrorFunct onError) +CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFConnect(void * appState, OnConnectionCompleteFunct onSuccess, + OnConnectionErrorFunct onError) { ChipLogProgress(Controller, "WiFi-PAF: Try to subscribe the NAN-USD devices"); gchar args[MAX_PAF_SUBSCRIBE_SSI_BUFLEN]; - snprintf(args, sizeof(args), "service_name=%s srv_proto_type=%u ttl=%u ", - srv_name, NAN_SRV_PROTO_MATTER, NAM_SUBSCRIBE_PERIOD); + snprintf(args, sizeof(args), "service_name=%s srv_proto_type=%u ttl=%u ", srv_name, NAN_SRV_PROTO_MATTER, NAM_SUBSCRIBE_PERIOD); mAppState = appState; GAutoPtr err; - wpa_fi_w1_wpa_supplicant1_interface_call_nansubscribe(mWpaSupplicant.iface, - args, - nullptr, + wpa_fi_w1_wpa_supplicant1_interface_call_nansubscribe( + mWpaSupplicant.iface, args, nullptr, reinterpret_cast( - +[](GObject * sourceObject_, GAsyncResult * res_, ConnectivityManagerImpl * self) { - return ; - }), + +[](GObject * sourceObject_, GAsyncResult * res_, ConnectivityManagerImpl * self) { return; }), &err.GetReceiver()); mOnPafSubscribeComplete = onSuccess; - g_signal_connect( - mWpaSupplicant.iface, "discovery-result", - G_CALLBACK(+[](WpaFiW1Wpa_supplicant1Interface * proxy, gboolean success, GVariant * obj, ConnectivityManagerImpl * self) { - return self->OnDiscoveryResult(success, obj); - }), - this); - + g_signal_connect(mWpaSupplicant.iface, "discovery-result", + G_CALLBACK(+[](WpaFiW1Wpa_supplicant1Interface * proxy, gboolean success, GVariant * obj, + ConnectivityManagerImpl * self) { return self->OnDiscoveryResult(success, obj); }), + this); return CHIP_NO_ERROR; } @@ -1432,7 +1421,8 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFSend(System::PacketBufferHandle && m ChipLogProgress(Controller, "WiFi-PAF: sending PAF Follow-up packets, (%lu)", msgBuf->DataLength()); CHIP_ERROR ret = CHIP_NO_ERROR; - if (msgBuf.IsNull()) { + if (msgBuf.IsNull()) + { ChipLogError(Controller, "WiFi-PAF: Invalid Packet (%lu)", msgBuf->DataLength()); return CHIP_ERROR_INVALID_ARGUMENT; } @@ -1456,39 +1446,31 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFSend(System::PacketBufferHandle && m GAutoPtr err; gchar args[MAX_PAF_TX_SSI_BUFLEN]; - snprintf(args, sizeof(args), "handle=%u req_instance_id=%u address=%02x:%02x:%02x:%02x:%02x:%02x ssi=", - mpaf_info.subscribe_id, mpaf_info.peer_publish_id, - mpaf_info.peer_addr[0], mpaf_info.peer_addr[1], mpaf_info.peer_addr[2], - mpaf_info.peer_addr[3], mpaf_info.peer_addr[4], mpaf_info.peer_addr[5]); + snprintf(args, sizeof(args), "handle=%u req_instance_id=%u address=%02x:%02x:%02x:%02x:%02x:%02x ssi=", mpaf_info.subscribe_id, + mpaf_info.peer_publish_id, mpaf_info.peer_addr[0], mpaf_info.peer_addr[1], mpaf_info.peer_addr[2], + mpaf_info.peer_addr[3], mpaf_info.peer_addr[4], mpaf_info.peer_addr[5]); - ChipLogProgress(Controller, "===> %s(), (%lu, %u)", __FUNCTION__, - (strlen(args) + msgBuf->DataLength()), - MAX_PAF_TX_SSI_BUFLEN) - VerifyOrReturnError((strlen(args) + msgBuf->DataLength() < MAX_PAF_TX_SSI_BUFLEN), - CHIP_ERROR_BUFFER_TOO_SMALL); + ChipLogProgress(Controller, "===> %s(), (%lu, %u)", __FUNCTION__, (strlen(args) + msgBuf->DataLength()), MAX_PAF_TX_SSI_BUFLEN) + VerifyOrReturnError((strlen(args) + msgBuf->DataLength() < MAX_PAF_TX_SSI_BUFLEN), CHIP_ERROR_BUFFER_TOO_SMALL); ret = chip::Encoding::BytesToUppercaseHexString(msgBuf->Start(), msgBuf->DataLength(), &args[strlen(args)], - MAX_PAF_TX_SSI_BUFLEN-strlen(args)); + MAX_PAF_TX_SSI_BUFLEN - strlen(args)); VerifyOrReturnError(ret == CHIP_NO_ERROR, ret); ChipLogProgress(DeviceLayer, "WiFi-PAF: ssi: [%s]", args); - wpa_fi_w1_wpa_supplicant1_interface_call_nantransmit_sync(mWpaSupplicant.iface, - args, - nullptr, - &err.GetReceiver()); + wpa_fi_w1_wpa_supplicant1_interface_call_nantransmit_sync(mWpaSupplicant.iface, args, nullptr, &err.GetReceiver()); - g_signal_connect( - mWpaSupplicant.iface, "nan-receive", - G_CALLBACK(+[](WpaFiW1Wpa_supplicant1Interface * proxy, GVariant * obj, ConnectivityManagerImpl * self) { - return self->OnNanReceive(obj); - }), - this); + g_signal_connect(mWpaSupplicant.iface, "nan-receive", + G_CALLBACK(+[](WpaFiW1Wpa_supplicant1Interface * proxy, GVariant * obj, ConnectivityManagerImpl * self) { + return self->OnNanReceive(obj); + }), + this); ChipLogProgress(Controller, "WiFi-PAF: Outbound message (%lu) done", msgBuf->DataLength()); return ret; } -#endif //CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +#endif // CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF void ConnectivityManagerImpl::_ConnectWiFiNetworkAsyncCallback(GObject * sourceObject, GAsyncResult * res) { @@ -1734,7 +1716,7 @@ CHIP_ERROR ConnectivityManagerImpl::GetConfiguredNetwork(NetworkCommissioning::N const gchar * networkPath = wpa_fi_w1_wpa_supplicant1_interface_get_current_network(mWpaSupplicant.iface); // wpa_supplicant DBus API: if network path of current network is "/", means no networks is currently selected. - if ((networkPath==nullptr) || (strcmp(networkPath, "/") == 0)) + if ((networkPath == nullptr) || (strcmp(networkPath, "/") == 0)) { return CHIP_ERROR_KEY_NOT_FOUND; } diff --git a/src/platform/Linux/ConnectivityManagerImpl.h b/src/platform/Linux/ConnectivityManagerImpl.h index 54f29170d20d21..b128b90e34d5fd 100644 --- a/src/platform/Linux/ConnectivityManagerImpl.h +++ b/src/platform/Linux/ConnectivityManagerImpl.h @@ -141,15 +141,13 @@ class ConnectivityManagerImpl final : public ConnectivityManager, NetworkCommissioning::Internal::WirelessDriver::ConnectCallback * connectCallback); #endif // CHIP_DEVICE_CONFIG_ENABLE_WIFI_PDC #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - CHIP_ERROR _WiFiPAFConnect(void * appState, - OnConnectionCompleteFunct onSuccess, - OnConnectionErrorFunct onError); + CHIP_ERROR _WiFiPAFConnect(void * appState, OnConnectionCompleteFunct onSuccess, OnConnectionErrorFunct onError); void OnDiscoveryResult(gboolean success, GVariant * obj); - void OnNanReceive(GVariant * obj); + void OnNanReceive(GVariant * obj); - CHIP_ERROR _WiFiPAFSend(chip::System::PacketBufferHandle && msgBuf); - Transport::WiFiPAFBase * _GetWiFiPAF(); - void _SetWiFiPAF(Transport::WiFiPAFBase * pWiFiPAF); + CHIP_ERROR _WiFiPAFSend(chip::System::PacketBufferHandle && msgBuf); + Transport::WiFiPAFBase * _GetWiFiPAF(); + void _SetWiFiPAF(Transport::WiFiPAFBase * pWiFiPAF); #endif void PostNetworkConnect(); @@ -230,23 +228,25 @@ class ConnectivityManagerImpl final : public ConnectivityManager, void _OnWpaInterfaceProxyReady(GObject * sourceObject, GAsyncResult * res); void _OnWpaBssProxyReady(GObject * sourceObject, GAsyncResult * res); #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - struct wpa_dbus_discov_info { - uint32_t subscribe_id; - uint32_t peer_publish_id; - uint8_t peer_addr[6]; - }; - struct wpa_dbus_discov_info mpaf_info; - struct wpa_dbus_nanrx_info { - uint32_t id; - uint32_t peer_id; - uint8_t peer_addr[6]; - uint32_t ssi_len; - }; - struct wpa_dbus_nanrx_info mpaf_nanrx_info; + struct wpa_dbus_discov_info + { + uint32_t subscribe_id; + uint32_t peer_publish_id; + uint8_t peer_addr[6]; + }; + struct wpa_dbus_discov_info mpaf_info; + struct wpa_dbus_nanrx_info + { + uint32_t id; + uint32_t peer_id; + uint8_t peer_addr[6]; + uint32_t ssi_len; + }; + struct wpa_dbus_nanrx_info mpaf_nanrx_info; OnConnectionCompleteFunct mOnPafSubscribeComplete; Transport::WiFiPAFBase * pmWiFiPAF; - void * mAppState; + void * mAppState; CHIP_ERROR _SetWiFiPAFAdvertisingEnabled(bool val); #endif diff --git a/src/transport/raw/WiFiPAF.cpp b/src/transport/raw/WiFiPAF.cpp index 53729b7dce9ff7..4d0607b3b4e03d 100644 --- a/src/transport/raw/WiFiPAF.cpp +++ b/src/transport/raw/WiFiPAF.cpp @@ -22,13 +22,13 @@ * */ -//#include +// #include #include #include #include -#include #include +#include #include diff --git a/src/transport/raw/WiFiPAF.h b/src/transport/raw/WiFiPAF.h index 2f4e774e179173..7e49c09fe81b96 100644 --- a/src/transport/raw/WiFiPAF.h +++ b/src/transport/raw/WiFiPAF.h @@ -37,11 +37,10 @@ namespace Transport { class WiFiPAFLayer { public: - WiFiPAFLayer() = default; + WiFiPAFLayer() = default; }; class WiFiPAFListenParameters; - /** * Implements a transport using Wi-Fi-PAF */ @@ -58,7 +57,7 @@ class DLL_EXPORT WiFiPAFBase : public Base kInitialized = 1, /**< State after class is connected and ready. */ kConnected = 2, /**< Endpoint connected. */ }; - WiFiPAFBase()=default; + WiFiPAFBase() = default; WiFiPAFBase(System::PacketBufferHandle * packetBuffers, size_t packetBuffersSize) : mPendingPackets(packetBuffers), mPendingPacketsSize(packetBuffersSize) {} @@ -75,18 +74,18 @@ class DLL_EXPORT WiFiPAFBase : public Base { return (mState != State::kNotReady) && (address.GetTransportType() == Type::kWiFiPAF); } - void OnWiFiPAFMessageReceived(System::PacketBufferHandle && buffer); - void SetWiFiPAFState(State state) { mState = state; }; - State GetWiFiPAFState() { return mState; }; + void OnWiFiPAFMessageReceived(System::PacketBufferHandle && buffer); + void SetWiFiPAFState(State state) { mState = state; }; + State GetWiFiPAFState() { return mState; }; private: void ClearState(); - /** + /** * Sends the specified message once a connection has been established. * @param msg - what buffer to send once a connection has been established. */ CHIP_ERROR SendAfterConnect(System::PacketBufferHandle && msg); - State mState = State::kNotReady; + State mState = State::kNotReady; System::PacketBufferHandle * mPendingPackets; size_t mPendingPacketsSize; @@ -102,16 +101,15 @@ class WiFiPAF : public WiFiPAFBase System::PacketBufferHandle mPendingPackets[kPendingPacketSize]; }; - /** Defines parameters for setting up the Wi-Fi PAF transport */ class WiFiPAFListenParameters { public: - WiFiPAFListenParameters() = default; - explicit WiFiPAFListenParameters(WiFiPAFBase * layer) : mWiFiPAF(layer) {} -private: - WiFiPAFBase * mWiFiPAF; + WiFiPAFListenParameters() = default; + explicit WiFiPAFListenParameters(WiFiPAFBase * layer) : mWiFiPAF(layer) {} +private: + WiFiPAFBase * mWiFiPAF; }; } // namespace Transport From 4df2319b12fa9efe8b99d9c8766d77831a1bb6fc Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Tue, 18 Jun 2024 07:43:15 +0000 Subject: [PATCH 03/33] Restyled by gn --- src/transport/raw/BUILD.gn | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/transport/raw/BUILD.gn b/src/transport/raw/BUILD.gn index 130d68f86152ff..f5593c012769e7 100644 --- a/src/transport/raw/BUILD.gn +++ b/src/transport/raw/BUILD.gn @@ -47,8 +47,8 @@ static_library("raw") { } if (chip_device_config_enable_wifipaf) { sources += [ - "WiFiPAF.cpp", - "WiFiPAF.h", + "WiFiPAF.cpp", + "WiFiPAF.h", ] } From 9c7e58c4e44c8880e56700f48962765dee7b1f15 Mon Sep 17 00:00:00 2001 From: "Lo,Chin-Ran" Date: Tue, 18 Jun 2024 18:41:43 +0800 Subject: [PATCH 04/33] * Add the missing compile macro --- src/setup_payload/SetupPayload.cpp | 6 +++++- src/setup_payload/SetupPayload.h | 2 ++ src/transport/raw/PeerAddress.h | 7 ++++++- 3 files changed, 13 insertions(+), 2 deletions(-) diff --git a/src/setup_payload/SetupPayload.cpp b/src/setup_payload/SetupPayload.cpp index 9683da21f8a7f9..926ec7ca445ec0 100644 --- a/src/setup_payload/SetupPayload.cpp +++ b/src/setup_payload/SetupPayload.cpp @@ -62,7 +62,11 @@ bool PayloadContents::isValidQRCodePayload(ValidationMode mode) const if (mode == ValidationMode::kProduce) { chip::RendezvousInformationFlags valid(RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kOnNetwork, - RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kWiFiPAF); + RendezvousInformationFlag::kSoftAP +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + , RendezvousInformationFlag::kWiFiPAF +#endif + ); VerifyOrReturnValue(rendezvousInformation.Value().HasOnly(valid), false); } diff --git a/src/setup_payload/SetupPayload.h b/src/setup_payload/SetupPayload.h index 3d5d101fbf4c6e..6252933dd79a78 100644 --- a/src/setup_payload/SetupPayload.h +++ b/src/setup_payload/SetupPayload.h @@ -101,7 +101,9 @@ enum class RendezvousInformationFlag : uint8_t kSoftAP = 1 << 0, ///< Device supports Wi-Fi softAP kBLE = 1 << 1, ///< Device supports BLE kOnNetwork = 1 << 2, ///< Device supports Setup on network +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF kWiFiPAF = 1 << 3, ///< Device supports Wi-Fi Public Action Frame for discovery +#endif }; using RendezvousInformationFlags = chip::BitFlags; diff --git a/src/transport/raw/PeerAddress.h b/src/transport/raw/PeerAddress.h index da4f40fc130a8f..441bcfdd1d7076 100644 --- a/src/transport/raw/PeerAddress.h +++ b/src/transport/raw/PeerAddress.h @@ -53,7 +53,9 @@ enum class Type : uint8_t kUdp, kBle, kTcp, +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF kWiFiPAF, +#endif }; /** @@ -168,9 +170,11 @@ class PeerAddress #endif snprintf(buf, bufSize, "TCP:[%s%s]:%d", ip_addr, interface, mPort); break; +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF case Type::kWiFiPAF: snprintf(buf, bufSize, "WiFiPAF"); break; +#endif case Type::kBle: // Note that BLE does not currently use any specific address. snprintf(buf, bufSize, "BLE"); @@ -212,8 +216,9 @@ class PeerAddress { return TCP(addr).SetPort(port).SetInterface(interface); } - +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF static PeerAddress WiFiPAF() { return PeerAddress(Type::kWiFiPAF); } +#endif static PeerAddress Multicast(chip::FabricId fabric, chip::GroupId group) { From a421e7022e90059281dbb5ff711f4c67d999e535 Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Tue, 18 Jun 2024 10:43:12 +0000 Subject: [PATCH 05/33] Restyled by clang-format --- src/setup_payload/SetupPayload.cpp | 5 +++-- src/setup_payload/SetupPayload.h | 2 +- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/setup_payload/SetupPayload.cpp b/src/setup_payload/SetupPayload.cpp index 926ec7ca445ec0..7a7423a35ba146 100644 --- a/src/setup_payload/SetupPayload.cpp +++ b/src/setup_payload/SetupPayload.cpp @@ -64,9 +64,10 @@ bool PayloadContents::isValidQRCodePayload(ValidationMode mode) const chip::RendezvousInformationFlags valid(RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kOnNetwork, RendezvousInformationFlag::kSoftAP #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - , RendezvousInformationFlag::kWiFiPAF + , + RendezvousInformationFlag::kWiFiPAF #endif - ); + ); VerifyOrReturnValue(rendezvousInformation.Value().HasOnly(valid), false); } diff --git a/src/setup_payload/SetupPayload.h b/src/setup_payload/SetupPayload.h index 6252933dd79a78..34e3e5ec647a20 100644 --- a/src/setup_payload/SetupPayload.h +++ b/src/setup_payload/SetupPayload.h @@ -102,7 +102,7 @@ enum class RendezvousInformationFlag : uint8_t kBLE = 1 << 1, ///< Device supports BLE kOnNetwork = 1 << 2, ///< Device supports Setup on network #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - kWiFiPAF = 1 << 3, ///< Device supports Wi-Fi Public Action Frame for discovery + kWiFiPAF = 1 << 3, ///< Device supports Wi-Fi Public Action Frame for discovery #endif }; using RendezvousInformationFlags = chip::BitFlags; From a816a61ab40a073d4e35e68cff7cd1b1011a09f7 Mon Sep 17 00:00:00 2001 From: crlonxp <88241281+crlonxp@users.noreply.github.com> Date: Thu, 20 Jun 2024 18:40:56 +0800 Subject: [PATCH 06/33] Update src/controller/CHIPDeviceController.cpp Co-authored-by: Boris Zbarsky --- src/controller/CHIPDeviceController.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp index 8e48d3cda8c86f..1f61c669d04167 100644 --- a/src/controller/CHIPDeviceController.cpp +++ b/src/controller/CHIPDeviceController.cpp @@ -842,7 +842,7 @@ CHIP_ERROR DeviceCommissioner::EstablishPASEConnection(NodeId remoteDeviceId, Re DeviceLayer::ConnectivityMgr().WiFiPAFConnect(this, OnWiFiPAFSubscribeComplete, OnWiFiPAFSubscribeError); ExitNow(CHIP_NO_ERROR); } - ChipLogProgress(Controller, "WiFi-PAF: Request to subscrib the NAN-USD device complete"); + ChipLogProgress(Controller, "WiFi-PAF: Request to subscribe the NAN-USD device complete"); } #endif session = mSystemState->SessionMgr()->CreateUnauthenticatedSession(params.GetPeerAddress(), params.GetMRPConfig()); From 9d052a06ccba74b22b1118515b9acb4ac57b7287 Mon Sep 17 00:00:00 2001 From: crlonxp <88241281+crlonxp@users.noreply.github.com> Date: Thu, 20 Jun 2024 18:48:30 +0800 Subject: [PATCH 07/33] Update src/include/platform/ConnectivityManager.h Co-authored-by: Boris Zbarsky --- src/include/platform/ConnectivityManager.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/include/platform/ConnectivityManager.h b/src/include/platform/ConnectivityManager.h index 80513bd1592ddc..6e4d0c0014c4ea 100644 --- a/src/include/platform/ConnectivityManager.h +++ b/src/include/platform/ConnectivityManager.h @@ -180,7 +180,7 @@ class ConnectivityManager typedef void (*OnConnectionCompleteFunct)(void * appState); typedef void (*OnConnectionErrorFunct)(void * appState, CHIP_ERROR err); CHIP_ERROR WiFiPAFConnect(void * appState, OnConnectionCompleteFunct onSuccess, OnConnectionErrorFunct onError); - CHIP_ERROR WiFiPAFSend(chip::System::PacketBufferHandle && msgBuf); + CHIP_ERROR WiFiPAFSend(System::PacketBufferHandle && msgBuf); Transport::WiFiPAFBase * GetWiFiPAF(); void SetWiFiPAF(Transport::WiFiPAFBase * pmWiFiPAF); #endif From d15b8d53f39d9d25c545d0adcd46b75610c08bd5 Mon Sep 17 00:00:00 2001 From: crlonxp <88241281+crlonxp@users.noreply.github.com> Date: Fri, 28 Jun 2024 17:35:08 +0800 Subject: [PATCH 08/33] Update examples/platform/linux/Options.cpp Co-authored-by: Karsten Sperling <113487422+ksperling-apple@users.noreply.github.com> --- examples/platform/linux/Options.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/platform/linux/Options.cpp b/examples/platform/linux/Options.cpp index 5e32bf7eb4bfde..ae6138047e19dc 100644 --- a/examples/platform/linux/Options.cpp +++ b/examples/platform/linux/Options.cpp @@ -107,7 +107,7 @@ enum kDeviceOption_FaultInjection, #endif #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - kDeviceOption_WiFi_PAF = 0x1028, + kDeviceOption_WiFi_PAF, #endif }; From 9bc1371992260e07c899f1a7871fecd6c692b1b9 Mon Sep 17 00:00:00 2001 From: "Lo,Chin-Ran" Date: Fri, 28 Jun 2024 21:17:44 +0800 Subject: [PATCH 09/33] Change by following the review's comment: * Change the name of option to [pair_mode]-[network] * Remove redundant compile flags * Move to start the Wi-Fi Manager in initialization stage * Unconditional the defintion * Add the cancel-publish / cancel-subscribe dbus interface * Fix bugs: - Redundant callback function registration - Remove the incorrect StackLock Signed-off-by: Lo,Chin-Ran --- .../chip-tool/commands/pairing/Commands.h | 2 +- .../payload/SetupPayloadParseCommand.cpp | 8 + examples/platform/linux/AppMain.cpp | 5 +- examples/platform/linux/Options.cpp | 8 +- src/app/server/CommissioningWindowManager.cpp | 3 + src/controller/AutoCommissioner.cpp | 11 +- src/controller/CHIPDeviceController.cpp | 26 +-- src/controller/SetUpCodePairer.cpp | 2 +- src/controller/SetUpCodePairer.h | 4 +- src/include/platform/CHIPDeviceConfig.h | 2 +- src/include/platform/CHIPDeviceEvent.h | 3 +- src/include/platform/ConnectivityManager.h | 10 +- .../Linux/ConnectivityManagerImpl.cpp | 172 +++++++++++------- src/platform/Linux/ConnectivityManagerImpl.h | 5 +- .../Linux/dbus/wpa/DBusWpaInterface.xml | 8 +- src/setup_payload/SetupPayload.h | 2 - src/transport/raw/PeerAddress.h | 7 +- src/transport/raw/WiFiPAF.cpp | 30 ++- src/transport/raw/WiFiPAF.h | 3 +- 19 files changed, 184 insertions(+), 127 deletions(-) diff --git a/examples/chip-tool/commands/pairing/Commands.h b/examples/chip-tool/commands/pairing/Commands.h index d85b5a5b0802f3..c202178657df7b 100644 --- a/examples/chip-tool/commands/pairing/Commands.h +++ b/examples/chip-tool/commands/pairing/Commands.h @@ -186,7 +186,7 @@ class PairWiFiPAF : public PairingCommand { public: PairWiFiPAF(CredentialIssuerCommands * credsIssuerConfig) : - PairingCommand("wifi-paf", PairingMode::WiFiPAF, PairingNetworkType::WiFi, credsIssuerConfig) + PairingCommand("wifipaf-wifi", PairingMode::WiFiPAF, PairingNetworkType::WiFi, credsIssuerConfig) {} }; #endif diff --git a/examples/chip-tool/commands/payload/SetupPayloadParseCommand.cpp b/examples/chip-tool/commands/payload/SetupPayloadParseCommand.cpp index 7ab62c7da5101d..11d4f0862b735e 100644 --- a/examples/chip-tool/commands/payload/SetupPayloadParseCommand.cpp +++ b/examples/chip-tool/commands/payload/SetupPayloadParseCommand.cpp @@ -108,6 +108,14 @@ CHIP_ERROR SetupPayloadParseCommand::Print(chip::SetupPayload payload) } humanFlags.Add("On IP network"); } + if (payload.rendezvousInformation.Value().Has(RendezvousInformationFlag::kWiFiPAF)) + { + if (!humanFlags.Empty()) + { + humanFlags.Add(", "); + } + humanFlags.Add("WIFIPAF"); + } } else { diff --git a/examples/platform/linux/AppMain.cpp b/examples/platform/linux/AppMain.cpp index 15f0625aebeb99..2023a766d8dbf4 100644 --- a/examples/platform/linux/AppMain.cpp +++ b/examples/platform/linux/AppMain.cpp @@ -366,8 +366,6 @@ int ChipLinuxAppInit(int argc, char * const argv[], OptionSet * customOptions, CHIP_ERROR err = CHIP_NO_ERROR; #if CONFIG_NETWORK_LAYER_BLE RendezvousInformationFlags rendezvousFlags = RendezvousInformationFlag::kBLE; -#elif CHIP_DEVICE_CONFIG_ENABLE_WPA && CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - RendezvousInformationFlags rendezvousFlags = RendezvousInformationFlag::kWiFiPAF; #else // CONFIG_NETWORK_LAYER_BLE RendezvousInformationFlag rendezvousFlags = RendezvousInformationFlag::kOnNetwork; #endif // CONFIG_NETWORK_LAYER_BLE @@ -375,6 +373,9 @@ int ChipLinuxAppInit(int argc, char * const argv[], OptionSet * customOptions, #ifdef CONFIG_RENDEZVOUS_MODE rendezvousFlags = static_cast(CONFIG_RENDEZVOUS_MODE); #endif +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + rendezvousFlags.Set(RendezvousInformationFlag::kWiFiPAF); +#endif err = Platform::MemoryInit(); SuccessOrExit(err); diff --git a/examples/platform/linux/Options.cpp b/examples/platform/linux/Options.cpp index ae6138047e19dc..82322c065c6c8d 100644 --- a/examples/platform/linux/Options.cpp +++ b/examples/platform/linux/Options.cpp @@ -121,7 +121,7 @@ OptionDef sDeviceOptionDefs[] = { { "wifi", kNoArgument, kDeviceOption_WiFi }, { "wifi-supports-5g", kNoArgument, kDeviceOption_WiFiSupports5g }, #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - { "wifi-paf", kNoArgument, kDeviceOption_WiFi_PAF }, + { "wifipaf", kNoArgument, kDeviceOption_WiFi_PAF }, #endif // CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF #endif // CHIP_DEVICE_CONFIG_ENABLE_WPA #if CHIP_ENABLE_OPENTHREAD @@ -195,11 +195,11 @@ const char * sDeviceOptionHelp = " --wifi-supports-5g\n" " Indicate that local Wi-Fi hardware should report 5GHz support.\n" #endif // CHIP_DEVICE_CONFIG_ENABLE_WIFI -#if (CHIP_DEVICE_CONFIG_ENABLE_WIFI && CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF) +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF "\n" - " --wifi-paf\n" + " --wifipaf\n" " Enable Wi-Fi PAF via wpa_supplicant.\n" -#endif // CHIP_DEVICE_CONFIG_ENABLE_WIFI && CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +#endif // CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF #if CHIP_ENABLE_OPENTHREAD "\n" " --thread\n" diff --git a/src/app/server/CommissioningWindowManager.cpp b/src/app/server/CommissioningWindowManager.cpp index 229fd67c5bb24b..61a59049f4bcc5 100644 --- a/src/app/server/CommissioningWindowManager.cpp +++ b/src/app/server/CommissioningWindowManager.cpp @@ -71,6 +71,9 @@ void CommissioningWindowManager::OnPlatformEvent(const DeviceLayer::ChipDeviceEv #if CONFIG_NETWORK_LAYER_BLE && CHIP_DEVICE_CONFIG_SUPPORTS_CONCURRENT_CONNECTION // If in NonConcurrentConnection, this will already have been completed mServer->GetBleLayerObject()->CloseAllBleConnections(); +#endif +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + DeviceLayer::ConnectivityMgr().SetWiFiPAFAdvertisingEnabled(false); #endif } else if (event->Type == DeviceLayer::DeviceEventType::kFailSafeTimerExpired) diff --git a/src/controller/AutoCommissioner.cpp b/src/controller/AutoCommissioner.cpp index a7f7772a18681b..dad29af3c35a21 100644 --- a/src/controller/AutoCommissioner.cpp +++ b/src/controller/AutoCommissioner.cpp @@ -592,14 +592,13 @@ CHIP_ERROR AutoCommissioner::StartCommissioning(DeviceCommissioner * commissione mCommissioneeDeviceProxy = proxy; mNeedsNetworkSetup = (mCommissioneeDeviceProxy->GetSecureSession().Value()->AsSecureSession()->GetPeerAddress().GetTransportType() == - Transport::Type::kBle) -#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - || (mCommissioneeDeviceProxy->GetSecureSession().Value()->AsSecureSession()->GetPeerAddress().GetTransportType() == - Transport::Type::kWiFiPAF) -#endif - ; + Transport::Type::kBle); CHIP_ERROR err = CHIP_NO_ERROR; CommissioningStage nextStage = GetNextCommissioningStage(CommissioningStage::kSecurePairing, err); +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + mNeedsNetworkSetup = mNeedsNetworkSetup || (mCommissioneeDeviceProxy->GetSecureSession().Value()->AsSecureSession()->GetPeerAddress().GetTransportType() == + Transport::Type::kWiFiPAF); +#endif mCommissioner->PerformCommissioningStep(mCommissioneeDeviceProxy, nextStage, mParams, this, GetEndpoint(nextStage), GetCommandTimeout(mCommissioneeDeviceProxy, nextStage)); return CHIP_NO_ERROR; diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp index 1f61c669d04167..5f6179a5acc59e 100644 --- a/src/controller/CHIPDeviceController.cpp +++ b/src/controller/CHIPDeviceController.cpp @@ -820,29 +820,15 @@ CHIP_ERROR DeviceCommissioner::EstablishPASEConnection(NodeId remoteDeviceId, Re if (DeviceLayer::ConnectivityMgr().GetWiFiPAF()->GetWiFiPAFState() != Transport::WiFiPAFBase::State::kConnected) { ChipLogProgress(Controller, "WiFi-PAF: Subscribing the NAN-USD devices"); - static constexpr useconds_t kWiFiStartCheckTimeUsec = WIFI_START_CHECK_TIME_USEC; - static constexpr uint8_t kWiFiStartCheckAttempts = WIFI_START_CHECK_ATTEMPTS; - - DeviceLayer::ConnectivityMgrImpl().StartWiFiManagement(); - { - for (int cnt = 0; cnt < kWiFiStartCheckAttempts; cnt++) - { - if (DeviceLayer::ConnectivityMgrImpl().IsWiFiManagementStarted()) - { - break; - } - usleep(kWiFiStartCheckTimeUsec); - } - } if (!DeviceLayer::ConnectivityMgrImpl().IsWiFiManagementStarted()) { - ChipLogError(NotSpecified, "Wi-Fi Management taking too long to start - device configuration will be reset."); + ChipLogError(Controller, "Wi-Fi Management should have be started now."); + ExitNow(CHIP_ERROR_INTERNAL); } mRendezvousParametersForDeviceDiscoveredOverWiFiPAF = params; - DeviceLayer::ConnectivityMgr().WiFiPAFConnect(this, OnWiFiPAFSubscribeComplete, OnWiFiPAFSubscribeError); + DeviceLayer::ConnectivityMgr().WiFiPAFConnect(params.GetSetupDiscriminator().value(), this, OnWiFiPAFSubscribeComplete, OnWiFiPAFSubscribeError); ExitNow(CHIP_NO_ERROR); } - ChipLogProgress(Controller, "WiFi-PAF: Request to subscribe the NAN-USD device complete"); } #endif session = mSystemState->SessionMgr()->CreateUnauthenticatedSession(params.GetPeerAddress(), params.GetMRPConfig()); @@ -918,16 +904,14 @@ void DeviceCommissioner::OnWiFiPAFSubscribeComplete(void * appState) auto self = static_cast(appState); auto device = self->mDeviceInPASEEstablishment; - ChipLogProgress(Controller, "WiFi-PAF: Subscription Completed!"); if (nullptr != device && device->GetDeviceTransportType() == Transport::Type::kWiFiPAF) { + ChipLogProgress(Controller, "WiFi-PAF: Subscription Completed, dev_id = %lu", device->GetDeviceId()); auto remoteId = device->GetDeviceId(); auto params = self->mRendezvousParametersForDeviceDiscoveredOverWiFiPAF; self->mRendezvousParametersForDeviceDiscoveredOverWiFiPAF = RendezvousParameters(); self->ReleaseCommissioneeDevice(device); - DeviceLayer::ConnectivityMgr().GetWiFiPAF()->SetWiFiPAFState(Transport::WiFiPAFBase::State::kConnected); - chip::DeviceLayer::StackLock stackLock; LogErrorOnFailure(self->EstablishPASEConnection(remoteId, params)); } } @@ -937,9 +921,9 @@ void DeviceCommissioner::OnWiFiPAFSubscribeError(void * appState, CHIP_ERROR err auto self = static_cast(appState); auto device = self->mDeviceInPASEEstablishment; - ChipLogProgress(Controller, "WiFi-PAF: Subscription Error!"); if (nullptr != device && device->GetDeviceTransportType() == Transport::Type::kWiFiPAF) { + ChipLogError(Controller, "WiFi-PAF: Subscription Error, id = %lu, err = %" CHIP_ERROR_FORMAT, device->GetDeviceId(), err.Format()); self->ReleaseCommissioneeDevice(device); self->mRendezvousParametersForDeviceDiscoveredOverWiFiPAF = RendezvousParameters(); if (self->mPairingDelegate != nullptr) diff --git a/src/controller/SetUpCodePairer.cpp b/src/controller/SetUpCodePairer.cpp index 08c6041d5e7ca8..7a4cc97f0b2f16 100644 --- a/src/controller/SetUpCodePairer.cpp +++ b/src/controller/SetUpCodePairer.cpp @@ -262,7 +262,7 @@ CHIP_ERROR SetUpCodePairer::StartDiscoverOverWiFiPAF(SetupPayload & payload) CHIP_ERROR SetUpCodePairer::StopConnectOverWiFiPAF() { - mWaitingForDiscovery[kWiFiPAF] = false; + mWaitingForDiscovery[kWiFiPAFTransport] = false; return CHIP_NO_ERROR; } #endif diff --git a/src/controller/SetUpCodePairer.h b/src/controller/SetUpCodePairer.h index fd9956e1fc0f8b..b901e8ee2a106a 100644 --- a/src/controller/SetUpCodePairer.h +++ b/src/controller/SetUpCodePairer.h @@ -154,9 +154,7 @@ class DLL_EXPORT SetUpCodePairer : public DevicePairingDelegate kBLETransport = 0, kIPTransport, kSoftAPTransport, -#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - kWiFiPAF, -#endif + kWiFiPAFTransport, kTransportTypeCount, }; diff --git a/src/include/platform/CHIPDeviceConfig.h b/src/include/platform/CHIPDeviceConfig.h index e7ad2dffe8ed39..2f746ae38765be 100644 --- a/src/include/platform/CHIPDeviceConfig.h +++ b/src/include/platform/CHIPDeviceConfig.h @@ -428,7 +428,7 @@ /** * CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF * - * Name of the WiFi PAF/DNAN-USD + * Name of the WiFiPAF commission function */ #ifndef CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF #define CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF 0 diff --git a/src/include/platform/CHIPDeviceEvent.h b/src/include/platform/CHIPDeviceEvent.h index 8d18e742c70729..09f4c46b652920 100644 --- a/src/include/platform/CHIPDeviceEvent.h +++ b/src/include/platform/CHIPDeviceEvent.h @@ -282,9 +282,8 @@ enum InternalEventTypes */ kCHIPoBLEConnectionError, kCHIPoBLENotifyConfirm, -#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF kCHIPoWiFiPAFWriteReceived, -#endif + kCHIPoWiFiPAFConnected, }; static_assert(kEventTypeNotSet == 0, "kEventTypeNotSet must be defined as 0"); diff --git a/src/include/platform/ConnectivityManager.h b/src/include/platform/ConnectivityManager.h index 6e4d0c0014c4ea..43ea9606db9574 100644 --- a/src/include/platform/ConnectivityManager.h +++ b/src/include/platform/ConnectivityManager.h @@ -174,12 +174,12 @@ class ConnectivityManager bool IsWiFiStationProvisioned(); void ClearWiFiStationProvision(); CHIP_ERROR GetAndLogWiFiStatsCounters(); -#if CHIP_DEVICE_CONFIG_ENABLE_WPA && CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF CHIP_ERROR SetWiFiPAFAdvertisingEnabled(bool val); typedef void (*OnConnectionCompleteFunct)(void * appState); typedef void (*OnConnectionErrorFunct)(void * appState, CHIP_ERROR err); - CHIP_ERROR WiFiPAFConnect(void * appState, OnConnectionCompleteFunct onSuccess, OnConnectionErrorFunct onError); + CHIP_ERROR WiFiPAFConnect(const SetupDiscriminator & connDiscriminator, void * appState, OnConnectionCompleteFunct onSuccess, OnConnectionErrorFunct onError); CHIP_ERROR WiFiPAFSend(System::PacketBufferHandle && msgBuf); Transport::WiFiPAFBase * GetWiFiPAF(); void SetWiFiPAF(Transport::WiFiPAFBase * pmWiFiPAF); @@ -420,16 +420,16 @@ inline CHIP_ERROR ConnectivityManager::GetAndLogWiFiStatsCounters() return static_cast(this)->_GetAndLogWiFiStatsCounters(); } -#if CHIP_DEVICE_CONFIG_ENABLE_WPA && CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF inline CHIP_ERROR ConnectivityManager::SetWiFiPAFAdvertisingEnabled(bool val) { return static_cast(this)->_SetWiFiPAFAdvertisingEnabled(val); } -inline CHIP_ERROR ConnectivityManager::WiFiPAFConnect(void * appState, OnConnectionCompleteFunct onSuccess, +inline CHIP_ERROR ConnectivityManager::WiFiPAFConnect(const SetupDiscriminator & connDiscriminator, void * appState, OnConnectionCompleteFunct onSuccess, OnConnectionErrorFunct onError) { - return static_cast(this)->_WiFiPAFConnect(appState, onSuccess, onError); + return static_cast(this)->_WiFiPAFConnect(connDiscriminator, appState, onSuccess, onError); } inline CHIP_ERROR ConnectivityManager::WiFiPAFSend(chip::System::PacketBufferHandle && msgBuf) diff --git a/src/platform/Linux/ConnectivityManagerImpl.cpp b/src/platform/Linux/ConnectivityManagerImpl.cpp index 76213b7c1b10ea..97c11f09553866 100644 --- a/src/platform/Linux/ConnectivityManagerImpl.cpp +++ b/src/platform/Linux/ConnectivityManagerImpl.cpp @@ -160,9 +160,16 @@ void ConnectivityManagerImpl::_OnPlatformEvent(const ChipDeviceEvent * event) switch (event->Type) { case DeviceEventType::kCHIPoWiFiPAFWriteReceived: - ChipLogProgress(DeviceLayer, "WiFi-PAF: kCHIPoWiFiPAFWriteReceived"); + ChipLogProgress(DeviceLayer, "WiFi-PAF: event: kCHIPoWiFiPAFWriteReceived"); _GetWiFiPAF()->OnWiFiPAFMessageReceived(System::PacketBufferHandle::Adopt(event->CHIPoWiFiPAFWriteReceived.Data)); break; + case DeviceEventType::kCHIPoWiFiPAFConnected: + ChipLogProgress(DeviceLayer, "WiFi-PAF: event: kCHIPoWiFiPAFConnected"); + if (mOnPafSubscribeComplete != nullptr) + { + mOnPafSubscribeComplete(mAppState); + } + break; } #endif // CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF } @@ -830,8 +837,7 @@ struct PAFPublishSSI uint16_t VendorId; }; #pragma pack(pop) - -CHIP_ERROR ConnectivityManagerImpl::_SetWiFiPAFAdvertisingEnabled(bool val) +CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFPublish() { CHIP_ERROR ret; GAutoPtr err; @@ -855,10 +861,10 @@ CHIP_ERROR ConnectivityManagerImpl::_SetWiFiPAFAdvertisingEnabled(bool val) PafPublish_ssi.VendorId = 0; } strcat(args, NAN_PUBLISH_SSI_TAG); - ret = chip::Encoding::BytesToUppercaseHexString((uint8_t *) &PafPublish_ssi, sizeof(PafPublish_ssi), &args[strlen(args)], + ret = Encoding::BytesToUppercaseHexString((uint8_t *) &PafPublish_ssi, sizeof(PafPublish_ssi), &args[strlen(args)], MAX_PAF_PUBLISH_SSI_BUFLEN - strlen(args)); VerifyOrReturnError(ret == CHIP_NO_ERROR, ret); - ChipLogProgress(DeviceLayer, "WiFi-PAF: SetWiFiPAFAdvertisingEnabled(%d)", val); + ChipLogProgress(DeviceLayer, "WiFi-PAF: publish: [%s]", args); wpa_fi_w1_wpa_supplicant1_interface_call_nanpublish_sync(mWpaSupplicant.iface, args, &publish_id, nullptr, &err.GetReceiver()); ChipLogProgress(DeviceLayer, "WiFi-PAF: publish_id: %d ! ", publish_id); @@ -870,6 +876,27 @@ CHIP_ERROR ConnectivityManagerImpl::_SetWiFiPAFAdvertisingEnabled(bool val) return CHIP_NO_ERROR; } +CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFCancelPublish() +{ + GAutoPtr err; + gchar args[MAX_PAF_PUBLISH_SSI_BUFLEN]; + + ChipLogProgress(DeviceLayer, "WiFi-PAF: cancel publish_id: %d ! ", mpaf_info.peer_publish_id); + snprintf(args, sizeof(args), "publish_id=%d", mpaf_info.peer_publish_id); + wpa_fi_w1_wpa_supplicant1_interface_call_nancancel_publish_sync(mWpaSupplicant.iface, args, nullptr, &err.GetReceiver()); + return CHIP_NO_ERROR; +} + + +CHIP_ERROR ConnectivityManagerImpl::_SetWiFiPAFAdvertisingEnabled(bool val) +{ + if (val == true) { + return _WiFiPAFPublish(); + } else { + return _WiFiPAFCancelPublish(); + } +} + Transport::WiFiPAFBase * ConnectivityManagerImpl::_GetWiFiPAF() { return pmWiFiPAF; @@ -1328,23 +1355,31 @@ void ConnectivityManagerImpl::OnDiscoveryResult(gboolean success, GVariant * dis return; } - GAutoPtr dataValue(g_variant_lookup_value(discov_info, "discov_info", G_VARIANT_TYPE_BYTESTRING)); - size_t bufferLen; - auto buffer = g_variant_get_fixed_array(dataValue.get(), &bufferLen, sizeof(uint8_t)); - - if (((struct wpa_dbus_discov_info *) buffer)->subscribe_id == mpaf_info.subscribe_id) - { - return; - } - memcpy(&mpaf_info, buffer, sizeof(struct wpa_dbus_discov_info)); - ChipLogProgress(DeviceLayer, "WiFi-PAF: subscribe_id: %u", mpaf_info.subscribe_id); - ChipLogProgress(DeviceLayer, "WiFi-PAF: peer_publish_id: %u", mpaf_info.peer_publish_id); - ChipLogProgress(DeviceLayer, "WiFi-PAF: peer_addr: [%02x:%02x:%02x:%02x:%02x:%02x]", mpaf_info.peer_addr[0], - mpaf_info.peer_addr[1], mpaf_info.peer_addr[2], mpaf_info.peer_addr[3], mpaf_info.peer_addr[4], - mpaf_info.peer_addr[5]); - if (mOnPafSubscribeComplete != nullptr) - { - mOnPafSubscribeComplete(mAppState); + if (success == true) { + GAutoPtr dataValue(g_variant_lookup_value(discov_info, "discov_info", G_VARIANT_TYPE_BYTESTRING)); + size_t bufferLen; + auto buffer = g_variant_get_fixed_array(dataValue.get(), &bufferLen, sizeof(uint8_t)); + if (((struct wpa_dbus_discov_info *) buffer)->subscribe_id == mpaf_info.subscribe_id) + { + return; + } + memcpy(&mpaf_info, buffer, sizeof(struct wpa_dbus_discov_info)); + ChipLogProgress(DeviceLayer, "WiFi-PAF: subscribe_id: %u", mpaf_info.subscribe_id); + ChipLogProgress(DeviceLayer, "WiFi-PAF: peer_publish_id: %u", mpaf_info.peer_publish_id); + ChipLogProgress(DeviceLayer, "WiFi-PAF: peer_addr: [%02x:%02x:%02x:%02x:%02x:%02x]", mpaf_info.peer_addr[0], + mpaf_info.peer_addr[1], mpaf_info.peer_addr[2], mpaf_info.peer_addr[3], mpaf_info.peer_addr[4], + mpaf_info.peer_addr[5]); + GetWiFiPAF()->SetWiFiPAFState(Transport::WiFiPAFBase::State::kConnected); + + ChipDeviceEvent event; + event.Type = DeviceEventType::kCHIPoWiFiPAFConnected; + PlatformMgr().PostEventOrDie(&event); + } else { + GetWiFiPAF()->SetWiFiPAFState(Transport::WiFiPAFBase::State::kInitialized); + if (mOnPafSubscribeError != nullptr) + { + mOnPafSubscribeError(mAppState, CHIP_ERROR_TIMEOUT); + } } return; @@ -1352,55 +1387,69 @@ void ConnectivityManagerImpl::OnDiscoveryResult(gboolean success, GVariant * dis void ConnectivityManagerImpl::OnNanReceive(GVariant * obj) { - ChipLogProgress(Controller, "WiFi-PAF: OnNanReceive"); - if (g_variant_n_children(obj) == 0) { return; } - { - GAutoPtr dataValue(g_variant_lookup_value(obj, "nanrx_info", G_VARIANT_TYPE_BYTESTRING)); - size_t bufferLen; - auto buffer = g_variant_get_fixed_array(dataValue.get(), &bufferLen, sizeof(uint8_t)); - - memcpy(&mpaf_nanrx_info, buffer, sizeof(struct wpa_dbus_nanrx_info)); - mpaf_info.subscribe_id = mpaf_nanrx_info.id; - mpaf_info.peer_publish_id = mpaf_nanrx_info.peer_id; - memcpy(mpaf_info.peer_addr, mpaf_nanrx_info.peer_addr, 6); - } - if (mpaf_nanrx_info.ssi_len > 0) - { - GAutoPtr dataValue(g_variant_lookup_value(obj, "ssi", G_VARIANT_TYPE_BYTESTRING)); - size_t bufferLen; - System::PacketBufferHandle buf; - auto rxbuf = g_variant_get_fixed_array(dataValue.get(), &bufferLen, sizeof(uint8_t)); - ChipLogProgress(DeviceLayer, "WiFi-PAF: wpa_supplicant:nan-rx: [buflen: %lu], preparing rxbuf", bufferLen); - buf = System::PacketBufferHandle::NewWithData(rxbuf, bufferLen); + // Read the rx_info + GAutoPtr dataValueInfo(g_variant_lookup_value(obj, "nanrx_info", G_VARIANT_TYPE_BYTESTRING)); + size_t infoBufferLen; + auto infoBuffer = g_variant_get_fixed_array(dataValueInfo.get(), &infoBufferLen, sizeof(uint8_t)); - // Post an event to the Chip queue to deliver the data into the Chip stack. - { - ChipDeviceEvent event; - event.Type = DeviceEventType::kCHIPoWiFiPAFWriteReceived; - event.CHIPoWiFiPAFWriteReceived.Data = std::move(buf).UnsafeRelease(); - PlatformMgr().PostEventOrDie(&event); - } - } - else + memcpy(&mpaf_nanrx_info, infoBuffer, sizeof(struct wpa_dbus_nanrx_info)); + mpaf_info.subscribe_id = mpaf_nanrx_info.id; + mpaf_info.peer_publish_id = mpaf_nanrx_info.peer_id; + memcpy(mpaf_info.peer_addr, mpaf_nanrx_info.peer_addr, 6); + if (mpaf_nanrx_info.ssi_len == 0) { - ChipLogProgress(DeviceLayer, "WiFi-PAF: Skip, ssi length = %u", mpaf_nanrx_info.ssi_len); + return; } + // Read the rx_data + GAutoPtr dataValue(g_variant_lookup_value(obj, "ssi", G_VARIANT_TYPE_BYTESTRING)); + size_t bufferLen; + System::PacketBufferHandle buf; + auto rxbuf = g_variant_get_fixed_array(dataValue.get(), &bufferLen, sizeof(uint8_t)); + ChipLogProgress(DeviceLayer, "WiFi-PAF: wpa_supplicant: nan-rx: [len: %lu]", bufferLen); + buf = System::PacketBufferHandle::NewWithData(rxbuf, bufferLen); + + // Post an event to the Chip queue to deliver the data into the Chip stack. + ChipDeviceEvent event; + event.Type = DeviceEventType::kCHIPoWiFiPAFWriteReceived; + event.CHIPoWiFiPAFWriteReceived.Data = std::move(buf).UnsafeRelease(); + PlatformMgr().PostEventOrDie(&event); return; } -CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFConnect(void * appState, OnConnectionCompleteFunct onSuccess, +CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFConnect(const SetupDiscriminator & connDiscriminator, void * appState, OnConnectionCompleteFunct onSuccess, OnConnectionErrorFunct onError) { ChipLogProgress(Controller, "WiFi-PAF: Try to subscribe the NAN-USD devices"); gchar args[MAX_PAF_SUBSCRIBE_SSI_BUFLEN]; snprintf(args, sizeof(args), "service_name=%s srv_proto_type=%u ttl=%u ", srv_name, NAN_SRV_PROTO_MATTER, NAM_SUBSCRIBE_PERIOD); - mAppState = appState; GAutoPtr err; + CHIP_ERROR ret; + struct PAFPublishSSI PafPublish_ssi; + + VerifyOrReturnError( + (strlen(args) + strlen(NAN_PUBLISH_SSI_TAG) + (sizeof(struct PAFPublishSSI) * 2) < MAX_PAF_PUBLISH_SSI_BUFLEN), + CHIP_ERROR_BUFFER_TOO_SMALL); + mAppState = appState; + PafPublish_ssi.DevOpCode = 0; + PafPublish_ssi.DevInfo = connDiscriminator.GetLongValue(); + if (DeviceLayer::GetDeviceInstanceInfoProvider()->GetProductId(PafPublish_ssi.ProductId) != CHIP_NO_ERROR) + { + PafPublish_ssi.ProductId = 0; + } + if (DeviceLayer::GetDeviceInstanceInfoProvider()->GetVendorId(PafPublish_ssi.VendorId) != CHIP_NO_ERROR) + { + PafPublish_ssi.VendorId = 0; + } + strcat(args, NAN_PUBLISH_SSI_TAG); + ret = Encoding::BytesToUppercaseHexString((uint8_t *) &PafPublish_ssi, sizeof(PafPublish_ssi), &args[strlen(args)], + MAX_PAF_PUBLISH_SSI_BUFLEN - strlen(args)); + VerifyOrReturnError(ret == CHIP_NO_ERROR, ret); + ChipLogProgress(DeviceLayer, "WiFi-PAF: subscribe: [%s]", args); wpa_fi_w1_wpa_supplicant1_interface_call_nansubscribe( mWpaSupplicant.iface, args, nullptr, @@ -1408,11 +1457,18 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFConnect(void * appState, OnConnectio +[](GObject * sourceObject_, GAsyncResult * res_, ConnectivityManagerImpl * self) { return; }), &err.GetReceiver()); mOnPafSubscribeComplete = onSuccess; + mOnPafSubscribeError = onError; g_signal_connect(mWpaSupplicant.iface, "discovery-result", G_CALLBACK(+[](WpaFiW1Wpa_supplicant1Interface * proxy, gboolean success, GVariant * obj, ConnectivityManagerImpl * self) { return self->OnDiscoveryResult(success, obj); }), this); + g_signal_connect(mWpaSupplicant.iface, "nan-receive", + G_CALLBACK(+[](WpaFiW1Wpa_supplicant1Interface * proxy, GVariant * obj, ConnectivityManagerImpl * self) { + return self->OnNanReceive(obj); + }), + this); + return CHIP_NO_ERROR; } @@ -1457,15 +1513,7 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFSend(System::PacketBufferHandle && m MAX_PAF_TX_SSI_BUFLEN - strlen(args)); VerifyOrReturnError(ret == CHIP_NO_ERROR, ret); ChipLogProgress(DeviceLayer, "WiFi-PAF: ssi: [%s]", args); - wpa_fi_w1_wpa_supplicant1_interface_call_nantransmit_sync(mWpaSupplicant.iface, args, nullptr, &err.GetReceiver()); - - g_signal_connect(mWpaSupplicant.iface, "nan-receive", - G_CALLBACK(+[](WpaFiW1Wpa_supplicant1Interface * proxy, GVariant * obj, ConnectivityManagerImpl * self) { - return self->OnNanReceive(obj); - }), - this); - ChipLogProgress(Controller, "WiFi-PAF: Outbound message (%lu) done", msgBuf->DataLength()); return ret; } diff --git a/src/platform/Linux/ConnectivityManagerImpl.h b/src/platform/Linux/ConnectivityManagerImpl.h index b128b90e34d5fd..83689adc91853f 100644 --- a/src/platform/Linux/ConnectivityManagerImpl.h +++ b/src/platform/Linux/ConnectivityManagerImpl.h @@ -141,7 +141,7 @@ class ConnectivityManagerImpl final : public ConnectivityManager, NetworkCommissioning::Internal::WirelessDriver::ConnectCallback * connectCallback); #endif // CHIP_DEVICE_CONFIG_ENABLE_WIFI_PDC #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - CHIP_ERROR _WiFiPAFConnect(void * appState, OnConnectionCompleteFunct onSuccess, OnConnectionErrorFunct onError); + CHIP_ERROR _WiFiPAFConnect(const SetupDiscriminator & connDiscriminator, void * appState, OnConnectionCompleteFunct onSuccess, OnConnectionErrorFunct onError); void OnDiscoveryResult(gboolean success, GVariant * obj); void OnNanReceive(GVariant * obj); @@ -245,9 +245,12 @@ class ConnectivityManagerImpl final : public ConnectivityManager, struct wpa_dbus_nanrx_info mpaf_nanrx_info; OnConnectionCompleteFunct mOnPafSubscribeComplete; + OnConnectionErrorFunct mOnPafSubscribeError; Transport::WiFiPAFBase * pmWiFiPAF; void * mAppState; CHIP_ERROR _SetWiFiPAFAdvertisingEnabled(bool val); + CHIP_ERROR _WiFiPAFPublish(); + CHIP_ERROR _WiFiPAFCancelPublish(); #endif bool _GetBssInfo(const gchar * bssPath, NetworkCommissioning::WiFiScanResponse & result); diff --git a/src/platform/Linux/dbus/wpa/DBusWpaInterface.xml b/src/platform/Linux/dbus/wpa/DBusWpaInterface.xml index a9c2c0b51353e9..49737260413d1c 100644 --- a/src/platform/Linux/dbus/wpa/DBusWpaInterface.xml +++ b/src/platform/Linux/dbus/wpa/DBusWpaInterface.xml @@ -58,11 +58,17 @@ - + + + + + + + diff --git a/src/setup_payload/SetupPayload.h b/src/setup_payload/SetupPayload.h index 34e3e5ec647a20..af7bf18f613b14 100644 --- a/src/setup_payload/SetupPayload.h +++ b/src/setup_payload/SetupPayload.h @@ -101,9 +101,7 @@ enum class RendezvousInformationFlag : uint8_t kSoftAP = 1 << 0, ///< Device supports Wi-Fi softAP kBLE = 1 << 1, ///< Device supports BLE kOnNetwork = 1 << 2, ///< Device supports Setup on network -#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF kWiFiPAF = 1 << 3, ///< Device supports Wi-Fi Public Action Frame for discovery -#endif }; using RendezvousInformationFlags = chip::BitFlags; diff --git a/src/transport/raw/PeerAddress.h b/src/transport/raw/PeerAddress.h index 441bcfdd1d7076..da4f40fc130a8f 100644 --- a/src/transport/raw/PeerAddress.h +++ b/src/transport/raw/PeerAddress.h @@ -53,9 +53,7 @@ enum class Type : uint8_t kUdp, kBle, kTcp, -#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF kWiFiPAF, -#endif }; /** @@ -170,11 +168,9 @@ class PeerAddress #endif snprintf(buf, bufSize, "TCP:[%s%s]:%d", ip_addr, interface, mPort); break; -#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF case Type::kWiFiPAF: snprintf(buf, bufSize, "WiFiPAF"); break; -#endif case Type::kBle: // Note that BLE does not currently use any specific address. snprintf(buf, bufSize, "BLE"); @@ -216,9 +212,8 @@ class PeerAddress { return TCP(addr).SetPort(port).SetInterface(interface); } -#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + static PeerAddress WiFiPAF() { return PeerAddress(Type::kWiFiPAF); } -#endif static PeerAddress Multicast(chip::FabricId fabric, chip::GroupId group) { diff --git a/src/transport/raw/WiFiPAF.cpp b/src/transport/raw/WiFiPAF.cpp index 4d0607b3b4e03d..8ddb645faa518a 100644 --- a/src/transport/raw/WiFiPAF.cpp +++ b/src/transport/raw/WiFiPAF.cpp @@ -18,18 +18,15 @@ /** * @file - * This file implements the CHIP Connection object that maintains a BLE connection. + * This file implements the Matter Connection object that maintains a Wi-Fi PAF connection * */ -// #include #include - #include #include #include #include - #include using namespace chip::System; @@ -54,18 +51,37 @@ CHIP_ERROR WiFiPAFBase::Init(const WiFiPAFListenParameters & param) DeviceLayer::ConnectivityMgr().SetWiFiPAF(this); mState = State::kInitialized; + if (!DeviceLayer::ConnectivityMgrImpl().IsWiFiManagementStarted()) { + ChipLogError(Inet, "Wi-Fi Management has not started, do it now."); + static constexpr useconds_t kWiFiStartCheckTimeUsec = WIFI_START_CHECK_TIME_USEC; + static constexpr uint8_t kWiFiStartCheckAttempts = WIFI_START_CHECK_ATTEMPTS; + DeviceLayer::ConnectivityMgrImpl().StartWiFiManagement(); + { + for (int cnt = 0; cnt < kWiFiStartCheckAttempts; cnt++) + { + if (DeviceLayer::ConnectivityMgrImpl().IsWiFiManagementStarted()) + { + break; + } + usleep(kWiFiStartCheckTimeUsec); + } + } + if (!DeviceLayer::ConnectivityMgrImpl().IsWiFiManagementStarted()) + { + ChipLogError(Inet, "Wi-Fi Management taking too long to start - device configuration will be reset."); + return CHIP_ERROR_INTERNAL; + } + ChipLogProgress(NotSpecified, "Wi-Fi Management is started"); + } return CHIP_NO_ERROR; } CHIP_ERROR WiFiPAFBase::SendMessage(const Transport::PeerAddress & address, System::PacketBufferHandle && msgBuf) { - ChipLogProgress(NotSpecified, "=====> WiFiPAFBase::SendMessage()"); ReturnErrorCodeIf(address.GetTransportType() != Type::kWiFiPAF, CHIP_ERROR_INVALID_ARGUMENT); ReturnErrorCodeIf(mState == State::kNotReady, CHIP_ERROR_INCORRECT_STATE); - DeviceLayer::ConnectivityMgr().WiFiPAFSend(std::move(msgBuf)); - ChipLogProgress(NotSpecified, "<===== WiFiPAFBase::SendMessage()"); return CHIP_NO_ERROR; } diff --git a/src/transport/raw/WiFiPAF.h b/src/transport/raw/WiFiPAF.h index 7e49c09fe81b96..efe67f2e8b8570 100644 --- a/src/transport/raw/WiFiPAF.h +++ b/src/transport/raw/WiFiPAF.h @@ -18,14 +18,13 @@ /** * @file - * This file defines the CHIP Connection object that maintains a Wi-Fi PAF connection. + * This file defines the Matter Connection object that maintains a Wi-Fi PAF connection. * */ #pragma once #include - #include #include #include From 41e334348389824675527161dd2e9e688df94df3 Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Fri, 28 Jun 2024 13:22:21 +0000 Subject: [PATCH 10/33] Restyled by clang-format --- src/controller/AutoCommissioner.cpp | 5 ++-- src/controller/CHIPDeviceController.cpp | 6 ++-- src/include/platform/ConnectivityManager.h | 7 +++-- .../Linux/ConnectivityManagerImpl.cpp | 29 +++++++++++-------- src/platform/Linux/ConnectivityManagerImpl.h | 9 +++--- src/setup_payload/SetupPayload.h | 2 +- src/transport/raw/WiFiPAF.cpp | 7 +++-- src/transport/raw/WiFiPAF.h | 2 +- 8 files changed, 39 insertions(+), 28 deletions(-) diff --git a/src/controller/AutoCommissioner.cpp b/src/controller/AutoCommissioner.cpp index dad29af3c35a21..a90da5e8a3dae3 100644 --- a/src/controller/AutoCommissioner.cpp +++ b/src/controller/AutoCommissioner.cpp @@ -596,8 +596,9 @@ CHIP_ERROR AutoCommissioner::StartCommissioning(DeviceCommissioner * commissione CHIP_ERROR err = CHIP_NO_ERROR; CommissioningStage nextStage = GetNextCommissioningStage(CommissioningStage::kSecurePairing, err); #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - mNeedsNetworkSetup = mNeedsNetworkSetup || (mCommissioneeDeviceProxy->GetSecureSession().Value()->AsSecureSession()->GetPeerAddress().GetTransportType() == - Transport::Type::kWiFiPAF); + mNeedsNetworkSetup = mNeedsNetworkSetup || + (mCommissioneeDeviceProxy->GetSecureSession().Value()->AsSecureSession()->GetPeerAddress().GetTransportType() == + Transport::Type::kWiFiPAF); #endif mCommissioner->PerformCommissioningStep(mCommissioneeDeviceProxy, nextStage, mParams, this, GetEndpoint(nextStage), GetCommandTimeout(mCommissioneeDeviceProxy, nextStage)); diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp index 5f6179a5acc59e..6f59f2752f9f8c 100644 --- a/src/controller/CHIPDeviceController.cpp +++ b/src/controller/CHIPDeviceController.cpp @@ -826,7 +826,8 @@ CHIP_ERROR DeviceCommissioner::EstablishPASEConnection(NodeId remoteDeviceId, Re ExitNow(CHIP_ERROR_INTERNAL); } mRendezvousParametersForDeviceDiscoveredOverWiFiPAF = params; - DeviceLayer::ConnectivityMgr().WiFiPAFConnect(params.GetSetupDiscriminator().value(), this, OnWiFiPAFSubscribeComplete, OnWiFiPAFSubscribeError); + DeviceLayer::ConnectivityMgr().WiFiPAFConnect(params.GetSetupDiscriminator().value(), this, OnWiFiPAFSubscribeComplete, + OnWiFiPAFSubscribeError); ExitNow(CHIP_NO_ERROR); } } @@ -923,7 +924,8 @@ void DeviceCommissioner::OnWiFiPAFSubscribeError(void * appState, CHIP_ERROR err if (nullptr != device && device->GetDeviceTransportType() == Transport::Type::kWiFiPAF) { - ChipLogError(Controller, "WiFi-PAF: Subscription Error, id = %lu, err = %" CHIP_ERROR_FORMAT, device->GetDeviceId(), err.Format()); + ChipLogError(Controller, "WiFi-PAF: Subscription Error, id = %lu, err = %" CHIP_ERROR_FORMAT, device->GetDeviceId(), + err.Format()); self->ReleaseCommissioneeDevice(device); self->mRendezvousParametersForDeviceDiscoveredOverWiFiPAF = RendezvousParameters(); if (self->mPairingDelegate != nullptr) diff --git a/src/include/platform/ConnectivityManager.h b/src/include/platform/ConnectivityManager.h index 43ea9606db9574..754ef84fe7ab38 100644 --- a/src/include/platform/ConnectivityManager.h +++ b/src/include/platform/ConnectivityManager.h @@ -179,7 +179,8 @@ class ConnectivityManager typedef void (*OnConnectionCompleteFunct)(void * appState); typedef void (*OnConnectionErrorFunct)(void * appState, CHIP_ERROR err); - CHIP_ERROR WiFiPAFConnect(const SetupDiscriminator & connDiscriminator, void * appState, OnConnectionCompleteFunct onSuccess, OnConnectionErrorFunct onError); + CHIP_ERROR WiFiPAFConnect(const SetupDiscriminator & connDiscriminator, void * appState, OnConnectionCompleteFunct onSuccess, + OnConnectionErrorFunct onError); CHIP_ERROR WiFiPAFSend(System::PacketBufferHandle && msgBuf); Transport::WiFiPAFBase * GetWiFiPAF(); void SetWiFiPAF(Transport::WiFiPAFBase * pmWiFiPAF); @@ -426,8 +427,8 @@ inline CHIP_ERROR ConnectivityManager::SetWiFiPAFAdvertisingEnabled(bool val) return static_cast(this)->_SetWiFiPAFAdvertisingEnabled(val); } -inline CHIP_ERROR ConnectivityManager::WiFiPAFConnect(const SetupDiscriminator & connDiscriminator, void * appState, OnConnectionCompleteFunct onSuccess, - OnConnectionErrorFunct onError) +inline CHIP_ERROR ConnectivityManager::WiFiPAFConnect(const SetupDiscriminator & connDiscriminator, void * appState, + OnConnectionCompleteFunct onSuccess, OnConnectionErrorFunct onError) { return static_cast(this)->_WiFiPAFConnect(connDiscriminator, appState, onSuccess, onError); } diff --git a/src/platform/Linux/ConnectivityManagerImpl.cpp b/src/platform/Linux/ConnectivityManagerImpl.cpp index 97c11f09553866..ed437dadf45ee5 100644 --- a/src/platform/Linux/ConnectivityManagerImpl.cpp +++ b/src/platform/Linux/ConnectivityManagerImpl.cpp @@ -862,7 +862,7 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFPublish() } strcat(args, NAN_PUBLISH_SSI_TAG); ret = Encoding::BytesToUppercaseHexString((uint8_t *) &PafPublish_ssi, sizeof(PafPublish_ssi), &args[strlen(args)], - MAX_PAF_PUBLISH_SSI_BUFLEN - strlen(args)); + MAX_PAF_PUBLISH_SSI_BUFLEN - strlen(args)); VerifyOrReturnError(ret == CHIP_NO_ERROR, ret); ChipLogProgress(DeviceLayer, "WiFi-PAF: publish: [%s]", args); wpa_fi_w1_wpa_supplicant1_interface_call_nanpublish_sync(mWpaSupplicant.iface, args, &publish_id, nullptr, &err.GetReceiver()); @@ -887,12 +887,14 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFCancelPublish() return CHIP_NO_ERROR; } - CHIP_ERROR ConnectivityManagerImpl::_SetWiFiPAFAdvertisingEnabled(bool val) { - if (val == true) { + if (val == true) + { return _WiFiPAFPublish(); - } else { + } + else + { return _WiFiPAFCancelPublish(); } } @@ -1355,7 +1357,8 @@ void ConnectivityManagerImpl::OnDiscoveryResult(gboolean success, GVariant * dis return; } - if (success == true) { + if (success == true) + { GAutoPtr dataValue(g_variant_lookup_value(discov_info, "discov_info", G_VARIANT_TYPE_BYTESTRING)); size_t bufferLen; auto buffer = g_variant_get_fixed_array(dataValue.get(), &bufferLen, sizeof(uint8_t)); @@ -1374,7 +1377,9 @@ void ConnectivityManagerImpl::OnDiscoveryResult(gboolean success, GVariant * dis ChipDeviceEvent event; event.Type = DeviceEventType::kCHIPoWiFiPAFConnected; PlatformMgr().PostEventOrDie(&event); - } else { + } + else + { GetWiFiPAF()->SetWiFiPAFState(Transport::WiFiPAFBase::State::kInitialized); if (mOnPafSubscribeError != nullptr) { @@ -1421,8 +1426,8 @@ void ConnectivityManagerImpl::OnNanReceive(GVariant * obj) return; } -CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFConnect(const SetupDiscriminator & connDiscriminator, void * appState, OnConnectionCompleteFunct onSuccess, - OnConnectionErrorFunct onError) +CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFConnect(const SetupDiscriminator & connDiscriminator, void * appState, + OnConnectionCompleteFunct onSuccess, OnConnectionErrorFunct onError) { ChipLogProgress(Controller, "WiFi-PAF: Try to subscribe the NAN-USD devices"); gchar args[MAX_PAF_SUBSCRIBE_SSI_BUFLEN]; @@ -1434,9 +1439,9 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFConnect(const SetupDiscriminator & c VerifyOrReturnError( (strlen(args) + strlen(NAN_PUBLISH_SSI_TAG) + (sizeof(struct PAFPublishSSI) * 2) < MAX_PAF_PUBLISH_SSI_BUFLEN), CHIP_ERROR_BUFFER_TOO_SMALL); - mAppState = appState; + mAppState = appState; PafPublish_ssi.DevOpCode = 0; - PafPublish_ssi.DevInfo = connDiscriminator.GetLongValue(); + PafPublish_ssi.DevInfo = connDiscriminator.GetLongValue(); if (DeviceLayer::GetDeviceInstanceInfoProvider()->GetProductId(PafPublish_ssi.ProductId) != CHIP_NO_ERROR) { PafPublish_ssi.ProductId = 0; @@ -1447,7 +1452,7 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFConnect(const SetupDiscriminator & c } strcat(args, NAN_PUBLISH_SSI_TAG); ret = Encoding::BytesToUppercaseHexString((uint8_t *) &PafPublish_ssi, sizeof(PafPublish_ssi), &args[strlen(args)], - MAX_PAF_PUBLISH_SSI_BUFLEN - strlen(args)); + MAX_PAF_PUBLISH_SSI_BUFLEN - strlen(args)); VerifyOrReturnError(ret == CHIP_NO_ERROR, ret); ChipLogProgress(DeviceLayer, "WiFi-PAF: subscribe: [%s]", args); @@ -1457,7 +1462,7 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFConnect(const SetupDiscriminator & c +[](GObject * sourceObject_, GAsyncResult * res_, ConnectivityManagerImpl * self) { return; }), &err.GetReceiver()); mOnPafSubscribeComplete = onSuccess; - mOnPafSubscribeError = onError; + mOnPafSubscribeError = onError; g_signal_connect(mWpaSupplicant.iface, "discovery-result", G_CALLBACK(+[](WpaFiW1Wpa_supplicant1Interface * proxy, gboolean success, GVariant * obj, ConnectivityManagerImpl * self) { return self->OnDiscoveryResult(success, obj); }), diff --git a/src/platform/Linux/ConnectivityManagerImpl.h b/src/platform/Linux/ConnectivityManagerImpl.h index 83689adc91853f..0f14eb737dfe9b 100644 --- a/src/platform/Linux/ConnectivityManagerImpl.h +++ b/src/platform/Linux/ConnectivityManagerImpl.h @@ -141,7 +141,8 @@ class ConnectivityManagerImpl final : public ConnectivityManager, NetworkCommissioning::Internal::WirelessDriver::ConnectCallback * connectCallback); #endif // CHIP_DEVICE_CONFIG_ENABLE_WIFI_PDC #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - CHIP_ERROR _WiFiPAFConnect(const SetupDiscriminator & connDiscriminator, void * appState, OnConnectionCompleteFunct onSuccess, OnConnectionErrorFunct onError); + CHIP_ERROR _WiFiPAFConnect(const SetupDiscriminator & connDiscriminator, void * appState, OnConnectionCompleteFunct onSuccess, + OnConnectionErrorFunct onError); void OnDiscoveryResult(gboolean success, GVariant * obj); void OnNanReceive(GVariant * obj); @@ -245,12 +246,12 @@ class ConnectivityManagerImpl final : public ConnectivityManager, struct wpa_dbus_nanrx_info mpaf_nanrx_info; OnConnectionCompleteFunct mOnPafSubscribeComplete; - OnConnectionErrorFunct mOnPafSubscribeError; + OnConnectionErrorFunct mOnPafSubscribeError; Transport::WiFiPAFBase * pmWiFiPAF; void * mAppState; CHIP_ERROR _SetWiFiPAFAdvertisingEnabled(bool val); - CHIP_ERROR _WiFiPAFPublish(); - CHIP_ERROR _WiFiPAFCancelPublish(); + CHIP_ERROR _WiFiPAFPublish(); + CHIP_ERROR _WiFiPAFCancelPublish(); #endif bool _GetBssInfo(const gchar * bssPath, NetworkCommissioning::WiFiScanResponse & result); diff --git a/src/setup_payload/SetupPayload.h b/src/setup_payload/SetupPayload.h index af7bf18f613b14..3d5d101fbf4c6e 100644 --- a/src/setup_payload/SetupPayload.h +++ b/src/setup_payload/SetupPayload.h @@ -101,7 +101,7 @@ enum class RendezvousInformationFlag : uint8_t kSoftAP = 1 << 0, ///< Device supports Wi-Fi softAP kBLE = 1 << 1, ///< Device supports BLE kOnNetwork = 1 << 2, ///< Device supports Setup on network - kWiFiPAF = 1 << 3, ///< Device supports Wi-Fi Public Action Frame for discovery + kWiFiPAF = 1 << 3, ///< Device supports Wi-Fi Public Action Frame for discovery }; using RendezvousInformationFlags = chip::BitFlags; diff --git a/src/transport/raw/WiFiPAF.cpp b/src/transport/raw/WiFiPAF.cpp index 8ddb645faa518a..97b465dd261e9b 100644 --- a/src/transport/raw/WiFiPAF.cpp +++ b/src/transport/raw/WiFiPAF.cpp @@ -22,12 +22,12 @@ * */ -#include +#include #include #include #include #include -#include +#include using namespace chip::System; @@ -51,7 +51,8 @@ CHIP_ERROR WiFiPAFBase::Init(const WiFiPAFListenParameters & param) DeviceLayer::ConnectivityMgr().SetWiFiPAF(this); mState = State::kInitialized; - if (!DeviceLayer::ConnectivityMgrImpl().IsWiFiManagementStarted()) { + if (!DeviceLayer::ConnectivityMgrImpl().IsWiFiManagementStarted()) + { ChipLogError(Inet, "Wi-Fi Management has not started, do it now."); static constexpr useconds_t kWiFiStartCheckTimeUsec = WIFI_START_CHECK_TIME_USEC; static constexpr uint8_t kWiFiStartCheckAttempts = WIFI_START_CHECK_ATTEMPTS; diff --git a/src/transport/raw/WiFiPAF.h b/src/transport/raw/WiFiPAF.h index efe67f2e8b8570..bd54d22cc3e26f 100644 --- a/src/transport/raw/WiFiPAF.h +++ b/src/transport/raw/WiFiPAF.h @@ -24,11 +24,11 @@ #pragma once -#include #include #include #include #include +#include namespace chip { namespace Transport { From 5f21574d5f369fa4b7e21c2602b38f20316748c7 Mon Sep 17 00:00:00 2001 From: "Lo,Chin-Ran" Date: Mon, 1 Jul 2024 15:43:01 +0800 Subject: [PATCH 11/33] Change by following the review's comment: - Unconditional functions in SetUpCodePairer - Change the description of the comment Signed-off-by: Lo,Chin-Ran --- src/controller/SetUpCodePairer.cpp | 4 ---- src/controller/SetUpCodePairer.h | 2 -- src/include/platform/CHIPDeviceConfig.h | 2 +- 3 files changed, 1 insertion(+), 7 deletions(-) diff --git a/src/controller/SetUpCodePairer.cpp b/src/controller/SetUpCodePairer.cpp index 7a4cc97f0b2f16..960b955586b80d 100644 --- a/src/controller/SetUpCodePairer.cpp +++ b/src/controller/SetUpCodePairer.cpp @@ -129,7 +129,6 @@ CHIP_ERROR SetUpCodePairer::Connect(SetupPayload & payload) } VerifyOrReturnError(searchOverAll || CHIP_NO_ERROR == err || CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE == err, err); } -#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF if (searchOverAll || payload.rendezvousInformation.Value().Has(RendezvousInformationFlag::kWiFiPAF)) { ChipLogProgress(Controller, "WiFi-PAF: has RendezvousInformationFlag::kWiFiPAF"); @@ -139,7 +138,6 @@ CHIP_ERROR SetUpCodePairer::Connect(SetupPayload & payload) } VerifyOrReturnError(searchOverAll || CHIP_NO_ERROR == err || CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE == err, err); } -#endif } // We always want to search on network because any node that has already been commissioned will use on-network regardless of the @@ -254,7 +252,6 @@ CHIP_ERROR SetUpCodePairer::StopConnectOverSoftAP() return CHIP_NO_ERROR; } -#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF CHIP_ERROR SetUpCodePairer::StartDiscoverOverWiFiPAF(SetupPayload & payload) { return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; @@ -265,7 +262,6 @@ CHIP_ERROR SetUpCodePairer::StopConnectOverWiFiPAF() mWaitingForDiscovery[kWiFiPAFTransport] = false; return CHIP_NO_ERROR; } -#endif bool SetUpCodePairer::ConnectToDiscoveredDevice() { diff --git a/src/controller/SetUpCodePairer.h b/src/controller/SetUpCodePairer.h index b901e8ee2a106a..81567bc6042f8e 100644 --- a/src/controller/SetUpCodePairer.h +++ b/src/controller/SetUpCodePairer.h @@ -111,10 +111,8 @@ class DLL_EXPORT SetUpCodePairer : public DevicePairingDelegate CHIP_ERROR StopConnectOverIP(); CHIP_ERROR StartDiscoverOverSoftAP(SetupPayload & payload); CHIP_ERROR StopConnectOverSoftAP(); -#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF CHIP_ERROR StartDiscoverOverWiFiPAF(SetupPayload & payload); CHIP_ERROR StopConnectOverWiFiPAF(); -#endif // Returns whether we have kicked off a new connection attempt. bool ConnectToDiscoveredDevice(); diff --git a/src/include/platform/CHIPDeviceConfig.h b/src/include/platform/CHIPDeviceConfig.h index 2f746ae38765be..ddc9022f382715 100644 --- a/src/include/platform/CHIPDeviceConfig.h +++ b/src/include/platform/CHIPDeviceConfig.h @@ -428,7 +428,7 @@ /** * CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF * - * Name of the WiFiPAF commission function + * Enable support for the WiFiPAF commissioning function */ #ifndef CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF #define CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF 0 From ad1b7d5f0d98de7b5a98c097e680a986f01af2c6 Mon Sep 17 00:00:00 2001 From: "Lo,Chin-Ran" Date: Wed, 3 Jul 2024 14:58:17 +0800 Subject: [PATCH 12/33] * Add the identifier to distinguish connections * Unconditional the SetupCode verification Signed-off-by: Lo,Chin-Ran --- examples/chip-tool/commands/pairing/PairingCommand.cpp | 2 +- src/controller/CHIPDeviceController.cpp | 2 +- src/setup_payload/SetupPayload.cpp | 5 +---- src/transport/raw/PeerAddress.h | 6 +++++- 4 files changed, 8 insertions(+), 7 deletions(-) diff --git a/examples/chip-tool/commands/pairing/PairingCommand.cpp b/examples/chip-tool/commands/pairing/PairingCommand.cpp index a346b55e2813a4..245c9ed57ff82c 100644 --- a/examples/chip-tool/commands/pairing/PairingCommand.cpp +++ b/examples/chip-tool/commands/pairing/PairingCommand.cpp @@ -82,7 +82,7 @@ CHIP_ERROR PairingCommand::RunInternal(NodeId remoteId) break; #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF case PairingMode::WiFiPAF: - err = Pair(remoteId, PeerAddress::WiFiPAF()); + err = Pair(remoteId, PeerAddress::WiFiPAF(remoteId)); break; #endif case PairingMode::AlreadyDiscovered: diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp index 6f59f2752f9f8c..37c0ead6a6faad 100644 --- a/src/controller/CHIPDeviceController.cpp +++ b/src/controller/CHIPDeviceController.cpp @@ -736,7 +736,7 @@ CHIP_ERROR DeviceCommissioner::EstablishPASEConnection(NodeId remoteDeviceId, Re #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF else if (params.GetPeerAddress().GetTransportType() == Transport::Type::kWiFiPAF) { - peerAddress = Transport::PeerAddress::WiFiPAF(); + peerAddress = Transport::PeerAddress::WiFiPAF(remoteDeviceId); } #endif // CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF diff --git a/src/setup_payload/SetupPayload.cpp b/src/setup_payload/SetupPayload.cpp index 7a7423a35ba146..2f51276dd1fefe 100644 --- a/src/setup_payload/SetupPayload.cpp +++ b/src/setup_payload/SetupPayload.cpp @@ -62,11 +62,8 @@ bool PayloadContents::isValidQRCodePayload(ValidationMode mode) const if (mode == ValidationMode::kProduce) { chip::RendezvousInformationFlags valid(RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kOnNetwork, - RendezvousInformationFlag::kSoftAP -#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - , + RendezvousInformationFlag::kSoftAP , RendezvousInformationFlag::kWiFiPAF -#endif ); VerifyOrReturnValue(rendezvousInformation.Value().HasOnly(valid), false); } diff --git a/src/transport/raw/PeerAddress.h b/src/transport/raw/PeerAddress.h index da4f40fc130a8f..dc3f879aa2cd21 100644 --- a/src/transport/raw/PeerAddress.h +++ b/src/transport/raw/PeerAddress.h @@ -65,6 +65,7 @@ class PeerAddress PeerAddress() : mIPAddress(Inet::IPAddress::Any), mTransportType(Type::kUndefined) {} PeerAddress(const Inet::IPAddress & addr, Type type) : mIPAddress(addr), mTransportType(type) {} PeerAddress(Type type) : mTransportType(type) {} + PeerAddress(Type type, NodeId remoteId) : mTransportType(type), mRemoteId(remoteId) {} PeerAddress(PeerAddress &&) = default; PeerAddress(const PeerAddress &) = default; @@ -78,6 +79,8 @@ class PeerAddress return *this; } + NodeId GetRemoteId() const { return mRemoteId; } + Type GetTransportType() const { return mTransportType; } PeerAddress & SetTransportType(Type type) { @@ -213,7 +216,7 @@ class PeerAddress return TCP(addr).SetPort(port).SetInterface(interface); } - static PeerAddress WiFiPAF() { return PeerAddress(Type::kWiFiPAF); } + static PeerAddress WiFiPAF(NodeId remoteId) { return PeerAddress(Type::kWiFiPAF); } static PeerAddress Multicast(chip::FabricId fabric, chip::GroupId group) { @@ -243,6 +246,7 @@ class PeerAddress Type mTransportType = Type::kUndefined; uint16_t mPort = CHIP_PORT; ///< Relevant for UDP data sending. Inet::InterfaceId mInterface = Inet::InterfaceId::Null(); + NodeId mRemoteId = 0; }; } // namespace Transport From 6a7a368ab0444df49863a9c27a47e91cfb37f742 Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Wed, 3 Jul 2024 07:00:50 +0000 Subject: [PATCH 13/33] Restyled by clang-format --- src/setup_payload/SetupPayload.cpp | 4 +--- src/transport/raw/PeerAddress.h | 2 +- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/src/setup_payload/SetupPayload.cpp b/src/setup_payload/SetupPayload.cpp index 2f51276dd1fefe..9683da21f8a7f9 100644 --- a/src/setup_payload/SetupPayload.cpp +++ b/src/setup_payload/SetupPayload.cpp @@ -62,9 +62,7 @@ bool PayloadContents::isValidQRCodePayload(ValidationMode mode) const if (mode == ValidationMode::kProduce) { chip::RendezvousInformationFlags valid(RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kOnNetwork, - RendezvousInformationFlag::kSoftAP , - RendezvousInformationFlag::kWiFiPAF - ); + RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kWiFiPAF); VerifyOrReturnValue(rendezvousInformation.Value().HasOnly(valid), false); } diff --git a/src/transport/raw/PeerAddress.h b/src/transport/raw/PeerAddress.h index dc3f879aa2cd21..0720bb4e50d31e 100644 --- a/src/transport/raw/PeerAddress.h +++ b/src/transport/raw/PeerAddress.h @@ -246,7 +246,7 @@ class PeerAddress Type mTransportType = Type::kUndefined; uint16_t mPort = CHIP_PORT; ///< Relevant for UDP data sending. Inet::InterfaceId mInterface = Inet::InterfaceId::Null(); - NodeId mRemoteId = 0; + NodeId mRemoteId = 0; }; } // namespace Transport From 3bf4c67708bb4ac38c4591d74f480a6bb6f385b5 Mon Sep 17 00:00:00 2001 From: "Lo,Chin-Ran" Date: Wed, 3 Jul 2024 18:21:27 +0800 Subject: [PATCH 14/33] Add RendezvousInformationFlag::kWiFiPAF to tests of TestQRCode Signed-off-by: Lo,Chin-Ran --- src/setup_payload/tests/TestQRCode.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/setup_payload/tests/TestQRCode.cpp b/src/setup_payload/tests/TestQRCode.cpp index 44c50d9e1e8f5b..d2b1e0803b0814 100644 --- a/src/setup_payload/tests/TestQRCode.cpp +++ b/src/setup_payload/tests/TestQRCode.cpp @@ -305,7 +305,7 @@ TEST(TestQRCode, TestSetupPayloadVerify) // test invalid rendezvousInformation test_payload = payload; RendezvousInformationFlags invalid = RendezvousInformationFlags( - RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kOnNetwork); + RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kOnNetwork, RendezvousInformationFlag::kWiFiPAF); invalid.SetRaw(static_cast(invalid.Raw() + 1)); test_payload.rendezvousInformation.SetValue(invalid); EXPECT_EQ(test_payload.isValidQRCodePayload(), false); From 2444a5625732672f2c431ccbe159eacb3034d92c Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Wed, 3 Jul 2024 10:23:15 +0000 Subject: [PATCH 15/33] Restyled by clang-format --- src/setup_payload/tests/TestQRCode.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/setup_payload/tests/TestQRCode.cpp b/src/setup_payload/tests/TestQRCode.cpp index d2b1e0803b0814..8703eb5989d65e 100644 --- a/src/setup_payload/tests/TestQRCode.cpp +++ b/src/setup_payload/tests/TestQRCode.cpp @@ -303,9 +303,10 @@ TEST(TestQRCode, TestSetupPayloadVerify) EXPECT_EQ(test_payload.isValidQRCodePayload(), false); // test invalid rendezvousInformation - test_payload = payload; - RendezvousInformationFlags invalid = RendezvousInformationFlags( - RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kOnNetwork, RendezvousInformationFlag::kWiFiPAF); + test_payload = payload; + RendezvousInformationFlags invalid = + RendezvousInformationFlags(RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kSoftAP, + RendezvousInformationFlag::kOnNetwork, RendezvousInformationFlag::kWiFiPAF); invalid.SetRaw(static_cast(invalid.Raw() + 1)); test_payload.rendezvousInformation.SetValue(invalid); EXPECT_EQ(test_payload.isValidQRCodePayload(), false); From 3160495c19eb97fa4ba3bb44cc95b86114163559 Mon Sep 17 00:00:00 2001 From: "Lo,Chin-Ran" Date: Thu, 4 Jul 2024 18:20:36 +0800 Subject: [PATCH 16/33] * Add code-wifi to do WiFiPAF by using code. example: - Linux DUT: sudo ./chip-all-clusters-app --wifi --wifipaf - Controller: sudo ./chip-tool pairing code-wifi 1 ap_ssid ap_pwd MT:-24J0SGJ10KA0648G00 Signed-off-by: Lo,Chin-Ran --- examples/platform/linux/AppMain.cpp | 2 +- src/controller/SetUpCodePairer.cpp | 47 +++++++++++++++++++++++++++++ src/controller/SetUpCodePairer.h | 6 ++++ 3 files changed, 54 insertions(+), 1 deletion(-) diff --git a/examples/platform/linux/AppMain.cpp b/examples/platform/linux/AppMain.cpp index 2023a766d8dbf4..01bf77c4e29566 100644 --- a/examples/platform/linux/AppMain.cpp +++ b/examples/platform/linux/AppMain.cpp @@ -367,7 +367,7 @@ int ChipLinuxAppInit(int argc, char * const argv[], OptionSet * customOptions, #if CONFIG_NETWORK_LAYER_BLE RendezvousInformationFlags rendezvousFlags = RendezvousInformationFlag::kBLE; #else // CONFIG_NETWORK_LAYER_BLE - RendezvousInformationFlag rendezvousFlags = RendezvousInformationFlag::kOnNetwork; + RendezvousInformationFlags rendezvousFlags = RendezvousInformationFlag::kOnNetwork; #endif // CONFIG_NETWORK_LAYER_BLE #ifdef CONFIG_RENDEZVOUS_MODE diff --git a/src/controller/SetUpCodePairer.cpp b/src/controller/SetUpCodePairer.cpp index 960b955586b80d..e62bac4fb7f0c9 100644 --- a/src/controller/SetUpCodePairer.cpp +++ b/src/controller/SetUpCodePairer.cpp @@ -254,7 +254,22 @@ CHIP_ERROR SetUpCodePairer::StopConnectOverSoftAP() CHIP_ERROR SetUpCodePairer::StartDiscoverOverWiFiPAF(SetupPayload & payload) { +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + ChipLogProgress(Controller, "Starting commissioning discovery over WiFiPAF"); + + VerifyOrReturnError(mCommissioner != nullptr, CHIP_ERROR_INCORRECT_STATE); + mWaitingForDiscovery[kWiFiPAFTransport] = true; + CHIP_ERROR err = DeviceLayer::ConnectivityMgr().WiFiPAFConnect(payload.discriminator, this, OnWiFiPAFSubscribeComplete, + OnWiFiPAFSubscribeError); + if (err != CHIP_NO_ERROR) + { + ChipLogError(Controller, "Commissioning discovery over WiFiPAF failed, err = %" CHIP_ERROR_FORMAT, err.Format()); + mWaitingForDiscovery[kWiFiPAFTransport] = false; + } + return err; +#else return CHIP_ERROR_UNSUPPORTED_CHIP_FEATURE; +#endif // CONFIG_NETWORK_LAYER_BLE } CHIP_ERROR SetUpCodePairer::StopConnectOverWiFiPAF() @@ -355,6 +370,37 @@ void SetUpCodePairer::OnBLEDiscoveryError(CHIP_ERROR err) } #endif // CONFIG_NETWORK_LAYER_BLE +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +void SetUpCodePairer::OnDiscoveredDeviceOverWifiPAF() +{ + ChipLogProgress(Controller, "Discovered device to be commissioned over WiFiPAF, RemoteId: %lu", mRemoteId); + + mWaitingForDiscovery[kWiFiPAFTransport] = false; + auto param = SetUpCodePairerParameters(); + param.SetPeerAddress(Transport::PeerAddress(Transport::Type::kWiFiPAF, mRemoteId)); + mDiscoveredParameters.emplace_front(param); + ConnectToDiscoveredDevice(); +} + +void SetUpCodePairer::OnWifiPAFDiscoveryError(CHIP_ERROR err) +{ + ChipLogError(Controller, "Commissioning discovery over WiFiPAF failed: %" CHIP_ERROR_FORMAT, err.Format()); + mWaitingForDiscovery[kWiFiPAFTransport] = false; + LogErrorOnFailure(err); +} + +void SetUpCodePairer::OnWiFiPAFSubscribeComplete(void * appState) +{ + (static_cast(appState))->OnDiscoveredDeviceOverWifiPAF(); +} + +void SetUpCodePairer::OnWiFiPAFSubscribeError(void * appState, CHIP_ERROR err) +{ + static_cast(appState)->OnWifiPAFDiscoveryError(err); +} +#endif + + bool SetUpCodePairer::IdIsPresent(uint16_t vendorOrProductID) { return vendorOrProductID != kNotAvailable; @@ -493,6 +539,7 @@ void SetUpCodePairer::ResetDiscoveryState() StopConnectOverBle(); StopConnectOverIP(); StopConnectOverSoftAP(); + StopConnectOverWiFiPAF(); // Just in case any of those failed to reset the waiting state properly. for (auto & waiting : mWaitingForDiscovery) diff --git a/src/controller/SetUpCodePairer.h b/src/controller/SetUpCodePairer.h index 81567bc6042f8e..fe679e5ea04b42 100644 --- a/src/controller/SetUpCodePairer.h +++ b/src/controller/SetUpCodePairer.h @@ -168,6 +168,12 @@ class DLL_EXPORT SetUpCodePairer : public DevicePairingDelegate static void OnDiscoveredDeviceOverBleSuccess(void * appState, BLE_CONNECTION_OBJECT connObj); static void OnDiscoveredDeviceOverBleError(void * appState, CHIP_ERROR err); #endif // CONFIG_NETWORK_LAYER_BLE +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + void OnDiscoveredDeviceOverWifiPAF(); + void OnWifiPAFDiscoveryError(CHIP_ERROR err); + static void OnWiFiPAFSubscribeComplete(void * appState); + static void OnWiFiPAFSubscribeError(void * appState, CHIP_ERROR err); +#endif bool NodeMatchesCurrentFilter(const Dnssd::DiscoveredNodeData & nodeData) const; static bool IdIsPresent(uint16_t vendorOrProductID); From 0fae787467f95fcb508f5da28a8d596e91f9d33e Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Thu, 4 Jul 2024 10:25:49 +0000 Subject: [PATCH 17/33] Restyled by clang-format --- src/controller/SetUpCodePairer.cpp | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/controller/SetUpCodePairer.cpp b/src/controller/SetUpCodePairer.cpp index e62bac4fb7f0c9..8c2a6985bf0478 100644 --- a/src/controller/SetUpCodePairer.cpp +++ b/src/controller/SetUpCodePairer.cpp @@ -260,7 +260,7 @@ CHIP_ERROR SetUpCodePairer::StartDiscoverOverWiFiPAF(SetupPayload & payload) VerifyOrReturnError(mCommissioner != nullptr, CHIP_ERROR_INCORRECT_STATE); mWaitingForDiscovery[kWiFiPAFTransport] = true; CHIP_ERROR err = DeviceLayer::ConnectivityMgr().WiFiPAFConnect(payload.discriminator, this, OnWiFiPAFSubscribeComplete, - OnWiFiPAFSubscribeError); + OnWiFiPAFSubscribeError); if (err != CHIP_NO_ERROR) { ChipLogError(Controller, "Commissioning discovery over WiFiPAF failed, err = %" CHIP_ERROR_FORMAT, err.Format()); @@ -376,7 +376,7 @@ void SetUpCodePairer::OnDiscoveredDeviceOverWifiPAF() ChipLogProgress(Controller, "Discovered device to be commissioned over WiFiPAF, RemoteId: %lu", mRemoteId); mWaitingForDiscovery[kWiFiPAFTransport] = false; - auto param = SetUpCodePairerParameters(); + auto param = SetUpCodePairerParameters(); param.SetPeerAddress(Transport::PeerAddress(Transport::Type::kWiFiPAF, mRemoteId)); mDiscoveredParameters.emplace_front(param); ConnectToDiscoveredDevice(); @@ -400,7 +400,6 @@ void SetUpCodePairer::OnWiFiPAFSubscribeError(void * appState, CHIP_ERROR err) } #endif - bool SetUpCodePairer::IdIsPresent(uint16_t vendorOrProductID) { return vendorOrProductID != kNotAvailable; From 35afdf6c0430f5518c1ff9578af2eabc51889f50 Mon Sep 17 00:00:00 2001 From: crlonxp <88241281+crlonxp@users.noreply.github.com> Date: Mon, 8 Jul 2024 10:45:23 +0800 Subject: [PATCH 18/33] Update src/transport/raw/PeerAddress.h Co-authored-by: Boris Zbarsky --- src/transport/raw/PeerAddress.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/transport/raw/PeerAddress.h b/src/transport/raw/PeerAddress.h index 0720bb4e50d31e..896648f76f537a 100644 --- a/src/transport/raw/PeerAddress.h +++ b/src/transport/raw/PeerAddress.h @@ -172,7 +172,7 @@ class PeerAddress snprintf(buf, bufSize, "TCP:[%s%s]:%d", ip_addr, interface, mPort); break; case Type::kWiFiPAF: - snprintf(buf, bufSize, "WiFiPAF"); + snprintf(buf, bufSize, "Wi-Fi PAF"); break; case Type::kBle: // Note that BLE does not currently use any specific address. From 9f06e17e6c8a8641078fa93a53c645706f7b1259 Mon Sep 17 00:00:00 2001 From: crlonxp <88241281+crlonxp@users.noreply.github.com> Date: Mon, 8 Jul 2024 10:46:50 +0800 Subject: [PATCH 19/33] Update examples/chip-tool/commands/payload/SetupPayloadParseCommand.cpp Co-authored-by: Boris Zbarsky --- .../chip-tool/commands/payload/SetupPayloadParseCommand.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/chip-tool/commands/payload/SetupPayloadParseCommand.cpp b/examples/chip-tool/commands/payload/SetupPayloadParseCommand.cpp index 11d4f0862b735e..de1afad1835385 100644 --- a/examples/chip-tool/commands/payload/SetupPayloadParseCommand.cpp +++ b/examples/chip-tool/commands/payload/SetupPayloadParseCommand.cpp @@ -114,7 +114,7 @@ CHIP_ERROR SetupPayloadParseCommand::Print(chip::SetupPayload payload) { humanFlags.Add(", "); } - humanFlags.Add("WIFIPAF"); + humanFlags.Add("Wi-Fi PAF"); } } else From 509fc101b02142a462fb2c2a7e435a6198b7e499 Mon Sep 17 00:00:00 2001 From: crlonxp <88241281+crlonxp@users.noreply.github.com> Date: Mon, 8 Jul 2024 10:48:04 +0800 Subject: [PATCH 20/33] Update src/include/platform/CHIPDeviceConfig.h Co-authored-by: Boris Zbarsky --- src/include/platform/CHIPDeviceConfig.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/include/platform/CHIPDeviceConfig.h b/src/include/platform/CHIPDeviceConfig.h index ddc9022f382715..bc13696c8c36a2 100644 --- a/src/include/platform/CHIPDeviceConfig.h +++ b/src/include/platform/CHIPDeviceConfig.h @@ -428,7 +428,7 @@ /** * CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF * - * Enable support for the WiFiPAF commissioning function + * Enable support for commissioning using Wi-Fi Public Action Frame as the transport. */ #ifndef CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF #define CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF 0 From 402325093efc0124178da1bfe379998a3c420135 Mon Sep 17 00:00:00 2001 From: "Lo,Chin-Ran" Date: Tue, 9 Jul 2024 21:14:09 +0800 Subject: [PATCH 21/33] Change by following the review's comment: * Add to end of the queue in OnDiscoveredDeviceOverWifiPAF() * Factor out the long expression into local Signed-off-by: Lo,Chin-Ran --- src/controller/AutoCommissioner.cpp | 15 +++++++-------- src/controller/SetUpCodePairer.cpp | 2 +- 2 files changed, 8 insertions(+), 9 deletions(-) diff --git a/src/controller/AutoCommissioner.cpp b/src/controller/AutoCommissioner.cpp index a90da5e8a3dae3..fb10de325dd62e 100644 --- a/src/controller/AutoCommissioner.cpp +++ b/src/controller/AutoCommissioner.cpp @@ -590,16 +590,15 @@ CHIP_ERROR AutoCommissioner::StartCommissioning(DeviceCommissioner * commissione mStopCommissioning = false; mCommissioner = commissioner; mCommissioneeDeviceProxy = proxy; - mNeedsNetworkSetup = - (mCommissioneeDeviceProxy->GetSecureSession().Value()->AsSecureSession()->GetPeerAddress().GetTransportType() == - Transport::Type::kBle); - CHIP_ERROR err = CHIP_NO_ERROR; - CommissioningStage nextStage = GetNextCommissioningStage(CommissioningStage::kSecurePairing, err); + + auto transportType = mCommissioneeDeviceProxy->GetSecureSession().Value()->AsSecureSession()->GetPeerAddress().GetTransportType(); + mNeedsNetworkSetup = (transportType == Transport::Type::kBle); #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - mNeedsNetworkSetup = mNeedsNetworkSetup || - (mCommissioneeDeviceProxy->GetSecureSession().Value()->AsSecureSession()->GetPeerAddress().GetTransportType() == - Transport::Type::kWiFiPAF); + mNeedsNetworkSetup = mNeedsNetworkSetup || (transportType == Transport::Type::kWiFiPAF); #endif + CHIP_ERROR err = CHIP_NO_ERROR; + CommissioningStage nextStage = GetNextCommissioningStage(CommissioningStage::kSecurePairing, err); + mCommissioner->PerformCommissioningStep(mCommissioneeDeviceProxy, nextStage, mParams, this, GetEndpoint(nextStage), GetCommandTimeout(mCommissioneeDeviceProxy, nextStage)); return CHIP_NO_ERROR; diff --git a/src/controller/SetUpCodePairer.cpp b/src/controller/SetUpCodePairer.cpp index 8c2a6985bf0478..7c1c6bf270fd79 100644 --- a/src/controller/SetUpCodePairer.cpp +++ b/src/controller/SetUpCodePairer.cpp @@ -378,7 +378,7 @@ void SetUpCodePairer::OnDiscoveredDeviceOverWifiPAF() mWaitingForDiscovery[kWiFiPAFTransport] = false; auto param = SetUpCodePairerParameters(); param.SetPeerAddress(Transport::PeerAddress(Transport::Type::kWiFiPAF, mRemoteId)); - mDiscoveredParameters.emplace_front(param); + mDiscoveredParameters.emplace_back(param); ConnectToDiscoveredDevice(); } From 50030858c57692efdd299ddab34a6d00cffb27f2 Mon Sep 17 00:00:00 2001 From: "Lo,Chin-Ran" Date: Wed, 10 Jul 2024 10:38:54 +0800 Subject: [PATCH 22/33] Remove the redundant LogErrorOnFailure() Signed-off-by: Lo,Chin-Ran --- src/controller/SetUpCodePairer.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/src/controller/SetUpCodePairer.cpp b/src/controller/SetUpCodePairer.cpp index 7c1c6bf270fd79..9cdba641d9c729 100644 --- a/src/controller/SetUpCodePairer.cpp +++ b/src/controller/SetUpCodePairer.cpp @@ -386,7 +386,6 @@ void SetUpCodePairer::OnWifiPAFDiscoveryError(CHIP_ERROR err) { ChipLogError(Controller, "Commissioning discovery over WiFiPAF failed: %" CHIP_ERROR_FORMAT, err.Format()); mWaitingForDiscovery[kWiFiPAFTransport] = false; - LogErrorOnFailure(err); } void SetUpCodePairer::OnWiFiPAFSubscribeComplete(void * appState) From 5a0c41f362af8e04cabe5cd6ead65e27961a404f Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Wed, 10 Jul 2024 02:40:47 +0000 Subject: [PATCH 23/33] Restyled by clang-format --- src/controller/AutoCommissioner.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/controller/AutoCommissioner.cpp b/src/controller/AutoCommissioner.cpp index fb10de325dd62e..0e83d7125cf175 100644 --- a/src/controller/AutoCommissioner.cpp +++ b/src/controller/AutoCommissioner.cpp @@ -591,7 +591,8 @@ CHIP_ERROR AutoCommissioner::StartCommissioning(DeviceCommissioner * commissione mCommissioner = commissioner; mCommissioneeDeviceProxy = proxy; - auto transportType = mCommissioneeDeviceProxy->GetSecureSession().Value()->AsSecureSession()->GetPeerAddress().GetTransportType(); + auto transportType = + mCommissioneeDeviceProxy->GetSecureSession().Value()->AsSecureSession()->GetPeerAddress().GetTransportType(); mNeedsNetworkSetup = (transportType == Transport::Type::kBle); #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF mNeedsNetworkSetup = mNeedsNetworkSetup || (transportType == Transport::Type::kWiFiPAF); From 02dfc418e2976cd14fc4aa069d9bc9c580dc312a Mon Sep 17 00:00:00 2001 From: "Lo,Chin-Ran" Date: Mon, 15 Jul 2024 10:15:39 +0800 Subject: [PATCH 24/33] Use the smart pointer to detect if the caller is still valid in the callback function Signed-off-by: Lo,Chin-Ran --- src/controller/CHIPDeviceController.cpp | 27 +++++++++++++++++--- src/controller/SetUpCodePairer.cpp | 34 ++++++++++++++++++++++--- 2 files changed, 54 insertions(+), 7 deletions(-) diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp index 37c0ead6a6faad..c58f9f8ed57191 100644 --- a/src/controller/CHIPDeviceController.cpp +++ b/src/controller/CHIPDeviceController.cpp @@ -93,6 +93,10 @@ using namespace chip::Encoding; #if CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY using namespace chip::Protocols::UserDirectedCommissioning; #endif // CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +static std::shared_ptr DevCommPtr; +void custom_del(DeviceCommissioner * p){}; +#endif DeviceController::DeviceController() { @@ -825,9 +829,10 @@ CHIP_ERROR DeviceCommissioner::EstablishPASEConnection(NodeId remoteDeviceId, Re ChipLogError(Controller, "Wi-Fi Management should have be started now."); ExitNow(CHIP_ERROR_INTERNAL); } + DevCommPtr.reset(this, custom_del); mRendezvousParametersForDeviceDiscoveredOverWiFiPAF = params; - DeviceLayer::ConnectivityMgr().WiFiPAFConnect(params.GetSetupDiscriminator().value(), this, OnWiFiPAFSubscribeComplete, - OnWiFiPAFSubscribeError); + DeviceLayer::ConnectivityMgr().WiFiPAFConnect(params.GetSetupDiscriminator().value(), (void *) (&(DevCommPtr)), + OnWiFiPAFSubscribeComplete, OnWiFiPAFSubscribeError); ExitNow(CHIP_NO_ERROR); } } @@ -902,9 +907,17 @@ void DeviceCommissioner::OnDiscoveredDeviceOverBleError(void * appState, CHIP_ER #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF void DeviceCommissioner::OnWiFiPAFSubscribeComplete(void * appState) { - auto self = static_cast(appState); + std::weak_ptr * caller = (std::weak_ptr *) (appState); + std::shared_ptr selfShrPtr = caller->lock(); + if (!selfShrPtr) + { + ChipLogError(Controller, "DeviceCommissioner was destroyed unexpectedly!"); + return; + } + auto self = selfShrPtr.get(); auto device = self->mDeviceInPASEEstablishment; + selfShrPtr.reset(); if (nullptr != device && device->GetDeviceTransportType() == Transport::Type::kWiFiPAF) { ChipLogProgress(Controller, "WiFi-PAF: Subscription Completed, dev_id = %lu", device->GetDeviceId()); @@ -919,9 +932,17 @@ void DeviceCommissioner::OnWiFiPAFSubscribeComplete(void * appState) void DeviceCommissioner::OnWiFiPAFSubscribeError(void * appState, CHIP_ERROR err) { + std::weak_ptr * caller = (std::weak_ptr *) (appState); + std::shared_ptr selfShrPtr = caller->lock(); + if (!selfShrPtr) + { + ChipLogError(Controller, "Err: DeviceCommissioner was destroyed unexpectedly!"); + return; + } auto self = static_cast(appState); auto device = self->mDeviceInPASEEstablishment; + selfShrPtr.reset(); if (nullptr != device && device->GetDeviceTransportType() == Transport::Type::kWiFiPAF) { ChipLogError(Controller, "WiFi-PAF: Subscription Error, id = %lu, err = %" CHIP_ERROR_FORMAT, device->GetDeviceId(), diff --git a/src/controller/SetUpCodePairer.cpp b/src/controller/SetUpCodePairer.cpp index 9cdba641d9c729..1dec78d80e4ca4 100644 --- a/src/controller/SetUpCodePairer.cpp +++ b/src/controller/SetUpCodePairer.cpp @@ -29,6 +29,7 @@ #include #include #include +#include #include #include @@ -252,6 +253,11 @@ CHIP_ERROR SetUpCodePairer::StopConnectOverSoftAP() return CHIP_NO_ERROR; } +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +static std::shared_ptr SetUpCodeParserPtr; +void custom_del(SetUpCodePairer * p){}; +#endif + CHIP_ERROR SetUpCodePairer::StartDiscoverOverWiFiPAF(SetupPayload & payload) { #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF @@ -259,8 +265,10 @@ CHIP_ERROR SetUpCodePairer::StartDiscoverOverWiFiPAF(SetupPayload & payload) VerifyOrReturnError(mCommissioner != nullptr, CHIP_ERROR_INCORRECT_STATE); mWaitingForDiscovery[kWiFiPAFTransport] = true; - CHIP_ERROR err = DeviceLayer::ConnectivityMgr().WiFiPAFConnect(payload.discriminator, this, OnWiFiPAFSubscribeComplete, - OnWiFiPAFSubscribeError); + + SetUpCodeParserPtr.reset(this, custom_del); + CHIP_ERROR err = DeviceLayer::ConnectivityMgr().WiFiPAFConnect(payload.discriminator, (void *) (&(SetUpCodeParserPtr)), + OnWiFiPAFSubscribeComplete, OnWiFiPAFSubscribeError); if (err != CHIP_NO_ERROR) { ChipLogError(Controller, "Commissioning discovery over WiFiPAF failed, err = %" CHIP_ERROR_FORMAT, err.Format()); @@ -390,12 +398,30 @@ void SetUpCodePairer::OnWifiPAFDiscoveryError(CHIP_ERROR err) void SetUpCodePairer::OnWiFiPAFSubscribeComplete(void * appState) { - (static_cast(appState))->OnDiscoveredDeviceOverWifiPAF(); + std::weak_ptr * caller = (std::weak_ptr *) (appState); + std::shared_ptr selfShrPtr = caller->lock(); + if (!selfShrPtr) + { + ChipLogError(Controller, "SetUpCodePairer is destroyed unexpectedly!"); + return; + } + selfShrPtr.get()->OnDiscoveredDeviceOverWifiPAF(); + // Release the ownership + selfShrPtr.reset(); } void SetUpCodePairer::OnWiFiPAFSubscribeError(void * appState, CHIP_ERROR err) { - static_cast(appState)->OnWifiPAFDiscoveryError(err); + std::weak_ptr * caller = (std::weak_ptr *) (appState); + std::shared_ptr selfShrPtr = caller->lock(); + if (!selfShrPtr) + { + ChipLogError(Controller, "Err: SetUpCodePairer was destroyed unexpectedly!"); + return; + } + selfShrPtr.get()->OnWifiPAFDiscoveryError(err); + // Release the ownership + selfShrPtr.reset(); } #endif From 3f436c8a40cb36bcbc444970ec509d27d77d8366 Mon Sep 17 00:00:00 2001 From: "Lo,Chin-Ran" Date: Mon, 15 Jul 2024 21:19:04 +0800 Subject: [PATCH 25/33] Fix the building error after rebase to TOT of master branch Signed-off-by: Lo,Chin-Ran --- examples/chip-tool/commands/pairing/PairingCommand.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/chip-tool/commands/pairing/PairingCommand.h b/examples/chip-tool/commands/pairing/PairingCommand.h index c222ad5f9cd5ff..9965b663ec111c 100644 --- a/examples/chip-tool/commands/pairing/PairingCommand.h +++ b/examples/chip-tool/commands/pairing/PairingCommand.h @@ -133,8 +133,8 @@ class PairingCommand : public CHIPCommand, #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF case PairingMode::WiFiPAF: AddArgument("skip-commissioning-complete", 0, 1, &mSkipCommissioningComplete); - AddArgument("setup-pin-code", 0, 134217727, &mSetupPINCode); - AddArgument("discriminator", 0, 4096, &mDiscriminator); + AddArgument("setup-pin-code", 0, 134217727, &mSetupPINCode.emplace()); + AddArgument("discriminator", 0, 4096, &mDiscriminator.emplace()); break; #endif case PairingMode::AlreadyDiscovered: From fef31921b2e6bd19ae0d07a873497b8972ff54ba Mon Sep 17 00:00:00 2001 From: "Lo,Chin-Ran" Date: Wed, 17 Jul 2024 20:30:28 +0800 Subject: [PATCH 26/33] Change the dbus interface usage by following the new api update in wpa_supplicant Signed-off-by: Lo,Chin-Ran --- src/platform/Linux/ConnectivityManagerImpl.cpp | 15 ++++++++++----- src/platform/Linux/ConnectivityManagerImpl.h | 1 + src/platform/Linux/dbus/wpa/DBusWpaInterface.xml | 13 +++++++++++-- 3 files changed, 22 insertions(+), 7 deletions(-) diff --git a/src/platform/Linux/ConnectivityManagerImpl.cpp b/src/platform/Linux/ConnectivityManagerImpl.cpp index ed437dadf45ee5..a80d0b98bdd22a 100644 --- a/src/platform/Linux/ConnectivityManagerImpl.cpp +++ b/src/platform/Linux/ConnectivityManagerImpl.cpp @@ -1374,6 +1374,11 @@ void ConnectivityManagerImpl::OnDiscoveryResult(gboolean success, GVariant * dis mpaf_info.peer_addr[5]); GetWiFiPAF()->SetWiFiPAFState(Transport::WiFiPAFBase::State::kConnected); + // Read the ssi + GAutoPtr ssiValue(g_variant_lookup_value(discov_info, "ssi", G_VARIANT_TYPE_BYTESTRING)); + size_t ssiBufLen; + g_variant_get_fixed_array(ssiValue.get(), &ssiBufLen, sizeof(uint8_t)); + ChipDeviceEvent event; event.Type = DeviceEventType::kCHIPoWiFiPAFConnected; PlatformMgr().PostEventOrDie(&event); @@ -1431,6 +1436,7 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFConnect(const SetupDiscriminator & c { ChipLogProgress(Controller, "WiFi-PAF: Try to subscribe the NAN-USD devices"); gchar args[MAX_PAF_SUBSCRIBE_SSI_BUFLEN]; + gint subscribe_id; snprintf(args, sizeof(args), "service_name=%s srv_proto_type=%u ttl=%u ", srv_name, NAN_SRV_PROTO_MATTER, NAM_SUBSCRIBE_PERIOD); GAutoPtr err; CHIP_ERROR ret; @@ -1456,14 +1462,13 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFConnect(const SetupDiscriminator & c VerifyOrReturnError(ret == CHIP_NO_ERROR, ret); ChipLogProgress(DeviceLayer, "WiFi-PAF: subscribe: [%s]", args); - wpa_fi_w1_wpa_supplicant1_interface_call_nansubscribe( - mWpaSupplicant.iface, args, nullptr, - reinterpret_cast( - +[](GObject * sourceObject_, GAsyncResult * res_, ConnectivityManagerImpl * self) { return; }), + wpa_fi_w1_wpa_supplicant1_interface_call_nansubscribe_sync( + mWpaSupplicant.iface, args, &subscribe_id, nullptr, &err.GetReceiver()); + ChipLogProgress(DeviceLayer, "WiFi-PAF: subscribe_id: [%d]", subscribe_id); mOnPafSubscribeComplete = onSuccess; mOnPafSubscribeError = onError; - g_signal_connect(mWpaSupplicant.iface, "discovery-result", + g_signal_connect(mWpaSupplicant.iface, "nan-discoveryresult", G_CALLBACK(+[](WpaFiW1Wpa_supplicant1Interface * proxy, gboolean success, GVariant * obj, ConnectivityManagerImpl * self) { return self->OnDiscoveryResult(success, obj); }), this); diff --git a/src/platform/Linux/ConnectivityManagerImpl.h b/src/platform/Linux/ConnectivityManagerImpl.h index 0f14eb737dfe9b..167f44155819df 100644 --- a/src/platform/Linux/ConnectivityManagerImpl.h +++ b/src/platform/Linux/ConnectivityManagerImpl.h @@ -234,6 +234,7 @@ class ConnectivityManagerImpl final : public ConnectivityManager, uint32_t subscribe_id; uint32_t peer_publish_id; uint8_t peer_addr[6]; + uint32_t ssi_len; }; struct wpa_dbus_discov_info mpaf_info; struct wpa_dbus_nanrx_info diff --git a/src/platform/Linux/dbus/wpa/DBusWpaInterface.xml b/src/platform/Linux/dbus/wpa/DBusWpaInterface.xml index 49737260413d1c..721ca0033cca09 100644 --- a/src/platform/Linux/dbus/wpa/DBusWpaInterface.xml +++ b/src/platform/Linux/dbus/wpa/DBusWpaInterface.xml @@ -58,13 +58,14 @@ - + + @@ -108,13 +109,21 @@ - + + + + + + + + + From f9f2aa39fed1b56a8e23f334fb323c0efbaf12bc Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Wed, 17 Jul 2024 12:33:44 +0000 Subject: [PATCH 27/33] Restyled by clang-format --- src/platform/Linux/ConnectivityManagerImpl.cpp | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/platform/Linux/ConnectivityManagerImpl.cpp b/src/platform/Linux/ConnectivityManagerImpl.cpp index a80d0b98bdd22a..33c331ab6e620c 100644 --- a/src/platform/Linux/ConnectivityManagerImpl.cpp +++ b/src/platform/Linux/ConnectivityManagerImpl.cpp @@ -1462,9 +1462,8 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFConnect(const SetupDiscriminator & c VerifyOrReturnError(ret == CHIP_NO_ERROR, ret); ChipLogProgress(DeviceLayer, "WiFi-PAF: subscribe: [%s]", args); - wpa_fi_w1_wpa_supplicant1_interface_call_nansubscribe_sync( - mWpaSupplicant.iface, args, &subscribe_id, nullptr, - &err.GetReceiver()); + wpa_fi_w1_wpa_supplicant1_interface_call_nansubscribe_sync(mWpaSupplicant.iface, args, &subscribe_id, nullptr, + &err.GetReceiver()); ChipLogProgress(DeviceLayer, "WiFi-PAF: subscribe_id: [%d]", subscribe_id); mOnPafSubscribeComplete = onSuccess; mOnPafSubscribeError = onError; From 30542c4d570775edd9f04a20f416a855f11d7bbd Mon Sep 17 00:00:00 2001 From: "Lo,Chin-Ran" Date: Fri, 19 Jul 2024 18:24:49 +0800 Subject: [PATCH 28/33] * Add freq_list option to support multiple channels * Add more tests in QRCode test Signed-off-by: Lo,Chin-Ran --- examples/platform/linux/AppMain.cpp | 5 +++- examples/platform/linux/Options.cpp | 8 ++++--- examples/platform/linux/Options.h | 1 + src/app/server/CommissioningWindowManager.cpp | 5 +++- src/include/platform/ConnectivityManager.h | 18 +++++++++++--- .../GenericConnectivityManagerImpl_WiFi.h | 3 --- .../Linux/ConnectivityManagerImpl.cpp | 24 +++++++++++++------ src/platform/Linux/ConnectivityManagerImpl.h | 4 ++-- src/setup_payload/tests/TestQRCode.cpp | 21 +++++++++++++++- 9 files changed, 68 insertions(+), 21 deletions(-) diff --git a/examples/platform/linux/AppMain.cpp b/examples/platform/linux/AppMain.cpp index 01bf77c4e29566..2bf0427240103c 100644 --- a/examples/platform/linux/AppMain.cpp +++ b/examples/platform/linux/AppMain.cpp @@ -481,7 +481,10 @@ int ChipLinuxAppInit(int argc, char * const argv[], OptionSet * customOptions, if (EnsureWiFiIsStarted()) { ChipLogProgress(NotSpecified, "Wi-Fi Management started"); - DeviceLayer::ConnectivityMgr().SetWiFiPAFAdvertisingEnabled(LinuxDeviceOptions::GetInstance().mWiFiPAF); + DeviceLayer::ConnectivityManager::WiFiPAFAdvertiseParam args; + args.enable = LinuxDeviceOptions::GetInstance().mWiFiPAF; + args.ExtCmds = LinuxDeviceOptions::GetInstance().mWiFiPafExtCmds; + DeviceLayer::ConnectivityMgr().SetWiFiPAFAdvertisingEnabled(args); } } #endif diff --git a/examples/platform/linux/Options.cpp b/examples/platform/linux/Options.cpp index 82322c065c6c8d..fa91578f50c149 100644 --- a/examples/platform/linux/Options.cpp +++ b/examples/platform/linux/Options.cpp @@ -121,7 +121,7 @@ OptionDef sDeviceOptionDefs[] = { { "wifi", kNoArgument, kDeviceOption_WiFi }, { "wifi-supports-5g", kNoArgument, kDeviceOption_WiFiSupports5g }, #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - { "wifipaf", kNoArgument, kDeviceOption_WiFi_PAF }, + { "wifipaf", kArgumentRequired, kDeviceOption_WiFi_PAF }, #endif // CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF #endif // CHIP_DEVICE_CONFIG_ENABLE_WPA #if CHIP_ENABLE_OPENTHREAD @@ -197,9 +197,10 @@ const char * sDeviceOptionHelp = #endif // CHIP_DEVICE_CONFIG_ENABLE_WIFI #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF "\n" - " --wifipaf\n" + " --wifipaf freq_list=,... \n" " Enable Wi-Fi PAF via wpa_supplicant.\n" -#endif // CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + " Give an empty string if not setting freq_list: \"\"\n" +#endif // CHIP_DEVICE_CONFIG_ENABLE_WIFIPAFs #if CHIP_ENABLE_OPENTHREAD "\n" " --thread\n" @@ -603,6 +604,7 @@ bool HandleOption(const char * aProgram, OptionSet * aOptions, int aIdentifier, #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF case kDeviceOption_WiFi_PAF: { LinuxDeviceOptions::GetInstance().mWiFiPAF = true; + LinuxDeviceOptions::GetInstance().mWiFiPafExtCmds = aValue; break; } #endif diff --git a/examples/platform/linux/Options.h b/examples/platform/linux/Options.h index 7e3c154e2260d3..3ba7b4d04bfe37 100644 --- a/examples/platform/linux/Options.h +++ b/examples/platform/linux/Options.h @@ -51,6 +51,7 @@ struct LinuxDeviceOptions bool mThread = false; #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF bool mWiFiPAF = false; + const char * mWiFiPafExtCmds = nullptr; #endif #if CHIP_DEVICE_CONFIG_ENABLE_BOTH_COMMISSIONER_AND_COMMISSIONEE || CHIP_DEVICE_ENABLE_PORT_PARAMS uint16_t securedDevicePort = CHIP_PORT; diff --git a/src/app/server/CommissioningWindowManager.cpp b/src/app/server/CommissioningWindowManager.cpp index 61a59049f4bcc5..47aca659f01deb 100644 --- a/src/app/server/CommissioningWindowManager.cpp +++ b/src/app/server/CommissioningWindowManager.cpp @@ -73,7 +73,10 @@ void CommissioningWindowManager::OnPlatformEvent(const DeviceLayer::ChipDeviceEv mServer->GetBleLayerObject()->CloseAllBleConnections(); #endif #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - DeviceLayer::ConnectivityMgr().SetWiFiPAFAdvertisingEnabled(false); + DeviceLayer::ConnectivityManager::WiFiPAFAdvertiseParam args; + args.enable = false; + args.ExtCmds = nullptr; + DeviceLayer::ConnectivityMgr().SetWiFiPAFAdvertisingEnabled(args); #endif } else if (event->Type == DeviceLayer::DeviceEventType::kFailSafeTimerExpired) diff --git a/src/include/platform/ConnectivityManager.h b/src/include/platform/ConnectivityManager.h index 754ef84fe7ab38..36c71a1fdda310 100644 --- a/src/include/platform/ConnectivityManager.h +++ b/src/include/platform/ConnectivityManager.h @@ -175,8 +175,9 @@ class ConnectivityManager void ClearWiFiStationProvision(); CHIP_ERROR GetAndLogWiFiStatsCounters(); #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - CHIP_ERROR SetWiFiPAFAdvertisingEnabled(bool val); + struct WiFiPAFAdvertiseParam; + CHIP_ERROR SetWiFiPAFAdvertisingEnabled(WiFiPAFAdvertiseParam &args); typedef void (*OnConnectionCompleteFunct)(void * appState); typedef void (*OnConnectionErrorFunct)(void * appState, CHIP_ERROR err); CHIP_ERROR WiFiPAFConnect(const SetupDiscriminator & connDiscriminator, void * appState, OnConnectionCompleteFunct onSuccess, @@ -282,6 +283,17 @@ struct ConnectivityManager::SEDIntervalsConfig System::Clock::Milliseconds32 IdleIntervalMS; }; +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +struct ConnectivityManager::WiFiPAFAdvertiseParam +{ + /* To enable/disable WiFiPAF Commissioning */ + bool enable; + /* The optional commands */ + const char* ExtCmds; +}; +#endif + + /** * Returns a reference to the public interface of the ConnectivityManager singleton object. * @@ -422,9 +434,9 @@ inline CHIP_ERROR ConnectivityManager::GetAndLogWiFiStatsCounters() } #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF -inline CHIP_ERROR ConnectivityManager::SetWiFiPAFAdvertisingEnabled(bool val) +inline CHIP_ERROR ConnectivityManager::SetWiFiPAFAdvertisingEnabled(WiFiPAFAdvertiseParam &args) { - return static_cast(this)->_SetWiFiPAFAdvertisingEnabled(val); + return static_cast(this)->_SetWiFiPAFAdvertisingEnabled(args); } inline CHIP_ERROR ConnectivityManager::WiFiPAFConnect(const SetupDiscriminator & connDiscriminator, void * appState, diff --git a/src/include/platform/internal/GenericConnectivityManagerImpl_WiFi.h b/src/include/platform/internal/GenericConnectivityManagerImpl_WiFi.h index 4db7ea9bdb889d..24cc0032389280 100644 --- a/src/include/platform/internal/GenericConnectivityManagerImpl_WiFi.h +++ b/src/include/platform/internal/GenericConnectivityManagerImpl_WiFi.h @@ -77,9 +77,6 @@ class GenericConnectivityManagerImpl_WiFi bool _CanStartWiFiScan(); void _OnWiFiScanDone(); void _OnWiFiStationProvisionChange(); -#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - CHIP_ERROR _SetWiFiPAFAdvertisingEnabled(bool val); -#endif // TODO ICD rework: ambiguous declaration of _SetPollingInterval when thread and wifi are both build together #if CHIP_CONFIG_ENABLE_ICD_SERVER && !CHIP_DEVICE_CONFIG_ENABLE_THREAD CHIP_ERROR _SetPollingInterval(System::Clock::Milliseconds32 pollingInterval); diff --git a/src/platform/Linux/ConnectivityManagerImpl.cpp b/src/platform/Linux/ConnectivityManagerImpl.cpp index 33c331ab6e620c..b34eda0b5f2195 100644 --- a/src/platform/Linux/ConnectivityManagerImpl.cpp +++ b/src/platform/Linux/ConnectivityManagerImpl.cpp @@ -822,11 +822,11 @@ const char srv_name[] = "_matterc._udp"; /* NAN-USD Service Protocol Type: ref: Table 58 of Wi-Fi Aware Specificaiton */ -#define MAX_PAF_PUBLISH_SSI_BUFLEN 128 +#define MAX_PAF_PUBLISH_SSI_BUFLEN 512 #define MAX_PAF_TX_SSI_BUFLEN 2048 #define NAN_SRV_PROTO_MATTER 3 #define NAM_PUBLISH_PERIOD 300u -#define NAN_PUBLISH_SSI_TAG "ssi=" +#define NAN_PUBLISH_SSI_TAG " ssi=" #pragma pack(push, 1) struct PAFPublishSSI @@ -837,14 +837,22 @@ struct PAFPublishSSI uint16_t VendorId; }; #pragma pack(pop) -CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFPublish() +CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFPublish(ConnectivityManager::WiFiPAFAdvertiseParam &InArgs) { CHIP_ERROR ret; GAutoPtr err; gchar args[MAX_PAF_PUBLISH_SSI_BUFLEN]; gint publish_id; + size_t req_len; snprintf(args, sizeof(args), "service_name=%s srv_proto_type=%u ttl=%u ", srv_name, NAN_SRV_PROTO_MATTER, NAM_PUBLISH_PERIOD); + req_len = strlen(args)+strlen(InArgs.ExtCmds); + if ((InArgs.ExtCmds != nullptr) && + (MAX_PAF_PUBLISH_SSI_BUFLEN > req_len)) { + strcat(args, InArgs.ExtCmds); + } else { + ChipLogError(DeviceLayer, "Input cmd is too long: limit:%d, req: %lu", MAX_PAF_PUBLISH_SSI_BUFLEN, req_len); + } struct PAFPublishSSI PafPublish_ssi; VerifyOrReturnError( @@ -860,7 +868,9 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFPublish() { PafPublish_ssi.VendorId = 0; } - strcat(args, NAN_PUBLISH_SSI_TAG); + if (MAX_PAF_PUBLISH_SSI_BUFLEN > strlen(args)+strlen(NAN_PUBLISH_SSI_TAG)) { + strcat(args, NAN_PUBLISH_SSI_TAG); + } ret = Encoding::BytesToUppercaseHexString((uint8_t *) &PafPublish_ssi, sizeof(PafPublish_ssi), &args[strlen(args)], MAX_PAF_PUBLISH_SSI_BUFLEN - strlen(args)); VerifyOrReturnError(ret == CHIP_NO_ERROR, ret); @@ -887,11 +897,11 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFCancelPublish() return CHIP_NO_ERROR; } -CHIP_ERROR ConnectivityManagerImpl::_SetWiFiPAFAdvertisingEnabled(bool val) +CHIP_ERROR ConnectivityManagerImpl::_SetWiFiPAFAdvertisingEnabled(WiFiPAFAdvertiseParam &args) { - if (val == true) + if (args.enable == true) { - return _WiFiPAFPublish(); + return _WiFiPAFPublish(args); } else { diff --git a/src/platform/Linux/ConnectivityManagerImpl.h b/src/platform/Linux/ConnectivityManagerImpl.h index 167f44155819df..d8abfe093c2b61 100644 --- a/src/platform/Linux/ConnectivityManagerImpl.h +++ b/src/platform/Linux/ConnectivityManagerImpl.h @@ -250,8 +250,8 @@ class ConnectivityManagerImpl final : public ConnectivityManager, OnConnectionErrorFunct mOnPafSubscribeError; Transport::WiFiPAFBase * pmWiFiPAF; void * mAppState; - CHIP_ERROR _SetWiFiPAFAdvertisingEnabled(bool val); - CHIP_ERROR _WiFiPAFPublish(); + CHIP_ERROR _SetWiFiPAFAdvertisingEnabled(WiFiPAFAdvertiseParam &args); + CHIP_ERROR _WiFiPAFPublish(WiFiPAFAdvertiseParam &args); CHIP_ERROR _WiFiPAFCancelPublish(); #endif diff --git a/src/setup_payload/tests/TestQRCode.cpp b/src/setup_payload/tests/TestQRCode.cpp index 8703eb5989d65e..545af28940b5f4 100644 --- a/src/setup_payload/tests/TestQRCode.cpp +++ b/src/setup_payload/tests/TestQRCode.cpp @@ -53,6 +53,9 @@ TEST(TestQRCode, TestRendezvousFlags) inPayload.rendezvousInformation.SetValue(RendezvousInformationFlag::kOnNetwork); EXPECT_TRUE(CheckWriteRead(inPayload)); + inPayload.rendezvousInformation.SetValue(RendezvousInformationFlag::kWiFiPAF); + EXPECT_TRUE(CheckWriteRead(inPayload)); + inPayload.rendezvousInformation.SetValue( RendezvousInformationFlags(RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kOnNetwork)); EXPECT_TRUE(CheckWriteRead(inPayload)); @@ -61,9 +64,25 @@ TEST(TestQRCode, TestRendezvousFlags) RendezvousInformationFlags(RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kOnNetwork)); EXPECT_TRUE(CheckWriteRead(inPayload)); + inPayload.rendezvousInformation.SetValue( + RendezvousInformationFlags(RendezvousInformationFlag::kWiFiPAF, RendezvousInformationFlag::kOnNetwork)); + EXPECT_TRUE(CheckWriteRead(inPayload)); + inPayload.rendezvousInformation.SetValue(RendezvousInformationFlags( RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kOnNetwork)); EXPECT_TRUE(CheckWriteRead(inPayload)); + + inPayload.rendezvousInformation.SetValue(RendezvousInformationFlags( + RendezvousInformationFlag::kWiFiPAF, RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kOnNetwork)); + + inPayload.rendezvousInformation.SetValue(RendezvousInformationFlags( + RendezvousInformationFlag::kWiFiPAF, RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kOnNetwork)); + + inPayload.rendezvousInformation.SetValue(RendezvousInformationFlags( + RendezvousInformationFlag::kWiFiPAF, RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kSoftAP, + RendezvousInformationFlag::kOnNetwork)); + + EXPECT_TRUE(CheckWriteRead(inPayload)); } TEST(TestQRCode, TestCommissioningFlow) @@ -89,7 +108,7 @@ TEST(TestQRCode, TestMaximumValues) inPayload.productID = 0xFFFF; inPayload.commissioningFlow = CommissioningFlow::kCustom; inPayload.rendezvousInformation.SetValue(RendezvousInformationFlags( - RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kOnNetwork)); + RendezvousInformationFlag::kWiFiPAF, RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kOnNetwork)); inPayload.discriminator.SetLongValue(static_cast((1 << kPayloadDiscriminatorFieldLengthInBits) - 1)); inPayload.setUpPINCode = static_cast((1 << kSetupPINCodeFieldLengthInBits) - 1); From 19ccdba8c02447f35c2d3fcbac0c3e2d543038a4 Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Fri, 19 Jul 2024 10:27:04 +0000 Subject: [PATCH 29/33] Restyled by clang-format --- examples/platform/linux/AppMain.cpp | 2 +- examples/platform/linux/Options.cpp | 2 +- examples/platform/linux/Options.h | 2 +- src/app/server/CommissioningWindowManager.cpp | 2 +- src/include/platform/ConnectivityManager.h | 9 ++++----- src/platform/Linux/ConnectivityManagerImpl.cpp | 17 ++++++++++------- src/platform/Linux/ConnectivityManagerImpl.h | 4 ++-- src/setup_payload/tests/TestQRCode.cpp | 15 ++++++++------- 8 files changed, 28 insertions(+), 25 deletions(-) diff --git a/examples/platform/linux/AppMain.cpp b/examples/platform/linux/AppMain.cpp index 2bf0427240103c..f9c54b3758c351 100644 --- a/examples/platform/linux/AppMain.cpp +++ b/examples/platform/linux/AppMain.cpp @@ -482,7 +482,7 @@ int ChipLinuxAppInit(int argc, char * const argv[], OptionSet * customOptions, { ChipLogProgress(NotSpecified, "Wi-Fi Management started"); DeviceLayer::ConnectivityManager::WiFiPAFAdvertiseParam args; - args.enable = LinuxDeviceOptions::GetInstance().mWiFiPAF; + args.enable = LinuxDeviceOptions::GetInstance().mWiFiPAF; args.ExtCmds = LinuxDeviceOptions::GetInstance().mWiFiPafExtCmds; DeviceLayer::ConnectivityMgr().SetWiFiPAFAdvertisingEnabled(args); } diff --git a/examples/platform/linux/Options.cpp b/examples/platform/linux/Options.cpp index fa91578f50c149..e102a13a967925 100644 --- a/examples/platform/linux/Options.cpp +++ b/examples/platform/linux/Options.cpp @@ -603,7 +603,7 @@ bool HandleOption(const char * aProgram, OptionSet * aOptions, int aIdentifier, #endif #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF case kDeviceOption_WiFi_PAF: { - LinuxDeviceOptions::GetInstance().mWiFiPAF = true; + LinuxDeviceOptions::GetInstance().mWiFiPAF = true; LinuxDeviceOptions::GetInstance().mWiFiPafExtCmds = aValue; break; } diff --git a/examples/platform/linux/Options.h b/examples/platform/linux/Options.h index 3ba7b4d04bfe37..f2210abf9090ef 100644 --- a/examples/platform/linux/Options.h +++ b/examples/platform/linux/Options.h @@ -50,7 +50,7 @@ struct LinuxDeviceOptions bool mWiFi = false; bool mThread = false; #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - bool mWiFiPAF = false; + bool mWiFiPAF = false; const char * mWiFiPafExtCmds = nullptr; #endif #if CHIP_DEVICE_CONFIG_ENABLE_BOTH_COMMISSIONER_AND_COMMISSIONEE || CHIP_DEVICE_ENABLE_PORT_PARAMS diff --git a/src/app/server/CommissioningWindowManager.cpp b/src/app/server/CommissioningWindowManager.cpp index 47aca659f01deb..47bc3e8ff97f07 100644 --- a/src/app/server/CommissioningWindowManager.cpp +++ b/src/app/server/CommissioningWindowManager.cpp @@ -74,7 +74,7 @@ void CommissioningWindowManager::OnPlatformEvent(const DeviceLayer::ChipDeviceEv #endif #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF DeviceLayer::ConnectivityManager::WiFiPAFAdvertiseParam args; - args.enable = false; + args.enable = false; args.ExtCmds = nullptr; DeviceLayer::ConnectivityMgr().SetWiFiPAFAdvertisingEnabled(args); #endif diff --git a/src/include/platform/ConnectivityManager.h b/src/include/platform/ConnectivityManager.h index 36c71a1fdda310..e77f5b2c827bc5 100644 --- a/src/include/platform/ConnectivityManager.h +++ b/src/include/platform/ConnectivityManager.h @@ -177,7 +177,7 @@ class ConnectivityManager #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF struct WiFiPAFAdvertiseParam; - CHIP_ERROR SetWiFiPAFAdvertisingEnabled(WiFiPAFAdvertiseParam &args); + CHIP_ERROR SetWiFiPAFAdvertisingEnabled(WiFiPAFAdvertiseParam & args); typedef void (*OnConnectionCompleteFunct)(void * appState); typedef void (*OnConnectionErrorFunct)(void * appState, CHIP_ERROR err); CHIP_ERROR WiFiPAFConnect(const SetupDiscriminator & connDiscriminator, void * appState, OnConnectionCompleteFunct onSuccess, @@ -288,12 +288,11 @@ struct ConnectivityManager::WiFiPAFAdvertiseParam { /* To enable/disable WiFiPAF Commissioning */ bool enable; - /* The optional commands */ - const char* ExtCmds; + /* The optional commands */ + const char * ExtCmds; }; #endif - /** * Returns a reference to the public interface of the ConnectivityManager singleton object. * @@ -434,7 +433,7 @@ inline CHIP_ERROR ConnectivityManager::GetAndLogWiFiStatsCounters() } #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF -inline CHIP_ERROR ConnectivityManager::SetWiFiPAFAdvertisingEnabled(WiFiPAFAdvertiseParam &args) +inline CHIP_ERROR ConnectivityManager::SetWiFiPAFAdvertisingEnabled(WiFiPAFAdvertiseParam & args) { return static_cast(this)->_SetWiFiPAFAdvertisingEnabled(args); } diff --git a/src/platform/Linux/ConnectivityManagerImpl.cpp b/src/platform/Linux/ConnectivityManagerImpl.cpp index b34eda0b5f2195..fb122de5a4aafc 100644 --- a/src/platform/Linux/ConnectivityManagerImpl.cpp +++ b/src/platform/Linux/ConnectivityManagerImpl.cpp @@ -837,7 +837,7 @@ struct PAFPublishSSI uint16_t VendorId; }; #pragma pack(pop) -CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFPublish(ConnectivityManager::WiFiPAFAdvertiseParam &InArgs) +CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFPublish(ConnectivityManager::WiFiPAFAdvertiseParam & InArgs) { CHIP_ERROR ret; GAutoPtr err; @@ -846,11 +846,13 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFPublish(ConnectivityManager::WiFiPAF size_t req_len; snprintf(args, sizeof(args), "service_name=%s srv_proto_type=%u ttl=%u ", srv_name, NAN_SRV_PROTO_MATTER, NAM_PUBLISH_PERIOD); - req_len = strlen(args)+strlen(InArgs.ExtCmds); - if ((InArgs.ExtCmds != nullptr) && - (MAX_PAF_PUBLISH_SSI_BUFLEN > req_len)) { + req_len = strlen(args) + strlen(InArgs.ExtCmds); + if ((InArgs.ExtCmds != nullptr) && (MAX_PAF_PUBLISH_SSI_BUFLEN > req_len)) + { strcat(args, InArgs.ExtCmds); - } else { + } + else + { ChipLogError(DeviceLayer, "Input cmd is too long: limit:%d, req: %lu", MAX_PAF_PUBLISH_SSI_BUFLEN, req_len); } @@ -868,7 +870,8 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFPublish(ConnectivityManager::WiFiPAF { PafPublish_ssi.VendorId = 0; } - if (MAX_PAF_PUBLISH_SSI_BUFLEN > strlen(args)+strlen(NAN_PUBLISH_SSI_TAG)) { + if (MAX_PAF_PUBLISH_SSI_BUFLEN > strlen(args) + strlen(NAN_PUBLISH_SSI_TAG)) + { strcat(args, NAN_PUBLISH_SSI_TAG); } ret = Encoding::BytesToUppercaseHexString((uint8_t *) &PafPublish_ssi, sizeof(PafPublish_ssi), &args[strlen(args)], @@ -897,7 +900,7 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFCancelPublish() return CHIP_NO_ERROR; } -CHIP_ERROR ConnectivityManagerImpl::_SetWiFiPAFAdvertisingEnabled(WiFiPAFAdvertiseParam &args) +CHIP_ERROR ConnectivityManagerImpl::_SetWiFiPAFAdvertisingEnabled(WiFiPAFAdvertiseParam & args) { if (args.enable == true) { diff --git a/src/platform/Linux/ConnectivityManagerImpl.h b/src/platform/Linux/ConnectivityManagerImpl.h index d8abfe093c2b61..5a5acfc41a6a38 100644 --- a/src/platform/Linux/ConnectivityManagerImpl.h +++ b/src/platform/Linux/ConnectivityManagerImpl.h @@ -250,8 +250,8 @@ class ConnectivityManagerImpl final : public ConnectivityManager, OnConnectionErrorFunct mOnPafSubscribeError; Transport::WiFiPAFBase * pmWiFiPAF; void * mAppState; - CHIP_ERROR _SetWiFiPAFAdvertisingEnabled(WiFiPAFAdvertiseParam &args); - CHIP_ERROR _WiFiPAFPublish(WiFiPAFAdvertiseParam &args); + CHIP_ERROR _SetWiFiPAFAdvertisingEnabled(WiFiPAFAdvertiseParam & args); + CHIP_ERROR _WiFiPAFPublish(WiFiPAFAdvertiseParam & args); CHIP_ERROR _WiFiPAFCancelPublish(); #endif diff --git a/src/setup_payload/tests/TestQRCode.cpp b/src/setup_payload/tests/TestQRCode.cpp index 545af28940b5f4..c99cd6eded9d44 100644 --- a/src/setup_payload/tests/TestQRCode.cpp +++ b/src/setup_payload/tests/TestQRCode.cpp @@ -65,8 +65,8 @@ TEST(TestQRCode, TestRendezvousFlags) EXPECT_TRUE(CheckWriteRead(inPayload)); inPayload.rendezvousInformation.SetValue( - RendezvousInformationFlags(RendezvousInformationFlag::kWiFiPAF, RendezvousInformationFlag::kOnNetwork)); - EXPECT_TRUE(CheckWriteRead(inPayload)); + RendezvousInformationFlags(RendezvousInformationFlag::kWiFiPAF, RendezvousInformationFlag::kOnNetwork)); + EXPECT_TRUE(CheckWriteRead(inPayload)); inPayload.rendezvousInformation.SetValue(RendezvousInformationFlags( RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kOnNetwork)); @@ -78,9 +78,9 @@ TEST(TestQRCode, TestRendezvousFlags) inPayload.rendezvousInformation.SetValue(RendezvousInformationFlags( RendezvousInformationFlag::kWiFiPAF, RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kOnNetwork)); - inPayload.rendezvousInformation.SetValue(RendezvousInformationFlags( - RendezvousInformationFlag::kWiFiPAF, RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kSoftAP, - RendezvousInformationFlag::kOnNetwork)); + inPayload.rendezvousInformation.SetValue( + RendezvousInformationFlags(RendezvousInformationFlag::kWiFiPAF, RendezvousInformationFlag::kBLE, + RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kOnNetwork)); EXPECT_TRUE(CheckWriteRead(inPayload)); } @@ -107,8 +107,9 @@ TEST(TestQRCode, TestMaximumValues) inPayload.vendorID = 0xFFFF; inPayload.productID = 0xFFFF; inPayload.commissioningFlow = CommissioningFlow::kCustom; - inPayload.rendezvousInformation.SetValue(RendezvousInformationFlags( - RendezvousInformationFlag::kWiFiPAF, RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kOnNetwork)); + inPayload.rendezvousInformation.SetValue( + RendezvousInformationFlags(RendezvousInformationFlag::kWiFiPAF, RendezvousInformationFlag::kBLE, + RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kOnNetwork)); inPayload.discriminator.SetLongValue(static_cast((1 << kPayloadDiscriminatorFieldLengthInBits) - 1)); inPayload.setUpPINCode = static_cast((1 << kSetupPINCodeFieldLengthInBits) - 1); From e032c6e1635bb6eb61be28c213d850539decfe42 Mon Sep 17 00:00:00 2001 From: "Lo,Chin-Ran" Date: Tue, 23 Jul 2024 20:27:16 +0800 Subject: [PATCH 30/33] * Change to have the consistent naming of the new added variables * Fix the problem to add tests in TestQRCode.cpp * Use a list to track the validation of the caller object. Signed-off-by: Lo,Chin-Ran --- examples/platform/linux/AppMain.cpp | 2 +- examples/platform/linux/Options.cpp | 2 +- examples/platform/linux/Options.h | 2 +- src/controller/CHIPDeviceController.cpp | 89 +++++++++++++++++++------ src/controller/CHIPDeviceController.h | 10 ++- src/controller/SetUpCodePairer.cpp | 47 +++++++------ src/controller/SetUpCodePairer.h | 2 +- src/setup_payload/tests/TestQRCode.cpp | 3 +- 8 files changed, 107 insertions(+), 50 deletions(-) diff --git a/examples/platform/linux/AppMain.cpp b/examples/platform/linux/AppMain.cpp index f9c54b3758c351..307b3428126db2 100644 --- a/examples/platform/linux/AppMain.cpp +++ b/examples/platform/linux/AppMain.cpp @@ -483,7 +483,7 @@ int ChipLinuxAppInit(int argc, char * const argv[], OptionSet * customOptions, ChipLogProgress(NotSpecified, "Wi-Fi Management started"); DeviceLayer::ConnectivityManager::WiFiPAFAdvertiseParam args; args.enable = LinuxDeviceOptions::GetInstance().mWiFiPAF; - args.ExtCmds = LinuxDeviceOptions::GetInstance().mWiFiPafExtCmds; + args.ExtCmds = LinuxDeviceOptions::GetInstance().mWiFiPAFExtCmds; DeviceLayer::ConnectivityMgr().SetWiFiPAFAdvertisingEnabled(args); } } diff --git a/examples/platform/linux/Options.cpp b/examples/platform/linux/Options.cpp index e102a13a967925..9b83d126c1f495 100644 --- a/examples/platform/linux/Options.cpp +++ b/examples/platform/linux/Options.cpp @@ -604,7 +604,7 @@ bool HandleOption(const char * aProgram, OptionSet * aOptions, int aIdentifier, #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF case kDeviceOption_WiFi_PAF: { LinuxDeviceOptions::GetInstance().mWiFiPAF = true; - LinuxDeviceOptions::GetInstance().mWiFiPafExtCmds = aValue; + LinuxDeviceOptions::GetInstance().mWiFiPAFExtCmds = aValue; break; } #endif diff --git a/examples/platform/linux/Options.h b/examples/platform/linux/Options.h index f2210abf9090ef..f921bee4ced554 100644 --- a/examples/platform/linux/Options.h +++ b/examples/platform/linux/Options.h @@ -51,7 +51,7 @@ struct LinuxDeviceOptions bool mThread = false; #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF bool mWiFiPAF = false; - const char * mWiFiPafExtCmds = nullptr; + const char * mWiFiPAFExtCmds = nullptr; #endif #if CHIP_DEVICE_CONFIG_ENABLE_BOTH_COMMISSIONER_AND_COMMISSIONEE || CHIP_DEVICE_ENABLE_PORT_PARAMS uint16_t securedDevicePort = CHIP_PORT; diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp index c58f9f8ed57191..9970aa7eb116f8 100644 --- a/src/controller/CHIPDeviceController.cpp +++ b/src/controller/CHIPDeviceController.cpp @@ -93,10 +93,6 @@ using namespace chip::Encoding; #if CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY using namespace chip::Protocols::UserDirectedCommissioning; #endif // CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY -#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF -static std::shared_ptr DevCommPtr; -void custom_del(DeviceCommissioner * p){}; -#endif DeviceController::DeviceController() { @@ -473,6 +469,13 @@ DeviceCommissioner::DeviceCommissioner() : mDeviceNOCChainCallback(OnDeviceNOCChainGeneration, this), mSetUpCodePairer(this) {} +DeviceCommissioner::~DeviceCommissioner() +{ +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + SetChkObjValid((void *)this, ObjChkAction::Clear, nullptr); +#endif +} + CHIP_ERROR DeviceCommissioner::Init(CommissionerInitParams params) { VerifyOrReturnError(params.operationalCredentialsDelegate != nullptr, CHIP_ERROR_INVALID_ARGUMENT); @@ -829,9 +832,9 @@ CHIP_ERROR DeviceCommissioner::EstablishPASEConnection(NodeId remoteDeviceId, Re ChipLogError(Controller, "Wi-Fi Management should have be started now."); ExitNow(CHIP_ERROR_INTERNAL); } - DevCommPtr.reset(this, custom_del); mRendezvousParametersForDeviceDiscoveredOverWiFiPAF = params; - DeviceLayer::ConnectivityMgr().WiFiPAFConnect(params.GetSetupDiscriminator().value(), (void *) (&(DevCommPtr)), + SetChkObjValid((void*)this, ObjChkAction::Set, nullptr); + DeviceLayer::ConnectivityMgr().WiFiPAFConnect(params.GetSetupDiscriminator().value(), (void *) this, OnWiFiPAFSubscribeComplete, OnWiFiPAFSubscribeError); ExitNow(CHIP_NO_ERROR); } @@ -905,19 +908,66 @@ void DeviceCommissioner::OnDiscoveredDeviceOverBleError(void * appState, CHIP_ER #endif // CONFIG_NETWORK_LAYER_BLE #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF +void DeviceCommissioner::SetChkObjValid(void * appObj, ObjChkAction action, bool* pIsObjValid) +{ + static std::vector ObjVector; + bool IsObjValid = false; + + switch (action) { + case ObjChkAction::Set: { + for (auto lt=ObjVector.begin(); lt!=ObjVector.end(); lt++) + { + if (*lt == appObj) { + IsObjValid = true; + break; + } + } + if (IsObjValid == false) { + ObjVector.push_back(appObj); + IsObjValid = true; + } + } + break; + case ObjChkAction::Check: { + for (auto lt=ObjVector.begin(); lt!=ObjVector.end(); lt++) + { + if (*lt == appObj) { + IsObjValid = true; + break; + } + } + } + break; + case ObjChkAction::Clear: { + for (auto lt=ObjVector.begin(); lt!=ObjVector.end(); lt++) + { + if (*lt == appObj) { + // Already existed in the list => Remove it + ObjVector.erase(lt); + break; + } + } + } + break; + } + if (pIsObjValid != nullptr) { + *pIsObjValid = IsObjValid; + } + return; +} + void DeviceCommissioner::OnWiFiPAFSubscribeComplete(void * appState) { - std::weak_ptr * caller = (std::weak_ptr *) (appState); - std::shared_ptr selfShrPtr = caller->lock(); - if (!selfShrPtr) - { - ChipLogError(Controller, "DeviceCommissioner was destroyed unexpectedly!"); + bool isObjValid; + SetChkObjValid(appState, ObjChkAction::Check, &isObjValid); + if (isObjValid == false) { + // The caller has been released. + ChipLogError(Controller, "DeviceCommissioner has been destroyed!"); return; } - auto self = selfShrPtr.get(); + auto self = (DeviceCommissioner*) appState; auto device = self->mDeviceInPASEEstablishment; - selfShrPtr.reset(); if (nullptr != device && device->GetDeviceTransportType() == Transport::Type::kWiFiPAF) { ChipLogProgress(Controller, "WiFi-PAF: Subscription Completed, dev_id = %lu", device->GetDeviceId()); @@ -932,17 +982,16 @@ void DeviceCommissioner::OnWiFiPAFSubscribeComplete(void * appState) void DeviceCommissioner::OnWiFiPAFSubscribeError(void * appState, CHIP_ERROR err) { - std::weak_ptr * caller = (std::weak_ptr *) (appState); - std::shared_ptr selfShrPtr = caller->lock(); - if (!selfShrPtr) - { - ChipLogError(Controller, "Err: DeviceCommissioner was destroyed unexpectedly!"); + bool isObjValid; + SetChkObjValid(appState, ObjChkAction::Check, &isObjValid); + if (isObjValid == false) { + // The caller has been released. + ChipLogError(Controller, "DeviceCommissioner has been destroyed!"); return; } - auto self = static_cast(appState); + auto self = (DeviceCommissioner*) appState; auto device = self->mDeviceInPASEEstablishment; - selfShrPtr.reset(); if (nullptr != device && device->GetDeviceTransportType() == Transport::Type::kWiFiPAF) { ChipLogError(Controller, "WiFi-PAF: Subscription Error, id = %lu, err = %" CHIP_ERROR_FORMAT, device->GetDeviceId(), diff --git a/src/controller/CHIPDeviceController.h b/src/controller/CHIPDeviceController.h index 98932cb4a62e5d..5ae67e36f41455 100644 --- a/src/controller/CHIPDeviceController.h +++ b/src/controller/CHIPDeviceController.h @@ -468,7 +468,7 @@ class DLL_EXPORT DeviceCommissioner : public DeviceController, { public: DeviceCommissioner(); - ~DeviceCommissioner() override {} + ~DeviceCommissioner() override; #if CHIP_DEVICE_CONFIG_ENABLE_COMMISSIONER_DISCOVERY // make this commissioner discoverable /** @@ -821,6 +821,14 @@ class DLL_EXPORT DeviceCommissioner : public DeviceController, return ExtendArmFailSafeInternal(proxy, step, armFailSafeTimeout, commandTimeout, onSuccess, onFailure, /* fireAndForget = */ true); } +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + enum ObjChkAction{ + Set, + Check, + Clear + }; + static void SetChkObjValid(void * appState, ObjChkAction action, bool * pIsObjValid); +#endif private: DevicePairingDelegate * mPairingDelegate = nullptr; diff --git a/src/controller/SetUpCodePairer.cpp b/src/controller/SetUpCodePairer.cpp index 1dec78d80e4ca4..45aecce43b09eb 100644 --- a/src/controller/SetUpCodePairer.cpp +++ b/src/controller/SetUpCodePairer.cpp @@ -60,6 +60,13 @@ CHIP_ERROR GetPayload(const char * setUpCode, SetupPayload & payload) } } // namespace +SetUpCodePairer::~SetUpCodePairer() +{ +#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF + DeviceCommissioner::SetChkObjValid((void *)this, DeviceCommissioner::ObjChkAction::Clear, nullptr); +#endif +} + CHIP_ERROR SetUpCodePairer::PairDevice(NodeId remoteId, const char * setUpCode, SetupCodePairerBehaviour commission, DiscoveryType discoveryType, Optional resolutionData) { @@ -253,21 +260,15 @@ CHIP_ERROR SetUpCodePairer::StopConnectOverSoftAP() return CHIP_NO_ERROR; } -#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF -static std::shared_ptr SetUpCodeParserPtr; -void custom_del(SetUpCodePairer * p){}; -#endif - CHIP_ERROR SetUpCodePairer::StartDiscoverOverWiFiPAF(SetupPayload & payload) { #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF ChipLogProgress(Controller, "Starting commissioning discovery over WiFiPAF"); - VerifyOrReturnError(mCommissioner != nullptr, CHIP_ERROR_INCORRECT_STATE); mWaitingForDiscovery[kWiFiPAFTransport] = true; - SetUpCodeParserPtr.reset(this, custom_del); - CHIP_ERROR err = DeviceLayer::ConnectivityMgr().WiFiPAFConnect(payload.discriminator, (void *) (&(SetUpCodeParserPtr)), + DeviceCommissioner::SetChkObjValid((void*)this, DeviceCommissioner::ObjChkAction::Set, nullptr); + CHIP_ERROR err = DeviceLayer::ConnectivityMgr().WiFiPAFConnect(payload.discriminator, (void *) this, OnWiFiPAFSubscribeComplete, OnWiFiPAFSubscribeError); if (err != CHIP_NO_ERROR) { @@ -398,30 +399,28 @@ void SetUpCodePairer::OnWifiPAFDiscoveryError(CHIP_ERROR err) void SetUpCodePairer::OnWiFiPAFSubscribeComplete(void * appState) { - std::weak_ptr * caller = (std::weak_ptr *) (appState); - std::shared_ptr selfShrPtr = caller->lock(); - if (!selfShrPtr) - { - ChipLogError(Controller, "SetUpCodePairer is destroyed unexpectedly!"); + bool isObjValid; + DeviceCommissioner::SetChkObjValid(appState, DeviceCommissioner::ObjChkAction::Check, &isObjValid); + if (isObjValid == false) { + // The caller has been released. + ChipLogError(Controller, "SetUpCodePairer has been destroyed!"); return; } - selfShrPtr.get()->OnDiscoveredDeviceOverWifiPAF(); - // Release the ownership - selfShrPtr.reset(); + auto self = (SetUpCodePairer*) appState; + self->OnDiscoveredDeviceOverWifiPAF(); } void SetUpCodePairer::OnWiFiPAFSubscribeError(void * appState, CHIP_ERROR err) { - std::weak_ptr * caller = (std::weak_ptr *) (appState); - std::shared_ptr selfShrPtr = caller->lock(); - if (!selfShrPtr) - { - ChipLogError(Controller, "Err: SetUpCodePairer was destroyed unexpectedly!"); + bool isObjValid; + DeviceCommissioner::SetChkObjValid(appState, DeviceCommissioner::ObjChkAction::Check, &isObjValid); + if (isObjValid == false) { + // The caller has been released. + ChipLogError(Controller, "SetUpCodePairer has been destroyed!"); return; } - selfShrPtr.get()->OnWifiPAFDiscoveryError(err); - // Release the ownership - selfShrPtr.reset(); + auto self = (SetUpCodePairer*) appState; + self->OnWifiPAFDiscoveryError(err); } #endif diff --git a/src/controller/SetUpCodePairer.h b/src/controller/SetUpCodePairer.h index fe679e5ea04b42..3414341a2cdd51 100644 --- a/src/controller/SetUpCodePairer.h +++ b/src/controller/SetUpCodePairer.h @@ -77,7 +77,7 @@ class DLL_EXPORT SetUpCodePairer : public DevicePairingDelegate { public: SetUpCodePairer(DeviceCommissioner * commissioner) : mCommissioner(commissioner) {} - virtual ~SetUpCodePairer() {} + ~SetUpCodePairer(); CHIP_ERROR PairDevice(chip::NodeId remoteId, const char * setUpCode, SetupCodePairerBehaviour connectionType = SetupCodePairerBehaviour::kCommission, diff --git a/src/setup_payload/tests/TestQRCode.cpp b/src/setup_payload/tests/TestQRCode.cpp index c99cd6eded9d44..e5d68227c2956e 100644 --- a/src/setup_payload/tests/TestQRCode.cpp +++ b/src/setup_payload/tests/TestQRCode.cpp @@ -74,14 +74,15 @@ TEST(TestQRCode, TestRendezvousFlags) inPayload.rendezvousInformation.SetValue(RendezvousInformationFlags( RendezvousInformationFlag::kWiFiPAF, RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kOnNetwork)); + EXPECT_TRUE(CheckWriteRead(inPayload)); inPayload.rendezvousInformation.SetValue(RendezvousInformationFlags( RendezvousInformationFlag::kWiFiPAF, RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kOnNetwork)); + EXPECT_TRUE(CheckWriteRead(inPayload)); inPayload.rendezvousInformation.SetValue( RendezvousInformationFlags(RendezvousInformationFlag::kWiFiPAF, RendezvousInformationFlag::kBLE, RendezvousInformationFlag::kSoftAP, RendezvousInformationFlag::kOnNetwork)); - EXPECT_TRUE(CheckWriteRead(inPayload)); } From d63bd30c661d3d36f90235ae845f7198ba9753d7 Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Tue, 23 Jul 2024 13:07:55 +0000 Subject: [PATCH 31/33] Restyled by clang-format --- src/controller/CHIPDeviceController.cpp | 78 ++++++++++++++----------- src/controller/CHIPDeviceController.h | 3 +- src/controller/SetUpCodePairer.cpp | 18 +++--- 3 files changed, 55 insertions(+), 44 deletions(-) diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp index 9970aa7eb116f8..0ab74c4e3ccef3 100644 --- a/src/controller/CHIPDeviceController.cpp +++ b/src/controller/CHIPDeviceController.cpp @@ -472,7 +472,7 @@ DeviceCommissioner::DeviceCommissioner() : DeviceCommissioner::~DeviceCommissioner() { #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - SetChkObjValid((void *)this, ObjChkAction::Clear, nullptr); + SetChkObjValid((void *) this, ObjChkAction::Clear, nullptr); #endif } @@ -833,7 +833,7 @@ CHIP_ERROR DeviceCommissioner::EstablishPASEConnection(NodeId remoteDeviceId, Re ExitNow(CHIP_ERROR_INTERNAL); } mRendezvousParametersForDeviceDiscoveredOverWiFiPAF = params; - SetChkObjValid((void*)this, ObjChkAction::Set, nullptr); + SetChkObjValid((void *) this, ObjChkAction::Set, nullptr); DeviceLayer::ConnectivityMgr().WiFiPAFConnect(params.GetSetupDiscriminator().value(), (void *) this, OnWiFiPAFSubscribeComplete, OnWiFiPAFSubscribeError); ExitNow(CHIP_NO_ERROR); @@ -908,49 +908,55 @@ void DeviceCommissioner::OnDiscoveredDeviceOverBleError(void * appState, CHIP_ER #endif // CONFIG_NETWORK_LAYER_BLE #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF -void DeviceCommissioner::SetChkObjValid(void * appObj, ObjChkAction action, bool* pIsObjValid) +void DeviceCommissioner::SetChkObjValid(void * appObj, ObjChkAction action, bool * pIsObjValid) { - static std::vector ObjVector; + static std::vector ObjVector; bool IsObjValid = false; - switch (action) { - case ObjChkAction::Set: { - for (auto lt=ObjVector.begin(); lt!=ObjVector.end(); lt++) + switch (action) + { + case ObjChkAction::Set: { + for (auto lt = ObjVector.begin(); lt != ObjVector.end(); lt++) + { + if (*lt == appObj) { - if (*lt == appObj) { - IsObjValid = true; - break; - } - } - if (IsObjValid == false) { - ObjVector.push_back(appObj); IsObjValid = true; + break; } } - break; - case ObjChkAction::Check: { - for (auto lt=ObjVector.begin(); lt!=ObjVector.end(); lt++) + if (IsObjValid == false) + { + ObjVector.push_back(appObj); + IsObjValid = true; + } + } + break; + case ObjChkAction::Check: { + for (auto lt = ObjVector.begin(); lt != ObjVector.end(); lt++) + { + if (*lt == appObj) { - if (*lt == appObj) { - IsObjValid = true; - break; - } + IsObjValid = true; + break; } } - break; - case ObjChkAction::Clear: { - for (auto lt=ObjVector.begin(); lt!=ObjVector.end(); lt++) + } + break; + case ObjChkAction::Clear: { + for (auto lt = ObjVector.begin(); lt != ObjVector.end(); lt++) + { + if (*lt == appObj) { - if (*lt == appObj) { - // Already existed in the list => Remove it - ObjVector.erase(lt); - break; - } + // Already existed in the list => Remove it + ObjVector.erase(lt); + break; } } - break; } - if (pIsObjValid != nullptr) { + break; + } + if (pIsObjValid != nullptr) + { *pIsObjValid = IsObjValid; } return; @@ -960,12 +966,13 @@ void DeviceCommissioner::OnWiFiPAFSubscribeComplete(void * appState) { bool isObjValid; SetChkObjValid(appState, ObjChkAction::Check, &isObjValid); - if (isObjValid == false) { + if (isObjValid == false) + { // The caller has been released. ChipLogError(Controller, "DeviceCommissioner has been destroyed!"); return; } - auto self = (DeviceCommissioner*) appState; + auto self = (DeviceCommissioner *) appState; auto device = self->mDeviceInPASEEstablishment; if (nullptr != device && device->GetDeviceTransportType() == Transport::Type::kWiFiPAF) @@ -984,12 +991,13 @@ void DeviceCommissioner::OnWiFiPAFSubscribeError(void * appState, CHIP_ERROR err { bool isObjValid; SetChkObjValid(appState, ObjChkAction::Check, &isObjValid); - if (isObjValid == false) { + if (isObjValid == false) + { // The caller has been released. ChipLogError(Controller, "DeviceCommissioner has been destroyed!"); return; } - auto self = (DeviceCommissioner*) appState; + auto self = (DeviceCommissioner *) appState; auto device = self->mDeviceInPASEEstablishment; if (nullptr != device && device->GetDeviceTransportType() == Transport::Type::kWiFiPAF) diff --git a/src/controller/CHIPDeviceController.h b/src/controller/CHIPDeviceController.h index 5ae67e36f41455..8b6122c348ecf1 100644 --- a/src/controller/CHIPDeviceController.h +++ b/src/controller/CHIPDeviceController.h @@ -822,7 +822,8 @@ class DLL_EXPORT DeviceCommissioner : public DeviceController, /* fireAndForget = */ true); } #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - enum ObjChkAction{ + enum ObjChkAction + { Set, Check, Clear diff --git a/src/controller/SetUpCodePairer.cpp b/src/controller/SetUpCodePairer.cpp index 45aecce43b09eb..6cee0ccff6b2bb 100644 --- a/src/controller/SetUpCodePairer.cpp +++ b/src/controller/SetUpCodePairer.cpp @@ -63,7 +63,7 @@ CHIP_ERROR GetPayload(const char * setUpCode, SetupPayload & payload) SetUpCodePairer::~SetUpCodePairer() { #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - DeviceCommissioner::SetChkObjValid((void *)this, DeviceCommissioner::ObjChkAction::Clear, nullptr); + DeviceCommissioner::SetChkObjValid((void *) this, DeviceCommissioner::ObjChkAction::Clear, nullptr); #endif } @@ -267,9 +267,9 @@ CHIP_ERROR SetUpCodePairer::StartDiscoverOverWiFiPAF(SetupPayload & payload) VerifyOrReturnError(mCommissioner != nullptr, CHIP_ERROR_INCORRECT_STATE); mWaitingForDiscovery[kWiFiPAFTransport] = true; - DeviceCommissioner::SetChkObjValid((void*)this, DeviceCommissioner::ObjChkAction::Set, nullptr); - CHIP_ERROR err = DeviceLayer::ConnectivityMgr().WiFiPAFConnect(payload.discriminator, (void *) this, - OnWiFiPAFSubscribeComplete, OnWiFiPAFSubscribeError); + DeviceCommissioner::SetChkObjValid((void *) this, DeviceCommissioner::ObjChkAction::Set, nullptr); + CHIP_ERROR err = DeviceLayer::ConnectivityMgr().WiFiPAFConnect(payload.discriminator, (void *) this, OnWiFiPAFSubscribeComplete, + OnWiFiPAFSubscribeError); if (err != CHIP_NO_ERROR) { ChipLogError(Controller, "Commissioning discovery over WiFiPAF failed, err = %" CHIP_ERROR_FORMAT, err.Format()); @@ -401,12 +401,13 @@ void SetUpCodePairer::OnWiFiPAFSubscribeComplete(void * appState) { bool isObjValid; DeviceCommissioner::SetChkObjValid(appState, DeviceCommissioner::ObjChkAction::Check, &isObjValid); - if (isObjValid == false) { + if (isObjValid == false) + { // The caller has been released. ChipLogError(Controller, "SetUpCodePairer has been destroyed!"); return; } - auto self = (SetUpCodePairer*) appState; + auto self = (SetUpCodePairer *) appState; self->OnDiscoveredDeviceOverWifiPAF(); } @@ -414,12 +415,13 @@ void SetUpCodePairer::OnWiFiPAFSubscribeError(void * appState, CHIP_ERROR err) { bool isObjValid; DeviceCommissioner::SetChkObjValid(appState, DeviceCommissioner::ObjChkAction::Check, &isObjValid); - if (isObjValid == false) { + if (isObjValid == false) + { // The caller has been released. ChipLogError(Controller, "SetUpCodePairer has been destroyed!"); return; } - auto self = (SetUpCodePairer*) appState; + auto self = (SetUpCodePairer *) appState; self->OnWifiPAFDiscoveryError(err); } #endif From 1bb23bfb17e9c8e905d6f9094b377601c07224bc Mon Sep 17 00:00:00 2001 From: "Lo,Chin-Ran" Date: Thu, 25 Jul 2024 10:50:46 +0200 Subject: [PATCH 32/33] Cancel the subscription in destructor to avoid the use-after-free issue Signed-off-by: Lo,Chin-Ran --- src/controller/CHIPDeviceController.cpp | 73 +------------------ src/controller/CHIPDeviceController.h | 9 --- src/controller/SetUpCodePairer.cpp | 20 +---- src/include/platform/ConnectivityManager.h | 6 ++ .../Linux/ConnectivityManagerImpl.cpp | 36 +++++++++ src/platform/Linux/ConnectivityManagerImpl.h | 4 +- 6 files changed, 47 insertions(+), 101 deletions(-) diff --git a/src/controller/CHIPDeviceController.cpp b/src/controller/CHIPDeviceController.cpp index 0ab74c4e3ccef3..955e36bfb0d8a2 100644 --- a/src/controller/CHIPDeviceController.cpp +++ b/src/controller/CHIPDeviceController.cpp @@ -472,7 +472,7 @@ DeviceCommissioner::DeviceCommissioner() : DeviceCommissioner::~DeviceCommissioner() { #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - SetChkObjValid((void *) this, ObjChkAction::Clear, nullptr); + DeviceLayer::ConnectivityMgr().WiFiPAFCancelConnect(); #endif } @@ -833,7 +833,6 @@ CHIP_ERROR DeviceCommissioner::EstablishPASEConnection(NodeId remoteDeviceId, Re ExitNow(CHIP_ERROR_INTERNAL); } mRendezvousParametersForDeviceDiscoveredOverWiFiPAF = params; - SetChkObjValid((void *) this, ObjChkAction::Set, nullptr); DeviceLayer::ConnectivityMgr().WiFiPAFConnect(params.GetSetupDiscriminator().value(), (void *) this, OnWiFiPAFSubscribeComplete, OnWiFiPAFSubscribeError); ExitNow(CHIP_NO_ERROR); @@ -908,70 +907,8 @@ void DeviceCommissioner::OnDiscoveredDeviceOverBleError(void * appState, CHIP_ER #endif // CONFIG_NETWORK_LAYER_BLE #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF -void DeviceCommissioner::SetChkObjValid(void * appObj, ObjChkAction action, bool * pIsObjValid) -{ - static std::vector ObjVector; - bool IsObjValid = false; - - switch (action) - { - case ObjChkAction::Set: { - for (auto lt = ObjVector.begin(); lt != ObjVector.end(); lt++) - { - if (*lt == appObj) - { - IsObjValid = true; - break; - } - } - if (IsObjValid == false) - { - ObjVector.push_back(appObj); - IsObjValid = true; - } - } - break; - case ObjChkAction::Check: { - for (auto lt = ObjVector.begin(); lt != ObjVector.end(); lt++) - { - if (*lt == appObj) - { - IsObjValid = true; - break; - } - } - } - break; - case ObjChkAction::Clear: { - for (auto lt = ObjVector.begin(); lt != ObjVector.end(); lt++) - { - if (*lt == appObj) - { - // Already existed in the list => Remove it - ObjVector.erase(lt); - break; - } - } - } - break; - } - if (pIsObjValid != nullptr) - { - *pIsObjValid = IsObjValid; - } - return; -} - void DeviceCommissioner::OnWiFiPAFSubscribeComplete(void * appState) { - bool isObjValid; - SetChkObjValid(appState, ObjChkAction::Check, &isObjValid); - if (isObjValid == false) - { - // The caller has been released. - ChipLogError(Controller, "DeviceCommissioner has been destroyed!"); - return; - } auto self = (DeviceCommissioner *) appState; auto device = self->mDeviceInPASEEstablishment; @@ -989,14 +926,6 @@ void DeviceCommissioner::OnWiFiPAFSubscribeComplete(void * appState) void DeviceCommissioner::OnWiFiPAFSubscribeError(void * appState, CHIP_ERROR err) { - bool isObjValid; - SetChkObjValid(appState, ObjChkAction::Check, &isObjValid); - if (isObjValid == false) - { - // The caller has been released. - ChipLogError(Controller, "DeviceCommissioner has been destroyed!"); - return; - } auto self = (DeviceCommissioner *) appState; auto device = self->mDeviceInPASEEstablishment; diff --git a/src/controller/CHIPDeviceController.h b/src/controller/CHIPDeviceController.h index 8b6122c348ecf1..4b876156199735 100644 --- a/src/controller/CHIPDeviceController.h +++ b/src/controller/CHIPDeviceController.h @@ -821,15 +821,6 @@ class DLL_EXPORT DeviceCommissioner : public DeviceController, return ExtendArmFailSafeInternal(proxy, step, armFailSafeTimeout, commandTimeout, onSuccess, onFailure, /* fireAndForget = */ true); } -#if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - enum ObjChkAction - { - Set, - Check, - Clear - }; - static void SetChkObjValid(void * appState, ObjChkAction action, bool * pIsObjValid); -#endif private: DevicePairingDelegate * mPairingDelegate = nullptr; diff --git a/src/controller/SetUpCodePairer.cpp b/src/controller/SetUpCodePairer.cpp index 6cee0ccff6b2bb..99e991dfe8c114 100644 --- a/src/controller/SetUpCodePairer.cpp +++ b/src/controller/SetUpCodePairer.cpp @@ -63,7 +63,7 @@ CHIP_ERROR GetPayload(const char * setUpCode, SetupPayload & payload) SetUpCodePairer::~SetUpCodePairer() { #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF - DeviceCommissioner::SetChkObjValid((void *) this, DeviceCommissioner::ObjChkAction::Clear, nullptr); + DeviceLayer::ConnectivityMgr().WiFiPAFCancelConnect(); #endif } @@ -266,8 +266,6 @@ CHIP_ERROR SetUpCodePairer::StartDiscoverOverWiFiPAF(SetupPayload & payload) ChipLogProgress(Controller, "Starting commissioning discovery over WiFiPAF"); VerifyOrReturnError(mCommissioner != nullptr, CHIP_ERROR_INCORRECT_STATE); mWaitingForDiscovery[kWiFiPAFTransport] = true; - - DeviceCommissioner::SetChkObjValid((void *) this, DeviceCommissioner::ObjChkAction::Set, nullptr); CHIP_ERROR err = DeviceLayer::ConnectivityMgr().WiFiPAFConnect(payload.discriminator, (void *) this, OnWiFiPAFSubscribeComplete, OnWiFiPAFSubscribeError); if (err != CHIP_NO_ERROR) @@ -399,28 +397,12 @@ void SetUpCodePairer::OnWifiPAFDiscoveryError(CHIP_ERROR err) void SetUpCodePairer::OnWiFiPAFSubscribeComplete(void * appState) { - bool isObjValid; - DeviceCommissioner::SetChkObjValid(appState, DeviceCommissioner::ObjChkAction::Check, &isObjValid); - if (isObjValid == false) - { - // The caller has been released. - ChipLogError(Controller, "SetUpCodePairer has been destroyed!"); - return; - } auto self = (SetUpCodePairer *) appState; self->OnDiscoveredDeviceOverWifiPAF(); } void SetUpCodePairer::OnWiFiPAFSubscribeError(void * appState, CHIP_ERROR err) { - bool isObjValid; - DeviceCommissioner::SetChkObjValid(appState, DeviceCommissioner::ObjChkAction::Check, &isObjValid); - if (isObjValid == false) - { - // The caller has been released. - ChipLogError(Controller, "SetUpCodePairer has been destroyed!"); - return; - } auto self = (SetUpCodePairer *) appState; self->OnWifiPAFDiscoveryError(err); } diff --git a/src/include/platform/ConnectivityManager.h b/src/include/platform/ConnectivityManager.h index e77f5b2c827bc5..209d7484b92bda 100644 --- a/src/include/platform/ConnectivityManager.h +++ b/src/include/platform/ConnectivityManager.h @@ -182,6 +182,7 @@ class ConnectivityManager typedef void (*OnConnectionErrorFunct)(void * appState, CHIP_ERROR err); CHIP_ERROR WiFiPAFConnect(const SetupDiscriminator & connDiscriminator, void * appState, OnConnectionCompleteFunct onSuccess, OnConnectionErrorFunct onError); + CHIP_ERROR WiFiPAFCancelConnect(); CHIP_ERROR WiFiPAFSend(System::PacketBufferHandle && msgBuf); Transport::WiFiPAFBase * GetWiFiPAF(); void SetWiFiPAF(Transport::WiFiPAFBase * pmWiFiPAF); @@ -444,6 +445,11 @@ inline CHIP_ERROR ConnectivityManager::WiFiPAFConnect(const SetupDiscriminator & return static_cast(this)->_WiFiPAFConnect(connDiscriminator, appState, onSuccess, onError); } +inline CHIP_ERROR ConnectivityManager::WiFiPAFCancelConnect() +{ + return static_cast(this)->_WiFiPAFCancelConnect(); +} + inline CHIP_ERROR ConnectivityManager::WiFiPAFSend(chip::System::PacketBufferHandle && msgBuf) { return static_cast(this)->_WiFiPAFSend(std::move(msgBuf)); diff --git a/src/platform/Linux/ConnectivityManagerImpl.cpp b/src/platform/Linux/ConnectivityManagerImpl.cpp index fb122de5a4aafc..9cf41a47e49b5d 100644 --- a/src/platform/Linux/ConnectivityManagerImpl.cpp +++ b/src/platform/Linux/ConnectivityManagerImpl.cpp @@ -1444,6 +1444,20 @@ void ConnectivityManagerImpl::OnNanReceive(GVariant * obj) return; } +void ConnectivityManagerImpl::OnNanSubscribeTerminated(gint term_subscribe_id, gint reason) +{ + ChipLogProgress(Controller, "WiFi-PAF: Subscription terminated (%d, %d)", term_subscribe_id, reason); + if (mpresubscribe_id == (uint32_t) term_subscribe_id) + { + mpresubscribe_id = 0; + } + if (mpaf_info.subscribe_id == (uint32_t) term_subscribe_id) + { + mpaf_info.subscribe_id = 0; + } + return; +} + CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFConnect(const SetupDiscriminator & connDiscriminator, void * appState, OnConnectionCompleteFunct onSuccess, OnConnectionErrorFunct onError) { @@ -1478,6 +1492,7 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFConnect(const SetupDiscriminator & c wpa_fi_w1_wpa_supplicant1_interface_call_nansubscribe_sync(mWpaSupplicant.iface, args, &subscribe_id, nullptr, &err.GetReceiver()); ChipLogProgress(DeviceLayer, "WiFi-PAF: subscribe_id: [%d]", subscribe_id); + mpresubscribe_id = subscribe_id; mOnPafSubscribeComplete = onSuccess; mOnPafSubscribeError = onError; g_signal_connect(mWpaSupplicant.iface, "nan-discoveryresult", @@ -1491,6 +1506,27 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFConnect(const SetupDiscriminator & c }), this); + g_signal_connect(mWpaSupplicant.iface, "nan-subscribeterminated", + G_CALLBACK(+[](WpaFiW1Wpa_supplicant1Interface * proxy, gint term_subscribe_id, gint reason, + ConnectivityManagerImpl * self) { + return self->OnNanSubscribeTerminated(term_subscribe_id, reason); + }), + this); + + return CHIP_NO_ERROR; +} + +CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFCancelConnect() +{ + if (mpresubscribe_id == 0) + { + return CHIP_NO_ERROR; + } + GAutoPtr err; + gchar args[MAX_PAF_PUBLISH_SSI_BUFLEN]; + + snprintf(args, sizeof(args), "subscribe_id=%d", mpresubscribe_id); + wpa_fi_w1_wpa_supplicant1_interface_call_nancancel_subscribe_sync(mWpaSupplicant.iface, args, nullptr, &err.GetReceiver()); return CHIP_NO_ERROR; } diff --git a/src/platform/Linux/ConnectivityManagerImpl.h b/src/platform/Linux/ConnectivityManagerImpl.h index 5a5acfc41a6a38..2025f228532961 100644 --- a/src/platform/Linux/ConnectivityManagerImpl.h +++ b/src/platform/Linux/ConnectivityManagerImpl.h @@ -143,9 +143,10 @@ class ConnectivityManagerImpl final : public ConnectivityManager, #if CHIP_DEVICE_CONFIG_ENABLE_WIFIPAF CHIP_ERROR _WiFiPAFConnect(const SetupDiscriminator & connDiscriminator, void * appState, OnConnectionCompleteFunct onSuccess, OnConnectionErrorFunct onError); + CHIP_ERROR _WiFiPAFCancelConnect(); void OnDiscoveryResult(gboolean success, GVariant * obj); void OnNanReceive(GVariant * obj); - + void OnNanSubscribeTerminated(gint term_subscribe_id, gint reason); CHIP_ERROR _WiFiPAFSend(chip::System::PacketBufferHandle && msgBuf); Transport::WiFiPAFBase * _GetWiFiPAF(); void _SetWiFiPAF(Transport::WiFiPAFBase * pWiFiPAF); @@ -236,6 +237,7 @@ class ConnectivityManagerImpl final : public ConnectivityManager, uint8_t peer_addr[6]; uint32_t ssi_len; }; + uint32_t mpresubscribe_id; struct wpa_dbus_discov_info mpaf_info; struct wpa_dbus_nanrx_info { From 96e5c6085b7751634eb85f8d7fae6d1594357cf1 Mon Sep 17 00:00:00 2001 From: "Restyled.io" Date: Fri, 26 Jul 2024 06:29:39 +0000 Subject: [PATCH 33/33] Restyled by clang-format --- src/platform/Linux/ConnectivityManagerImpl.cpp | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/src/platform/Linux/ConnectivityManagerImpl.cpp b/src/platform/Linux/ConnectivityManagerImpl.cpp index 9cf41a47e49b5d..0ba16f90d874a9 100644 --- a/src/platform/Linux/ConnectivityManagerImpl.cpp +++ b/src/platform/Linux/ConnectivityManagerImpl.cpp @@ -1506,12 +1506,11 @@ CHIP_ERROR ConnectivityManagerImpl::_WiFiPAFConnect(const SetupDiscriminator & c }), this); - g_signal_connect(mWpaSupplicant.iface, "nan-subscribeterminated", - G_CALLBACK(+[](WpaFiW1Wpa_supplicant1Interface * proxy, gint term_subscribe_id, gint reason, - ConnectivityManagerImpl * self) { - return self->OnNanSubscribeTerminated(term_subscribe_id, reason); - }), - this); + g_signal_connect( + mWpaSupplicant.iface, "nan-subscribeterminated", + G_CALLBACK(+[](WpaFiW1Wpa_supplicant1Interface * proxy, gint term_subscribe_id, gint reason, + ConnectivityManagerImpl * self) { return self->OnNanSubscribeTerminated(term_subscribe_id, reason); }), + this); return CHIP_NO_ERROR; }