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