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 * *****************************************************************/
27 #include "ocprovisioningmanager.h"
28 #include "secureresourceprovider.h"
30 #include "oic_malloc.h"
31 #include "aclresource.h"
32 #include "pstatresource.h"
33 #include "srmresourcestrings.h"
34 #include "credresource.h"
35 #include "doxmresource.h"
36 #include "pconfresource.h"
37 #include "credentialgenerator.h"
38 #include "cainterface.h"
41 #include "pmutility.h"
42 #include "provisioningdatabasemanager.h"
45 #include "ocpayload.h"
48 #include "crlresource.h"
54 * Macro to verify argument is not equal to NULL.
55 * eg: VERIFY_NON_NULL(TAG, ptrData, ERROR,OC_STACK_ERROR);
57 #define VERIFY_NON_NULL(tag, arg, logLevel, retValue) { if (NULL == (arg)) \
58 { OIC_LOG((logLevel), tag, #arg " is NULL"); return retValue; } }
61 * Macro to verify success of operation.
62 * eg: VERIFY_SUCCESS(TAG, OC_STACK_OK == foo(), ERROR, OC_STACK_ERROR);
64 #define VERIFY_SUCCESS(tag, op, logLevel, retValue) { if (!(op)) \
65 {OIC_LOG((logLevel), tag, #op " failed!!"); return retValue;} }
68 * Structure to carry credential data to callback.
70 typedef struct CredentialData CredentialData_t;
73 void *ctx; /**< Pointer to user context.**/
74 const OCProvisionDev_t *deviceInfo1; /**< Pointer to OCProvisionDev_t.**/
75 const OCProvisionDev_t *deviceInfo2; /**< Pointer to OCProvisionDev_t.**/
76 OicSecCred_t *credInfo; /**< Pointer to OicSecCred_t.**/
77 OicSecCred_t *credInfoFirst; /**< Pointer to OicSecCred_t.**/
78 OCProvisionResultCB resultCallback; /**< Pointer to result callback.**/
79 OCProvisionResult_t *resArr; /**< Result array.**/
80 int numOfResults; /**< Number of results in result array.**/
84 * Structure to carry ACL provision API data to callback.
86 typedef struct ACLData ACLData_t;
89 void *ctx; /**< Pointer to user context.**/
90 const OCProvisionDev_t *deviceInfo; /**< Pointer to PMDevInfo_t.**/
91 OCProvisionResultCB resultCallback; /**< Pointer to result callback.**/
92 OCProvisionResult_t *resArr; /**< Result array.**/
93 int numOfResults; /**< Number of results in result array.**/
97 * Structure to carry PCONF provision API data to callback.
99 typedef struct PconfData PconfData_t;
102 void *ctx; /**< Pointer to user context.**/
103 const OCProvisionDev_t *deviceInfo; /**< Pointer to PMDevInfo_t.**/
104 OCProvisionResultCB resultCallback; /**< Pointer to result callback.**/
105 OCProvisionResult_t *resArr; /**< Result array.**/
106 int numOfResults; /**< Number of results in result array.**/
109 // Enum type index for unlink callback.
111 IDX_FIRST_DEVICE_RES = 0, // index for resulf of the first device
112 IDX_SECOND_DEVICE_RES, // index for result of the second device
113 IDX_DB_UPDATE_RES // index for result of updating provisioning database.
116 // Structure to carry unlink APIs data to callback.
117 typedef struct UnlinkData UnlinkData_t;
120 OCProvisionDev_t* unlinkDev; /**< Pointer to OCProvisionDev_t to be unlinked.**/
121 OCProvisionResult_t* unlinkRes; /**< Result array.**/
122 OCProvisionResultCB resultCallback; /**< Pointer to result callback.**/
123 int numOfResults; /**< Number of results in result array.**/
126 //Example of DELETE cred request -> coaps://0.0.0.0:5684/oic/sec/cred?sub=(BASE64 ENCODED UUID)
127 const char * SRP_FORM_DELETE_CREDENTIAL = "coaps://[%s]:%d%s?%s=%s";
129 // Structure to carry remove APIs data to callback.
130 typedef struct RemoveData RemoveData_t;
133 OCProvisionDev_t* revokeTargetDev; /**< Device which is going to be revoked..**/
134 OCProvisionDev_t* linkedDevList; /**< A list of devices which have invalid credential.**/
135 OCProvisionResult_t* removeRes; /**< Result array.**/
136 OCProvisionResultCB resultCallback; /**< Pointer to result callback.**/
137 size_t numOfResults; /**< Number of results in result array.**/
138 size_t sizeOfResArray;
145 static OCStackResult provisionCredentials(const OicSecCred_t *cred,
146 const OCProvisionDev_t *deviceInfo, CredentialData_t *credData,
147 OCClientResponseHandler responseHandler);
151 * Internal function to update result in result array.
153 static void registerResultForCredProvisioning(CredentialData_t *credData,
154 OCStackResult stackresult, int cause)
157 OIC_LOG_V(INFO,TAG,"value of credData->numOfResults is %d",credData->numOfResults);
160 memcpy(credData->resArr[(credData->numOfResults)].deviceId.id,
161 credData->deviceInfo1->doxm->deviceID.id,UUID_LENGTH);
165 memcpy(credData->resArr[(credData->numOfResults)].deviceId.id,
166 credData->deviceInfo2->doxm->deviceID.id,UUID_LENGTH);
168 credData->resArr[(credData->numOfResults)].res = stackresult;
169 ++(credData->numOfResults);
173 * Callback handler for handling callback of provisioning device 2.
175 * @param[in] ctx ctx value passed to callback from calling function.
176 * @param[in] UNUSED handle to an invocation
177 * @param[in] clientResponse Response from queries to remote servers.
178 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
179 * and OC_STACK_KEEP_TRANSACTION to keep it.
181 static OCStackApplicationResult provisionCredentialCB2(void *ctx, OCDoHandle UNUSED,
182 OCClientResponse *clientResponse)
184 VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
185 CredentialData_t *credData = (CredentialData_t *) ctx;
188 OCProvisionResultCB resultCallback = credData->resultCallback;
189 OIC_LOG(INFO, TAG, "provisionCredentialCB2 called");
192 if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
194 registerResultForCredProvisioning(credData, OC_STACK_RESOURCE_CREATED, 2);
195 OCStackResult res = PDMLinkDevices(&credData->deviceInfo1->doxm->deviceID,
196 &credData->deviceInfo2->doxm->deviceID);
197 if (OC_STACK_OK != res)
199 OIC_LOG(ERROR, TAG, "Error occured on PDMLinkDevices");
200 return OC_STACK_DELETE_TRANSACTION;
202 OIC_LOG(INFO, TAG, "Link created successfully");
204 ((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
207 OICFree(credData->resArr);
209 return OC_STACK_DELETE_TRANSACTION;
213 OIC_LOG(INFO, TAG, "provisionCredentialCB2 received Null clientResponse");
214 registerResultForCredProvisioning(credData, OC_STACK_ERROR, 2);
215 ((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
218 OICFree(credData->resArr);
220 return OC_STACK_DELETE_TRANSACTION;
224 * Callback handler for handling callback of provisioning device 1.
226 * @param[in] ctx ctx value passed to callback from calling function.
227 * @param[in] UNUSED handle to an invocation
228 * @param[in] clientResponse Response from queries to remote servers.
229 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
230 * and OC_STACK_KEEP_TRANSACTION to keep it.
232 static OCStackApplicationResult provisionCredentialCB1(void *ctx, OCDoHandle UNUSED,
233 OCClientResponse *clientResponse)
235 VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
237 CredentialData_t* credData = (CredentialData_t*) ctx;
238 OICFree(credData->credInfoFirst);
239 const OCProvisionDev_t *deviceInfo = credData->deviceInfo2;
240 OicSecCred_t *credInfo = credData->credInfo;
241 const OCProvisionResultCB resultCallback = credData->resultCallback;
244 if (OC_STACK_RESOURCE_CREATED == clientResponse->result)
246 // send credentials to second device
247 registerResultForCredProvisioning(credData, OC_STACK_RESOURCE_CREATED,1);
248 OCStackResult res = provisionCredentials(credInfo, deviceInfo, credData,
249 provisionCredentialCB2);
250 DeleteCredList(credInfo);
251 if (OC_STACK_OK != res)
253 registerResultForCredProvisioning(credData, res,2);
254 ((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
257 OICFree(credData->resArr);
264 registerResultForCredProvisioning(credData, OC_STACK_ERROR,1);
265 ((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
268 OICFree(credData->resArr);
275 OIC_LOG(INFO, TAG, "provisionCredentialCB received Null clientResponse for first device");
276 registerResultForCredProvisioning(credData, OC_STACK_ERROR,1);
277 ((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
280 DeleteCredList(credInfo);
281 OICFree(credData->resArr);
285 return OC_STACK_DELETE_TRANSACTION;
291 * Internal function for handling credential generation and sending credential to resource server.
293 * @param[in] cred Instance of cred resource.
294 * @param[in] deviceInfo information about device to which credential is to be provisioned.
295 * @param[in] responseHandler callbak called by OC stack when request API receives response.
296 * @return OC_STACK_OK in case of success and other value otherwise.
298 static OCStackResult provisionCredentials(const OicSecCred_t *cred,
299 const OCProvisionDev_t *deviceInfo, CredentialData_t *credData,
300 OCClientResponseHandler responseHandler)
302 OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
305 OIC_LOG(ERROR, TAG, "Failed to memory allocation");
306 return OC_STACK_NO_MEMORY;
308 secPayload->base.type = PAYLOAD_TYPE_SECURITY;
309 OCStackResult res = CredToCBORPayload(cred, &secPayload->securityData, &secPayload->payloadSize);
310 if((OC_STACK_OK != res) && (NULL == secPayload->securityData))
312 OCPayloadDestroy((OCPayload *)secPayload);
313 OIC_LOG(ERROR, TAG, "Failed to CredToCBORPayload");
314 return OC_STACK_NO_MEMORY;
317 OIC_LOG(DEBUG, TAG, "Created payload for Cred:");
318 OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize);
319 char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
320 if(!PMGenerateQuery(true,
321 deviceInfo->endpoint.addr,
322 deviceInfo->securePort,
323 deviceInfo->connType,
324 query, sizeof(query), OIC_RSRC_CRED_URI))
326 OIC_LOG(ERROR, TAG, "DeviceDiscoveryHandler : Failed to generate query");
327 return OC_STACK_ERROR;
329 OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
331 OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL};
332 cbData.cb = responseHandler;
333 cbData.context = (void *) credData;
336 OCDoHandle handle = NULL;
337 OCMethod method = OC_REST_POST;
338 OCStackResult ret = OCDoResource(&handle, method, query, 0, (OCPayload*)secPayload,
339 deviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
340 OIC_LOG_V(INFO, TAG, "OCDoResource::Credential provisioning returned : %d",ret);
341 if (ret != OC_STACK_OK)
343 OIC_LOG(ERROR, TAG, "OCStack resource error");
351 * Structure to carry certificate data to callback.
353 typedef struct CertificateData CertData_t;
354 struct CertificateData
356 void *ctx; /**< Pointer to user context.**/
357 const OCProvisionDev_t *deviceInfo; /**< Pointer to OCProvisionDev_t.**/
358 OicSecCred_t *credInfo; /**< Pointer to OicSecCred_t.**/
359 OCProvisionResultCB resultCallback; /**< Pointer to result callback.**/
360 OCProvisionResult_t *resArr; /**< Result array.**/
361 int numOfResults; /**< Number of results in result array.**/
365 * Structure to carry CRL provision API data to callback.
367 typedef struct CRLData CRLData_t;
370 void *ctx; /**< Pointer to user context.**/
371 const OCProvisionDev_t *deviceInfo; /**< Pointer to PMDevInfo_t.**/
372 OCProvisionResultCB resultCallback; /**< Pointer to result callback.**/
373 OCProvisionResult_t *resArr; /**< Result array.**/
374 int numOfResults; /**< Number of results in result array.**/
378 * Internal function to update result in result array.
380 static void registerResultForCertProvisioning(CertData_t *certData,
381 OCStackResult stackresult)
384 OIC_LOG_V(INFO,TAG,"value of credData->numOfResults is %d",certData->numOfResults);
385 memcpy(certData->resArr[(certData->numOfResults)].deviceId.id,
386 certData->deviceInfo->doxm->deviceID.id,UUID_LENGTH);
387 certData->resArr[(certData->numOfResults)].res = stackresult;
388 ++(certData->numOfResults);
392 * Internal Function to store results in result array during ACL provisioning.
394 static void registerResultForCRLProvisioning(CRLData_t *crlData,
395 OCStackResult stackresult)
397 OIC_LOG_V(INFO, TAG, "Inside registerResultForCRLProvisioning crlData->numOfResults is %d\n",
398 crlData->numOfResults);
399 memcpy(crlData->resArr[(crlData->numOfResults)].deviceId.id,
400 crlData->deviceInfo->doxm->deviceID.id, UUID_LENGTH);
401 crlData->resArr[(crlData->numOfResults)].res = stackresult;
402 ++(crlData->numOfResults);
407 * Callback handler of SRPProvisionCRL.
409 * @param[in] ctx ctx value passed to callback from calling function.
410 * @param[in] UNUSED handle to an invocation
411 * @param[in] clientResponse Response from queries to remote servers.
412 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
413 * and OC_STACK_KEEP_TRANSACTION to keep it.
415 static OCStackApplicationResult SRPProvisionCRLCB(void *ctx, OCDoHandle UNUSED,
416 OCClientResponse *clientResponse)
418 OIC_LOG_V(INFO, TAG, "Inside SRPProvisionCRLCB.");
420 VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
421 CRLData_t *crlData = (CRLData_t*)ctx;
422 OCProvisionResultCB resultCallback = crlData->resultCallback;
426 if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
428 registerResultForCRLProvisioning(crlData, OC_STACK_RESOURCE_CREATED);
429 ((OCProvisionResultCB)(resultCallback))(crlData->ctx, crlData->numOfResults,
432 OICFree(crlData->resArr);
434 return OC_STACK_DELETE_TRANSACTION;
437 registerResultForCRLProvisioning(crlData, OC_STACK_ERROR);
438 ((OCProvisionResultCB)(resultCallback))(crlData->ctx, crlData->numOfResults,
441 OIC_LOG_V(ERROR, TAG, "SRPProvisionCRLCB received Null clientResponse");
442 OICFree(crlData->resArr);
444 return OC_STACK_DELETE_TRANSACTION;
447 OCStackResult SRPProvisionCRL(void *ctx, const OCProvisionDev_t *selectedDeviceInfo,
448 OicSecCrl_t *crl, OCProvisionResultCB resultCallback)
450 VERIFY_NON_NULL(TAG, selectedDeviceInfo, ERROR, OC_STACK_INVALID_PARAM);
451 VERIFY_NON_NULL(TAG, crl, ERROR, OC_STACK_INVALID_PARAM);
452 VERIFY_NON_NULL(TAG, resultCallback, ERROR, OC_STACK_INVALID_CALLBACK);
454 OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
457 OIC_LOG(ERROR, TAG, "Failed to memory allocation");
458 return OC_STACK_NO_MEMORY;
461 secPayload->base.type = PAYLOAD_TYPE_SECURITY;
462 OCStackResult res = CrlToCBORPayload(crl, &secPayload->securityData, &secPayload->payloadSize);
463 if((OC_STACK_OK != res) && (NULL == secPayload->securityData))
466 OIC_LOG(ERROR, TAG, "Failed to BinToCrlJSON");
467 return OC_STACK_NO_MEMORY;
469 OIC_LOG(DEBUG, TAG, "Created payload for CRL:");
470 OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize);
472 char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
473 if(!PMGenerateQuery(true,
474 selectedDeviceInfo->endpoint.addr,
475 selectedDeviceInfo->securePort,
476 selectedDeviceInfo->connType,
477 query, sizeof(query), OIC_RSRC_CRL_URI))
479 OIC_LOG(ERROR, TAG, "DeviceDiscoveryHandler : Failed to generate query");
480 OCPayloadDestroy((OCPayload *)secPayload);
481 return OC_STACK_ERROR;
483 OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
485 OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL};
486 cbData.cb = &SRPProvisionCRLCB;
487 CRLData_t *crlData = (CRLData_t *) OICCalloc(1, sizeof(CRLData_t));
490 OCPayloadDestroy((OCPayload *)secPayload);
491 OIC_LOG(ERROR, TAG, "Unable to allocate memory");
492 return OC_STACK_NO_MEMORY;
495 crlData->deviceInfo = selectedDeviceInfo;
496 crlData->resultCallback = resultCallback;
497 crlData->numOfResults=0;
500 crlData->resArr = (OCProvisionResult_t*)OICCalloc(1, sizeof(OCProvisionResult_t));
501 if (crlData->resArr == NULL)
503 OCPayloadDestroy((OCPayload *)secPayload);
504 OIC_LOG(ERROR, TAG, "Unable to allocate memory");
505 return OC_STACK_NO_MEMORY;
508 cbData.context = (void *)crlData;
510 OCMethod method = OC_REST_POST;
511 OCDoHandle handle = NULL;
512 OIC_LOG(DEBUG, TAG, "Sending CRL info to resource server");
514 OCStackResult ret = OCDoResource(&handle, method, query,
515 &selectedDeviceInfo->endpoint, (OCPayload*)secPayload,
516 selectedDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
518 if (ret != OC_STACK_OK)
520 OICFree(crlData->resArr);
528 * Internal function for handling credential generation and sending cretificate credential.
530 * @param[in] cred Instance of cred resource.
531 * @param[in] deviceInfo information about device to which credential is to be provisioned.
532 * @param[in] responseHandler callbak called by OC stack when request API receives response.
533 * @return OC_STACK_OK in case of success and other value otherwise.
535 static OCStackResult provisionCertCred(const OicSecCred_t *cred,
536 const OCProvisionDev_t *deviceInfo, CertData_t *certData,
537 OCClientResponseHandler responseHandler)
539 OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
542 OIC_LOG(ERROR, TAG, "Failed to memory allocation");
543 return OC_STACK_NO_MEMORY;
545 secPayload->base.type = PAYLOAD_TYPE_SECURITY;
546 OCStackResult res = CredToCBORPayload(cred, &secPayload->securityData,
547 &secPayload->payloadSize);
549 if ((OC_STACK_OK != res) || (NULL == secPayload->securityData))
552 OIC_LOG(ERROR, TAG, "Failed to CredToCBORPayload");
553 return OC_STACK_NO_MEMORY;
556 OIC_LOG(DEBUG, TAG, "Created payload for Cred:");
557 OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize);
558 char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
559 if(!PMGenerateQuery(true,
560 deviceInfo->endpoint.addr,
561 deviceInfo->securePort,
562 deviceInfo->connType,
563 query, sizeof(query), OIC_RSRC_CRED_URI))
565 OIC_LOG(ERROR, TAG, "DeviceDiscoveryHandler : Failed to generate query");
566 OCPayloadDestroy((OCPayload *)secPayload);
567 return OC_STACK_ERROR;
569 OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
571 OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL};
572 cbData.cb = responseHandler;
573 cbData.context = (void *) certData;
576 OCDoHandle handle = NULL;
577 OCMethod method = OC_REST_POST;
578 OCStackResult ret = OCDoResource(&handle, method, query, 0, (OCPayload*)secPayload,
579 deviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
580 OIC_LOG_V(INFO, TAG, "OCDoResource::Certificate provisioning returned : %d",ret);
581 if (ret != OC_STACK_OK)
583 OIC_LOG(ERROR, TAG, "OCStack resource error");
590 * Callback handler for handling callback of certificate provisioning device.
592 * @param[in] ctx ctx value passed to callback from calling function.
593 * @param[in] UNUSED handle to an invocation
594 * @param[in] clientResponse Response from queries to remote servers.
595 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
596 * and OC_STACK_KEEP_TRANSACTION to keep it.
598 static OCStackApplicationResult provisionCertCB(void *ctx, OCDoHandle UNUSED,
599 OCClientResponse *clientResponse)
601 VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
602 CertData_t *certData = (CertData_t *) ctx;
605 OCProvisionResultCB resultCallback = certData->resultCallback;
606 OIC_LOG(INFO, TAG, "provisionCertCred called");
609 if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
611 registerResultForCertProvisioning(certData, OC_STACK_RESOURCE_CREATED);
612 ((OCProvisionResultCB)(resultCallback))(certData->ctx, certData->numOfResults,
615 OICFree(certData->resArr);
617 return OC_STACK_DELETE_TRANSACTION;
621 OIC_LOG(INFO, TAG, "provisionCertCredCB received Null clientResponse");
622 registerResultForCertProvisioning(certData, OC_STACK_ERROR);
623 ((OCProvisionResultCB)(resultCallback))(certData->ctx, certData->numOfResults,
626 OICFree(certData->resArr);
628 return OC_STACK_DELETE_TRANSACTION;
630 #endif // __WITH_X509__
632 OCStackResult SRPProvisionCredentials(void *ctx, OicSecCredType_t type, size_t keySize,
633 const OCProvisionDev_t *pDev1,
634 const OCProvisionDev_t *pDev2,
635 OCProvisionResultCB resultCallback)
637 VERIFY_NON_NULL(TAG, pDev1, ERROR, OC_STACK_INVALID_PARAM);
638 if (SYMMETRIC_PAIR_WISE_KEY == type)
640 VERIFY_NON_NULL(TAG, pDev2, ERROR, OC_STACK_INVALID_PARAM);
644 OIC_LOG(INFO, TAG, "SRPUnlinkDevices : NULL Callback");
645 return OC_STACK_INVALID_CALLBACK;
647 if (SYMMETRIC_PAIR_WISE_KEY == type &&
648 0 == memcmp(&pDev1->doxm->deviceID, &pDev2->doxm->deviceID, sizeof(OicUuid_t)))
650 OIC_LOG(INFO, TAG, "SRPUnlinkDevices : Same device ID");
651 return OC_STACK_INVALID_PARAM;
654 if (SYMMETRIC_PAIR_WISE_KEY == type &&
655 !(OWNER_PSK_LENGTH_128 == keySize || OWNER_PSK_LENGTH_256 == keySize))
657 OIC_LOG(INFO, TAG, "Invalid key size");
658 return OC_STACK_INVALID_PARAM;
661 OIC_LOG(INFO, TAG, "In SRPProvisionCredentials");
663 if (SYMMETRIC_PAIR_WISE_KEY == type)
665 bool linkExisits = true;
666 OCStackResult res = PDMIsLinkExists(&pDev1->doxm->deviceID, &pDev2->doxm->deviceID, &linkExisits);
668 if (res != OC_STACK_OK)
670 OIC_LOG(ERROR, TAG, "Internal error occured");
675 OIC_LOG(ERROR, TAG, "Link already exists");
676 return OC_STACK_INVALID_PARAM;
680 OicUuid_t provTooldeviceID = {{0,}};
681 if (OC_STACK_OK != GetDoxmDeviceID(&provTooldeviceID))
683 OIC_LOG(ERROR, TAG, "Error while retrieving provisioning tool's device ID");
684 return OC_STACK_ERROR;
686 OIC_LOG(INFO, TAG, "retrieved deviceid");
689 case SYMMETRIC_PAIR_WISE_KEY:
691 const OCProvisionDev_t *firstDevice = pDev1;
692 const OCProvisionDev_t *secondDevice = pDev2;
694 OicSecCred_t *firstCred = NULL;
695 OicSecCred_t *secondCred = NULL;
696 OCStackResult res = PMGeneratePairWiseCredentials(type, keySize, &provTooldeviceID,
697 &firstDevice->doxm->deviceID, &secondDevice->doxm->deviceID,
698 &firstCred, &secondCred);
699 VERIFY_SUCCESS(TAG, (res==OC_STACK_OK), ERROR, OC_STACK_ERROR);
700 OIC_LOG(INFO, TAG, "Credentials generated successfully");
701 CredentialData_t *credData =
702 (CredentialData_t *) OICCalloc(1, sizeof(CredentialData_t));
703 if (NULL == credData)
707 OIC_LOG(ERROR, TAG, "Memory allocation problem");
708 return OC_STACK_NO_MEMORY;
710 credData->deviceInfo1 = firstDevice;
711 credData->deviceInfo2 = secondDevice;
712 credData->credInfo = secondCred;
714 credData->credInfoFirst = firstCred;
715 credData->numOfResults = 0;
716 credData->resultCallback = resultCallback;
717 // first call to provision creds to device1.
718 // second call to provision creds to device2.
721 (OCProvisionResult_t*)OICCalloc(noOfRiCalls, sizeof(OCProvisionResult_t));
722 if (NULL == credData->resArr)
727 OIC_LOG(ERROR, TAG, "Memory allocation problem");
728 return OC_STACK_NO_MEMORY;
730 res = provisionCredentials(firstCred, firstDevice, credData, &provisionCredentialCB1);
731 if (OC_STACK_OK != res)
733 DeleteCredList(firstCred);
734 DeleteCredList(secondCred);
735 OICFree(credData->resArr);
738 OIC_LOG_V(INFO, TAG, "provisionCredentials returned: %d",res);
739 VERIFY_SUCCESS(TAG, (res==OC_STACK_OK), ERROR, OC_STACK_ERROR);
743 case SIGNED_ASYMMETRIC_KEY:
745 const OCProvisionDev_t *firstDevice = pDev1;
746 OicSecCred_t *cred = NULL;
747 OCStackResult res = PMGenerateCertificateCredentials(&provTooldeviceID,
748 &firstDevice->doxm->deviceID,&cred);
749 VERIFY_SUCCESS(TAG, (res==OC_STACK_OK), ERROR, OC_STACK_ERROR);
750 OIC_LOG(INFO, TAG, "Certificate credentials generated successfully");
751 CertData_t *certData = (CertData_t *) OICCalloc(1, sizeof(CertData_t));
752 if (NULL == certData)
755 OIC_LOG(ERROR, TAG, "Memory allocation problem");
756 return OC_STACK_NO_MEMORY;
759 certData->deviceInfo = firstDevice;
761 certData->credInfo = cred;
762 certData->numOfResults = 0;
763 certData->resultCallback = resultCallback;
765 certData->resArr = (OCProvisionResult_t*)OICCalloc(1, sizeof(OCProvisionResult_t));
766 if (NULL == certData->resArr)
768 DeleteCredList(cred);
770 OIC_LOG(ERROR, TAG, "Memory allocation problem");
771 return OC_STACK_NO_MEMORY;
774 res = provisionCertCred(cred, firstDevice, certData, &provisionCertCB);
775 if (OC_STACK_OK != res)
777 OICFree(certData->resArr);
780 DeleteCredList(cred);
781 OIC_LOG_V(INFO, TAG, "provisionCertCredentials returned: %d",res);
788 OIC_LOG(ERROR, TAG, "Invalid option.");
789 return OC_STACK_INVALID_PARAM;
792 return OC_STACK_ERROR;
796 * Internal Function to store results in result array during ACL provisioning.
798 static void registerResultForACLProvisioning(ACLData_t *aclData,
799 OCStackResult stackresult)
801 OIC_LOG_V(INFO, TAG, "Inside registerResultForACLProvisioning aclData->numOfResults is %d\n",
802 aclData->numOfResults);
803 memcpy(aclData->resArr[(aclData->numOfResults)].deviceId.id,
804 aclData->deviceInfo->doxm->deviceID.id, UUID_LENGTH);
805 aclData->resArr[(aclData->numOfResults)].res = stackresult;
806 ++(aclData->numOfResults);
810 * Callback handler of SRPProvisionACL.
812 * @param[in] ctx ctx value passed to callback from calling function.
813 * @param[in] UNUSED handle to an invocation
814 * @param[in] clientResponse Response from queries to remote servers.
815 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
816 * and OC_STACK_KEEP_TRANSACTION to keep it.
818 static OCStackApplicationResult SRPProvisionACLCB(void *ctx, OCDoHandle UNUSED,
819 OCClientResponse *clientResponse)
821 OIC_LOG_V(INFO, TAG, "Inside SRPProvisionACLCB.");
823 VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
824 ACLData_t *aclData = (ACLData_t*)ctx;
825 OCProvisionResultCB resultCallback = aclData->resultCallback;
829 if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
831 registerResultForACLProvisioning(aclData, OC_STACK_RESOURCE_CREATED);
832 ((OCProvisionResultCB)(resultCallback))(aclData->ctx, aclData->numOfResults,
835 OICFree(aclData->resArr);
837 return OC_STACK_DELETE_TRANSACTION;
840 registerResultForACLProvisioning(aclData, OC_STACK_ERROR);
841 ((OCProvisionResultCB)(resultCallback))(aclData->ctx, aclData->numOfResults,
844 OIC_LOG_V(ERROR, TAG, "SRPProvisionACLCB received Null clientResponse");
845 OICFree(aclData->resArr);
847 return OC_STACK_DELETE_TRANSACTION;
850 OCStackResult SRPProvisionACL(void *ctx, const OCProvisionDev_t *selectedDeviceInfo,
851 OicSecAcl_t *acl, OCProvisionResultCB resultCallback)
853 VERIFY_NON_NULL(TAG, selectedDeviceInfo, ERROR, OC_STACK_INVALID_PARAM);
854 VERIFY_NON_NULL(TAG, acl, ERROR, OC_STACK_INVALID_PARAM);
855 VERIFY_NON_NULL(TAG, resultCallback, ERROR, OC_STACK_INVALID_CALLBACK);
857 OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
860 OIC_LOG(ERROR, TAG, "Failed to memory allocation");
861 return OC_STACK_NO_MEMORY;
863 secPayload->base.type = PAYLOAD_TYPE_SECURITY;
864 if(OC_STACK_OK != AclToCBORPayload(acl, &secPayload->securityData, &secPayload->payloadSize))
866 OCPayloadDestroy((OCPayload *)secPayload);
867 OIC_LOG(ERROR, TAG, "Failed to AclToCBORPayload");
868 return OC_STACK_NO_MEMORY;
870 char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
871 if(!PMGenerateQuery(true,
872 selectedDeviceInfo->endpoint.addr,
873 selectedDeviceInfo->securePort,
874 selectedDeviceInfo->connType,
875 query, sizeof(query), OIC_RSRC_ACL_URI))
877 OIC_LOG(ERROR, TAG, "DeviceDiscoveryHandler : Failed to generate query");
878 return OC_STACK_ERROR;
880 OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
882 OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL};
883 cbData.cb = &SRPProvisionACLCB;
884 ACLData_t *aclData = (ACLData_t *) OICCalloc(1, sizeof(ACLData_t));
887 OCPayloadDestroy((OCPayload *)secPayload);
888 OIC_LOG(ERROR, TAG, "Unable to allocate memory");
889 return OC_STACK_NO_MEMORY;
891 aclData->deviceInfo = selectedDeviceInfo;
892 aclData->resultCallback = resultCallback;
893 aclData->numOfResults=0;
895 // call to provision ACL to device1.
897 aclData->resArr = (OCProvisionResult_t*)OICCalloc(noOfRiCalls, sizeof(OCProvisionResult_t));
898 if (aclData->resArr == NULL)
901 OCPayloadDestroy((OCPayload *)secPayload);
902 OIC_LOG(ERROR, TAG, "Unable to allocate memory");
903 return OC_STACK_NO_MEMORY;
905 cbData.context = (void *)aclData;
907 OCMethod method = OC_REST_POST;
908 OCDoHandle handle = NULL;
909 OIC_LOG(DEBUG, TAG, "Sending ACL info to resource server");
910 OCStackResult ret = OCDoResource(&handle, method, query,
911 &selectedDeviceInfo->endpoint, (OCPayload*)secPayload,
912 selectedDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
913 if (ret != OC_STACK_OK)
915 OICFree(aclData->resArr);
918 VERIFY_SUCCESS(TAG, (OC_STACK_OK == ret), ERROR, OC_STACK_ERROR);
923 * Internal Function to store results in result array during Direct-Pairing provisioning.
925 static void registerResultForDirectPairingProvisioning(PconfData_t *pconfData,
926 OCStackResult stackresult)
928 OIC_LOG_V(INFO, TAG, "Inside registerResultForDirectPairingProvisioning "
929 "pconfData->numOfResults is %d\n", pconfData->numOfResults);
930 memcpy(pconfData->resArr[(pconfData->numOfResults)].deviceId.id,
931 pconfData->deviceInfo->doxm->deviceID.id, UUID_LENGTH);
932 pconfData->resArr[(pconfData->numOfResults)].res = stackresult;
933 ++(pconfData->numOfResults);
937 * Callback handler of SRPProvisionDirectPairing.
939 * @param[in] ctx ctx value passed to callback from calling function.
940 * @param[in] UNUSED handle to an invocation
941 * @param[in] clientResponse Response from queries to remote servers.
942 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
943 * and OC_STACK_KEEP_TRANSACTION to keep it.
945 static OCStackApplicationResult SRPProvisionDirectPairingCB(void *ctx, OCDoHandle UNUSED,
946 OCClientResponse *clientResponse)
948 OIC_LOG_V(INFO, TAG, "Inside SRPProvisionDirectPairingCB.");
950 VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
951 PconfData_t *pconfData = (PconfData_t*)ctx;
952 OCProvisionResultCB resultCallback = pconfData->resultCallback;
956 if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
958 registerResultForDirectPairingProvisioning(pconfData, OC_STACK_OK);
959 ((OCProvisionResultCB)(resultCallback))(pconfData->ctx, pconfData->numOfResults,
962 OICFree(pconfData->resArr);
964 return OC_STACK_DELETE_TRANSACTION;
967 registerResultForDirectPairingProvisioning(pconfData, OC_STACK_ERROR);
968 ((OCProvisionResultCB)(resultCallback))(pconfData->ctx, pconfData->numOfResults,
971 OIC_LOG_V(ERROR, TAG, "SRPProvisionDirectPairingCB received Null clientResponse");
972 OICFree(pconfData->resArr);
974 return OC_STACK_DELETE_TRANSACTION;
977 OCStackResult SRPProvisionDirectPairing(void *ctx, const OCProvisionDev_t *selectedDeviceInfo,
978 OicSecPconf_t *pconf, OCProvisionResultCB resultCallback)
980 VERIFY_NON_NULL(TAG, selectedDeviceInfo, ERROR, OC_STACK_INVALID_PARAM);
981 VERIFY_NON_NULL(TAG, pconf, ERROR, OC_STACK_INVALID_PARAM);
982 VERIFY_NON_NULL(TAG, resultCallback, ERROR, OC_STACK_INVALID_CALLBACK);
984 // check direct-pairing capability
985 if (true != selectedDeviceInfo->doxm->dpc)
987 OIC_LOG(ERROR, TAG, "Resouce server does not have Direct-Pairing Capability ");
988 return OC_STACK_UNAUTHORIZED_REQ;
991 OicUuid_t provTooldeviceID = {.id={0}};
992 if (OC_STACK_OK != GetDoxmDeviceID(&provTooldeviceID))
994 OIC_LOG(ERROR, TAG, "Error while retrieving provisioning tool's device ID");
995 return OC_STACK_ERROR;
997 memcpy(&pconf->rownerID, &provTooldeviceID, sizeof(OicUuid_t));
999 OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
1002 OIC_LOG(ERROR, TAG, "Failed to memory allocation");
1003 return OC_STACK_NO_MEMORY;
1005 secPayload->base.type = PAYLOAD_TYPE_SECURITY;
1007 if (OC_STACK_OK != PconfToCBORPayload(pconf, &(secPayload->securityData),
1008 &(secPayload->payloadSize)))
1010 OCPayloadDestroy((OCPayload*)secPayload);
1011 OIC_LOG(ERROR, TAG, "Failed to PconfToCborPayload");
1012 return OC_STACK_NO_MEMORY;
1014 OIC_LOG(DEBUG, TAG, "Created payload for pconf set");
1015 OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize);
1018 char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
1019 if(!PMGenerateQuery(true,
1020 selectedDeviceInfo->endpoint.addr,
1021 selectedDeviceInfo->securePort,
1022 selectedDeviceInfo->connType,
1023 query, sizeof(query), OIC_RSRC_PCONF_URI))
1025 OIC_LOG(ERROR, TAG, "SRPProvisionDirectPairing : Failed to generate query");
1026 return OC_STACK_ERROR;
1028 OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
1030 OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL};
1031 cbData.cb = &SRPProvisionDirectPairingCB;
1032 PconfData_t *pconfData = (PconfData_t *) OICCalloc(1, sizeof(PconfData_t));
1033 if (NULL == pconfData)
1035 OCPayloadDestroy((OCPayload*)secPayload);
1036 OIC_LOG(ERROR, TAG, "Unable to allocate memory");
1037 return OC_STACK_NO_MEMORY;
1039 pconfData->deviceInfo = selectedDeviceInfo;
1040 pconfData->resultCallback = resultCallback;
1041 pconfData->numOfResults=0;
1042 pconfData->ctx = ctx;
1043 // call to provision PCONF to device1.
1044 int noOfRiCalls = 1;
1045 pconfData->resArr = (OCProvisionResult_t*)OICCalloc(noOfRiCalls, sizeof(OCProvisionResult_t));
1046 if (NULL == pconfData->resArr)
1049 OCPayloadDestroy((OCPayload*)secPayload);
1050 OIC_LOG(ERROR, TAG, "Unable to allocate memory");
1051 return OC_STACK_NO_MEMORY;
1053 cbData.context = (void *)pconfData;
1055 OCMethod method = OC_REST_POST;
1056 OCDoHandle handle = NULL;
1057 OIC_LOG(DEBUG, TAG, "Sending PCONF info to resource server");
1058 OCStackResult ret = OCDoResource(&handle, method, query,
1059 &selectedDeviceInfo->endpoint, (OCPayload*)secPayload,
1060 selectedDeviceInfo->connType, OC_LOW_QOS, &cbData, NULL, 0);
1061 if (OC_STACK_OK != ret)
1063 OICFree(pconfData->resArr);
1066 VERIFY_SUCCESS(TAG, (OC_STACK_OK == ret), ERROR, OC_STACK_ERROR);
1070 static void DeleteUnlinkData_t(UnlinkData_t *unlinkData)
1074 OICFree(unlinkData->unlinkDev);
1075 OICFree(unlinkData->unlinkRes);
1076 OICFree(unlinkData);
1080 static void registerResultForUnlinkDevices(UnlinkData_t *unlinkData, OCStackResult stackresult,
1083 if (NULL != unlinkData)
1085 OIC_LOG_V(INFO, TAG, "Inside registerResultForUnlinkDevices unlinkData->numOfResults is %d\n",
1086 unlinkData->numOfResults);
1087 OIC_LOG_V(INFO, TAG, "Stack result :: %d", stackresult);
1089 OicUuid_t *pUuid = &unlinkData->unlinkRes[(unlinkData->numOfResults)].deviceId;
1091 // Set result in the result array according to the position (devNum).
1092 if (idx != IDX_DB_UPDATE_RES)
1094 memcpy(pUuid->id, unlinkData->unlinkDev[idx].doxm->deviceID.id, sizeof(pUuid->id));
1097 { // When deivce ID is 000... this means it's the result of database update.
1098 memset(pUuid->id, 0, sizeof(pUuid->id));
1100 unlinkData->unlinkRes[(unlinkData->numOfResults)].res = stackresult;
1101 ++(unlinkData->numOfResults);
1102 OIC_LOG (INFO, TAG, "Out registerResultForUnlinkDevices");
1106 static OCStackResult SendDeleteCredentialRequest(void* ctx,
1107 OCClientResponseHandler respHandler,
1108 const OCProvisionDev_t* revokedDev,
1109 const OCProvisionDev_t* destDev)
1111 OIC_LOG(DEBUG, TAG, "IN SendDeleteCredentialRequest");
1113 if (NULL == ctx || NULL == respHandler || NULL == revokedDev || NULL == destDev)
1115 return OC_STACK_INVALID_PARAM;
1119 OCStackResult ret = ConvertUuidToStr(&revokedDev->doxm->deviceID, &subID);
1120 if(OC_STACK_OK != ret)
1122 OIC_LOG(ERROR, TAG, "SendDeleteCredentialRequest : Failed to canonical UUID encoding");
1123 return OC_STACK_ERROR;
1126 char reqBuf[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
1128 //coaps://0.0.0.0:5684/oic/sec/cred?subjectid=(Canonical ENCODED UUID)
1129 snRet = snprintf(reqBuf, sizeof(reqBuf), SRP_FORM_DELETE_CREDENTIAL, destDev->endpoint.addr,
1130 destDev->securePort, OIC_RSRC_CRED_URI, OIC_JSON_SUBJECTID_NAME, subID);
1134 OIC_LOG_V(ERROR, TAG, "SendDeleteCredentialRequest : Error (snprintf) %d\n", snRet);
1135 return OC_STACK_ERROR;
1137 else if ((size_t)snRet >= sizeof(reqBuf))
1139 OIC_LOG_V(ERROR, TAG, "SendDeleteCredentialRequest : Truncated (snprintf) %d\n", snRet);
1140 return OC_STACK_ERROR;
1143 OCCallbackData cbData;
1144 memset(&cbData, 0, sizeof(cbData));
1145 cbData.context = ctx;
1146 cbData.cb = respHandler;
1148 OIC_LOG_V(INFO, TAG, "URI: %s",reqBuf);
1150 OIC_LOG(DEBUG, TAG, "Sending remove credential request to resource server");
1152 ret = OCDoResource(NULL, OC_REST_DELETE, reqBuf,
1153 &destDev->endpoint, NULL,
1154 CT_ADAPTER_IP, OC_HIGH_QOS, &cbData, NULL, 0);
1155 if (OC_STACK_OK != ret)
1157 OIC_LOG_V(ERROR, TAG, "SendDeleteCredentialRequest : Error in OCDoResource %d", ret);
1159 OIC_LOG(DEBUG, TAG, "OUT SendDeleteCredentialRequest");
1165 * Callback handler of unlink second device.
1167 * @param[in] ctx ctx value passed to callback from calling function.
1168 * @param[in] handle handle to an invocation
1169 * @param[in] clientResponse Response from queries to remote servers.
1170 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction and
1171 * OC_STACK_KEEP_TRANSACTION to keep it.
1173 static OCStackApplicationResult SRPUnlinkDevice2CB(void *unlinkCtx, OCDoHandle handle,
1174 OCClientResponse *clientResponse)
1177 OIC_LOG(DEBUG, TAG, "IN SRPUnlinkDevice2CB");
1178 VERIFY_NON_NULL(TAG, unlinkCtx, ERROR, OC_STACK_DELETE_TRANSACTION);
1179 UnlinkData_t* unlinkData = (UnlinkData_t*)unlinkCtx;
1183 OIC_LOG(DEBUG, TAG, "Valid client response for device 2");
1184 registerResultForUnlinkDevices(unlinkData, clientResponse->result, IDX_SECOND_DEVICE_RES);
1186 if (OC_STACK_RESOURCE_DELETED == clientResponse->result)
1188 OIC_LOG(DEBUG, TAG, "Credential of device2 revoked");
1192 OIC_LOG(ERROR, TAG, "Unable to delete credential information from device 2");
1193 unlinkData->resultCallback(unlinkData->ctx,
1194 unlinkData->numOfResults, unlinkData->unlinkRes, true);
1200 registerResultForUnlinkDevices(unlinkData, OC_STACK_INVALID_REQUEST_HANDLE,
1201 IDX_SECOND_DEVICE_RES);
1202 unlinkData->resultCallback(unlinkData->ctx,
1203 unlinkData->numOfResults, unlinkData->unlinkRes, true);
1204 OIC_LOG(ERROR, TAG, "SRPUnlinkDevice2CB received Null clientResponse");
1208 //Update provisioning DB when succes case.
1209 if (OC_STACK_OK != PDMUnlinkDevices(&unlinkData->unlinkDev[0].doxm->deviceID,
1210 &unlinkData->unlinkDev[1].doxm->deviceID))
1212 OIC_LOG(FATAL, TAG, "All requests are successfully done but update provisioning DB FAILED.");
1213 registerResultForUnlinkDevices(unlinkData, OC_STACK_INCONSISTENT_DB, IDX_DB_UPDATE_RES);
1214 unlinkData->resultCallback(unlinkData->ctx,
1215 unlinkData->numOfResults, unlinkData->unlinkRes, true);
1218 unlinkData->resultCallback(unlinkData->ctx, unlinkData->numOfResults, unlinkData->unlinkRes,
1222 DeleteUnlinkData_t(unlinkData);
1223 OIC_LOG(DEBUG, TAG, "OUT SRPUnlinkDevice2CB");
1224 return OC_STACK_DELETE_TRANSACTION;
1229 * Callback handler of unlink first device.
1231 * @param[in] ctx ctx value passed to callback from calling function.
1232 * @param[in] handle handle to an invocation
1233 * @param[in] clientResponse Response from queries to remote servers.
1234 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction and
1235 * OC_STACK_KEEP_TRANSACTION to keep it.
1237 static OCStackApplicationResult SRPUnlinkDevice1CB(void *unlinkCtx, OCDoHandle handle,
1238 OCClientResponse *clientResponse)
1240 OIC_LOG_V(INFO, TAG, "Inside SRPUnlinkDevice1CB ");
1241 VERIFY_NON_NULL(TAG, unlinkCtx, ERROR, OC_STACK_DELETE_TRANSACTION);
1242 UnlinkData_t* unlinkData = (UnlinkData_t*)unlinkCtx;
1247 OIC_LOG(DEBUG, TAG, "Valid client response for device 1");
1248 registerResultForUnlinkDevices(unlinkData, clientResponse->result, IDX_FIRST_DEVICE_RES);
1250 if (OC_STACK_RESOURCE_DELETED == clientResponse->result)
1252 OIC_LOG(DEBUG, TAG, "Credential of device 1 is revoked");
1254 // Second revocation request to second device.
1255 OCStackResult res = SendDeleteCredentialRequest((void*)unlinkData, &SRPUnlinkDevice2CB,
1256 &unlinkData->unlinkDev[0],
1257 &unlinkData->unlinkDev[1] /*Dest*/);
1258 OIC_LOG_V(DEBUG, TAG, "Credential revocation request device 2, result :: %d",res);
1259 if (OC_STACK_OK != res)
1261 OIC_LOG(ERROR, TAG, "Error while sending revocation request for device 2");
1262 registerResultForUnlinkDevices(unlinkData, OC_STACK_INVALID_REQUEST_HANDLE,
1263 IDX_SECOND_DEVICE_RES);
1264 unlinkData->resultCallback(unlinkData->ctx,
1265 unlinkData->numOfResults, unlinkData->unlinkRes, true);
1270 OIC_LOG(DEBUG, TAG, "Request for credential revocation successfully sent");
1271 return OC_STACK_DELETE_TRANSACTION;
1276 OIC_LOG(ERROR, TAG, "Unable to delete credential information from device 1");
1278 unlinkData->resultCallback(unlinkData->ctx, unlinkData->numOfResults,
1279 unlinkData->unlinkRes, true);
1285 OIC_LOG(DEBUG, TAG, "Invalid response from server");
1286 registerResultForUnlinkDevices(unlinkData, OC_STACK_INVALID_REQUEST_HANDLE,
1287 IDX_FIRST_DEVICE_RES );
1288 unlinkData->resultCallback(unlinkData->ctx,
1289 unlinkData->numOfResults, unlinkData->unlinkRes,
1291 OIC_LOG(ERROR, TAG, "SRPUnlinkDevice1CB received Null clientResponse");
1295 OIC_LOG_V(INFO, TAG, "Out SRPUnlinkDevice1CB");
1296 DeleteUnlinkData_t(unlinkData);
1297 return OC_STACK_DELETE_TRANSACTION;
1301 * Function to unlink devices.
1302 * This function will remove the credential & relationship between the two devices.
1304 * @param[in] ctx Application context would be returned in result callback
1305 * @param[in] pTargetDev1 first device information to be unlinked.
1306 * @param[in] pTargetDev2 second device information to be unlinked.
1307 * @param[in] resultCallback callback provided by API user, callback will be called when
1308 * device unlink is finished.
1309 * @return OC_STACK_OK in case of success and other value otherwise.
1311 OCStackResult SRPUnlinkDevices(void* ctx,
1312 const OCProvisionDev_t* pTargetDev1,
1313 const OCProvisionDev_t* pTargetDev2,
1314 OCProvisionResultCB resultCallback)
1316 OIC_LOG(INFO, TAG, "IN SRPUnlinkDevices");
1318 if (!pTargetDev1 || !pTargetDev2 || !pTargetDev1->doxm || !pTargetDev2->doxm)
1320 OIC_LOG(INFO, TAG, "SRPUnlinkDevices : NULL parameters");
1321 return OC_STACK_INVALID_PARAM;
1323 if (!resultCallback)
1325 OIC_LOG(INFO, TAG, "SRPUnlinkDevices : NULL Callback");
1326 return OC_STACK_INVALID_CALLBACK;
1328 if (0 == memcmp(&pTargetDev1->doxm->deviceID, &pTargetDev2->doxm->deviceID, sizeof(OicUuid_t)))
1330 OIC_LOG(INFO, TAG, "SRPUnlinkDevices : Same device ID");
1331 return OC_STACK_INVALID_PARAM;
1334 OIC_LOG(INFO, TAG, "Unlinking following devices: ");
1335 PMPrintOCProvisionDev(pTargetDev1);
1336 PMPrintOCProvisionDev(pTargetDev2);
1338 // Mark the link status stale
1339 OCStackResult res = PDMSetLinkStale(&pTargetDev1->doxm->deviceID, &pTargetDev2->doxm->deviceID);
1340 if (OC_STACK_OK != res)
1342 OIC_LOG(FATAL, TAG, "unable to update DB. Try again.");
1346 UnlinkData_t* unlinkData = (UnlinkData_t*)OICCalloc(1, sizeof(UnlinkData_t));
1347 VERIFY_NON_NULL(TAG, unlinkData, ERROR, OC_STACK_NO_MEMORY);
1349 //Initialize unlink data
1350 unlinkData->ctx = ctx;
1351 unlinkData->unlinkDev = (OCProvisionDev_t*)OICCalloc(2, sizeof(OCProvisionDev_t));
1352 if (NULL == unlinkData->unlinkDev)
1354 OIC_LOG(ERROR, TAG, "Memory allocation failed");
1355 res = OC_STACK_NO_MEMORY;
1359 unlinkData->unlinkRes = (OCProvisionResult_t*)OICCalloc(3, sizeof(OCProvisionResult_t));
1360 if (NULL == unlinkData->unlinkRes)
1362 OIC_LOG(ERROR, TAG, "Memory allocation failed");
1363 res = OC_STACK_NO_MEMORY;
1367 memcpy(&unlinkData->unlinkDev[0], pTargetDev1, sizeof(OCProvisionDev_t));
1368 memcpy(&unlinkData->unlinkDev[1], pTargetDev2, sizeof(OCProvisionDev_t));
1370 unlinkData->numOfResults = 0;
1371 unlinkData->resultCallback = resultCallback;
1373 res = SendDeleteCredentialRequest((void*)unlinkData, &SRPUnlinkDevice1CB,
1374 &unlinkData->unlinkDev[1], &unlinkData->unlinkDev[0]);
1375 if (OC_STACK_OK != res)
1377 OIC_LOG(ERROR, TAG, "SRPUnlinkDevices : SendDeleteCredentialRequest failed");
1384 OIC_LOG(INFO, TAG, "OUT SRPUnlinkDevices");
1385 DeleteUnlinkData_t(unlinkData);
1389 static void DeleteRemoveData_t(RemoveData_t* pRemoveData)
1393 OICFree(pRemoveData->revokeTargetDev);
1394 OCDeleteDiscoveredDevices(pRemoveData->linkedDevList);
1395 OICFree(pRemoveData->removeRes);
1396 OICFree(pRemoveData);
1400 static void registerResultForRemoveDevice(RemoveData_t *removeData, OicUuid_t *pLinkedDevId,
1401 OCStackResult stackresult, bool hasError)
1403 OIC_LOG_V(INFO, TAG, "Inside registerResultForRemoveDevice removeData->numOfResults is %zu\n",
1404 removeData->numOfResults + 1);
1407 memcpy(removeData->removeRes[(removeData->numOfResults)].deviceId.id,
1408 &pLinkedDevId->id, sizeof(pLinkedDevId->id));
1412 memset(removeData->removeRes[(removeData->numOfResults)].deviceId.id,
1413 0, sizeof(pLinkedDevId->id) );
1415 removeData->removeRes[(removeData->numOfResults)].res = stackresult;
1416 removeData->hasError = hasError;
1417 ++(removeData->numOfResults);
1419 // If we get suffcient result from linked devices, we have to call user callback and do free
1420 if (removeData->sizeOfResArray == removeData->numOfResults)
1422 if(!removeData->hasError)
1424 // Remove device info from prvisioning database
1425 if (OC_STACK_OK != PDMDeleteDevice(&removeData->revokeTargetDev->doxm->deviceID))
1427 OIC_LOG(ERROR, TAG, "ResultForRemoveDevice : Failed to remove device in PDM.");
1428 removeData->hasError = true;
1431 removeData->resultCallback(removeData->ctx, removeData->numOfResults, removeData->removeRes,
1432 removeData->hasError);
1433 DeleteRemoveData_t(removeData);
1438 * Callback handler of unlink first device.
1440 * @param[in] ctx ctx value passed to callback from calling function.
1441 * @param[in] handle handle to an invocation
1442 * @param[in] clientResponse Response from queries to remote servers.
1443 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
1444 * and OC_STACK_KEEP_TRANSACTION to keep it.
1446 static OCStackApplicationResult SRPRemoveDeviceCB(void *delDevCtx, OCDoHandle handle,
1447 OCClientResponse *clientResponse)
1449 //Update the delete credential into delete device context
1450 //Save the deleted status in delDevCtx
1452 OIC_LOG_V(INFO, TAG, "Inside SRPRemoveDeviceCB.");
1453 VERIFY_NON_NULL(TAG, delDevCtx, ERROR, OC_STACK_DELETE_TRANSACTION);
1454 OCStackResult res = OC_STACK_ERROR;
1456 RemoveData_t* removeData = (RemoveData_t*)delDevCtx;
1460 OicUuid_t revDevUuid = {.id={0}};
1461 if(UUID_LENGTH == clientResponse->identity.id_length)
1463 memcpy(revDevUuid.id, clientResponse->identity.id, sizeof(revDevUuid.id));
1464 if (OC_STACK_RESOURCE_DELETED == clientResponse->result)
1466 res = PDMUnlinkDevices(&removeData->revokeTargetDev->doxm->deviceID, &revDevUuid);
1467 if (OC_STACK_OK != res)
1469 OIC_LOG(ERROR, TAG, "PDMSetLinkStale() FAIL: PDB is an obsolete one.");
1470 registerResultForRemoveDevice(removeData, &revDevUuid,
1471 OC_STACK_INCONSISTENT_DB, true);
1473 return OC_STACK_DELETE_TRANSACTION;
1476 registerResultForRemoveDevice(removeData, &revDevUuid,
1477 OC_STACK_RESOURCE_DELETED, false);
1481 registerResultForRemoveDevice(removeData, &revDevUuid,
1482 clientResponse->result, true);
1483 OIC_LOG(ERROR, TAG, "Unexpected result from DELETE credential request!");
1488 OIC_LOG_V(WARNING, TAG, "Incorrect length of device UUID was sent from %s:%d",
1489 clientResponse->devAddr.addr, clientResponse->devAddr.port);
1491 if (OC_STACK_RESOURCE_DELETED == clientResponse->result)
1494 * Since server's credential was deleted,
1495 * register result as OC_STACK_INCONSISTENT_DB with NULL UUID.
1497 OIC_LOG_V(ERROR, TAG, "But server's credential was deleted.");
1498 registerResultForRemoveDevice(removeData, NULL, OC_STACK_INCONSISTENT_DB, true);
1502 registerResultForRemoveDevice(removeData, NULL, clientResponse->result, true);
1508 registerResultForRemoveDevice(removeData, NULL, OC_STACK_ERROR, true);
1509 OIC_LOG(ERROR, TAG, "SRPRemoveDevices received Null clientResponse");
1513 return OC_STACK_DELETE_TRANSACTION;
1516 static OCStackResult GetListofDevToReqDeleteCred(const OCProvisionDev_t* pRevokeTargetDev,
1517 OCProvisionDev_t* pOwnedDevList,
1518 OCUuidList_t* pLinkedUuidList,
1519 OCProvisionDev_t** ppLinkedDevList,
1520 size_t *numOfLinkedDev)
1522 // pOwnedDevList could be NULL. It means no alived and owned device now.
1523 if (pRevokeTargetDev == NULL || pLinkedUuidList == NULL ||\
1524 ppLinkedDevList == NULL || numOfLinkedDev == NULL)
1526 return OC_STACK_INVALID_PARAM;
1530 OCUuidList_t *curUuid = NULL, *tmpUuid = NULL;
1531 LL_FOREACH_SAFE(pLinkedUuidList, curUuid, tmpUuid)
1533 // Mark the link status stale.
1534 OCStackResult res = PDMSetLinkStale(&curUuid->dev, &pRevokeTargetDev->doxm->deviceID);
1535 if (OC_STACK_OK != res)
1537 OIC_LOG(FATAL, TAG, "PDMSetLinkStale() FAIL: PDB is an obsolete one.");
1538 return OC_STACK_INCONSISTENT_DB;
1543 // If this linked device is alive (power-on), add the deivce to the list.
1544 OCProvisionDev_t *curDev = NULL, *tmpDev = NULL;
1545 LL_FOREACH_SAFE(pOwnedDevList, curDev, tmpDev)
1547 if (memcmp(curDev->doxm->deviceID.id, curUuid->dev.id, sizeof(curUuid->dev.id)) == 0)
1549 OCProvisionDev_t* targetDev = PMCloneOCProvisionDev(curDev);
1550 if (NULL == targetDev)
1552 OIC_LOG(ERROR, TAG, "SRPRemoveDevice : Cloning OCProvisionDev_t Failed.");
1553 return OC_STACK_NO_MEMORY;
1556 LL_PREPEND(*ppLinkedDevList, targetDev);
1563 *numOfLinkedDev = cnt;
1568 * Function to device revocation
1569 * This function will remove credential of target device from all devices in subnet.
1571 * @param[in] ctx Application context would be returned in result callback
1572 * @param[in] waitTimeForOwnedDeviceDiscovery Maximum wait time for owned device discovery.(seconds)
1573 * @param[in] pTargetDev Device information to be revoked.
1574 * @param[in] resultCallback callback provided by API user, callback will be called when
1575 * credential revocation is finished.
1576 * @return OC_STACK_OK in case of success and other value otherwise.
1577 * If OC_STACK_OK is returned, the caller of this API should wait for callback.
1578 * OC_STACK_CONTINUE means operation is success but no request is need to be initiated.
1580 OCStackResult SRPRemoveDevice(void* ctx, unsigned short waitTimeForOwnedDeviceDiscovery,
1581 const OCProvisionDev_t* pTargetDev, OCProvisionResultCB resultCallback)
1583 OIC_LOG(INFO, TAG, "IN SRPRemoveDevice");
1585 if (!pTargetDev || 0 == waitTimeForOwnedDeviceDiscovery)
1587 OIC_LOG(INFO, TAG, "SRPRemoveDevice : NULL parameters");
1588 return OC_STACK_INVALID_PARAM;
1590 if (!resultCallback)
1592 OIC_LOG(INFO, TAG, "SRPRemoveDevice : NULL Callback");
1593 return OC_STACK_INVALID_CALLBACK;
1596 // Declare variables in here to handle error cases with goto statement.
1597 OCProvisionDev_t* pOwnedDevList = NULL;
1598 OCProvisionDev_t* pLinkedDevList = NULL;
1599 RemoveData_t* removeData = NULL;
1601 //1. Find all devices that has a credential of the revoked device
1602 OCUuidList_t* pLinkedUuidList = NULL;
1603 size_t numOfDevices = 0;
1604 OCStackResult res = OC_STACK_ERROR;
1605 res = PDMGetLinkedDevices(&pTargetDev->doxm->deviceID, &pLinkedUuidList, &numOfDevices);
1606 if (OC_STACK_OK != res)
1608 OIC_LOG(ERROR, TAG, "SRPRemoveDevice : Failed to get linked devices information");
1611 // if there is no related device, we can skip further process.
1612 if (0 == numOfDevices)
1614 OIC_LOG(DEBUG, TAG, "SRPRemoveDevice : No linked device found.");
1615 res = OC_STACK_CONTINUE;
1619 //2. Find owned device from the network
1620 res = PMDeviceDiscovery(waitTimeForOwnedDeviceDiscovery, true, &pOwnedDevList);
1621 if (OC_STACK_OK != res)
1623 OIC_LOG(ERROR, TAG, "SRPRemoveDevice : Failed to PMDeviceDiscovery");
1627 //3. Make a list of devices to send DELETE credential request
1628 // by comparing owned devices from provisioning database with mutlicast discovery result.
1629 size_t numOfLinkedDev = 0;
1630 res = GetListofDevToReqDeleteCred(pTargetDev, pOwnedDevList, pLinkedUuidList,
1631 &pLinkedDevList, &numOfLinkedDev);
1632 if (OC_STACK_OK != res)
1634 OIC_LOG(ERROR, TAG, "SRPRemoveDevice : GetListofDevToReqDeleteCred() failed");
1637 if (0 == numOfLinkedDev) // This case means, there is linked device but it's not alive now.
1638 { // So we don't have to send request message.
1639 OIC_LOG(DEBUG, TAG, "SRPRemoveDevice : No alived & linked device found.");
1640 res = OC_STACK_CONTINUE;
1644 // 4. Prepare RemoveData Context data.
1645 removeData = (RemoveData_t*)OICCalloc(1, sizeof(RemoveData_t));
1648 OIC_LOG(ERROR, TAG, "SRPRemoveDevices : Failed to memory allocation");
1649 res = OC_STACK_NO_MEMORY;
1653 removeData->revokeTargetDev = PMCloneOCProvisionDev(pTargetDev);
1654 if (!removeData->revokeTargetDev)
1656 OIC_LOG(ERROR, TAG, "SRPRemoveDevices : PMCloneOCProvisionDev Failed");
1657 res = OC_STACK_NO_MEMORY;
1661 removeData->removeRes =
1662 (OCProvisionResult_t*)OICCalloc(numOfLinkedDev, sizeof(OCProvisionResult_t));
1663 if (!removeData->removeRes)
1665 OIC_LOG(ERROR, TAG, "SRPRemoveDevices : Failed to memory allocation");
1666 res = OC_STACK_NO_MEMORY;
1670 removeData->ctx = ctx;
1671 removeData->linkedDevList = pLinkedDevList;
1672 removeData->resultCallback = resultCallback;
1673 removeData->numOfResults = 0;
1674 removeData->sizeOfResArray = numOfLinkedDev;
1675 removeData->hasError = false;
1677 // 5. Send DELETE credential request to linked devices.
1678 OCProvisionDev_t *curDev = NULL, *tmpDev = NULL;
1679 OCStackResult totalRes = OC_STACK_ERROR; /* variable for checking request is sent or not */
1680 LL_FOREACH_SAFE(pLinkedDevList, curDev, tmpDev)
1682 res = SendDeleteCredentialRequest((void*)removeData, &SRPRemoveDeviceCB,
1683 removeData->revokeTargetDev, curDev);
1684 if (OC_STACK_OK != res)
1686 OIC_LOG_V(ERROR, TAG, "SRPRemoveDevice : Fail to send the DELETE credential request to\
1687 %s:%u", curDev->endpoint.addr, curDev->endpoint.port);
1691 totalRes = OC_STACK_OK; // This means at least one request is successfully sent.
1695 PDMDestoryOicUuidLinkList(pLinkedUuidList); //TODO: Modify API name to have unified convention.
1696 PMDeleteDeviceList(pOwnedDevList);
1697 OIC_LOG(INFO, TAG, "OUT SRPRemoveDevice");
1699 return totalRes; // Caller of this API should wait callback if totalRes == OC_STACK_OK.
1702 PDMDestoryOicUuidLinkList(pLinkedUuidList);
1703 PMDeleteDeviceList(pOwnedDevList);
1704 PMDeleteDeviceList(pLinkedDevList);
1707 OICFree(removeData->revokeTargetDev);
1708 OICFree(removeData->removeRes);
1709 OICFree(removeData);
1711 OIC_LOG(INFO, TAG, "OUT ERROR case SRPRemoveDevice");