resource/csdk/security/provisioning/src/secureresourceprovider.c

   1 /* *****************************************************************
   2  *
   3  * Copyright 2015 Samsung Electronics All Rights Reserved.
   4  *
   5  *
   6  *
   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
  10  *
  11  *     http://www.apache.org/licenses/LICENSE-2.0
  12  *
  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.
  18  *
  19  * *****************************************************************/
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <stdint.h>
  23 #ifdef HAVE_UNISTD_H
  24 #include <unistd.h>
  25 #endif
  26
  27 #include "ocprovisioningmanager.h"
  28 #include "secureresourceprovider.h"
  29 #include "logger.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"
  39 #include "cJSON.h"
  40 #include "pmtypes.h"
  41 #include "pmutility.h"
  42 #include "provisioningdatabasemanager.h"
  43 #include "base64.h"
  44 #include "utlist.h"
  45 #include "ocpayload.h"
  46
  47 #ifdef __WITH_X509__
  48 #include "crlresource.h"
  49 #endif // WITH_X509__
  50
  51 #define TAG "SRPAPI"
  52
  53 /**
  54  * Macro to verify argument is not equal to NULL.
  55  * eg: VERIFY_NON_NULL(TAG, ptrData, ERROR,OC_STACK_ERROR);
  56  */
  57 #define VERIFY_NON_NULL(tag, arg, logLevel, retValue) { if (NULL == (arg)) \
  58             { OIC_LOG((logLevel), tag, #arg " is NULL"); return retValue; } }
  59
  60 /**
  61  * Macro to verify success of operation.
  62  * eg: VERIFY_SUCCESS(TAG, OC_STACK_OK == foo(), ERROR, OC_STACK_ERROR);
  63  */
  64 #define VERIFY_SUCCESS(tag, op, logLevel, retValue) { if (!(op)) \
  65             {OIC_LOG((logLevel), tag, #op " failed!!"); return retValue;} }
  66
  67 /**
  68  * Structure to carry credential data to callback.
  69  */
  70 typedef struct CredentialData CredentialData_t;
  71 struct CredentialData
  72 {
  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.**/
  81 };
  82
  83 /**
  84  * Structure to carry ACL provision API data to callback.
  85  */
  86 typedef struct ACLData ACLData_t;
  87 struct ACLData
  88 {
  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.**/
  94 };
  95
  96 /**
  97  * Structure to carry PCONF provision API data to callback.
  98  */
  99 typedef struct PconfData PconfData_t;
 100 struct PconfData
 101 {
 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.**/
 107 };
 108
 109 // Enum type index for unlink callback.
 110 typedef enum {
 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.
 114 } IdxUnlinkRes_t;
 115
 116 // Structure to carry unlink APIs data to callback.
 117 typedef struct UnlinkData UnlinkData_t;
 118 struct UnlinkData {
 119     void *ctx;
 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.**/
 124 };
 125
 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";
 128
 129 // Structure to carry remove APIs data to callback.
 130 typedef struct RemoveData RemoveData_t;
 131 struct RemoveData {
 132     void *ctx;
 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;
 139     bool hasError;
 140 };
 141
 142 /**
 143  * Function prototype
 144  */
 145 static OCStackResult provisionCredentials(const OicSecCred_t *cred,
 146         const OCProvisionDev_t *deviceInfo, CredentialData_t *credData,
 147         OCClientResponseHandler responseHandler);
 148
 149
 150 /**
 151  * Internal function to update result in result array.
 152  */
 153 static void registerResultForCredProvisioning(CredentialData_t *credData,
 154                                               OCStackResult stackresult, int cause)
 155 {
 156
 157    OIC_LOG_V(INFO,TAG,"value of credData->numOfResults is %d",credData->numOfResults);
 158    if(1 == cause)
 159    {
 160        memcpy(credData->resArr[(credData->numOfResults)].deviceId.id,
 161               credData->deviceInfo1->doxm->deviceID.id,UUID_LENGTH);
 162    }
 163    else
 164    {
 165        memcpy(credData->resArr[(credData->numOfResults)].deviceId.id,
 166               credData->deviceInfo2->doxm->deviceID.id,UUID_LENGTH);
 167    }
 168    credData->resArr[(credData->numOfResults)].res = stackresult;
 169    ++(credData->numOfResults);
 170 }
 171
 172 /**
 173  * Callback handler for handling callback of provisioning device 2.
 174  *
 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.
 180  */
 181 static OCStackApplicationResult provisionCredentialCB2(void *ctx, OCDoHandle UNUSED,
 182                                                        OCClientResponse *clientResponse)
 183 {
 184     VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
 185     CredentialData_t *credData = (CredentialData_t *) ctx;
 186     (void)UNUSED;
 187
 188     OCProvisionResultCB resultCallback = credData->resultCallback;
 189     OIC_LOG(INFO, TAG, "provisionCredentialCB2 called");
 190     if (clientResponse)
 191     {
 192         if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
 193         {
 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)
 198             {
 199                 OIC_LOG(ERROR, TAG, "Error occured on PDMLinkDevices");
 200                 return OC_STACK_DELETE_TRANSACTION;
 201             }
 202             OIC_LOG(INFO, TAG, "Link created successfully");
 203
 204             ((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
 205                                                     credData->resArr,
 206                                                     false);
 207              OICFree(credData->resArr);
 208              OICFree(credData);
 209              return OC_STACK_DELETE_TRANSACTION;
 210         }
 211
 212     }
 213     OIC_LOG(INFO, TAG, "provisionCredentialCB2 received Null clientResponse");
 214     registerResultForCredProvisioning(credData, OC_STACK_ERROR, 2);
 215     ((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
 216                                             credData->resArr,
 217                                             true);
 218     OICFree(credData->resArr);
 219     OICFree(credData);
 220     return OC_STACK_DELETE_TRANSACTION;
 221 }
 222
 223 /**
 224  * Callback handler for handling callback of provisioning device 1.
 225  *
 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.
 231  */
 232 static OCStackApplicationResult provisionCredentialCB1(void *ctx, OCDoHandle UNUSED,
 233                                                        OCClientResponse *clientResponse)
 234 {
 235     VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
 236     (void)UNUSED;
 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;
 242     if (clientResponse)
 243     {
 244         if (OC_STACK_RESOURCE_CREATED == clientResponse->result)
 245         {
 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)
 252             {
 253                 registerResultForCredProvisioning(credData, res,2);
 254                 ((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
 255                                                         credData->resArr,
 256                                                         true);
 257                 OICFree(credData->resArr);
 258                 OICFree(credData);
 259                 credData = NULL;
 260             }
 261         }
 262         else
 263         {
 264             registerResultForCredProvisioning(credData, OC_STACK_ERROR,1);
 265             ((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
 266                                                     credData->resArr,
 267                                                     true);
 268             OICFree(credData->resArr);
 269             OICFree(credData);
 270             credData = NULL;
 271         }
 272     }
 273     else
 274     {
 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,
 278                                                      credData->resArr,
 279                                                      true);
 280         DeleteCredList(credInfo);
 281         OICFree(credData->resArr);
 282         OICFree(credData);
 283         credData = NULL;
 284     }
 285     return OC_STACK_DELETE_TRANSACTION;
 286 }
 287
 288
 289
 290 /**
 291  * Internal function for handling credential generation and sending credential to resource server.
 292  *
 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.
 297  */
 298 static OCStackResult provisionCredentials(const OicSecCred_t *cred,
 299         const OCProvisionDev_t *deviceInfo, CredentialData_t *credData,
 300         OCClientResponseHandler responseHandler)
 301 {
 302     OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
 303     if (!secPayload)
 304     {
 305         OIC_LOG(ERROR, TAG, "Failed to memory allocation");
 306         return OC_STACK_NO_MEMORY;
 307     }
 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))
 311     {
 312         OCPayloadDestroy((OCPayload *)secPayload);
 313         OIC_LOG(ERROR, TAG, "Failed to CredToCBORPayload");
 314         return OC_STACK_NO_MEMORY;
 315     }
 316
 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))
 325     {
 326         OIC_LOG(ERROR, TAG, "DeviceDiscoveryHandler : Failed to generate query");
 327         return OC_STACK_ERROR;
 328     }
 329     OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
 330
 331     OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL};
 332     cbData.cb = responseHandler;
 333     cbData.context = (void *) credData;
 334     cbData.cd = NULL;
 335
 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)
 342     {
 343         OIC_LOG(ERROR, TAG, "OCStack resource error");
 344         return ret;
 345     }
 346     return OC_STACK_OK;
 347 }
 348
 349 #ifdef __WITH_X509__
 350 /**
 351  * Structure to carry certificate data to callback.
 352  */
 353 typedef struct CertificateData CertData_t;
 354 struct CertificateData
 355 {
 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.**/
 362 };
 363
 364 /**
 365  * Structure to carry CRL provision API data to callback.
 366  */
 367 typedef struct CRLData CRLData_t;
 368 struct CRLData
 369 {
 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.**/
 375 };
 376
 377 /**
 378  * Internal function to update result in result array.
 379  */
 380 static void registerResultForCertProvisioning(CertData_t *certData,
 381                                               OCStackResult stackresult)
 382 {
 383
 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);
 389 }
 390
 391 /**
 392  * Internal Function to store results in result array during ACL provisioning.
 393  */
 394 static void registerResultForCRLProvisioning(CRLData_t *crlData,
 395                                              OCStackResult stackresult)
 396 {
 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);
 403 }
 404
 405
 406 /**
 407  * Callback handler of SRPProvisionCRL.
 408  *
 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.
 414  */
 415 static OCStackApplicationResult SRPProvisionCRLCB(void *ctx, OCDoHandle UNUSED,
 416                                                   OCClientResponse *clientResponse)
 417 {
 418     OIC_LOG_V(INFO, TAG, "Inside SRPProvisionCRLCB.");
 419     (void)UNUSED;
 420     VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
 421     CRLData_t *crlData = (CRLData_t*)ctx;
 422     OCProvisionResultCB resultCallback = crlData->resultCallback;
 423
 424     if (clientResponse)
 425     {
 426         if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
 427         {
 428             registerResultForCRLProvisioning(crlData, OC_STACK_RESOURCE_CREATED);
 429             ((OCProvisionResultCB)(resultCallback))(crlData->ctx, crlData->numOfResults,
 430                                                     crlData->resArr,
 431                                                     false);
 432              OICFree(crlData->resArr);
 433              OICFree(crlData);
 434              return OC_STACK_DELETE_TRANSACTION;
 435         }
 436     }
 437     registerResultForCRLProvisioning(crlData, OC_STACK_ERROR);
 438     ((OCProvisionResultCB)(resultCallback))(crlData->ctx, crlData->numOfResults,
 439                                             crlData->resArr,
 440                                             true);
 441     OIC_LOG_V(ERROR, TAG, "SRPProvisionCRLCB received Null clientResponse");
 442     OICFree(crlData->resArr);
 443     OICFree(crlData);
 444     return OC_STACK_DELETE_TRANSACTION;
 445 }
 446
 447 OCStackResult SRPProvisionCRL(void *ctx, const OCProvisionDev_t *selectedDeviceInfo,
 448         OicSecCrl_t *crl, OCProvisionResultCB resultCallback)
 449 {
 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);
 453
 454     OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
 455     if (!secPayload)
 456     {
 457         OIC_LOG(ERROR, TAG, "Failed to memory allocation");
 458         return OC_STACK_NO_MEMORY;
 459     }
 460
 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))
 464     {
 465         OICFree(secPayload);
 466         OIC_LOG(ERROR, TAG, "Failed to BinToCrlJSON");
 467         return OC_STACK_NO_MEMORY;
 468     }
 469     OIC_LOG(DEBUG, TAG, "Created payload for CRL:");
 470     OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize);
 471
 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))
 478     {
 479         OIC_LOG(ERROR, TAG, "DeviceDiscoveryHandler : Failed to generate query");
 480         OCPayloadDestroy((OCPayload *)secPayload);
 481         return OC_STACK_ERROR;
 482     }
 483     OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
 484
 485     OCCallbackData cbData =  {.context=NULL, .cb=NULL, .cd=NULL};
 486     cbData.cb = &SRPProvisionCRLCB;
 487     CRLData_t *crlData = (CRLData_t *) OICCalloc(1, sizeof(CRLData_t));
 488     if (crlData == NULL)
 489     {
 490         OCPayloadDestroy((OCPayload *)secPayload);
 491         OIC_LOG(ERROR, TAG, "Unable to allocate memory");
 492         return OC_STACK_NO_MEMORY;
 493     }
 494
 495     crlData->deviceInfo = selectedDeviceInfo;
 496     crlData->resultCallback = resultCallback;
 497     crlData->numOfResults=0;
 498     crlData->ctx = ctx;
 499
 500     crlData->resArr = (OCProvisionResult_t*)OICCalloc(1, sizeof(OCProvisionResult_t));
 501     if (crlData->resArr == NULL)
 502     {
 503         OCPayloadDestroy((OCPayload *)secPayload);
 504         OIC_LOG(ERROR, TAG, "Unable to allocate memory");
 505         return OC_STACK_NO_MEMORY;
 506     }
 507
 508     cbData.context = (void *)crlData;
 509     cbData.cd = NULL;
 510     OCMethod method = OC_REST_POST;
 511     OCDoHandle handle = NULL;
 512     OIC_LOG(DEBUG, TAG, "Sending CRL info to resource server");
 513
 514     OCStackResult ret = OCDoResource(&handle, method, query,
 515             &selectedDeviceInfo->endpoint, (OCPayload*)secPayload,
 516             selectedDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
 517
 518     if (ret != OC_STACK_OK)
 519     {
 520         OICFree(crlData->resArr);
 521         OICFree(crlData);
 522     }
 523
 524     return ret;
 525 }
 526
 527 /**
 528  * Internal function for handling credential generation and sending cretificate credential.
 529  *
 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.
 534  */
 535 static OCStackResult provisionCertCred(const OicSecCred_t *cred,
 536         const OCProvisionDev_t *deviceInfo, CertData_t *certData,
 537         OCClientResponseHandler responseHandler)
 538 {
 539     OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
 540     if(!secPayload)
 541     {
 542         OIC_LOG(ERROR, TAG, "Failed to memory allocation");
 543         return OC_STACK_NO_MEMORY;
 544     }
 545     secPayload->base.type = PAYLOAD_TYPE_SECURITY;
 546     OCStackResult res = CredToCBORPayload(cred, &secPayload->securityData,
 547         &secPayload->payloadSize);
 548
 549     if ((OC_STACK_OK != res) || (NULL == secPayload->securityData))
 550     {
 551         OICFree(secPayload);
 552         OIC_LOG(ERROR, TAG, "Failed to CredToCBORPayload");
 553         return OC_STACK_NO_MEMORY;
 554     }
 555
 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))
 564     {
 565         OIC_LOG(ERROR, TAG, "DeviceDiscoveryHandler : Failed to generate query");
 566         OCPayloadDestroy((OCPayload *)secPayload);
 567         return OC_STACK_ERROR;
 568     }
 569     OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
 570
 571     OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL};
 572     cbData.cb = responseHandler;
 573     cbData.context = (void *) certData;
 574     cbData.cd = NULL;
 575
 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)
 582     {
 583         OIC_LOG(ERROR, TAG, "OCStack resource error");
 584     }
 585
 586     return ret;
 587 }
 588
 589 /**
 590  * Callback handler for handling callback of certificate provisioning device.
 591  *
 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.
 597  */
 598 static OCStackApplicationResult provisionCertCB(void *ctx, OCDoHandle UNUSED,
 599                                                        OCClientResponse *clientResponse)
 600 {
 601     VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
 602     CertData_t *certData = (CertData_t *) ctx;
 603     (void)UNUSED;
 604
 605     OCProvisionResultCB resultCallback = certData->resultCallback;
 606     OIC_LOG(INFO, TAG, "provisionCertCred called");
 607     if (clientResponse)
 608     {
 609         if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
 610         {
 611             registerResultForCertProvisioning(certData, OC_STACK_RESOURCE_CREATED);
 612             ((OCProvisionResultCB)(resultCallback))(certData->ctx, certData->numOfResults,
 613                                                     certData->resArr,
 614                                                     false);
 615              OICFree(certData->resArr);
 616              OICFree(certData);
 617              return OC_STACK_DELETE_TRANSACTION;
 618         }
 619
 620     }
 621     OIC_LOG(INFO, TAG, "provisionCertCredCB received Null clientResponse");
 622     registerResultForCertProvisioning(certData, OC_STACK_ERROR);
 623     ((OCProvisionResultCB)(resultCallback))(certData->ctx, certData->numOfResults,
 624                                             certData->resArr,
 625                                             true);
 626     OICFree(certData->resArr);
 627     OICFree(certData);
 628     return OC_STACK_DELETE_TRANSACTION;
 629 }
 630 #endif // __WITH_X509__
 631
 632 OCStackResult SRPProvisionCredentials(void *ctx, OicSecCredType_t type, size_t keySize,
 633                                       const OCProvisionDev_t *pDev1,
 634                                       const OCProvisionDev_t *pDev2,
 635                                       OCProvisionResultCB resultCallback)
 636 {
 637     VERIFY_NON_NULL(TAG, pDev1, ERROR,  OC_STACK_INVALID_PARAM);
 638     if (SYMMETRIC_PAIR_WISE_KEY == type)
 639     {
 640         VERIFY_NON_NULL(TAG, pDev2, ERROR,  OC_STACK_INVALID_PARAM);
 641     }
 642     if (!resultCallback)
 643     {
 644         OIC_LOG(INFO, TAG, "SRPUnlinkDevices : NULL Callback");
 645         return OC_STACK_INVALID_CALLBACK;
 646     }
 647     if (SYMMETRIC_PAIR_WISE_KEY == type &&
 648         0 == memcmp(&pDev1->doxm->deviceID, &pDev2->doxm->deviceID, sizeof(OicUuid_t)))
 649     {
 650         OIC_LOG(INFO, TAG, "SRPUnlinkDevices : Same device ID");
 651         return OC_STACK_INVALID_PARAM;
 652     }
 653
 654     if (SYMMETRIC_PAIR_WISE_KEY == type &&
 655        !(OWNER_PSK_LENGTH_128 == keySize || OWNER_PSK_LENGTH_256 == keySize))
 656     {
 657         OIC_LOG(INFO, TAG, "Invalid key size");
 658         return OC_STACK_INVALID_PARAM;
 659     }
 660
 661     OIC_LOG(INFO, TAG, "In SRPProvisionCredentials");
 662
 663     if (SYMMETRIC_PAIR_WISE_KEY == type)
 664     {
 665         bool linkExisits = true;
 666         OCStackResult res = PDMIsLinkExists(&pDev1->doxm->deviceID, &pDev2->doxm->deviceID, &linkExisits);
 667
 668         if (res != OC_STACK_OK)
 669         {
 670             OIC_LOG(ERROR, TAG, "Internal error occured");
 671             return res;
 672         }
 673         if (linkExisits)
 674         {
 675             OIC_LOG(ERROR, TAG, "Link already exists");
 676             return OC_STACK_INVALID_PARAM;
 677         }
 678     }
 679
 680     OicUuid_t provTooldeviceID =   {{0,}};
 681     if (OC_STACK_OK != GetDoxmDeviceID(&provTooldeviceID))
 682     {
 683         OIC_LOG(ERROR, TAG, "Error while retrieving provisioning tool's device ID");
 684         return OC_STACK_ERROR;
 685     }
 686     OIC_LOG(INFO, TAG, "retrieved deviceid");
 687     switch (type)
 688     {
 689         case SYMMETRIC_PAIR_WISE_KEY:
 690         {
 691             const OCProvisionDev_t *firstDevice = pDev1;
 692             const OCProvisionDev_t *secondDevice = pDev2;
 693
 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)
 704             {
 705                 OICFree(firstCred);
 706                 OICFree(secondCred);
 707                 OIC_LOG(ERROR, TAG, "Memory allocation problem");
 708                 return OC_STACK_NO_MEMORY;
 709             }
 710             credData->deviceInfo1 = firstDevice;
 711             credData->deviceInfo2 = secondDevice;
 712             credData->credInfo = secondCred;
 713             credData->ctx = ctx;
 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.
 719             int noOfRiCalls = 2;
 720             credData->resArr =
 721                 (OCProvisionResult_t*)OICCalloc(noOfRiCalls, sizeof(OCProvisionResult_t));
 722             if (NULL == credData->resArr)
 723             {
 724                 OICFree(firstCred);
 725                 OICFree(secondCred);
 726                 OICFree(credData);
 727                 OIC_LOG(ERROR, TAG, "Memory allocation problem");
 728                 return OC_STACK_NO_MEMORY;
 729             }
 730             res = provisionCredentials(firstCred, firstDevice, credData, &provisionCredentialCB1);
 731             if (OC_STACK_OK != res)
 732             {
 733                 DeleteCredList(firstCred);
 734                 DeleteCredList(secondCred);
 735                 OICFree(credData->resArr);
 736                 OICFree(credData);
 737             }
 738             OIC_LOG_V(INFO, TAG, "provisionCredentials returned: %d",res);
 739             VERIFY_SUCCESS(TAG, (res==OC_STACK_OK), ERROR, OC_STACK_ERROR);
 740             return res;
 741         }
 742 #ifdef __WITH_X509__
 743         case SIGNED_ASYMMETRIC_KEY:
 744         {
 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)
 753             {
 754                 OICFree(cred);
 755                 OIC_LOG(ERROR, TAG, "Memory allocation problem");
 756                 return OC_STACK_NO_MEMORY;
 757             }
 758
 759             certData->deviceInfo = firstDevice;
 760             certData->ctx = ctx;
 761             certData->credInfo = cred;
 762             certData->numOfResults = 0;
 763             certData->resultCallback = resultCallback;
 764
 765             certData->resArr = (OCProvisionResult_t*)OICCalloc(1, sizeof(OCProvisionResult_t));
 766             if (NULL == certData->resArr)
 767             {
 768                 DeleteCredList(cred);
 769                 OICFree(certData);
 770                 OIC_LOG(ERROR, TAG, "Memory allocation problem");
 771                 return OC_STACK_NO_MEMORY;
 772             }
 773
 774             res = provisionCertCred(cred, firstDevice, certData, &provisionCertCB);
 775             if (OC_STACK_OK != res)
 776             {
 777                 OICFree(certData->resArr);
 778                 OICFree(certData);
 779             }
 780             DeleteCredList(cred);
 781             OIC_LOG_V(INFO, TAG, "provisionCertCredentials returned: %d",res);
 782
 783             return res;
 784         }
 785 #endif
 786         default:
 787         {
 788             OIC_LOG(ERROR, TAG, "Invalid option.");
 789             return OC_STACK_INVALID_PARAM;
 790         }
 791     }
 792     return OC_STACK_ERROR;
 793 }
 794
 795 /**
 796  * Internal Function to store results in result array during ACL provisioning.
 797  */
 798 static void registerResultForACLProvisioning(ACLData_t *aclData,
 799                                              OCStackResult stackresult)
 800 {
 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);
 807 }
 808
 809 /**
 810  * Callback handler of SRPProvisionACL.
 811  *
 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.
 817  */
 818 static OCStackApplicationResult SRPProvisionACLCB(void *ctx, OCDoHandle UNUSED,
 819                                                   OCClientResponse *clientResponse)
 820 {
 821     OIC_LOG_V(INFO, TAG, "Inside SRPProvisionACLCB.");
 822     (void)UNUSED;
 823     VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
 824     ACLData_t *aclData = (ACLData_t*)ctx;
 825     OCProvisionResultCB resultCallback = aclData->resultCallback;
 826
 827     if (clientResponse)
 828     {
 829         if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
 830         {
 831             registerResultForACLProvisioning(aclData, OC_STACK_RESOURCE_CREATED);
 832             ((OCProvisionResultCB)(resultCallback))(aclData->ctx, aclData->numOfResults,
 833                                                     aclData->resArr,
 834                                                     false);
 835              OICFree(aclData->resArr);
 836              OICFree(aclData);
 837              return OC_STACK_DELETE_TRANSACTION;
 838         }
 839     }
 840     registerResultForACLProvisioning(aclData, OC_STACK_ERROR);
 841     ((OCProvisionResultCB)(resultCallback))(aclData->ctx, aclData->numOfResults,
 842                                             aclData->resArr,
 843                                             true);
 844     OIC_LOG_V(ERROR, TAG, "SRPProvisionACLCB received Null clientResponse");
 845     OICFree(aclData->resArr);
 846     OICFree(aclData);
 847     return OC_STACK_DELETE_TRANSACTION;
 848 }
 849
 850 OCStackResult SRPProvisionACL(void *ctx, const OCProvisionDev_t *selectedDeviceInfo,
 851         OicSecAcl_t *acl, OCProvisionResultCB resultCallback)
 852 {
 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);
 856
 857     OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
 858     if(!secPayload)
 859     {
 860         OIC_LOG(ERROR, TAG, "Failed to memory allocation");
 861         return OC_STACK_NO_MEMORY;
 862     }
 863     secPayload->base.type = PAYLOAD_TYPE_SECURITY;
 864     if(OC_STACK_OK != AclToCBORPayload(acl, &secPayload->securityData, &secPayload->payloadSize))
 865     {
 866         OCPayloadDestroy((OCPayload *)secPayload);
 867         OIC_LOG(ERROR, TAG, "Failed to AclToCBORPayload");
 868         return OC_STACK_NO_MEMORY;
 869     }
 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))
 876     {
 877         OIC_LOG(ERROR, TAG, "DeviceDiscoveryHandler : Failed to generate query");
 878         return OC_STACK_ERROR;
 879     }
 880     OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
 881
 882     OCCallbackData cbData =  {.context=NULL, .cb=NULL, .cd=NULL};
 883     cbData.cb = &SRPProvisionACLCB;
 884     ACLData_t *aclData = (ACLData_t *) OICCalloc(1, sizeof(ACLData_t));
 885     if (aclData == NULL)
 886     {
 887         OCPayloadDestroy((OCPayload *)secPayload);
 888         OIC_LOG(ERROR, TAG, "Unable to allocate memory");
 889         return OC_STACK_NO_MEMORY;
 890     }
 891     aclData->deviceInfo = selectedDeviceInfo;
 892     aclData->resultCallback = resultCallback;
 893     aclData->numOfResults=0;
 894     aclData->ctx = ctx;
 895     // call to provision ACL to device1.
 896     int noOfRiCalls = 1;
 897     aclData->resArr = (OCProvisionResult_t*)OICCalloc(noOfRiCalls, sizeof(OCProvisionResult_t));
 898     if (aclData->resArr == NULL)
 899     {
 900         OICFree(aclData);
 901         OCPayloadDestroy((OCPayload *)secPayload);
 902         OIC_LOG(ERROR, TAG, "Unable to allocate memory");
 903         return OC_STACK_NO_MEMORY;
 904     }
 905     cbData.context = (void *)aclData;
 906     cbData.cd = NULL;
 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)
 914     {
 915         OICFree(aclData->resArr);
 916         OICFree(aclData);
 917     }
 918     VERIFY_SUCCESS(TAG, (OC_STACK_OK == ret), ERROR, OC_STACK_ERROR);
 919     return OC_STACK_OK;
 920 }
 921
 922 /**
 923  * Internal Function to store results in result array during Direct-Pairing provisioning.
 924  */
 925 static void registerResultForDirectPairingProvisioning(PconfData_t *pconfData,
 926                                              OCStackResult stackresult)
 927 {
 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);
 934 }
 935
 936 /**
 937  * Callback handler of SRPProvisionDirectPairing.
 938  *
 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.
 944  */
 945 static OCStackApplicationResult SRPProvisionDirectPairingCB(void *ctx, OCDoHandle UNUSED,
 946                                                   OCClientResponse *clientResponse)
 947 {
 948     OIC_LOG_V(INFO, TAG, "Inside SRPProvisionDirectPairingCB.");
 949     (void)UNUSED;
 950     VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
 951     PconfData_t *pconfData = (PconfData_t*)ctx;
 952     OCProvisionResultCB resultCallback = pconfData->resultCallback;
 953
 954     if (clientResponse)
 955     {
 956         if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
 957         {
 958             registerResultForDirectPairingProvisioning(pconfData, OC_STACK_OK);
 959             ((OCProvisionResultCB)(resultCallback))(pconfData->ctx, pconfData->numOfResults,
 960                                                     pconfData->resArr,
 961                                                     false);
 962              OICFree(pconfData->resArr);
 963              OICFree(pconfData);
 964              return OC_STACK_DELETE_TRANSACTION;
 965         }
 966     }
 967     registerResultForDirectPairingProvisioning(pconfData, OC_STACK_ERROR);
 968     ((OCProvisionResultCB)(resultCallback))(pconfData->ctx, pconfData->numOfResults,
 969                                             pconfData->resArr,
 970                                             true);
 971     OIC_LOG_V(ERROR, TAG, "SRPProvisionDirectPairingCB received Null clientResponse");
 972     OICFree(pconfData->resArr);
 973     OICFree(pconfData);
 974     return OC_STACK_DELETE_TRANSACTION;
 975 }
 976
 977 OCStackResult SRPProvisionDirectPairing(void *ctx, const OCProvisionDev_t *selectedDeviceInfo,
 978         OicSecPconf_t *pconf, OCProvisionResultCB resultCallback)
 979 {
 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);
 983
 984     // check direct-pairing capability
 985     if (true != selectedDeviceInfo->doxm->dpc)
 986     {
 987         OIC_LOG(ERROR, TAG, "Resouce server does not have Direct-Pairing Capability ");
 988         return OC_STACK_UNAUTHORIZED_REQ;
 989     }
 990
 991     OicUuid_t provTooldeviceID =   {.id={0}};
 992     if (OC_STACK_OK != GetDoxmDeviceID(&provTooldeviceID))
 993     {
 994         OIC_LOG(ERROR, TAG, "Error while retrieving provisioning tool's device ID");
 995         return OC_STACK_ERROR;
 996     }
 997     memcpy(&pconf->rownerID, &provTooldeviceID, sizeof(OicUuid_t));
 998
 999     OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
