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 * *****************************************************************/
25 #include "ocprovisioningmanager.h"
26 #include "secureresourceprovider.h"
28 #include "oic_malloc.h"
29 #include "aclresource.h"
30 #include "pstatresource.h"
31 #include "srmresourcestrings.h"
32 #include "credresource.h"
33 #include "doxmresource.h"
34 #include "pconfresource.h"
35 #include "credentialgenerator.h"
36 #include "cainterface.h"
39 #include "pmutility.h"
40 #include "provisioningdatabasemanager.h"
43 #include "ocpayload.h"
46 #include "crlresource.h"
52 * Macro to verify argument is not equal to NULL.
53 * eg: VERIFY_NON_NULL(TAG, ptrData, ERROR,OC_STACK_ERROR);
55 #define VERIFY_NON_NULL(tag, arg, logLevel, retValue) { if (NULL == (arg)) \
56 { OIC_LOG((logLevel), tag, #arg " is NULL"); return retValue; } }
59 * Macro to verify success of operation.
60 * eg: VERIFY_SUCCESS(TAG, OC_STACK_OK == foo(), ERROR, OC_STACK_ERROR);
62 #define VERIFY_SUCCESS(tag, op, logLevel, retValue) { if (!(op)) \
63 {OIC_LOG((logLevel), tag, #op " failed!!"); return retValue;} }
66 * Structure to carry credential data to callback.
68 typedef struct CredentialData CredentialData_t;
71 void *ctx; /**< Pointer to user context.**/
72 const OCProvisionDev_t *deviceInfo1; /**< Pointer to OCProvisionDev_t.**/
73 const OCProvisionDev_t *deviceInfo2; /**< Pointer to OCProvisionDev_t.**/
74 OicSecCred_t *credInfo; /**< Pointer to OicSecCred_t.**/
75 OicSecCred_t *credInfoFirst; /**< Pointer to OicSecCred_t.**/
76 OCProvisionResultCB resultCallback; /**< Pointer to result callback.**/
77 OCProvisionResult_t *resArr; /**< Result array.**/
78 int numOfResults; /**< Number of results in result array.**/
82 * Structure to carry ACL provision API data to callback.
84 typedef struct ACLData ACLData_t;
87 void *ctx; /**< Pointer to user context.**/
88 const OCProvisionDev_t *deviceInfo; /**< Pointer to PMDevInfo_t.**/
89 OCProvisionResultCB resultCallback; /**< Pointer to result callback.**/
90 OCProvisionResult_t *resArr; /**< Result array.**/
91 int numOfResults; /**< Number of results in result array.**/
95 * Structure to carry PCONF provision API data to callback.
97 typedef struct PconfData PconfData_t;
100 void *ctx; /**< Pointer to user context.**/
101 const OCProvisionDev_t *deviceInfo; /**< Pointer to PMDevInfo_t.**/
102 OCProvisionResultCB resultCallback; /**< Pointer to result callback.**/
103 OCProvisionResult_t *resArr; /**< Result array.**/
104 int numOfResults; /**< Number of results in result array.**/
107 // Enum type index for unlink callback.
109 IDX_FIRST_DEVICE_RES = 0, // index for resulf of the first device
110 IDX_SECOND_DEVICE_RES, // index for result of the second device
111 IDX_DB_UPDATE_RES // index for result of updating provisioning database.
114 // Structure to carry unlink APIs data to callback.
115 typedef struct UnlinkData UnlinkData_t;
118 OCProvisionDev_t* unlinkDev; /**< Pointer to OCProvisionDev_t to be unlinked.**/
119 OCProvisionResult_t* unlinkRes; /**< Result array.**/
120 OCProvisionResultCB resultCallback; /**< Pointer to result callback.**/
121 int numOfResults; /**< Number of results in result array.**/
124 //Example of DELETE cred request -> coaps://0.0.0.0:5684/oic/sec/cred?sub=(BASE64 ENCODED UUID)
125 const char * SRP_FORM_DELETE_CREDENTIAL = "coaps://[%s]:%d%s?%s=%s";
127 // Structure to carry remove APIs data to callback.
128 typedef struct RemoveData RemoveData_t;
131 OCProvisionDev_t* revokeTargetDev; /**< Device which is going to be revoked..**/
132 OCProvisionDev_t* linkedDevList; /**< A list of devices which have invalid credential.**/
133 OCProvisionResult_t* removeRes; /**< Result array.**/
134 OCProvisionResultCB resultCallback; /**< Pointer to result callback.**/
135 size_t numOfResults; /**< Number of results in result array.**/
136 size_t sizeOfResArray;
143 static OCStackResult provisionCredentials(const OicSecCred_t *cred,
144 const OCProvisionDev_t *deviceInfo, CredentialData_t *credData,
145 OCClientResponseHandler responseHandler);
149 * Internal function to update result in result array.
151 static void registerResultForCredProvisioning(CredentialData_t *credData,
152 OCStackResult stackresult, int cause)
155 OIC_LOG_V(INFO,TAG,"value of credData->numOfResults is %d",credData->numOfResults);
158 memcpy(credData->resArr[(credData->numOfResults)].deviceId.id,
159 credData->deviceInfo1->doxm->deviceID.id,UUID_LENGTH);
163 memcpy(credData->resArr[(credData->numOfResults)].deviceId.id,
164 credData->deviceInfo2->doxm->deviceID.id,UUID_LENGTH);
166 credData->resArr[(credData->numOfResults)].res = stackresult;
167 ++(credData->numOfResults);
171 * Callback handler for handling callback of provisioning device 2.
173 * @param[in] ctx ctx value passed to callback from calling function.
174 * @param[in] UNUSED handle to an invocation
175 * @param[in] clientResponse Response from queries to remote servers.
176 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
177 * and OC_STACK_KEEP_TRANSACTION to keep it.
179 static OCStackApplicationResult provisionCredentialCB2(void *ctx, OCDoHandle UNUSED,
180 OCClientResponse *clientResponse)
182 VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
183 CredentialData_t *credData = (CredentialData_t *) ctx;
186 OCProvisionResultCB resultCallback = credData->resultCallback;
187 OIC_LOG(INFO, TAG, "provisionCredentialCB2 called");
190 if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
192 registerResultForCredProvisioning(credData, OC_STACK_RESOURCE_CREATED, 2);
193 OCStackResult res = PDMLinkDevices(&credData->deviceInfo1->doxm->deviceID,
194 &credData->deviceInfo2->doxm->deviceID);
195 if (OC_STACK_OK != res)
197 OIC_LOG(ERROR, TAG, "Error occured on PDMLinkDevices");
198 return OC_STACK_DELETE_TRANSACTION;
200 OIC_LOG(INFO, TAG, "Link created successfully");
202 ((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
205 OICFree(credData->resArr);
207 return OC_STACK_DELETE_TRANSACTION;
211 OIC_LOG(INFO, TAG, "provisionCredentialCB2 received Null clientResponse");
212 registerResultForCredProvisioning(credData, OC_STACK_ERROR, 2);
213 ((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
216 OICFree(credData->resArr);
218 return OC_STACK_DELETE_TRANSACTION;
222 * Callback handler for handling callback of provisioning device 1.
224 * @param[in] ctx ctx value passed to callback from calling function.
225 * @param[in] UNUSED handle to an invocation
226 * @param[in] clientResponse Response from queries to remote servers.
227 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
228 * and OC_STACK_KEEP_TRANSACTION to keep it.
230 static OCStackApplicationResult provisionCredentialCB1(void *ctx, OCDoHandle UNUSED,
231 OCClientResponse *clientResponse)
233 VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
235 CredentialData_t* credData = (CredentialData_t*) ctx;
236 OICFree(credData->credInfoFirst);
237 const OCProvisionDev_t *deviceInfo = credData->deviceInfo2;
238 OicSecCred_t *credInfo = credData->credInfo;
239 const OCProvisionResultCB resultCallback = credData->resultCallback;
242 if (OC_STACK_RESOURCE_CREATED == clientResponse->result)
244 // send credentials to second device
245 registerResultForCredProvisioning(credData, OC_STACK_RESOURCE_CREATED,1);
246 OCStackResult res = provisionCredentials(credInfo, deviceInfo, credData,
247 provisionCredentialCB2);
248 DeleteCredList(credInfo);
249 if (OC_STACK_OK != res)
251 registerResultForCredProvisioning(credData, res,2);
252 ((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
255 OICFree(credData->resArr);
262 registerResultForCredProvisioning(credData, OC_STACK_ERROR,1);
263 ((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
266 OICFree(credData->resArr);
273 OIC_LOG(INFO, TAG, "provisionCredentialCB received Null clientResponse for first device");
274 registerResultForCredProvisioning(credData, OC_STACK_ERROR,1);
275 ((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
278 DeleteCredList(credInfo);
279 OICFree(credData->resArr);
283 return OC_STACK_DELETE_TRANSACTION;
289 * Internal function for handling credential generation and sending credential to resource server.
291 * @param[in] cred Instance of cred resource.
292 * @param[in] deviceInfo information about device to which credential is to be provisioned.
293 * @param[in] responseHandler callbak called by OC stack when request API receives response.
294 * @return OC_STACK_OK in case of success and other value otherwise.
296 static OCStackResult provisionCredentials(const OicSecCred_t *cred,
297 const OCProvisionDev_t *deviceInfo, CredentialData_t *credData,
298 OCClientResponseHandler responseHandler)
300 OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
303 OIC_LOG(ERROR, TAG, "Failed to memory allocation");
304 return OC_STACK_NO_MEMORY;
306 secPayload->base.type = PAYLOAD_TYPE_SECURITY;
307 OCStackResult res = CredToCBORPayload(cred, &secPayload->securityData1, &secPayload->payloadSize);
308 if((OC_STACK_OK != res) && (NULL == secPayload->securityData1))
310 OCPayloadDestroy((OCPayload *)secPayload);
311 OIC_LOG(ERROR, TAG, "Failed to CredToCBORPayload");
312 return OC_STACK_NO_MEMORY;
315 OIC_LOG_V(INFO, TAG, "Credential for provisioning : %s",secPayload->securityData1);
316 char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
317 if(!PMGenerateQuery(true,
318 deviceInfo->endpoint.addr,
319 deviceInfo->securePort,
320 deviceInfo->connType,
321 query, sizeof(query), OIC_RSRC_CRED_URI))
323 OIC_LOG(ERROR, TAG, "DeviceDiscoveryHandler : Failed to generate query");
324 return OC_STACK_ERROR;
326 OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
328 OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL};
329 cbData.cb = responseHandler;
330 cbData.context = (void *) credData;
333 OCDoHandle handle = NULL;
334 OCMethod method = OC_REST_POST;
335 OCStackResult ret = OCDoResource(&handle, method, query, 0, (OCPayload*)secPayload,
336 deviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
337 OIC_LOG_V(INFO, TAG, "OCDoResource::Credential provisioning returned : %d",ret);
338 if (ret != OC_STACK_OK)
340 OIC_LOG(ERROR, TAG, "OCStack resource error");
348 * Structure to carry certificate data to callback.
350 typedef struct CertificateData CertData_t;
351 struct CertificateData
353 void *ctx; /**< Pointer to user context.**/
354 const OCProvisionDev_t *deviceInfo; /**< Pointer to OCProvisionDev_t.**/
355 OicSecCred_t *credInfo; /**< Pointer to OicSecCred_t.**/
356 OCProvisionResultCB resultCallback; /**< Pointer to result callback.**/
357 OCProvisionResult_t *resArr; /**< Result array.**/
358 int numOfResults; /**< Number of results in result array.**/
362 * Structure to carry CRL provision API data to callback.
364 typedef struct CRLData CRLData_t;
367 void *ctx; /**< Pointer to user context.**/
368 const OCProvisionDev_t *deviceInfo; /**< Pointer to PMDevInfo_t.**/
369 OCProvisionResultCB resultCallback; /**< Pointer to result callback.**/
370 OCProvisionResult_t *resArr; /**< Result array.**/
371 int numOfResults; /**< Number of results in result array.**/
375 * Internal function to update result in result array.
377 static void registerResultForCertProvisioning(CertData_t *certData,
378 OCStackResult stackresult)
381 OIC_LOG_V(INFO,TAG,"value of credData->numOfResults is %d",certData->numOfResults);
382 memcpy(certData->resArr[(certData->numOfResults)].deviceId.id,
383 certData->deviceInfo->doxm->deviceID.id,UUID_LENGTH);
384 certData->resArr[(certData->numOfResults)].res = stackresult;
385 ++(certData->numOfResults);
389 * Internal Function to store results in result array during ACL provisioning.
391 static void registerResultForCRLProvisioning(CRLData_t *crlData,
392 OCStackResult stackresult)
394 OIC_LOG_V(INFO, TAG, "Inside registerResultForCRLProvisioning crlData->numOfResults is %d\n",
395 crlData->numOfResults);
396 memcpy(crlData->resArr[(crlData->numOfResults)].deviceId.id,
397 crlData->deviceInfo->doxm->deviceID.id, UUID_LENGTH);
398 crlData->resArr[(crlData->numOfResults)].res = stackresult;
399 ++(crlData->numOfResults);
404 * Callback handler of SRPProvisionCRL.
406 * @param[in] ctx ctx value passed to callback from calling function.
407 * @param[in] UNUSED handle to an invocation
408 * @param[in] clientResponse Response from queries to remote servers.
409 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
410 * and OC_STACK_KEEP_TRANSACTION to keep it.
412 static OCStackApplicationResult SRPProvisionCRLCB(void *ctx, OCDoHandle UNUSED,
413 OCClientResponse *clientResponse)
415 OIC_LOG_V(INFO, TAG, "Inside SRPProvisionCRLCB.");
417 VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
418 CRLData_t *crlData = (CRLData_t*)ctx;
419 OCProvisionResultCB resultCallback = crlData->resultCallback;
423 if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
425 registerResultForCRLProvisioning(crlData, OC_STACK_RESOURCE_CREATED);
426 ((OCProvisionResultCB)(resultCallback))(crlData->ctx, crlData->numOfResults,
429 OICFree(crlData->resArr);
431 return OC_STACK_DELETE_TRANSACTION;
434 registerResultForCRLProvisioning(crlData, OC_STACK_ERROR);
435 ((OCProvisionResultCB)(resultCallback))(crlData->ctx, crlData->numOfResults,
438 OIC_LOG_V(ERROR, TAG, "SRPProvisionCRLCB received Null clientResponse");
439 OICFree(crlData->resArr);
441 return OC_STACK_DELETE_TRANSACTION;
444 OCStackResult SRPProvisionCRL(void *ctx, const OCProvisionDev_t *selectedDeviceInfo,
445 OicSecCrl_t *crl, OCProvisionResultCB resultCallback)
447 VERIFY_NON_NULL(TAG, selectedDeviceInfo, ERROR, OC_STACK_INVALID_PARAM);
448 VERIFY_NON_NULL(TAG, crl, ERROR, OC_STACK_INVALID_PARAM);
449 VERIFY_NON_NULL(TAG, resultCallback, ERROR, OC_STACK_INVALID_CALLBACK);
451 OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
454 OIC_LOG(ERROR, TAG, "Failed to memory allocation");
455 return OC_STACK_NO_MEMORY;
458 secPayload->base.type = PAYLOAD_TYPE_SECURITY;
459 OCStackResult res = CrlToCBORPayload(crl, &secPayload->securityData1, &secPayload->payloadSize);
460 if((OC_STACK_OK != res) && (NULL == secPayload->securityData1))
463 OIC_LOG(ERROR, TAG, "Failed to BinToCrlJSON");
464 return OC_STACK_NO_MEMORY;
466 OIC_LOG_V(INFO, TAG, "CRL : %s", secPayload->securityData1);
468 char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
469 if(!PMGenerateQuery(true,
470 selectedDeviceInfo->endpoint.addr,
471 selectedDeviceInfo->securePort,
472 selectedDeviceInfo->connType,
473 query, sizeof(query), OIC_RSRC_CRL_URI))
475 OIC_LOG(ERROR, TAG, "DeviceDiscoveryHandler : Failed to generate query");
476 OCPayloadDestroy((OCPayload *)secPayload);
477 return OC_STACK_ERROR;
479 OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
481 OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL};
482 cbData.cb = &SRPProvisionCRLCB;
483 CRLData_t *crlData = (CRLData_t *) OICCalloc(1, sizeof(CRLData_t));
486 OCPayloadDestroy((OCPayload *)secPayload);
487 OIC_LOG(ERROR, TAG, "Unable to allocate memory");
488 return OC_STACK_NO_MEMORY;
491 crlData->deviceInfo = selectedDeviceInfo;
492 crlData->resultCallback = resultCallback;
493 crlData->numOfResults=0;
496 crlData->resArr = (OCProvisionResult_t*)OICCalloc(1, sizeof(OCProvisionResult_t));
497 if (crlData->resArr == NULL)
499 OCPayloadDestroy((OCPayload *)secPayload);
500 OIC_LOG(ERROR, TAG, "Unable to allocate memory");
501 return OC_STACK_NO_MEMORY;
504 cbData.context = (void *)crlData;
506 OCMethod method = OC_REST_POST;
507 OCDoHandle handle = NULL;
508 OIC_LOG(DEBUG, TAG, "Sending CRL info to resource server");
510 OCStackResult ret = OCDoResource(&handle, method, query,
511 &selectedDeviceInfo->endpoint, (OCPayload*)secPayload,
512 selectedDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
514 if (ret != OC_STACK_OK)
516 OICFree(crlData->resArr);
524 * Internal function for handling credential generation and sending cretificate credential.
526 * @param[in] cred Instance of cred resource.
527 * @param[in] deviceInfo information about device to which credential is to be provisioned.
528 * @param[in] responseHandler callbak called by OC stack when request API receives response.
529 * @return OC_STACK_OK in case of success and other value otherwise.
531 static OCStackResult provisionCertCred(const OicSecCred_t *cred,
532 const OCProvisionDev_t *deviceInfo, CertData_t *certData,
533 OCClientResponseHandler responseHandler)
535 OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
538 OIC_LOG(ERROR, TAG, "Failed to memory allocation");
539 return OC_STACK_NO_MEMORY;
541 secPayload->base.type = PAYLOAD_TYPE_SECURITY;
542 OCStackResult res = CredToCBORPayload(cred, &secPayload->securityData1,
543 &secPayload->payloadSize);
545 if ((OC_STACK_OK != res) || (NULL == secPayload->securityData1))
548 OIC_LOG(ERROR, TAG, "Failed to CredToCBORPayload");
549 return OC_STACK_NO_MEMORY;
552 OIC_LOG_V(INFO, TAG, "Credential for provisioning : %s",secPayload->securityData1);
553 char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
554 if(!PMGenerateQuery(true,
555 deviceInfo->endpoint.addr,
556 deviceInfo->securePort,
557 deviceInfo->connType,
558 query, sizeof(query), OIC_RSRC_CRED_URI))
560 OIC_LOG(ERROR, TAG, "DeviceDiscoveryHandler : Failed to generate query");
561 OCPayloadDestroy((OCPayload *)secPayload);
562 return OC_STACK_ERROR;
564 OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
566 OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL};
567 cbData.cb = responseHandler;
568 cbData.context = (void *) certData;
571 OCDoHandle handle = NULL;
572 OCMethod method = OC_REST_POST;
573 OCStackResult ret = OCDoResource(&handle, method, query, 0, (OCPayload*)secPayload,
574 deviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
575 OIC_LOG_V(INFO, TAG, "OCDoResource::Certificate provisioning returned : %d",ret);
576 if (ret != OC_STACK_OK)
578 OIC_LOG(ERROR, TAG, "OCStack resource error");
585 * Callback handler for handling callback of certificate provisioning device.
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 provisionCertCB(void *ctx, OCDoHandle UNUSED,
594 OCClientResponse *clientResponse)
596 VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
597 CertData_t *certData = (CertData_t *) ctx;
600 OCProvisionResultCB resultCallback = certData->resultCallback;
601 OIC_LOG(INFO, TAG, "provisionCertCred called");
604 if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
606 registerResultForCertProvisioning(certData, OC_STACK_RESOURCE_CREATED);
607 ((OCProvisionResultCB)(resultCallback))(certData->ctx, certData->numOfResults,
610 OICFree(certData->resArr);
612 return OC_STACK_DELETE_TRANSACTION;
616 OIC_LOG(INFO, TAG, "provisionCertCredCB received Null clientResponse");
617 registerResultForCertProvisioning(certData, OC_STACK_ERROR);
618 ((OCProvisionResultCB)(resultCallback))(certData->ctx, certData->numOfResults,
621 OICFree(certData->resArr);
623 return OC_STACK_DELETE_TRANSACTION;
625 #endif // __WITH_X509__
627 OCStackResult SRPProvisionCredentials(void *ctx, OicSecCredType_t type, size_t keySize,
628 const OCProvisionDev_t *pDev1,
629 const OCProvisionDev_t *pDev2,
630 OCProvisionResultCB resultCallback)
632 if (!pDev1 || !pDev2 || !pDev1->doxm || !pDev2->doxm)
634 OIC_LOG(INFO, TAG, "SRPUnlinkDevices : NULL parameters");
635 return OC_STACK_INVALID_PARAM;
639 OIC_LOG(INFO, TAG, "SRPUnlinkDevices : NULL Callback");
640 return OC_STACK_INVALID_CALLBACK;
642 if (0 == memcmp(&pDev1->doxm->deviceID, &pDev2->doxm->deviceID, sizeof(OicUuid_t)))
644 OIC_LOG(INFO, TAG, "SRPUnlinkDevices : Same device ID");
645 return OC_STACK_INVALID_PARAM;
648 if (SYMMETRIC_PAIR_WISE_KEY == type &&
649 !(OWNER_PSK_LENGTH_128 == keySize || OWNER_PSK_LENGTH_256 == keySize))
651 OIC_LOG(INFO, TAG, "Invalid key size");
652 return OC_STACK_INVALID_PARAM;
655 OIC_LOG(INFO, TAG, "In SRPProvisionCredentials");
657 if (SYMMETRIC_PAIR_WISE_KEY == type)
659 bool linkExisits = true;
660 OCStackResult res = PDMIsLinkExists(&pDev1->doxm->deviceID, &pDev2->doxm->deviceID, &linkExisits);
662 if (res != OC_STACK_OK)
664 OIC_LOG(ERROR, TAG, "Internal error occured");
669 OIC_LOG(ERROR, TAG, "Link already exists");
670 return OC_STACK_INVALID_PARAM;
674 OicUuid_t provTooldeviceID = {{0,}};
675 if (OC_STACK_OK != GetDoxmDeviceID(&provTooldeviceID))
677 OIC_LOG(ERROR, TAG, "Error while retrieving provisioning tool's device ID");
678 return OC_STACK_ERROR;
680 OIC_LOG(INFO, TAG, "retrieved deviceid");
683 case SYMMETRIC_PAIR_WISE_KEY:
685 const OCProvisionDev_t *firstDevice = pDev1;
686 const OCProvisionDev_t *secondDevice = pDev2;
688 OicSecCred_t *firstCred = NULL;
689 OicSecCred_t *secondCred = NULL;
690 OCStackResult res = PMGeneratePairWiseCredentials(type, keySize, &provTooldeviceID,
691 &firstDevice->doxm->deviceID, &secondDevice->doxm->deviceID,
692 &firstCred, &secondCred);
693 VERIFY_SUCCESS(TAG, (res==OC_STACK_OK), ERROR, OC_STACK_ERROR);
694 OIC_LOG(INFO, TAG, "Credentials generated successfully");
695 CredentialData_t *credData =
696 (CredentialData_t *) OICCalloc(1, sizeof(CredentialData_t));
697 if (NULL == credData)
701 OIC_LOG(ERROR, TAG, "Memory allocation problem");
702 return OC_STACK_NO_MEMORY;
704 credData->deviceInfo1 = firstDevice;
705 credData->deviceInfo2 = secondDevice;
706 credData->credInfo = secondCred;
708 credData->credInfoFirst = firstCred;
709 credData->numOfResults = 0;
710 credData->resultCallback = resultCallback;
711 // first call to provision creds to device1.
712 // second call to provision creds to device2.
715 (OCProvisionResult_t*)OICCalloc(noOfRiCalls, sizeof(OCProvisionResult_t));
716 if (NULL == credData->resArr)
721 OIC_LOG(ERROR, TAG, "Memory allocation problem");
722 return OC_STACK_NO_MEMORY;
724 res = provisionCredentials(firstCred, firstDevice, credData, &provisionCredentialCB1);
725 if (OC_STACK_OK != res)
727 DeleteCredList(firstCred);
728 DeleteCredList(secondCred);
729 OICFree(credData->resArr);
732 OIC_LOG_V(INFO, TAG, "provisionCredentials returned: %d",res);
733 VERIFY_SUCCESS(TAG, (res==OC_STACK_OK), ERROR, OC_STACK_ERROR);
737 case SIGNED_ASYMMETRIC_KEY:
739 const OCProvisionDev_t *firstDevice = pDev1;
740 OicSecCred_t *cred = NULL;
741 OCStackResult res = PMGenerateCertificateCredentials(&provTooldeviceID,
742 &firstDevice->doxm->deviceID,&cred);
743 VERIFY_SUCCESS(TAG, (res==OC_STACK_OK), ERROR, OC_STACK_ERROR);
744 OIC_LOG(INFO, TAG, "Certificate credentials generated successfully");
745 CertData_t *certData = (CertData_t *) OICCalloc(1, sizeof(CertData_t));
746 if (NULL == certData)
749 OIC_LOG(ERROR, TAG, "Memory allocation problem");
750 return OC_STACK_NO_MEMORY;
753 certData->deviceInfo = firstDevice;
755 certData->credInfo = cred;
756 certData->numOfResults = 0;
757 certData->resultCallback = resultCallback;
759 certData->resArr = (OCProvisionResult_t*)OICCalloc(1, sizeof(OCProvisionResult_t));
760 if (NULL == certData->resArr)
762 DeleteCredList(cred);
764 OIC_LOG(ERROR, TAG, "Memory allocation problem");
765 return OC_STACK_NO_MEMORY;
768 res = provisionCertCred(cred, firstDevice, certData, &provisionCertCB);
769 if (OC_STACK_OK != res)
771 OICFree(certData->resArr);
774 DeleteCredList(cred);
775 OIC_LOG_V(INFO, TAG, "provisionCertCredentials returned: %d",res);
782 OIC_LOG(ERROR, TAG, "Invalid option.");
783 return OC_STACK_INVALID_PARAM;
786 return OC_STACK_ERROR;
790 * Internal Function to store results in result array during ACL provisioning.
792 static void registerResultForACLProvisioning(ACLData_t *aclData,
793 OCStackResult stackresult)
795 OIC_LOG_V(INFO, TAG, "Inside registerResultForACLProvisioning aclData->numOfResults is %d\n",
796 aclData->numOfResults);
797 memcpy(aclData->resArr[(aclData->numOfResults)].deviceId.id,
798 aclData->deviceInfo->doxm->deviceID.id, UUID_LENGTH);
799 aclData->resArr[(aclData->numOfResults)].res = stackresult;
800 ++(aclData->numOfResults);
804 * Callback handler of SRPProvisionACL.
806 * @param[in] ctx ctx value passed to callback from calling function.
807 * @param[in] UNUSED handle to an invocation
808 * @param[in] clientResponse Response from queries to remote servers.
809 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
810 * and OC_STACK_KEEP_TRANSACTION to keep it.
812 static OCStackApplicationResult SRPProvisionACLCB(void *ctx, OCDoHandle UNUSED,
813 OCClientResponse *clientResponse)
815 OIC_LOG_V(INFO, TAG, "Inside SRPProvisionACLCB.");
817 VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
818 ACLData_t *aclData = (ACLData_t*)ctx;
819 OCProvisionResultCB resultCallback = aclData->resultCallback;
823 if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
825 registerResultForACLProvisioning(aclData, OC_STACK_RESOURCE_CREATED);
826 ((OCProvisionResultCB)(resultCallback))(aclData->ctx, aclData->numOfResults,
829 OICFree(aclData->resArr);
831 return OC_STACK_DELETE_TRANSACTION;
834 registerResultForACLProvisioning(aclData, OC_STACK_ERROR);
835 ((OCProvisionResultCB)(resultCallback))(aclData->ctx, aclData->numOfResults,
838 OIC_LOG_V(ERROR, TAG, "SRPProvisionACLCB received Null clientResponse");
839 OICFree(aclData->resArr);
841 return OC_STACK_DELETE_TRANSACTION;
844 OCStackResult SRPProvisionACL(void *ctx, const OCProvisionDev_t *selectedDeviceInfo,
845 OicSecAcl_t *acl, OCProvisionResultCB resultCallback)
847 VERIFY_NON_NULL(TAG, selectedDeviceInfo, ERROR, OC_STACK_INVALID_PARAM);
848 VERIFY_NON_NULL(TAG, acl, ERROR, OC_STACK_INVALID_PARAM);
849 VERIFY_NON_NULL(TAG, resultCallback, ERROR, OC_STACK_INVALID_CALLBACK);
851 OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
854 OIC_LOG(ERROR, TAG, "Failed to memory allocation");
855 return OC_STACK_NO_MEMORY;
857 secPayload->base.type = PAYLOAD_TYPE_SECURITY;
858 if(OC_STACK_OK != AclToCBORPayload(acl, &secPayload->securityData1, &secPayload->payloadSize))
860 OCPayloadDestroy((OCPayload *)secPayload);
861 OIC_LOG(ERROR, TAG, "Failed to AclToCBORPayload");
862 return OC_STACK_NO_MEMORY;
864 char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
865 if(!PMGenerateQuery(true,
866 selectedDeviceInfo->endpoint.addr,
867 selectedDeviceInfo->securePort,
868 selectedDeviceInfo->connType,
869 query, sizeof(query), OIC_RSRC_ACL_URI))
871 OIC_LOG(ERROR, TAG, "DeviceDiscoveryHandler : Failed to generate query");
872 return OC_STACK_ERROR;
874 OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
876 OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL};
877 cbData.cb = &SRPProvisionACLCB;
878 ACLData_t *aclData = (ACLData_t *) OICCalloc(1, sizeof(ACLData_t));
881 OCPayloadDestroy((OCPayload *)secPayload);
882 OIC_LOG(ERROR, TAG, "Unable to allocate memory");
883 return OC_STACK_NO_MEMORY;
885 aclData->deviceInfo = selectedDeviceInfo;
886 aclData->resultCallback = resultCallback;
887 aclData->numOfResults=0;
889 // call to provision ACL to device1.
891 aclData->resArr = (OCProvisionResult_t*)OICCalloc(noOfRiCalls, sizeof(OCProvisionResult_t));
892 if (aclData->resArr == NULL)
895 OCPayloadDestroy((OCPayload *)secPayload);
896 OIC_LOG(ERROR, TAG, "Unable to allocate memory");
897 return OC_STACK_NO_MEMORY;
899 cbData.context = (void *)aclData;
901 OCMethod method = OC_REST_POST;
902 OCDoHandle handle = NULL;
903 OIC_LOG(DEBUG, TAG, "Sending ACL info to resource server");
904 OCStackResult ret = OCDoResource(&handle, method, query,
905 &selectedDeviceInfo->endpoint, (OCPayload*)secPayload,
906 selectedDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
907 if (ret != OC_STACK_OK)
909 OICFree(aclData->resArr);
912 VERIFY_SUCCESS(TAG, (OC_STACK_OK == ret), ERROR, OC_STACK_ERROR);
917 * Internal Function to store results in result array during Direct-Pairing provisioning.
919 static void registerResultForDirectPairingProvisioning(PconfData_t *pconfData,
920 OCStackResult stackresult)
922 OIC_LOG_V(INFO, TAG, "Inside registerResultForDirectPairingProvisioning "
923 "pconfData->numOfResults is %d\n", pconfData->numOfResults);
924 memcpy(pconfData->resArr[(pconfData->numOfResults)].deviceId.id,
925 pconfData->deviceInfo->doxm->deviceID.id, UUID_LENGTH);
926 pconfData->resArr[(pconfData->numOfResults)].res = stackresult;
927 ++(pconfData->numOfResults);
931 * Callback handler of SRPProvisionDirectPairing.
933 * @param[in] ctx ctx value passed to callback from calling function.
934 * @param[in] UNUSED handle to an invocation
935 * @param[in] clientResponse Response from queries to remote servers.
936 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
937 * and OC_STACK_KEEP_TRANSACTION to keep it.
939 static OCStackApplicationResult SRPProvisionDirectPairingCB(void *ctx, OCDoHandle UNUSED,
940 OCClientResponse *clientResponse)
942 OIC_LOG_V(INFO, TAG, "Inside SRPProvisionDirectPairingCB.");
944 VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
945 PconfData_t *pconfData = (PconfData_t*)ctx;
946 OCProvisionResultCB resultCallback = pconfData->resultCallback;
950 if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
952 registerResultForDirectPairingProvisioning(pconfData, OC_STACK_RESOURCE_CREATED);
953 ((OCProvisionResultCB)(resultCallback))(pconfData->ctx, pconfData->numOfResults,
956 OICFree(pconfData->resArr);
958 return OC_STACK_DELETE_TRANSACTION;
961 registerResultForDirectPairingProvisioning(pconfData, OC_STACK_ERROR);
962 ((OCProvisionResultCB)(resultCallback))(pconfData->ctx, pconfData->numOfResults,
965 OIC_LOG_V(ERROR, TAG, "SRPProvisionDirectPairingCB received Null clientResponse");
966 OICFree(pconfData->resArr);
968 return OC_STACK_DELETE_TRANSACTION;
971 OCStackResult SRPProvisionDirectPairing(void *ctx, const OCProvisionDev_t *selectedDeviceInfo,
972 OicSecPconf_t *pconf, OCProvisionResultCB resultCallback)
974 VERIFY_NON_NULL(TAG, selectedDeviceInfo, ERROR, OC_STACK_INVALID_PARAM);
975 VERIFY_NON_NULL(TAG, pconf, ERROR, OC_STACK_INVALID_PARAM);
976 VERIFY_NON_NULL(TAG, resultCallback, ERROR, OC_STACK_INVALID_CALLBACK);
978 // check direct-pairing capability
979 if (true != selectedDeviceInfo->doxm->dpc)
981 OIC_LOG(ERROR, TAG, "Resouce server does not have Direct-Pairing Capability ");
982 return OC_STACK_UNAUTHORIZED_REQ;
985 OicUuid_t provTooldeviceID = {.id={0}};
986 if (OC_STACK_OK != GetDoxmDeviceID(&provTooldeviceID))
988 OIC_LOG(ERROR, TAG, "Error while retrieving provisioning tool's device ID");
989 return OC_STACK_ERROR;
991 memcpy(&pconf->rowner, &provTooldeviceID, sizeof(OicUuid_t));
993 OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
996 OIC_LOG(ERROR, TAG, "Failed to memory allocation");
997 return OC_STACK_NO_MEMORY;
999 secPayload->base.type = PAYLOAD_TYPE_SECURITY;
1001 if (OC_STACK_OK != PconfToCBORPayload(pconf, &(secPayload->securityData1),
1002 &(secPayload->payloadSize)))
1004 OCPayloadDestroy((OCPayload*)secPayload);
1005 OIC_LOG(ERROR, TAG, "Failed to PconfToCborPayload");
1006 return OC_STACK_NO_MEMORY;
1008 OIC_LOG_V(INFO, TAG, "PCONF : %s", secPayload->securityData1);
1010 char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
1011 if(!PMGenerateQuery(true,
1012 selectedDeviceInfo->endpoint.addr,
1013 selectedDeviceInfo->securePort,
1014 selectedDeviceInfo->connType,
1015 query, sizeof(query), OIC_RSRC_PCONF_URI))
1017 OIC_LOG(ERROR, TAG, "SRPProvisionDirectPairing : Failed to generate query");
1018 return OC_STACK_ERROR;
1020 OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
1022 OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL};
1023 cbData.cb = &SRPProvisionDirectPairingCB;
1024 PconfData_t *pconfData = (PconfData_t *) OICCalloc(1, sizeof(PconfData_t));
1025 if (NULL == pconfData)
1027 OCPayloadDestroy((OCPayload*)secPayload);
1028 OIC_LOG(ERROR, TAG, "Unable to allocate memory");
1029 return OC_STACK_NO_MEMORY;
1031 pconfData->deviceInfo = selectedDeviceInfo;
1032 pconfData->resultCallback = resultCallback;
1033 pconfData->numOfResults=0;
1034 pconfData->ctx = ctx;
1035 // call to provision PCONF to device1.
1036 int noOfRiCalls = 1;
1037 pconfData->resArr = (OCProvisionResult_t*)OICCalloc(noOfRiCalls, sizeof(OCProvisionResult_t));
1038 if (NULL == pconfData->resArr)
1041 OCPayloadDestroy((OCPayload*)secPayload);
1042 OIC_LOG(ERROR, TAG, "Unable to allocate memory");
1043 return OC_STACK_NO_MEMORY;
1045 cbData.context = (void *)pconfData;
1047 OCMethod method = OC_REST_POST;
1048 OCDoHandle handle = NULL;
1049 OIC_LOG(DEBUG, TAG, "Sending PCONF info to resource server");
1050 OCStackResult ret = OCDoResource(&handle, method, query,
1051 &selectedDeviceInfo->endpoint, (OCPayload*)secPayload,
1052 selectedDeviceInfo->connType, OC_LOW_QOS, &cbData, NULL, 0);
1053 if (OC_STACK_OK != ret)
1055 OICFree(pconfData->resArr);
1058 VERIFY_SUCCESS(TAG, (OC_STACK_OK == ret), ERROR, OC_STACK_ERROR);
1062 static void DeleteUnlinkData_t(UnlinkData_t *unlinkData)
1066 OICFree(unlinkData->unlinkDev);
1067 OICFree(unlinkData->unlinkRes);
1068 OICFree(unlinkData);
1072 static void registerResultForUnlinkDevices(UnlinkData_t *unlinkData, OCStackResult stackresult,
1075 if (NULL != unlinkData)
1077 OIC_LOG_V(INFO, TAG, "Inside registerResultForUnlinkDevices unlinkData->numOfResults is %d\n",
1078 unlinkData->numOfResults);
1079 OIC_LOG_V(INFO, TAG, "Stack result :: %d", stackresult);
1081 OicUuid_t *pUuid = &unlinkData->unlinkRes[(unlinkData->numOfResults)].deviceId;
1083 // Set result in the result array according to the position (devNum).
1084 if (idx != IDX_DB_UPDATE_RES)
1086 memcpy(pUuid->id, unlinkData->unlinkDev[idx].doxm->deviceID.id, sizeof(pUuid->id));
1089 { // When deivce ID is 000... this means it's the result of database update.
1090 memset(pUuid->id, 0, sizeof(pUuid->id));
1092 unlinkData->unlinkRes[(unlinkData->numOfResults)].res = stackresult;
1093 ++(unlinkData->numOfResults);
1094 OIC_LOG (INFO, TAG, "Out registerResultForUnlinkDevices");
1098 static OCStackResult SendDeleteCredentialRequest(void* ctx,
1099 OCClientResponseHandler respHandler,
1100 const OCProvisionDev_t* revokedDev,
1101 const OCProvisionDev_t* destDev)
1103 OIC_LOG(DEBUG, TAG, "IN SendDeleteCredentialRequest");
1105 if (NULL == ctx || NULL == respHandler || NULL == revokedDev || NULL == destDev)
1107 return OC_STACK_INVALID_PARAM;
1110 char base64Buff[B64ENCODE_OUT_SAFESIZE(sizeof(revokedDev->doxm->deviceID.id)) + 1] = {};
1111 uint32_t base64Len = 0;
1112 if (B64_OK != b64Encode(revokedDev->doxm->deviceID.id, sizeof(revokedDev->doxm->deviceID.id),
1113 base64Buff, sizeof(base64Buff), &base64Len))
1115 OIC_LOG(ERROR, TAG, "SendDeleteCredentialRequest : Failed to base64 encoding");
1116 return OC_STACK_ERROR;
1119 char reqBuf[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
1121 //coaps://0.0.0.0:5684/oic/sec/cred?sub=(BASE64 ENCODED UUID)
1122 snRet = snprintf(reqBuf, sizeof(reqBuf), SRP_FORM_DELETE_CREDENTIAL, destDev->endpoint.addr,
1123 destDev->securePort, OIC_RSRC_CRED_URI, OIC_JSON_SUBJECT_NAME, base64Buff);
1126 OIC_LOG_V(ERROR, TAG, "SendDeleteCredentialRequest : Error (snprintf) %d\n", snRet);
1127 return OC_STACK_ERROR;
1129 else if ((size_t)snRet >= sizeof(reqBuf))
1131 OIC_LOG_V(ERROR, TAG, "SendDeleteCredentialRequest : Truncated (snprintf) %d\n", snRet);
1132 return OC_STACK_ERROR;
1135 OCCallbackData cbData;
1136 memset(&cbData, 0, sizeof(cbData));
1137 cbData.context = ctx;
1138 cbData.cb = respHandler;
1140 OIC_LOG_V(INFO, TAG, "URI: %s",reqBuf);
1142 OIC_LOG(DEBUG, TAG, "Sending remove credential request to resource server");
1144 OCStackResult ret = OCDoResource(NULL, OC_REST_DELETE, reqBuf,
1145 &destDev->endpoint, NULL,
1146 CT_ADAPTER_IP, OC_HIGH_QOS, &cbData, NULL, 0);
1147 if (OC_STACK_OK != ret)
1149 OIC_LOG_V(ERROR, TAG, "SendDeleteCredentialRequest : Error in OCDoResource %d", ret);
1151 OIC_LOG(DEBUG, TAG, "OUT SendDeleteCredentialRequest");
1157 * Callback handler of unlink second device.
1159 * @param[in] ctx ctx value passed to callback from calling function.
1160 * @param[in] handle handle to an invocation
1161 * @param[in] clientResponse Response from queries to remote servers.
1162 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction and
1163 * OC_STACK_KEEP_TRANSACTION to keep it.
1165 static OCStackApplicationResult SRPUnlinkDevice2CB(void *unlinkCtx, OCDoHandle handle,
1166 OCClientResponse *clientResponse)
1169 OIC_LOG(DEBUG, TAG, "IN SRPUnlinkDevice2CB");
1170 VERIFY_NON_NULL(TAG, unlinkCtx, ERROR, OC_STACK_DELETE_TRANSACTION);
1171 UnlinkData_t* unlinkData = (UnlinkData_t*)unlinkCtx;
1175 OIC_LOG(DEBUG, TAG, "Valid client response for device 2");
1176 registerResultForUnlinkDevices(unlinkData, clientResponse->result, IDX_SECOND_DEVICE_RES);
1178 if (OC_STACK_RESOURCE_DELETED == clientResponse->result)
1180 OIC_LOG(DEBUG, TAG, "Credential of device2 revoked");
1184 OIC_LOG(ERROR, TAG, "Unable to delete credential information from device 2");
1185 unlinkData->resultCallback(unlinkData->ctx,
1186 unlinkData->numOfResults, unlinkData->unlinkRes, true);
1192 registerResultForUnlinkDevices(unlinkData, OC_STACK_INVALID_REQUEST_HANDLE,
1193 IDX_SECOND_DEVICE_RES);
1194 unlinkData->resultCallback(unlinkData->ctx,
1195 unlinkData->numOfResults, unlinkData->unlinkRes, true);
1196 OIC_LOG(ERROR, TAG, "SRPUnlinkDevice2CB received Null clientResponse");
1200 //Update provisioning DB when succes case.
1201 if (OC_STACK_OK != PDMUnlinkDevices(&unlinkData->unlinkDev[0].doxm->deviceID,
1202 &unlinkData->unlinkDev[1].doxm->deviceID))
1204 OIC_LOG(FATAL, TAG, "All requests are successfully done but update provisioning DB FAILED.");
1205 registerResultForUnlinkDevices(unlinkData, OC_STACK_INCONSISTENT_DB, IDX_DB_UPDATE_RES);
1206 unlinkData->resultCallback(unlinkData->ctx,
1207 unlinkData->numOfResults, unlinkData->unlinkRes, true);
1210 unlinkData->resultCallback(unlinkData->ctx, unlinkData->numOfResults, unlinkData->unlinkRes,
1214 DeleteUnlinkData_t(unlinkData);
1215 OIC_LOG(DEBUG, TAG, "OUT SRPUnlinkDevice2CB");
1216 return OC_STACK_DELETE_TRANSACTION;
1221 * Callback handler of unlink first device.
1223 * @param[in] ctx ctx value passed to callback from calling function.
1224 * @param[in] handle handle to an invocation
1225 * @param[in] clientResponse Response from queries to remote servers.
1226 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction and
1227 * OC_STACK_KEEP_TRANSACTION to keep it.
1229 static OCStackApplicationResult SRPUnlinkDevice1CB(void *unlinkCtx, OCDoHandle handle,
1230 OCClientResponse *clientResponse)
1232 OIC_LOG_V(INFO, TAG, "Inside SRPUnlinkDevice1CB ");
1233 VERIFY_NON_NULL(TAG, unlinkCtx, ERROR, OC_STACK_DELETE_TRANSACTION);
1234 UnlinkData_t* unlinkData = (UnlinkData_t*)unlinkCtx;
1239 OIC_LOG(DEBUG, TAG, "Valid client response for device 1");
1240 registerResultForUnlinkDevices(unlinkData, clientResponse->result, IDX_FIRST_DEVICE_RES);
1242 if (OC_STACK_RESOURCE_DELETED == clientResponse->result)
1244 OIC_LOG(DEBUG, TAG, "Credential of device 1 is revoked");
1246 // Second revocation request to second device.
1247 OCStackResult res = SendDeleteCredentialRequest((void*)unlinkData, &SRPUnlinkDevice2CB,
1248 &unlinkData->unlinkDev[0],
1249 &unlinkData->unlinkDev[1] /*Dest*/);
1250 OIC_LOG_V(DEBUG, TAG, "Credential revocation request device 2, result :: %d",res);
1251 if (OC_STACK_OK != res)
1253 OIC_LOG(ERROR, TAG, "Error while sending revocation request for device 2");
1254 registerResultForUnlinkDevices(unlinkData, OC_STACK_INVALID_REQUEST_HANDLE,
1255 IDX_SECOND_DEVICE_RES);
1256 unlinkData->resultCallback(unlinkData->ctx,
1257 unlinkData->numOfResults, unlinkData->unlinkRes, true);
1262 OIC_LOG(DEBUG, TAG, "Request for credential revocation successfully sent");
1263 return OC_STACK_DELETE_TRANSACTION;
1268 OIC_LOG(ERROR, TAG, "Unable to delete credential information from device 1");
1270 unlinkData->resultCallback(unlinkData->ctx, unlinkData->numOfResults,
1271 unlinkData->unlinkRes, true);
1277 OIC_LOG(DEBUG, TAG, "Invalid response from server");
1278 registerResultForUnlinkDevices(unlinkData, OC_STACK_INVALID_REQUEST_HANDLE,
1279 IDX_FIRST_DEVICE_RES );
1280 unlinkData->resultCallback(unlinkData->ctx,
1281 unlinkData->numOfResults, unlinkData->unlinkRes,
1283 OIC_LOG(ERROR, TAG, "SRPUnlinkDevice1CB received Null clientResponse");
1287 OIC_LOG_V(INFO, TAG, "Out SRPUnlinkDevice1CB");
1288 DeleteUnlinkData_t(unlinkData);
1289 return OC_STACK_DELETE_TRANSACTION;
1293 * Function to unlink devices.
1294 * This function will remove the credential & relationship between the two devices.
1296 * @param[in] ctx Application context would be returned in result callback
1297 * @param[in] pTargetDev1 first device information to be unlinked.
1298 * @param[in] pTargetDev2 second device information to be unlinked.
1299 * @param[in] resultCallback callback provided by API user, callback will be called when
1300 * device unlink is finished.
1301 * @return OC_STACK_OK in case of success and other value otherwise.
1303 OCStackResult SRPUnlinkDevices(void* ctx,
1304 const OCProvisionDev_t* pTargetDev1,
1305 const OCProvisionDev_t* pTargetDev2,
1306 OCProvisionResultCB resultCallback)
1308 OIC_LOG(INFO, TAG, "IN SRPUnlinkDevices");
1310 if (!pTargetDev1 || !pTargetDev2 || !pTargetDev1->doxm || !pTargetDev2->doxm)
1312 OIC_LOG(INFO, TAG, "SRPUnlinkDevices : NULL parameters");
1313 return OC_STACK_INVALID_PARAM;
1315 if (!resultCallback)
1317 OIC_LOG(INFO, TAG, "SRPUnlinkDevices : NULL Callback");
1318 return OC_STACK_INVALID_CALLBACK;
1320 if (0 == memcmp(&pTargetDev1->doxm->deviceID, &pTargetDev2->doxm->deviceID, sizeof(OicUuid_t)))
1322 OIC_LOG(INFO, TAG, "SRPUnlinkDevices : Same device ID");
1323 return OC_STACK_INVALID_PARAM;
1326 OIC_LOG(INFO, TAG, "Unlinking following devices: ");
1327 PMPrintOCProvisionDev(pTargetDev1);
1328 PMPrintOCProvisionDev(pTargetDev2);
1330 // Mark the link status stale
1331 OCStackResult res = PDMSetLinkStale(&pTargetDev1->doxm->deviceID, &pTargetDev2->doxm->deviceID);
1332 if (OC_STACK_OK != res)
1334 OIC_LOG(FATAL, TAG, "unable to update DB. Try again.");
1338 UnlinkData_t* unlinkData = (UnlinkData_t*)OICCalloc(1, sizeof(UnlinkData_t));
1339 VERIFY_NON_NULL(TAG, unlinkData, ERROR, OC_STACK_NO_MEMORY);
1341 //Initialize unlink data
1342 unlinkData->ctx = ctx;
1343 unlinkData->unlinkDev = (OCProvisionDev_t*)OICCalloc(2, sizeof(OCProvisionDev_t));
1344 if (NULL == unlinkData->unlinkDev)
1346 OIC_LOG(ERROR, TAG, "Memory allocation failed");
1347 res = OC_STACK_NO_MEMORY;
1351 unlinkData->unlinkRes = (OCProvisionResult_t*)OICCalloc(3, sizeof(OCProvisionResult_t));
1352 if (NULL == unlinkData->unlinkRes)
1354 OIC_LOG(ERROR, TAG, "Memory allocation failed");
1355 res = OC_STACK_NO_MEMORY;
1359 memcpy(&unlinkData->unlinkDev[0], pTargetDev1, sizeof(OCProvisionDev_t));
1360 memcpy(&unlinkData->unlinkDev[1], pTargetDev2, sizeof(OCProvisionDev_t));
1362 unlinkData->numOfResults = 0;
1363 unlinkData->resultCallback = resultCallback;
1365 res = SendDeleteCredentialRequest((void*)unlinkData, &SRPUnlinkDevice1CB,
1366 &unlinkData->unlinkDev[1], &unlinkData->unlinkDev[0]);
1367 if (OC_STACK_OK != res)
1369 OIC_LOG(ERROR, TAG, "SRPUnlinkDevices : SendDeleteCredentialRequest failed");
1376 OIC_LOG(INFO, TAG, "OUT SRPUnlinkDevices");
1377 DeleteUnlinkData_t(unlinkData);
1381 static void DeleteRemoveData_t(RemoveData_t* pRemoveData)
1385 OICFree(pRemoveData->revokeTargetDev);
1386 OCDeleteDiscoveredDevices(pRemoveData->linkedDevList);
1387 OICFree(pRemoveData->removeRes);
1388 OICFree(pRemoveData);
1392 static void registerResultForRemoveDevice(RemoveData_t *removeData, OicUuid_t *pLinkedDevId,
1393 OCStackResult stackresult, bool hasError)
1395 OIC_LOG_V(INFO, TAG, "Inside registerResultForRemoveDevice removeData->numOfResults is %zu\n",
1396 removeData->numOfResults + 1);
1399 memcpy(removeData->removeRes[(removeData->numOfResults)].deviceId.id,
1400 &pLinkedDevId->id, sizeof(pLinkedDevId->id));
1404 memset(removeData->removeRes[(removeData->numOfResults)].deviceId.id,
1405 0, sizeof(pLinkedDevId->id) );
1407 removeData->removeRes[(removeData->numOfResults)].res = stackresult;
1408 removeData->hasError = hasError;
1409 ++(removeData->numOfResults);
1411 // If we get suffcient result from linked devices, we have to call user callback and do free
1412 if (removeData->sizeOfResArray == removeData->numOfResults)
1414 if(!removeData->hasError)
1416 // Remove device info from prvisioning database
1417 if (OC_STACK_OK != PDMDeleteDevice(&removeData->revokeTargetDev->doxm->deviceID))
1419 OIC_LOG(ERROR, TAG, "ResultForRemoveDevice : Failed to remove device in PDM.");
1420 removeData->hasError = true;
1423 removeData->resultCallback(removeData->ctx, removeData->numOfResults, removeData->removeRes,
1424 removeData->hasError);
1425 DeleteRemoveData_t(removeData);
1430 * Callback handler of unlink first device.
1432 * @param[in] ctx ctx value passed to callback from calling function.
1433 * @param[in] handle handle to an invocation
1434 * @param[in] clientResponse Response from queries to remote servers.
1435 * @return OC_STACK_DELETE_TRANSACTION to delete the transaction
1436 * and OC_STACK_KEEP_TRANSACTION to keep it.
1438 static OCStackApplicationResult SRPRemoveDeviceCB(void *delDevCtx, OCDoHandle handle,
1439 OCClientResponse *clientResponse)
1441 //Update the delete credential into delete device context
1442 //Save the deleted status in delDevCtx
1444 OIC_LOG_V(INFO, TAG, "Inside SRPRemoveDeviceCB.");
1445 VERIFY_NON_NULL(TAG, delDevCtx, ERROR, OC_STACK_DELETE_TRANSACTION);
1446 OCStackResult res = OC_STACK_ERROR;
1448 RemoveData_t* removeData = (RemoveData_t*)delDevCtx;
1453 OicUuid_t revDevUuid = {.id={0}};
1454 if(UUID_LENGTH == clientResponse->identity.id_length)
1456 memcpy(revDevUuid.id, clientResponse->identity.id, sizeof(revDevUuid.id));
1457 if (OC_STACK_RESOURCE_DELETED == clientResponse->result)
1459 res = PDMUnlinkDevices(&removeData->revokeTargetDev->doxm->deviceID, &revDevUuid);
1460 if (OC_STACK_OK != res)
1462 OIC_LOG(ERROR, TAG, "PDMSetLinkStale() FAIL: PDB is an obsolete one.");
1463 registerResultForRemoveDevice(removeData, &revDevUuid,
1464 OC_STACK_INCONSISTENT_DB, true);
1466 return OC_STACK_DELETE_TRANSACTION;
1469 registerResultForRemoveDevice(removeData, &revDevUuid,
1470 OC_STACK_RESOURCE_DELETED, false);
1474 registerResultForRemoveDevice(removeData, &revDevUuid,
1475 clientResponse->result, true);
1476 OIC_LOG(ERROR, TAG, "Unexpected result from DELETE credential request!");
1481 OIC_LOG_V(WARNING, TAG, "Incorrect length of device UUID was sent from %s:%d",
1482 clientResponse->devAddr.addr, clientResponse->devAddr.port);
1484 if (OC_STACK_RESOURCE_DELETED == clientResponse->result)
1487 * Since server's credential was deleted,
1488 * register result as OC_STACK_INCONSISTENT_DB with NULL UUID.
1491 OIC_LOG_V(ERROR, TAG, "But server's credential was deleted.");
1492 registerResultForRemoveDevice(removeData, NULL, OC_STACK_INCONSISTENT_DB, true);
1496 registerResultForRemoveDevice(removeData, NULL, clientResponse->result, true);
1502 registerResultForRemoveDevice(removeData, NULL, OC_STACK_ERROR, true);
1503 OIC_LOG(ERROR, TAG, "SRPRemoveDevices received Null clientResponse");
1508 OIC_LOG(WARNING, TAG, "SRPRemoveDevices received null context");
1511 return OC_STACK_DELETE_TRANSACTION;
1514 static OCStackResult GetListofDevToReqDeleteCred(const OCProvisionDev_t* pRevokeTargetDev,
1515 OCProvisionDev_t* pOwnedDevList,
1516 OCUuidList_t* pLinkedUuidList,
1517 OCProvisionDev_t** ppLinkedDevList,
1518 size_t *numOfLinkedDev)
1520 // pOwnedDevList could be NULL. It means no alived and owned device now.
1521 if (pRevokeTargetDev == NULL || pLinkedUuidList == NULL ||\
1522 ppLinkedDevList == NULL || numOfLinkedDev == NULL)
1524 return OC_STACK_INVALID_PARAM;
1528 OCUuidList_t *curUuid = NULL, *tmpUuid = NULL;
1529 LL_FOREACH_SAFE(pLinkedUuidList, curUuid, tmpUuid)
1531 // Mark the link status stale.
1532 OCStackResult res = PDMSetLinkStale(&curUuid->dev, &pRevokeTargetDev->doxm->deviceID);
1533 if (OC_STACK_OK != res)
1535 OIC_LOG(FATAL, TAG, "PDMSetLinkStale() FAIL: PDB is an obsolete one.");
1536 return OC_STACK_INCONSISTENT_DB;
1541 // If this linked device is alive (power-on), add the deivce to the list.
1542 OCProvisionDev_t *curDev = NULL, *tmpDev = NULL;
1543 LL_FOREACH_SAFE(pOwnedDevList, curDev, tmpDev)
1545 if (memcmp(curDev->doxm->deviceID.id, curUuid->dev.id, sizeof(curUuid->dev.id)) == 0)
1547 OCProvisionDev_t* targetDev = PMCloneOCProvisionDev(curDev);
1548 if (NULL == targetDev)
1550 OIC_LOG(ERROR, TAG, "SRPRemoveDevice : Cloning OCProvisionDev_t Failed.");
1551 return OC_STACK_NO_MEMORY;
1554 LL_PREPEND(*ppLinkedDevList, targetDev);
1561 *numOfLinkedDev = cnt;
1566 * Function to device revocation
1567 * This function will remove credential of target device from all devices in subnet.
1569 * @param[in] ctx Application context would be returned in result callback
1570 * @param[in] waitTimeForOwnedDeviceDiscovery Maximum wait time for owned device discovery.(seconds)
1571 * @param[in] pTargetDev Device information to be revoked.
1572 * @param[in] resultCallback callback provided by API user, callback will be called when
1573 * credential revocation is finished.
1574 * @return OC_STACK_OK in case of success and other value otherwise.
1575 * If OC_STACK_OK is returned, the caller of this API should wait for callback.
1576 * OC_STACK_CONTINUE means operation is success but no request is need to be initiated.
1578 OCStackResult SRPRemoveDevice(void* ctx, unsigned short waitTimeForOwnedDeviceDiscovery,
1579 const OCProvisionDev_t* pTargetDev, OCProvisionResultCB resultCallback)
1581 OIC_LOG(INFO, TAG, "IN SRPRemoveDevice");
1583 if (!pTargetDev || 0 == waitTimeForOwnedDeviceDiscovery)
1585 OIC_LOG(INFO, TAG, "SRPRemoveDevice : NULL parameters");
1586 return OC_STACK_INVALID_PARAM;
1588 if (!resultCallback)
1590 OIC_LOG(INFO, TAG, "SRPRemoveDevice : NULL Callback");
1591 return OC_STACK_INVALID_CALLBACK;
1594 // Declare variables in here to handle error cases with goto statement.
1595 OCProvisionDev_t* pOwnedDevList = NULL;
1596 OCProvisionDev_t* pLinkedDevList = NULL;
1597 RemoveData_t* removeData = NULL;
1599 //1. Find all devices that has a credential of the revoked device
1600 OCUuidList_t* pLinkedUuidList = NULL;
1601 size_t numOfDevices = 0;
1602 OCStackResult res = OC_STACK_ERROR;
1603 res = PDMGetLinkedDevices(&pTargetDev->doxm->deviceID, &pLinkedUuidList, &numOfDevices);
1604 if (OC_STACK_OK != res)
1606 OIC_LOG(ERROR, TAG, "SRPRemoveDevice : Failed to get linked devices information");
1609 // if there is no related device, we can skip further process.
1610 if (0 == numOfDevices)
1612 OIC_LOG(DEBUG, TAG, "SRPRemoveDevice : No linked device found.");
1613 res = OC_STACK_CONTINUE;
1617 //2. Find owned device from the network
1618 res = PMDeviceDiscovery(waitTimeForOwnedDeviceDiscovery, true, &pOwnedDevList);
1619 if (OC_STACK_OK != res)
1621 OIC_LOG(ERROR, TAG, "SRPRemoveDevice : Failed to PMDeviceDiscovery");
1625 //3. Make a list of devices to send DELETE credential request
1626 // by comparing owned devices from provisioning database with mutlicast discovery result.
1627 size_t numOfLinkedDev = 0;
1628 res = GetListofDevToReqDeleteCred(pTargetDev, pOwnedDevList, pLinkedUuidList,
1629 &pLinkedDevList, &numOfLinkedDev);
1630 if (OC_STACK_OK != res)
1632 OIC_LOG(ERROR, TAG, "SRPRemoveDevice : GetListofDevToReqDeleteCred() failed");
1635 if (0 == numOfLinkedDev) // This case means, there is linked device but it's not alive now.
1636 { // So we don't have to send request message.
1637 OIC_LOG(DEBUG, TAG, "SRPRemoveDevice : No alived & linked device found.");
1638 res = OC_STACK_CONTINUE;
1642 // 4. Prepare RemoveData Context data.
1643 removeData = (RemoveData_t*)OICCalloc(1, sizeof(RemoveData_t));
1646 OIC_LOG(ERROR, TAG, "SRPRemoveDevices : Failed to memory allocation");
1647 res = OC_STACK_NO_MEMORY;
1651 removeData->revokeTargetDev = PMCloneOCProvisionDev(pTargetDev);
1652 if (!removeData->revokeTargetDev)
1654 OIC_LOG(ERROR, TAG, "SRPRemoveDevices : PMCloneOCProvisionDev Failed");
1655 res = OC_STACK_NO_MEMORY;
1659 removeData->removeRes =
1660 (OCProvisionResult_t*)OICCalloc(numOfLinkedDev, sizeof(OCProvisionResult_t));
1661 if (!removeData->removeRes)
1663 OIC_LOG(ERROR, TAG, "SRPRemoveDevices : Failed to memory allocation");
1664 res = OC_STACK_NO_MEMORY;
1668 removeData->ctx = ctx;
1669 removeData->linkedDevList = pLinkedDevList;
1670 removeData->resultCallback = resultCallback;
1671 removeData->numOfResults = 0;
1672 removeData->sizeOfResArray = numOfLinkedDev;
1673 removeData->hasError = false;
1675 // 5. Send DELETE credential request to linked devices.
1676 OCProvisionDev_t *curDev = NULL, *tmpDev = NULL;
1677 OCStackResult totalRes = OC_STACK_ERROR; /* variable for checking request is sent or not */
1678 LL_FOREACH_SAFE(pLinkedDevList, curDev, tmpDev)
1680 res = SendDeleteCredentialRequest((void*)removeData, &SRPRemoveDeviceCB,
1681 removeData->revokeTargetDev, curDev);
1682 if (OC_STACK_OK != res)
1684 OIC_LOG_V(ERROR, TAG, "SRPRemoveDevice : Fail to send the DELETE credential request to\
1685 %s:%u", curDev->endpoint.addr, curDev->endpoint.port);
1689 totalRes = OC_STACK_OK; // This means at least one request is successfully sent.
1693 PDMDestoryOicUuidLinkList(pLinkedUuidList); //TODO: Modify API name to have unified convention.
1694 PMDeleteDeviceList(pOwnedDevList);
1695 OIC_LOG(INFO, TAG, "OUT SRPRemoveDevice");
1697 return totalRes; // Caller of this API should wait callback if totalRes == OC_STACK_OK.
1700 PDMDestoryOicUuidLinkList(pLinkedUuidList);
1701 PMDeleteDeviceList(pOwnedDevList);
1702 PMDeleteDeviceList(pLinkedDevList);
1705 OICFree(removeData->revokeTargetDev);
1706 OICFree(removeData->removeRes);
1707 OICFree(removeData);
1709 OIC_LOG(INFO, TAG, "OUT ERROR case SRPRemoveDevice");