weave/src/lib/profiles/software-update/SoftwareUpdateProfile.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 message descriptions for the messages in
  *      the software update profile.
  *
  */

 #include <Weave/Core/WeaveCore.h>
 #include <Weave/Core/WeaveMessageLayer.h>
 #include <Weave/Profiles/ProfileCommon.h>
 #include "SoftwareUpdateProfile.h"
 using namespace ::nl::Weave;
 using namespace ::nl::Weave::Profiles;
 using namespace ::nl::Weave::Profiles::SoftwareUpdate;
 /*
  * -- definitions for ImageQuery and its supporting classes --
  *
  * the no-arg constructor for an IntegrityTypeList
  */
 IntegrityTypeList::IntegrityTypeList()
 {
   theLength=0;
   for (int i=0; i<3; i++) theList[i]=kIntegrityType_SHA160;
 }
 /*
  * parameters:
  * - uint8_t aLength, an 8-bit length value for the list (<4)
  * - uint8_t *aList, pointer to an array of itegrity type values
  * return:
  * - WEAVE_NO_ERROR if it's all good
  * - WEAVE_ERROR_INVALID_LIST_LENGTH if the length is too long
  */
 WEAVE_ERROR IntegrityTypeList::init(uint8_t aLength, uint8_t *aList)
 {
   if (aLength>3) return WEAVE_ERROR_INVALID_LIST_LENGTH;
   theLength=aLength;
   for (int i=0; i<theLength; i++) theList[i]=aList[i];
   return WEAVE_NO_ERROR;
 }
 /*
  * parameter: MessageIterator &i, an iterator over the message being packed
  * returns: error/status
  */
 WEAVE_ERROR IntegrityTypeList::pack(MessageIterator &i)
 {
   if (i.hasRoom(theLength+1)) {
     i.writeByte(theLength);
     for (int j=0; j<theLength; j++) i.writeByte(theList[j]);
     return WEAVE_NO_ERROR;
   }
   else
     return WEAVE_ERROR_INVALID_LIST_LENGTH;
 }
 /*
  * parameters:
  * - MessageIterator &i, an iterator over the message being parsed
  * - IntegrityTypeList &aList, a pointer to an object to contain the result
  * returns: error/status
  */
 WEAVE_ERROR IntegrityTypeList::parse(MessageIterator &i, IntegrityTypeList &aList)
 {
   i.readByte(&aList.theLength);
   if (!i.hasData(aList.theLength)) return WEAVE_ERROR_INVALID_LIST_LENGTH;
   for (int j=0; j<aList.theLength; j++) i.readByte(&aList.theList[j]);
   return WEAVE_NO_ERROR;
 }
 /*
  * parameter: IntegrityTypeList &another, another list to check against
  * returns: true if the lists are equal, false otherwise
  */
 bool IntegrityTypeList::operator == (const IntegrityTypeList &another) const
 {
   if (theLength!=another.theLength)
     return false;
   for (int i=0; i<theLength; i++) {
     if (theList[i]!=another.theList[i])
       return false;
   }
   return true;
 }
 /*
  * the no-arg constructor for an UpdateSchemeList
  */
 UpdateSchemeList::UpdateSchemeList()
 {
   theLength=0;
   for (int i=0; i<4; i++) theList[i]=kUpdateScheme_HTTP;
 }
 /*
  * parameters:
  * - uint8_t aLength, an 8-bit length value for the list (<5)
  * - uint8_t *aList, pointer to an array of update scheme values
  * return: error/status
  */
 WEAVE_ERROR UpdateSchemeList::init(uint8_t aLength, uint8_t *aList)
 {
   if (aLength>4) return WEAVE_ERROR_INVALID_LIST_LENGTH;
   theLength=aLength;
   for (int i=0; i<theLength; i++) theList[i]=aList[i];
   return WEAVE_NO_ERROR;
 }
 /*
  * parameters: MessageIterator &i,
  * returns: error/status
  */
 WEAVE_ERROR UpdateSchemeList::pack(MessageIterator &i)
 {
   if (i.hasRoom(theLength+1)) {
     i.writeByte(theLength);
     for (int j=0; j<theLength; j++) i.writeByte(theList[j]);
     return WEAVE_NO_ERROR;
   }
   else
     return WEAVE_ERROR_INVALID_LIST_LENGTH;
 }
 /*
  * parameters:
  * - MessageIterator &i, an iterator over the message being parsed
  * - UpdateSchemeList &aList, a pointer to an object into which to put the result
  * returns: the updated pointer p pointing after the parsed list
  */
 WEAVE_ERROR UpdateSchemeList::parse(MessageIterator &i, UpdateSchemeList &aList)
 {
   i.readByte(&aList.theLength);
   if (!i.hasData(aList.theLength)) return WEAVE_ERROR_INVALID_LIST_LENGTH;
   for (int j=0; j<aList.theLength; j++) i.readByte(&aList.theList[j]);
   return WEAVE_NO_ERROR;
 }
 /*
  * parameter: UpdateSchemeList &another, another list to check against
  * returns: true if the lists are equal, false otherwise
  */
 bool UpdateSchemeList::operator == (const UpdateSchemeList &another) const
 {
   if (theLength!=another.theLength)
     return false;
   for (int i=0; i<theLength; i++) {
     if (theList[i]!=another.theList[i])
       return false;
   }
   return true;
 }
 /*
  * parameters:
  * - uint16_t aVendor, the vendor identifier for the specified product
  * - uint16_t aProduct, that vendor's product identifier
  * - uint16_t aRevision, the vendor-specific product revision number
  */
 ProductSpec::ProductSpec(uint16_t aVendor, uint16_t aProduct, uint16_t aRevision)
 {
   vendorId=aVendor;
   productId=aProduct;
   productRev=aRevision;
 }
 /*
  * the no-arg constructor for a ProductSpec
  */
 ProductSpec::ProductSpec()
 {
   vendorId=productId=productRev=0;
 }

 bool ProductSpec::operator == (const ProductSpec &another) const
 {
   return ((vendorId == another.vendorId) && (productId == another.productId) && (productRev == another.productRev));
 }

 /*
  * the no-arg constructor for an ImageQuery
  */
 ImageQuery::ImageQuery()
 {
   version.theLength=0;
   version.isShort=true;
   integrityTypes.theLength=0;
   updateSchemes.theLength=0;
   packageSpec.theLength=0;
   packageSpec.isShort=true;
   localeSpec.theLength=0;
   localeSpec.isShort=true;
   targetNodeId=0;
 }
 /*
  * parameters:
  * - ProductSpec &aProductSPec, the sending device's product specification
  * - ReferencedString &aVersion, the sending device's software version
  * - IntegrityTypeList &aTypeList, the integrity types supported by the sender
  * - UpdateSchemeList &aSchemeList, the update schemes supported by the sender
  * - ReferencedString *aPackage, the sending device's package spec (optional)
  * - ReferencedString *aLocale, the sending device's locale spec (optional)
  * - ReferencedTLVData *aMetaData, optional TLV-encoded vendor data
  return: error/status
 */
 WEAVE_ERROR ImageQuery::init(ProductSpec &aProductSpec,
                              ReferencedString &aVersion,
                              IntegrityTypeList &aTypeList,
                              UpdateSchemeList &aSchemeList,
                              ReferencedString *aPackage,
                              ReferencedString *aLocale,
                              uint64_t aTargetNodeId,
                              ReferencedTLVData *aMetaData)
 {
   productSpec=aProductSpec;
   version=aVersion;
   version.isShort=true;
   integrityTypes=aTypeList;
   updateSchemes=aSchemeList;
   if (aPackage!=NULL) {
     packageSpec=*aPackage;
     packageSpec.isShort=true;
   }
   if (aLocale!=NULL) localeSpec=*aLocale;
   targetNodeId=aTargetNodeId;
   if (aMetaData!=NULL) theMetaData=*aMetaData;
   return WEAVE_NO_ERROR;
 }
 /*
  * parameter: PacketBuffer *aBuffer, a packet into which the pack the query
  * return: /error/status
  */
 WEAVE_ERROR ImageQuery::pack(PacketBuffer *aBuffer)
 {
   MessageIterator i(aBuffer);
   i.append();
   // figure out what the frame control field looks like.
   uint8_t frameCtl=0;
   if (packageSpec.theLength!=0)
     frameCtl|=kFlag_PackageSpecPresent;
   if (localeSpec.theLength!=0)
     frameCtl|=kFlag_LocaleSpecPresent;
   if (targetNodeId!=0)
     frameCtl|=kFlag_TargetNodeIdPresent;
   // now write it
   TRY(i.writeByte(frameCtl));
   // write the product spec
   TRY(i.write16(productSpec.vendorId));
   TRY(i.write16(productSpec.productId));
   TRY(i.write16(productSpec.productRev));
   // pack the version string
   TRY(version.pack(i));
   // now do the intergrity types and update schemes
   TRY(integrityTypes.pack(i));
   TRY(updateSchemes.pack(i));
   // now the optional fields
   if (packageSpec.theLength!=0) TRY(packageSpec.pack(i));
   if (localeSpec.theLength!=0) TRY(localeSpec.pack(i));
   if (targetNodeId!=0) TRY(i.write64(targetNodeId));
   theMetaData.pack(i);
   return WEAVE_NO_ERROR;
 }
 /*
  * parameters:
  * - PacketBuffer *aBuffer, a pointer to a packet from which to parse the query
  * - ImageQuery &aQuery, an object in which to put the result
  * return: error/status
  */
 WEAVE_ERROR ImageQuery::parse(PacketBuffer *aBuffer, ImageQuery &aQuery)
 {
   MessageIterator i(aBuffer);
   // get the frame control field this doesn't actually become part of
   // the message object.
   uint8_t frameCtl;
   TRY(i.readByte(&frameCtl));
   // now get the product spec.
   TRY(i.read16(&aQuery.productSpec.vendorId));
   TRY(i.read16(&aQuery.productSpec.productId));
   TRY(i.read16(&aQuery.productSpec.productRev));
   // get the version string
   TRY(ReferencedString::parse(i, aQuery.version));
   // now do integrity types and update schemes.
   TRY(IntegrityTypeList::parse(i, aQuery.integrityTypes));
   TRY(UpdateSchemeList::parse(i, aQuery.updateSchemes));
   // if a package is provided then get it
   if (frameCtl & kFlag_PackageSpecPresent) TRY(ReferencedString::parse(i, aQuery.packageSpec));
   // if a locale is provided then get it
   if (frameCtl & kFlag_LocaleSpecPresent) TRY(ReferencedString::parse(i, aQuery.localeSpec));
   // if a target node id is provided then get it
   if (frameCtl & kFlag_TargetNodeIdPresent) TRY(i.read64(&aQuery.targetNodeId));
   // and maybe the metadata
   ReferencedTLVData::parse(i, aQuery.theMetaData);
   return WEAVE_NO_ERROR;
 }
 /*
  * the only way to tell if two of these things are equal is to try
  * all of their components.
  * parameter: ImageQuery &another, another query to check against
  * returns: true if the queries are equal, false otherwise
  */
 bool ImageQuery::operator == (const ImageQuery &another) const
 {
   return ((productSpec.vendorId==another.productSpec.vendorId) &&
           (productSpec.productId==another.productSpec.productId) &&
           (productSpec.productRev==another.productSpec.productRev) &&
           (version==another.version) &&
           (integrityTypes==another.integrityTypes) &&
           (updateSchemes==another.updateSchemes) &&
           (packageSpec==another.packageSpec) &&
           (localeSpec==another.localeSpec) &&
           (targetNodeId==another.targetNodeId) &&
           (theMetaData==another.theMetaData));
 }
 /*
  * -- definitions for ImageQueryResponse and its supporting classes --
  *
  * parameter: uint8_t type, an IntegrityType value
  * return: the integity check output length for that type
  */
 inline int integrityLength(uint8_t aType)
 {
   switch (aType) {
   case kIntegrityType_SHA160:
     return kLength_SHA160;
   case kIntegrityType_SHA256:
     return kLength_SHA256;
   case kIntegrityType_SHA512:
     return kLength_SHA512;
   default:
     return 0;
   }
 }
 /*
  * the no-arg contructor for an IntegritySpec
  */
 IntegritySpec::IntegritySpec()
 {
   type=kIntegrityType_SHA160;
 }
 /*
  * parameters:
  * - uint8_t aType, an integrity type
  * - uint8_t * aValue, an integrity check code of the appropriate length
  * represented as a packed string of bytes
  * return: error/status
  */
 WEAVE_ERROR IntegritySpec::init(uint8_t aType, uint8_t* aValue)
 {
   uint8_t len=integrityLength(aType);
   if (len==0) return WEAVE_ERROR_INVALID_INTEGRITY_TYPE;
   type=aType;
   for (int i=0; i<len; i++) value[i]=aValue[i];
   return WEAVE_NO_ERROR;
 }
 /*
  * parameters: MessageIterator &i, an iterator ofver the message
  * being packed
  * returns: error/status
  */
 WEAVE_ERROR IntegritySpec::pack(MessageIterator &i)
 {
   TRY(i.writeByte(type));
   for (int j=0; j<integrityLength(type); j++) TRY(i.writeByte(value[j]));
   return WEAVE_NO_ERROR;
 }
 /*
  * parameters:
  * - MessageIterator &i, an iterator over the message being parsed
  * - IntegritySpec &aSpec, a pointer to an object to contain the result
  * returns: error/status
  */
 WEAVE_ERROR IntegritySpec::parse(MessageIterator &i, IntegritySpec &aSpec)
 {
   TRY(i.readByte(&aSpec.type));
   for (int j=0; j<integrityLength(aSpec.type); j++) TRY(i.readByte(&aSpec.value[j]));
   return WEAVE_NO_ERROR;
 }
 /*
  * parameter: IntegritySpec &another, another spec to check against
  * returns: true if the integrity specs are equal, false otherwise
  */
 bool IntegritySpec::operator == (const IntegritySpec &another) const
 {
   if (type!=another.type)
     return false;
   for (int i=0; i<integrityLength(type); i++) {
     if (value[i]!=another.value[i])
       return false;
   }
   return true;
 }
 /*
  * parameters:
  * - ReferencedString &aUri, the URI at which the new firmware image is to be found
  * - Referenced &aVersion, the version string for this image
  * - IntegritySpec &aIntegrity, the integrity spec corresponding to the new image
  * - uint8_t aScheme, the update scheme to use in downloading
  * - UpdatePriority aPriority, the update priority associated with this update
  * - UpdateCondition aCondition, the condition under which to update
  * - bool aReportStatus, if true requests the client to report after download and
  * update, otherwise the client will not report
  * return: error/status
  */
 WEAVE_ERROR ImageQueryResponse::init(ReferencedString &aUri, ReferencedString &aVersion,
                                      IntegritySpec &aIntegrity, uint8_t aScheme,
                                      UpdatePriority aPriority, UpdateCondition aCondition,
                                      bool aReportStatus)
 {
   // we assume success here (woohoo! optional)
   uri=aUri;
   versionSpec=aVersion;
   versionSpec.isShort=true;
   integritySpec=aIntegrity;
   updateScheme=aScheme;
   updatePriority=aPriority;
   updateCondition=aCondition;
   reportStatus=aReportStatus;
   return WEAVE_NO_ERROR;
 }
 /*
  * the no-arg constructor for ImageQueryResponse objects
  */
 ImageQueryResponse::ImageQueryResponse() :
     uri()
 {
   versionSpec.theLength=0;
   versionSpec.isShort=true;
   updateScheme=kUpdateScheme_HTTP;
   reportStatus=false;
 }
 /*
  * parameter: PacketBuffer *aBuffer, a packet into which the pack the response
  * return: /error/status
  */
 WEAVE_ERROR ImageQueryResponse::pack(PacketBuffer* aBuffer)
 {
   MessageIterator i(aBuffer);
   i.append();
   TRY(uri.pack(i));
   TRY(versionSpec.pack(i));
   TRY(integritySpec.pack(i));
   TRY(i.writeByte((uint8_t)updateScheme));
   uint8_t updateOptions=(uint8_t)updatePriority|((uint8_t)updateCondition<<kOffset_UpdateCondition);
   if (reportStatus) updateOptions|=kMask_ReportStatus;
   TRY(i.writeByte(updateOptions));
   return WEAVE_NO_ERROR;
 }
 /*
  * parameters:
  * - PacketBuffer* aBuffer, a message buffer from which to parse the message
  * - ImageQueryResponse &aResponse, a place to put the result
  * returns: error/status
  */
 WEAVE_ERROR ImageQueryResponse::parse(PacketBuffer *aBuffer, ImageQueryResponse &aResponse)
 {
   MessageIterator i(aBuffer);
   uint8_t updateOptions;
   TRY(ReferencedString::parse(i, aResponse.uri));
   TRY(ReferencedString::parse(i, aResponse.versionSpec));
   TRY(IntegritySpec::parse(i, aResponse.integritySpec));
   TRY(i.readByte(&aResponse.updateScheme));
   TRY(i.readByte(&updateOptions));
   aResponse.updatePriority=(UpdatePriority)(updateOptions&kMask_UpdatePriority);
   aResponse.updateCondition=(UpdateCondition)((updateOptions&kMask_UpdateCondition)>>kOffset_UpdateCondition);
   aResponse.reportStatus=(updateOptions&kMask_ReportStatus)==kMask_ReportStatus;
   return WEAVE_NO_ERROR;
 }
 /*
  * parameter: ImageQueryResponse &another, another response to check against
  * returns: true if the responses are equal, false otherwise
  */
 bool ImageQueryResponse::operator ==(const ImageQueryResponse &another) const
 {
   return ((uri==another.uri) &&
           (versionSpec==another.versionSpec) &&
           (integritySpec==another.integritySpec) &&
           (updateScheme==another.updateScheme) &&
           (updatePriority==another.updatePriority) &&
           (updateCondition==another.updateCondition) &&
           (reportStatus==another.reportStatus));
 }
	/*
	*
	* 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 message descriptions for the messages in
	* the software update profile.
	*
	*/

	#include <Weave/Core/WeaveCore.h>
	#include <Weave/Core/WeaveMessageLayer.h>
	#include <Weave/Profiles/ProfileCommon.h>
	#include "SoftwareUpdateProfile.h"
	using namespace ::nl::Weave;
	using namespace ::nl::Weave::Profiles;
	using namespace ::nl::Weave::Profiles::SoftwareUpdate;
	/*
	* -- definitions for ImageQuery and its supporting classes --
	*
	* the no-arg constructor for an IntegrityTypeList
	*/
	IntegrityTypeList::IntegrityTypeList()
	{
	theLength=0;
	for (int i=0; i<3; i++) theList[i]=kIntegrityType_SHA160;
	}
	/*
	* parameters:
	* - uint8_t aLength, an 8-bit length value for the list (<4)
	* - uint8_t *aList, pointer to an array of itegrity type values
	* return:
	* - WEAVE_NO_ERROR if it's all good
	* - WEAVE_ERROR_INVALID_LIST_LENGTH if the length is too long
	*/
	WEAVE_ERROR IntegrityTypeList::init(uint8_t aLength, uint8_t *aList)
	{
	if (aLength>3) return WEAVE_ERROR_INVALID_LIST_LENGTH;
	theLength=aLength;
	for (int i=0; i<theLength; i++) theList[i]=aList[i];
	return WEAVE_NO_ERROR;
	}
	/*
	* parameter: MessageIterator &i, an iterator over the message being packed
	* returns: error/status
	*/
	WEAVE_ERROR IntegrityTypeList::pack(MessageIterator &i)
	{
	if (i.hasRoom(theLength+1)) {
	i.writeByte(theLength);
	for (int j=0; j<theLength; j++) i.writeByte(theList[j]);
	return WEAVE_NO_ERROR;
	}
	else
	return WEAVE_ERROR_INVALID_LIST_LENGTH;
	}
	/*
	* parameters:
	* - MessageIterator &i, an iterator over the message being parsed
	* - IntegrityTypeList &aList, a pointer to an object to contain the result
	* returns: error/status
	*/
	WEAVE_ERROR IntegrityTypeList::parse(MessageIterator &i, IntegrityTypeList &aList)
	{
	i.readByte(&aList.theLength);
	if (!i.hasData(aList.theLength)) return WEAVE_ERROR_INVALID_LIST_LENGTH;
	for (int j=0; j<aList.theLength; j++) i.readByte(&aList.theList[j]);
	return WEAVE_NO_ERROR;
	}
	/*
	* parameter: IntegrityTypeList &another, another list to check against
	* returns: true if the lists are equal, false otherwise
	*/
	bool IntegrityTypeList::operator == (const IntegrityTypeList &another) const
	{
	if (theLength!=another.theLength)
	return false;
	for (int i=0; i<theLength; i++) {
	if (theList[i]!=another.theList[i])
	return false;
	}
	return true;
	}
	/*
	* the no-arg constructor for an UpdateSchemeList
	*/
	UpdateSchemeList::UpdateSchemeList()
	{
	theLength=0;
	for (int i=0; i<4; i++) theList[i]=kUpdateScheme_HTTP;
	}
	/*
	* parameters:
	* - uint8_t aLength, an 8-bit length value for the list (<5)
	* - uint8_t *aList, pointer to an array of update scheme values
	* return: error/status
	*/
	WEAVE_ERROR UpdateSchemeList::init(uint8_t aLength, uint8_t *aList)
	{
	if (aLength>4) return WEAVE_ERROR_INVALID_LIST_LENGTH;
	theLength=aLength;
	for (int i=0; i<theLength; i++) theList[i]=aList[i];
	return WEAVE_NO_ERROR;
	}
	/*
	* parameters: MessageIterator &i,
	* returns: error/status
	*/
	WEAVE_ERROR UpdateSchemeList::pack(MessageIterator &i)
	{
	if (i.hasRoom(theLength+1)) {
	i.writeByte(theLength);
	for (int j=0; j<theLength; j++) i.writeByte(theList[j]);
	return WEAVE_NO_ERROR;
	}
	else
	return WEAVE_ERROR_INVALID_LIST_LENGTH;
	}
	/*
	* parameters:
	* - MessageIterator &i, an iterator over the message being parsed
	* - UpdateSchemeList &aList, a pointer to an object into which to put the result
	* returns: the updated pointer p pointing after the parsed list
	*/
	WEAVE_ERROR UpdateSchemeList::parse(MessageIterator &i, UpdateSchemeList &aList)
	{
	i.readByte(&aList.theLength);
	if (!i.hasData(aList.theLength)) return WEAVE_ERROR_INVALID_LIST_LENGTH;
	for (int j=0; j<aList.theLength; j++) i.readByte(&aList.theList[j]);
	return WEAVE_NO_ERROR;
	}
	/*
	* parameter: UpdateSchemeList &another, another list to check against
	* returns: true if the lists are equal, false otherwise
	*/
	bool UpdateSchemeList::operator == (const UpdateSchemeList &another) const
	{
	if (theLength!=another.theLength)
	return false;
	for (int i=0; i<theLength; i++) {
	if (theList[i]!=another.theList[i])
	return false;
	}
	return true;
	}
	/*
	* parameters:
	* - uint16_t aVendor, the vendor identifier for the specified product
	* - uint16_t aProduct, that vendor's product identifier
	* - uint16_t aRevision, the vendor-specific product revision number
	*/
	ProductSpec::ProductSpec(uint16_t aVendor, uint16_t aProduct, uint16_t aRevision)
	{
	vendorId=aVendor;
	productId=aProduct;
	productRev=aRevision;
	}
	/*
	* the no-arg constructor for a ProductSpec
	*/
	ProductSpec::ProductSpec()
	{
	vendorId=productId=productRev=0;
	}

	bool ProductSpec::operator == (const ProductSpec &another) const
	{
	return ((vendorId == another.vendorId) && (productId == another.productId) && (productRev == another.productRev));
	}

	/*
	* the no-arg constructor for an ImageQuery
	*/
	ImageQuery::ImageQuery()
	{
	version.theLength=0;
	version.isShort=true;
	integrityTypes.theLength=0;
	updateSchemes.theLength=0;
	packageSpec.theLength=0;
	packageSpec.isShort=true;
	localeSpec.theLength=0;
	localeSpec.isShort=true;
	targetNodeId=0;
	}
	/*
	* parameters:
	* - ProductSpec &aProductSPec, the sending device's product specification
	* - ReferencedString &aVersion, the sending device's software version
	* - IntegrityTypeList &aTypeList, the integrity types supported by the sender
	* - UpdateSchemeList &aSchemeList, the update schemes supported by the sender
	* - ReferencedString *aPackage, the sending device's package spec (optional)
	* - ReferencedString *aLocale, the sending device's locale spec (optional)
	* - ReferencedTLVData *aMetaData, optional TLV-encoded vendor data
	return: error/status
	*/
	WEAVE_ERROR ImageQuery::init(ProductSpec &aProductSpec,
	ReferencedString &aVersion,
	IntegrityTypeList &aTypeList,
	UpdateSchemeList &aSchemeList,
	ReferencedString *aPackage,
	ReferencedString *aLocale,
	uint64_t aTargetNodeId,
	ReferencedTLVData *aMetaData)
	{
	productSpec=aProductSpec;
	version=aVersion;
	version.isShort=true;
	integrityTypes=aTypeList;
	updateSchemes=aSchemeList;
	if (aPackage!=NULL) {
	packageSpec=*aPackage;
	packageSpec.isShort=true;
	}
	if (aLocale!=NULL) localeSpec=*aLocale;
	targetNodeId=aTargetNodeId;
	if (aMetaData!=NULL) theMetaData=*aMetaData;
	return WEAVE_NO_ERROR;
	}
	/*
	* parameter: PacketBuffer *aBuffer, a packet into which the pack the query
	* return: /error/status
	*/
	WEAVE_ERROR ImageQuery::pack(PacketBuffer *aBuffer)
	{
	MessageIterator i(aBuffer);
	i.append();
	// figure out what the frame control field looks like.
	uint8_t frameCtl=0;
	if (packageSpec.theLength!=0)
	frameCtl\|=kFlag_PackageSpecPresent;
	if (localeSpec.theLength!=0)
	frameCtl\|=kFlag_LocaleSpecPresent;
	if (targetNodeId!=0)
	frameCtl\|=kFlag_TargetNodeIdPresent;
	// now write it
	TRY(i.writeByte(frameCtl));
	// write the product spec
	TRY(i.write16(productSpec.vendorId));
	TRY(i.write16(productSpec.productId));
	TRY(i.write16(productSpec.productRev));
	// pack the version string
	TRY(version.pack(i));
	// now do the intergrity types and update schemes
	TRY(integrityTypes.pack(i));
	TRY(updateSchemes.pack(i));
	// now the optional fields
	if (packageSpec.theLength!=0) TRY(packageSpec.pack(i));
	if (localeSpec.theLength!=0) TRY(localeSpec.pack(i));
	if (targetNodeId!=0) TRY(i.write64(targetNodeId));
	theMetaData.pack(i);
	return WEAVE_NO_ERROR;
	}
	/*
	* parameters:
	* - PacketBuffer *aBuffer, a pointer to a packet from which to parse the query
	* - ImageQuery &aQuery, an object in which to put the result
	* return: error/status
	*/
	WEAVE_ERROR ImageQuery::parse(PacketBuffer *aBuffer, ImageQuery &aQuery)
	{
	MessageIterator i(aBuffer);
	// get the frame control field this doesn't actually become part of
	// the message object.
	uint8_t frameCtl;
	TRY(i.readByte(&frameCtl));
	// now get the product spec.
	TRY(i.read16(&aQuery.productSpec.vendorId));
	TRY(i.read16(&aQuery.productSpec.productId));
	TRY(i.read16(&aQuery.productSpec.productRev));
	// get the version string
	TRY(ReferencedString::parse(i, aQuery.version));
	// now do integrity types and update schemes.
	TRY(IntegrityTypeList::parse(i, aQuery.integrityTypes));
	TRY(UpdateSchemeList::parse(i, aQuery.updateSchemes));
	// if a package is provided then get it
	if (frameCtl & kFlag_PackageSpecPresent) TRY(ReferencedString::parse(i, aQuery.packageSpec));
	// if a locale is provided then get it
	if (frameCtl & kFlag_LocaleSpecPresent) TRY(ReferencedString::parse(i, aQuery.localeSpec));
	// if a target node id is provided then get it
	if (frameCtl & kFlag_TargetNodeIdPresent) TRY(i.read64(&aQuery.targetNodeId));
	// and maybe the metadata
	ReferencedTLVData::parse(i, aQuery.theMetaData);
	return WEAVE_NO_ERROR;
	}
	/*
	* the only way to tell if two of these things are equal is to try
	* all of their components.
	* parameter: ImageQuery &another, another query to check against
	* returns: true if the queries are equal, false otherwise
	*/
	bool ImageQuery::operator == (const ImageQuery &another) const
	{
	return ((productSpec.vendorId==another.productSpec.vendorId) &&
	(productSpec.productId==another.productSpec.productId) &&
	(productSpec.productRev==another.productSpec.productRev) &&
	(version==another.version) &&
	(integrityTypes==another.integrityTypes) &&
	(updateSchemes==another.updateSchemes) &&
	(packageSpec==another.packageSpec) &&
	(localeSpec==another.localeSpec) &&
	(targetNodeId==another.targetNodeId) &&
	(theMetaData==another.theMetaData));
	}
	/*
	* -- definitions for ImageQueryResponse and its supporting classes --
	*
	* parameter: uint8_t type, an IntegrityType value
	* return: the integity check output length for that type
	*/
	inline int integrityLength(uint8_t aType)
	{
	switch (aType) {
	case kIntegrityType_SHA160:
	return kLength_SHA160;
	case kIntegrityType_SHA256:
	return kLength_SHA256;
	case kIntegrityType_SHA512:
	return kLength_SHA512;
	default:
	return 0;
	}
	}
	/*
	* the no-arg contructor for an IntegritySpec
	*/
	IntegritySpec::IntegritySpec()
	{
	type=kIntegrityType_SHA160;
	}
	/*
	* parameters:
	* - uint8_t aType, an integrity type
	* - uint8_t * aValue, an integrity check code of the appropriate length
	* represented as a packed string of bytes
	* return: error/status
	*/
	WEAVE_ERROR IntegritySpec::init(uint8_t aType, uint8_t* aValue)
	{
	uint8_t len=integrityLength(aType);
	if (len==0) return WEAVE_ERROR_INVALID_INTEGRITY_TYPE;
	type=aType;
	for (int i=0; i<len; i++) value[i]=aValue[i];
	return WEAVE_NO_ERROR;
	}
	/*
	* parameters: MessageIterator &i, an iterator ofver the message
	* being packed
	* returns: error/status
	*/
	WEAVE_ERROR IntegritySpec::pack(MessageIterator &i)
	{
	TRY(i.writeByte(type));
	for (int j=0; j<integrityLength(type); j++) TRY(i.writeByte(value[j]));
	return WEAVE_NO_ERROR;
	}
	/*
	* parameters:
	* - MessageIterator &i, an iterator over the message being parsed
	* - IntegritySpec &aSpec, a pointer to an object to contain the result
	* returns: error/status
	*/
	WEAVE_ERROR IntegritySpec::parse(MessageIterator &i, IntegritySpec &aSpec)
	{
	TRY(i.readByte(&aSpec.type));
	for (int j=0; j<integrityLength(aSpec.type); j++) TRY(i.readByte(&aSpec.value[j]));
	return WEAVE_NO_ERROR;
	}
	/*
	* parameter: IntegritySpec &another, another spec to check against
	* returns: true if the integrity specs are equal, false otherwise
	*/
	bool IntegritySpec::operator == (const IntegritySpec &another) const
	{
	if (type!=another.type)
	return false;
	for (int i=0; i<integrityLength(type); i++) {
	if (value[i]!=another.value[i])
	return false;
	}
	return true;
	}
	/*
	* parameters:
	* - ReferencedString &aUri, the URI at which the new firmware image is to be found
	* - Referenced &aVersion, the version string for this image
	* - IntegritySpec &aIntegrity, the integrity spec corresponding to the new image
	* - uint8_t aScheme, the update scheme to use in downloading
	* - UpdatePriority aPriority, the update priority associated with this update
	* - UpdateCondition aCondition, the condition under which to update
	* - bool aReportStatus, if true requests the client to report after download and
	* update, otherwise the client will not report
	* return: error/status
	*/
	WEAVE_ERROR ImageQueryResponse::init(ReferencedString &aUri, ReferencedString &aVersion,
	IntegritySpec &aIntegrity, uint8_t aScheme,
	UpdatePriority aPriority, UpdateCondition aCondition,
	bool aReportStatus)
	{
	// we assume success here (woohoo! optional)
	uri=aUri;
	versionSpec=aVersion;
	versionSpec.isShort=true;
	integritySpec=aIntegrity;
	updateScheme=aScheme;
	updatePriority=aPriority;
	updateCondition=aCondition;
	reportStatus=aReportStatus;
	return WEAVE_NO_ERROR;
	}
	/*
	* the no-arg constructor for ImageQueryResponse objects
	*/
	ImageQueryResponse::ImageQueryResponse() :
	uri()
	{
	versionSpec.theLength=0;
	versionSpec.isShort=true;
	updateScheme=kUpdateScheme_HTTP;
	reportStatus=false;
	}
	/*
	* parameter: PacketBuffer *aBuffer, a packet into which the pack the response
	* return: /error/status
	*/
	WEAVE_ERROR ImageQueryResponse::pack(PacketBuffer* aBuffer)
	{
	MessageIterator i(aBuffer);
	i.append();
	TRY(uri.pack(i));
	TRY(versionSpec.pack(i));
	TRY(integritySpec.pack(i));
	TRY(i.writeByte((uint8_t)updateScheme));
	uint8_t updateOptions=(uint8_t)updatePriority\|((uint8_t)updateCondition<<kOffset_UpdateCondition);
	if (reportStatus) updateOptions\|=kMask_ReportStatus;
	TRY(i.writeByte(updateOptions));
	return WEAVE_NO_ERROR;
	}
	/*
	* parameters:
	* - PacketBuffer* aBuffer, a message buffer from which to parse the message
	* - ImageQueryResponse &aResponse, a place to put the result
	* returns: error/status
	*/
	WEAVE_ERROR ImageQueryResponse::parse(PacketBuffer *aBuffer, ImageQueryResponse &aResponse)
	{
	MessageIterator i(aBuffer);
	uint8_t updateOptions;
	TRY(ReferencedString::parse(i, aResponse.uri));
	TRY(ReferencedString::parse(i, aResponse.versionSpec));
	TRY(IntegritySpec::parse(i, aResponse.integritySpec));
	TRY(i.readByte(&aResponse.updateScheme));
	TRY(i.readByte(&updateOptions));
	aResponse.updatePriority=(UpdatePriority)(updateOptions&kMask_UpdatePriority);
	aResponse.updateCondition=(UpdateCondition)((updateOptions&kMask_UpdateCondition)>>kOffset_UpdateCondition);
	aResponse.reportStatus=(updateOptions&kMask_ReportStatus)==kMask_ReportStatus;
	return WEAVE_NO_ERROR;
	}
	/*
	* parameter: ImageQueryResponse &another, another response to check against
	* returns: true if the responses are equal, false otherwise
	*/
	bool ImageQueryResponse::operator ==(const ImageQueryResponse &another) const
	{
	return ((uri==another.uri) &&
	(versionSpec==another.versionSpec) &&
	(integritySpec==another.integritySpec) &&
	(updateScheme==another.updateScheme) &&
	(updatePriority==another.updatePriority) &&
	(updateCondition==another.updateCondition) &&
	(reportStatus==another.reportStatus));
	}