weave/src/lib/profiles/time/WeaveTime.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 contains implementation of the basic message codecs
  *      used in Time Services #WEAVE_CONFIG_TIME must be defined if
  *      Time Services are needed.
  *
  */

 #ifndef __STDC_CONSTANT_MACROS
 #define __STDC_CONSTANT_MACROS
 #endif

 #include <Weave/Core/WeaveEncoding.h>
 #include <Weave/Profiles/time/WeaveTime.h>
 #include <Weave/Support/CodeUtils.h>
 #include <Weave/Support/ErrorStr.h>
 #include <Weave/Support/MathUtils.h>
 #include <Weave/Support/logging/WeaveLogging.h>

 #if WEAVE_CONFIG_TIME

 using namespace nl::Weave::Encoding;

 using namespace nl::Weave::Profiles::Time;

 TimeChangeNotification::TimeChangeNotification(void)
 {
 }

 WEAVE_ERROR TimeChangeNotification::Encode(PacketBuffer* const aMsg)
 {
     // note that we assume the buffer is big enough for this message
     uint8_t *cursor = aMsg->Start();

     // write stuff into the message body
     // 16 reserved bits, all set to 0
     LittleEndian::Write16(cursor, 0);

     aMsg->SetDataLength(cursor - aMsg->Start());

     return WEAVE_NO_ERROR;
 }

 WEAVE_ERROR TimeChangeNotification::Decode(TimeChangeNotification * const aObject, PacketBuffer* const aMsg)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     // we should have at least 16 reserved bits

     if (aMsg->DataLength() < 2)
     {
         ExitNow(err = WEAVE_ERROR_INVALID_MESSAGE_LENGTH);
     }

     {
         const uint8_t *cursor = aMsg->Start();
         const uint16_t status = LittleEndian::Read16(cursor);

         // non-zero reserved bits indicate the message has some extension that we are not aware of

         if (status != 0)
         {
             WeaveLogDetail(TimeService,
                 "TimeSyncRequestAdvisory unknown extension, as reserved bits are not all 0s (0x%X)",
                 status);
         }
     }

 exit:
     WeaveLogFunctError(err);

     return err;
 }

 TimeSyncRequest::TimeSyncRequest(void) :
     mLikelihoodForResponse(kLikelihoodForResponse_Min)
 {
 }

 void TimeSyncRequest::Init(const uint8_t aLikelihood, const bool aIsTimeCoordinator)
 {
     mLikelihoodForResponse = aLikelihood;
     mIsTimeCoordinator = aIsTimeCoordinator;
 }

 WEAVE_ERROR TimeSyncRequest::Encode(PacketBuffer* const aMsg)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     // validate the source object first

     // Note that we cannot put check on kLikelihoodForResponse_Min here, because it's currently set to 0.
     // The compiler would argue it's unnecessary
     if (mLikelihoodForResponse > kLikelihoodForResponse_Max)
     {
         ExitNow(err = WEAVE_ERROR_INCORRECT_STATE);
     }

     {
         // Compose the 16-bit status
         const uint16_t status = ((mLikelihoodForResponse & 0x1F) << 1) | (mIsTimeCoordinator ? 1 : 0);

         // write stuff into the message body
         // note that we assume the buffer is big enough for this message
         uint8_t *cursor = aMsg->Start();
         LittleEndian::Write16(cursor, status);

         // calculate the message length again
         aMsg->SetDataLength(cursor - aMsg->Start());
     }

 exit:
     WeaveLogFunctError(err);

     return err;
 }

 WEAVE_ERROR TimeSyncRequest::Decode(TimeSyncRequest * const aObject, PacketBuffer* const aMsg)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     // at least 2 bytes of status

     if (aMsg->DataLength() < 2)
     {
         ExitNow(err = WEAVE_ERROR_INVALID_MESSAGE_LENGTH);
     }

     {
         const uint8_t *cursor = aMsg->Start();
         const uint16_t status = LittleEndian::Read16(cursor);

         // lowest 1-bit
         aObject->mIsTimeCoordinator = status & 0x1;

         // next 5-bit
         aObject->mLikelihoodForResponse = (status >> 1) & 0x1F;

         // Note that we cannot put check on kLikelihoodForResponse_Min here, because it's currently set to 0.
         // The compiler would argue it's unnecessary
         if (aObject->mLikelihoodForResponse > kLikelihoodForResponse_Max)
         {
             ExitNow(err = WEAVE_ERROR_MESSAGE_INCOMPLETE);
         }

         // anything other than the low 6-bit is reserved
         // non-zero reserved bits indicate the message has some extension that we are not aware of
         if ((status >> 6) != 0)
         {
             WeaveLogDetail(TimeService, "TimeSyncRequest unknown extension, as reserved bits are not all 0s (0x%X)",
                 status);
         }
     }

 exit:
     WeaveLogFunctError(err);

     return err;
 }

 TimeSyncResponse::TimeSyncResponse(void)
 {
 }

 void TimeSyncResponse::Init(const TimeSyncRole aRole, const timesync_t aTimeOfRequest,
     const timesync_t aTimeOfResponse,
     const uint8_t aNumContributorInLastLocalSync, const uint16_t aTimeSinceLastSyncWithServer_min)
 {
     mIsTimeCoordinator = (kTimeSyncRole_Coordinator == aRole) ? true : false;
     mTimeOfRequest = aTimeOfRequest;
     mTimeOfResponse = aTimeOfResponse;

     mNumContributorInLastLocalSync = aNumContributorInLastLocalSync;
     // clamp the number of contacts to kNumberOfContact_Max
     if (mNumContributorInLastLocalSync > kNumberOfContributor_Max)
     {
         mNumContributorInLastLocalSync = kNumberOfContributor_Max;
     }

     if (aTimeSinceLastSyncWithServer_min <= kTimeSinceLastSyncWithServer_Max)
     {
         mTimeSinceLastSyncWithServer_min = aTimeSinceLastSyncWithServer_min;
     }
     else
     {
         mTimeSinceLastSyncWithServer_min = kTimeSinceLastSyncWithServer_Invalid;
     }
 }

 WEAVE_ERROR TimeSyncResponse::Encode(PacketBuffer* const aMsg)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     // Compose the 16-bit status
     const uint16_t status = uint16_t(((mNumContributorInLastLocalSync & 0x1F) << 1) | (mIsTimeCoordinator ? 1 : 0));
     const uint16_t freshness = uint16_t(mTimeSinceLastSyncWithServer_min & 0xFFF);

     // write stuff into the message body
     // note that we assume the buffer is big enough for this message
     uint8_t *cursor = aMsg->Start();

     LittleEndian::Write16(cursor, status);
     LittleEndian::Write64(cursor, mTimeOfRequest);
     LittleEndian::Write64(cursor, mTimeOfResponse);
     LittleEndian::Write16(cursor, freshness);

     // calculate the message length again
     aMsg->SetDataLength(cursor - aMsg->Start());

     WeaveLogFunctError(err);

     return err;
 }

 WEAVE_ERROR TimeSyncResponse::Decode(TimeSyncResponse * const aObject, PacketBuffer* const aMsg)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     // at least 2 bytes of status plus 8 bytes of timestamp

     if (aMsg->DataLength() < 20)
     {
         ExitNow(err = WEAVE_ERROR_INVALID_MESSAGE_LENGTH);
     }

     {
         const uint8_t *cursor = aMsg->Start();
         const uint16_t status = LittleEndian::Read16(cursor);

         aObject->mTimeOfRequest = LittleEndian::Read64(cursor);
         aObject->mTimeOfResponse = LittleEndian::Read64(cursor);
         aObject->mTimeSinceLastSyncWithServer_min = (LittleEndian::Read16(cursor) & 0xFFF);

         if (aObject->mTimeOfRequest & MASK_INVALID_TIMESYNC)
         {
             ExitNow(err = WEAVE_ERROR_MESSAGE_INCOMPLETE);
         }

         if (aObject->mTimeOfResponse & MASK_INVALID_TIMESYNC)
         {
             ExitNow(err = WEAVE_ERROR_MESSAGE_INCOMPLETE);
         }

         // lowest 1-bit
         aObject->mIsTimeCoordinator = bool(status & 0x1);

         // next 5-bit
         aObject->mNumContributorInLastLocalSync = ((status >> 1) & 0x1F);

         // anything other than the low 6-bit is reserved
         // non-zero reserved bits indicate the message has some extension that we are not aware of
         if ((status >> 6) != 0)
         {
             WeaveLogDetail(TimeService, "TimeSyncResponse unknown extension, as reserved bits are not all 0s (0x%X)",
                 status);
         }
     }

 exit:
     WeaveLogFunctError(err);

     return err;
 }

 _TimeSyncNodeBase::_TimeSyncNodeBase(void) :
     FabricState(NULL),
     ExchangeMgr(NULL)
 {

 }

 void _TimeSyncNodeBase::Init(WeaveFabricState * const aFabricState,
     WeaveExchangeManager * const aExchangeMgr)
 {
     FabricState = aFabricState;
     ExchangeMgr = aExchangeMgr;
 }

 #endif // WEAVE_CONFIG_TIME
	/*
	*
	* 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 contains implementation of the basic message codecs
	* used in Time Services #WEAVE_CONFIG_TIME must be defined if
	* Time Services are needed.
	*
	*/

	#ifndef __STDC_CONSTANT_MACROS
	#define __STDC_CONSTANT_MACROS
	#endif

	#include <Weave/Core/WeaveEncoding.h>
	#include <Weave/Profiles/time/WeaveTime.h>
	#include <Weave/Support/CodeUtils.h>
	#include <Weave/Support/ErrorStr.h>
	#include <Weave/Support/MathUtils.h>
	#include <Weave/Support/logging/WeaveLogging.h>

	#if WEAVE_CONFIG_TIME

	using namespace nl::Weave::Encoding;

	using namespace nl::Weave::Profiles::Time;

	TimeChangeNotification::TimeChangeNotification(void)
	{
	}

	WEAVE_ERROR TimeChangeNotification::Encode(PacketBuffer* const aMsg)
	{
	// note that we assume the buffer is big enough for this message
	uint8_t *cursor = aMsg->Start();

	// write stuff into the message body
	// 16 reserved bits, all set to 0
	LittleEndian::Write16(cursor, 0);

	aMsg->SetDataLength(cursor - aMsg->Start());

	return WEAVE_NO_ERROR;
	}

	WEAVE_ERROR TimeChangeNotification::Decode(TimeChangeNotification * const aObject, PacketBuffer* const aMsg)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	// we should have at least 16 reserved bits

	if (aMsg->DataLength() < 2)
	{
	ExitNow(err = WEAVE_ERROR_INVALID_MESSAGE_LENGTH);
	}

	{
	const uint8_t *cursor = aMsg->Start();
	const uint16_t status = LittleEndian::Read16(cursor);

	// non-zero reserved bits indicate the message has some extension that we are not aware of

	if (status != 0)
	{
	WeaveLogDetail(TimeService,
	"TimeSyncRequestAdvisory unknown extension, as reserved bits are not all 0s (0x%X)",
	status);
	}
	}

	exit:
	WeaveLogFunctError(err);

	return err;
	}

	TimeSyncRequest::TimeSyncRequest(void) :
	mLikelihoodForResponse(kLikelihoodForResponse_Min)
	{
	}

	void TimeSyncRequest::Init(const uint8_t aLikelihood, const bool aIsTimeCoordinator)
	{
	mLikelihoodForResponse = aLikelihood;
	mIsTimeCoordinator = aIsTimeCoordinator;
	}

	WEAVE_ERROR TimeSyncRequest::Encode(PacketBuffer* const aMsg)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	// validate the source object first

	// Note that we cannot put check on kLikelihoodForResponse_Min here, because it's currently set to 0.
	// The compiler would argue it's unnecessary
	if (mLikelihoodForResponse > kLikelihoodForResponse_Max)
	{
	ExitNow(err = WEAVE_ERROR_INCORRECT_STATE);
	}

	{
	// Compose the 16-bit status
	const uint16_t status = ((mLikelihoodForResponse & 0x1F) << 1) \| (mIsTimeCoordinator ? 1 : 0);

	// write stuff into the message body
	// note that we assume the buffer is big enough for this message
	uint8_t *cursor = aMsg->Start();
	LittleEndian::Write16(cursor, status);

	// calculate the message length again
	aMsg->SetDataLength(cursor - aMsg->Start());
	}

	exit:
	WeaveLogFunctError(err);

	return err;
	}

	WEAVE_ERROR TimeSyncRequest::Decode(TimeSyncRequest * const aObject, PacketBuffer* const aMsg)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	// at least 2 bytes of status

	if (aMsg->DataLength() < 2)
	{
	ExitNow(err = WEAVE_ERROR_INVALID_MESSAGE_LENGTH);
	}

	{
	const uint8_t *cursor = aMsg->Start();
	const uint16_t status = LittleEndian::Read16(cursor);

	// lowest 1-bit
	aObject->mIsTimeCoordinator = status & 0x1;

	// next 5-bit
	aObject->mLikelihoodForResponse = (status >> 1) & 0x1F;

	// Note that we cannot put check on kLikelihoodForResponse_Min here, because it's currently set to 0.
	// The compiler would argue it's unnecessary
	if (aObject->mLikelihoodForResponse > kLikelihoodForResponse_Max)
	{
	ExitNow(err = WEAVE_ERROR_MESSAGE_INCOMPLETE);
	}

	// anything other than the low 6-bit is reserved
	// non-zero reserved bits indicate the message has some extension that we are not aware of
	if ((status >> 6) != 0)
	{
	WeaveLogDetail(TimeService, "TimeSyncRequest unknown extension, as reserved bits are not all 0s (0x%X)",
	status);
	}
	}

	exit:
	WeaveLogFunctError(err);

	return err;
	}

	TimeSyncResponse::TimeSyncResponse(void)
	{
	}

	void TimeSyncResponse::Init(const TimeSyncRole aRole, const timesync_t aTimeOfRequest,
	const timesync_t aTimeOfResponse,
	const uint8_t aNumContributorInLastLocalSync, const uint16_t aTimeSinceLastSyncWithServer_min)
	{
	mIsTimeCoordinator = (kTimeSyncRole_Coordinator == aRole) ? true : false;
	mTimeOfRequest = aTimeOfRequest;
	mTimeOfResponse = aTimeOfResponse;

	mNumContributorInLastLocalSync = aNumContributorInLastLocalSync;
	// clamp the number of contacts to kNumberOfContact_Max
	if (mNumContributorInLastLocalSync > kNumberOfContributor_Max)
	{
	mNumContributorInLastLocalSync = kNumberOfContributor_Max;
	}

	if (aTimeSinceLastSyncWithServer_min <= kTimeSinceLastSyncWithServer_Max)
	{
	mTimeSinceLastSyncWithServer_min = aTimeSinceLastSyncWithServer_min;
	}
	else
	{
	mTimeSinceLastSyncWithServer_min = kTimeSinceLastSyncWithServer_Invalid;
	}
	}

	WEAVE_ERROR TimeSyncResponse::Encode(PacketBuffer* const aMsg)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	// Compose the 16-bit status
	const uint16_t status = uint16_t(((mNumContributorInLastLocalSync & 0x1F) << 1) \| (mIsTimeCoordinator ? 1 : 0));
	const uint16_t freshness = uint16_t(mTimeSinceLastSyncWithServer_min & 0xFFF);

	// write stuff into the message body
	// note that we assume the buffer is big enough for this message
	uint8_t *cursor = aMsg->Start();

	LittleEndian::Write16(cursor, status);
	LittleEndian::Write64(cursor, mTimeOfRequest);
	LittleEndian::Write64(cursor, mTimeOfResponse);
	LittleEndian::Write16(cursor, freshness);

	// calculate the message length again
	aMsg->SetDataLength(cursor - aMsg->Start());

	WeaveLogFunctError(err);

	return err;
	}

	WEAVE_ERROR TimeSyncResponse::Decode(TimeSyncResponse * const aObject, PacketBuffer* const aMsg)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	// at least 2 bytes of status plus 8 bytes of timestamp

	if (aMsg->DataLength() < 20)
	{
	ExitNow(err = WEAVE_ERROR_INVALID_MESSAGE_LENGTH);
	}

	{
	const uint8_t *cursor = aMsg->Start();
	const uint16_t status = LittleEndian::Read16(cursor);

	aObject->mTimeOfRequest = LittleEndian::Read64(cursor);
	aObject->mTimeOfResponse = LittleEndian::Read64(cursor);
	aObject->mTimeSinceLastSyncWithServer_min = (LittleEndian::Read16(cursor) & 0xFFF);

	if (aObject->mTimeOfRequest & MASK_INVALID_TIMESYNC)
	{
	ExitNow(err = WEAVE_ERROR_MESSAGE_INCOMPLETE);
	}

	if (aObject->mTimeOfResponse & MASK_INVALID_TIMESYNC)
	{
	ExitNow(err = WEAVE_ERROR_MESSAGE_INCOMPLETE);
	}

	// lowest 1-bit
	aObject->mIsTimeCoordinator = bool(status & 0x1);

	// next 5-bit
	aObject->mNumContributorInLastLocalSync = ((status >> 1) & 0x1F);

	// anything other than the low 6-bit is reserved
	// non-zero reserved bits indicate the message has some extension that we are not aware of
	if ((status >> 6) != 0)
	{
	WeaveLogDetail(TimeService, "TimeSyncResponse unknown extension, as reserved bits are not all 0s (0x%X)",
	status);
	}
	}

	exit:
	WeaveLogFunctError(err);

	return err;
	}

	_TimeSyncNodeBase::_TimeSyncNodeBase(void) :
	FabricState(NULL),
	ExchangeMgr(NULL)
	{

	}

	void _TimeSyncNodeBase::Init(WeaveFabricState * const aFabricState,
	WeaveExchangeManager * const aExchangeMgr)
	{
	FabricState = aFabricState;
	ExchangeMgr = aExchangeMgr;
	}

	#endif // WEAVE_CONFIG_TIME