1000     if(!secPayload)
1001     {
1002         OIC_LOG(ERROR, TAG, "Failed to memory allocation");
1003         return OC_STACK_NO_MEMORY;
1004     }
1005     secPayload->base.type = PAYLOAD_TYPE_SECURITY;
1006
1007     if (OC_STACK_OK != PconfToCBORPayload(pconf, &(secPayload->securityData),
1008                 &(secPayload->payloadSize)))
1009     {
1010         OCPayloadDestroy((OCPayload*)secPayload);
1011         OIC_LOG(ERROR, TAG, "Failed to PconfToCborPayload");
1012         return OC_STACK_NO_MEMORY;
1013     }
1014     OIC_LOG(DEBUG, TAG, "Created payload for pconf set");
1015     OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize);
1016
1017
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))
1024     {
1025         OIC_LOG(ERROR, TAG, "SRPProvisionDirectPairing : Failed to generate query");
1026         return OC_STACK_ERROR;
1027     }
1028     OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
1029
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)
1034     {
1035         OCPayloadDestroy((OCPayload*)secPayload);
1036         OIC_LOG(ERROR, TAG, "Unable to allocate memory");
1037         return OC_STACK_NO_MEMORY;
1038     }
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)
1047     {
1048         OICFree(pconfData);
1049         OCPayloadDestroy((OCPayload*)secPayload);
1050         OIC_LOG(ERROR, TAG, "Unable to allocate memory");
1051         return OC_STACK_NO_MEMORY;
1052     }
1053     cbData.context = (void *)pconfData;
1054     cbData.cd = NULL;
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_HIGH_QOS, &cbData, NULL, 0);
1061     if (OC_STACK_OK != ret)
1062     {
1063         OICFree(pconfData->resArr);
1064         OICFree(pconfData);
1065     }
1066     VERIFY_SUCCESS(TAG, (OC_STACK_OK == ret), ERROR, OC_STACK_ERROR);
1067     return OC_STACK_OK;
1068 }
1069
1070 static void DeleteUnlinkData_t(UnlinkData_t *unlinkData)
1071 {
1072     if (unlinkData)
1073     {
1074         OICFree(unlinkData->unlinkDev);
1075         OICFree(unlinkData->unlinkRes);
1076         OICFree(unlinkData);
1077     }
1078 }
1079
1080 static void registerResultForUnlinkDevices(UnlinkData_t *unlinkData, OCStackResult stackresult,
1081                                            IdxUnlinkRes_t idx)
1082 {
1083     if (NULL != unlinkData)
1084     {
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);
1088
1089         OicUuid_t *pUuid = &unlinkData->unlinkRes[(unlinkData->numOfResults)].deviceId;
1090
1091         // Set result in the result array according to the position (devNum).
1092         if (idx != IDX_DB_UPDATE_RES)
1093         {
1094             memcpy(pUuid->id, unlinkData->unlinkDev[idx].doxm->deviceID.id, sizeof(pUuid->id));
1095         }
1096         else
1097         {   // When deivce ID is 000... this means it's the result of database update.
1098             memset(pUuid->id, 0, sizeof(pUuid->id));
1099         }
1100         unlinkData->unlinkRes[(unlinkData->numOfResults)].res = stackresult;
1101         ++(unlinkData->numOfResults);
1102         OIC_LOG (INFO, TAG, "Out registerResultForUnlinkDevices");
1103     }
1104 }
1105
1106 static OCStackResult SendDeleteCredentialRequest(void* ctx,
1107                                                  OCClientResponseHandler respHandler,
1108                                                  const OCProvisionDev_t* revokedDev,
1109                                                  const OCProvisionDev_t* destDev)
1110 {
1111     OIC_LOG(DEBUG, TAG, "IN SendDeleteCredentialRequest");
1112
1113     if (NULL == ctx || NULL == respHandler || NULL == revokedDev || NULL == destDev)
1114     {
1115         return OC_STACK_INVALID_PARAM;
1116     }
1117
1118     char *subID = NULL;
1119     OCStackResult ret = ConvertUuidToStr(&revokedDev->doxm->deviceID, &subID);
1120     if(OC_STACK_OK != ret)
1121     {
1122         OIC_LOG(ERROR, TAG, "SendDeleteCredentialRequest : Failed to canonical UUID encoding");
1123         return OC_STACK_ERROR;
1124     }
1125
1126     char reqBuf[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
1127     int snRet = 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);
1131     OICFree(subID);
1132     if (snRet < 0)
1133     {
1134         OIC_LOG_V(ERROR, TAG, "SendDeleteCredentialRequest : Error (snprintf) %d\n", snRet);
1135         return OC_STACK_ERROR;
1136     }
1137     else if ((size_t)snRet >= sizeof(reqBuf))
1138     {
1139         OIC_LOG_V(ERROR, TAG, "SendDeleteCredentialRequest : Truncated (snprintf) %d\n", snRet);
1140         return OC_STACK_ERROR;
1141     }
1142
1143     OCCallbackData cbData;
1144     memset(&cbData, 0, sizeof(cbData));
1145     cbData.context = ctx;
1146     cbData.cb = respHandler;
1147     cbData.cd = NULL;
1148     OIC_LOG_V(INFO, TAG, "URI: %s",reqBuf);
1149
1150     OIC_LOG(DEBUG, TAG, "Sending remove credential request to resource server");
1151
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)
1156     {
1157         OIC_LOG_V(ERROR, TAG, "SendDeleteCredentialRequest : Error in OCDoResource %d", ret);
1158     }
1159     OIC_LOG(DEBUG, TAG, "OUT SendDeleteCredentialRequest");
1160
1161     return ret;
1162 }
1163
1164 /**
1165  * Callback handler of unlink second device.
1166  *
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.
1172  */
1173 static OCStackApplicationResult SRPUnlinkDevice2CB(void *unlinkCtx, OCDoHandle handle,
1174         OCClientResponse *clientResponse)
1175 {
1176     (void) handle;
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;
1180
1181     if (clientResponse)
1182     {
1183         OIC_LOG(DEBUG, TAG, "Valid client response for device 2");
1184         registerResultForUnlinkDevices(unlinkData, clientResponse->result, IDX_SECOND_DEVICE_RES);
1185
1186         if (OC_STACK_RESOURCE_DELETED == clientResponse->result)
1187         {
1188             OIC_LOG(DEBUG, TAG, "Credential of device2 revoked");
1189         }
1190         else
1191         {
1192             OIC_LOG(ERROR, TAG, "Unable to delete credential information from device 2");
1193             unlinkData->resultCallback(unlinkData->ctx,
1194                                        unlinkData->numOfResults, unlinkData->unlinkRes, true);
1195             goto error;
1196         }
1197     }
1198     else
1199     {
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");
1205         goto error;
1206     }
1207
1208     //Update provisioning DB when succes case.
1209     if (OC_STACK_OK != PDMUnlinkDevices(&unlinkData->unlinkDev[0].doxm->deviceID,
1210                                        &unlinkData->unlinkDev[1].doxm->deviceID))
1211     {
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);
1216         goto error;
1217     }
1218     unlinkData->resultCallback(unlinkData->ctx, unlinkData->numOfResults, unlinkData->unlinkRes,
1219                                false);
1220
1221 error:
1222     DeleteUnlinkData_t(unlinkData);
1223     OIC_LOG(DEBUG, TAG, "OUT SRPUnlinkDevice2CB");
1224     return OC_STACK_DELETE_TRANSACTION;
1225
1226 }
1227
1228 /**
1229  * Callback handler of unlink first device.
1230  *
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.
1236  */
1237 static OCStackApplicationResult SRPUnlinkDevice1CB(void *unlinkCtx, OCDoHandle handle,
1238         OCClientResponse *clientResponse)
1239 {
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;
1243     (void) handle;
1244
1245     if (clientResponse)
1246     {
1247         OIC_LOG(DEBUG, TAG, "Valid client response for device 1");
1248         registerResultForUnlinkDevices(unlinkData, clientResponse->result, IDX_FIRST_DEVICE_RES);
1249
1250         if (OC_STACK_RESOURCE_DELETED == clientResponse->result)
1251         {
1252             OIC_LOG(DEBUG, TAG, "Credential of device 1 is revoked");
1253
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)
1260             {
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);
1266                  goto error;
1267             }
1268             else
1269             {
1270                 OIC_LOG(DEBUG, TAG, "Request for credential revocation successfully sent");
1271                 return OC_STACK_DELETE_TRANSACTION;
1272             }
1273         }
1274         else
1275         {
1276             OIC_LOG(ERROR, TAG, "Unable to delete credential information from device 1");
1277
1278             unlinkData->resultCallback(unlinkData->ctx, unlinkData->numOfResults,
1279                                             unlinkData->unlinkRes, true);
1280             goto error;
1281         }
1282     }
1283     else
1284     {
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,
1290                                    true);
1291         OIC_LOG(ERROR, TAG, "SRPUnlinkDevice1CB received Null clientResponse");
1292     }
1293
1294 error:
1295     OIC_LOG_V(INFO, TAG, "Out SRPUnlinkDevice1CB");
1296     DeleteUnlinkData_t(unlinkData);
1297     return OC_STACK_DELETE_TRANSACTION;
1298 }
1299
1300 /*
1301 * Function to unlink devices.
1302 * This function will remove the credential & relationship between the two devices.
1303 *
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.
1310 */
1311 OCStackResult SRPUnlinkDevices(void* ctx,
1312                                const OCProvisionDev_t* pTargetDev1,
1313                                const OCProvisionDev_t* pTargetDev2,
1314                                OCProvisionResultCB resultCallback)
1315 {
1316     OIC_LOG(INFO, TAG, "IN SRPUnlinkDevices");
1317
1318     if (!pTargetDev1 || !pTargetDev2 || !pTargetDev1->doxm || !pTargetDev2->doxm)
1319     {
1320         OIC_LOG(INFO, TAG, "SRPUnlinkDevices : NULL parameters");
1321         return OC_STACK_INVALID_PARAM;
1322     }
1323     if (!resultCallback)
1324     {
1325         OIC_LOG(INFO, TAG, "SRPUnlinkDevices : NULL Callback");
1326         return OC_STACK_INVALID_CALLBACK;
1327     }
1328     if (0 == memcmp(&pTargetDev1->doxm->deviceID, &pTargetDev2->doxm->deviceID, sizeof(OicUuid_t)))
1329     {
1330         OIC_LOG(INFO, TAG, "SRPUnlinkDevices : Same device ID");
1331         return OC_STACK_INVALID_PARAM;
1332     }
1333
1334     OIC_LOG(INFO, TAG, "Unlinking following devices: ");
1335     PMPrintOCProvisionDev(pTargetDev1);
1336     PMPrintOCProvisionDev(pTargetDev2);
1337
1338     // Mark the link status stale
1339     OCStackResult res = PDMSetLinkStale(&pTargetDev1->doxm->deviceID, &pTargetDev2->doxm->deviceID);
1340     if (OC_STACK_OK != res)
1341     {
1342         OIC_LOG(FATAL, TAG, "unable to update DB. Try again.");
1343         return res;
1344     }
1345
1346     UnlinkData_t* unlinkData = (UnlinkData_t*)OICCalloc(1, sizeof(UnlinkData_t));
1347     VERIFY_NON_NULL(TAG, unlinkData, ERROR, OC_STACK_NO_MEMORY);
1348
1349     //Initialize unlink data
1350     unlinkData->ctx = ctx;
1351     unlinkData->unlinkDev = (OCProvisionDev_t*)OICCalloc(2, sizeof(OCProvisionDev_t));
1352     if (NULL == unlinkData->unlinkDev)
1353     {
1354         OIC_LOG(ERROR, TAG, "Memory allocation failed");
1355         res = OC_STACK_NO_MEMORY;
1356         goto error;
1357     }
1358
1359     unlinkData->unlinkRes = (OCProvisionResult_t*)OICCalloc(3, sizeof(OCProvisionResult_t));
1360     if (NULL == unlinkData->unlinkRes)
1361     {
1362         OIC_LOG(ERROR, TAG, "Memory allocation failed");
1363         res = OC_STACK_NO_MEMORY;
1364         goto error;
1365     }
1366
1367     memcpy(&unlinkData->unlinkDev[0], pTargetDev1, sizeof(OCProvisionDev_t));
1368     memcpy(&unlinkData->unlinkDev[1], pTargetDev2, sizeof(OCProvisionDev_t));
1369
1370     unlinkData->numOfResults = 0;
1371     unlinkData->resultCallback = resultCallback;
1372
1373     res = SendDeleteCredentialRequest((void*)unlinkData, &SRPUnlinkDevice1CB,
1374                                        &unlinkData->unlinkDev[1], &unlinkData->unlinkDev[0]);
1375     if (OC_STACK_OK != res)
1376     {
1377         OIC_LOG(ERROR, TAG, "SRPUnlinkDevices : SendDeleteCredentialRequest failed");
1378         goto error;
1379     }
1380
1381     return res;
1382
1383 error:
1384     OIC_LOG(INFO, TAG, "OUT SRPUnlinkDevices");
1385     DeleteUnlinkData_t(unlinkData);
1386     return res;
1387 }
1388
1389 static void DeleteRemoveData_t(RemoveData_t* pRemoveData)
1390 {
1391     if (pRemoveData)
1392     {
1393         OICFree(pRemoveData->revokeTargetDev);
1394         OCDeleteDiscoveredDevices(pRemoveData->linkedDevList);
1395         OICFree(pRemoveData->removeRes);
1396         OICFree(pRemoveData);
1397     }
1398 }
1399
1400 static void registerResultForRemoveDevice(RemoveData_t *removeData, OicUuid_t *pLinkedDevId,
1401                                           OCStackResult stackresult, bool hasError)
1402 {
1403     OIC_LOG_V(INFO, TAG, "Inside registerResultForRemoveDevice removeData->numOfResults is %zu\n",
1404                          removeData->numOfResults + 1);
1405     if (pLinkedDevId)
1406     {
1407         memcpy(removeData->removeRes[(removeData->numOfResults)].deviceId.id,
1408                &pLinkedDevId->id, sizeof(pLinkedDevId->id));
1409     }
1410     else
1411     {
1412         memset(removeData->removeRes[(removeData->numOfResults)].deviceId.id,
1413                0, sizeof(pLinkedDevId->id) );
1414     }
1415     removeData->removeRes[(removeData->numOfResults)].res = stackresult;
1416     removeData->hasError = hasError;
1417     ++(removeData->numOfResults);
1418
1419     // If we get suffcient result from linked devices, we have to call user callback and do free
1420     if (removeData->sizeOfResArray == removeData->numOfResults)
1421     {
1422         if(!removeData->hasError)
1423         {
1424             // Remove device info from prvisioning database
1425             if (OC_STACK_OK != PDMDeleteDevice(&removeData->revokeTargetDev->doxm->deviceID))
1426             {
1427                 OIC_LOG(ERROR, TAG, "ResultForRemoveDevice : Failed to remove device in PDM.");
1428                 removeData->hasError = true;
1429             }
1430         }
1431         removeData->resultCallback(removeData->ctx, removeData->numOfResults, removeData->removeRes,
1432                                    removeData->hasError);
1433         DeleteRemoveData_t(removeData);
1434     }
1435  }
1436
1437 /**
1438  * Callback handler of unlink first device.
1439  *
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.
1445  */
1446 static OCStackApplicationResult SRPRemoveDeviceCB(void *delDevCtx, OCDoHandle handle,
1447         OCClientResponse *clientResponse)
1448 {
1449     //Update the delete credential into delete device context
1450     //Save the deleted status in delDevCtx
1451     (void)handle;
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;
1455
1456     RemoveData_t* removeData = (RemoveData_t*)delDevCtx;
1457
1458     if (clientResponse)
1459     {
1460         OicUuid_t revDevUuid = {.id={0}};
1461         if(UUID_LENGTH == clientResponse->identity.id_length)
1462         {
1463             memcpy(revDevUuid.id, clientResponse->identity.id, sizeof(revDevUuid.id));
1464             if (OC_STACK_RESOURCE_DELETED == clientResponse->result)
1465             {
1466                 res = PDMUnlinkDevices(&removeData->revokeTargetDev->doxm->deviceID, &revDevUuid);
1467                 if (OC_STACK_OK != res)
1468                 {
1469                     OIC_LOG(ERROR, TAG, "PDMSetLinkStale() FAIL: PDB is an obsolete one.");
1470                            registerResultForRemoveDevice(removeData, &revDevUuid,
1471                            OC_STACK_INCONSISTENT_DB, true);
1472
1473                     return OC_STACK_DELETE_TRANSACTION;
1474                 }
1475
1476                 registerResultForRemoveDevice(removeData, &revDevUuid,
1477                                               OC_STACK_RESOURCE_DELETED, false);
1478             }
1479             else
1480             {
1481                 registerResultForRemoveDevice(removeData, &revDevUuid,
1482                                               clientResponse->result, true);
1483                 OIC_LOG(ERROR, TAG, "Unexpected result from DELETE credential request!");
1484             }
1485         }
1486         else
1487         {
1488             OIC_LOG_V(WARNING, TAG, "Incorrect length of device UUID was sent from %s:%d",
1489                      clientResponse->devAddr.addr, clientResponse->devAddr.port);
1490
1491             if (OC_STACK_RESOURCE_DELETED == clientResponse->result)
1492             {
1493                 /**
1494                   * Since server's credential was deleted,
1495                   * register result as OC_STACK_INCONSISTENT_DB with NULL UUID.
1496                   */
1497                 OIC_LOG_V(ERROR, TAG, "But server's credential was deleted.");
1498                 registerResultForRemoveDevice(removeData, NULL, OC_STACK_INCONSISTENT_DB, true);
1499             }
1500             else
1501             {
1502                 registerResultForRemoveDevice(removeData, NULL, clientResponse->result, true);
1503             }
1504         }
1505     }
1506     else
1507     {
1508         registerResultForRemoveDevice(removeData, NULL, OC_STACK_ERROR, true);
1509         OIC_LOG(ERROR, TAG, "SRPRemoveDevices received Null clientResponse");
1510     }
1511
1512
1513     return OC_STACK_DELETE_TRANSACTION;
1514 }
1515
1516 static OCStackResult GetListofDevToReqDeleteCred(const OCProvisionDev_t* pRevokeTargetDev,
1517                                                  OCProvisionDev_t* pOwnedDevList,
1518                                                  OCUuidList_t* pLinkedUuidList,
1519                                                  OCProvisionDev_t** ppLinkedDevList,
1520                                                  size_t *numOfLinkedDev)
1521 {
1522     // pOwnedDevList could be NULL. It means no alived and owned device now.
1523     if (pRevokeTargetDev == NULL || pLinkedUuidList == NULL ||\
1524         ppLinkedDevList == NULL || numOfLinkedDev == NULL)
1525     {
1526         return OC_STACK_INVALID_PARAM;
1527     }
1528
1529     size_t cnt = 0;
1530     OCUuidList_t *curUuid = NULL, *tmpUuid = NULL;
1531     LL_FOREACH_SAFE(pLinkedUuidList, curUuid, tmpUuid)
1532     {
1533         // Mark the link status stale.
1534         OCStackResult res = PDMSetLinkStale(&curUuid->dev, &pRevokeTargetDev->doxm->deviceID);
1535         if (OC_STACK_OK != res)
1536         {
1537             OIC_LOG(FATAL, TAG, "PDMSetLinkStale() FAIL: PDB is an obsolete one.");
1538             return OC_STACK_INCONSISTENT_DB;
1539         }
1540
1541         if (pOwnedDevList)
1542         {
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)
1546             {
1547                 if (memcmp(curDev->doxm->deviceID.id, curUuid->dev.id, sizeof(curUuid->dev.id)) == 0)
1548                 {
1549                     OCProvisionDev_t* targetDev = PMCloneOCProvisionDev(curDev);
1550                     if (NULL == targetDev)
1551                     {
1552                         OIC_LOG(ERROR, TAG, "SRPRemoveDevice : Cloning OCProvisionDev_t Failed.");
1553                         return OC_STACK_NO_MEMORY;
1554                     }
1555
1556                     LL_PREPEND(*ppLinkedDevList, targetDev);
1557                     cnt++;
1558                     break;
1559                 }
1560             }
1561         }
1562     }
1563     *numOfLinkedDev = cnt;
1564     return OC_STACK_OK;
1565 }
1566
1567 /*
1568 * Function to device revocation
1569 * This function will remove credential of target device from all devices in subnet.
1570 *
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.
1579 */
1580 OCStackResult SRPRemoveDevice(void* ctx, unsigned short waitTimeForOwnedDeviceDiscovery,
1581                              const OCProvisionDev_t* pTargetDev, OCProvisionResultCB resultCallback)
1582 {
1583     OIC_LOG(INFO, TAG, "IN SRPRemoveDevice");
1584
1585     if (!pTargetDev  || 0 == waitTimeForOwnedDeviceDiscovery)
1586     {
1587         OIC_LOG(INFO, TAG, "SRPRemoveDevice : NULL parameters");
1588         return OC_STACK_INVALID_PARAM;
1589     }
1590     if (!resultCallback)
1591     {
1592         OIC_LOG(INFO, TAG, "SRPRemoveDevice : NULL Callback");
1593         return OC_STACK_INVALID_CALLBACK;
1594     }
1595
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;
1600
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)
1607     {
1608         OIC_LOG(ERROR, TAG, "SRPRemoveDevice : Failed to get linked devices information");
1609         return res;
1610     }
1611     // if there is no related device, we can skip further process.
1612     if (0 == numOfDevices)
1613     {
1614         OIC_LOG(DEBUG, TAG, "SRPRemoveDevice : No linked device found.");
1615         res = OC_STACK_CONTINUE;
1616         goto error;
1617     }
1618
1619     //2. Find owned device from the network
1620     res = PMDeviceDiscovery(waitTimeForOwnedDeviceDiscovery, true, &pOwnedDevList);
1621     if (OC_STACK_OK != res)
1622     {
1623         OIC_LOG(ERROR, TAG, "SRPRemoveDevice : Failed to PMDeviceDiscovery");
1624         goto error;
1625     }
1626
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)
1633     {
1634         OIC_LOG(ERROR, TAG, "SRPRemoveDevice : GetListofDevToReqDeleteCred() failed");
1635         goto error;
1636     }
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;
1641         goto error;
1642     }
1643
1644     // 4. Prepare RemoveData Context data.
1645     removeData = (RemoveData_t*)OICCalloc(1, sizeof(RemoveData_t));
1646     if (!removeData)
1647     {
1648         OIC_LOG(ERROR, TAG, "SRPRemoveDevices : Failed to memory allocation");
1649         res = OC_STACK_NO_MEMORY;
1650         goto error;
1651     }
1652
1653     removeData->revokeTargetDev = PMCloneOCProvisionDev(pTargetDev);
1654     if (!removeData->revokeTargetDev)
1655     {
1656         OIC_LOG(ERROR, TAG, "SRPRemoveDevices : PMCloneOCProvisionDev Failed");
1657         res = OC_STACK_NO_MEMORY;
1658         goto error;
1659     }
1660
1661     removeData->removeRes =
1662         (OCProvisionResult_t*)OICCalloc(numOfLinkedDev, sizeof(OCProvisionResult_t));
1663     if (!removeData->removeRes)
1664     {
1665         OIC_LOG(ERROR, TAG, "SRPRemoveDevices : Failed to memory allocation");
1666         res = OC_STACK_NO_MEMORY;
1667         goto error;
1668     }
1669
1670     removeData->ctx = ctx;
1671     removeData->linkedDevList = pLinkedDevList;
1672     removeData->resultCallback = resultCallback;
1673     removeData->numOfResults = 0;
1674     removeData->sizeOfResArray = numOfLinkedDev;
1675     removeData->hasError = false;
1676
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)
1681     {
1682         res = SendDeleteCredentialRequest((void*)removeData, &SRPRemoveDeviceCB,
1683                                            removeData->revokeTargetDev, curDev);
1684         if (OC_STACK_OK != res)
1685         {
1686             OIC_LOG_V(ERROR, TAG, "SRPRemoveDevice : Fail to send the DELETE credential request to\
1687                      %s:%u", curDev->endpoint.addr, curDev->endpoint.port);
1688         }
1689         else
1690         {
1691             totalRes = OC_STACK_OK; // This means at least one request is successfully sent.
1692         }
1693     }
1694
1695     PDMDestoryOicUuidLinkList(pLinkedUuidList); //TODO: Modify API name to have unified convention.
1696     PMDeleteDeviceList(pOwnedDevList);
1697     OIC_LOG(INFO, TAG, "OUT SRPRemoveDevice");
1698
1699     return totalRes; // Caller of this API should wait callback if totalRes == OC_STACK_OK.
1700
1701 error:
1702     PDMDestoryOicUuidLinkList(pLinkedUuidList);
1703     PMDeleteDeviceList(pOwnedDevList);
1704     PMDeleteDeviceList(pLinkedDevList);
1705     if (removeData)
1706     {
1707         OICFree(removeData->revokeTargetDev);
1708         OICFree(removeData->removeRes);
1709         OICFree(removeData);
1710     }
1711     OIC_LOG(INFO, TAG, "OUT ERROR case SRPRemoveDevice");
1712     return res;
1713 }