weave/src/test-apps/MockAlarmOriginator.cpp - nest-cam/4320010/weave - Git at Google

 /*
  *
  *    Copyright (c) 2014-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.
  */

 // __STDC_LIMIT_MACROS must be defined for UINT8_MAX and INT32_MAX to be defined for pre-C++11 clib
 #ifndef __STDC_LIMIT_MACROS
 #define __STDC_LIMIT_MACROS
 #endif // __STDC_LIMIT_MACROS

 // __STDC_CONSTANT_MACROS must be defined for INT64_C and UINT64_C to be defined for pre-C++11 clib
 #ifndef __STDC_CONSTANT_MACROS
 #define __STDC_CONSTANT_MACROS
 #endif // __STDC_CONSTANT_MACROS

 // it is important for this first inclusion of stdint.h to have all the right switches turned ON
 #include <stdint.h>

 // __STDC_FORMAT_MACROS must be defined for PRIX64 to be defined for pre-C++11 clib
 #ifndef __STDC_FORMAT_MACROS
 #define __STDC_FORMAT_MACROS
 #endif // __STDC_FORMAT_MACROS

 // it is important for this first inclusion of inttypes.h to have all the right switches turned ON
 #include <inttypes.h>

 #define WEAVE_CONFIG_ENABLE_LOG_FILE_LINE_FUNC_ON_ERROR 1

 #include <Weave/Support/CodeUtils.h>
 #include <Weave/Support/logging/WeaveLogging.h>
 #include <Weave/Support/ErrorStr.h>

 #include "MockAlarmOriginator.h"
 #include "MockAlarmRemote.h"

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

 WeaveAlarmServer gAlarmServer;

 AlarmHushRequest hushChallenge;

 void LogAlarmCondition(const uint8_t alarm_condition);

 MockAlarmOriginator::MockAlarmOriginator() :
     mAlarmClient(NULL)
 {
 }

 WEAVE_ERROR MockAlarmOriginator::Init(WeaveExchangeManager *exchangeMgr,
     const bool shouldAlarm,
     const uint8_t encryptionType,
     const uint16_t keyId)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;
     Alarm alarm;

     err = gAlarmServer.Init(exchangeMgr, this);
     SuccessOrExit(err);

     gAlarmServer.mInterfaceId = INET_NULL_INTERFACEID;
     gAlarmServer.mAlarmRebroadcastPeriodMsec = 4000;         // ms
     gAlarmServer.mAlarmRefreshPeriodMsec = 30000;            // ms
     gAlarmServer.mAlarmRebroadcastThreshold = 6;

     err = hushChallenge.init();
     SuccessOrExit(err);

     {
         // challenge code shall be sent over through BLE advertising, in the hope of saving one round trip
         const uint32_t challengeCode = 0xABCD0123;
         const uint16_t hushKeyId = 0x0002;
         const uint8_t hushKey [16] = { 1 };
         hushChallenge.mProximityVerificationCode = 0xDEADBEEF;
         err = hushChallenge.sign(challengeCode, hushKeyId, hushKey, int16_t(sizeof(hushKey)));
         SuccessOrExit(err);
         WeaveLogProgress(Alarm, "Hush challenge: 0x%X keyId: 0x%X, key is %d-byte starting with %d",
             challengeCode, hushChallenge.mSignature.mKeyId, sizeof(hushKey), hushKey[0]);
         WeaveLogProgress(Alarm, "Hush mSignature part 1: %02X%02X%02X%02X-%02X%02X%02X%02X",
             hushChallenge.mSignature.mKeyedHash[0], hushChallenge.mSignature.mKeyedHash[1],
             hushChallenge.mSignature.mKeyedHash[2], hushChallenge.mSignature.mKeyedHash[3],
             hushChallenge.mSignature.mKeyedHash[4], hushChallenge.mSignature.mKeyedHash[5],
             hushChallenge.mSignature.mKeyedHash[6], hushChallenge.mSignature.mKeyedHash[7]);
         WeaveLogProgress(Alarm, "Hush mSignature part 2: %02X%02X%02X%02X-%02X%02X%02X%02X",
             hushChallenge.mSignature.mKeyedHash[8], hushChallenge.mSignature.mKeyedHash[9],
             hushChallenge.mSignature.mKeyedHash[10], hushChallenge.mSignature.mKeyedHash[11],
             hushChallenge.mSignature.mKeyedHash[12], hushChallenge.mSignature.mKeyedHash[13],
             hushChallenge.mSignature.mKeyedHash[14], hushChallenge.mSignature.mKeyedHash[15]);
         WeaveLogProgress(Alarm, "Hush mSignature part 3: %02X%02X%02X%02X",
             hushChallenge.mSignature.mKeyedHash[16], hushChallenge.mSignature.mKeyedHash[17],
             hushChallenge.mSignature.mKeyedHash[18], hushChallenge.mSignature.mKeyedHash[19]);
     }

     gAlarmServer.SetAlarmDelegate(this);

     mAlarmClient = gAlarmServer.NewClient(kAnyNodeId, encryptionType, keyId);
     VerifyOrExit(NULL != mAlarmClient, err = WEAVE_ERROR_NO_MEMORY);

     if (shouldAlarm)
     {
         alarm.AddAlarm(WEAVE_ALARM_CO | WEAVE_ALARM_STATE_HEADS_UP_1);
         alarm.AddAlarm(WEAVE_ALARM_SMOKE | WEAVE_ALARM_STATE_ALARM_NONHUSHABLE);

         err = mAlarmClient->SendAlarm(&alarm);
         SuccessOrExit(err);
     }

     {
         // just a simple test to demo how random number generation utility routines work
         uint32_t testRandom = 0;
         WeaveAlarmClient::GenerateHushChallenge(&testRandom);
         WeaveLogProgress(Alarm, "Random number generated for hush challenge code: 0x%X", testRandom);
         WeaveAlarmClient::GenerateProximityVerificationCode(&testRandom);
         WeaveLogProgress(Alarm, "Random number generated for proximity verification code: 0x%X", testRandom);
     }

 exit:
     WeaveLogFunctError(err);

     return err;
 }

 WEAVE_ERROR MockAlarmOriginator::Shutdown(void)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     err = gAlarmServer.Shutdown();
     SuccessOrExit(err);

 exit:
     WeaveLogFunctError(err);

     return err;
 }

 WEAVE_ERROR MockAlarmOriginator::OnHushRequest(nl::Weave::ExchangeContext *ec, uint32_t proximityVerificationCode, const AlarmHushSignature & signature)
 {
     WEAVE_ERROR err = WEAVE_NO_ERROR;

     // Application code shall verify the content/signature of the hush request and decide if
     // this request needs to be further processed
     // hush requests coming from channels other than BLE can be ignored

     WeaveLogProgress(Alarm, "Req key id: 0x%X", signature.mKeyId);

     WeaveLogProgress(Alarm, "Req signature part 1: %02X%02X%02X%02X-%02X%02X%02X%02X",
         signature.mKeyedHash[0], signature.mKeyedHash[1],
         signature.mKeyedHash[2], signature.mKeyedHash[3],
         signature.mKeyedHash[4], signature.mKeyedHash[5],
         signature.mKeyedHash[6], signature.mKeyedHash[7]);
     WeaveLogProgress(Alarm, "Req signature part 2: %02X%02X%02X%02X-%02X%02X%02X%02X",
         signature.mKeyedHash[8], signature.mKeyedHash[9],
         signature.mKeyedHash[10], signature.mKeyedHash[11],
         signature.mKeyedHash[12], signature.mKeyedHash[13],
         signature.mKeyedHash[14], signature.mKeyedHash[15]);
     WeaveLogProgress(Alarm, "Req signature part 3: %02X%02X%02X%02X",
         signature.mKeyedHash[16], signature.mKeyedHash[17],
         signature.mKeyedHash[18], signature.mKeyedHash[19]);

     if (!signature.mIsSigned)
     {
         WeaveLogProgress(Alarm, "Hush: not signed");

         // the request is not signed
         err = gAlarmServer.SendStatusReport(kWeaveProfile_Alarm,
             kAlarmStatusReport_HushRejected_SignatureValidationFailure);
     }
     else if (hushChallenge.mSignature != signature)
     {
         WeaveLogProgress(Alarm, "Hush: not signed or signature doesn't match");

         // since we use signature comparison, the request is either not signed, or doesn't match with ours
         err = gAlarmServer.SendStatusReport(kWeaveProfile_Alarm,
             kAlarmStatusReport_HushRejected_SignatureValidationFailure);
     }
     else if (NULL == mAlarmClient)
     {
         WeaveLogProgress(Alarm, "Hush: no alarm");

         // there is no Alarm at all to hush, but we should still respond with a 'success',
         err = gAlarmServer.SendHushResponse(kAlarmHushResult_Success);
         SuccessOrExit(err);
     }
     else
     {
         WeaveLogProgress(Alarm, "Hush: incoming proximity verification code 0x%X", proximityVerificationCode);

         if (hushChallenge.mProximityVerificationCode != proximityVerificationCode)
         {
             WeaveLogProgress(Alarm, "Hush: expected proximity verification code 0x%X, doesn't match", proximityVerificationCode);

             err = gAlarmServer.SendStatusReport(kWeaveProfile_Alarm,
                 kAlarmStatusReport_HushRejected_ProximityValidationFailure);
             SuccessOrExit(err);
         }
         else
         {
             // apply hush to each of condition we have
             // application code might have other logic to execute for hushing and doesn't have to be
             // bound by this particular Alarm object
             Alarm & currentAlarm(mAlarmClient->mCurrentAlarm);

             WeaveLogProgress(Alarm, "BEFORE Hush: counter [%d] with [%d] conditions",
                 currentAlarm.mAlarmCtr,
                 currentAlarm.mLength);

             for (int i = 0; i < currentAlarm.mLength; ++i)
             {
                 LogAlarmCondition(currentAlarm.mConditions[i]);
             }

             for (int i = 0; i < currentAlarm.mLength; ++i)
             {
                 if (currentAlarm.GetAlarmState(i) <= WEAVE_ALARM_STATE_ALARM_HUSHABLE)
                 {
                     currentAlarm.SetAlarmState(i, WEAVE_ALARM_STATE_ALARM_REMOTE_HUSH);
                 }
             }

             WeaveLogProgress(Alarm, "AFTER Hush: counter [%d] with [%d] conditions",
                 currentAlarm.mAlarmCtr,
                 currentAlarm.mLength);

             for (int i = 0; i < currentAlarm.mLength; ++i)
             {
                 LogAlarmCondition(currentAlarm.mConditions[i]);
             }

             // this call 'kills' the alarm and makes the pointer useless
             mAlarmClient->Close();
             mAlarmClient = NULL;

             err = gAlarmServer.SendHushResponse(kAlarmHushResult_Success, currentAlarm.mLength, currentAlarm.mConditions);
             SuccessOrExit(err);
         }
     }

 exit:
     WeaveLogFunctError(err);

     return err;
 }

 void LogAlarmCondition(const uint8_t alarm_condition)
 {
     const char * state;
     const char * source;

     switch (alarm_condition & 0xf0)
     {
     case WEAVE_ALARM_SMOKE:
         source = "smoke";
         break;
     case WEAVE_ALARM_TEMP:
         source = "temperature";
         break;
     case WEAVE_ALARM_CO:
         source = "carbon monoxide";
         break;
     case WEAVE_ALARM_CH4:
         source = "gas";
         break;
     case WEAVE_ALARM_HUMIDITY:
         source = "humidity";
         break;
     case WEAVE_ALARM_OTHER:
         source = "other";
         break;
     default:
         source = "unknown";
         break;
     }

     switch (alarm_condition & 0x0f)
     {
     case WEAVE_ALARM_STATE_STANDBY:
         state = "standby";
         break;
     case WEAVE_ALARM_STATE_HEADS_UP_1:
         state = "heads up 1";
         break;
     case WEAVE_ALARM_STATE_HEADS_UP_2:
         state = "heads up 2";
         break;
     case WEAVE_ALARM_STATE_HU_HUSH:
         state = "heads up hush";
         break;
     case WEAVE_ALARM_STATE_ALARM_HUSHABLE:
         state = "ALARM, hushable";
         break;
     case WEAVE_ALARM_STATE_ALARM_NONHUSHABLE:
         state = "ALARM, NONHUSHABLE";
         break;
     case WEAVE_ALARM_STATE_ALARM_GLOBAL_HUSH:
         state = "global hush";
         break;
     case WEAVE_ALARM_STATE_ALARM_REMOTE_HUSH:
         state = "remote hush";
         break;
     case WEAVE_ALARM_STATE_SELFTEST:
         state = "selftest";
         break;
     default:
         state = "unknown";
         break;
     }

     WeaveLogProgress(Alarm, "[%s]: [%s]", state, source);
 }

 void MockAlarmOriginator::OnAlarmClientStateChange(WeaveAlarmClient * const aClient)
 {
     WeaveLogProgress(Alarm, "Alarm from 0x%" PRIx64 " changed", aClient->GetOriginator());

     for (int i = 0; i < aClient->mCurrentAlarm.mLength; ++i)
     {
         LogAlarmCondition(aClient->mCurrentAlarm.GetAlarm(i));
     }
 }

 void MockAlarmOriginator::OnNewRemoteAlarmDropped(const Alarm & aAlarm)
 {
     WeaveLogProgress(Alarm, "Alarm at where id [%u] has been dropped", aAlarm.mWhere);

     for (int i = 0; i < aAlarm.mLength; ++i)
     {
         LogAlarmCondition(aAlarm.GetAlarm(i));
     }
 }

 int MockAlarmOriginator::CompareSeverity(const Alarm & aAlarm1, const Alarm & aAlarm2)
 {
     enum
     {
         kResultSource_Smoke = 0,
         kResultSource_CO = 1,

         kResultAlarm1 = +1,
         kResultTie = 0,
         kResultAlarm2 = -1,

         kNumRecognizedAlarmSources = 2,
     };

     int resultTable[kNumRecognizedAlarmSources][2];
     resultTable[kResultSource_Smoke][0] = WEAVE_ALARM_STATE_INVALID;
     resultTable[kResultSource_Smoke][1] = kResultTie;
     resultTable[kResultSource_CO][0] = WEAVE_ALARM_STATE_INVALID;
     resultTable[kResultSource_CO][1] = kResultTie;

     for (int i = 0; i < aAlarm1.mLength; ++i)
     {
         switch (aAlarm1.GetAlarmCondition(i))
         {
         case WEAVE_ALARM_SMOKE:
             resultTable[kResultSource_Smoke][0] = aAlarm1.GetAlarmState(i);
             break;

         case WEAVE_ALARM_CO:
             resultTable[kResultSource_CO][0] = aAlarm1.GetAlarmState(i);
             break;

         default:
             WeaveLogError(Alarm, "Ignore unknown alarm source %u", aAlarm1.GetAlarmCondition(i));
         }
     }

     for (int i = 0; i < aAlarm2.mLength; ++i)
     {
         switch (aAlarm1.GetAlarmCondition(i))
         {
         case WEAVE_ALARM_SMOKE:
             if (WEAVE_ALARM_STATE_INVALID == resultTable[kResultSource_Smoke][0])
             {
                 // alarm1 doesn't have this source, so alarm2 wins here
                 resultTable[kResultSource_Smoke][0] = aAlarm2.GetAlarmState(i);
                 resultTable[kResultSource_Smoke][1] = kResultAlarm2;
             }
             else
             {
                 // both alarm1 and alarm2 have this source. let's compare them
                 const int state1 = resultTable[kResultSource_Smoke][0];
                 const int state2 = aAlarm2.GetAlarmState(i);
                 if (state1 > state2)
                 {
                     resultTable[kResultSource_Smoke][1] = kResultAlarm1;
                 }
                 else if (state1 == state2)
                 {
                     resultTable[kResultSource_Smoke][1] = kResultTie;
                 }
                 else
                 {
                     resultTable[kResultSource_Smoke][1] = kResultAlarm2;
                 }
             }
             break;

         case WEAVE_ALARM_CO:
             if (WEAVE_ALARM_STATE_INVALID == resultTable[kResultSource_CO][0])
             {
                 // alarm1 doesn't have this source, so alarm2 wins here
                 resultTable[kResultSource_CO][0] = aAlarm2.GetAlarmState(i);
                 resultTable[kResultSource_CO][1] = kResultAlarm2;
             }
             else
             {
                 // both alarm1 and alarm2 have this source. let's compare them
                 const int state1 = resultTable[kResultSource_CO][0];
                 const int state2 = aAlarm2.GetAlarmState(i);
                 if (state1 > state2)
                 {
                     resultTable[kResultSource_CO][1] = kResultAlarm1;
                 }
                 else if (state1 == state2)
                 {
                     resultTable[kResultSource_CO][1] = kResultTie;
                 }
                 else
                 {
                     resultTable[kResultSource_CO][1] = kResultAlarm2;
                 }
             }
             break;

         default:
             WeaveLogError(Alarm, "Ignore unknown alarm source %u", aAlarm2.GetAlarmCondition(i));
         }
     }

     if (resultTable[kResultSource_Smoke][1] != kResultTie)
     {
         // Smoke take precedence. Use the result of smoke if possible
         return resultTable[kResultSource_Smoke][1];
     }
     else
     {
         // otherwise, use CO
         return resultTable[kResultSource_CO][1];
     }
 }
	/*
	*
	* Copyright (c) 2014-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.
	*/

	// __STDC_LIMIT_MACROS must be defined for UINT8_MAX and INT32_MAX to be defined for pre-C++11 clib
	#ifndef __STDC_LIMIT_MACROS
	#define __STDC_LIMIT_MACROS
	#endif // __STDC_LIMIT_MACROS

	// __STDC_CONSTANT_MACROS must be defined for INT64_C and UINT64_C to be defined for pre-C++11 clib
	#ifndef __STDC_CONSTANT_MACROS
	#define __STDC_CONSTANT_MACROS
	#endif // __STDC_CONSTANT_MACROS

	// it is important for this first inclusion of stdint.h to have all the right switches turned ON
	#include <stdint.h>

	// __STDC_FORMAT_MACROS must be defined for PRIX64 to be defined for pre-C++11 clib
	#ifndef __STDC_FORMAT_MACROS
	#define __STDC_FORMAT_MACROS
	#endif // __STDC_FORMAT_MACROS

	// it is important for this first inclusion of inttypes.h to have all the right switches turned ON
	#include <inttypes.h>

	#define WEAVE_CONFIG_ENABLE_LOG_FILE_LINE_FUNC_ON_ERROR 1

	#include <Weave/Support/CodeUtils.h>
	#include <Weave/Support/logging/WeaveLogging.h>
	#include <Weave/Support/ErrorStr.h>

	#include "MockAlarmOriginator.h"
	#include "MockAlarmRemote.h"

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

	WeaveAlarmServer gAlarmServer;

	AlarmHushRequest hushChallenge;

	void LogAlarmCondition(const uint8_t alarm_condition);

	MockAlarmOriginator::MockAlarmOriginator() :
	mAlarmClient(NULL)
	{
	}

	WEAVE_ERROR MockAlarmOriginator::Init(WeaveExchangeManager *exchangeMgr,
	const bool shouldAlarm,
	const uint8_t encryptionType,
	const uint16_t keyId)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;
	Alarm alarm;

	err = gAlarmServer.Init(exchangeMgr, this);
	SuccessOrExit(err);

	gAlarmServer.mInterfaceId = INET_NULL_INTERFACEID;
	gAlarmServer.mAlarmRebroadcastPeriodMsec = 4000; // ms
	gAlarmServer.mAlarmRefreshPeriodMsec = 30000; // ms
	gAlarmServer.mAlarmRebroadcastThreshold = 6;

	err = hushChallenge.init();
	SuccessOrExit(err);

	{
	// challenge code shall be sent over through BLE advertising, in the hope of saving one round trip
	const uint32_t challengeCode = 0xABCD0123;
	const uint16_t hushKeyId = 0x0002;
	const uint8_t hushKey [16] = { 1 };
	hushChallenge.mProximityVerificationCode = 0xDEADBEEF;
	err = hushChallenge.sign(challengeCode, hushKeyId, hushKey, int16_t(sizeof(hushKey)));
	SuccessOrExit(err);
	WeaveLogProgress(Alarm, "Hush challenge: 0x%X keyId: 0x%X, key is %d-byte starting with %d",
	challengeCode, hushChallenge.mSignature.mKeyId, sizeof(hushKey), hushKey[0]);
	WeaveLogProgress(Alarm, "Hush mSignature part 1: %02X%02X%02X%02X-%02X%02X%02X%02X",
	hushChallenge.mSignature.mKeyedHash[0], hushChallenge.mSignature.mKeyedHash[1],
	hushChallenge.mSignature.mKeyedHash[2], hushChallenge.mSignature.mKeyedHash[3],
	hushChallenge.mSignature.mKeyedHash[4], hushChallenge.mSignature.mKeyedHash[5],
	hushChallenge.mSignature.mKeyedHash[6], hushChallenge.mSignature.mKeyedHash[7]);
	WeaveLogProgress(Alarm, "Hush mSignature part 2: %02X%02X%02X%02X-%02X%02X%02X%02X",
	hushChallenge.mSignature.mKeyedHash[8], hushChallenge.mSignature.mKeyedHash[9],
	hushChallenge.mSignature.mKeyedHash[10], hushChallenge.mSignature.mKeyedHash[11],
	hushChallenge.mSignature.mKeyedHash[12], hushChallenge.mSignature.mKeyedHash[13],
	hushChallenge.mSignature.mKeyedHash[14], hushChallenge.mSignature.mKeyedHash[15]);
	WeaveLogProgress(Alarm, "Hush mSignature part 3: %02X%02X%02X%02X",
	hushChallenge.mSignature.mKeyedHash[16], hushChallenge.mSignature.mKeyedHash[17],
	hushChallenge.mSignature.mKeyedHash[18], hushChallenge.mSignature.mKeyedHash[19]);
	}

	gAlarmServer.SetAlarmDelegate(this);

	mAlarmClient = gAlarmServer.NewClient(kAnyNodeId, encryptionType, keyId);
	VerifyOrExit(NULL != mAlarmClient, err = WEAVE_ERROR_NO_MEMORY);

	if (shouldAlarm)
	{
	alarm.AddAlarm(WEAVE_ALARM_CO \| WEAVE_ALARM_STATE_HEADS_UP_1);
	alarm.AddAlarm(WEAVE_ALARM_SMOKE \| WEAVE_ALARM_STATE_ALARM_NONHUSHABLE);

	err = mAlarmClient->SendAlarm(&alarm);
	SuccessOrExit(err);
	}

	{
	// just a simple test to demo how random number generation utility routines work
	uint32_t testRandom = 0;
	WeaveAlarmClient::GenerateHushChallenge(&testRandom);
	WeaveLogProgress(Alarm, "Random number generated for hush challenge code: 0x%X", testRandom);
	WeaveAlarmClient::GenerateProximityVerificationCode(&testRandom);
	WeaveLogProgress(Alarm, "Random number generated for proximity verification code: 0x%X", testRandom);
	}

	exit:
	WeaveLogFunctError(err);

	return err;
	}

	WEAVE_ERROR MockAlarmOriginator::Shutdown(void)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	err = gAlarmServer.Shutdown();
	SuccessOrExit(err);

	exit:
	WeaveLogFunctError(err);

	return err;
	}

	WEAVE_ERROR MockAlarmOriginator::OnHushRequest(nl::Weave::ExchangeContext *ec, uint32_t proximityVerificationCode, const AlarmHushSignature & signature)
	{
	WEAVE_ERROR err = WEAVE_NO_ERROR;

	// Application code shall verify the content/signature of the hush request and decide if
	// this request needs to be further processed
	// hush requests coming from channels other than BLE can be ignored

	WeaveLogProgress(Alarm, "Req key id: 0x%X", signature.mKeyId);

	WeaveLogProgress(Alarm, "Req signature part 1: %02X%02X%02X%02X-%02X%02X%02X%02X",
	signature.mKeyedHash[0], signature.mKeyedHash[1],
	signature.mKeyedHash[2], signature.mKeyedHash[3],
	signature.mKeyedHash[4], signature.mKeyedHash[5],
	signature.mKeyedHash[6], signature.mKeyedHash[7]);
	WeaveLogProgress(Alarm, "Req signature part 2: %02X%02X%02X%02X-%02X%02X%02X%02X",
	signature.mKeyedHash[8], signature.mKeyedHash[9],
	signature.mKeyedHash[10], signature.mKeyedHash[11],
	signature.mKeyedHash[12], signature.mKeyedHash[13],
	signature.mKeyedHash[14], signature.mKeyedHash[15]);
	WeaveLogProgress(Alarm, "Req signature part 3: %02X%02X%02X%02X",
	signature.mKeyedHash[16], signature.mKeyedHash[17],
	signature.mKeyedHash[18], signature.mKeyedHash[19]);

	if (!signature.mIsSigned)
	{
	WeaveLogProgress(Alarm, "Hush: not signed");

	// the request is not signed
	err = gAlarmServer.SendStatusReport(kWeaveProfile_Alarm,
	kAlarmStatusReport_HushRejected_SignatureValidationFailure);
	}
	else if (hushChallenge.mSignature != signature)
	{
	WeaveLogProgress(Alarm, "Hush: not signed or signature doesn't match");

	// since we use signature comparison, the request is either not signed, or doesn't match with ours
	err = gAlarmServer.SendStatusReport(kWeaveProfile_Alarm,
	kAlarmStatusReport_HushRejected_SignatureValidationFailure);
	}
	else if (NULL == mAlarmClient)
	{
	WeaveLogProgress(Alarm, "Hush: no alarm");

	// there is no Alarm at all to hush, but we should still respond with a 'success',
	err = gAlarmServer.SendHushResponse(kAlarmHushResult_Success);
	SuccessOrExit(err);
	}
	else
	{
	WeaveLogProgress(Alarm, "Hush: incoming proximity verification code 0x%X", proximityVerificationCode);

	if (hushChallenge.mProximityVerificationCode != proximityVerificationCode)
	{
	WeaveLogProgress(Alarm, "Hush: expected proximity verification code 0x%X, doesn't match", proximityVerificationCode);

	err = gAlarmServer.SendStatusReport(kWeaveProfile_Alarm,
	kAlarmStatusReport_HushRejected_ProximityValidationFailure);
	SuccessOrExit(err);
	}
	else
	{
	// apply hush to each of condition we have
	// application code might have other logic to execute for hushing and doesn't have to be
	// bound by this particular Alarm object
	Alarm & currentAlarm(mAlarmClient->mCurrentAlarm);

	WeaveLogProgress(Alarm, "BEFORE Hush: counter [%d] with [%d] conditions",
	currentAlarm.mAlarmCtr,
	currentAlarm.mLength);

	for (int i = 0; i < currentAlarm.mLength; ++i)
	{
	LogAlarmCondition(currentAlarm.mConditions[i]);
	}

	for (int i = 0; i < currentAlarm.mLength; ++i)
	{
	if (currentAlarm.GetAlarmState(i) <= WEAVE_ALARM_STATE_ALARM_HUSHABLE)
	{
	currentAlarm.SetAlarmState(i, WEAVE_ALARM_STATE_ALARM_REMOTE_HUSH);
	}
	}

	WeaveLogProgress(Alarm, "AFTER Hush: counter [%d] with [%d] conditions",
	currentAlarm.mAlarmCtr,
	currentAlarm.mLength);

	for (int i = 0; i < currentAlarm.mLength; ++i)
	{
	LogAlarmCondition(currentAlarm.mConditions[i]);
	}

	// this call 'kills' the alarm and makes the pointer useless
	mAlarmClient->Close();
	mAlarmClient = NULL;

	err = gAlarmServer.SendHushResponse(kAlarmHushResult_Success, currentAlarm.mLength, currentAlarm.mConditions);
	SuccessOrExit(err);
	}
	}

	exit:
	WeaveLogFunctError(err);

	return err;
	}

	void LogAlarmCondition(const uint8_t alarm_condition)
	{
	const char * state;
	const char * source;

	switch (alarm_condition & 0xf0)
	{
	case WEAVE_ALARM_SMOKE:
	source = "smoke";
	break;
	case WEAVE_ALARM_TEMP:
	source = "temperature";
	break;
	case WEAVE_ALARM_CO:
	source = "carbon monoxide";
	break;
	case WEAVE_ALARM_CH4:
	source = "gas";
	break;
	case WEAVE_ALARM_HUMIDITY:
	source = "humidity";
	break;
	case WEAVE_ALARM_OTHER:
	source = "other";
	break;
	default:
	source = "unknown";
	break;
	}

	switch (alarm_condition & 0x0f)
	{
	case WEAVE_ALARM_STATE_STANDBY:
	state = "standby";
	break;
	case WEAVE_ALARM_STATE_HEADS_UP_1:
	state = "heads up 1";
	break;
	case WEAVE_ALARM_STATE_HEADS_UP_2:
	state = "heads up 2";
	break;
	case WEAVE_ALARM_STATE_HU_HUSH:
	state = "heads up hush";
	break;
	case WEAVE_ALARM_STATE_ALARM_HUSHABLE:
	state = "ALARM, hushable";
	break;
	case WEAVE_ALARM_STATE_ALARM_NONHUSHABLE:
	state = "ALARM, NONHUSHABLE";
	break;
	case WEAVE_ALARM_STATE_ALARM_GLOBAL_HUSH:
	state = "global hush";
	break;
	case WEAVE_ALARM_STATE_ALARM_REMOTE_HUSH:
	state = "remote hush";
	break;
	case WEAVE_ALARM_STATE_SELFTEST:
	state = "selftest";
	break;
	default:
	state = "unknown";
	break;
	}

	WeaveLogProgress(Alarm, "[%s]: [%s]", state, source);
	}

	void MockAlarmOriginator::OnAlarmClientStateChange(WeaveAlarmClient * const aClient)
	{
	WeaveLogProgress(Alarm, "Alarm from 0x%" PRIx64 " changed", aClient->GetOriginator());

	for (int i = 0; i < aClient->mCurrentAlarm.mLength; ++i)
	{
	LogAlarmCondition(aClient->mCurrentAlarm.GetAlarm(i));
	}
	}

	void MockAlarmOriginator::OnNewRemoteAlarmDropped(const Alarm & aAlarm)
	{
	WeaveLogProgress(Alarm, "Alarm at where id [%u] has been dropped", aAlarm.mWhere);

	for (int i = 0; i < aAlarm.mLength; ++i)
	{
	LogAlarmCondition(aAlarm.GetAlarm(i));
	}
	}

	int MockAlarmOriginator::CompareSeverity(const Alarm & aAlarm1, const Alarm & aAlarm2)
	{
	enum
	{
	kResultSource_Smoke = 0,
	kResultSource_CO = 1,

	kResultAlarm1 = +1,
	kResultTie = 0,
	kResultAlarm2 = -1,

	kNumRecognizedAlarmSources = 2,
	};

	int resultTable[kNumRecognizedAlarmSources][2];
	resultTable[kResultSource_Smoke][0] = WEAVE_ALARM_STATE_INVALID;
	resultTable[kResultSource_Smoke][1] = kResultTie;
	resultTable[kResultSource_CO][0] = WEAVE_ALARM_STATE_INVALID;
	resultTable[kResultSource_CO][1] = kResultTie;

	for (int i = 0; i < aAlarm1.mLength; ++i)
	{
	switch (aAlarm1.GetAlarmCondition(i))
	{
	case WEAVE_ALARM_SMOKE:
	resultTable[kResultSource_Smoke][0] = aAlarm1.GetAlarmState(i);
	break;

	case WEAVE_ALARM_CO:
	resultTable[kResultSource_CO][0] = aAlarm1.GetAlarmState(i);
	break;

	default:
	WeaveLogError(Alarm, "Ignore unknown alarm source %u", aAlarm1.GetAlarmCondition(i));
	}
	}

	for (int i = 0; i < aAlarm2.mLength; ++i)
	{
	switch (aAlarm1.GetAlarmCondition(i))
	{
	case WEAVE_ALARM_SMOKE:
	if (WEAVE_ALARM_STATE_INVALID == resultTable[kResultSource_Smoke][0])
	{
	// alarm1 doesn't have this source, so alarm2 wins here
	resultTable[kResultSource_Smoke][0] = aAlarm2.GetAlarmState(i);
	resultTable[kResultSource_Smoke][1] = kResultAlarm2;
	}
	else
	{
	// both alarm1 and alarm2 have this source. let's compare them
	const int state1 = resultTable[kResultSource_Smoke][0];
	const int state2 = aAlarm2.GetAlarmState(i);
	if (state1 > state2)
	{
	resultTable[kResultSource_Smoke][1] = kResultAlarm1;
	}
	else if (state1 == state2)
	{
	resultTable[kResultSource_Smoke][1] = kResultTie;
	}
	else
	{
	resultTable[kResultSource_Smoke][1] = kResultAlarm2;
	}
	}
	break;

	case WEAVE_ALARM_CO:
	if (WEAVE_ALARM_STATE_INVALID == resultTable[kResultSource_CO][0])
	{
	// alarm1 doesn't have this source, so alarm2 wins here
	resultTable[kResultSource_CO][0] = aAlarm2.GetAlarmState(i);
	resultTable[kResultSource_CO][1] = kResultAlarm2;
	}
	else
	{
	// both alarm1 and alarm2 have this source. let's compare them
	const int state1 = resultTable[kResultSource_CO][0];
	const int state2 = aAlarm2.GetAlarmState(i);
	if (state1 > state2)
	{
	resultTable[kResultSource_CO][1] = kResultAlarm1;
	}
	else if (state1 == state2)
	{
	resultTable[kResultSource_CO][1] = kResultTie;
	}
	else
	{
	resultTable[kResultSource_CO][1] = kResultAlarm2;
	}
	}
	break;

	default:
	WeaveLogError(Alarm, "Ignore unknown alarm source %u", aAlarm2.GetAlarmCondition(i));
	}
	}

	if (resultTable[kResultSource_Smoke][1] != kResultTie)
	{
	// Smoke take precedence. Use the result of smoke if possible
	return resultTable[kResultSource_Smoke][1];
	}
	else
	{
	// otherwise, use CO
	return resultTable[kResultSource_CO][1];
	}
	}