1 /* *****************************************************************
3 * Copyright 2015 Samsung Electronics All Rights Reserved.
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
19 * *****************************************************************/
21 // Defining _POSIX_C_SOURCE macro with 199309L (or greater) as value
22 // causes header files to expose definitions
23 // corresponding to the POSIX.1b, Real-time extensions
24 // (IEEE Std 1003.1b-1993) specification
26 // For this specific file, see use of clock_gettime,
27 // Refer to http://pubs.opengroup.org/stage7tc1/functions/clock_gettime.html
28 // and to http://man7.org/linux/man-pages/man2/clock_gettime.2.html
29 #ifndef _POSIX_C_SOURCE
30 #define _POSIX_C_SOURCE 200809L
40 #include "oic_malloc.h"
41 #include "oic_string.h"
43 #include "cainterface.h"
48 #include "srmresourcestrings.h"
49 #include "doxmresource.h"
50 #include "pstatresource.h"
51 #include "credresource.h"
52 #include "aclresource.h"
53 #include "ownershiptransfermanager.h"
54 #include "securevirtualresourcetypes.h"
55 #include "oxmjustworks.h"
57 #include "pmutility.h"
58 #include "srmutility.h"
59 #include "provisioningdatabasemanager.h"
60 #include "oxmrandompin.h"
61 #include "ocpayload.h"
62 #include "payload_logging.h"
67 * Array to store the callbacks for each owner transfer method.
69 static OTMCallbackData_t g_OTMDatas[OIC_OXM_COUNT];
72 * Variable for storing provisioning tool's provisioning capabilities
73 * Must be in decreasing order of preference. More prefered method should
74 * have lower array index.
76 static OicSecDpom_t gProvisioningToolCapability[] = { SINGLE_SERVICE_CLIENT_DRIVEN };
79 * Number of supported provisioning methods
80 * current version supports only one.
82 static size_t gNumOfProvisioningMethodsPT = 1;
85 * Variables for pointing the OTMContext to be used in the DTLS handshake result callback.
87 static OTMContext_t* g_otmCtx = NULL;
90 * Function to select appropriate provisioning method.
92 * @param[in] supportedMethods Array of supported methods
93 * @param[in] numberOfMethods number of supported methods
94 * @param[out] selectedMethod Selected methods
95 * @return OC_STACK_OK on success
97 static OCStackResult SelectProvisioningMethod(const OicSecOxm_t *supportedMethods,
98 size_t numberOfMethods, OicSecOxm_t *selectedMethod)
100 OIC_LOG(DEBUG, TAG, "IN SelectProvisioningMethod");
102 if(numberOfMethods == 0 || !supportedMethods)
104 OIC_LOG(WARNING, TAG, "Could not find a supported OxM.");
105 return OC_STACK_ERROR;
108 *selectedMethod = supportedMethods[0];
109 for(size_t i = 0; i < numberOfMethods; i++)
111 if(*selectedMethod < supportedMethods[i])
113 *selectedMethod = supportedMethods[i];
121 * Function to select operation mode.This function will return most secure common operation mode.
123 * @param[in] selectedDeviceInfo selected device information to performing provisioning.
124 * @param[out] selectedMode selected operation mode
125 * @return OC_STACK_OK on success
127 static void SelectOperationMode(const OCProvisionDev_t *selectedDeviceInfo,
128 OicSecDpom_t *selectedMode)
130 OIC_LOG(DEBUG, TAG, "IN SelectOperationMode");
135 while (i < gNumOfProvisioningMethodsPT && j < selectedDeviceInfo->pstat->smLen)
137 if (gProvisioningToolCapability[i] < selectedDeviceInfo->pstat->sm[j])
141 else if (selectedDeviceInfo->pstat->sm[j] < gProvisioningToolCapability[i])
145 else /* if gProvisioningToolCapability[i] == deviceSupportedMethods[j] */
147 *selectedMode = gProvisioningToolCapability[j];
151 OIC_LOG_V(DEBUG, TAG, "Selected Operation Mode = %d", *selectedMode);
153 OIC_LOG(DEBUG, TAG, "OUT SelectOperationMode");
157 * Function to start ownership transfer.
158 * This function will send the first request for provisioning,
159 * The next request message is sent from the response handler for this request.
161 * @param[in] ctx context value passed to callback from calling function.
162 * @param[in] selectedDevice selected device information to performing provisioning.
163 * @return OC_STACK_OK on success
165 static OCStackResult StartOwnershipTransfer(void* ctx, OCProvisionDev_t* selectedDevice);
168 * Function to update owner transfer mode
170 * @param[in] otmCtx Context value of ownership transfer.
171 * @return OC_STACK_OK on success
173 static OCStackResult PutOwnerTransferModeToResource(OTMContext_t* otmCtx);
176 * Function to send request to resource to get its pstat resource information.
178 * @param[in] otmCtx Context value of ownership transfer.
179 * @return OC_STACK_OK on success
181 static OCStackResult GetProvisioningStatusResource(OTMContext_t* otmCtx);
185 * Function to send uuid of owner device to new device.
186 * This function would update 'owner of doxm' as UUID for provisioning tool.
188 * @param[in] otmCtx Context value of ownership transfer.
189 * @return OC_STACK_OK on success
191 static OCStackResult PutOwnerUuid(OTMContext_t* otmCtx);
194 * Function to update the operation mode. As per the spec. Operation mode in client driven
195 * single service provisioning it will be updated to 0x3
197 * @param[in] otmCtx Context value of ownership transfer.
198 * @return OC_STACK_OK on success
200 static OCStackResult PutUpdateOperationMode(OTMContext_t* otmCtx);
203 * Function to update the owner credential to new device
205 * @param[in] otmCtx Context value of ownership transfer.
206 * @param[in] selectedOperationMode selected operation mode
207 * @return OC_STACK_OK on success
209 static OCStackResult PutOwnerCredential(OTMContext_t* otmCtx);
212 * Function to send ownerShip info.
213 * This function would update 'owned of doxm' as true.
215 * @param[in] otmCtx Context value of ownership transfer.
216 * @return OC_STACK_OK on success
218 static OCStackResult PutOwnershipInformation(OTMContext_t* otmCtx);
221 * Function to update pstat when finalize provisioning.
222 * This function would update 'cm' as bx0011,1100 and 'tm' as bx0000,0000.
224 * @param[in] ctx context value passed to callback from calling function.
225 * @param[in] selectedDevice selected device information to performing provisioning.
226 * @return OC_STACK_OK on success
228 static OCStackResult PutProvisioningStatus(OTMContext_t* otmCtx);
230 static bool IsComplete(OTMContext_t* otmCtx)
232 for(size_t i = 0; i < otmCtx->ctxResultArraySize; i++)
234 if(OC_STACK_CONTINUE == otmCtx->ctxResultArray[i].res)
244 * Function to save the result of provisioning.
246 * @param[in,out] otmCtx Context value of ownership transfer.
247 * @param[in] res result of provisioning
249 static void SetResult(OTMContext_t* otmCtx, const OCStackResult res)
251 OIC_LOG_V(DEBUG, TAG, "IN SetResult : %d ", res);
255 OIC_LOG(WARNING, TAG, "OTMContext is NULL");
259 if(otmCtx->selectedDeviceInfo)
261 //Revert psk_info callback and new deivce uuid in case of random PIN OxM
262 if(OIC_RANDOM_DEVICE_PIN == otmCtx->selectedDeviceInfo->doxm->oxmSel)
264 if(CA_STATUS_OK != CARegisterDTLSCredentialsHandler(GetDtlsPskCredentials))
266 OIC_LOG(WARNING, TAG, "Failed to revert is DTLS credential handler.");
268 OicUuid_t emptyUuid = { .id={0}};
269 SetUuidForRandomPinOxm(&emptyUuid);
272 for(size_t i = 0; i < otmCtx->ctxResultArraySize; i++)
274 if(memcmp(otmCtx->selectedDeviceInfo->doxm->deviceID.id,
275 otmCtx->ctxResultArray[i].deviceId.id, UUID_LENGTH) == 0)
277 otmCtx->ctxResultArray[i].res = res;
278 if(OC_STACK_OK != res)
280 otmCtx->ctxHasError = true;
287 //If all request is completed, invoke the user callback.
288 if(IsComplete(otmCtx))
290 otmCtx->ctxResultCallback(otmCtx->userCtx, otmCtx->ctxResultArraySize,
291 otmCtx->ctxResultArray, otmCtx->ctxHasError);
292 OICFree(otmCtx->ctxResultArray);
297 if(OC_STACK_OK != StartOwnershipTransfer(otmCtx,
298 otmCtx->selectedDeviceInfo->next))
300 OIC_LOG(ERROR, TAG, "Failed to StartOwnershipTransfer");
305 OIC_LOG(DEBUG, TAG, "OUT SetResult");
309 * Function to handle the handshake result in OTM.
310 * This function will be invoked after DTLS handshake
311 * @param endPoint [IN] The remote endpoint.
312 * @param errorInfo [IN] Error information from the endpoint.
315 void DTLSHandshakeCB(const CAEndpoint_t *endpoint, const CAErrorInfo_t *info)
317 if(NULL != g_otmCtx && NULL != g_otmCtx->selectedDeviceInfo &&
318 NULL != endpoint && NULL != info)
320 OIC_LOG_V(INFO, TAG, "Received status from remote device(%s:%d) : %d",
321 endpoint->addr, endpoint->port, info->result);
323 OicSecDoxm_t* newDevDoxm = g_otmCtx->selectedDeviceInfo->doxm;
325 if(NULL != newDevDoxm)
327 OicUuid_t emptyUuid = {.id={0}};
329 //Make sure the address matches.
330 if(strncmp(g_otmCtx->selectedDeviceInfo->endpoint.addr,
332 sizeof(endpoint->addr)) == 0 &&
333 g_otmCtx->selectedDeviceInfo->securePort == endpoint->port)
335 OCStackResult res = OC_STACK_ERROR;
337 //If temporal secure sesstion established successfully
338 if(CA_STATUS_OK == info->result &&
339 false == newDevDoxm->owned &&
340 memcmp(&(newDevDoxm->owner), &emptyUuid, sizeof(OicUuid_t)) == 0)
342 //Send request : PUT /oic/sec/doxm [{... , "devowner":"PT's UUID"}]
343 res = PutOwnerUuid(g_otmCtx);
344 if(OC_STACK_OK != res)
346 OIC_LOG(ERROR, TAG, "OperationModeUpdate : Failed to send owner information");
347 SetResult(g_otmCtx, res);
350 //In case of authentication failure
351 else if(CA_DTLS_AUTHENTICATION_FAILURE == info->result)
353 //in case of error from owner credential
354 if(memcmp(&(newDevDoxm->owner), &emptyUuid, sizeof(OicUuid_t)) != 0 &&
355 true == newDevDoxm->owned)
357 OIC_LOG(ERROR, TAG, "The owner credential may incorrect.");
359 if(OC_STACK_OK != RemoveCredential(&(newDevDoxm->deviceID)))
361 OIC_LOG(WARNING, TAG, "Failed to remove the invaild owner credential");
363 SetResult(g_otmCtx, OC_STACK_AUTHENTICATION_FAILURE);
365 //in case of error from wrong PIN, re-start the ownership transfer
366 else if(OIC_RANDOM_DEVICE_PIN == newDevDoxm->oxmSel)
368 OIC_LOG(ERROR, TAG, "The PIN number may incorrect.");
370 memcpy(&(newDevDoxm->owner), &emptyUuid, sizeof(OicUuid_t));
371 newDevDoxm->owned = false;
372 g_otmCtx->attemptCnt++;
374 if(WRONG_PIN_MAX_ATTEMP > g_otmCtx->attemptCnt)
376 res = StartOwnershipTransfer(g_otmCtx, g_otmCtx->selectedDeviceInfo);
377 if(OC_STACK_OK != res)
379 SetResult(g_otmCtx, res);
380 OIC_LOG(ERROR, TAG, "Failed to Re-StartOwnershipTransfer");
385 OIC_LOG(ERROR, TAG, "User has exceeded the number of authentication attempts.");
386 SetResult(g_otmCtx, OC_STACK_AUTHENTICATION_FAILURE);
391 OIC_LOG(ERROR, TAG, "Failed to establish secure session.");
392 SetResult(g_otmCtx, OC_STACK_AUTHENTICATION_FAILURE);
401 * Function to save ownerPSK at provisioning tool end.
403 * @param[in] selectedDeviceInfo selected device information to performing provisioning.
404 * @return OC_STACK_OK on success
406 static OCStackResult SaveOwnerPSK(OCProvisionDev_t *selectedDeviceInfo)
408 OIC_LOG(DEBUG, TAG, "IN SaveOwnerPSK");
410 OCStackResult res = OC_STACK_ERROR;
412 CAEndpoint_t endpoint;
413 memset(&endpoint, 0x00, sizeof(CAEndpoint_t));
414 OICStrcpy(endpoint.addr, MAX_ADDR_STR_SIZE_CA, selectedDeviceInfo->endpoint.addr);
415 endpoint.addr[MAX_ADDR_STR_SIZE_CA - 1] = '\0';
416 endpoint.port = selectedDeviceInfo->securePort;
418 OicUuid_t ptDeviceID = {.id={0}};
419 if (OC_STACK_OK != GetDoxmDeviceID(&ptDeviceID))
421 OIC_LOG(ERROR, TAG, "Error while retrieving provisioning tool's device ID");
425 uint8_t ownerPSK[OWNER_PSK_LENGTH_128] = {0};
426 OicSecKey_t ownerKey = {ownerPSK, OWNER_PSK_LENGTH_128};
428 //Generating OwnerPSK
429 CAResult_t pskRet = CAGenerateOwnerPSK(&endpoint,
430 (uint8_t *)GetOxmString(selectedDeviceInfo->doxm->oxmSel),
431 strlen(GetOxmString(selectedDeviceInfo->doxm->oxmSel)),
432 ptDeviceID.id, sizeof(ptDeviceID.id),
433 selectedDeviceInfo->doxm->deviceID.id, sizeof(selectedDeviceInfo->doxm->deviceID.id),
434 ownerPSK, OWNER_PSK_LENGTH_128);
436 if (CA_STATUS_OK == pskRet)
438 OIC_LOG(INFO, TAG,"ownerPSK dump:\n");
439 OIC_LOG_BUFFER(INFO, TAG,ownerPSK, OWNER_PSK_LENGTH_128);
440 //Generating new credential for provisioning tool
443 OicSecCred_t *cred = GenerateCredential(&selectedDeviceInfo->doxm->deviceID,
444 SYMMETRIC_PAIR_WISE_KEY, NULL,
445 &ownerKey, ownLen, &ptDeviceID);
446 VERIFY_NON_NULL(TAG, cred, ERROR);
448 res = AddCredential(cred);
449 if(res != OC_STACK_OK)
451 DeleteCredList(cred);
457 OIC_LOG(ERROR, TAG, "CAGenerateOwnerPSK failed");
460 OIC_LOG(DEBUG, TAG, "OUT SaveOwnerPSK");
466 * Callback handler for OwnerShipTransferModeHandler API.
468 * @param[in] ctx ctx value passed to callback from calling function.
469 * @param[in] UNUSED handle to an invocation
470 * @param[in] clientResponse Response from queries to remote servers.
471 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
472 * and OC_STACK_KEEP_TRANSACTION to keep it.
474 static OCStackApplicationResult OwnerTransferModeHandler(void *ctx, OCDoHandle UNUSED,
475 OCClientResponse *clientResponse)
477 OIC_LOG(DEBUG, TAG, "IN OwnerTransferModeHandler");
479 VERIFY_NON_NULL(TAG, clientResponse, WARNING);
480 VERIFY_NON_NULL(TAG, ctx, WARNING);
482 OTMContext_t* otmCtx = (OTMContext_t*)ctx;
484 if(clientResponse->result == OC_STACK_OK)
486 OIC_LOG(INFO, TAG, "OwnerTransferModeHandler : response result = OC_STACK_OK");
487 //Send request : GET /oic/sec/pstat
488 OCStackResult res = GetProvisioningStatusResource(otmCtx);
489 if(OC_STACK_OK != res)
491 OIC_LOG(WARNING, TAG, "Failed to get pstat information");
492 SetResult(otmCtx, res);
497 OIC_LOG_V(WARNING, TAG, "OwnerTransferModeHandler : Client response is incorrect : %d",
498 clientResponse->result);
499 SetResult(otmCtx, clientResponse->result);
502 OIC_LOG(DEBUG, TAG, "OUT OwnerTransferModeHandler");
505 return OC_STACK_DELETE_TRANSACTION;
509 * Callback handler for ProvisioningStatusResouceHandler API.
511 * @param[in] ctx ctx value passed to callback from calling function.
512 * @param[in] UNUSED handle to an invocation
513 * @param[in] clientResponse Response from queries to remote servers.
514 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
515 * and OC_STACK_KEEP_TRANSACTION to keep it.
517 static OCStackApplicationResult ListMethodsHandler(void *ctx, OCDoHandle UNUSED,
518 OCClientResponse *clientResponse)
520 OIC_LOG(DEBUG, TAG, "IN ListMethodsHandler");
522 VERIFY_NON_NULL(TAG, clientResponse, WARNING);
523 VERIFY_NON_NULL(TAG, ctx, WARNING);
525 OTMContext_t* otmCtx = (OTMContext_t*)ctx;
527 if (OC_STACK_OK == clientResponse->result)
529 if (NULL == clientResponse->payload)
531 OIC_LOG(INFO, TAG, "Skiping Null payload");
532 SetResult(otmCtx, OC_STACK_ERROR);
533 return OC_STACK_DELETE_TRANSACTION;
536 if (PAYLOAD_TYPE_SECURITY != clientResponse->payload->type)
538 OIC_LOG(INFO, TAG, "Unknown payload type");
539 SetResult(otmCtx, OC_STACK_ERROR);
540 return OC_STACK_DELETE_TRANSACTION;
542 OicSecPstat_t* pstat = NULL;
543 OCStackResult result = CBORPayloadToPstat(
544 ((OCSecurityPayload*)clientResponse->payload)->securityData1,
545 ((OCSecurityPayload*)clientResponse->payload)->payloadSize,
547 if(NULL == pstat && result != OC_STACK_OK)
549 OIC_LOG(ERROR, TAG, "Error while converting cbor to pstat.");
550 SetResult(otmCtx, OC_STACK_ERROR);
551 return OC_STACK_DELETE_TRANSACTION;
553 if(false == (TAKE_OWNER & pstat->cm))
555 OIC_LOG(ERROR, TAG, "Device pairing mode enabling owner transfer operations is disabled");
556 SetResult(otmCtx, OC_STACK_ERROR);
557 return OC_STACK_DELETE_TRANSACTION;
559 otmCtx->selectedDeviceInfo->pstat = pstat;
561 //Select operation mode (Currently supported SINGLE_SERVICE_CLIENT_DRIVEN only)
562 SelectOperationMode(otmCtx->selectedDeviceInfo, &(otmCtx->selectedDeviceInfo->pstat->om));
564 //Send request : PUT /oic/sec/pstat [{"om":"bx11", .. }]
565 OCStackResult res = PutUpdateOperationMode(otmCtx);
566 if (OC_STACK_OK != res)
568 OIC_LOG(ERROR, TAG, "Error while updating operation mode.");
569 SetResult(otmCtx, res);
574 OIC_LOG_V(WARNING, TAG, "ListMethodsHandler : Client response is incorrect : %d",
575 clientResponse->result);
576 SetResult(otmCtx, clientResponse->result);
579 OIC_LOG(DEBUG, TAG, "OUT ListMethodsHandler");
581 return OC_STACK_DELETE_TRANSACTION;
585 * Response handler for update owner uuid request.
587 * @param[in] ctx ctx value passed to callback from calling function.
588 * @param[in] UNUSED handle to an invocation
589 * @param[in] clientResponse Response from queries to remote servers.
590 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
591 * and OC_STACK_KEEP_TRANSACTION to keep it.
593 static OCStackApplicationResult OwnerUuidUpdateHandler(void *ctx, OCDoHandle UNUSED,
594 OCClientResponse *clientResponse)
596 VERIFY_NON_NULL(TAG, clientResponse, WARNING);
597 VERIFY_NON_NULL(TAG, ctx, WARNING);
599 OIC_LOG(DEBUG, TAG, "IN OwnerUuidUpdateHandler");
601 OCStackResult res = OC_STACK_OK;
602 OTMContext_t* otmCtx = (OTMContext_t*)ctx;
604 if(OC_STACK_OK == clientResponse->result)
606 if(otmCtx && otmCtx->selectedDeviceInfo)
608 res = SaveOwnerPSK(otmCtx->selectedDeviceInfo);
609 if(OC_STACK_OK != res)
611 OIC_LOG(ERROR, TAG, "OwnerUuidUpdateHandler:Failed to owner PSK generation");
612 SetResult(otmCtx, res);
613 return OC_STACK_DELETE_TRANSACTION;
616 //PUT owner credential to new device according to security spec B.
617 res = PutOwnerCredential(otmCtx);
618 if(OC_STACK_OK != res)
621 "OwnerUuidUpdateHandler:Failed to send PUT request for onwer credential");
622 SetResult(otmCtx, res);
623 return OC_STACK_DELETE_TRANSACTION;
629 res = clientResponse->result;
630 OIC_LOG_V(ERROR, TAG, "OwnerUuidHandler : Unexpected result %d", res);
631 SetResult(otmCtx, res);
634 OIC_LOG(DEBUG, TAG, "OUT OwnerUuidUpdateHandler");
637 return OC_STACK_DELETE_TRANSACTION;
641 * Response handler for update operation mode.
643 * @param[in] ctx ctx value passed to callback from calling function.
644 * @param[in] UNUSED handle to an invocation
645 * @param[in] clientResponse Response from queries to remote servers.
646 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
647 * and OC_STACK_KEEP_TRANSACTION to keep it.
649 static OCStackApplicationResult OperationModeUpdateHandler(void *ctx, OCDoHandle UNUSED,
650 OCClientResponse *clientResponse)
652 OIC_LOG(DEBUG, TAG, "IN OperationModeUpdateHandler");
654 VERIFY_NON_NULL(TAG, clientResponse, WARNING);
655 VERIFY_NON_NULL(TAG, ctx, WARNING);
657 OTMContext_t* otmCtx = (OTMContext_t*)ctx;
659 if (OC_STACK_OK == clientResponse->result)
661 OCStackResult res = OC_STACK_ERROR;
662 OicSecOxm_t selOxm = otmCtx->selectedDeviceInfo->doxm->oxmSel;
664 //Load secret for temporal secure session.
665 if(g_OTMDatas[selOxm].loadSecretCB)
667 res = g_OTMDatas[selOxm].loadSecretCB(otmCtx);
668 if(OC_STACK_OK != res)
670 OIC_LOG(ERROR, TAG, "OperationModeUpdate : Failed to load secret");
671 SetResult(otmCtx, res);
672 return OC_STACK_DELETE_TRANSACTION;
676 //It will be used in handshake event handler
679 //Try DTLS handshake to generate secure session
680 if(g_OTMDatas[selOxm].createSecureSessionCB)
682 res = g_OTMDatas[selOxm].createSecureSessionCB(otmCtx);
683 if(OC_STACK_OK != res)
685 OIC_LOG(ERROR, TAG, "OperationModeUpdate : Failed to create DTLS session");
686 SetResult(otmCtx, res);
687 return OC_STACK_DELETE_TRANSACTION;
693 OIC_LOG(ERROR, TAG, "Error while update operation mode");
694 SetResult(otmCtx, clientResponse->result);
697 OIC_LOG(DEBUG, TAG, "OUT OperationModeUpdateHandler");
700 return OC_STACK_DELETE_TRANSACTION;
704 * Response handler for update owner crendetial request.
706 * @param[in] ctx ctx value passed to callback from calling function.
707 * @param[in] UNUSED handle to an invocation
708 * @param[in] clientResponse Response from queries to remote servers.
709 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
710 * and OC_STACK_KEEP_TRANSACTION to keep it.
712 static OCStackApplicationResult OwnerCredentialHandler(void *ctx, OCDoHandle UNUSED,
713 OCClientResponse *clientResponse)
715 VERIFY_NON_NULL(TAG, clientResponse, WARNING);
716 VERIFY_NON_NULL(TAG, ctx, WARNING);
718 OIC_LOG(DEBUG, TAG, "IN OwnerCredentialHandler");
720 OCStackResult res = OC_STACK_OK;
721 OTMContext_t* otmCtx = (OTMContext_t*)ctx;
723 if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
725 if(otmCtx && otmCtx->selectedDeviceInfo)
727 //Close the temporal secure session to verify the owner credential
728 CAEndpoint_t* endpoint = (CAEndpoint_t *)&otmCtx->selectedDeviceInfo->endpoint;
729 endpoint->port = otmCtx->selectedDeviceInfo->securePort;
730 CAResult_t caResult = CACloseDtlsSession(endpoint);
731 if(CA_STATUS_OK != caResult)
733 OIC_LOG(ERROR, TAG, "Failed to close DTLS session");
734 SetResult(otmCtx, caResult);
735 return OC_STACK_DELETE_TRANSACTION;
739 * If we select NULL cipher,
740 * client will select appropriate cipher suite according to server's cipher-suite list.
742 caResult = CASelectCipherSuite(TLS_NULL_WITH_NULL_NULL);
743 if(CA_STATUS_OK != caResult)
745 OIC_LOG(ERROR, TAG, "Failed to select TLS_NULL_WITH_NULL_NULL");
746 SetResult(otmCtx, caResult);
747 return OC_STACK_DELETE_TRANSACTION;
751 * in case of random PIN based OxM,
752 * revert get_psk_info callback of tinyDTLS to use owner credential.
754 if(OIC_RANDOM_DEVICE_PIN == otmCtx->selectedDeviceInfo->doxm->oxmSel)
756 OicUuid_t emptyUuid = { .id={0}};
757 SetUuidForRandomPinOxm(&emptyUuid);
759 if(CA_STATUS_OK != CARegisterDTLSCredentialsHandler(GetDtlsPskCredentials))
761 OIC_LOG(ERROR, TAG, "Failed to revert DTLS credential handler.");
762 SetResult(otmCtx, OC_STACK_INVALID_CALLBACK);
763 return OC_STACK_DELETE_TRANSACTION;
767 //PUT /oic/sec/doxm [{ ..., "owned":"TRUE" }]
768 res = PutOwnershipInformation(otmCtx);
769 if(OC_STACK_OK != res)
771 OIC_LOG(ERROR, TAG, "Failed to put ownership information to new device");
772 SetResult(otmCtx, res);
773 return OC_STACK_DELETE_TRANSACTION;
779 res = clientResponse->result;
780 OIC_LOG_V(ERROR, TAG, "OwnerCredentialHandler : Unexpected result %d", res);
781 SetResult(otmCtx, res);
784 OIC_LOG(DEBUG, TAG, "OUT OwnerCredentialHandler");
787 return OC_STACK_DELETE_TRANSACTION;
792 * Response handler for update owner information request.
794 * @param[in] ctx ctx value passed to callback from calling function.
795 * @param[in] UNUSED handle to an invocation
796 * @param[in] clientResponse Response from queries to remote servers.
797 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
798 * and OC_STACK_KEEP_TRANSACTION to keep it.
800 static OCStackApplicationResult OwnershipInformationHandler(void *ctx, OCDoHandle UNUSED,
801 OCClientResponse *clientResponse)
803 VERIFY_NON_NULL(TAG, clientResponse, WARNING);
804 VERIFY_NON_NULL(TAG, ctx, WARNING);
806 OIC_LOG(DEBUG, TAG, "IN OwnershipInformationHandler");
808 OCStackResult res = OC_STACK_OK;
809 OTMContext_t* otmCtx = (OTMContext_t*)ctx;
811 if(OC_STACK_OK == clientResponse->result)
813 if(otmCtx && otmCtx->selectedDeviceInfo)
815 OIC_LOG(INFO, TAG, "Ownership transfer was successfully completed.");
816 OIC_LOG(INFO, TAG, "Start defualt ACL & commit-hash provisioning.");
818 res = PutProvisioningStatus(otmCtx);
819 if(OC_STACK_OK != res)
821 OIC_LOG(ERROR, TAG, "Failed to update pstat");
822 SetResult(otmCtx, res);
828 res = clientResponse->result;
829 OIC_LOG_V(ERROR, TAG, "OwnershipInformationHandler : Unexpected result %d", res);
830 SetResult(otmCtx, res);
833 OIC_LOG(DEBUG, TAG, "OUT OwnershipInformationHandler");
836 return OC_STACK_DELETE_TRANSACTION;
840 * Response handler of update provisioning status.
842 * @param[in] ctx ctx value passed to callback from calling function.
843 * @param[in] UNUSED handle to an invocation
844 * @param[in] clientResponse Response from queries to remote servers.
845 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
846 * and OC_STACK_KEEP_TRANSACTION to keep it.
848 static OCStackApplicationResult ProvisioningStatusHandler(void *ctx, OCDoHandle UNUSED,
849 OCClientResponse *clientResponse)
851 OIC_LOG_V(INFO, TAG, "IN ProvisioningStatusHandler.");
853 VERIFY_NON_NULL(TAG, clientResponse, ERROR);
854 VERIFY_NON_NULL(TAG, ctx, ERROR);
856 OTMContext_t* otmCtx = (OTMContext_t*) ctx;
859 if (OC_STACK_OK == clientResponse->result)
861 OCStackResult res = PDMAddDevice(&otmCtx->selectedDeviceInfo->doxm->deviceID);
862 if (OC_STACK_OK == res)
864 OIC_LOG_V(INFO, TAG, "Add device's UUID in PDM_DB");
865 SetResult(otmCtx, OC_STACK_OK);
866 return OC_STACK_DELETE_TRANSACTION;
870 OIC_LOG(ERROR, TAG, "Ownership transfer is complete but adding information to DB is failed.");
875 OIC_LOG_V(INFO, TAG, "Error occured in provisionDefaultACLCB :: %d\n",
876 clientResponse->result);
877 SetResult(otmCtx, clientResponse->result);
882 OIC_LOG_V(INFO, TAG, "OUT ProvisioningStatusHandler.");
883 return OC_STACK_DELETE_TRANSACTION;
886 static OCStackResult PutOwnerCredential(OTMContext_t* otmCtx)
888 OIC_LOG(DEBUG, TAG, "IN PutOwnerCredential");
890 if(!otmCtx || !otmCtx->selectedDeviceInfo)
892 OIC_LOG(ERROR, TAG, "Invalid parameters");
893 return OC_STACK_INVALID_PARAM;
896 OCProvisionDev_t* deviceInfo = otmCtx->selectedDeviceInfo;
897 char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
899 if(!PMGenerateQuery(true,
900 deviceInfo->endpoint.addr, deviceInfo->securePort,
901 deviceInfo->connType,
902 query, sizeof(query), OIC_RSRC_CRED_URI))
904 OIC_LOG(ERROR, TAG, "PutOwnerCredential : Failed to generate query");
905 return OC_STACK_ERROR;
907 OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
908 OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
911 OIC_LOG(ERROR, TAG, "Failed to memory allocation");
912 return OC_STACK_NO_MEMORY;
915 //Generate owner credential for new device
916 secPayload->base.type = PAYLOAD_TYPE_SECURITY;
917 OicSecCred_t* ownerCredential = GetCredResourceData(&(deviceInfo->doxm->deviceID));
920 OIC_LOG(ERROR, TAG, "Can not find OwnerPSK.");
921 return OC_STACK_NO_RESOURCE;
924 OicUuid_t credSubjectId = {.id={0}};
925 if(OC_STACK_OK == GetDoxmDeviceID(&credSubjectId))
927 OicSecCred_t newCredential;
928 memcpy(&newCredential, ownerCredential, sizeof(OicSecCred_t));
929 newCredential.next = NULL;
931 //Set subject ID as PT's ID
932 memcpy(&(newCredential.subject), &credSubjectId, sizeof(OicUuid_t));
934 //Fill private data as empty string
935 newCredential.privateData.data = NULL;
936 newCredential.privateData.len = 0;
938 newCredential.publicData.data = NULL;
939 newCredential.publicData.len = 0;
942 //Send owner credential to new device : PUT /oic/sec/cred [ owner credential ]
943 if (OC_STACK_OK != CredToCBORPayload(&newCredential, &secPayload->securityData1, &secPayload->payloadSize))
946 OIC_LOG(ERROR, TAG, "Error while converting bin to cbor.");
947 return OC_STACK_ERROR;
949 OIC_LOG_V(DEBUG, TAG, "Payload : %s", secPayload->securityData1);
951 OCCallbackData cbData;
952 cbData.cb = &OwnerCredentialHandler;
953 cbData.context = (void *)otmCtx;
955 OCStackResult res = OCDoResource(NULL, OC_REST_PUT, query,
956 &deviceInfo->endpoint, (OCPayload*)secPayload,
957 deviceInfo->connType, OC_LOW_QOS, &cbData, NULL, 0);
958 if (res != OC_STACK_OK)
960 OIC_LOG(ERROR, TAG, "OCStack resource error");
965 OIC_LOG(ERROR, TAG, "Failed to read DOXM device ID.");
966 return OC_STACK_NO_RESOURCE;
969 OIC_LOG(DEBUG, TAG, "OUT PutOwnerCredential");
974 static OCStackResult PutOwnerTransferModeToResource(OTMContext_t* otmCtx)
976 OIC_LOG(DEBUG, TAG, "IN PutOwnerTransferModeToResource");
978 if(!otmCtx || !otmCtx->selectedDeviceInfo)
980 OIC_LOG(ERROR, TAG, "Invalid parameters");
981 return OC_STACK_INVALID_PARAM;
984 OCProvisionDev_t* deviceInfo = otmCtx->selectedDeviceInfo;
985 OicSecOxm_t selectedOxm = deviceInfo->doxm->oxmSel;
986 char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
988 if(!PMGenerateQuery(false,
989 deviceInfo->endpoint.addr, deviceInfo->endpoint.port,
990 deviceInfo->connType,
991 query, sizeof(query), OIC_RSRC_DOXM_URI))
993 OIC_LOG(ERROR, TAG, "PutOwnerTransferModeToResource : Failed to generate query");
994 return OC_STACK_ERROR;
996 OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
997 OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
1000 OIC_LOG(ERROR, TAG, "Failed to memory allocation");
1001 return OC_STACK_NO_MEMORY;
1003 secPayload->base.type = PAYLOAD_TYPE_SECURITY;
1004 OCStackResult res = g_OTMDatas[selectedOxm].createSelectOxmPayloadCB(otmCtx,
1005 &secPayload->securityData1, &secPayload->payloadSize);
1006 if (OC_STACK_OK != res && NULL == secPayload->securityData1)
1008 OCPayloadDestroy((OCPayload *)secPayload);
1009 OIC_LOG(ERROR, TAG, "Error while converting bin to cbor");
1010 return OC_STACK_ERROR;
1013 OCCallbackData cbData;
1014 cbData.cb = &OwnerTransferModeHandler;
1015 cbData.context = (void *)otmCtx;
1017 res = OCDoResource(NULL, OC_REST_PUT, query,
1018 &deviceInfo->endpoint, (OCPayload *)secPayload,
1019 deviceInfo->connType, OC_LOW_QOS, &cbData, NULL, 0);
1020 if (res != OC_STACK_OK)
1022 OIC_LOG(ERROR, TAG, "OCStack resource error");
1025 OIC_LOG(DEBUG, TAG, "OUT PutOwnerTransferModeToResource");
1030 static OCStackResult GetProvisioningStatusResource(OTMContext_t* otmCtx)
1032 OIC_LOG(DEBUG, TAG, "IN GetProvisioningStatusResource");
1034 if(!otmCtx || !otmCtx->selectedDeviceInfo)
1036 OIC_LOG(ERROR, TAG, "Invailed parameters");
1037 return OC_STACK_INVALID_PARAM;
1040 OCProvisionDev_t* deviceInfo = otmCtx->selectedDeviceInfo;
1041 char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
1042 if(!PMGenerateQuery(false,
1043 deviceInfo->endpoint.addr, deviceInfo->endpoint.port,
1044 deviceInfo->connType,
1045 query, sizeof(query), OIC_RSRC_PSTAT_URI))
1047 OIC_LOG(ERROR, TAG, "GetProvisioningStatusResource : Failed to generate query");
1048 return OC_STACK_ERROR;
1050 OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
1052 OCCallbackData cbData;
1053 cbData.cb = &ListMethodsHandler;
1054 cbData.context = (void *)otmCtx;
1056 OCStackResult res = OCDoResource(NULL, OC_REST_GET, query, NULL, NULL,
1057 deviceInfo->connType, OC_LOW_QOS, &cbData, NULL, 0);
1058 if (res != OC_STACK_OK)
1060 OIC_LOG(ERROR, TAG, "OCStack resource error");
1063 OIC_LOG(DEBUG, TAG, "OUT GetProvisioningStatusResource");
1068 static OCStackResult PutOwnerUuid(OTMContext_t* otmCtx)
1070 OIC_LOG(DEBUG, TAG, "IN PutOwnerUuid");
1072 if(!otmCtx || !otmCtx->selectedDeviceInfo)
1074 OIC_LOG(ERROR, TAG, "Invailed parameters");
1075 return OC_STACK_INVALID_PARAM;
1078 OCProvisionDev_t* deviceInfo = otmCtx->selectedDeviceInfo;
1079 char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
1080 if(!PMGenerateQuery(true,
1081 deviceInfo->endpoint.addr, deviceInfo->securePort,
1082 deviceInfo->connType,
1083 query, sizeof(query), OIC_RSRC_DOXM_URI))
1085 OIC_LOG(ERROR, TAG, "PutOwnershipInformation : Failed to generate query");
1086 return OC_STACK_ERROR;
1088 OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
1090 //PUT PT's uuid to new device
1091 OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
1094 OIC_LOG(ERROR, TAG, "Failed to memory allocation");
1095 return OC_STACK_NO_MEMORY;
1097 secPayload->base.type = PAYLOAD_TYPE_SECURITY;
1098 OCStackResult res = g_OTMDatas[deviceInfo->doxm->oxmSel].createOwnerTransferPayloadCB(
1099 otmCtx, &secPayload->securityData1, &secPayload->payloadSize);
1100 if (NULL == secPayload->securityData1)
1102 OCPayloadDestroy((OCPayload *)secPayload);
1103 OIC_LOG(ERROR, TAG, "Error while converting doxm bin to cbor.");
1104 return OC_STACK_INVALID_PARAM;
1106 OIC_LOG_V(DEBUG, TAG, "Payload : %s", secPayload->securityData1);
1108 OCCallbackData cbData;
1109 cbData.cb = &OwnerUuidUpdateHandler;
1110 cbData.context = (void *)otmCtx;
1113 res = OCDoResource(NULL, OC_REST_PUT, query, 0, (OCPayload *)secPayload,
1114 deviceInfo->connType, OC_LOW_QOS, &cbData, NULL, 0);
1115 if (res != OC_STACK_OK)
1117 OIC_LOG(ERROR, TAG, "OCStack resource error");
1120 OIC_LOG(DEBUG, TAG, "OUT PutOwnerUuid");
1125 static OCStackResult PutOwnershipInformation(OTMContext_t* otmCtx)
1127 OIC_LOG(DEBUG, TAG, "IN PutOwnershipInformation");
1129 if(!otmCtx || !otmCtx->selectedDeviceInfo)
1131 OIC_LOG(ERROR, TAG, "Invailed parameters");
1132 return OC_STACK_INVALID_PARAM;
1135 OCProvisionDev_t* deviceInfo = otmCtx->selectedDeviceInfo;
1136 char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
1137 if(!PMGenerateQuery(true,
1138 deviceInfo->endpoint.addr, deviceInfo->securePort,
1139 deviceInfo->connType,
1140 query, sizeof(query), OIC_RSRC_DOXM_URI))
1142 OIC_LOG(ERROR, TAG, "PutOwnershipInformation : Failed to generate query");
1143 return OC_STACK_ERROR;
1145 OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
1147 //OwnershipInformationHandler
1148 OCSecurityPayload *secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
1151 OIC_LOG(ERROR, TAG, "Failed to memory allocation");
1152 return OC_STACK_NO_MEMORY;
1155 otmCtx->selectedDeviceInfo->doxm->owned = true;
1157 secPayload->base.type = PAYLOAD_TYPE_SECURITY;
1158 OCStackResult res = DoxmToCBORPayload(otmCtx->selectedDeviceInfo->doxm,
1159 &secPayload->securityData1, &secPayload->payloadSize);
1160 if (OC_STACK_OK != res && NULL == secPayload->securityData1)
1162 OCPayloadDestroy((OCPayload *)secPayload);
1163 OIC_LOG(ERROR, TAG, "Error while converting doxm bin to json");
1164 return OC_STACK_INVALID_PARAM;
1167 OCCallbackData cbData;
1168 cbData.cb = &OwnershipInformationHandler;
1169 cbData.context = (void *)otmCtx;
1172 res = OCDoResource(NULL, OC_REST_PUT, query, 0, (OCPayload*)secPayload,
1173 deviceInfo->connType, OC_LOW_QOS, &cbData, NULL, 0);
1174 if (res != OC_STACK_OK)
1176 OIC_LOG(ERROR, TAG, "OCStack resource error");
1179 OIC_LOG(DEBUG, TAG, "OUT PutOwnershipInformation");
1184 static OCStackResult PutUpdateOperationMode(OTMContext_t* otmCtx)
1186 OIC_LOG(DEBUG, TAG, "IN PutUpdateOperationMode");
1188 if(!otmCtx || !otmCtx->selectedDeviceInfo)
1190 return OC_STACK_INVALID_PARAM;
1193 OCProvisionDev_t* deviceInfo = otmCtx->selectedDeviceInfo;
1194 char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
1195 if(!PMGenerateQuery(false,
1196 deviceInfo->endpoint.addr, deviceInfo->endpoint.port,
1197 deviceInfo->connType,
1198 query, sizeof(query), OIC_RSRC_PSTAT_URI))
1200 OIC_LOG(ERROR, TAG, "PutUpdateOperationMode : Failed to generate query");
1201 return OC_STACK_ERROR;
1203 OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
1205 OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
1208 OIC_LOG(ERROR, TAG, "Failed to memory allocation");
1209 return OC_STACK_NO_MEMORY;
1211 secPayload->base.type = PAYLOAD_TYPE_SECURITY;
1212 OCStackResult res = PstatToCBORPayload(deviceInfo->pstat, &secPayload->securityData1,
1213 &secPayload->payloadSize);
1214 if (OC_STACK_OK != res)
1216 OCPayloadDestroy((OCPayload *)secPayload);
1217 OIC_LOG(ERROR, TAG, "Error while converting pstat to cbor.");
1218 return OC_STACK_INVALID_PARAM;
1221 OCCallbackData cbData;
1222 cbData.cb = &OperationModeUpdateHandler;
1223 cbData.context = (void *)otmCtx;
1225 res = OCDoResource(NULL, OC_REST_PUT, query, 0, (OCPayload *)secPayload,
1226 deviceInfo->connType, OC_LOW_QOS, &cbData, NULL, 0);
1227 if (res != OC_STACK_OK)
1229 OIC_LOG(ERROR, TAG, "OCStack resource error");
1232 OIC_LOG(DEBUG, TAG, "OUT PutUpdateOperationMode");
1237 static OCStackResult StartOwnershipTransfer(void* ctx, OCProvisionDev_t* selectedDevice)
1239 OIC_LOG(INFO, TAG, "IN StartOwnershipTransfer");
1240 OTMContext_t* otmCtx = (OTMContext_t*)ctx;
1241 otmCtx->selectedDeviceInfo = selectedDevice;
1243 //Set to the lowest level OxM, and then find more higher level OxM.
1244 OCStackResult res = SelectProvisioningMethod(selectedDevice->doxm->oxm,
1245 selectedDevice->doxm->oxmLen,
1246 &selectedDevice->doxm->oxmSel);
1247 if(OC_STACK_OK != res)
1249 OIC_LOG(ERROR, TAG, "Failed to select the provisioning method");
1250 SetResult(otmCtx, res);
1253 OIC_LOG_V(DEBUG, TAG, "Selected provisoning method = %d", selectedDevice->doxm->oxmSel);
1255 //Send Req: PUT /oic/sec/doxm [{..."OxmSel" :g_OTMDatas[Index of Selected OxM].OXMString,...}]
1256 res = PutOwnerTransferModeToResource(otmCtx);
1257 if(OC_STACK_OK != res)
1259 OIC_LOG(WARNING, TAG, "Failed to select the provisioning method");
1260 SetResult(otmCtx, res);
1264 //Register DTLS event handler to catch the dtls event while handshake
1265 if(CA_STATUS_OK != CARegisterDTLSHandshakeCallback(DTLSHandshakeCB))
1267 OIC_LOG(WARNING, TAG, "StartOwnershipTransfer : Failed to register DTLS handshake callback.");
1270 OIC_LOG(INFO, TAG, "OUT StartOwnershipTransfer");
1276 OCStackResult OTMSetOwnershipTransferCallbackData(OicSecOxm_t oxmType, OTMCallbackData_t* data)
1278 OIC_LOG(DEBUG, TAG, "IN OTMSetOwnerTransferCallbackData");
1282 OIC_LOG(ERROR, TAG, "OTMSetOwnershipTransferCallbackData : Invalid parameters");
1283 return OC_STACK_INVALID_PARAM;
1285 if(oxmType >= OIC_OXM_COUNT)
1287 OIC_LOG(INFO, TAG, "Unknow ownership transfer method");
1288 return OC_STACK_INVALID_PARAM;
1291 g_OTMDatas[oxmType].loadSecretCB= data->loadSecretCB;
1292 g_OTMDatas[oxmType].createSecureSessionCB = data->createSecureSessionCB;
1293 g_OTMDatas[oxmType].createSelectOxmPayloadCB = data->createSelectOxmPayloadCB;
1294 g_OTMDatas[oxmType].createOwnerTransferPayloadCB = data->createOwnerTransferPayloadCB;
1296 OIC_LOG(DEBUG, TAG, "OUT OTMSetOwnerTransferCallbackData");
1302 * NOTE : Unowned discovery should be done before performing OTMDoOwnershipTransfer
1304 OCStackResult OTMDoOwnershipTransfer(void* ctx,
1305 OCProvisionDev_t *selectedDevicelist,
1306 OCProvisionResultCB resultCallback)
1308 OIC_LOG(DEBUG, TAG, "IN OTMDoOwnershipTransfer");
1310 if (NULL == selectedDevicelist)
1312 return OC_STACK_INVALID_PARAM;
1314 if (NULL == resultCallback)
1316 return OC_STACK_INVALID_CALLBACK;
1319 OTMContext_t* otmCtx = (OTMContext_t*)OICCalloc(1,sizeof(OTMContext_t));
1322 OIC_LOG(ERROR, TAG, "Failed to create OTM Context");
1323 return OC_STACK_NO_MEMORY;
1325 otmCtx->ctxResultCallback = resultCallback;
1326 otmCtx->ctxHasError = false;
1327 otmCtx->userCtx = ctx;
1328 OCProvisionDev_t* pCurDev = selectedDevicelist;
1330 //Counting number of selected devices.
1331 otmCtx->ctxResultArraySize = 0;
1332 while(NULL != pCurDev)
1334 otmCtx->ctxResultArraySize++;
1335 pCurDev = pCurDev->next;
1338 otmCtx->ctxResultArray =
1339 (OCProvisionResult_t*)OICCalloc(otmCtx->ctxResultArraySize, sizeof(OCProvisionResult_t));
1340 if(NULL == otmCtx->ctxResultArray)
1342 OIC_LOG(ERROR, TAG, "OTMDoOwnershipTransfer : Failed to memory allocation");
1344 return OC_STACK_NO_MEMORY;
1346 pCurDev = selectedDevicelist;
1348 OCStackResult res = OC_STACK_OK;
1349 //Fill the device UUID for result array.
1350 for(size_t devIdx = 0; devIdx < otmCtx->ctxResultArraySize; devIdx++)
1352 //Checking duplication of Device ID.
1353 bool isDuplicate = true;
1354 res = PDMIsDuplicateDevice(&pCurDev->doxm->deviceID, &isDuplicate);
1355 if (OC_STACK_OK != res)
1361 OIC_LOG(ERROR, TAG, "OTMDoOwnershipTransfer : Device ID is duplicated");
1362 res = OC_STACK_INVALID_PARAM;
1365 memcpy(otmCtx->ctxResultArray[devIdx].deviceId.id,
1366 pCurDev->doxm->deviceID.id,
1368 otmCtx->ctxResultArray[devIdx].res = OC_STACK_CONTINUE;
1369 pCurDev = pCurDev->next;
1372 StartOwnershipTransfer(otmCtx, selectedDevicelist);
1374 OIC_LOG(DEBUG, TAG, "OUT OTMDoOwnershipTransfer");
1378 OICFree(otmCtx->ctxResultArray);
1384 * Callback handler of SRPFinalizeProvisioning.
1386 * @param[in] ctx ctx value passed to callback from calling function.
1387 * @param[in] UNUSED handle to an invocation
1388 * @param[in] clientResponse Response from queries to remote servers.
1389 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
1390 * and OC_STACK_KEEP_TRANSACTION to keep it.
1392 static OCStackApplicationResult FinalizeProvisioningCB(void *ctx, OCDoHandle UNUSED,
1393 OCClientResponse *clientResponse)
1395 OIC_LOG_V(INFO, TAG, "IN FinalizeProvisioningCB.");
1397 VERIFY_NON_NULL(TAG, clientResponse, ERROR);
1398 VERIFY_NON_NULL(TAG, ctx, ERROR);
1400 OTMContext_t* otmCtx = (OTMContext_t*)ctx;
1402 if(OC_STACK_OK == clientResponse->result)
1404 OCStackResult res = PDMAddDevice(&otmCtx->selectedDeviceInfo->doxm->deviceID);
1406 if (OC_STACK_OK == res)
1408 OIC_LOG_V(INFO, TAG, "Add device's UUID in PDM_DB");
1409 SetResult(otmCtx, OC_STACK_OK);
1410 return OC_STACK_DELETE_TRANSACTION;
1414 OIC_LOG(ERROR, TAG, "Ownership transfer is complete but adding information to DB is failed.");
1418 return OC_STACK_DELETE_TRANSACTION;
1422 * Callback handler of default ACL provisioning.
1424 * @param[in] ctx ctx value passed to callback from calling function.
1425 * @param[in] UNUSED handle to an invocation
1426 * @param[in] clientResponse Response from queries to remote servers.
1427 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
1428 * and OC_STACK_KEEP_TRANSACTION to keep it.
1430 static OCStackApplicationResult ProvisionDefaultACLCB(void *ctx, OCDoHandle UNUSED,
1431 OCClientResponse *clientResponse)
1433 OIC_LOG_V(INFO, TAG, "IN ProvisionDefaultACLCB.");
1435 VERIFY_NON_NULL(TAG, clientResponse, ERROR);
1436 VERIFY_NON_NULL(TAG, ctx, ERROR);
1438 OTMContext_t* otmCtx = (OTMContext_t*) ctx;
1441 if (OC_STACK_RESOURCE_CREATED == clientResponse->result)
1443 OIC_LOG_V(INFO, TAG, "Staring commit hash task.");
1444 // TODO hash currently have fixed value 0.
1445 uint16_t aclHash = 0;
1446 otmCtx->selectedDeviceInfo->pstat->commitHash = aclHash;
1447 otmCtx->selectedDeviceInfo->pstat->tm = NORMAL;
1448 OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
1451 OIC_LOG(ERROR, TAG, "Failed to memory allocation");
1452 return OC_STACK_NO_MEMORY;
1454 secPayload->base.type = PAYLOAD_TYPE_SECURITY;
1455 OCStackResult res = PstatToCBORPayload(otmCtx->selectedDeviceInfo->pstat,
1456 &secPayload->securityData1, &secPayload->payloadSize);
1457 if (OC_STACK_OK != res || NULL == secPayload->securityData1)
1459 OICFree(secPayload);
1460 SetResult(otmCtx, OC_STACK_INVALID_JSON);
1461 return OC_STACK_DELETE_TRANSACTION;
1464 char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
1465 if(!PMGenerateQuery(true,
1466 otmCtx->selectedDeviceInfo->endpoint.addr,
1467 otmCtx->selectedDeviceInfo->securePort,
1468 otmCtx->selectedDeviceInfo->connType,
1469 query, sizeof(query), OIC_RSRC_PSTAT_URI))
1471 OIC_LOG(ERROR, TAG, "ProvisionDefaultACLCB : Failed to generate query");
1472 return OC_STACK_ERROR;
1474 OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
1476 OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL};
1477 cbData.cb = &FinalizeProvisioningCB;
1478 cbData.context = (void*)otmCtx;
1480 OCStackResult ret = OCDoResource(NULL, OC_REST_PUT, query, 0, (OCPayload*)secPayload,
1481 otmCtx->selectedDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
1482 OIC_LOG_V(INFO, TAG, "OCDoResource returned: %d",ret);
1483 if (ret != OC_STACK_OK)
1485 OIC_LOG(ERROR, TAG, "OCStack resource error");
1486 SetResult(otmCtx, ret);
1491 OIC_LOG_V(INFO, TAG, "Error occured in provisionDefaultACLCB :: %d\n",
1492 clientResponse->result);
1493 SetResult(otmCtx, clientResponse->result);
1496 return OC_STACK_DELETE_TRANSACTION;
1499 OCStackResult PutProvisioningStatus(OTMContext_t* otmCtx)
1501 OIC_LOG(INFO, TAG, "IN PutProvisioningStatus");
1505 OIC_LOG(ERROR, TAG, "OTMContext is NULL");
1506 return OC_STACK_INVALID_PARAM;
1508 if(!otmCtx->selectedDeviceInfo)
1510 OIC_LOG(ERROR, TAG, "Can't find device information in OTMContext");
1512 return OC_STACK_INVALID_PARAM;
1515 //Change the TAKE_OWNER bit of CM to 0.
1516 otmCtx->selectedDeviceInfo->pstat->cm &= (~TAKE_OWNER);
1518 OCSecurityPayload *secPayload = (OCSecurityPayload *)OICCalloc(1, sizeof(OCSecurityPayload));
1521 OIC_LOG(ERROR, TAG, "Failed to memory allocation");
1522 return OC_STACK_NO_MEMORY;
1524 secPayload->base.type = PAYLOAD_TYPE_SECURITY;
1525 if (OC_STACK_OK != PstatToCBORPayload(otmCtx->selectedDeviceInfo->pstat,
1526 &secPayload->securityData1, &secPayload->payloadSize))
1528 OCPayloadDestroy((OCPayload *)secPayload);
1529 SetResult(otmCtx, OC_STACK_INVALID_JSON);
1530 return OC_STACK_INVALID_JSON;
1532 OIC_LOG_V(INFO, TAG, "Created payload for commit hash: %s",secPayload->securityData1);
1534 char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
1535 if(!PMGenerateQuery(true,
1536 otmCtx->selectedDeviceInfo->endpoint.addr,
1537 otmCtx->selectedDeviceInfo->securePort,
1538 otmCtx->selectedDeviceInfo->connType,
1539 query, sizeof(query), OIC_RSRC_PSTAT_URI))
1541 OIC_LOG(ERROR, TAG, "PutProvisioningStatus : Failed to generate query");
1542 return OC_STACK_ERROR;
1544 OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
1546 OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL};
1547 cbData.cb = &ProvisioningStatusHandler;
1548 cbData.context = (void*)otmCtx;
1550 OCStackResult ret = OCDoResource(NULL, OC_REST_PUT, query, 0, (OCPayload*)secPayload,
1551 otmCtx->selectedDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
1552 OIC_LOG_V(INFO, TAG, "OCDoResource returned: %d",ret);
1553 if (ret != OC_STACK_OK)
1555 OIC_LOG(ERROR, TAG, "OCStack resource error");
1556 SetResult(otmCtx, ret);
1559 OIC_LOG(INFO, TAG, "OUT PutProvisioningStatus");