X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=resource%2Fcsdk%2Fsecurity%2Fprovisioning%2Fsrc%2Fownershiptransfermanager.c;h=9bdc2c592e58affd82e837f139dc0d04159870e1;hb=5ca344b5d30aa6322c89a460f9c551d5a194be83;hp=e1ba69b6008a3b0b2ce715f104523515347b445e;hpb=172aa5cd0babea8218de011a41d0cc203b8dcccf;p=platform%2Fupstream%2Fiotivity.git diff --git a/resource/csdk/security/provisioning/src/ownershiptransfermanager.c b/resource/csdk/security/provisioning/src/ownershiptransfermanager.c index e1ba69b..9bdc2c5 100644 --- a/resource/csdk/security/provisioning/src/ownershiptransfermanager.c +++ b/resource/csdk/security/provisioning/src/ownershiptransfermanager.c @@ -30,9 +30,15 @@ #define _POSIX_C_SOURCE 200809L #endif +#ifdef HAVE_TIME_H #include +#endif +#ifdef HAVE_UNISTD_H #include +#endif +#ifdef HAVE_SYS_TIME_H #include +#endif #include #include @@ -69,19 +75,6 @@ static OTMCallbackData_t g_OTMDatas[OIC_OXM_COUNT]; /** - * Variable for storing provisioning tool's provisioning capabilities - * Must be in decreasing order of preference. More prefered method should - * have lower array index. - */ -static OicSecDpom_t gProvisioningToolCapability[] = { SINGLE_SERVICE_CLIENT_DRIVEN }; - -/** - * Number of supported provisioning methods - * current version supports only one. - */ -static size_t gNumOfProvisioningMethodsPT = 1; - -/** * Variables for pointing the OTMContext to be used in the DTLS handshake result callback. */ static OTMContext_t* g_otmCtx = NULL; @@ -95,8 +88,7 @@ static OTMContext_t* g_otmCtx = NULL; * @return OC_STACK_OK on success */ static OCStackResult SelectProvisioningMethod(const OicSecOxm_t *supportedMethods, - size_t numberOfMethods, - OicSecOxm_t *selectedMethod) + size_t numberOfMethods, OicSecOxm_t *selectedMethod) { OIC_LOG(DEBUG, TAG, "IN SelectProvisioningMethod"); @@ -129,29 +121,8 @@ static void SelectOperationMode(const OCProvisionDev_t *selectedDeviceInfo, OicSecDpom_t *selectedMode) { OIC_LOG(DEBUG, TAG, "IN SelectOperationMode"); - - size_t i = 0; - size_t j = 0; - - while (i < gNumOfProvisioningMethodsPT && j < selectedDeviceInfo->pstat->smLen) - { - if (gProvisioningToolCapability[i] < selectedDeviceInfo->pstat->sm[j]) - { - i++; - } - else if (selectedDeviceInfo->pstat->sm[j] < gProvisioningToolCapability[i]) - { - j++; - } - else /* if gProvisioningToolCapability[i] == deviceSupportedMethods[j] */ - { - *selectedMode = gProvisioningToolCapability[j]; - break; - } - } + *selectedMode = selectedDeviceInfo->pstat->sm[0]; OIC_LOG_V(DEBUG, TAG, "Selected Operation Mode = %d", *selectedMode); - - OIC_LOG(DEBUG, TAG, "OUT SelectOperationMode"); } /** @@ -171,7 +142,7 @@ static OCStackResult StartOwnershipTransfer(void* ctx, OCProvisionDev_t* selecte * @param[in] otmCtx Context value of ownership transfer. * @return OC_STACK_OK on success */ -static OCStackResult PutOwnerTransferModeToResource(OTMContext_t* otmCtx); +static OCStackResult PostOwnerTransferModeToResource(OTMContext_t* otmCtx); /** * Function to send request to resource to get its pstat resource information. @@ -189,7 +160,7 @@ static OCStackResult GetProvisioningStatusResource(OTMContext_t* otmCtx); * @param[in] otmCtx Context value of ownership transfer. * @return OC_STACK_OK on success */ -static OCStackResult PutOwnerUuid(OTMContext_t* otmCtx); +static OCStackResult PostOwnerUuid(OTMContext_t* otmCtx); /** * Function to update the operation mode. As per the spec. Operation mode in client driven @@ -198,7 +169,7 @@ static OCStackResult PutOwnerUuid(OTMContext_t* otmCtx); * @param[in] otmCtx Context value of ownership transfer. * @return OC_STACK_OK on success */ -static OCStackResult PutUpdateOperationMode(OTMContext_t* otmCtx); +static OCStackResult PostUpdateOperationMode(OTMContext_t* otmCtx); /** * Function to update the owner credential to new device @@ -207,7 +178,7 @@ static OCStackResult PutUpdateOperationMode(OTMContext_t* otmCtx); * @param[in] selectedOperationMode selected operation mode * @return OC_STACK_OK on success */ -static OCStackResult PutOwnerCredential(OTMContext_t* otmCtx); +static OCStackResult PostOwnerCredential(OTMContext_t* otmCtx); /** * Function to send ownerShip info. @@ -216,17 +187,27 @@ static OCStackResult PutOwnerCredential(OTMContext_t* otmCtx); * @param[in] otmCtx Context value of ownership transfer. * @return OC_STACK_OK on success */ -static OCStackResult PutOwnershipInformation(OTMContext_t* otmCtx); +static OCStackResult PostOwnershipInformation(OTMContext_t* otmCtx); + +/** + * Function to update pstat as Ready for provisioning. + * This function would update 'cm' from bx0000,0010 to bx0000,0000. + * + * @param[in] ctx context value passed to callback from calling function. + * @param[in] selectedDevice selected device information to performing provisioning. + * @return OC_STACK_OK on success + */ +static OCStackResult PostProvisioningStatus(OTMContext_t* otmCtx); /** - * Function to update pstat when finalize provisioning. - * This function would update 'cm' as bx0011,1100 and 'tm' as bx0000,0000. + * Function to update pstat as Ready for Normal Operation. + * This function would update 'isop' from false to true. * * @param[in] ctx context value passed to callback from calling function. * @param[in] selectedDevice selected device information to performing provisioning. * @return OC_STACK_OK on success */ -static OCStackResult PutProvisioningStatus(OTMContext_t* otmCtx); +static OCStackResult PostNormalOperationStatus(OTMContext_t* otmCtx); static bool IsComplete(OTMContext_t* otmCtx) { @@ -340,8 +321,8 @@ void DTLSHandshakeCB(const CAEndpoint_t *endpoint, const CAErrorInfo_t *info) false == newDevDoxm->owned && memcmp(&(newDevDoxm->owner), &emptyUuid, sizeof(OicUuid_t)) == 0) { - //Send request : PUT /oic/sec/doxm [{... , "devowner":"PT's UUID"}] - res = PutOwnerUuid(g_otmCtx); + //Send request : POST /oic/sec/doxm [{... , "devowner":"PT's UUID"}] + res = PostOwnerUuid(g_otmCtx); if(OC_STACK_OK != res) { OIC_LOG(ERROR, TAG, "OperationModeUpdate : Failed to send owner information"); @@ -424,6 +405,7 @@ static OCStackResult SaveOwnerPSK(OCProvisionDev_t *selectedDeviceInfo) } uint8_t ownerPSK[OWNER_PSK_LENGTH_128] = {0}; + OicSecKey_t ownerKey = {ownerPSK, OWNER_PSK_LENGTH_128}; //Generating OwnerPSK CAResult_t pskRet = CAGenerateOwnerPSK(&endpoint, @@ -438,19 +420,33 @@ static OCStackResult SaveOwnerPSK(OCProvisionDev_t *selectedDeviceInfo) OIC_LOG(INFO, TAG,"ownerPSK dump:\n"); OIC_LOG_BUFFER(INFO, TAG,ownerPSK, OWNER_PSK_LENGTH_128); //Generating new credential for provisioning tool - size_t ownLen = 1; - uint32_t outLen = 0; - - char base64Buff[B64ENCODE_OUT_SAFESIZE(sizeof(ownerPSK)) + 1] = {}; - B64Result b64Ret = b64Encode(ownerPSK, sizeof(ownerPSK), base64Buff, sizeof(base64Buff), - &outLen); - VERIFY_SUCCESS(TAG, B64_OK == b64Ret, ERROR); - OicSecCred_t *cred = GenerateCredential(&selectedDeviceInfo->doxm->deviceID, SYMMETRIC_PAIR_WISE_KEY, NULL, - base64Buff, ownLen, &ptDeviceID); + &ownerKey, &ptDeviceID); VERIFY_NON_NULL(TAG, cred, ERROR); + // TODO: Added as workaround. Will be replaced soon. + cred->privateData.encoding = OIC_ENCODING_RAW; + +#if 1 + // NOTE: Test codes to use BASE64 encoded owner PSK. + uint32_t outSize = 0; + size_t b64BufSize = B64ENCODE_OUT_SAFESIZE((OWNER_PSK_LENGTH_128 + 1)); + char* b64Buf = (uint8_t *)OICCalloc(1, b64BufSize); + VERIFY_NON_NULL(TAG, b64Buf, ERROR); + b64Encode(cred->privateData.data, cred->privateData.len, b64Buf, b64BufSize, &outSize); + + OICFree( cred->privateData.data ); + cred->privateData.data = (uint8_t *)OICCalloc(1, outSize + 1); + VERIFY_NON_NULL(TAG, cred->privateData.data, ERROR); + + strncpy(cred->privateData.data, b64Buf, outSize); + cred->privateData.data[outSize] = '\0'; + cred->privateData.encoding = OIC_ENCODING_BASE64; + cred->privateData.len = outSize; + OICFree(b64Buf); +#endif //End of Test codes + res = AddCredential(cred); if(res != OC_STACK_OK) { @@ -487,7 +483,7 @@ static OCStackApplicationResult OwnerTransferModeHandler(void *ctx, OCDoHandle U OTMContext_t* otmCtx = (OTMContext_t*)ctx; (void)UNUSED; - if(clientResponse->result == OC_STACK_OK) + if(OC_STACK_RESOURCE_CHANGED == clientResponse->result) { OIC_LOG(INFO, TAG, "OwnerTransferModeHandler : response result = OC_STACK_OK"); //Send request : GET /oic/sec/pstat @@ -545,24 +541,30 @@ static OCStackApplicationResult ListMethodsHandler(void *ctx, OCDoHandle UNUSED, SetResult(otmCtx, OC_STACK_ERROR); return OC_STACK_DELETE_TRANSACTION; } - uint8_t size = 0; OicSecPstat_t* pstat = NULL; OCStackResult result = CBORPayloadToPstat( - ((OCSecurityPayload*)clientResponse->payload)->securityData1, - size, &pstat); - if(NULL == pstat && result != OC_STACK_OK) + ((OCSecurityPayload*)clientResponse->payload)->securityData, + ((OCSecurityPayload*)clientResponse->payload)->payloadSize, + &pstat); + if(NULL == pstat || result != OC_STACK_OK) { OIC_LOG(ERROR, TAG, "Error while converting cbor to pstat."); SetResult(otmCtx, OC_STACK_ERROR); return OC_STACK_DELETE_TRANSACTION; } + if(false == (TAKE_OWNER & pstat->cm)) + { + OIC_LOG(ERROR, TAG, "Device pairing mode enabling owner transfer operations is disabled"); + SetResult(otmCtx, OC_STACK_ERROR); + return OC_STACK_DELETE_TRANSACTION; + } otmCtx->selectedDeviceInfo->pstat = pstat; //Select operation mode (Currently supported SINGLE_SERVICE_CLIENT_DRIVEN only) SelectOperationMode(otmCtx->selectedDeviceInfo, &(otmCtx->selectedDeviceInfo->pstat->om)); - //Send request : PUT /oic/sec/pstat [{"om":"bx11", .. }] - OCStackResult res = PutUpdateOperationMode(otmCtx); + //Send request : POST /oic/sec/pstat [{"om":"bx11", .. }] + OCStackResult res = PostUpdateOperationMode(otmCtx); if (OC_STACK_OK != res) { OIC_LOG(ERROR, TAG, "Error while updating operation mode."); @@ -601,7 +603,7 @@ static OCStackApplicationResult OwnerUuidUpdateHandler(void *ctx, OCDoHandle UNU OCStackResult res = OC_STACK_OK; OTMContext_t* otmCtx = (OTMContext_t*)ctx; - if(OC_STACK_OK == clientResponse->result) + if(OC_STACK_RESOURCE_CHANGED == clientResponse->result) { if(otmCtx && otmCtx->selectedDeviceInfo) { @@ -613,12 +615,12 @@ static OCStackApplicationResult OwnerUuidUpdateHandler(void *ctx, OCDoHandle UNU return OC_STACK_DELETE_TRANSACTION; } - //PUT owner credential to new device according to security spec B. - res = PutOwnerCredential(otmCtx); + //POST owner credential to new device according to security spec B. + res = PostOwnerCredential(otmCtx); if(OC_STACK_OK != res) { OIC_LOG(ERROR, TAG, - "OwnerUuidUpdateHandler:Failed to send PUT request for onwer credential"); + "OwnerUuidUpdateHandler:Failed to send PosT request for onwer credential"); SetResult(otmCtx, res); return OC_STACK_DELETE_TRANSACTION; } @@ -656,7 +658,7 @@ static OCStackApplicationResult OperationModeUpdateHandler(void *ctx, OCDoHandle OTMContext_t* otmCtx = (OTMContext_t*)ctx; (void) UNUSED; - if (OC_STACK_OK == clientResponse->result) + if (OC_STACK_RESOURCE_CHANGED == clientResponse->result) { OCStackResult res = OC_STACK_ERROR; OicSecOxm_t selOxm = otmCtx->selectedDeviceInfo->doxm->oxmSel; @@ -764,11 +766,11 @@ static OCStackApplicationResult OwnerCredentialHandler(void *ctx, OCDoHandle UNU } } - //PUT /oic/sec/doxm [{ ..., "owned":"TRUE" }] - res = PutOwnershipInformation(otmCtx); + //POST /oic/sec/doxm [{ ..., "owned":"TRUE" }] + res = PostOwnershipInformation(otmCtx); if(OC_STACK_OK != res) { - OIC_LOG(ERROR, TAG, "Failed to put ownership information to new device"); + OIC_LOG(ERROR, TAG, "Failed to post ownership information to new device"); SetResult(otmCtx, res); return OC_STACK_DELETE_TRANSACTION; } @@ -808,14 +810,14 @@ static OCStackApplicationResult OwnershipInformationHandler(void *ctx, OCDoHandl OCStackResult res = OC_STACK_OK; OTMContext_t* otmCtx = (OTMContext_t*)ctx; - if(OC_STACK_OK == clientResponse->result) + if(OC_STACK_RESOURCE_CHANGED == clientResponse->result) { if(otmCtx && otmCtx->selectedDeviceInfo) { OIC_LOG(INFO, TAG, "Ownership transfer was successfully completed."); - OIC_LOG(INFO, TAG, "Start defualt ACL & commit-hash provisioning."); + OIC_LOG(INFO, TAG, "Set Ready for provisioning state ."); - res = PutProvisioningStatus(otmCtx); + res = PostProvisioningStatus(otmCtx); if(OC_STACK_OK != res) { OIC_LOG(ERROR, TAG, "Failed to update pstat"); @@ -855,9 +857,57 @@ static OCStackApplicationResult ProvisioningStatusHandler(void *ctx, OCDoHandle OTMContext_t* otmCtx = (OTMContext_t*) ctx; (void)UNUSED; + OCStackResult res = OC_STACK_OK; + + if(OC_STACK_RESOURCE_CHANGED == clientResponse->result) + { + if(otmCtx && otmCtx->selectedDeviceInfo) + { + OIC_LOG(INFO, TAG, "Device state is in Ready for Provisionig."); + + res = PostNormalOperationStatus(otmCtx); + if(OC_STACK_OK != res) + { + OIC_LOG(ERROR, TAG, "Failed to update pstat"); + SetResult(otmCtx, res); + } + } + } + else + { + OIC_LOG_V(INFO, TAG, "Error occured in provisionDefaultACLCB :: %d\n", + clientResponse->result); + SetResult(otmCtx, clientResponse->result); + } + +exit: + OIC_LOG_V(INFO, TAG, "OUT ProvisioningStatusHandler."); + return OC_STACK_DELETE_TRANSACTION; +} + +/** + * Response handler of update provisioning status to Ready for Normal.. + * + * @param[in] ctx ctx value passed to callback from calling function. + * @param[in] UNUSED handle to an invocation + * @param[in] clientResponse Response from queries to remote servers. + * @return OC_STACK_DELETE_TRANSACTION to delete the transaction + * and OC_STACK_KEEP_TRANSACTION to keep it. + */ +static OCStackApplicationResult ReadyForNomalStatusHandler(void *ctx, OCDoHandle UNUSED, + OCClientResponse *clientResponse) +{ + OIC_LOG_V(INFO, TAG, "IN ReadyForNomalStatusHandler."); + + VERIFY_NON_NULL(TAG, clientResponse, ERROR); + VERIFY_NON_NULL(TAG, ctx, ERROR); + + OTMContext_t* otmCtx = (OTMContext_t*) ctx; + (void)UNUSED; - if (OC_STACK_OK == clientResponse->result) + if (OC_STACK_RESOURCE_CHANGED == clientResponse->result) { + OIC_LOG(INFO, TAG, "Device state is in Ready for Normal Operation."); OCStackResult res = PDMAddDevice(&otmCtx->selectedDeviceInfo->doxm->deviceID); if (OC_STACK_OK == res) { @@ -877,15 +927,14 @@ static OCStackApplicationResult ProvisioningStatusHandler(void *ctx, OCDoHandle SetResult(otmCtx, clientResponse->result); } - exit: - OIC_LOG_V(INFO, TAG, "OUT ProvisioningStatusHandler."); + OIC_LOG_V(INFO, TAG, "OUT ReadyForNomalStatusHandler."); return OC_STACK_DELETE_TRANSACTION; } -static OCStackResult PutOwnerCredential(OTMContext_t* otmCtx) +static OCStackResult PostOwnerCredential(OTMContext_t* otmCtx) { - OIC_LOG(DEBUG, TAG, "IN PutOwnerCredential"); + OIC_LOG(DEBUG, TAG, "IN PostOwnerCredential"); if(!otmCtx || !otmCtx->selectedDeviceInfo) { @@ -901,7 +950,7 @@ static OCStackResult PutOwnerCredential(OTMContext_t* otmCtx) deviceInfo->connType, query, sizeof(query), OIC_RSRC_CRED_URI)) { - OIC_LOG(ERROR, TAG, "PutOwnerCredential : Failed to generate query"); + OIC_LOG(ERROR, TAG, "PostOwnerCredential : Failed to generate query"); return OC_STACK_ERROR; } OIC_LOG_V(DEBUG, TAG, "Query=%s", query); @@ -914,8 +963,7 @@ static OCStackResult PutOwnerCredential(OTMContext_t* otmCtx) //Generate owner credential for new device secPayload->base.type = PAYLOAD_TYPE_SECURITY; - OicSecCred_t* ownerCredential = - GetCredResourceData(&(deviceInfo->doxm->deviceID)); + const OicSecCred_t* ownerCredential = GetCredResourceData(&(deviceInfo->doxm->deviceID)); if(!ownerCredential) { OIC_LOG(ERROR, TAG, "Can not find OwnerPSK."); @@ -933,25 +981,32 @@ static OCStackResult PutOwnerCredential(OTMContext_t* otmCtx) memcpy(&(newCredential.subject), &credSubjectId, sizeof(OicUuid_t)); //Fill private data as empty string - newCredential.privateData.data = NULL; - - //Send owner credential to new device : PUT /oic/sec/cred [ owner credential ] - secPayload->securityData = BinToCredJSON(&newCredential); - if (NULL == secPayload->securityData) + newCredential.privateData.data = ""; + newCredential.privateData.len = 0; + newCredential.privateData.encoding = ownerCredential->privateData.encoding; +#ifdef __WITH_X509__ + newCredential.publicData.data = NULL; + newCredential.publicData.len = 0; +#endif + int secureFlag = 0; + //Send owner credential to new device : POST /oic/sec/cred [ owner credential ] + if (OC_STACK_OK != CredToCBORPayload(&newCredential, &secPayload->securityData, + &secPayload->payloadSize, secureFlag)) { OICFree(secPayload); - OIC_LOG(ERROR, TAG, "Error while converting bin to json"); + OIC_LOG(ERROR, TAG, "Error while converting bin to cbor."); return OC_STACK_ERROR; } - OIC_LOG_V(DEBUG, TAG, "Payload : %s", secPayload->securityData); + OIC_LOG(DEBUG, TAG, "Cred Payload:"); + OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize); OCCallbackData cbData; cbData.cb = &OwnerCredentialHandler; cbData.context = (void *)otmCtx; cbData.cd = NULL; - OCStackResult res = OCDoResource(NULL, OC_REST_PUT, query, + OCStackResult res = OCDoResource(NULL, OC_REST_POST, query, &deviceInfo->endpoint, (OCPayload*)secPayload, - deviceInfo->connType, OC_LOW_QOS, &cbData, NULL, 0); + deviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0); if (res != OC_STACK_OK) { OIC_LOG(ERROR, TAG, "OCStack resource error"); @@ -963,14 +1018,14 @@ static OCStackResult PutOwnerCredential(OTMContext_t* otmCtx) return OC_STACK_NO_RESOURCE; } - OIC_LOG(DEBUG, TAG, "OUT PutOwnerCredential"); + OIC_LOG(DEBUG, TAG, "OUT PostOwnerCredential"); return OC_STACK_OK; } -static OCStackResult PutOwnerTransferModeToResource(OTMContext_t* otmCtx) +static OCStackResult PostOwnerTransferModeToResource(OTMContext_t* otmCtx) { - OIC_LOG(DEBUG, TAG, "IN PutOwnerTransferModeToResource"); + OIC_LOG(DEBUG, TAG, "IN PostOwnerTransferModeToResource"); if(!otmCtx || !otmCtx->selectedDeviceInfo) { @@ -987,7 +1042,7 @@ static OCStackResult PutOwnerTransferModeToResource(OTMContext_t* otmCtx) deviceInfo->connType, query, sizeof(query), OIC_RSRC_DOXM_URI)) { - OIC_LOG(ERROR, TAG, "PutOwnerTransferModeToResource : Failed to generate query"); + OIC_LOG(ERROR, TAG, "PostOwnerTransferModeToResource : Failed to generate query"); return OC_STACK_ERROR; } OIC_LOG_V(DEBUG, TAG, "Query=%s", query); @@ -998,11 +1053,12 @@ static OCStackResult PutOwnerTransferModeToResource(OTMContext_t* otmCtx) return OC_STACK_NO_MEMORY; } secPayload->base.type = PAYLOAD_TYPE_SECURITY; - secPayload->securityData = g_OTMDatas[selectedOxm].createSelectOxmPayloadCB(otmCtx); - if (NULL == secPayload->securityData) + OCStackResult res = g_OTMDatas[selectedOxm].createSelectOxmPayloadCB(otmCtx, + &secPayload->securityData, &secPayload->payloadSize); + if (OC_STACK_OK != res && NULL == secPayload->securityData) { - OICFree(secPayload); - OIC_LOG(ERROR, TAG, "Error while converting bin to json"); + OCPayloadDestroy((OCPayload *)secPayload); + OIC_LOG(ERROR, TAG, "Error while converting bin to cbor"); return OC_STACK_ERROR; } @@ -1010,15 +1066,15 @@ static OCStackResult PutOwnerTransferModeToResource(OTMContext_t* otmCtx) cbData.cb = &OwnerTransferModeHandler; cbData.context = (void *)otmCtx; cbData.cd = NULL; - OCStackResult res = OCDoResource(NULL, OC_REST_PUT, query, - &deviceInfo->endpoint, (OCPayload*)secPayload, - deviceInfo->connType, OC_LOW_QOS, &cbData, NULL, 0); + res = OCDoResource(NULL, OC_REST_POST, query, + &deviceInfo->endpoint, (OCPayload *)secPayload, + deviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0); if (res != OC_STACK_OK) { OIC_LOG(ERROR, TAG, "OCStack resource error"); } - OIC_LOG(DEBUG, TAG, "OUT PutOwnerTransferModeToResource"); + OIC_LOG(DEBUG, TAG, "OUT PostOwnerTransferModeToResource"); return res; } @@ -1050,7 +1106,7 @@ static OCStackResult GetProvisioningStatusResource(OTMContext_t* otmCtx) cbData.context = (void *)otmCtx; cbData.cd = NULL; OCStackResult res = OCDoResource(NULL, OC_REST_GET, query, NULL, NULL, - deviceInfo->connType, OC_LOW_QOS, &cbData, NULL, 0); + deviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0); if (res != OC_STACK_OK) { OIC_LOG(ERROR, TAG, "OCStack resource error"); @@ -1061,9 +1117,9 @@ static OCStackResult GetProvisioningStatusResource(OTMContext_t* otmCtx) return res; } -static OCStackResult PutOwnerUuid(OTMContext_t* otmCtx) +static OCStackResult PostOwnerUuid(OTMContext_t* otmCtx) { - OIC_LOG(DEBUG, TAG, "IN PutOwnerUuid"); + OIC_LOG(DEBUG, TAG, "IN PostOwnerUuid"); if(!otmCtx || !otmCtx->selectedDeviceInfo) { @@ -1078,12 +1134,12 @@ static OCStackResult PutOwnerUuid(OTMContext_t* otmCtx) deviceInfo->connType, query, sizeof(query), OIC_RSRC_DOXM_URI)) { - OIC_LOG(ERROR, TAG, "PutOwnershipInformation : Failed to generate query"); + OIC_LOG(ERROR, TAG, "PostOwnerUuid : Failed to generate query"); return OC_STACK_ERROR; } OIC_LOG_V(DEBUG, TAG, "Query=%s", query); - //PUT PT's uuid to new device + //Post PT's uuid to new device OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload)); if(!secPayload) { @@ -1091,36 +1147,36 @@ static OCStackResult PutOwnerUuid(OTMContext_t* otmCtx) return OC_STACK_NO_MEMORY; } secPayload->base.type = PAYLOAD_TYPE_SECURITY; - secPayload->securityData = - g_OTMDatas[deviceInfo->doxm->oxmSel].createOwnerTransferPayloadCB(otmCtx); - if (NULL == secPayload->securityData) + OCStackResult res = g_OTMDatas[deviceInfo->doxm->oxmSel].createOwnerTransferPayloadCB( + otmCtx, &secPayload->securityData, &secPayload->payloadSize); + if (OC_STACK_OK != res && NULL == secPayload->securityData) { - OICFree(secPayload); - OIC_LOG(ERROR, TAG, "Error while converting doxm bin to json"); + OCPayloadDestroy((OCPayload *)secPayload); + OIC_LOG(ERROR, TAG, "Error while converting doxm bin to cbor."); return OC_STACK_INVALID_PARAM; } - OIC_LOG_V(DEBUG, TAG, "Payload : %s", secPayload->securityData); + OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize); OCCallbackData cbData; cbData.cb = &OwnerUuidUpdateHandler; cbData.context = (void *)otmCtx; cbData.cd = NULL; - OCStackResult res = OCDoResource(NULL, OC_REST_PUT, query, 0, (OCPayload*)secPayload, - deviceInfo->connType, OC_LOW_QOS, &cbData, NULL, 0); + res = OCDoResource(NULL, OC_REST_POST, query, 0, (OCPayload *)secPayload, + deviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0); if (res != OC_STACK_OK) { OIC_LOG(ERROR, TAG, "OCStack resource error"); } - OIC_LOG(DEBUG, TAG, "OUT PutOwnerUuid"); + OIC_LOG(DEBUG, TAG, "OUT PostOwnerUuid"); return res; } -static OCStackResult PutOwnershipInformation(OTMContext_t* otmCtx) +static OCStackResult PostOwnershipInformation(OTMContext_t* otmCtx) { - OIC_LOG(DEBUG, TAG, "IN PutOwnershipInformation"); + OIC_LOG(DEBUG, TAG, "IN PostOwnershipInformation"); if(!otmCtx || !otmCtx->selectedDeviceInfo) { @@ -1135,49 +1191,51 @@ static OCStackResult PutOwnershipInformation(OTMContext_t* otmCtx) deviceInfo->connType, query, sizeof(query), OIC_RSRC_DOXM_URI)) { - OIC_LOG(ERROR, TAG, "PutOwnershipInformation : Failed to generate query"); + OIC_LOG(ERROR, TAG, "PostOwnershipInformation : Failed to generate query"); return OC_STACK_ERROR; } OIC_LOG_V(DEBUG, TAG, "Query=%s", query); //OwnershipInformationHandler - OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload)); - if(!secPayload) + OCSecurityPayload *secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload)); + if (!secPayload) { OIC_LOG(ERROR, TAG, "Failed to memory allocation"); return OC_STACK_NO_MEMORY; } otmCtx->selectedDeviceInfo->doxm->owned = true; - secPayload->securityData = BinToDoxmJSON(otmCtx->selectedDeviceInfo->doxm); - if (NULL == secPayload->securityData) + + secPayload->base.type = PAYLOAD_TYPE_SECURITY; + OCStackResult res = DoxmToCBORPayload(otmCtx->selectedDeviceInfo->doxm, + &secPayload->securityData, &secPayload->payloadSize); + if (OC_STACK_OK != res && NULL == secPayload->securityData) { - OICFree(secPayload); + OCPayloadDestroy((OCPayload *)secPayload); OIC_LOG(ERROR, TAG, "Error while converting doxm bin to json"); return OC_STACK_INVALID_PARAM; } - secPayload->base.type = PAYLOAD_TYPE_SECURITY; OCCallbackData cbData; cbData.cb = &OwnershipInformationHandler; cbData.context = (void *)otmCtx; cbData.cd = NULL; - OCStackResult res = OCDoResource(NULL, OC_REST_PUT, query, 0, (OCPayload*)secPayload, - deviceInfo->connType, OC_LOW_QOS, &cbData, NULL, 0); + res = OCDoResource(NULL, OC_REST_POST, query, 0, (OCPayload*)secPayload, + deviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0); if (res != OC_STACK_OK) { OIC_LOG(ERROR, TAG, "OCStack resource error"); } - OIC_LOG(DEBUG, TAG, "OUT PutOwnershipInformation"); + OIC_LOG(DEBUG, TAG, "OUT PostOwnershipInformation"); return res; } -static OCStackResult PutUpdateOperationMode(OTMContext_t* otmCtx) +static OCStackResult PostUpdateOperationMode(OTMContext_t* otmCtx) { - OIC_LOG(DEBUG, TAG, "IN PutUpdateOperationMode"); + OIC_LOG(DEBUG, TAG, "IN PostUpdateOperationMode"); if(!otmCtx || !otmCtx->selectedDeviceInfo) { @@ -1191,7 +1249,7 @@ static OCStackResult PutUpdateOperationMode(OTMContext_t* otmCtx) deviceInfo->connType, query, sizeof(query), OIC_RSRC_PSTAT_URI)) { - OIC_LOG(ERROR, TAG, "PutUpdateOperationMode : Failed to generate query"); + OIC_LOG(ERROR, TAG, "PostUpdateOperationMode : Failed to generate query"); return OC_STACK_ERROR; } OIC_LOG_V(DEBUG, TAG, "Query=%s", query); @@ -1203,9 +1261,8 @@ static OCStackResult PutUpdateOperationMode(OTMContext_t* otmCtx) return OC_STACK_NO_MEMORY; } secPayload->base.type = PAYLOAD_TYPE_SECURITY; - size_t size = 0; - OCStackResult res = PstatToCBORPayload(deviceInfo->pstat, &secPayload->securityData1, - &size); + OCStackResult res = PstatToCBORPayload(deviceInfo->pstat, &secPayload->securityData, + &secPayload->payloadSize); if (OC_STACK_OK != res) { OCPayloadDestroy((OCPayload *)secPayload); @@ -1217,14 +1274,14 @@ static OCStackResult PutUpdateOperationMode(OTMContext_t* otmCtx) cbData.cb = &OperationModeUpdateHandler; cbData.context = (void *)otmCtx; cbData.cd = NULL; - res = OCDoResource(NULL, OC_REST_PUT, query, 0, (OCPayload*)secPayload, - deviceInfo->connType, OC_LOW_QOS, &cbData, NULL, 0); + res = OCDoResource(NULL, OC_REST_POST, query, 0, (OCPayload *)secPayload, + deviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0); if (res != OC_STACK_OK) { OIC_LOG(ERROR, TAG, "OCStack resource error"); } - OIC_LOG(DEBUG, TAG, "OUT PutUpdateOperationMode"); + OIC_LOG(DEBUG, TAG, "OUT PostUpdateOperationMode"); return res; } @@ -1247,8 +1304,8 @@ static OCStackResult StartOwnershipTransfer(void* ctx, OCProvisionDev_t* selecte } OIC_LOG_V(DEBUG, TAG, "Selected provisoning method = %d", selectedDevice->doxm->oxmSel); - //Send Req: PUT /oic/sec/doxm [{..."OxmSel" :g_OTMDatas[Index of Selected OxM].OXMString,...}] - res = PutOwnerTransferModeToResource(otmCtx); + //Send Req: POST /oic/sec/doxm [{..."OxmSel" :g_OTMDatas[Index of Selected OxM].OXMString,...}] + res = PostOwnerTransferModeToResource(otmCtx); if(OC_STACK_OK != res) { OIC_LOG(WARNING, TAG, "Failed to select the provisioning method"); @@ -1375,41 +1432,92 @@ error: return res; } -OCStackResult PutProvisioningStatus(OTMContext_t* otmCtx) +OCStackResult PostProvisioningStatus(OTMContext_t* otmCtx) { - OIC_LOG(INFO, TAG, "IN PutProvisioningStatus"); + OIC_LOG(INFO, TAG, "IN PostProvisioningStatus"); - if(!otmCtx) + if(!otmCtx || !otmCtx->selectedDeviceInfo) { OIC_LOG(ERROR, TAG, "OTMContext is NULL"); return OC_STACK_INVALID_PARAM; } - if(!otmCtx->selectedDeviceInfo) + + //Change the TAKE_OWNER bit of CM to 0. + otmCtx->selectedDeviceInfo->pstat->cm &= (~TAKE_OWNER); + + OCSecurityPayload *secPayload = (OCSecurityPayload *)OICCalloc(1, sizeof(OCSecurityPayload)); + if (!secPayload) { - OIC_LOG(ERROR, TAG, "Can't find device information in OTMContext"); - OICFree(otmCtx); + OIC_LOG(ERROR, TAG, "Failed to memory allocation"); + return OC_STACK_NO_MEMORY; + } + secPayload->base.type = PAYLOAD_TYPE_SECURITY; + if (OC_STACK_OK != PstatToCBORPayload(otmCtx->selectedDeviceInfo->pstat, + &secPayload->securityData, &secPayload->payloadSize)) + { + OCPayloadDestroy((OCPayload *)secPayload); + return OC_STACK_INVALID_JSON; + } + OIC_LOG(DEBUG, TAG, "Created payload for chage to Provisiong state"); + OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize); + + char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0}; + if(!PMGenerateQuery(true, + otmCtx->selectedDeviceInfo->endpoint.addr, + otmCtx->selectedDeviceInfo->securePort, + otmCtx->selectedDeviceInfo->connType, + query, sizeof(query), OIC_RSRC_PSTAT_URI)) + { + OIC_LOG(ERROR, TAG, "PostProvisioningStatus : Failed to generate query"); + return OC_STACK_ERROR; + } + OIC_LOG_V(DEBUG, TAG, "Query=%s", query); + + OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL}; + cbData.cb = &ProvisioningStatusHandler; + cbData.context = (void*)otmCtx; + cbData.cd = NULL; + OCStackResult ret = OCDoResource(NULL, OC_REST_POST, query, 0, (OCPayload*)secPayload, + otmCtx->selectedDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0); + OIC_LOG_V(INFO, TAG, "OCDoResource returned: %d",ret); + if (ret != OC_STACK_OK) + { + OIC_LOG(ERROR, TAG, "OCStack resource error"); + } + + OIC_LOG(INFO, TAG, "OUT PostProvisioningStatus"); + + return ret; +} + +OCStackResult PostNormalOperationStatus(OTMContext_t* otmCtx) +{ + OIC_LOG(INFO, TAG, "IN PostNormalOperationStatus"); + + if(!otmCtx || !otmCtx->selectedDeviceInfo) + { + OIC_LOG(ERROR, TAG, "OTMContext is NULL"); return OC_STACK_INVALID_PARAM; } - otmCtx->selectedDeviceInfo->pstat->tm = NORMAL; - otmCtx->selectedDeviceInfo->pstat->cm = PROVISION_ACLS | PROVISION_CREDENTIALS | - SECURITY_MANAGEMENT_SERVICES | BOOTSTRAP_SERVICE; - OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload)); - if(!secPayload) + //Set isop to true. + otmCtx->selectedDeviceInfo->pstat->isOp = true; + + OCSecurityPayload *secPayload = (OCSecurityPayload *)OICCalloc(1, sizeof(OCSecurityPayload)); + if (!secPayload) { OIC_LOG(ERROR, TAG, "Failed to memory allocation"); return OC_STACK_NO_MEMORY; } secPayload->base.type = PAYLOAD_TYPE_SECURITY; - size_t size = 0; if (OC_STACK_OK != PstatToCBORPayload(otmCtx->selectedDeviceInfo->pstat, - &secPayload->securityData1, &size)) + &secPayload->securityData, &secPayload->payloadSize)) { OCPayloadDestroy((OCPayload *)secPayload); - SetResult(otmCtx, OC_STACK_INVALID_JSON); return OC_STACK_INVALID_JSON; } - OIC_LOG_V(INFO, TAG, "Created payload for commit hash: %s",secPayload->securityData1); + OIC_LOG(DEBUG, TAG, "Created payload for chage to Provisiong state"); + OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize); char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0}; if(!PMGenerateQuery(true, @@ -1418,25 +1526,24 @@ OCStackResult PutProvisioningStatus(OTMContext_t* otmCtx) otmCtx->selectedDeviceInfo->connType, query, sizeof(query), OIC_RSRC_PSTAT_URI)) { - OIC_LOG(ERROR, TAG, "PutProvisioningStatus : Failed to generate query"); + OIC_LOG(ERROR, TAG, "PostNormalOperationStatus : Failed to generate query"); return OC_STACK_ERROR; } OIC_LOG_V(DEBUG, TAG, "Query=%s", query); OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL}; - cbData.cb = &ProvisioningStatusHandler; + cbData.cb = &ReadyForNomalStatusHandler; cbData.context = (void*)otmCtx; cbData.cd = NULL; - OCStackResult ret = OCDoResource(NULL, OC_REST_PUT, query, 0, (OCPayload*)secPayload, + OCStackResult ret = OCDoResource(NULL, OC_REST_POST, query, 0, (OCPayload*)secPayload, otmCtx->selectedDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0); OIC_LOG_V(INFO, TAG, "OCDoResource returned: %d",ret); if (ret != OC_STACK_OK) { OIC_LOG(ERROR, TAG, "OCStack resource error"); - SetResult(otmCtx, ret); } - OIC_LOG(INFO, TAG, "OUT PutProvisioningStatus"); + OIC_LOG(INFO, TAG, "OUT PostNormalOperationStatus"); return ret; }