| /* |
| * |
| * Copyright (c) 2013-2017 Nest Labs, Inc. |
| * 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 |
| * Declaration of Weave Device Manager, a common class |
| * that implements discovery, pairing and provisioning of Weave |
| * devices. |
| * |
| */ |
| |
| #ifndef __WEAVEDEVICEMANAGER_H |
| #define __WEAVEDEVICEMANAGER_H |
| |
| // This module uses Legacy WDM (V2) |
| #include <Weave/Profiles/data-management/Legacy/WdmManagedNamespace.h> |
| |
| #include <Weave/Support/NLDLLUtil.h> |
| #include <Weave/Core/WeaveCore.h> |
| #include <Weave/Core/WeaveTLV.h> |
| #include <Weave/Profiles/common/WeaveMessage.h> |
| #include <Weave/Profiles/data-management/DataManagement.h> |
| #include <Weave/Profiles/data-management/ProfileDatabase.h> |
| #include <Weave/Profiles/device-description/DeviceDescription.h> |
| #include <Weave/Profiles/locale/LocaleProfile.hpp> |
| #include <Weave/Profiles/network-provisioning/NetworkProvisioning.h> |
| #include <Weave/Profiles/network-provisioning/NetworkInfo.h> |
| #include <Weave/Profiles/security/WeaveSecurity.h> |
| #include <Weave/Profiles/security/WeaveCASE.h> |
| #include <Weave/Profiles/service-directory/ServiceDirectory.h> |
| #include <Weave/Profiles/status-report/StatusReportProfile.h> |
| #include <Weave/Profiles/token-pairing/TokenPairing.h> |
| #include <Weave/Profiles/vendor/nestlabs/dropcam-legacy-pairing/DropcamLegacyPairing.h> |
| #include <Weave/Profiles/vendor/nestlabs/thermostat/NestThermostatWeaveConstants.h> |
| |
| namespace nl { |
| namespace Weave { |
| namespace DeviceManager { |
| |
| using namespace nl::Weave::Profiles; |
| using namespace nl::Weave::Profiles::DataManagement; |
| using namespace nl::Weave::Profiles::DeviceDescription; |
| using namespace nl::Weave::Profiles::Vendor::Nestlabs::DropcamLegacyPairing; |
| using namespace nl::Weave::Profiles::NetworkProvisioning; |
| |
| using NetworkProvisioning::NetworkType; |
| using NetworkProvisioning::WiFiMode; |
| using NetworkProvisioning::WiFiRole; |
| using NetworkProvisioning::WiFiSecurityType; |
| using DeviceDescription::IdentifyDeviceCriteria; |
| |
| static const uint16_t MAX_ENUMERATED_DEVICES = 256; // Size (arbitrarily chosen) of table to de-dupe enumerated node IDs. |
| |
| |
| class DeviceStatus |
| { |
| public: |
| uint32_t StatusProfileId; |
| uint16_t StatusCode; |
| uint32_t SystemErrorCode; |
| }; |
| |
| class WeaveDeviceManager; |
| |
| extern "C" |
| { |
| typedef void (*CompleteFunct)(WeaveDeviceManager *deviceMgr, void *appReqState); |
| typedef void (*IdentifyDeviceCompleteFunct)(WeaveDeviceManager *deviceMgr, void *appReqState, const DeviceDescription::WeaveDeviceDescriptor *devdesc); |
| typedef void (*DeviceEnumerationResponseFunct)(WeaveDeviceManager *deviceMgr, void *appReqState, const DeviceDescription::WeaveDeviceDescriptor *devdesc, |
| IPAddress deviceAddr, InterfaceId deviceIntf); |
| typedef void (*NetworkScanCompleteFunct)(WeaveDeviceManager *deviceMgr, void *appReqState, uint16_t netCount, const NetworkInfo *netInfoList); |
| typedef void (*GetNetworksCompleteFunct)(WeaveDeviceManager *deviceMgr, void *appReqState, uint16_t netCount, const NetworkInfo *netInfoList); |
| typedef void (*AddNetworkCompleteFunct)(WeaveDeviceManager *deviceMgr, void *appReqState, uint32_t networkId); |
| typedef void (*GetRendezvousModeCompleteFunct)(WeaveDeviceManager *deviceMgr, void *appReqState, uint16_t modeFlags); |
| typedef void (*GetFabricConfigCompleteFunct)(WeaveDeviceManager *deviceMgr, void *appReqState, const uint8_t *fabricConfig, uint32_t fabricConfigLen); |
| typedef void (*ErrorFunct)(WeaveDeviceManager *deviceMgr, void *appReqState, WEAVE_ERROR err, DeviceStatus *devStatus); |
| typedef void (*StartFunct)(WeaveDeviceManager *deviceMgr, void *appReqState, WeaveConnection *con); |
| typedef void (*ConnectionClosedFunc)(WeaveDeviceManager *deviceMgr, void *appReqState, WeaveConnection *con, WEAVE_ERROR conErr); |
| typedef void (*GetActiveLocaleCompleteFunct)(WeaveDeviceManager *deviceMgr, void *appReqState, const char *activeLocale); |
| typedef void (*GetAvailableLocalesCompleteFunct)(WeaveDeviceManager *deviceMgr, void *appReqState, uint16_t localeCount, const char **localeList); |
| typedef void (*ThermostatGetEntryKeyCompleteFunct)(WeaveDeviceManager *deviceMgr, void *appReqState, const char *entryKey); |
| typedef void (*ThermostatSystemTestStatusCompleteFunct)(WeaveDeviceManager *deviceMgr, void *appReqState, uint64_t systemTestStatus); |
| typedef void (*PairTokenCompleteFunct)(WeaveDeviceManager *deviceMgr, void *appReqState, const uint8_t *tokenPairingBundle, uint32_t tokenPairingBunldeLen); |
| typedef void (*UnpairTokenCompleteFunct)(WeaveDeviceManager *deviceMgr, void *appReqState); |
| typedef void (*GetCameraAuthDataCompleteFunct)(WeaveDeviceManager *deviceMgr, void *appReqState, const char *macAddress, const char *authData); |
| |
| /** |
| * callback when hush operation completed with a proper response message |
| * |
| * @param[in] hushResult result of the hush operation. possible values are in the kAlarmHushResult_ family |
| * @param[in] length number of valid entries in the conditions array |
| * @param[in] conditions array of alarm conditions. data pointed by this pointer would be invalid after the call |
| * |
| */ |
| typedef void (*HushCompleteFunct)(WeaveDeviceManager *deviceMgr, void *appReqState, uint8_t hushResult, uint8_t length, const uint8_t *conditions); |
| } |
| ; |
| |
| class NL_DLL_EXPORT WeaveDeviceManager : private Security::CASE::WeaveCASEAuthDelegate |
| { |
| public: |
| enum |
| { |
| kState_NotInitialized = 0, |
| kState_Initialized = 1 |
| } State; // [READ-ONLY] Current state |
| |
| WeaveDeviceManager(); |
| |
| void *AppState; |
| |
| WEAVE_ERROR Init(WeaveExchangeManager *exchangeMsg, WeaveSecurityManager *securityMgr); |
| WEAVE_ERROR Shutdown(); |
| |
| // ----- Device Information ----- |
| WEAVE_ERROR GetDeviceId(uint64_t& deviceId); |
| WEAVE_ERROR GetDeviceAddress(IPAddress& deviceAddr); |
| WEAVE_ERROR IdentifyDevice(void *appReqState, IdentifyDeviceCompleteFunct onComplete, ErrorFunct onError); |
| |
| WEAVE_ERROR StartDeviceEnumeration(void *appReqState, const IdentifyDeviceCriteria &deviceCriteria, DeviceEnumerationResponseFunct onResponse, ErrorFunct onError); |
| void StopDeviceEnumeration(); |
| |
| // ----- Connection Management ----- |
| // TODO WEAV-1573: Add support for InterfaceId specification for ConnectDevice APIs |
| WEAVE_ERROR ConnectDevice(uint64_t deviceId, IPAddress deviceAddr, |
| void *appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR ConnectDevice(uint64_t deviceId, IPAddress deviceAddr, const char *pairingCode, |
| void *appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR ConnectDevice(uint64_t deviceId, IPAddress deviceAddr, const uint8_t *accessToken, uint32_t accessTokenLen, |
| void *appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR RendezvousDevice(const IdentifyDeviceCriteria &deviceCriteria, |
| void *appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR RendezvousDevice(const char *pairingCode, const IdentifyDeviceCriteria &deviceCriteria, |
| void *appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR RendezvousDevice(const uint8_t *accessToken, uint32_t accessTokenLen, const IdentifyDeviceCriteria &deviceCriteria, |
| void *appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR PassiveRendezvousDevice(void *appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR PassiveRendezvousDevice(const char *pairingCode, void *appReqState, CompleteFunct onComplete, ErrorFunct onError, StartFunct onStart = NULL); |
| WEAVE_ERROR PassiveRendezvousDevice(const uint8_t *accessToken, uint32_t accessTokenLen, void *appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| #if CONFIG_NETWORK_LAYER_BLE |
| WEAVE_ERROR ConnectBle(BLE_CONNECTION_OBJECT connObj, |
| void *appReqState, CompleteFunct onComplete, ErrorFunct onError, bool autoClose = true); |
| WEAVE_ERROR ConnectBle(BLE_CONNECTION_OBJECT connObj, const char *pairingCode, |
| void *appReqState, CompleteFunct onComplete, ErrorFunct onError, bool autoClose = true); |
| WEAVE_ERROR ConnectBle(BLE_CONNECTION_OBJECT connObj, const uint8_t *accessToken, uint32_t accessTokenLen, |
| void *appReqState, CompleteFunct onComplete, ErrorFunct onError, bool autoClose = true); |
| #endif // CONFIG_NETWORK_LAYER_BLE |
| |
| // ----- Remote Passive Rendezvous ----- |
| |
| // In all 3 functions below, the rendezvousDeviceAddr parameter may be specified as IPAddress::Any. Otherwise, |
| // the assisting device will turn away all would-be joiners if their IP address does not match the specified value. |
| // The assisting device turns these devices away before ever forming a tunnel between the DM and would-be joiner. |
| |
| // Perform Remote Passive Rendezvous with CASE authentication for rendezvoused device. DM will attempt to |
| // authenticate each rendezvoused, would-be joiner using the given CASE credentials. If a device fails to |
| // authenticate, the DM will close its tunneled connection to that device and reconnect to the assisting device, |
| // starting over the RPR process to listen for new connections on its unsecured Weave port. This cycle repeats |
| // until either the rendezvous timeout expires or a joiner successfully authenticates. |
| // |
| // The CASE variant of this function is provided for the sake of completeness. It is expected that only the PASE |
| // variant will be used to perform RPR in the case of Thread-assisted pairing. |
| WEAVE_ERROR RemotePassiveRendezvous(const IPAddress rendezvousDeviceAddr, const uint8_t *accessToken, |
| uint32_t accessTokenLen, const uint16_t rendezvousTimeoutSec, const uint16_t inactivityTimeoutSec, |
| void *appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| |
| // Perform Remote Passive Rendezvous with PASE authentication for rendezvoused device. DM will attempt to |
| // authenticate each rendezvoused, would-be joiner using the given PASE credentials. If a device fails to |
| // authenticate, the DM will close its tunneled connection to that device and reconnect to the assisting device, |
| // starting over the RPR process to listen for new connections on its unsecured Weave port. This cycle repeats |
| // until either the rendezvous timeout expires or a joiner successfully authenticates. |
| // |
| // It is expected that this function will be used to perform RPR in the case of Thread-assisted pairing. |
| WEAVE_ERROR RemotePassiveRendezvous(const IPAddress rendezvousDeviceAddr, const char *pairingCode, |
| const uint16_t rendezvousTimeoutSec, const uint16_t inactivityTimeoutSec, void *appReqState, |
| CompleteFunct onComplete, ErrorFunct onError); |
| |
| // Perform Remote Passive Rendezvous with no authentication for rendezvoused device, i.e. DM will accept |
| // first tunnel handed to it by assisting device without question. |
| // |
| // The no-auth variant of this function is provided for the sake of completeness. It is expected that only the |
| // PASE varient will be used to perform RPR in the case of Thread-assisted pairing. |
| WEAVE_ERROR RemotePassiveRendezvous(const IPAddress rendezvousDeviceAddr, const uint16_t rendezvousTimeoutSec, |
| const uint16_t inactivityTimeoutSec, void *appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| |
| WEAVE_ERROR ReconnectDevice(void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR EnableConnectionMonitor(uint16_t interval, uint16_t timeout, void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR DisableConnectionMonitor(void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR SetRendezvousAddress(IPAddress addr); |
| WEAVE_ERROR SetAutoReconnect(bool autoReconnect); |
| WEAVE_ERROR SetUseAccessToken(bool useAccessToken); |
| WEAVE_ERROR SetRendezvousLinkLocal(bool RendezvousLinkLocal); |
| WEAVE_ERROR SetConnectTimeout(uint32_t timeoutMS); |
| void Close(); |
| void Close(bool graceful); |
| void CloseDeviceConnection(); |
| void CloseDeviceConnection(bool graceful); |
| bool IsConnected() const; |
| void SetConnectionClosedCallback(ConnectionClosedFunc onConnecionClosedFunc, void *onConnecionClosedAppReq); |
| |
| // ----- Network Provisioning ----- |
| WEAVE_ERROR ScanNetworks(NetworkType networkType, void* appReqState, NetworkScanCompleteFunct onComplete, |
| ErrorFunct onError); |
| WEAVE_ERROR AddNetwork(const NetworkInfo *netInfo, void* appReqState, AddNetworkCompleteFunct onComplete, |
| ErrorFunct onError); |
| WEAVE_ERROR UpdateNetwork(const NetworkInfo *netInfo, void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR RemoveNetwork(uint32_t networkId, void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR GetNetworks(uint8_t flags, void* appReqState, GetNetworksCompleteFunct onComplete, |
| ErrorFunct onError); |
| WEAVE_ERROR EnableNetwork(uint32_t networkId, void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR DisableNetwork(uint32_t networkId, void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR TestNetworkConnectivity(uint32_t networkId, void* appReqState, CompleteFunct onComplete, |
| ErrorFunct onError); |
| WEAVE_ERROR GetRendezvousMode(void* appReqState, GetRendezvousModeCompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR SetRendezvousMode(uint16_t modeFlags, void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR GetLastNetworkProvisioningResult(void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| |
| // ----- Fabric Provisioning ----- |
| WEAVE_ERROR CreateFabric(void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR LeaveFabric(void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR GetFabricConfig(void* appReqState, GetFabricConfigCompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR JoinExistingFabric(const uint8_t *fabricConfig, uint32_t fabricConfigLen, void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| |
| // ----- Service Provisioning ----- |
| WEAVE_ERROR RegisterServicePairAccount(uint64_t serviceId, const char *accountId, |
| const uint8_t *serviceConfig, uint16_t serviceConfigLen, |
| const uint8_t *pairingToken, uint16_t pairingTokenLen, |
| const uint8_t *pairingInitData, uint16_t pairingInitDataLen, |
| void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR UpdateService(uint64_t serviceId, const uint8_t *serviceConfig, uint16_t serviceConfigLen, |
| void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR UnregisterService(uint64_t serviceId, void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| |
| // ----- Device Control ----- |
| WEAVE_ERROR ArmFailSafe(uint8_t armMode, uint32_t failSafeToken, void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR DisarmFailSafe(void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR GetCameraAuthData(const char* nonce, void* appReqState, GetCameraAuthDataCompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR ResetConfig(uint16_t resetFlags, void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| |
| WEAVE_ERROR SignedHush(uint32_t proximityVerificationCode, uint32_t challenge, uint16_t keyId, const uint8_t *key, uint16_t keySize, |
| void* appReqState, HushCompleteFunct onHushComplete, ErrorFunct onError); |
| WEAVE_ERROR StartSystemTest(void* appReqState, uint32_t profileId, uint32_t testId, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR StopSystemTest(void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| |
| // ----- Locale ----- |
| WEAVE_ERROR GetActiveLocale(void* appReqState, GetActiveLocaleCompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR SetActiveLocale(void* appReqState, const char *aLocale, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR GetAvailableLocales(void* appReqState, GetAvailableLocalesCompleteFunct onComplete, ErrorFunct onError); |
| |
| // ---- Thermostat ---- |
| WEAVE_ERROR ThermostatGetEntryKey(void* appReqState, ThermostatGetEntryKeyCompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR ThermostatSystemTestStatus(void* appReqState, ThermostatSystemTestStatusCompleteFunct onComplete, ErrorFunct onError); |
| |
| // ---- Token Pairing ---- |
| WEAVE_ERROR PairToken(const uint8_t *pairingToken, uint32_t pairingTokenLen, void* appReqState, PairTokenCompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR UnpairToken(void* appReqState, UnpairTokenCompleteFunct onComplete, ErrorFunct onError); |
| |
| // ----- Misc Operations ----- |
| WEAVE_ERROR Ping(void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| WEAVE_ERROR Ping(void* appReqState, int32_t payloadSize, CompleteFunct onComplete, ErrorFunct onError); |
| static bool IsValidPairingCode(const char *pairingCode); |
| |
| // ----- Node ID List Utils ----- |
| static WEAVE_ERROR AddNodeToList(uint64_t nodeId, uint64_t* &list, uint32_t &listLen, uint32_t &listMaxLen, uint32_t initialMaxLen); |
| static bool IsNodeInList(uint64_t nodeId, uint64_t* list, uint32_t listLen); |
| |
| // ----- DEPRECATED Methods ----- |
| WEAVE_ERROR SetWiFiRendezvousAddress(IPAddress addr); // DEPRECATED -- Use SetRendezvousAddress() |
| WEAVE_ERROR RendezvousDevice(const char *pairingCode, void* appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| |
| private: |
| enum OpState |
| { |
| kOpState_Idle = 0, |
| kOpState_RendezvousDevice = 1, |
| kOpState_ConnectDevice = 2, |
| kOpState_ReconnectDevice = 3, |
| kOpState_IdentifyDevice = 5, |
| kOpState_ScanNetworks = 6, |
| kOpState_GetNetworks = 7, |
| kOpState_GetNetworkConfig = 8, |
| kOpState_AddNetwork = 9, |
| kOpState_UpdateNetwork = 10, |
| kOpState_RemoveNetwork = 11, |
| kOpState_EnableNetwork = 12, |
| kOpState_DisableNetwork = 13, |
| kOpState_TestNetworkConnectivity = 14, |
| kOpState_GetRendezvousMode = 15, |
| kOpState_SetRendezvousMode = 16, |
| kOpState_CreateFabric = 17, |
| kOpState_LeaveFabric = 18, |
| kOpState_GetFabricConfig = 19, |
| kOpState_JoinExistingFabric = 20, |
| kOpState_RegisterServicePairAccount = 21, |
| kOpState_UpdateService = 22, |
| kOpState_UnregisterService = 23, |
| kOpState_ArmFailSafe = 24, |
| kOpState_DisarmFailSafe = 25, |
| kOpState_ResetConfig = 26, |
| kOpState_Ping = 27, |
| kOpState_EnableConnectionMonitor = 28, |
| kOpState_DisableConnectionMonitor = 29, |
| kOpState_GetLastNPResult = 30, |
| kOpState_PassiveRendezvousDevice = 31, |
| kOpState_RemotePassiveRendezvousRequest = 32, |
| kOpState_AwaitingRemoteConnectionComplete = 33, |
| kOpState_RemotePassiveRendezvousAuthenticate = 34, |
| kOpState_RestartRemotePassiveRendezvous = 35, |
| kOpState_InitializeBleConnection = 36, |
| kOpState_Hush = 37, |
| kOpState_GetActiveLocale = 38, |
| kOpState_SetActiveLocale = 39, |
| kOpState_GetAvailableLocales = 40, |
| kOpState_ThermostatGetEntryKey = 41, |
| kOpState_ThermostatSystemTestStatus = 42, |
| kOpState_StartSystemTest = 43, |
| kOpState_StopSystemTest = 44, |
| kOpState_PairToken = 45, |
| kOpState_UnpairToken = 46, |
| kOpState_GetCameraAuthData = 47, |
| kOpState_EnumerateDevices = 48, |
| kOpState_RemotePassiveRendezvousTimedOut = 49 |
| }; |
| |
| enum ConnectionState |
| { |
| kConnectionState_NotConnected = 0, |
| kConnectionState_WaitDeviceConnect = 1, |
| kConnectionState_IdentifyDevice = 2, |
| kConnectionState_ConnectDevice = 3, |
| kConnectionState_StartSession = 4, |
| kConnectionState_ReenableConnectionMonitor = 5, |
| kConnectionState_Connected = 6, |
| kConnectionState_IdentifyRemoteDevice = 7 |
| }; |
| |
| enum |
| { |
| kMaxPairingCodeLength = 16, |
| |
| kConRetryInterval = 500, // ms |
| kEnumerateDevicesRetryInterval = 500, // ms |
| kSessionRetryInterval = 1000, // ms |
| kMaxSessionRetryCount = 20, |
| }; |
| |
| enum |
| { |
| kAuthType_None = 0, |
| kAuthType_PASEWithPairingCode = 1, |
| kAuthType_CASEWithAccessToken = 2 |
| }; |
| |
| enum |
| { |
| // Max Validation Certs -- This controls the maximum number of certificates |
| // that can be involved in the validation of peer's certificate. It must |
| // include room for the peer's entity cert, our trust anchors and any intermediate |
| // certs given to us by the peer in the CASE BeginSession request/response. |
| kMaxCASECerts = 10, |
| |
| // Certificate Decode Buffer Size -- Size of the temporary buffer used to decode |
| // certs. The buffer must be big enough to hold the ASN1 DER encoding of the |
| // TBSCertificate portion of the largest cert involved in CASE authentication |
| // of the peer, not including the trust anchors. Note that all certificates |
| // by the peer are decoded using this buffer, even if they are ultimately not |
| // involved in authenticating the peer. |
| kCertDecodeBufferSize = 1024 |
| }; |
| |
| class WDMDMClient : public nl::Weave::Profiles::DataManagement::DMClient |
| { |
| public: |
| WDMDMClient(void); |
| ~WDMDMClient(void); |
| |
| WEAVE_ERROR InitClient(WeaveDeviceManager *aDeviceMgr, WeaveExchangeManager *aExchangeMgr); |
| |
| WEAVE_ERROR ViewConfirm(const uint64_t &aResponderId, StatusReport &aStatus, uint16_t aTxnId); |
| WEAVE_ERROR ViewConfirm(const uint64_t &aResponderId, ReferencedTLVData &aDataList, uint16_t aTxnId); |
| WEAVE_ERROR UpdateConfirm(const uint64_t &aResponderId, StatusReport &aStatus, uint16_t aTxnId); |
| using nl::Weave::Profiles::DataManagement::ProtocolEngine::IncompleteIndication; |
| void IncompleteIndication(const uint64_t &aPeerNodeId, StatusReport &aReport); |
| |
| #if WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| WEAVE_ERROR SubscribeConfirm(const uint64_t &aResponderId, StatusReport &aStatus, uint16_t aTxnId); |
| WEAVE_ERROR SubscribeConfirm(const uint64_t &aResponderId, const TopicIdentifier &aTopicId, uint16_t aTxnId); |
| WEAVE_ERROR SubscribeConfirm(const uint64_t &aResponderId, const TopicIdentifier &aTopicId, ReferencedTLVData &aDataList, uint16_t aTxnId); |
| WEAVE_ERROR UnsubscribeIndication(const uint64_t &aPublisherId, const TopicIdentifier &aTopicId, StatusReport &aReport); |
| WEAVE_ERROR CancelSubscriptionConfirm(const uint64_t &aResponderId, const TopicIdentifier &aTopicId, StatusReport &aStatus, uint16_t aTxnId); |
| WEAVE_ERROR NotifyIndication(const TopicIdentifier &aTopicId, ReferencedTLVData &aDataList); |
| |
| #endif // WEAVE_CONFIG_WDM_ALLOW_CLIENT_SUBSCRIPTION |
| |
| private: |
| WeaveDeviceManager *mDeviceMgr; |
| }; |
| |
| System::Layer* mSystemLayer; |
| WeaveMessageLayer *mMessageLayer; |
| WeaveExchangeManager *mExchangeMgr; |
| WeaveSecurityManager *mSecurityMgr; |
| ConnectionState mConState; |
| WeaveConnection *mDeviceCon; |
| OpState mOpState; |
| void *mAppReqState; |
| union |
| { |
| CompleteFunct General; |
| IdentifyDeviceCompleteFunct IdentifyDevice; |
| NetworkScanCompleteFunct ScanNetworks; |
| GetNetworksCompleteFunct GetNetworks; |
| AddNetworkCompleteFunct AddNetwork; |
| GetRendezvousModeCompleteFunct GetRendezvousMode; |
| GetFabricConfigCompleteFunct GetFabricConfig; |
| HushCompleteFunct Hush; |
| GetActiveLocaleCompleteFunct GetActiveLocale; |
| GetAvailableLocalesCompleteFunct GetAvailableLocales; |
| ThermostatGetEntryKeyCompleteFunct ThermostatGetEntryKey; |
| ThermostatSystemTestStatusCompleteFunct ThermostatSystemStatus; |
| PairTokenCompleteFunct PairToken; |
| UnpairTokenCompleteFunct UnpairToken; |
| GetCameraAuthDataCompleteFunct GetCameraAuthData; |
| DeviceEnumerationResponseFunct DeviceEnumeration; |
| } mOnComplete; |
| CompleteFunct mOnRemotePassiveRendezvousComplete; |
| ErrorFunct mOnError; |
| StartFunct mOnStart; |
| ConnectionClosedFunc mOnConnectionClosedFunc; |
| void *mOnConnectionClosedAppReq; |
| ExchangeContext *mCurReq; |
| uint32_t mCurReqProfileId; |
| uint16_t mCurReqMsgType; |
| PacketBuffer *mCurReqMsg; |
| ExchangeContext::MessageReceiveFunct mCurReqRcvFunct; |
| IPAddress mRendezvousAddr; |
| IPAddress mDeviceAddr; |
| IPAddress mAssistingDeviceAddr; |
| IPAddress mRemoteDeviceAddr; |
| InterfaceId mDeviceIntf; |
| InterfaceId mAssistingDeviceIntf; |
| IdentifyDeviceCriteria mDeviceCriteria; |
| uint64_t mDeviceId; |
| uint64_t mAssistingDeviceId; |
| uint32_t mConTimeout; // in ms; 0 means disabled. |
| uint32_t mConTryCount; |
| uint16_t mSessionKeyId; |
| uint8_t mEncType; |
| uint8_t mAuthType; |
| uint8_t mAssistingDeviceAuthType; |
| uint8_t mRemoteDeviceAuthType; |
| char *mCameraNonce; |
| void *mAuthKey; |
| void *mAssistingDeviceAuthKey; |
| void *mRemoteDeviceAuthKey; |
| uint32_t mAuthKeyLen; |
| uint32_t mAssistingDeviceAuthKeyLen; |
| uint32_t mRemoteDeviceAuthKeyLen; |
| uint32_t mConMonitorInterval; // in ms; 0 means disabled. |
| uint32_t mConMonitorTimeout; // in ms; 0 means disabled. |
| uint32_t mRemotePassiveRendezvousTimeout; // in seconds; 0 means disabled. |
| uint32_t mRemotePassiveRendezvousInactivityTimeout; // in seconds; 0 means disabled. |
| bool mRemotePassiveRendezvousTimerIsRunning; |
| bool mConMonitorEnabled; |
| bool mAutoReconnect; |
| bool mRendezvousLinkLocal; |
| bool mUseAccessToken; |
| bool mConnectedToRemoteDevice; // Used to determine whether to allow auto-reconnect. |
| bool mIsUnsecuredConnectionListenerSet; |
| WDMDMClient mDMClient; |
| const char *mActiveLocale; |
| uint32_t mPingSize; |
| uint8_t *mTokenPairingCertificate; |
| uint32_t mTokenPairingCertificateLen; |
| uint64_t *mEnumeratedNodes; |
| uint32_t mEnumeratedNodesLen; |
| uint32_t mEnumeratedNodesMaxLen; |
| |
| // Use by static HandleConnectionReceived callback. |
| static WeaveDeviceManager *sListeningDeviceMgr; |
| |
| WEAVE_ERROR DoRemotePassiveRendezvous(const IPAddress rendezvousDeviceAddr, const uint16_t rendezvousTimeout, |
| const uint16_t inactivityTimeout, void *appReqState, CompleteFunct onComplete, ErrorFunct onError); |
| |
| WEAVE_ERROR SendRequest(uint32_t profileId, uint16_t msgType, PacketBuffer *msgBuf, |
| ExchangeContext::MessageReceiveFunct onMsgRcvd); |
| WEAVE_ERROR SendPendingRequest(); |
| |
| WEAVE_ERROR SaveAuthKey(const char *pairingCode); |
| WEAVE_ERROR SaveAuthKey(const uint8_t *accessToken, uint32_t accessTokenLen); |
| void ClearAuthKey(); |
| void ClearAuthKey(void *&authKey, uint32_t &authKeyLen); |
| |
| WEAVE_ERROR SaveRemoteDeviceAuthInfo(uint8_t authType, const char *authKey, uint32_t authKeyLen); |
| void ClearRemoteDeviceAuthInfo(); |
| |
| void ClearRequestState(); |
| void ClearOpState(); |
| |
| static void HandleRequestConnectionClosed(ExchangeContext *ec, WeaveConnection *con, WEAVE_ERROR conErr); |
| |
| WEAVE_ERROR InitiateDeviceEnumeration(); |
| WEAVE_ERROR InitiateConnection(); |
| #if CONFIG_NETWORK_LAYER_BLE |
| WEAVE_ERROR InitiateBleConnection(BLE_CONNECTION_OBJECT connObj, void *appReqState, CompleteFunct onComplete, ErrorFunct onError, bool autoClose); |
| #endif // CONFIG_NETWORK_LAYER_BLE |
| |
| static WEAVE_ERROR FilterIdentifyResponse(IdentifyResponseMessage &respMsg, IdentifyDeviceCriteria criteria, uint64_t sourceNodeId, bool& isMatch); |
| |
| static void HandleDeviceEnumerationIdentifyResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo, |
| const WeaveMessageInfo *msgInfo, uint32_t profileId, uint8_t msgType, PacketBuffer *payload); |
| static void HandleDeviceEnumerationTimeout(System::Layer *aSystemLayer, void *aAppState, System::Error aError); |
| |
| static void HandleConnectionIdentifyResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo, |
| const WeaveMessageInfo *msgInfo, uint32_t profileId, uint8_t msgType, PacketBuffer *payload); |
| static void HandleConnectionIdentifyTimeout(System::Layer *aSystemLayer, void *aAppState, System::Error aError); |
| |
| WEAVE_ERROR SetUnsecuredConnectionHandler(); |
| WEAVE_ERROR ClearUnsecuredConnectionHandler(); |
| |
| WEAVE_ERROR StartConnectDevice(uint64_t deviceId, IPAddress deviceAddr); |
| static void HandleConnectionComplete(WeaveConnection *con, WEAVE_ERROR conErr); |
| static void HandleConnectionClosed(WeaveConnection *con, WEAVE_ERROR conErr); |
| static void HandleConnectionReceived(WeaveMessageLayer *msgLayer, WeaveConnection *con); |
| static void HandleUnsecuredConnectionCallbackRemoved(void *appState); |
| |
| WEAVE_ERROR StartSession(); |
| static void HandleSessionEstablished(WeaveSecurityManager *sm, WeaveConnection *con, void *appReqState, |
| uint16_t sessionKeyId, uint64_t peerNodeId, uint8_t encType); |
| static void HandleSessionError(WeaveSecurityManager *sm, WeaveConnection *con, void *appReqState, |
| WEAVE_ERROR localErr, uint64_t peerNodeId, StatusReport *statusReport); |
| static void RetrySession(System::Layer* aSystemLayer, void* aAppState, System::Error aError); |
| |
| void ReenableConnectionMonitor(); |
| static void HandleReenableConnectionMonitorResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo, |
| uint32_t profileId, uint8_t msgType, PacketBuffer *payload); |
| |
| void HandleConnectionReady(); |
| |
| static void HandleIdentifyDeviceResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo, |
| uint32_t profileId, uint8_t msgType, PacketBuffer *payload); |
| |
| static void HandleNetworkProvisioningResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo, |
| uint32_t profileId, uint8_t msgType, PacketBuffer *payload); |
| |
| static void HandleGetCameraAuthDataResponseEntry(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo, |
| uint32_t profileId, uint8_t msgType, PacketBuffer *payload); |
| |
| static void HandleServiceProvisioningResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo, |
| uint32_t profileId, uint8_t msgType, PacketBuffer *payload); |
| |
| static void HandleFabricProvisioningResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo, |
| uint32_t profileId, uint8_t msgType, PacketBuffer *payload); |
| void HandleGetCameraAuthDataResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo, |
| uint32_t profileId, uint8_t msgType, PacketBuffer *payload); |
| |
| static void HandleDeviceControlResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo, |
| uint32_t profileId, uint8_t msgType, PacketBuffer *payload); |
| |
| static void HandleRemotePassiveRendezvousComplete(ExchangeContext *ec, const IPPacketInfo *pktInfo, const |
| WeaveMessageInfo *msgInfo, uint32_t profileId, uint8_t msgType, PacketBuffer *payload); |
| |
| static void HandlePingResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo, |
| uint32_t profileId, uint8_t msgType, PacketBuffer *payload); |
| |
| static void HandleHushResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo, |
| uint32_t profileId, uint8_t msgType, PacketBuffer *payload); |
| |
| static void HandlePairTokenResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo, |
| uint32_t profileId, uint8_t msgType, PacketBuffer *payload); |
| |
| static void HandleUnpairTokenResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo, |
| uint32_t profileId, uint8_t msgType, PacketBuffer *payload); |
| |
| void StartConnectionMonitorTimer(); |
| void CancelConnectionMonitorTimer(); |
| static void HandleEchoRequest(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo, |
| uint32_t profileId, uint8_t msgType, PacketBuffer *payload); |
| static void HandleConnectionMonitorTimeout(System::Layer* aSystemLayer, void* aAppState, System::Error aError); |
| |
| void HandleRemoteConnectionComplete(); |
| void CancelRemotePassiveRendezvous(); |
| |
| WEAVE_ERROR StartRemotePassiveRendezvousTimer(); |
| void CancelRemotePassiveRendezvousTimer(); |
| |
| void RestartRemotePassiveRendezvousListen(); |
| WEAVE_ERROR StartReconnectToAssistingDevice(); |
| |
| // Below methods juggle peer address, authentication, and secure session state so we can reuse existing DM |
| // components for the "RPR PASE failed -> reconnect to assisting device -> send another RPR request" code path. |
| WEAVE_ERROR SaveAssistingDeviceConnectionInfo(); // Save all information required to reconnect to the assisting |
| // device so we can continue with Remote Passive Rendezvous |
| // attempt after PASE authentication with a particular remote |
| // host fails. |
| // |
| void RestoreAssistingDeviceAddressInfo(); // Restore saved node ID, IP address, and interface |
| // information for assisting device. |
| // |
| WEAVE_ERROR RestoreAssistingDeviceAuthInfo(); // Restore saved assisting device auth info so we can |
| // reauthenticate with it from scratch. |
| // |
| void ResetConnectionInfo(); // Clear current connection and authentication information. |
| |
| void HandleRemotePassiveRendezvousReconnectComplete(); |
| static void HandleAssistingDeviceReconnectWithSessionCompleteEntry(WeaveDeviceManager *deviceMgr, |
| void *appReqState); |
| static void HandleAssistingDeviceReconnectCompleteEntry(WeaveDeviceManager *deviceMgr, void *appReqState); |
| static void HandleRemotePassiveRendezvousTimeout(System::Layer* aSystemLayer, void* aAppState, System::Error aError); |
| static void HandleRemoteConnectionComplete(ExchangeContext *ec, const IPPacketInfo *pktInfo, |
| const WeaveMessageInfo *msgInfo, uint32_t profileId, uint8_t msgType, PacketBuffer *payload); |
| static void HandleRemoteIdentifyResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo, |
| const WeaveMessageInfo *msgInfo, uint32_t profileId, uint8_t msgType, PacketBuffer *payload); |
| static void HandleRemoteIdentifyConnectionClosed(ExchangeContext *ec, WeaveConnection *con, WEAVE_ERROR conErr); |
| static void HandleRemoteIdentifyTimeout(ExchangeContext *ec); |
| |
| static WEAVE_ERROR DecodeStatusReport(PacketBuffer *msgBuf, DeviceStatus& status); |
| static WEAVE_ERROR DecodeNetworkInfoList(PacketBuffer *buf, uint16_t& count, NetworkInfo *& netInfoList); |
| |
| // CASE auth delegate methods |
| virtual WEAVE_ERROR GetNodeCertInfo(bool isInitiator, uint8_t *buf, uint16_t bufSize, uint16_t& certInfoLen); |
| virtual WEAVE_ERROR GetNodePrivateKey(bool isInitiator, const uint8_t *& weavePrivKey, uint16_t& weavePrivKeyLen); |
| virtual WEAVE_ERROR ReleaseNodePrivateKey(const uint8_t *weavePrivKey); |
| virtual WEAVE_ERROR GetNodePayload(bool isInitiator, uint8_t *buf, uint16_t bufSize, uint16_t& payloadLen); |
| virtual WEAVE_ERROR BeginCertValidation(bool isInitiator, Security::WeaveCertificateSet& certSet, Security::ValidationContext& validContext); |
| virtual WEAVE_ERROR HandleCertValidationResult(bool isInitiator, WEAVE_ERROR& validRes, Security::WeaveCertificateData *peerCert, |
| uint64_t peerNodeId, Security::WeaveCertificateSet& certSet, Security::ValidationContext& validContext); |
| virtual WEAVE_ERROR EndCertValidation(Security::WeaveCertificateSet& certSet, Security::ValidationContext& validContext); |
| |
| // Locale |
| static void WriteLocaleRequest(nl::Weave::TLV::TLVWriter &aWriter, void *ctx); |
| |
| // Thermostat |
| static void WriteThermostatRequest(nl::Weave::TLV::TLVWriter &aWriter, void *ctx); |
| |
| // Convert EUI-48 value to string of hex characters. String buffer must be at least EUI48_STR_LEN bytes in length. |
| static void Eui48ToString(char *strBuf, uint8_t (&eui)[EUI48_LEN]); |
| }; |
| |
| // ProductWildcardId -- Special Values that can be placed in the IdentifyDeviceCriteria.TargetProductId |
| // field to identify particular groups of Nest devices. |
| enum ProductWildcardId |
| { |
| kProductWildcardId_RangeStart = 0xFFF0, |
| kProductWildcardId_RangeEnd = 0xFFFE, |
| |
| kProductWildcardId_NestThermostat = 0xFFF0, |
| kProductWildcardId_NestProtect = 0xFFF1, |
| kProductWildcardId_NestCam = 0xFFF2 |
| }; |
| |
| |
| } // namespace DeviceManager |
| } // namespace Weave |
| } // namespace nl |
| |
| #endif // __WEAVEDEVICEMANAGER_H |
