| /* |
| * |
| * 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 |
| * This file implements the Fabric Provisioning Profile, used to |
| * manage membership to Weave Fabrics. |
| * |
| * The Fabric Provisioning Profile facilitates client-server operations |
| * such that the client (the controlling device) can trigger specific |
| * functionality on the server (the device undergoing provisioning), |
| * to allow it to create, join, and leave Weave Fabrics. This includes |
| * communicating Fabric configuration information such as identifiers, |
| * keys, security schemes, and related data. |
| * |
| */ |
| |
| #include <Weave/Core/WeaveCore.h> |
| #include <Weave/Core/WeaveTLV.h> |
| #include <Weave/Support/CodeUtils.h> |
| #include <Weave/Core/WeaveEncoding.h> |
| #include <Weave/Profiles/WeaveProfiles.h> |
| #include "FabricProvisioning.h" |
| #include <Weave/Profiles/common/CommonProfile.h> |
| |
| namespace nl { |
| namespace Weave { |
| namespace Profiles { |
| namespace FabricProvisioning { |
| |
| using namespace nl::Weave::Crypto; |
| using namespace nl::Weave::Encoding; |
| using namespace nl::Weave::TLV; |
| |
| FabricProvisioningServer::FabricProvisioningServer() |
| { |
| FabricState = NULL; |
| ExchangeMgr = NULL; |
| mDelegate = NULL; |
| mCurClientOp = NULL; |
| } |
| |
| /** |
| * Initialize the Fabric Provisioning Server state and register to receive |
| * Fabric Provisioning messages. |
| * |
| * @param[in] exchangeMgr A pointer to the system Weave Exchange Manager. |
| * |
| * @retval #WEAVE_ERROR_TOO_MANY_UNSOLICITED_MESSAGE_HANDLERS If too many message handlers have |
| * already been registered. |
| * @retval #WEAVE_NO_ERROR On success. |
| */ |
| WEAVE_ERROR FabricProvisioningServer::Init(WeaveExchangeManager *exchangeMgr) |
| { |
| FabricState = exchangeMgr->FabricState; |
| ExchangeMgr = exchangeMgr; |
| mDelegate = NULL; |
| mCurClientOp = NULL; |
| |
| // Register to receive unsolicited Service Provisioning messages from the exchange manager. |
| WEAVE_ERROR err = |
| ExchangeMgr->RegisterUnsolicitedMessageHandler(kWeaveProfile_FabricProvisioning, HandleClientRequest, this); |
| |
| return err; |
| } |
| |
| /** |
| * Shutdown the Fabric Provisioning Server. |
| * |
| * @retval #WEAVE_NO_ERROR unconditionally. |
| */ |
| // TODO: Additional documentation detail required (i.e. how this function impacts object lifecycle). |
| WEAVE_ERROR FabricProvisioningServer::Shutdown() |
| { |
| if (ExchangeMgr != NULL) |
| ExchangeMgr->UnregisterUnsolicitedMessageHandler(kWeaveProfile_FabricProvisioning); |
| |
| FabricState = NULL; |
| ExchangeMgr = NULL; |
| mDelegate = NULL; |
| mCurClientOp = NULL; |
| |
| return WEAVE_NO_ERROR; |
| } |
| |
| /** |
| * Set the delegate to process Fabric Provisioning events. |
| * |
| * @param[in] delegate A pointer to the Fabric Provisioning Delegate. |
| */ |
| void FabricProvisioningServer::SetDelegate(FabricProvisioningDelegate *delegate) |
| { |
| mDelegate = delegate; |
| } |
| |
| /** |
| * Send a success response to a Fabric Provisioning request. |
| * |
| * @retval #WEAVE_ERROR_INCORRECT_STATE If there is no request being processed. |
| * @retval #WEAVE_NO_ERROR On success. |
| * @retval other Other Weave or platform-specific error codes indicating that an error |
| * occurred preventing the sending of the success response. |
| */ |
| WEAVE_ERROR FabricProvisioningServer::SendSuccessResponse() |
| { |
| return SendStatusReport(kWeaveProfile_Common, Common::kStatus_Success); |
| } |
| |
| /** |
| * Send a status report response to a request. |
| * |
| * @param[in] statusProfileId The Weave profile ID this status report pertains to. |
| * @param[in] statusCode The status code to be included in this response. |
| * @param[in] sysError The system error code to be included in this response. |
| * |
| * @retval #WEAVE_ERROR_INCORRECT_STATE If there is no request being processed. |
| * @retval #WEAVE_NO_ERROR On success. |
| * @retval other Other Weave or platform-specific error codes indicating that an error |
| * occurred preventing the sending of the status report. |
| */ |
| WEAVE_ERROR FabricProvisioningServer::SendStatusReport(uint32_t statusProfileId, uint16_t statusCode, WEAVE_ERROR sysError) |
| { |
| WEAVE_ERROR err; |
| |
| VerifyOrExit(mCurClientOp != NULL, err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| err = WeaveServerBase::SendStatusReport(mCurClientOp, statusProfileId, statusCode, sysError); |
| |
| exit: |
| |
| if (mCurClientOp != NULL) |
| { |
| mCurClientOp->Close(); |
| mCurClientOp = NULL; |
| } |
| |
| return err; |
| } |
| |
| void FabricProvisioningServer::HandleClientRequest(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo, |
| uint32_t profileId, uint8_t msgType, PacketBuffer *msgBuf) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| FabricProvisioningServer *server = (FabricProvisioningServer *) ec->AppState; |
| FabricProvisioningDelegate *delegate = server->mDelegate; |
| |
| // Fail messages for the wrong profile. This shouldn't happen, but better safe than sorry. |
| if (profileId != kWeaveProfile_FabricProvisioning) |
| { |
| WeaveServerBase::SendStatusReport(ec, kWeaveProfile_Common, Common::kStatus_BadRequest, WEAVE_NO_ERROR); |
| ec->Close(); |
| goto exit; |
| } |
| |
| // Call on the delegate to enforce message-level access control. If policy dictates the message should NOT |
| // be processed, then simply end the exchange and return. If an error response was warranted, the appropriate |
| // response will have been sent within EnforceAccessControl(). |
| if (!server->EnforceAccessControl(ec, profileId, msgType, msgInfo, server->mDelegate)) |
| { |
| ec->Close(); |
| ExitNow(); |
| } |
| |
| // Disallow simultaneous requests. |
| if (server->mCurClientOp != NULL) |
| { |
| WeaveServerBase::SendStatusReport(ec, kWeaveProfile_Common, Common::kStatus_Busy, WEAVE_NO_ERROR); |
| ec->Close(); |
| goto exit; |
| } |
| |
| // Record that we have a request in process. |
| server->mCurClientOp = ec; |
| |
| // Decode and dispatch the message. |
| switch (msgType) |
| { |
| case kMsgType_CreateFabric: |
| |
| // Return an error if the node is already a member of a fabric. |
| if (server->FabricState->FabricId != 0) |
| { |
| server->SendStatusReport(kWeaveProfile_FabricProvisioning, kStatusCode_AlreadyMemberOfFabric); |
| ExitNow(); |
| } |
| |
| // Create a new fabric. |
| err = server->FabricState->CreateFabric(); |
| SuccessOrExit(err); |
| |
| // Call the application to perform any creation-time operations (such as address assignment). |
| // Note that this can fail, in which case we abort the fabric creation. |
| err = delegate->HandleCreateFabric(); |
| if (err != WEAVE_NO_ERROR) |
| server->FabricState->ClearFabricState(); |
| SuccessOrExit(err); |
| |
| break; |
| |
| case kMsgType_LeaveFabric: |
| |
| // Return an error if the node is not a member of a fabric. |
| if (server->FabricState->FabricId == 0) |
| { |
| server->SendStatusReport(kWeaveProfile_FabricProvisioning, kStatusCode_NotMemberOfFabric); |
| ExitNow(); |
| } |
| |
| // Clear the fabric state. |
| server->FabricState->ClearFabricState(); |
| |
| // Call the application to perform any leave-time operations. |
| err = delegate->HandleLeaveFabric(); |
| SuccessOrExit(err); |
| |
| break; |
| |
| case kMsgType_GetFabricConfig: |
| |
| // Return an error if the node is not a member of a fabric. |
| if (server->FabricState->FabricId == 0) |
| { |
| server->SendStatusReport(kWeaveProfile_FabricProvisioning, kStatusCode_NotMemberOfFabric); |
| ExitNow(); |
| } |
| |
| // Get the encoded fabric state from the fabric state object. |
| PacketBuffer::Free(msgBuf); |
| msgBuf = PacketBuffer::New(); |
| VerifyOrExit(msgBuf != NULL, err = WEAVE_ERROR_NO_MEMORY); |
| uint32_t fabricStateLen; |
| err = server->FabricState->GetFabricState(msgBuf->Start(), msgBuf->AvailableDataLength(), fabricStateLen); |
| SuccessOrExit(err); |
| msgBuf->SetDataLength(fabricStateLen); |
| |
| // Send the get fabric config response. |
| err = server->mCurClientOp->SendMessage(kWeaveProfile_FabricProvisioning, kMsgType_GetFabricConfigComplete, msgBuf, 0); |
| SuccessOrExit(err); |
| msgBuf = NULL; |
| |
| server->mCurClientOp->Close(); |
| server->mCurClientOp = NULL; |
| |
| err = delegate->HandleGetFabricConfig(); |
| SuccessOrExit(err); |
| |
| break; |
| |
| case kMsgType_JoinExistingFabric: |
| |
| // Return an error if the node is already a member of a fabric. |
| if (server->FabricState->FabricId != 0) |
| { |
| server->SendStatusReport(kWeaveProfile_FabricProvisioning, kStatusCode_AlreadyMemberOfFabric); |
| ExitNow(); |
| } |
| |
| // Join an existing fabric identified by the supplied fabric state. Right now the only possible |
| // reason for this to fail is bad input data. |
| err = server->FabricState->JoinExistingFabric(msgBuf->Start(), msgBuf->DataLength()); |
| if (err != WEAVE_NO_ERROR) |
| { |
| server->SendStatusReport(kWeaveProfile_FabricProvisioning, kStatusCode_InvalidFabricConfig); |
| ExitNow(); |
| } |
| |
| // Call the application to perform any join-time operations (such as address assignment). |
| // Note that this can fail, in which case we abort the fabric join. |
| err = delegate->HandleJoinExistingFabric(); |
| if (err != WEAVE_NO_ERROR) |
| server->FabricState->ClearFabricState(); |
| SuccessOrExit(err); |
| |
| break; |
| |
| default: |
| server->SendStatusReport(kWeaveProfile_Common, Common::kStatus_BadRequest); |
| break; |
| } |
| |
| exit: |
| |
| if (msgBuf != NULL) |
| PacketBuffer::Free(msgBuf); |
| |
| if (err != WEAVE_NO_ERROR && server->mCurClientOp != NULL && ec == server->mCurClientOp) |
| { |
| uint16_t statusCode = (err == WEAVE_ERROR_INVALID_MESSAGE_LENGTH) |
| ? Common::kStatus_BadRequest |
| : Common::kStatus_InternalError; |
| server->SendStatusReport(kWeaveProfile_Common, statusCode, err); |
| } |
| } |
| |
| void FabricProvisioningDelegate::EnforceAccessControl(ExchangeContext *ec, uint32_t msgProfileId, uint8_t msgType, |
| const WeaveMessageInfo *msgInfo, AccessControlResult& result) |
| { |
| // If the result has not already been determined by a subclass... |
| if (result == kAccessControlResult_NotDetermined) |
| { |
| switch (msgType) |
| { |
| #if WEAVE_CONFIG_REQUIRE_AUTH_FABRIC_PROV |
| |
| case kMsgType_CreateFabric: |
| case kMsgType_JoinExistingFabric: |
| if (msgInfo->PeerAuthMode == kWeaveAuthMode_CASE_AccessToken || |
| (msgInfo->PeerAuthMode == kWeaveAuthMode_PASE_PairingCode && !IsPairedToAccount())) |
| { |
| result = kAccessControlResult_Accepted; |
| } |
| break; |
| |
| case kMsgType_LeaveFabric: |
| case kMsgType_GetFabricConfig: |
| if (msgInfo->PeerAuthMode == kWeaveAuthMode_CASE_AccessToken) |
| { |
| result = kAccessControlResult_Accepted; |
| } |
| break; |
| |
| #else // WEAVE_CONFIG_REQUIRE_AUTH_FABRIC_PROV |
| |
| case kMsgType_CreateFabric: |
| case kMsgType_JoinExistingFabric: |
| case kMsgType_LeaveFabric: |
| case kMsgType_GetFabricConfig: |
| result = kAccessControlResult_Accepted; |
| break; |
| |
| #endif // WEAVE_CONFIG_REQUIRE_AUTH_FABRIC_PROV |
| |
| default: |
| WeaveServerBase::SendStatusReport(ec, kWeaveProfile_Common, Common::kStatus_UnsupportedMessage, WEAVE_NO_ERROR); |
| result = kAccessControlResult_Rejected_RespSent; |
| break; |
| } |
| } |
| |
| // Call up to the base class. |
| WeaveServerDelegateBase::EnforceAccessControl(ec, msgProfileId, msgType, msgInfo, result); |
| } |
| |
| // TODO: eliminate this method when device code provides appropriate implementations. |
| bool FabricProvisioningDelegate::IsPairedToAccount() const |
| { |
| return false; |
| } |
| |
| |
| |
| |
| } /* namespace FabricProvisioning */ |
| } /* namespace Profiles */ |
| } /* namespace Weave */ |
| } /* namespace nl */ |
