| /* |
| * |
| * 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 a derived unsolicited responder |
| * (i.e., server) for the Weave Software Update (SWU) profile used |
| * for the Weave mock device command line functional testing |
| * tool. |
| * |
| */ |
| |
| #include <stdlib.h> |
| #include <fcntl.h> |
| #include <unistd.h> |
| #include <stdio.h> |
| #include <errno.h> |
| |
| #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 "MockSWUServer.h" |
| #include <Weave/Profiles/common/CommonProfile.h> |
| |
| |
| MockSoftwareUpdateServer::MockSoftwareUpdateServer() |
| { |
| FabricState = NULL; |
| ExchangeMgr = NULL; |
| mCurServerOp = NULL; |
| mRefImageQuery = NULL; |
| mFileDesignator = NULL; |
| mCurServerOpBuf = NULL; |
| } |
| |
| WEAVE_ERROR MockSoftwareUpdateServer::Init(WeaveExchangeManager *exchangeMgr) |
| { |
| FabricState = exchangeMgr->FabricState; |
| ExchangeMgr = exchangeMgr; |
| mCurServerOp = NULL; |
| mCurServerOpBuf = NULL; |
| mFileDesignator = NULL; |
| |
| // Register to receive unsolicited Service Provisioning messages from the exchange manager. |
| WEAVE_ERROR err = |
| ExchangeMgr->RegisterUnsolicitedMessageHandler(kWeaveProfile_SWU, HandleClientRequest, this); |
| |
| return err; |
| } |
| |
| WEAVE_ERROR MockSoftwareUpdateServer::Shutdown() |
| { |
| if (ExchangeMgr != NULL) |
| ExchangeMgr->UnregisterUnsolicitedMessageHandler(kWeaveProfile_SWU); |
| |
| if (mCurServerOp != NULL) |
| { |
| mCurServerOp->Close(); |
| mCurServerOp = NULL; |
| } |
| |
| if (mCurServerOpBuf != NULL) |
| { |
| PacketBuffer::Free(mCurServerOpBuf); |
| mCurServerOpBuf = NULL; |
| } |
| |
| FabricState = NULL; |
| ExchangeMgr = NULL; |
| mCurServerOp = NULL; |
| |
| return WEAVE_NO_ERROR; |
| } |
| |
| void MockSoftwareUpdateServer::HandleClientRequest(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo, |
| uint32_t profileId, uint8_t msgType, PacketBuffer *payload) |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| MockSoftwareUpdateServer *server = (MockSoftwareUpdateServer *) ec->AppState; |
| |
| // Fail messages for the wrong profile. This shouldn't happen, but better safe than sorry. |
| if (profileId != kWeaveProfile_SWU) |
| { |
| server->SendStatusReport(kWeaveProfile_Common, Common::kStatus_BadRequest, WEAVE_NO_ERROR); |
| ec->Close(); |
| goto exit; |
| } |
| |
| // Disallow simultaneous requests. |
| if (server->mCurServerOp != NULL) |
| { |
| server->SendStatusReport(kWeaveProfile_Common, Common::kStatus_Busy, WEAVE_NO_ERROR); |
| ec->Close(); |
| goto exit; |
| } |
| |
| // Record that we have a request in process. |
| server->mCurServerOp = ec; |
| |
| // Decode and dispatch the message. |
| switch (msgType) |
| { |
| case kMsgType_ImageQuery: |
| err = HandleImageQuery(ec, pktInfo, msgInfo, profileId, msgType, payload); |
| SuccessOrExit(err); |
| break; |
| |
| default: |
| server->SendStatusReport(kWeaveProfile_Common, Common::kStatus_BadRequest); |
| break; |
| } |
| |
| exit: |
| |
| if (payload != NULL) |
| PacketBuffer::Free(payload); |
| } |
| |
| WEAVE_ERROR MockSoftwareUpdateServer::GenerateImageDigest(const char *imagePath, uint8_t integrityType, uint8_t *digest) |
| { |
| //Generate Image Digest |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| uint8_t block[512]; |
| FILE *file; |
| int bytesRead = 0; |
| nl::Weave::Platform::Security::SHA1 sha1; |
| nl::Weave::Platform::Security::SHA256 sha256; |
| |
| file = fopen(imagePath, "r"); |
| if (file == NULL) |
| { |
| printf("Unable to open %s: %s\n", imagePath, strerror(errno)); |
| ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT); |
| } |
| |
| switch (integrityType) |
| { |
| case kIntegrityType_SHA160: |
| |
| sha1.Begin(); |
| break; |
| case kIntegrityType_SHA256: |
| sha256.Begin(); |
| break; |
| default: |
| printf("Unsupported image integrity type: %u\n", integrityType); |
| ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT); |
| break; |
| } |
| |
| while ((bytesRead = fread(block, 1, sizeof(block), file)) > 0) |
| { |
| if (integrityType == kIntegrityType_SHA160) |
| sha1.AddData(block, bytesRead); |
| else |
| sha256.AddData(block, bytesRead); |
| } |
| |
| if (bytesRead < 0) |
| { |
| printf("Error reading %s: %s\n", imagePath, strerror(errno)); |
| ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT); |
| } |
| |
| if (integrityType == kIntegrityType_SHA160) |
| sha1.Finish(digest); |
| else |
| sha256.Finish(digest); |
| |
| exit: |
| if (file != NULL) |
| fclose(file); |
| |
| return err; |
| } |
| |
| WEAVE_ERROR MockSoftwareUpdateServer::SendImageQueryResponse() |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| ImageQueryResponse imageQueryResponse; |
| IntegritySpec integritySpec; |
| ReferencedString URI; |
| uint8_t imageDigest[nl::Weave::Platform::Security::SHA256::kHashLength]; |
| uint8_t supported_update_scheme; |
| int integrityType = -1; |
| int i = 0; |
| |
| VerifyOrExit(mFileDesignator != NULL, err = WEAVE_ERROR_INVALID_ARGUMENT); |
| |
| // Use the first one |
| supported_update_scheme = mRefImageQuery->updateSchemes.theList[0]; |
| |
| // Scan the offered list of integrity types for SHA1 or SHA256. Prefer SHA256 when offered. |
| for (i = 0; i < mRefImageQuery->integrityTypes.theLength; i++) |
| { |
| switch (mRefImageQuery->integrityTypes.theList[i]) |
| { |
| case kIntegrityType_SHA160: |
| if (integrityType == -1) |
| integrityType = kIntegrityType_SHA160; |
| break; |
| case kIntegrityType_SHA256: |
| integrityType = kIntegrityType_SHA256; |
| break; |
| default: |
| break; |
| } |
| } |
| if (integrityType == -1) |
| { |
| printf("No supported integrity types in ImageQuery\n"); |
| ExitNow(err = WEAVE_ERROR_INVALID_ARGUMENT); |
| } |
| |
| err = GenerateImageDigest(mFileDesignator, (uint8_t)integrityType, imageDigest); |
| SuccessOrExit(err); |
| |
| err = integritySpec.init(mRefImageQuery->integrityTypes.theList[i], imageDigest); |
| SuccessOrExit(err); |
| |
| err = URI.init((uint16_t)(strlen(mFileDesignator) + 1), (char *)mFileDesignator); |
| SuccessOrExit(err); |
| |
| err = imageQueryResponse.init(URI, mRefImageQuery->version, integritySpec, |
| supported_update_scheme, Normal, Unconditionally, false); |
| SuccessOrExit(err); |
| |
| mCurServerOpBuf = PacketBuffer::New(); |
| err = imageQueryResponse.pack(mCurServerOpBuf); |
| SuccessOrExit(err); |
| |
| // If we are given a URI, then we should download the image and calculate the checksum using the correct |
| // integrity type otherwise use the local image provided in the argument and calc the checksum. |
| |
| err = mCurServerOp->SendMessage(kWeaveProfile_SWU, kMsgType_ImageQueryResponse, mCurServerOpBuf); |
| SuccessOrExit(err); |
| |
| exit: |
| return err; |
| } |
| |
| WEAVE_ERROR MockSoftwareUpdateServer::SendImageQueryStatus() |
| { |
| WEAVE_ERROR err = WEAVE_NO_ERROR; |
| |
| mCurServerOpBuf = PacketBuffer::New(); |
| |
| StatusReport statusReport; |
| statusReport.init(kWeaveProfile_SWU, kStatus_NoUpdateAvailable); |
| |
| err = statusReport.pack(mCurServerOpBuf); |
| SuccessOrExit(err); |
| |
| err = mCurServerOp->SendMessage(kWeaveProfile_Common, Common::kMsgType_StatusReport, mCurServerOpBuf); |
| SuccessOrExit(err); |
| |
| exit: |
| return err; |
| |
| } |
| |
| WEAVE_ERROR MockSoftwareUpdateServer::HandleImageQuery(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo, |
| uint32_t profileId, uint8_t msgType, PacketBuffer *payload) |
| { |
| ImageQuery ParsedImageQueryRequest; |
| bool update_available = false; |
| bool common_integrity_scheme_found = false; |
| bool common_update_scheme_found = false; |
| int index = 0; |
| |
| MockSoftwareUpdateServer *server = (MockSoftwareUpdateServer *) ec->AppState; |
| |
| //Parse image query ans print values |
| WEAVE_ERROR err = ImageQuery::parse(payload, ParsedImageQueryRequest); |
| if (WEAVE_NO_ERROR == err) { |
| printf("\nReceievd Image Query Request\n"); |
| printf(" Vendor Id: %d\n", ParsedImageQueryRequest.productSpec.vendorId); |
| printf(" Product Id: %d\n", ParsedImageQueryRequest.productSpec.productId); |
| printf(" Product Rev: %d\n", ParsedImageQueryRequest.productSpec.productRev); |
| printf(" Software version: %s\n", ParsedImageQueryRequest.version.printString()); |
| printf(" Integrity Type: %d\n", ParsedImageQueryRequest.integrityTypes.theList[0]); |
| printf(" Update Scheme: %d\n", ParsedImageQueryRequest.updateSchemes.theList[0]); |
| printf("\n"); |
| } |
| |
| // Condition to send a image query response: |
| // 1. Product Spec matches |
| // 2. If the server supports any of the client's intergrity schemes |
| // 3. If the server supports any of the client's update schemes |
| |
| // Condition to send an Status Report with No Image Available |
| // 1-2 from Image Query Response |
| // 5. Client's and server version's are the same |
| |
| // Any other issues with Image Query such as an invalid field or entry: |
| // Send down a status report with Error Message |
| |
| if ((ParsedImageQueryRequest.productSpec) == (server->mRefImageQuery->productSpec)) |
| { |
| update_available = true; |
| } |
| VerifyOrExit(update_available, printf("Product Specs do not match\n")); |
| |
| for (index = 0; index < server->mRefImageQuery->integrityTypes.theLength; index++) |
| { |
| if (ParsedImageQueryRequest.integrityTypes.theList[0] == server->mRefImageQuery->integrityTypes.theList[index]) |
| { |
| printf("Using integrity scheme :%d\n", ParsedImageQueryRequest.integrityTypes.theList[0]); |
| common_integrity_scheme_found = true; |
| break; |
| } |
| } |
| |
| if (!common_integrity_scheme_found) |
| { |
| update_available = false; |
| VerifyOrExit(update_available, printf("Integrity Scheme requested by the client is not supported\n")); |
| } |
| |
| for (index = 0; index < server->mRefImageQuery->updateSchemes.theLength; index++) |
| { |
| if (ParsedImageQueryRequest.updateSchemes.theList[0] == server->mRefImageQuery->updateSchemes.theList[index]) |
| { |
| printf("Using Update Scheme :%d\n", ParsedImageQueryRequest.updateSchemes.theList[0]); |
| common_update_scheme_found = true; |
| break; |
| } |
| } |
| |
| if (!common_update_scheme_found) |
| { |
| update_available = false; |
| VerifyOrExit(update_available, printf("Update Scheme requested by the client is not supported\n")); |
| } |
| |
| if (ParsedImageQueryRequest.version == server->mRefImageQuery->version) |
| { |
| // Send down an image query status |
| update_available = false; |
| } |
| else |
| { |
| // Send Down an Image Query response |
| update_available = true; |
| } |
| |
| exit: |
| if (update_available && common_update_scheme_found && common_integrity_scheme_found) |
| { |
| server->SendImageQueryResponse(); |
| } |
| else |
| { |
| server->SendImageQueryStatus(); |
| } |
| |
| // Cleanup |
| server->mCurServerOp = NULL; |
| |
| return WEAVE_NO_ERROR; |
| } |
| |
| WEAVE_ERROR MockSoftwareUpdateServer::SendStatusReport(uint32_t statusProfileId, uint16_t statusCode, WEAVE_ERROR sysError) |
| { |
| WEAVE_ERROR err; |
| |
| VerifyOrExit(mCurServerOp != NULL, err = WEAVE_ERROR_INCORRECT_STATE); |
| |
| printf("Sending StatusReport to the client -> Profile : %d StatusCode : %d\n", statusProfileId, statusCode); |
| err = WeaveServerBase::SendStatusReport(mCurServerOp, statusProfileId, statusCode, sysError); |
| |
| exit: |
| |
| if (mCurServerOp != NULL) |
| { |
| mCurServerOp->Close(); |
| mCurServerOp = NULL; |
| } |
| |
| if (mCurServerOpBuf != NULL) |
| { |
| PacketBuffer::Free(mCurServerOpBuf); |
| mCurServerOpBuf = NULL; |
| } |
| |
| return err; |
| } |
| |
| void MockSoftwareUpdateServer::SetReferenceImageQuery(ImageQuery *aRefImageQuery) |
| { |
| mRefImageQuery = aRefImageQuery; |
| |
| #if MOCK_SWU_SERVER_DEBUG |
| printf("\nUsing the following configuration:\n"); |
| printf(" Vendor Id: %d\n", mRefImageQuery->productSpec.vendorId); |
| printf(" Product Id: %d\n", mRefImageQuery->productSpec.productId); |
| printf(" Product Rev: %d\n", mRefImageQuery->productSpec.productRev); |
| printf(" Software version: %s\n", mRefImageQuery->version.printString()); |
| printf(" Integrity Type[s]: "); |
| for (int i = 0 ; i < mRefImageQuery->integrityTypes.theLength; i++) |
| { printf("%d ", mRefImageQuery->integrityTypes.theList[i]); } |
| printf("\n"); |
| printf(" Update Scheme[s]: "); |
| for (int i = 0 ; i < mRefImageQuery->updateSchemes.theLength; i++) |
| { printf("%d ", mRefImageQuery->updateSchemes.theList[i]); } |
| printf("\n"); |
| #endif |
| |
| } |
| |
| WEAVE_ERROR MockSoftwareUpdateServer::SetFileDesignator(const char *aFileDesignator) |
| { |
| FILE *file; |
| |
| if (!aFileDesignator) |
| { |
| printf("--file-designator not specified\n"); |
| exit(-1); |
| } |
| |
| // Make sure we can open the image file |
| file = fopen(aFileDesignator, "r"); |
| if (file == NULL) { |
| return WEAVE_ERROR_INCORRECT_STATE; |
| } |
| else { |
| fclose(file); |
| } |
| |
| mFileDesignator = aFileDesignator; |
| return WEAVE_NO_ERROR; |
| } |
| |
| WEAVE_ERROR MockSoftwareUpdateServer::SendImageAnnounce(WeaveConnection *con) |
| { |
| // Discard any existing exchange context. |
| // Effectively we can only have one SWU exchange with a single node at any one time. |
| if (mCurServerOp != NULL) |
| { |
| mCurServerOp->Close(); |
| mCurServerOp = NULL; |
| } |
| |
| // Create a new exchange context. |
| mCurServerOp = ExchangeMgr->NewContext(con, this); |
| if (mCurServerOp == NULL) |
| return WEAVE_ERROR_NO_MEMORY; |
| |
| return SendImageAnnounce(); |
| } |
| |
| WEAVE_ERROR MockSoftwareUpdateServer::SendImageAnnounce(uint64_t nodeId, IPAddress nodeAddr) |
| { |
| return SendImageAnnounce(nodeId, nodeAddr, WEAVE_PORT); |
| } |
| |
| WEAVE_ERROR MockSoftwareUpdateServer::SendImageAnnounce(uint64_t nodeId, IPAddress nodeAddr, uint16_t port) |
| { |
| // Discard any existing exchange context. Effectively we can only have one SWU exchange with |
| // a single node at any one time. |
| if (mCurServerOp != NULL) |
| { |
| mCurServerOp->Close(); |
| mCurServerOp = NULL; |
| } |
| |
| if (nodeAddr == IPAddress::Any) |
| nodeAddr = FabricState->SelectNodeAddress(nodeId); |
| |
| // Create a new exchange context. |
| mCurServerOp = ExchangeMgr->NewContext(nodeId, nodeAddr, this); |
| if (mCurServerOp == NULL) |
| return WEAVE_ERROR_NO_MEMORY; |
| |
| return SendImageAnnounce(); |
| } |
| |
| WEAVE_ERROR MockSoftwareUpdateServer::SendImageAnnounce() |
| { |
| printf("0 SendImageAnnounce entering\n"); |
| |
| PacketBuffer* lBuffer = PacketBuffer::New(); |
| |
| // Send image announce message. Discard the exchange context if the send fails. |
| WEAVE_ERROR err = mCurServerOp->SendMessage(kWeaveProfile_SWU, kMsgType_ImageAnnounce, lBuffer); |
| lBuffer = NULL; |
| |
| mCurServerOp->Close(); |
| mCurServerOp = NULL; |
| |
| if (err != WEAVE_NO_ERROR) |
| { |
| printf(" 1 mCurServeOp->Sendmessage(Image announce) FAILED: %s\n", nl::ErrorStr(err)); |
| return err; |
| } |
| printf("2 Send Image Announce exiting\n"); |
| return err; |
| } |
