X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=resource%2Fcsdk%2Fsecurity%2Fprovisioning%2Fsrc%2Fownershiptransfermanager.c;h=0c2ff43b8d1dede83dad6907cdd82b5809166828;hb=153cb2647598cbff08e50f9eccdc480b7f59c745;hp=6ac1ff0432200289d8ebf58ffb4a2c20beac06d5;hpb=9b1951d39e268acff49e5ed00887ca6eaf62cb34;p=platform%2Fupstream%2Fiotivity.git diff --git a/resource/csdk/security/provisioning/src/ownershiptransfermanager.c b/resource/csdk/security/provisioning/src/ownershiptransfermanager.c old mode 100755 new mode 100644 index 6ac1ff0..0c2ff43 --- a/resource/csdk/security/provisioning/src/ownershiptransfermanager.c +++ b/resource/csdk/security/provisioning/src/ownershiptransfermanager.c @@ -58,6 +58,8 @@ #include "srmutility.h" #include "provisioningdatabasemanager.h" #include "oxmrandompin.h" +#include "ocpayload.h" +#include "payload_logging.h" #define TAG "OTM" @@ -67,35 +69,9 @@ 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. + * Variables for pointing the OTMContext to be used in the DTLS handshake result callback. */ -static OicSecDpom_t gProvisioningToolCapability[] = { SINGLE_SERVICE_CLIENT_DRIVEN }; - -/** - * Number of supported provisioning methods - * current version supports only one. - */ -static size_t gNumOfProvisioningMethodsPT = 1; - -/** - * Function to getting string of ownership transfer method - */ -static const char* GetOxmString(OicSecOxm_t oxmType) -{ - switch(oxmType) - { - case OIC_JUST_WORKS: - return OXM_JUST_WORKS; - case OIC_RANDOM_DEVICE_PIN: - return OXM_RANDOM_DEVICE_PIN; - case OIC_MANUFACTURER_CERTIFICATE: - return OXM_MANUFACTURER_CERTIFICATE; - default: - return NULL; - } -} +static OTMContext_t* g_otmCtx = NULL; /** * Function to select appropriate provisioning method. @@ -106,14 +82,13 @@ static const char* GetOxmString(OicSecOxm_t oxmType) * @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) { - OC_LOG(DEBUG, TAG, "IN SelectProvisioningMethod"); + OIC_LOG(DEBUG, TAG, "IN SelectProvisioningMethod"); if(numberOfMethods == 0 || !supportedMethods) { - OC_LOG(WARNING, TAG, "Could not find a supported OxM."); + OIC_LOG(WARNING, TAG, "Could not find a supported OxM."); return OC_STACK_ERROR; } @@ -139,37 +114,29 @@ static OCStackResult SelectProvisioningMethod(const OicSecOxm_t *supportedMethod static void SelectOperationMode(const OCProvisionDev_t *selectedDeviceInfo, OicSecDpom_t *selectedMode) { - OC_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; - } - } - OC_LOG(DEBUG, TAG, "OUT SelectOperationMode"); + OIC_LOG(DEBUG, TAG, "IN SelectOperationMode"); + *selectedMode = selectedDeviceInfo->pstat->sm[0]; + OIC_LOG_V(DEBUG, TAG, "Selected Operation Mode = %d", *selectedMode); } /** + * Function to start ownership transfer. + * This function will send the first request for provisioning, + * The next request message is sent from the response handler for this request. + * + * @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 StartOwnershipTransfer(void* ctx, OCProvisionDev_t* selectedDevice); + +/** * Function to update owner transfer mode * * @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. @@ -181,45 +148,60 @@ static OCStackResult GetProvisioningStatusResource(OTMContext_t* otmCtx); /** - * Function to send ownerShip info. This function would update Owned as true and - * owner as UUID for provisioning tool + * Function to send uuid of owner device to new device. + * This function would update 'owner of doxm' as UUID for provisioning tool. * * @param[in] otmCtx Context value of ownership transfer. * @return OC_STACK_OK on success */ -static OCStackResult PutOwnershipInformation(OTMContext_t* otmCtx); +static OCStackResult PostOwnerUuid(OTMContext_t* otmCtx); /** * Function to update the operation mode. As per the spec. Operation mode in client driven * single service provisioning it will be updated to 0x3 * * @param[in] otmCtx Context value of ownership transfer. + * @return OC_STACK_OK on success + */ +static OCStackResult PostUpdateOperationMode(OTMContext_t* otmCtx); + +/** + * Function to update the owner credential to new device + * + * @param[in] otmCtx Context value of ownership transfer. * @param[in] selectedOperationMode selected operation mode * @return OC_STACK_OK on success */ -static OCStackResult PutUpdateOperationMode(OTMContext_t* otmCtx, - OicSecDpom_t selectedOperationMode); +static OCStackResult PutOwnerCredential(OTMContext_t* otmCtx); /** - * Function to start ownership transfer. - * This function will send the first request for provisioning, - * The next request message is sent from the response handler for this request. + * Function to send ownerShip info. + * This function would update 'owned of doxm' as true. + * + * @param[in] otmCtx Context value of ownership transfer. + * @return OC_STACK_OK on success + */ +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 StartOwnershipTransfer(void* ctx, OCProvisionDev_t* selectedDevice); +static OCStackResult PostProvisioningStatus(OTMContext_t* otmCtx); -/* - * Function to finalize provisioning. - * This function will send default ACL and commit hash. +/** + * Function to update pstat as Ready for Normal Operation. + * This function would update 'isop' from false to true. * - * @param[in] otmCtx Context value of ownership transfer. + * @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 FinalizeProvisioning(OTMContext_t* otmCtx); - +static OCStackResult PostNormalOperationStatus(OTMContext_t* otmCtx); static bool IsComplete(OTMContext_t* otmCtx) { @@ -242,16 +224,27 @@ static bool IsComplete(OTMContext_t* otmCtx) */ static void SetResult(OTMContext_t* otmCtx, const OCStackResult res) { - OC_LOG(DEBUG, TAG, "IN SetResult"); + OIC_LOG_V(DEBUG, TAG, "IN SetResult : %d ", res); if(!otmCtx) { - OC_LOG(WARNING, TAG, "OTMContext is NULL"); + OIC_LOG(WARNING, TAG, "OTMContext is NULL"); return; } if(otmCtx->selectedDeviceInfo) { + //Revert psk_info callback and new deivce uuid in case of random PIN OxM + if(OIC_RANDOM_DEVICE_PIN == otmCtx->selectedDeviceInfo->doxm->oxmSel) + { + if(CA_STATUS_OK != CARegisterDTLSCredentialsHandler(GetDtlsPskCredentials)) + { + OIC_LOG(WARNING, TAG, "Failed to revert is DTLS credential handler."); + } + OicUuid_t emptyUuid = { .id={0}}; + SetUuidForRandomPinOxm(&emptyUuid); + } + for(size_t i = 0; i < otmCtx->ctxResultArraySize; i++) { if(memcmp(otmCtx->selectedDeviceInfo->doxm->deviceID.id, @@ -265,6 +258,8 @@ static void SetResult(OTMContext_t* otmCtx, const OCStackResult res) } } + g_otmCtx = NULL; + //If all request is completed, invoke the user callback. if(IsComplete(otmCtx)) { @@ -278,14 +273,105 @@ static void SetResult(OTMContext_t* otmCtx, const OCStackResult res) if(OC_STACK_OK != StartOwnershipTransfer(otmCtx, otmCtx->selectedDeviceInfo->next)) { - OC_LOG(ERROR, TAG, "Failed to StartOwnershipTransfer"); + OIC_LOG(ERROR, TAG, "Failed to StartOwnershipTransfer"); } } } - OC_LOG(DEBUG, TAG, "OUT SetResult"); + OIC_LOG(DEBUG, TAG, "OUT SetResult"); } +/** + * Function to handle the handshake result in OTM. + * This function will be invoked after DTLS handshake + * @param endPoint [IN] The remote endpoint. + * @param errorInfo [IN] Error information from the endpoint. + * @return NONE + */ +void DTLSHandshakeCB(const CAEndpoint_t *endpoint, const CAErrorInfo_t *info) +{ + if(NULL != g_otmCtx && NULL != g_otmCtx->selectedDeviceInfo && + NULL != endpoint && NULL != info) + { + OIC_LOG_V(INFO, TAG, "Received status from remote device(%s:%d) : %d", + endpoint->addr, endpoint->port, info->result); + + OicSecDoxm_t* newDevDoxm = g_otmCtx->selectedDeviceInfo->doxm; + + if(NULL != newDevDoxm) + { + OicUuid_t emptyUuid = {.id={0}}; + + //Make sure the address matches. + if(strncmp(g_otmCtx->selectedDeviceInfo->endpoint.addr, + endpoint->addr, + sizeof(endpoint->addr)) == 0 && + g_otmCtx->selectedDeviceInfo->securePort == endpoint->port) + { + OCStackResult res = OC_STACK_ERROR; + + //If temporal secure sesstion established successfully + if(CA_STATUS_OK == info->result && + false == newDevDoxm->owned && + memcmp(&(newDevDoxm->owner), &emptyUuid, sizeof(OicUuid_t)) == 0) + { + //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"); + SetResult(g_otmCtx, res); + } + } + //In case of authentication failure + else if(CA_DTLS_AUTHENTICATION_FAILURE == info->result) + { + //in case of error from owner credential + if(memcmp(&(newDevDoxm->owner), &emptyUuid, sizeof(OicUuid_t)) != 0 && + true == newDevDoxm->owned) + { + OIC_LOG(ERROR, TAG, "The owner credential may incorrect."); + + if(OC_STACK_OK != RemoveCredential(&(newDevDoxm->deviceID))) + { + OIC_LOG(WARNING, TAG, "Failed to remove the invaild owner credential"); + } + SetResult(g_otmCtx, OC_STACK_AUTHENTICATION_FAILURE); + } + //in case of error from wrong PIN, re-start the ownership transfer + else if(OIC_RANDOM_DEVICE_PIN == newDevDoxm->oxmSel) + { + OIC_LOG(ERROR, TAG, "The PIN number may incorrect."); + + memcpy(&(newDevDoxm->owner), &emptyUuid, sizeof(OicUuid_t)); + newDevDoxm->owned = false; + g_otmCtx->attemptCnt++; + + if(WRONG_PIN_MAX_ATTEMP > g_otmCtx->attemptCnt) + { + res = StartOwnershipTransfer(g_otmCtx, g_otmCtx->selectedDeviceInfo); + if(OC_STACK_OK != res) + { + SetResult(g_otmCtx, res); + OIC_LOG(ERROR, TAG, "Failed to Re-StartOwnershipTransfer"); + } + } + else + { + OIC_LOG(ERROR, TAG, "User has exceeded the number of authentication attempts."); + SetResult(g_otmCtx, OC_STACK_AUTHENTICATION_FAILURE); + } + } + else + { + OIC_LOG(ERROR, TAG, "Failed to establish secure session."); + SetResult(g_otmCtx, OC_STACK_AUTHENTICATION_FAILURE); + } + } + } + } + } +} /** * Function to save ownerPSK at provisioning tool end. @@ -295,7 +381,7 @@ static void SetResult(OTMContext_t* otmCtx, const OCStackResult res) */ static OCStackResult SaveOwnerPSK(OCProvisionDev_t *selectedDeviceInfo) { - OC_LOG(DEBUG, TAG, "IN SaveOwnerPSK"); + OIC_LOG(DEBUG, TAG, "IN SaveOwnerPSK"); OCStackResult res = OC_STACK_ERROR; @@ -308,38 +394,53 @@ static OCStackResult SaveOwnerPSK(OCProvisionDev_t *selectedDeviceInfo) OicUuid_t ptDeviceID = {.id={0}}; if (OC_STACK_OK != GetDoxmDeviceID(&ptDeviceID)) { - OC_LOG(ERROR, TAG, "Error while retrieving provisioning tool's device ID"); + OIC_LOG(ERROR, TAG, "Error while retrieving provisioning tool's device ID"); return res; } uint8_t ownerPSK[OWNER_PSK_LENGTH_128] = {0}; + OicSecKey_t ownerKey = {ownerPSK, OWNER_PSK_LENGTH_128}; //Generating OwnerPSK CAResult_t pskRet = CAGenerateOwnerPSK(&endpoint, (uint8_t *)GetOxmString(selectedDeviceInfo->doxm->oxmSel), - strlen(GetOxmString(selectedDeviceInfo->doxm->oxmSel)), ptDeviceID.id, - sizeof(ptDeviceID.id), selectedDeviceInfo->doxm->deviceID.id, - sizeof(selectedDeviceInfo->doxm->deviceID.id), ownerPSK, - OWNER_PSK_LENGTH_128); + strlen(GetOxmString(selectedDeviceInfo->doxm->oxmSel)), + ptDeviceID.id, sizeof(ptDeviceID.id), + selectedDeviceInfo->doxm->deviceID.id, sizeof(selectedDeviceInfo->doxm->deviceID.id), + ownerPSK, OWNER_PSK_LENGTH_128); if (CA_STATUS_OK == pskRet) { - OC_LOG(INFO, TAG,"ownerPSK dump:\n"); - OC_LOG_BUFFER(INFO, TAG,ownerPSK, OWNER_PSK_LENGTH_128); + 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) { @@ -349,10 +450,10 @@ static OCStackResult SaveOwnerPSK(OCProvisionDev_t *selectedDeviceInfo) } else { - OC_LOG(ERROR, TAG, "CAGenerateOwnerPSK failed"); + OIC_LOG(ERROR, TAG, "CAGenerateOwnerPSK failed"); } - OC_LOG(DEBUG, TAG, "OUT SaveOwnerPSK"); + OIC_LOG(DEBUG, TAG, "OUT SaveOwnerPSK"); exit: return res; } @@ -369,7 +470,7 @@ exit: static OCStackApplicationResult OwnerTransferModeHandler(void *ctx, OCDoHandle UNUSED, OCClientResponse *clientResponse) { - OC_LOG(DEBUG, TAG, "IN OwnerTransferModeHandler"); + OIC_LOG(DEBUG, TAG, "IN OwnerTransferModeHandler"); VERIFY_NON_NULL(TAG, clientResponse, WARNING); VERIFY_NON_NULL(TAG, ctx, WARNING); @@ -378,23 +479,23 @@ static OCStackApplicationResult OwnerTransferModeHandler(void *ctx, OCDoHandle U (void)UNUSED; if(clientResponse->result == OC_STACK_OK) { - OC_LOG(INFO, TAG, "OwnerTransferModeHandler : response result = OC_STACK_OK"); + OIC_LOG(INFO, TAG, "OwnerTransferModeHandler : response result = OC_STACK_OK"); //Send request : GET /oic/sec/pstat OCStackResult res = GetProvisioningStatusResource(otmCtx); if(OC_STACK_OK != res) { - OC_LOG(WARNING, TAG, "Failed to get pstat information"); + OIC_LOG(WARNING, TAG, "Failed to get pstat information"); SetResult(otmCtx, res); } } else { - OC_LOG_V(WARNING, TAG, "OwnerTransferModeHandler : Client response is incorrect : %d", + OIC_LOG_V(WARNING, TAG, "OwnerTransferModeHandler : Client response is incorrect : %d", clientResponse->result); SetResult(otmCtx, clientResponse->result); } - OC_LOG(DEBUG, TAG, "OUT OwnerTransferModeHandler"); + OIC_LOG(DEBUG, TAG, "OUT OwnerTransferModeHandler"); exit: return OC_STACK_DELETE_TRANSACTION; @@ -412,7 +513,7 @@ exit: static OCStackApplicationResult ListMethodsHandler(void *ctx, OCDoHandle UNUSED, OCClientResponse *clientResponse) { - OC_LOG(DEBUG, TAG, "IN ListMethodsHandler"); + OIC_LOG(DEBUG, TAG, "IN ListMethodsHandler"); VERIFY_NON_NULL(TAG, clientResponse, WARNING); VERIFY_NON_NULL(TAG, ctx, WARNING); @@ -423,54 +524,61 @@ static OCStackApplicationResult ListMethodsHandler(void *ctx, OCDoHandle UNUSED, { if (NULL == clientResponse->payload) { - OC_LOG(INFO, TAG, "Skiping Null payload"); + OIC_LOG(INFO, TAG, "Skiping Null payload"); SetResult(otmCtx, OC_STACK_ERROR); return OC_STACK_DELETE_TRANSACTION; } if (PAYLOAD_TYPE_SECURITY != clientResponse->payload->type) { - OC_LOG(INFO, TAG, "Unknown payload type"); + OIC_LOG(INFO, TAG, "Unknown payload type"); SetResult(otmCtx, OC_STACK_ERROR); return OC_STACK_DELETE_TRANSACTION; } - - OicSecPstat_t* pstat = JSONToPstatBin( - ((OCSecurityPayload*)clientResponse->payload)->securityData); - if(NULL == pstat) + OicSecPstat_t* pstat = NULL; + OCStackResult result = CBORPayloadToPstat( + ((OCSecurityPayload*)clientResponse->payload)->securityData, + ((OCSecurityPayload*)clientResponse->payload)->payloadSize, + &pstat); + if(NULL == pstat || result != OC_STACK_OK) { - OC_LOG(ERROR, TAG, "Error while converting json to pstat bin"); + 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) - OicSecDpom_t selectedOperationMode; - SelectOperationMode(otmCtx->selectedDeviceInfo, &selectedOperationMode); + SelectOperationMode(otmCtx->selectedDeviceInfo, &(otmCtx->selectedDeviceInfo->pstat->om)); - //Send request : PUT /oic/sec/pstat [{"OM":"0x11", .. }] - OCStackResult res = PutUpdateOperationMode(otmCtx, selectedOperationMode); + //Send request : POST /oic/sec/pstat [{"om":"bx11", .. }] + OCStackResult res = PostUpdateOperationMode(otmCtx); if (OC_STACK_OK != res) { - OC_LOG(ERROR, TAG, "Error while updating operation mode."); + OIC_LOG(ERROR, TAG, "Error while updating operation mode."); SetResult(otmCtx, res); } } else { - OC_LOG_V(WARNING, TAG, "ListMethodsHandler : Client response is incorrect : %d", + OIC_LOG_V(WARNING, TAG, "ListMethodsHandler : Client response is incorrect : %d", clientResponse->result); SetResult(otmCtx, clientResponse->result); } - OC_LOG(DEBUG, TAG, "OUT ListMethodsHandler"); + OIC_LOG(DEBUG, TAG, "OUT ListMethodsHandler"); exit: return OC_STACK_DELETE_TRANSACTION; } /** - * Callback handler for OwnershipInformationHandler API. + * Response handler for update owner uuid request. * * @param[in] ctx ctx value passed to callback from calling function. * @param[in] UNUSED handle to an invocation @@ -478,73 +586,48 @@ exit: * @return OC_STACK_DELETE_TRANSACTION to delete the transaction * and OC_STACK_KEEP_TRANSACTION to keep it. */ -static OCStackApplicationResult OwnershipInformationHandler(void *ctx, OCDoHandle UNUSED, +static OCStackApplicationResult OwnerUuidUpdateHandler(void *ctx, OCDoHandle UNUSED, OCClientResponse *clientResponse) { VERIFY_NON_NULL(TAG, clientResponse, WARNING); VERIFY_NON_NULL(TAG, ctx, WARNING); - OC_LOG(DEBUG, TAG, "IN OwnershipInformationHandler"); + OIC_LOG(DEBUG, TAG, "IN OwnerUuidUpdateHandler"); (void)UNUSED; OCStackResult res = OC_STACK_OK; OTMContext_t* otmCtx = (OTMContext_t*)ctx; - if (OC_STACK_OK == clientResponse->result) + + if(OC_STACK_OK == clientResponse->result) { - if(OIC_RANDOM_DEVICE_PIN == otmCtx->selectedDeviceInfo->doxm->oxmSel) + if(otmCtx && otmCtx->selectedDeviceInfo) { - res = RemoveCredential(&otmCtx->subIdForPinOxm); - if(OC_STACK_RESOURCE_DELETED != res) + res = SaveOwnerPSK(otmCtx->selectedDeviceInfo); + if(OC_STACK_OK != res) { - OC_LOG_V(ERROR, TAG, "Failed to remove temporal PSK : %d", res); + OIC_LOG(ERROR, TAG, "OwnerUuidUpdateHandler:Failed to owner PSK generation"); + SetResult(otmCtx, res); return OC_STACK_DELETE_TRANSACTION; } - } - - res = SaveOwnerPSK(otmCtx->selectedDeviceInfo); - if(OC_STACK_OK != res) - { - OC_LOG(ERROR, TAG, "OperationModeUpdate : Failed to owner PSK generation"); - SetResult(otmCtx, res); - return OC_STACK_DELETE_TRANSACTION; - } - - CAEndpoint_t* endpoint = (CAEndpoint_t *)&otmCtx->selectedDeviceInfo->endpoint; - endpoint->port = otmCtx->selectedDeviceInfo->securePort; - CAResult_t caResult = CACloseDtlsSession(endpoint); - if(CA_STATUS_OK != caResult) - { - OC_LOG(ERROR, TAG, "Failed to close DTLS session"); - SetResult(otmCtx, caResult); - return OC_STACK_DELETE_TRANSACTION; - } - - /** - * If we select NULL cipher, - * client will select appropriate cipher suite according to server's cipher-suite list. - */ - caResult = CASelectCipherSuite(TLS_NULL_WITH_NULL_NULL); - if(CA_STATUS_OK != caResult) - { - OC_LOG(ERROR, TAG, "Failed to select TLS_NULL_WITH_NULL_NULL"); - SetResult(otmCtx, caResult); - return OC_STACK_DELETE_TRANSACTION; - } - - OC_LOG(INFO, TAG, "Ownership transfer was successfully completed."); - OC_LOG(INFO, TAG, "Start defualt ACL & commit-hash provisioning."); - res = FinalizeProvisioning(otmCtx); - if(OC_STACK_OK != res) - { - SetResult(otmCtx, res); + //PUT owner credential to new device according to security spec B. + res = PutOwnerCredential(otmCtx); + if(OC_STACK_OK != res) + { + OIC_LOG(ERROR, TAG, + "OwnerUuidUpdateHandler:Failed to send PUT request for onwer credential"); + SetResult(otmCtx, res); + return OC_STACK_DELETE_TRANSACTION; + } } } else { res = clientResponse->result; + OIC_LOG_V(ERROR, TAG, "OwnerUuidHandler : Unexpected result %d", res); + SetResult(otmCtx, res); } - OC_LOG(DEBUG, TAG, "OUT OwnershipInformationHandler"); + OIC_LOG(DEBUG, TAG, "OUT OwnerUuidUpdateHandler"); exit: return OC_STACK_DELETE_TRANSACTION; @@ -562,7 +645,7 @@ exit: static OCStackApplicationResult OperationModeUpdateHandler(void *ctx, OCDoHandle UNUSED, OCClientResponse *clientResponse) { - OC_LOG(DEBUG, TAG, "IN OperationModeUpdateHandler"); + OIC_LOG(DEBUG, TAG, "IN OperationModeUpdateHandler"); VERIFY_NON_NULL(TAG, clientResponse, WARNING); VERIFY_NON_NULL(TAG, ctx, WARNING); @@ -580,52 +663,367 @@ static OCStackApplicationResult OperationModeUpdateHandler(void *ctx, OCDoHandle res = g_OTMDatas[selOxm].loadSecretCB(otmCtx); if(OC_STACK_OK != res) { - OC_LOG(ERROR, TAG, "OperationModeUpdate : Failed to load secret"); + OIC_LOG(ERROR, TAG, "OperationModeUpdate : Failed to load secret"); SetResult(otmCtx, res); return OC_STACK_DELETE_TRANSACTION; } } + //It will be used in handshake event handler + g_otmCtx = otmCtx; + //Try DTLS handshake to generate secure session if(g_OTMDatas[selOxm].createSecureSessionCB) { res = g_OTMDatas[selOxm].createSecureSessionCB(otmCtx); if(OC_STACK_OK != res) { - OC_LOG(ERROR, TAG, "OperationModeUpdate : Failed to create DTLS session"); + OIC_LOG(ERROR, TAG, "OperationModeUpdate : Failed to create DTLS session"); SetResult(otmCtx, res); return OC_STACK_DELETE_TRANSACTION; } } + } + else + { + OIC_LOG(ERROR, TAG, "Error while update operation mode"); + SetResult(otmCtx, clientResponse->result); + } - //Send request : PUT /oic/sec/doxm [{"Owned":"True", .. , "Owner":"PT's UUID"}] - res = PutOwnershipInformation(otmCtx); - if(OC_STACK_OK != res) + OIC_LOG(DEBUG, TAG, "OUT OperationModeUpdateHandler"); + +exit: + return OC_STACK_DELETE_TRANSACTION; +} + +/** + * Response handler for update owner crendetial request. + * + * @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 OwnerCredentialHandler(void *ctx, OCDoHandle UNUSED, + OCClientResponse *clientResponse) +{ + VERIFY_NON_NULL(TAG, clientResponse, WARNING); + VERIFY_NON_NULL(TAG, ctx, WARNING); + + OIC_LOG(DEBUG, TAG, "IN OwnerCredentialHandler"); + (void)UNUSED; + OCStackResult res = OC_STACK_OK; + OTMContext_t* otmCtx = (OTMContext_t*)ctx; + + if(OC_STACK_RESOURCE_CREATED == clientResponse->result) + { + if(otmCtx && otmCtx->selectedDeviceInfo) { - OC_LOG(ERROR, TAG, "OperationModeUpdate : Failed to send owner information"); - SetResult(otmCtx, res); + //Close the temporal secure session to verify the owner credential + CAEndpoint_t* endpoint = (CAEndpoint_t *)&otmCtx->selectedDeviceInfo->endpoint; + endpoint->port = otmCtx->selectedDeviceInfo->securePort; + CAResult_t caResult = CACloseDtlsSession(endpoint); + if(CA_STATUS_OK != caResult) + { + OIC_LOG(ERROR, TAG, "Failed to close DTLS session"); + SetResult(otmCtx, caResult); + return OC_STACK_DELETE_TRANSACTION; + } + + /** + * If we select NULL cipher, + * client will select appropriate cipher suite according to server's cipher-suite list. + */ + caResult = CASelectCipherSuite(TLS_NULL_WITH_NULL_NULL); + if(CA_STATUS_OK != caResult) + { + OIC_LOG(ERROR, TAG, "Failed to select TLS_NULL_WITH_NULL_NULL"); + SetResult(otmCtx, caResult); + return OC_STACK_DELETE_TRANSACTION; + } + + /** + * in case of random PIN based OxM, + * revert get_psk_info callback of tinyDTLS to use owner credential. + */ + if(OIC_RANDOM_DEVICE_PIN == otmCtx->selectedDeviceInfo->doxm->oxmSel) + { + OicUuid_t emptyUuid = { .id={0}}; + SetUuidForRandomPinOxm(&emptyUuid); + + if(CA_STATUS_OK != CARegisterDTLSCredentialsHandler(GetDtlsPskCredentials)) + { + OIC_LOG(ERROR, TAG, "Failed to revert DTLS credential handler."); + SetResult(otmCtx, OC_STACK_INVALID_CALLBACK); + return OC_STACK_DELETE_TRANSACTION; + } + } + + //POST /oic/sec/doxm [{ ..., "owned":"TRUE" }] + res = PostOwnershipInformation(otmCtx); + if(OC_STACK_OK != res) + { + OIC_LOG(ERROR, TAG, "Failed to post ownership information to new device"); + SetResult(otmCtx, res); + return OC_STACK_DELETE_TRANSACTION; + } } } else { - OC_LOG(ERROR, TAG, "Error while update operation mode"); - SetResult(otmCtx, clientResponse->result); + res = clientResponse->result; + OIC_LOG_V(ERROR, TAG, "OwnerCredentialHandler : Unexpected result %d", res); + SetResult(otmCtx, res); + } + + OIC_LOG(DEBUG, TAG, "OUT OwnerCredentialHandler"); + +exit: + return OC_STACK_DELETE_TRANSACTION; +} + + +/** + * Response handler for update owner information request. + * + * @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 OwnershipInformationHandler(void *ctx, OCDoHandle UNUSED, + OCClientResponse *clientResponse) +{ + VERIFY_NON_NULL(TAG, clientResponse, WARNING); + VERIFY_NON_NULL(TAG, ctx, WARNING); + + OIC_LOG(DEBUG, TAG, "IN OwnershipInformationHandler"); + (void)UNUSED; + OCStackResult res = OC_STACK_OK; + OTMContext_t* otmCtx = (OTMContext_t*)ctx; + + if(OC_STACK_OK == clientResponse->result) + { + if(otmCtx && otmCtx->selectedDeviceInfo) + { + OIC_LOG(INFO, TAG, "Ownership transfer was successfully completed."); + OIC_LOG(INFO, TAG, "Set Ready for provisioning state ."); + + res = PostProvisioningStatus(otmCtx); + if(OC_STACK_OK != res) + { + OIC_LOG(ERROR, TAG, "Failed to update pstat"); + SetResult(otmCtx, res); + } + } + } + else + { + res = clientResponse->result; + OIC_LOG_V(ERROR, TAG, "OwnershipInformationHandler : Unexpected result %d", res); + SetResult(otmCtx, res); } - OC_LOG(DEBUG, TAG, "OUT OperationModeUpdateHandler"); + OIC_LOG(DEBUG, TAG, "OUT OwnershipInformationHandler"); exit: return OC_STACK_DELETE_TRANSACTION; } +/** + * Response handler of update provisioning status. + * + * @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 ProvisioningStatusHandler(void *ctx, OCDoHandle UNUSED, + OCClientResponse *clientResponse) +{ + OIC_LOG_V(INFO, TAG, "IN ProvisioningStatusHandler."); + + VERIFY_NON_NULL(TAG, clientResponse, ERROR); + VERIFY_NON_NULL(TAG, ctx, ERROR); + + OTMContext_t* otmCtx = (OTMContext_t*) ctx; + (void)UNUSED; + OCStackResult res = OC_STACK_OK; + + if(OC_STACK_OK == 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) + { + OIC_LOG(INFO, TAG, "Device state is in Ready for Normal Operation."); + OCStackResult res = PDMAddDevice(&otmCtx->selectedDeviceInfo->doxm->deviceID); + if (OC_STACK_OK == res) + { + OIC_LOG_V(INFO, TAG, "Add device's UUID in PDM_DB"); + SetResult(otmCtx, OC_STACK_OK); + return OC_STACK_DELETE_TRANSACTION; + } + else + { + OIC_LOG(ERROR, TAG, "Ownership transfer is complete but adding information to DB is failed."); + } + } + 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 ReadyForNomalStatusHandler."); + return OC_STACK_DELETE_TRANSACTION; +} -static OCStackResult PutOwnerTransferModeToResource(OTMContext_t* otmCtx) +static OCStackResult PutOwnerCredential(OTMContext_t* otmCtx) { - OC_LOG(DEBUG, TAG, "IN PutOwnerTransferModeToResource"); + OIC_LOG(DEBUG, TAG, "IN PutOwnerCredential"); if(!otmCtx || !otmCtx->selectedDeviceInfo) { - OC_LOG(ERROR, TAG, "Invalid parameters"); + OIC_LOG(ERROR, TAG, "Invalid parameters"); + return OC_STACK_INVALID_PARAM; + } + + OCProvisionDev_t* deviceInfo = otmCtx->selectedDeviceInfo; + char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0}; + + if(!PMGenerateQuery(true, + deviceInfo->endpoint.addr, deviceInfo->securePort, + deviceInfo->connType, + query, sizeof(query), OIC_RSRC_CRED_URI)) + { + OIC_LOG(ERROR, TAG, "PutOwnerCredential : Failed to generate query"); + return OC_STACK_ERROR; + } + OIC_LOG_V(DEBUG, TAG, "Query=%s", query); + OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload)); + if(!secPayload) + { + OIC_LOG(ERROR, TAG, "Failed to memory allocation"); + return OC_STACK_NO_MEMORY; + } + + //Generate owner credential for new device + secPayload->base.type = PAYLOAD_TYPE_SECURITY; + const OicSecCred_t* ownerCredential = GetCredResourceData(&(deviceInfo->doxm->deviceID)); + if(!ownerCredential) + { + OIC_LOG(ERROR, TAG, "Can not find OwnerPSK."); + return OC_STACK_NO_RESOURCE; + } + + OicUuid_t credSubjectId = {.id={0}}; + if(OC_STACK_OK == GetDoxmDeviceID(&credSubjectId)) + { + OicSecCred_t newCredential; + memcpy(&newCredential, ownerCredential, sizeof(OicSecCred_t)); + newCredential.next = NULL; + + //Set subject ID as PT's ID + memcpy(&(newCredential.subject), &credSubjectId, sizeof(OicUuid_t)); + + //Fill private data as empty string + 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 : PUT /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 cbor."); + return OC_STACK_ERROR; + } + 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, + &deviceInfo->endpoint, (OCPayload*)secPayload, + deviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0); + if (res != OC_STACK_OK) + { + OIC_LOG(ERROR, TAG, "OCStack resource error"); + } + } + else + { + OIC_LOG(ERROR, TAG, "Failed to read DOXM device ID."); + return OC_STACK_NO_RESOURCE; + } + + OIC_LOG(DEBUG, TAG, "OUT PutOwnerCredential"); + + return OC_STACK_OK; +} + +static OCStackResult PostOwnerTransferModeToResource(OTMContext_t* otmCtx) +{ + OIC_LOG(DEBUG, TAG, "IN PostOwnerTransferModeToResource"); + + if(!otmCtx || !otmCtx->selectedDeviceInfo) + { + OIC_LOG(ERROR, TAG, "Invalid parameters"); return OC_STACK_INVALID_PARAM; } @@ -638,50 +1036,50 @@ static OCStackResult PutOwnerTransferModeToResource(OTMContext_t* otmCtx) deviceInfo->connType, query, sizeof(query), OIC_RSRC_DOXM_URI)) { - OC_LOG(ERROR, TAG, "PutOwnerTransferModeToResource : Failed to generate query"); + OIC_LOG(ERROR, TAG, "PostOwnerTransferModeToResource : Failed to generate query"); return OC_STACK_ERROR; } - OC_LOG_V(DEBUG, TAG, "Query=%s", query); + OIC_LOG_V(DEBUG, TAG, "Query=%s", query); OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload)); if(!secPayload) { - OC_LOG(ERROR, TAG, "Failed to memory allocation"); + OIC_LOG(ERROR, TAG, "Failed to memory allocation"); 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); - OC_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; } - OC_LOG_V(DEBUG, TAG, "Payload : %s", secPayload->securityData); OCCallbackData cbData; 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) { - OC_LOG(ERROR, TAG, "OCStack resource error"); + OIC_LOG(ERROR, TAG, "OCStack resource error"); } - OC_LOG(DEBUG, TAG, "OUT PutOwnerTransferModeToResource"); + OIC_LOG(DEBUG, TAG, "OUT PostOwnerTransferModeToResource"); return res; } static OCStackResult GetProvisioningStatusResource(OTMContext_t* otmCtx) { - OC_LOG(DEBUG, TAG, "IN GetProvisioningStatusResource"); + OIC_LOG(DEBUG, TAG, "IN GetProvisioningStatusResource"); if(!otmCtx || !otmCtx->selectedDeviceInfo) { - OC_LOG(ERROR, TAG, "Invailed parameters"); + OIC_LOG(ERROR, TAG, "Invailed parameters"); return OC_STACK_INVALID_PARAM; } @@ -692,35 +1090,34 @@ static OCStackResult GetProvisioningStatusResource(OTMContext_t* otmCtx) deviceInfo->connType, query, sizeof(query), OIC_RSRC_PSTAT_URI)) { - OC_LOG(ERROR, TAG, "GetProvisioningStatusResource : Failed to generate query"); + OIC_LOG(ERROR, TAG, "GetProvisioningStatusResource : Failed to generate query"); return OC_STACK_ERROR; } - OC_LOG_V(DEBUG, TAG, "Query=%s", query); + OIC_LOG_V(DEBUG, TAG, "Query=%s", query); OCCallbackData cbData; cbData.cb = &ListMethodsHandler; 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) { - OC_LOG(ERROR, TAG, "OCStack resource error"); + OIC_LOG(ERROR, TAG, "OCStack resource error"); } - OC_LOG(DEBUG, TAG, "OUT GetProvisioningStatusResource"); + OIC_LOG(DEBUG, TAG, "OUT GetProvisioningStatusResource"); return res; } - -static OCStackResult PutOwnershipInformation(OTMContext_t* otmCtx) +static OCStackResult PostOwnerUuid(OTMContext_t* otmCtx) { - OC_LOG(DEBUG, TAG, "IN PutOwnershipInformation"); + OIC_LOG(DEBUG, TAG, "IN PostOwnerUuid"); if(!otmCtx || !otmCtx->selectedDeviceInfo) { - OC_LOG(ERROR, TAG, "Invailed parameters"); + OIC_LOG(ERROR, TAG, "Invailed parameters"); return OC_STACK_INVALID_PARAM; } @@ -731,25 +1128,85 @@ static OCStackResult PutOwnershipInformation(OTMContext_t* otmCtx) deviceInfo->connType, query, sizeof(query), OIC_RSRC_DOXM_URI)) { - OC_LOG(ERROR, TAG, "PutOwnershipInformation : Failed to generate query"); + OIC_LOG(ERROR, TAG, "PostOwnerUuid : Failed to generate query"); return OC_STACK_ERROR; } - OC_LOG_V(DEBUG, TAG, "Query=%s", query); + OIC_LOG_V(DEBUG, TAG, "Query=%s", query); - //OwnershipInformationHandler - OicSecOxm_t selOxm = deviceInfo->doxm->oxmSel; + //Post PT's uuid to new device OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload)); if(!secPayload) { - OC_LOG(ERROR, TAG, "Failed to memory allocation"); + OIC_LOG(ERROR, TAG, "Failed to memory allocation"); return OC_STACK_NO_MEMORY; } secPayload->base.type = PAYLOAD_TYPE_SECURITY; - secPayload->securityData = g_OTMDatas[selOxm].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); - OC_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_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize); + + OCCallbackData cbData; + cbData.cb = &OwnerUuidUpdateHandler; + cbData.context = (void *)otmCtx; + cbData.cd = NULL; + + 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 PostOwnerUuid"); + + return res; +} + +static OCStackResult PostOwnershipInformation(OTMContext_t* otmCtx) +{ + OIC_LOG(DEBUG, TAG, "IN PostOwnershipInformation"); + + if(!otmCtx || !otmCtx->selectedDeviceInfo) + { + OIC_LOG(ERROR, TAG, "Invailed parameters"); + return OC_STACK_INVALID_PARAM; + } + + OCProvisionDev_t* deviceInfo = otmCtx->selectedDeviceInfo; + char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0}; + if(!PMGenerateQuery(true, + deviceInfo->endpoint.addr, deviceInfo->securePort, + deviceInfo->connType, + query, sizeof(query), OIC_RSRC_DOXM_URI)) + { + 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) + { + OIC_LOG(ERROR, TAG, "Failed to memory allocation"); + return OC_STACK_NO_MEMORY; + } + + otmCtx->selectedDeviceInfo->doxm->owned = true; + + secPayload->base.type = PAYLOAD_TYPE_SECURITY; + OCStackResult res = DoxmToCBORPayload(otmCtx->selectedDeviceInfo->doxm, + &secPayload->securityData, &secPayload->payloadSize); + if (OC_STACK_OK != res && NULL == secPayload->securityData) + { + OCPayloadDestroy((OCPayload *)secPayload); + OIC_LOG(ERROR, TAG, "Error while converting doxm bin to json"); return OC_STACK_INVALID_PARAM; } @@ -757,22 +1214,22 @@ static OCStackResult PutOwnershipInformation(OTMContext_t* otmCtx) 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) { - OC_LOG(ERROR, TAG, "OCStack resource error"); + OIC_LOG(ERROR, TAG, "OCStack resource error"); } - OC_LOG(DEBUG, TAG, "OUT PutOwnershipInformation"); + OIC_LOG(DEBUG, TAG, "OUT PostOwnershipInformation"); return res; } -static OCStackResult PutUpdateOperationMode(OTMContext_t* otmCtx, - OicSecDpom_t selectedOperationMode) +static OCStackResult PostUpdateOperationMode(OTMContext_t* otmCtx) { - OC_LOG(DEBUG, TAG, "IN PutUpdateOperationMode"); + OIC_LOG(DEBUG, TAG, "IN PostUpdateOperationMode"); if(!otmCtx || !otmCtx->selectedDeviceInfo) { @@ -786,25 +1243,24 @@ static OCStackResult PutUpdateOperationMode(OTMContext_t* otmCtx, deviceInfo->connType, query, sizeof(query), OIC_RSRC_PSTAT_URI)) { - OC_LOG(ERROR, TAG, "PutUpdateOperationMode : Failed to generate query"); + OIC_LOG(ERROR, TAG, "PostUpdateOperationMode : Failed to generate query"); return OC_STACK_ERROR; } - OC_LOG_V(DEBUG, TAG, "Query=%s", query); - - deviceInfo->pstat->om = selectedOperationMode; + OIC_LOG_V(DEBUG, TAG, "Query=%s", query); OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload)); if(!secPayload) { - OC_LOG(ERROR, TAG, "Failed to memory allocation"); + OIC_LOG(ERROR, TAG, "Failed to memory allocation"); return OC_STACK_NO_MEMORY; } secPayload->base.type = PAYLOAD_TYPE_SECURITY; - secPayload->securityData = BinToPstatJSON(deviceInfo->pstat); - if (NULL == secPayload->securityData) + OCStackResult res = PstatToCBORPayload(deviceInfo->pstat, &secPayload->securityData, + &secPayload->payloadSize); + if (OC_STACK_OK != res) { - OICFree(secPayload); - OC_LOG(ERROR, TAG, "Error while converting pstat bin to json"); + OCPayloadDestroy((OCPayload *)secPayload); + OIC_LOG(ERROR, TAG, "Error while converting pstat to cbor."); return OC_STACK_INVALID_PARAM; } @@ -812,21 +1268,21 @@ static OCStackResult PutUpdateOperationMode(OTMContext_t* otmCtx, cbData.cb = &OperationModeUpdateHandler; 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) { - OC_LOG(ERROR, TAG, "OCStack resource error"); + OIC_LOG(ERROR, TAG, "OCStack resource error"); } - OC_LOG(DEBUG, TAG, "OUT PutUpdateOperationMode"); + OIC_LOG(DEBUG, TAG, "OUT PostUpdateOperationMode"); return res; } static OCStackResult StartOwnershipTransfer(void* ctx, OCProvisionDev_t* selectedDevice) { - OC_LOG(INFO, TAG, "IN StartOwnershipTransfer"); + OIC_LOG(INFO, TAG, "IN StartOwnershipTransfer"); OTMContext_t* otmCtx = (OTMContext_t*)ctx; otmCtx->selectedDeviceInfo = selectedDevice; @@ -836,22 +1292,28 @@ static OCStackResult StartOwnershipTransfer(void* ctx, OCProvisionDev_t* selecte &selectedDevice->doxm->oxmSel); if(OC_STACK_OK != res) { - OC_LOG(ERROR, TAG, "Failed to select the provisioning method"); + OIC_LOG(ERROR, TAG, "Failed to select the provisioning method"); SetResult(otmCtx, res); return res; } - OC_LOG_V(DEBUG, TAG, "Selected provisoning method = %d", selectedDevice->doxm->oxmSel); + 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) { - OC_LOG(WARNING, TAG, "Failed to select the provisioning method"); + OIC_LOG(WARNING, TAG, "Failed to select the provisioning method"); SetResult(otmCtx, res); return res; } - OC_LOG(INFO, TAG, "OUT StartOwnershipTransfer"); + //Register DTLS event handler to catch the dtls event while handshake + if(CA_STATUS_OK != CARegisterDTLSHandshakeCallback(DTLSHandshakeCB)) + { + OIC_LOG(WARNING, TAG, "StartOwnershipTransfer : Failed to register DTLS handshake callback."); + } + + OIC_LOG(INFO, TAG, "OUT StartOwnershipTransfer"); return res; @@ -859,16 +1321,16 @@ static OCStackResult StartOwnershipTransfer(void* ctx, OCProvisionDev_t* selecte OCStackResult OTMSetOwnershipTransferCallbackData(OicSecOxm_t oxmType, OTMCallbackData_t* data) { - OC_LOG(DEBUG, TAG, "IN OTMSetOwnerTransferCallbackData"); + OIC_LOG(DEBUG, TAG, "IN OTMSetOwnerTransferCallbackData"); if(!data) { - OC_LOG(ERROR, TAG, "OTMSetOwnershipTransferCallbackData : Invalid parameters"); + OIC_LOG(ERROR, TAG, "OTMSetOwnershipTransferCallbackData : Invalid parameters"); return OC_STACK_INVALID_PARAM; } if(oxmType >= OIC_OXM_COUNT) { - OC_LOG(INFO, TAG, "Unknow ownership transfer method"); + OIC_LOG(INFO, TAG, "Unknow ownership transfer method"); return OC_STACK_INVALID_PARAM; } @@ -877,7 +1339,7 @@ OCStackResult OTMSetOwnershipTransferCallbackData(OicSecOxm_t oxmType, OTMCallba g_OTMDatas[oxmType].createSelectOxmPayloadCB = data->createSelectOxmPayloadCB; g_OTMDatas[oxmType].createOwnerTransferPayloadCB = data->createOwnerTransferPayloadCB; - OC_LOG(DEBUG, TAG, "OUT OTMSetOwnerTransferCallbackData"); + OIC_LOG(DEBUG, TAG, "OUT OTMSetOwnerTransferCallbackData"); return OC_STACK_OK; } @@ -889,17 +1351,21 @@ OCStackResult OTMDoOwnershipTransfer(void* ctx, OCProvisionDev_t *selectedDevicelist, OCProvisionResultCB resultCallback) { - OC_LOG(DEBUG, TAG, "IN OTMDoOwnershipTransfer"); + OIC_LOG(DEBUG, TAG, "IN OTMDoOwnershipTransfer"); - if (NULL == selectedDevicelist || NULL == resultCallback ) + if (NULL == selectedDevicelist) { return OC_STACK_INVALID_PARAM; } + if (NULL == resultCallback) + { + return OC_STACK_INVALID_CALLBACK; + } OTMContext_t* otmCtx = (OTMContext_t*)OICCalloc(1,sizeof(OTMContext_t)); if(!otmCtx) { - OC_LOG(ERROR, TAG, "Failed to create OTM Context"); + OIC_LOG(ERROR, TAG, "Failed to create OTM Context"); return OC_STACK_NO_MEMORY; } otmCtx->ctxResultCallback = resultCallback; @@ -919,30 +1385,28 @@ OCStackResult OTMDoOwnershipTransfer(void* ctx, (OCProvisionResult_t*)OICCalloc(otmCtx->ctxResultArraySize, sizeof(OCProvisionResult_t)); if(NULL == otmCtx->ctxResultArray) { - OC_LOG(ERROR, TAG, "OTMDoOwnershipTransfer : Failed to memory allocation"); + OIC_LOG(ERROR, TAG, "OTMDoOwnershipTransfer : Failed to memory allocation"); OICFree(otmCtx); return OC_STACK_NO_MEMORY; } pCurDev = selectedDevicelist; + OCStackResult res = OC_STACK_OK; //Fill the device UUID for result array. for(size_t devIdx = 0; devIdx < otmCtx->ctxResultArraySize; devIdx++) { //Checking duplication of Device ID. bool isDuplicate = true; - OCStackResult res = PDMIsDuplicateDevice(&pCurDev->doxm->deviceID, &isDuplicate); + res = PDMIsDuplicateDevice(&pCurDev->doxm->deviceID, &isDuplicate); if (OC_STACK_OK != res) { - OICFree(otmCtx->ctxResultArray); - OICFree(otmCtx); - return res; + goto error; } if (isDuplicate) { - OC_LOG(ERROR, TAG, "OTMDoOwnershipTransfer : Device ID is duplicated"); - OICFree(otmCtx->ctxResultArray); - OICFree(otmCtx); - return OC_STACK_INVALID_PARAM; + OIC_LOG(ERROR, TAG, "OTMDoOwnershipTransfer : Device ID is duplicated"); + res = OC_STACK_INVALID_PARAM; + goto error; } memcpy(otmCtx->ctxResultArray[devIdx].deviceId.id, pCurDev->doxm->deviceID.id, @@ -950,228 +1414,130 @@ OCStackResult OTMDoOwnershipTransfer(void* ctx, otmCtx->ctxResultArray[devIdx].res = OC_STACK_CONTINUE; pCurDev = pCurDev->next; } + StartOwnershipTransfer(otmCtx, selectedDevicelist); - OC_LOG(DEBUG, TAG, "OUT OTMDoOwnershipTransfer"); + OIC_LOG(DEBUG, TAG, "OUT OTMDoOwnershipTransfer"); return OC_STACK_OK; + +error: + OICFree(otmCtx->ctxResultArray); + OICFree(otmCtx); + return res; } -/** - * Callback handler of SRPFinalizeProvisioning. - * - * @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 FinalizeProvisioningCB(void *ctx, OCDoHandle UNUSED, - OCClientResponse *clientResponse) +OCStackResult PostProvisioningStatus(OTMContext_t* otmCtx) { - OC_LOG_V(INFO, TAG, "IN FinalizeProvisioningCB."); + OIC_LOG(INFO, TAG, "IN PostProvisioningStatus"); - 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(!otmCtx || !otmCtx->selectedDeviceInfo) { - OCStackResult res = PDMAddDevice(&otmCtx->selectedDeviceInfo->doxm->deviceID); - - if (OC_STACK_OK == res) - { - OC_LOG_V(INFO, TAG, "Add device's UUID in PDM_DB"); - SetResult(otmCtx, OC_STACK_OK); - return OC_STACK_DELETE_TRANSACTION; - } - else - { - OC_LOG(ERROR, TAG, "Ownership transfer is complete but adding information to DB is failed."); - } + OIC_LOG(ERROR, TAG, "OTMContext is NULL"); + return OC_STACK_INVALID_PARAM; } -exit: - return OC_STACK_DELETE_TRANSACTION; -} - -/** - * Callback handler of default ACL provisioning. - * - * @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 ProvisionDefaultACLCB(void *ctx, OCDoHandle UNUSED, - OCClientResponse *clientResponse) -{ - OC_LOG_V(INFO, TAG, "IN ProvisionDefaultACLCB."); - VERIFY_NON_NULL(TAG, clientResponse, ERROR); - VERIFY_NON_NULL(TAG, ctx, ERROR); - - OTMContext_t* otmCtx = (OTMContext_t*) ctx; - (void)UNUSED; + //Change the TAKE_OWNER bit of CM to 0. + otmCtx->selectedDeviceInfo->pstat->cm &= (~TAKE_OWNER); - if (OC_STACK_RESOURCE_CREATED == clientResponse->result) + OCSecurityPayload *secPayload = (OCSecurityPayload *)OICCalloc(1, sizeof(OCSecurityPayload)); + if (!secPayload) { - OC_LOG_V(INFO, TAG, "Staring commit hash task."); - // TODO hash currently have fixed value 0. - uint16_t aclHash = 0; - otmCtx->selectedDeviceInfo->pstat->commitHash = aclHash; - otmCtx->selectedDeviceInfo->pstat->tm = NORMAL; - OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload)); - if(!secPayload) - { - OC_LOG(ERROR, TAG, "Failed to memory allocation"); - return OC_STACK_NO_MEMORY; - } - secPayload->base.type = PAYLOAD_TYPE_SECURITY; - secPayload->securityData = BinToPstatJSON(otmCtx->selectedDeviceInfo->pstat); - if (NULL == secPayload->securityData) - { - OICFree(secPayload); - SetResult(otmCtx, OC_STACK_INVALID_JSON); - return OC_STACK_DELETE_TRANSACTION; - } - OC_LOG_V(INFO, TAG, "Created payload for commit hash: %s",secPayload->securityData); - - 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)) - { - OC_LOG(ERROR, TAG, "ProvisionDefaultACLCB : Failed to generate query"); - return OC_STACK_ERROR; - } - OC_LOG_V(DEBUG, TAG, "Query=%s", query); + 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); - OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL}; - cbData.cb = &FinalizeProvisioningCB; - cbData.context = (void*)otmCtx; - cbData.cd = NULL; - OCStackResult ret = OCDoResource(NULL, OC_REST_PUT, query, 0, (OCPayload*)secPayload, - otmCtx->selectedDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0); - OC_LOG_V(INFO, TAG, "OCDoResource returned: %d",ret); - if (ret != OC_STACK_OK) - { - OC_LOG(ERROR, TAG, "OCStack resource error"); - SetResult(otmCtx, ret); - } + 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; } - else + 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) { - OC_LOG_V(INFO, TAG, "Error occured in provisionDefaultACLCB :: %d\n", - clientResponse->result); - SetResult(otmCtx, clientResponse->result); + OIC_LOG(ERROR, TAG, "OCStack resource error"); } -exit: - return OC_STACK_DELETE_TRANSACTION; -} + OIC_LOG(INFO, TAG, "OUT PostProvisioningStatus"); -OCStackResult FinalizeProvisioning(OTMContext_t* otmCtx) + return ret; +} + +OCStackResult PostNormalOperationStatus(OTMContext_t* otmCtx) { - OC_LOG(INFO, TAG, "IN FinalizeProvisioning"); + OIC_LOG(INFO, TAG, "IN PostNormalOperationStatus"); - if(!otmCtx) - { - OC_LOG(ERROR, TAG, "OTMContext is NULL"); - return OC_STACK_INVALID_PARAM; - } - if(!otmCtx->selectedDeviceInfo) + if(!otmCtx || !otmCtx->selectedDeviceInfo) { - OC_LOG(ERROR, TAG, "Can't find device information in OTMContext"); - OICFree(otmCtx); + OIC_LOG(ERROR, TAG, "OTMContext is NULL"); return OC_STACK_INVALID_PARAM; } - // Provision Default ACL to device - OicSecAcl_t defaultAcl = - { {.id={0}}, - 1, - NULL, - 0x001F, - 0, - NULL, - NULL, - 1, - NULL, - NULL, - }; - - OicUuid_t provTooldeviceID = {.id={0}}; - if (OC_STACK_OK != GetDoxmDeviceID(&provTooldeviceID)) - { - OC_LOG(ERROR, TAG, "Error while retrieving provisioning tool's device ID"); - SetResult(otmCtx, OC_STACK_ERROR); - return OC_STACK_ERROR; - } - OC_LOG(INFO, TAG, "Retieved deviceID"); - memcpy(defaultAcl.subject.id, provTooldeviceID.id, sizeof(defaultAcl.subject.id)); - char *wildCardResource = "*"; - defaultAcl.resources = &wildCardResource; - defaultAcl.owners = (OicUuid_t *) OICCalloc(1, UUID_LENGTH); - if(!defaultAcl.owners) - { - OC_LOG(ERROR, TAG, "Failed to memory allocation for default ACL"); - SetResult(otmCtx, OC_STACK_NO_MEMORY); - return OC_STACK_NO_MEMORY; - } - memcpy(defaultAcl.owners->id, provTooldeviceID.id, UUID_LENGTH); - OC_LOG(INFO, TAG, "Provisioning default ACL"); + //Set isop to true. + otmCtx->selectedDeviceInfo->pstat->isOp = true; - OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload)); - if(!secPayload) + OCSecurityPayload *secPayload = (OCSecurityPayload *)OICCalloc(1, sizeof(OCSecurityPayload)); + if (!secPayload) { - OC_LOG(ERROR, TAG, "Failed to memory allocation"); + OIC_LOG(ERROR, TAG, "Failed to memory allocation"); return OC_STACK_NO_MEMORY; } secPayload->base.type = PAYLOAD_TYPE_SECURITY; - secPayload->securityData = BinToAclJSON(&defaultAcl); - OICFree(defaultAcl.owners); - if(!secPayload->securityData) + if (OC_STACK_OK != PstatToCBORPayload(otmCtx->selectedDeviceInfo->pstat, + &secPayload->securityData, &secPayload->payloadSize)) { - OICFree(secPayload); - OC_LOG(INFO, TAG, "FinalizeProvisioning : Failed to BinToAclJSON"); - SetResult(otmCtx, OC_STACK_ERROR); - return OC_STACK_ERROR; + OCPayloadDestroy((OCPayload *)secPayload); + return OC_STACK_INVALID_JSON; } - OC_LOG_V(INFO, TAG, "Provisioning default ACL : %s",secPayload->securityData); + 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_ACL_URI)) + query, sizeof(query), OIC_RSRC_PSTAT_URI)) { - OC_LOG(ERROR, TAG, "FinalizeProvisioning : Failed to generate query"); + OIC_LOG(ERROR, TAG, "PostNormalOperationStatus : Failed to generate query"); return OC_STACK_ERROR; } - OC_LOG_V(DEBUG, TAG, "Query=%s", query); - - OC_LOG_V(INFO, TAG, "Request URI for Provisioning default ACL : %s", query); + OIC_LOG_V(DEBUG, TAG, "Query=%s", query); - OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL}; - cbData.cb = &ProvisionDefaultACLCB; - cbData.context = (void *)otmCtx; + OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL}; + cbData.cb = &ReadyForNomalStatusHandler; + cbData.context = (void*)otmCtx; cbData.cd = NULL; - OCStackResult ret = OCDoResource(NULL, OC_REST_POST, query, - &otmCtx->selectedDeviceInfo->endpoint, (OCPayload*)secPayload, + OCStackResult ret = OCDoResource(NULL, OC_REST_POST, query, 0, (OCPayload*)secPayload, otmCtx->selectedDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0); - if (OC_STACK_OK != ret) + OIC_LOG_V(INFO, TAG, "OCDoResource returned: %d",ret); + if (ret != OC_STACK_OK) { - SetResult(otmCtx, ret); - return ret; + OIC_LOG(ERROR, TAG, "OCStack resource error"); } - OC_LOG(INFO, TAG, "OUT FinalizeProvisioning"); + OIC_LOG(INFO, TAG, "OUT PostNormalOperationStatus"); return ret; - } -