weave/src/lib/profiles/service-provisioning/ServiceProvisioningServer.cpp - nest-cam/4320010/weave - Git at Google

 /*
  *
  *    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 objects for a Weave Service Provisioning
  *      profile unsolicited responder (server).
  *
  */

 #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 "ServiceProvisioning.h"
 #include <Weave/Profiles/common/CommonProfile.h>

 namespace nl {
 namespace Weave {
 namespace Profiles {
 namespace ServiceProvisioning {

 using namespace nl::Weave::Encoding;
 using namespace nl::Weave::TLV;

 ServiceProvisioningServer::ServiceProvisioningServer()
 {
     FabricState = NULL;
     ExchangeMgr = NULL;
     mDelegate = NULL;
     mCurClientOp = NULL;
     mCurClientOpBuf = NULL;
     mCurServerOp = NULL;
     mServerOpState = kServerOpState_Idle;
 }

 WEAVE_ERROR ServiceProvisioningServer::Init(WeaveExchangeManager *exchangeMgr)
 {
     FabricState = exchangeMgr->FabricState;
     ExchangeMgr = exchangeMgr;
     mDelegate = NULL;
     mCurClientOp = NULL;
     mCurClientOpBuf = NULL;
     mCurServerOp = NULL;
     mServerOpState = kServerOpState_Idle;

     // Register to receive unsolicited Service Provisioning messages from the exchange manager.
     WEAVE_ERROR err =
         ExchangeMgr->RegisterUnsolicitedMessageHandler(kWeaveProfile_ServiceProvisioning, HandleClientRequest, this);

     return err;
 }

 WEAVE_ERROR ServiceProvisioningServer::Shutdown()
 {
     if (ExchangeMgr != NULL)
         ExchangeMgr->UnregisterUnsolicitedMessageHandler(kWeaveProfile_ServiceProvisioning);

     if (mCurClientOpBuf != NULL)
         PacketBuffer::Free(mCurClientOpBuf);

     FabricState = NULL;
     ExchangeMgr = NULL;
     mDelegate = NULL;
     mCurClientOp = NULL;
     mCurClientOpBuf = NULL;
     mCurServerOp = NULL;
     mServerOpState = kServerOpState_Idle;

     return WEAVE_NO_ERROR;
 }

 void ServiceProvisioningServer::SetDelegate(ServiceProvisioningDelegate *delegate)
 {
     mDelegate = delegate;
 }

 ServiceProvisioningDelegate* ServiceProvisioningServer::GetDelegate(void) const
 {
     return mDelegate;
 }

 WEAVE_ERROR ServiceProvisioningServer::SendSuccessResponse()
 {
     return SendStatusReport(kWeaveProfile_Common, Common::kStatus_Success);
 }

 WEAVE_ERROR ServiceProvisioningServer::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:
     mServerOpState = kServerOpState_Idle;

     if (mCurClientOp != NULL)
     {
         mCurClientOp->Close();
         mCurClientOp = NULL;
     }

     if (mCurClientOpBuf != NULL)
     {
         PacketBuffer::Free(mCurClientOpBuf);
         mCurClientOpBuf = NULL;
     }

     return err;
 }

 WEAVE_ERROR ServiceProvisioningServer::SendPairDeviceToAccountRequest(WeaveConnection *serverCon, uint64_t serviceId, uint64_t fabricId,
                                                                       const char *accountId, uint16_t accountIdLen,
                                                                       const uint8_t *pairingToken, uint16_t pairingTokenLen,
                                                                       const uint8_t *pairingInitData, uint16_t pairingInitDataLen,
                                                                       const uint8_t *deviceInitData, uint16_t deviceInitDataLen)
 {
     WEAVE_ERROR                 err     = WEAVE_NO_ERROR;
     PairDeviceToAccountMessage  msg;
     PacketBuffer*               msgBuf  = NULL;
     uint16_t                    msgLen  = sizeof(accountIdLen) + sizeof(pairingTokenLen) + sizeof(pairingInitDataLen) + sizeof(deviceInitDataLen) +
                                           sizeof(serviceId) + sizeof(fabricId) + accountIdLen + pairingTokenLen + pairingInitDataLen + deviceInitDataLen;

     if (mServerOpState != kServerOpState_Idle)
         return WEAVE_ERROR_INCORRECT_STATE;

     msg.ServiceId = serviceId;
     msg.FabricId = fabricId;
     msg.AccountId = accountId;
     msg.AccountIdLen = accountIdLen;
     msg.PairingToken = pairingToken;
     msg.PairingTokenLen = pairingTokenLen;
     msg.PairingInitData = pairingInitData;
     msg.PairingInitDataLen = pairingInitDataLen;
     msg.DeviceInitData = deviceInitData;
     msg.DeviceInitDataLen = deviceInitDataLen;

     // Allocate a buffer for the message.
     msgBuf = PacketBuffer::NewWithAvailableSize(msgLen);
     VerifyOrExit(msgBuf != NULL, err = WEAVE_ERROR_NO_MEMORY);

     // Encode the message.
     err = msg.Encode(msgBuf);
     SuccessOrExit(err);

     // Allocate and initialize an exchange context.
     mCurServerOp = ExchangeMgr->NewContext(serverCon, this);
     VerifyOrExit(mCurServerOp != NULL, err = WEAVE_ERROR_NO_MEMORY);

     mCurServerOp->OnMessageReceived = HandleServerResponse;

     if (mCurServerOp->ResponseTimeout == 0)
     {
         mCurServerOp->ResponseTimeout = WEAVE_CONFIG_SERVICE_PROV_RESPONSE_TIMEOUT;
     }
     mCurServerOp->OnResponseTimeout = HandleServerResponseTimeout;
     mCurServerOp->OnConnectionClosed = HandleServerConnectionClosed;
     mCurServerOp->OnKeyError = HandleServerKeyError;

     // Record that a PairDeviceToAccount request is outstanding.
     mServerOpState = kServerOpState_PairDeviceToAccount;

     // Send the PairDeviceToAccount message to the service.
     err = mCurServerOp->SendMessage(kWeaveProfile_ServiceProvisioning, kMsgType_PairDeviceToAccount, msgBuf, 0);
     msgBuf = NULL;

 exit:
     if (msgBuf != NULL)
         PacketBuffer::Free(msgBuf);
     if (err != WEAVE_NO_ERROR)
     {
         if (mCurServerOp != NULL)
         {
             mCurServerOp->Close();
             mCurServerOp = NULL;
         }
         mServerOpState = kServerOpState_Idle;
     }
     return err;
 }

 WEAVE_ERROR ServiceProvisioningServer::SendPairDeviceToAccountRequest(Binding *binding, uint64_t serviceId, uint64_t fabricId,
                                                                       const char *accountId, uint16_t accountIdLen,
                                                                       const uint8_t *pairingToken, uint16_t pairingTokenLen,
                                                                       const uint8_t *pairingInitData, uint16_t pairingInitDataLen,
                                                                       const uint8_t *deviceInitData, uint16_t deviceInitDataLen)
 {
     WEAVE_ERROR                 err     = WEAVE_NO_ERROR;
     PairDeviceToAccountMessage  msg;
     PacketBuffer*               msgBuf  = NULL;
     uint16_t                    flags   = 0;
     uint16_t                    msgLen  = sizeof(accountIdLen) + sizeof(pairingTokenLen) + sizeof(pairingInitDataLen) + sizeof(deviceInitDataLen) +
                                           sizeof(serviceId) + sizeof(fabricId) + accountIdLen + pairingTokenLen + pairingInitDataLen + deviceInitDataLen;

     if (mServerOpState != kServerOpState_Idle)
         return WEAVE_ERROR_INCORRECT_STATE;

     msg.ServiceId = serviceId;
     msg.FabricId = fabricId;
     msg.AccountId = accountId;
     msg.AccountIdLen = accountIdLen;
     msg.PairingToken = pairingToken;
     msg.PairingTokenLen = pairingTokenLen;
     msg.PairingInitData = pairingInitData;
     msg.PairingInitDataLen = pairingInitDataLen;
     msg.DeviceInitData = deviceInitData;
     msg.DeviceInitDataLen = deviceInitDataLen;

     // Allocate a buffer for the message.
     msgBuf = PacketBuffer::NewWithAvailableSize(msgLen);
     VerifyOrExit(msgBuf != NULL, err = WEAVE_ERROR_NO_MEMORY);

     // Encode the message.
     err = msg.Encode(msgBuf);
     SuccessOrExit(err);

     // Allocate and initialize an exchange context.
     err = binding->NewExchangeContext(mCurServerOp);
     SuccessOrExit(err);

     mCurServerOp->AppState = this;
     mCurServerOp->OnMessageReceived = HandleServerResponse;

     if (mCurServerOp->ResponseTimeout == 0)
     {
         mCurServerOp->ResponseTimeout = WEAVE_CONFIG_SERVICE_PROV_RESPONSE_TIMEOUT;
     }
     mCurServerOp->OnResponseTimeout = HandleServerResponseTimeout;
     mCurServerOp->OnConnectionClosed = HandleServerConnectionClosed;
     mCurServerOp->OnKeyError = HandleServerKeyError;

 #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
     mCurServerOp->OnSendError = HandleServerSendError;
 #endif // #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING

     // Record that a PairDeviceToAccount request is outstanding.
     mServerOpState = kServerOpState_PairDeviceToAccount;

     // TODO: [TT] Not needed for Jay's new bindings WEAV-1870.
     flags = (mCurServerOp->Con == NULL) ? ExchangeContext::kSendFlag_RequestAck : 0;

     // Send the PairDeviceToAccount message to the service.
     err = mCurServerOp->SendMessage(kWeaveProfile_ServiceProvisioning, kMsgType_PairDeviceToAccount, msgBuf, flags);
     msgBuf = NULL;

 exit:
     if (msgBuf != NULL)
         PacketBuffer::Free(msgBuf);
     if (err != WEAVE_NO_ERROR)
     {
         mServerOpState = kServerOpState_Idle;
         if (mCurServerOp != NULL)
         {
             mCurServerOp->Close();
             mCurServerOp = NULL;
         }
     }
     return err;
 }

 void ServiceProvisioningServer::HandleClientRequest(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo,
                                                     uint32_t profileId, uint8_t msgType, PacketBuffer *payload)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     ServiceProvisioningServer *server = (ServiceProvisioningServer *) ec->AppState;
     ServiceProvisioningDelegate *delegate = server->mDelegate;
     uint16_t dataLen = payload->DataLength();
     uint8_t *p = payload->Start();

     // Fail messages for the wrong profile. This shouldn't happen, but better safe than sorry.
     if (profileId != kWeaveProfile_ServiceProvisioning)
     {
         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_RegisterServicePairAccount:

         err = RegisterServicePairAccountMessage::Decode(payload, server->mCurClientOpMsg.RegisterServicePairAccount);
         SuccessOrExit(err);

         server->mCurClientOpBuf = payload;
         payload = NULL;

         err = delegate->HandleRegisterServicePairAccount(server->mCurClientOpMsg.RegisterServicePairAccount);
         SuccessOrExit(err);

         break;

     case kMsgType_UpdateService:
         err = UpdateServiceMessage::Decode(payload, server->mCurClientOpMsg.UpdateService);
         SuccessOrExit(err);

         server->mCurClientOpBuf = payload;
         payload = NULL;

         err = delegate->HandleUpdateService(server->mCurClientOpMsg.UpdateService);
         SuccessOrExit(err);

         break;

     case kMsgType_UnregisterService:
     {
         uint64_t serviceId;

         VerifyOrExit(dataLen == 8, err = WEAVE_ERROR_INVALID_MESSAGE_LENGTH);
         serviceId = LittleEndian::Get64(p);

         err = delegate->HandleUnregisterService(serviceId);
         SuccessOrExit(err);

         break;
     }

     default:
         server->SendStatusReport(kWeaveProfile_Common, Common::kStatus_BadRequest);
         break;
     }

 exit:

     if (payload != NULL)
         PacketBuffer::Free(payload);

     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 ServiceProvisioningServer::HandleServerResponse(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo,
                                                      uint32_t profileId, uint8_t msgType, PacketBuffer *payload)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     WEAVE_ERROR delegateErr = WEAVE_NO_ERROR;
     StatusReport statusReport;
     ServiceProvisioningServer *server = (ServiceProvisioningServer *) ec->AppState;

     // Sanity check that the passed-in exchange context is in fact the one that represents the current
     // outstanding server operation. If not, it'll get closed at exit. If it does match, we'll null ec
     // to prevent it from getting closed at exit.
     VerifyOrExit(ec == server->mCurServerOp, err = WEAVE_NO_ERROR);
     ec = NULL;

     // Verify the message is expected.
     VerifyOrExit((profileId == kWeaveProfile_Common && msgType == nl::Weave::Profiles::Common::kMsgType_StatusReport) ||
                  (profileId == kWeaveProfile_StatusReport_Deprecated),
                  err = WEAVE_ERROR_INVALID_MESSAGE_TYPE);

     err = StatusReport::parse(payload, statusReport);
     SuccessOrExit(err);

     // Free the payload here to reduce buffer pressure.
     PacketBuffer::Free(payload);
     payload = NULL;

     delegateErr = (statusReport.mProfileId == kWeaveProfile_Common && statusReport.mStatusCode == Common::kStatus_Success)
         ? WEAVE_NO_ERROR
         : WEAVE_ERROR_STATUS_REPORT_RECEIVED;

     server->HandlePairDeviceToAccountResult(delegateErr, statusReport.mProfileId, statusReport.mStatusCode);

 exit:
     // Free the payload first to reduce buffer pressure.
     if (payload != NULL)
         PacketBuffer::Free(payload);
     if (err != WEAVE_NO_ERROR)
         server->HandlePairDeviceToAccountResult(err, 0, 0);
     if (ec != NULL)
         ec->Close();
 }

 void ServiceProvisioningServer::HandleServerResponseTimeout(ExchangeContext *ec)
 {
     ServiceProvisioningServer *server = (ServiceProvisioningServer *) ec->AppState;

     // Sanity check that the passed-in exchange context is in fact the one that represents the current
     // outstanding server operation. If not, it'll get closed at exit. If it does match, we'll null ec
     // to prevent it from getting closed at exit.
     VerifyOrExit(ec == server->mCurServerOp, );
     ec = NULL;

     server->HandlePairDeviceToAccountResult(WEAVE_ERROR_TIMEOUT, 0, 0);

 exit:
     if (ec != NULL)
         ec->Close();
 }

 void ServiceProvisioningServer::HandleServerConnectionClosed(ExchangeContext *ec, WeaveConnection *con, WEAVE_ERROR conErr)
 {
     ServiceProvisioningServer *server = (ServiceProvisioningServer *) ec->AppState;

     // Sanity check that the passed-in exchange context is in fact the one that represents the current
     // outstanding server operation. If not, it'll get closed at exit. If it does match, we'll null ec
     // to prevent it from getting closed at exit.
     VerifyOrExit(ec == server->mCurServerOp, );
     ec = NULL;

     // No error on connection close means the service simply closed the connection without responding. In that case
     // deliver WEAVE_ERROR_CONNECTION_CLOSED_UNEXPECTEDLY to the delegate.
     if (conErr == WEAVE_NO_ERROR)
         conErr = WEAVE_ERROR_CONNECTION_CLOSED_UNEXPECTEDLY;

     server->HandlePairDeviceToAccountResult(conErr, 0, 0);

 exit:
     if (ec != NULL)
         ec->Close();
 }

 void ServiceProvisioningServer::HandleServerKeyError(ExchangeContext *ec, WEAVE_ERROR keyErr)
 {
     ServiceProvisioningServer *server = (ServiceProvisioningServer *) ec->AppState;

     // Sanity check that the passed-in exchange context is in fact the one that represents the current
     // outstanding server operation. If not, it'll get closed at exit. If it does match, we'll null ec
     // to prevent it from getting closed at exit.
     VerifyOrExit(ec == server->mCurServerOp, );
     ec = NULL;

     server->HandlePairDeviceToAccountResult(keyErr, 0, 0);

 exit:
     if (ec != NULL)
         ec->Close();
 }

 #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
 void ServiceProvisioningServer::HandleServerSendError(ExchangeContext *ec, WEAVE_ERROR err, void *msgCtxt)
 {
     ServiceProvisioningServer *server = (ServiceProvisioningServer *) ec->AppState;

     // Sanity check that the passed-in exchange context is in fact the one that represents the current
     // outstanding server operation. If not, it'll get closed at exit. If it does match, we'll null ec
     // to prevent it from getting closed at exit.
     VerifyOrExit(ec == server->mCurServerOp, );
     ec = NULL;

     server->HandlePairDeviceToAccountResult(err, 0, 0);

 exit:
     if (ec != NULL)
         ec->Close();
 }
 #endif // #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING

 void ServiceProvisioningServer::HandlePairDeviceToAccountResult(WEAVE_ERROR localErr, uint32_t serverStatusProfileId, uint16_t serverStatusCode)
 {
     mServerOpState = kServerOpState_Idle;
     mCurServerOp->Close();
     mCurServerOp = NULL;

     if (mDelegate)
     {
         mDelegate->HandlePairDeviceToAccountResult(localErr, serverStatusProfileId, serverStatusCode);
     }
 }

 bool ServiceProvisioningServer::IsValidServiceConfig(const uint8_t *serviceConfig, uint16_t serviceConfigLen)
 {
     WEAVE_ERROR err;
     nl::Weave::TLV::TLVReader reader;

     reader.Init(serviceConfig, serviceConfigLen);

     err = reader.Next();
     SuccessOrExit(err);

     VerifyOrExit(reader.GetTag() == ProfileTag(kWeaveProfile_ServiceProvisioning, kTag_ServiceConfig), err = WEAVE_ERROR_INVALID_TLV_TAG);

     {
         TLVType topLevelContainer;
         bool caCertsPresent = false, dirEndPointPresent = false;

         err = reader.EnterContainer(topLevelContainer);
         SuccessOrExit(err);

         while ((err = reader.Next()) == WEAVE_NO_ERROR)
         {
             uint64_t elemTag = reader.GetTag();

             if (!IsContextTag(elemTag))
                 continue;

             switch (TagNumFromTag(elemTag))
             {
             case kTag_ServiceConfig_CACerts:
                 VerifyOrExit(reader.GetType() == kTLVType_Array, err = WEAVE_ERROR_INVALID_TLV_ELEMENT);
                 caCertsPresent = true;
                 break;
             case kTag_ServiceConfig_DirectoryEndPoint:
                 VerifyOrExit(reader.GetType() == kTLVType_Structure, err = WEAVE_ERROR_INVALID_TLV_ELEMENT);
                 dirEndPointPresent = true;
                 break;
             default:
                 // Ignore unknown elements
                 break;
             }
         }

         if (err != WEAVE_END_OF_TLV)
             ExitNow();

         err = reader.ExitContainer(topLevelContainer);
         SuccessOrExit(err);

         VerifyOrExit(caCertsPresent && dirEndPointPresent, err = WEAVE_ERROR_MISSING_TLV_ELEMENT);
     }

 exit:
     return err == WEAVE_NO_ERROR;
 }

 void ServiceProvisioningDelegate::EnforceAccessControl(ExchangeContext *ec, uint32_t msgProfileId, uint8_t msgType,
         const WeaveMessageInfo *msgInfo, AccessControlResult& result)
 {
     enum { kServiceProvisioningEndpointId = 0x18B4300200000010ull };

     // If the result has not already been determined by a subclass...
     if (result == kAccessControlResult_NotDetermined)
     {
         switch (msgType)
         {
 #if WEAVE_CONFIG_REQUIRE_AUTH_SERVICE_PROV

         case kMsgType_RegisterServicePairAccount:
             if (msgInfo->PeerAuthMode == kWeaveAuthMode_PASE_PairingCode && !IsPairedToAccount())
             {
                 result = kAccessControlResult_Accepted;
             }
             break;

         case kMsgType_UpdateService:
             if (msgInfo->PeerAuthMode == kWeaveAuthMode_CASE_AccessToken)
             {
                 result = kAccessControlResult_Accepted;
             }
             break;

         case kMsgType_UnregisterService:
             if (msgInfo->PeerAuthMode == kWeaveAuthMode_CASE_AccessToken ||
                 (msgInfo->PeerAuthMode == kWeaveAuthMode_CASE_ServiceEndPoint && msgInfo->SourceNodeId == kServiceProvisioningEndpointId))
             {
                 result = kAccessControlResult_Accepted;
             }
             break;

 #else // WEAVE_CONFIG_REQUIRE_AUTH_SERVICE_PROV

         case kMsgType_RegisterServicePairAccount:
         case kMsgType_UpdateService:
         case kMsgType_UnregisterService:
             result = kAccessControlResult_Accepted;
             break;

 #endif // WEAVE_CONFIG_REQUIRE_AUTH_SERVICE_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 ServiceProvisioningDelegate::IsPairedToAccount() const
 {
     return false;
 }

 } // ServiceProvisioning
 } // namespace Profiles
 } // namespace Weave
 } // namespace nl
	/*
	*
	* 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 objects for a Weave Service Provisioning
	* profile unsolicited responder (server).
	*
	*/

	#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 "ServiceProvisioning.h"
	#include <Weave/Profiles/common/CommonProfile.h>

	namespace nl {
	namespace Weave {
	namespace Profiles {
	namespace ServiceProvisioning {

	using namespace nl::Weave::Encoding;
	using namespace nl::Weave::TLV;

	ServiceProvisioningServer::ServiceProvisioningServer()
	{
	FabricState = NULL;
	ExchangeMgr = NULL;
	mDelegate = NULL;
	mCurClientOp = NULL;
	mCurClientOpBuf = NULL;
	mCurServerOp = NULL;
	mServerOpState = kServerOpState_Idle;
	}

	WEAVE_ERROR ServiceProvisioningServer::Init(WeaveExchangeManager *exchangeMgr)
	{
	FabricState = exchangeMgr->FabricState;
	ExchangeMgr = exchangeMgr;
	mDelegate = NULL;
	mCurClientOp = NULL;
	mCurClientOpBuf = NULL;
	mCurServerOp = NULL;
	mServerOpState = kServerOpState_Idle;

	// Register to receive unsolicited Service Provisioning messages from the exchange manager.
	WEAVE_ERROR err =
	ExchangeMgr->RegisterUnsolicitedMessageHandler(kWeaveProfile_ServiceProvisioning, HandleClientRequest, this);

	return err;
	}

	WEAVE_ERROR ServiceProvisioningServer::Shutdown()
	{
	if (ExchangeMgr != NULL)
	ExchangeMgr->UnregisterUnsolicitedMessageHandler(kWeaveProfile_ServiceProvisioning);

	if (mCurClientOpBuf != NULL)
	PacketBuffer::Free(mCurClientOpBuf);

	FabricState = NULL;
	ExchangeMgr = NULL;
	mDelegate = NULL;
	mCurClientOp = NULL;
	mCurClientOpBuf = NULL;
	mCurServerOp = NULL;
	mServerOpState = kServerOpState_Idle;

	return WEAVE_NO_ERROR;
	}

	void ServiceProvisioningServer::SetDelegate(ServiceProvisioningDelegate *delegate)
	{
	mDelegate = delegate;
	}

	ServiceProvisioningDelegate* ServiceProvisioningServer::GetDelegate(void) const
	{
	return mDelegate;
	}

	WEAVE_ERROR ServiceProvisioningServer::SendSuccessResponse()
	{
	return SendStatusReport(kWeaveProfile_Common, Common::kStatus_Success);
	}

	WEAVE_ERROR ServiceProvisioningServer::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:
	mServerOpState = kServerOpState_Idle;

	if (mCurClientOp != NULL)
	{
	mCurClientOp->Close();
	mCurClientOp = NULL;
	}

	if (mCurClientOpBuf != NULL)
	{
	PacketBuffer::Free(mCurClientOpBuf);
	mCurClientOpBuf = NULL;
	}

	return err;
	}

	WEAVE_ERROR ServiceProvisioningServer::SendPairDeviceToAccountRequest(WeaveConnection *serverCon, uint64_t serviceId, uint64_t fabricId,
	const char *accountId, uint16_t accountIdLen,
	const uint8_t *pairingToken, uint16_t pairingTokenLen,
	const uint8_t *pairingInitData, uint16_t pairingInitDataLen,
	const uint8_t *deviceInitData, uint16_t deviceInitDataLen)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	PairDeviceToAccountMessage msg;
	PacketBuffer* msgBuf = NULL;
	uint16_t msgLen = sizeof(accountIdLen) + sizeof(pairingTokenLen) + sizeof(pairingInitDataLen) + sizeof(deviceInitDataLen) +
	sizeof(serviceId) + sizeof(fabricId) + accountIdLen + pairingTokenLen + pairingInitDataLen + deviceInitDataLen;

	if (mServerOpState != kServerOpState_Idle)
	return WEAVE_ERROR_INCORRECT_STATE;

	msg.ServiceId = serviceId;
	msg.FabricId = fabricId;
	msg.AccountId = accountId;
	msg.AccountIdLen = accountIdLen;
	msg.PairingToken = pairingToken;
	msg.PairingTokenLen = pairingTokenLen;
	msg.PairingInitData = pairingInitData;
	msg.PairingInitDataLen = pairingInitDataLen;
	msg.DeviceInitData = deviceInitData;
	msg.DeviceInitDataLen = deviceInitDataLen;

	// Allocate a buffer for the message.
	msgBuf = PacketBuffer::NewWithAvailableSize(msgLen);
	VerifyOrExit(msgBuf != NULL, err = WEAVE_ERROR_NO_MEMORY);

	// Encode the message.
	err = msg.Encode(msgBuf);
	SuccessOrExit(err);

	// Allocate and initialize an exchange context.
	mCurServerOp = ExchangeMgr->NewContext(serverCon, this);
	VerifyOrExit(mCurServerOp != NULL, err = WEAVE_ERROR_NO_MEMORY);

	mCurServerOp->OnMessageReceived = HandleServerResponse;

	if (mCurServerOp->ResponseTimeout == 0)
	{
	mCurServerOp->ResponseTimeout = WEAVE_CONFIG_SERVICE_PROV_RESPONSE_TIMEOUT;
	}
	mCurServerOp->OnResponseTimeout = HandleServerResponseTimeout;
	mCurServerOp->OnConnectionClosed = HandleServerConnectionClosed;
	mCurServerOp->OnKeyError = HandleServerKeyError;

	// Record that a PairDeviceToAccount request is outstanding.
	mServerOpState = kServerOpState_PairDeviceToAccount;

	// Send the PairDeviceToAccount message to the service.
	err = mCurServerOp->SendMessage(kWeaveProfile_ServiceProvisioning, kMsgType_PairDeviceToAccount, msgBuf, 0);
	msgBuf = NULL;

	exit:
	if (msgBuf != NULL)
	PacketBuffer::Free(msgBuf);
	if (err != WEAVE_NO_ERROR)
	{
	if (mCurServerOp != NULL)
	{
	mCurServerOp->Close();
	mCurServerOp = NULL;
	}
	mServerOpState = kServerOpState_Idle;
	}
	return err;
	}

	WEAVE_ERROR ServiceProvisioningServer::SendPairDeviceToAccountRequest(Binding *binding, uint64_t serviceId, uint64_t fabricId,
	const char *accountId, uint16_t accountIdLen,
	const uint8_t *pairingToken, uint16_t pairingTokenLen,
	const uint8_t *pairingInitData, uint16_t pairingInitDataLen,
	const uint8_t *deviceInitData, uint16_t deviceInitDataLen)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	PairDeviceToAccountMessage msg;
	PacketBuffer* msgBuf = NULL;
	uint16_t flags = 0;
	uint16_t msgLen = sizeof(accountIdLen) + sizeof(pairingTokenLen) + sizeof(pairingInitDataLen) + sizeof(deviceInitDataLen) +
	sizeof(serviceId) + sizeof(fabricId) + accountIdLen + pairingTokenLen + pairingInitDataLen + deviceInitDataLen;

	if (mServerOpState != kServerOpState_Idle)
	return WEAVE_ERROR_INCORRECT_STATE;

	msg.ServiceId = serviceId;
	msg.FabricId = fabricId;
	msg.AccountId = accountId;
	msg.AccountIdLen = accountIdLen;
	msg.PairingToken = pairingToken;
	msg.PairingTokenLen = pairingTokenLen;
	msg.PairingInitData = pairingInitData;
	msg.PairingInitDataLen = pairingInitDataLen;
	msg.DeviceInitData = deviceInitData;
	msg.DeviceInitDataLen = deviceInitDataLen;

	// Allocate a buffer for the message.
	msgBuf = PacketBuffer::NewWithAvailableSize(msgLen);
	VerifyOrExit(msgBuf != NULL, err = WEAVE_ERROR_NO_MEMORY);

	// Encode the message.
	err = msg.Encode(msgBuf);
	SuccessOrExit(err);

	// Allocate and initialize an exchange context.
	err = binding->NewExchangeContext(mCurServerOp);
	SuccessOrExit(err);

	mCurServerOp->AppState = this;
	mCurServerOp->OnMessageReceived = HandleServerResponse;

	if (mCurServerOp->ResponseTimeout == 0)
	{
	mCurServerOp->ResponseTimeout = WEAVE_CONFIG_SERVICE_PROV_RESPONSE_TIMEOUT;
	}
	mCurServerOp->OnResponseTimeout = HandleServerResponseTimeout;
	mCurServerOp->OnConnectionClosed = HandleServerConnectionClosed;
	mCurServerOp->OnKeyError = HandleServerKeyError;

	#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
	mCurServerOp->OnSendError = HandleServerSendError;
	#endif // #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING

	// Record that a PairDeviceToAccount request is outstanding.
	mServerOpState = kServerOpState_PairDeviceToAccount;

	// TODO: [TT] Not needed for Jay's new bindings WEAV-1870.
	flags = (mCurServerOp->Con == NULL) ? ExchangeContext::kSendFlag_RequestAck : 0;

	// Send the PairDeviceToAccount message to the service.
	err = mCurServerOp->SendMessage(kWeaveProfile_ServiceProvisioning, kMsgType_PairDeviceToAccount, msgBuf, flags);
	msgBuf = NULL;

	exit:
	if (msgBuf != NULL)
	PacketBuffer::Free(msgBuf);
	if (err != WEAVE_NO_ERROR)
	{
	mServerOpState = kServerOpState_Idle;
	if (mCurServerOp != NULL)
	{
	mCurServerOp->Close();
	mCurServerOp = NULL;
	}
	}
	return err;
	}

	void ServiceProvisioningServer::HandleClientRequest(ExchangeContext ec, const IPPacketInfo pktInfo, const WeaveMessageInfo *msgInfo,
	uint32_t profileId, uint8_t msgType, PacketBuffer *payload)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	ServiceProvisioningServer server = (ServiceProvisioningServer ) ec->AppState;
	ServiceProvisioningDelegate *delegate = server->mDelegate;
	uint16_t dataLen = payload->DataLength();
	uint8_t *p = payload->Start();

	// Fail messages for the wrong profile. This shouldn't happen, but better safe than sorry.
	if (profileId != kWeaveProfile_ServiceProvisioning)
	{
	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_RegisterServicePairAccount:

	err = RegisterServicePairAccountMessage::Decode(payload, server->mCurClientOpMsg.RegisterServicePairAccount);
	SuccessOrExit(err);

	server->mCurClientOpBuf = payload;
	payload = NULL;

	err = delegate->HandleRegisterServicePairAccount(server->mCurClientOpMsg.RegisterServicePairAccount);
	SuccessOrExit(err);

	break;

	case kMsgType_UpdateService:
	err = UpdateServiceMessage::Decode(payload, server->mCurClientOpMsg.UpdateService);
	SuccessOrExit(err);

	server->mCurClientOpBuf = payload;
	payload = NULL;

	err = delegate->HandleUpdateService(server->mCurClientOpMsg.UpdateService);
	SuccessOrExit(err);

	break;

	case kMsgType_UnregisterService:
	{
	uint64_t serviceId;

	VerifyOrExit(dataLen == 8, err = WEAVE_ERROR_INVALID_MESSAGE_LENGTH);
	serviceId = LittleEndian::Get64(p);

	err = delegate->HandleUnregisterService(serviceId);
	SuccessOrExit(err);

	break;
	}

	default:
	server->SendStatusReport(kWeaveProfile_Common, Common::kStatus_BadRequest);
	break;
	}

	exit:

	if (payload != NULL)
	PacketBuffer::Free(payload);

	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 ServiceProvisioningServer::HandleServerResponse(ExchangeContext ec, const IPPacketInfo pktInfo, const WeaveMessageInfo *msgInfo,
	uint32_t profileId, uint8_t msgType, PacketBuffer *payload)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	WEAVE_ERROR delegateErr = WEAVE_NO_ERROR;
	StatusReport statusReport;
	ServiceProvisioningServer server = (ServiceProvisioningServer ) ec->AppState;

	// Sanity check that the passed-in exchange context is in fact the one that represents the current
	// outstanding server operation. If not, it'll get closed at exit. If it does match, we'll null ec
	// to prevent it from getting closed at exit.
	VerifyOrExit(ec == server->mCurServerOp, err = WEAVE_NO_ERROR);
	ec = NULL;

	// Verify the message is expected.
	VerifyOrExit((profileId == kWeaveProfile_Common && msgType == nl::Weave::Profiles::Common::kMsgType_StatusReport) \|\|
	(profileId == kWeaveProfile_StatusReport_Deprecated),
	err = WEAVE_ERROR_INVALID_MESSAGE_TYPE);

	err = StatusReport::parse(payload, statusReport);
	SuccessOrExit(err);

	// Free the payload here to reduce buffer pressure.
	PacketBuffer::Free(payload);
	payload = NULL;

	delegateErr = (statusReport.mProfileId == kWeaveProfile_Common && statusReport.mStatusCode == Common::kStatus_Success)
	? WEAVE_NO_ERROR
	: WEAVE_ERROR_STATUS_REPORT_RECEIVED;

	server->HandlePairDeviceToAccountResult(delegateErr, statusReport.mProfileId, statusReport.mStatusCode);

	exit:
	// Free the payload first to reduce buffer pressure.
	if (payload != NULL)
	PacketBuffer::Free(payload);
	if (err != WEAVE_NO_ERROR)
	server->HandlePairDeviceToAccountResult(err, 0, 0);
	if (ec != NULL)
	ec->Close();
	}

	void ServiceProvisioningServer::HandleServerResponseTimeout(ExchangeContext *ec)
	{
	ServiceProvisioningServer server = (ServiceProvisioningServer ) ec->AppState;

	// Sanity check that the passed-in exchange context is in fact the one that represents the current
	// outstanding server operation. If not, it'll get closed at exit. If it does match, we'll null ec
	// to prevent it from getting closed at exit.
	VerifyOrExit(ec == server->mCurServerOp, );
	ec = NULL;

	server->HandlePairDeviceToAccountResult(WEAVE_ERROR_TIMEOUT, 0, 0);

	exit:
	if (ec != NULL)
	ec->Close();
	}

	void ServiceProvisioningServer::HandleServerConnectionClosed(ExchangeContext ec, WeaveConnection con, WEAVE_ERROR conErr)
	{
	ServiceProvisioningServer server = (ServiceProvisioningServer ) ec->AppState;

	// Sanity check that the passed-in exchange context is in fact the one that represents the current
	// outstanding server operation. If not, it'll get closed at exit. If it does match, we'll null ec
	// to prevent it from getting closed at exit.
	VerifyOrExit(ec == server->mCurServerOp, );
	ec = NULL;

	// No error on connection close means the service simply closed the connection without responding. In that case
	// deliver WEAVE_ERROR_CONNECTION_CLOSED_UNEXPECTEDLY to the delegate.
	if (conErr == WEAVE_NO_ERROR)
	conErr = WEAVE_ERROR_CONNECTION_CLOSED_UNEXPECTEDLY;

	server->HandlePairDeviceToAccountResult(conErr, 0, 0);

	exit:
	if (ec != NULL)
	ec->Close();
	}

	void ServiceProvisioningServer::HandleServerKeyError(ExchangeContext *ec, WEAVE_ERROR keyErr)
	{
	ServiceProvisioningServer server = (ServiceProvisioningServer ) ec->AppState;

	// Sanity check that the passed-in exchange context is in fact the one that represents the current
	// outstanding server operation. If not, it'll get closed at exit. If it does match, we'll null ec
	// to prevent it from getting closed at exit.
	VerifyOrExit(ec == server->mCurServerOp, );
	ec = NULL;

	server->HandlePairDeviceToAccountResult(keyErr, 0, 0);

	exit:
	if (ec != NULL)
	ec->Close();
	}

	#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
	void ServiceProvisioningServer::HandleServerSendError(ExchangeContext ec, WEAVE_ERROR err, void msgCtxt)
	{
	ServiceProvisioningServer server = (ServiceProvisioningServer ) ec->AppState;

	// Sanity check that the passed-in exchange context is in fact the one that represents the current
	// outstanding server operation. If not, it'll get closed at exit. If it does match, we'll null ec
	// to prevent it from getting closed at exit.
	VerifyOrExit(ec == server->mCurServerOp, );
	ec = NULL;

	server->HandlePairDeviceToAccountResult(err, 0, 0);

	exit:
	if (ec != NULL)
	ec->Close();
	}
	#endif // #if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING

	void ServiceProvisioningServer::HandlePairDeviceToAccountResult(WEAVE_ERROR localErr, uint32_t serverStatusProfileId, uint16_t serverStatusCode)
	{
	mServerOpState = kServerOpState_Idle;
	mCurServerOp->Close();
	mCurServerOp = NULL;

	if (mDelegate)
	{
	mDelegate->HandlePairDeviceToAccountResult(localErr, serverStatusProfileId, serverStatusCode);
	}
	}

	bool ServiceProvisioningServer::IsValidServiceConfig(const uint8_t *serviceConfig, uint16_t serviceConfigLen)
	{
	WEAVE_ERROR err;
	nl::Weave::TLV::TLVReader reader;

	reader.Init(serviceConfig, serviceConfigLen);

	err = reader.Next();
	SuccessOrExit(err);

	VerifyOrExit(reader.GetTag() == ProfileTag(kWeaveProfile_ServiceProvisioning, kTag_ServiceConfig), err = WEAVE_ERROR_INVALID_TLV_TAG);

	{
	TLVType topLevelContainer;
	bool caCertsPresent = false, dirEndPointPresent = false;

	err = reader.EnterContainer(topLevelContainer);
	SuccessOrExit(err);

	while ((err = reader.Next()) == WEAVE_NO_ERROR)
	{
	uint64_t elemTag = reader.GetTag();

	if (!IsContextTag(elemTag))
	continue;

	switch (TagNumFromTag(elemTag))
	{
	case kTag_ServiceConfig_CACerts:
	VerifyOrExit(reader.GetType() == kTLVType_Array, err = WEAVE_ERROR_INVALID_TLV_ELEMENT);
	caCertsPresent = true;
	break;
	case kTag_ServiceConfig_DirectoryEndPoint:
	VerifyOrExit(reader.GetType() == kTLVType_Structure, err = WEAVE_ERROR_INVALID_TLV_ELEMENT);
	dirEndPointPresent = true;
	break;
	default:
	// Ignore unknown elements
	break;
	}
	}

	if (err != WEAVE_END_OF_TLV)
	ExitNow();

	err = reader.ExitContainer(topLevelContainer);
	SuccessOrExit(err);

	VerifyOrExit(caCertsPresent && dirEndPointPresent, err = WEAVE_ERROR_MISSING_TLV_ELEMENT);
	}

	exit:
	return err == WEAVE_NO_ERROR;
	}

	void ServiceProvisioningDelegate::EnforceAccessControl(ExchangeContext *ec, uint32_t msgProfileId, uint8_t msgType,
	const WeaveMessageInfo *msgInfo, AccessControlResult& result)
	{
	enum { kServiceProvisioningEndpointId = 0x18B4300200000010ull };

	// If the result has not already been determined by a subclass...
	if (result == kAccessControlResult_NotDetermined)
	{
	switch (msgType)
	{
	#if WEAVE_CONFIG_REQUIRE_AUTH_SERVICE_PROV

	case kMsgType_RegisterServicePairAccount:
	if (msgInfo->PeerAuthMode == kWeaveAuthMode_PASE_PairingCode && !IsPairedToAccount())
	{
	result = kAccessControlResult_Accepted;
	}
	break;

	case kMsgType_UpdateService:
	if (msgInfo->PeerAuthMode == kWeaveAuthMode_CASE_AccessToken)
	{
	result = kAccessControlResult_Accepted;
	}
	break;

	case kMsgType_UnregisterService:
	if (msgInfo->PeerAuthMode == kWeaveAuthMode_CASE_AccessToken \|\|
	(msgInfo->PeerAuthMode == kWeaveAuthMode_CASE_ServiceEndPoint && msgInfo->SourceNodeId == kServiceProvisioningEndpointId))
	{
	result = kAccessControlResult_Accepted;
	}
	break;

	#else // WEAVE_CONFIG_REQUIRE_AUTH_SERVICE_PROV

	case kMsgType_RegisterServicePairAccount:
	case kMsgType_UpdateService:
	case kMsgType_UnregisterService:
	result = kAccessControlResult_Accepted;
	break;

	#endif // WEAVE_CONFIG_REQUIRE_AUTH_SERVICE_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 ServiceProvisioningDelegate::IsPairedToAccount() const
	{
	return false;
	}

	} // ServiceProvisioning
	} // namespace Profiles
	} // namespace Weave
	} // namespace nl