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 // Structure to carry get security resource APIs data to callback.
  97 typedef struct GetSecData GetSecData_t;
  98 struct GetSecData {
  99     void *ctx;
 100     const OCProvisionDev_t *deviceInfo;         /**< Pointer to PMDevInfo_t.**/
 101     OCProvisionResultCB resultCallback;         /**< Pointer to result callback.**/
 102     OCProvisionResult_t *resArr;                /**< Result array.**/
 103     int numOfResults;                        /**< Number of results in result array.**/
 104 };
 105
 106 /**
 107  * Structure to carry PCONF provision API data to callback.
 108  */
 109 typedef struct PconfData PconfData_t;
 110 struct PconfData
 111 {
 112     void *ctx;                                  /**< Pointer to user context.**/
 113     const OCProvisionDev_t *deviceInfo;         /**< Pointer to PMDevInfo_t.**/
 114     OCProvisionResultCB resultCallback;         /**< Pointer to result callback.**/
 115     OCProvisionResult_t *resArr;                /**< Result array.**/
 116     int numOfResults;                           /**< Number of results in result array.**/
 117 };
 118
 119 // Enum type index for unlink callback.
 120 typedef enum {
 121     IDX_FIRST_DEVICE_RES = 0, // index for resulf of the first device
 122     IDX_SECOND_DEVICE_RES,    // index for result of the second device
 123     IDX_DB_UPDATE_RES         // index for result of updating provisioning database.
 124 } IdxUnlinkRes_t;
 125
 126 // Structure to carry unlink APIs data to callback.
 127 typedef struct UnlinkData UnlinkData_t;
 128 struct UnlinkData {
 129     void *ctx;
 130     OCProvisionDev_t* unlinkDev;             /**< Pointer to OCProvisionDev_t to be unlinked.**/
 131     OCProvisionResult_t* unlinkRes;          /**< Result array.**/
 132     OCProvisionResultCB resultCallback;      /**< Pointer to result callback.**/
 133     int numOfResults;                        /**< Number of results in result array.**/
 134 };
 135
 136 //Example of DELETE cred request -> coaps://0.0.0.0:5684/oic/sec/cred?sub=(BASE64 ENCODED UUID)
 137 const char * SRP_FORM_DELETE_CREDENTIAL = "coaps://[%s]:%d%s?%s=%s";
 138
 139 // Structure to carry remove APIs data to callback.
 140 typedef struct RemoveData RemoveData_t;
 141 struct RemoveData {
 142     void *ctx;
 143     OCProvisionDev_t* revokeTargetDev;      /**< Device which is going to be revoked..**/
 144     OCProvisionDev_t* linkedDevList;        /**< A list of devices which have invalid credential.**/
 145     OCProvisionResult_t* removeRes;         /**< Result array.**/
 146     OCProvisionResultCB resultCallback;     /**< Pointer to result callback.**/
 147     size_t numOfResults;                    /**< Number of results in result array.**/
 148     size_t sizeOfResArray;
 149     bool hasError;
 150 };
 151
 152 /**
 153  * Function prototype
 154  */
 155 static OCStackResult provisionCredentials(const OicSecCred_t *cred,
 156         const OCProvisionDev_t *deviceInfo, CredentialData_t *credData,
 157         OCClientResponseHandler responseHandler);
 158
 159
 160 /**
 161  * Internal function to update result in result array.
 162  */
 163 static void registerResultForCredProvisioning(CredentialData_t *credData,
 164                                               OCStackResult stackresult, int cause)
 165 {
 166
 167    OIC_LOG_V(INFO,TAG,"value of credData->numOfResults is %d",credData->numOfResults);
 168    if(1 == cause)
 169    {
 170        memcpy(credData->resArr[(credData->numOfResults)].deviceId.id,
 171               credData->deviceInfo1->doxm->deviceID.id,UUID_LENGTH);
 172    }
 173    else
 174    {
 175        memcpy(credData->resArr[(credData->numOfResults)].deviceId.id,
 176               credData->deviceInfo2->doxm->deviceID.id,UUID_LENGTH);
 177    }
 178    credData->resArr[(credData->numOfResults)].res = stackresult;
 179    ++(credData->numOfResults);
 180 }
 181
 182 /**
 183  * Callback handler for handling callback of provisioning device 2.
 184  *
 185  * @param[in] ctx             ctx value passed to callback from calling function.
 186  * @param[in] UNUSED          handle to an invocation
 187  * @param[in] clientResponse  Response from queries to remote servers.
 188  * @return  OC_STACK_DELETE_TRANSACTION to delete the transaction
 189  *          and  OC_STACK_KEEP_TRANSACTION to keep it.
 190  */
 191 static OCStackApplicationResult provisionCredentialCB2(void *ctx, OCDoHandle UNUSED,
 192                                                        OCClientResponse *clientResponse)
 193 {
 194     VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
 195     CredentialData_t *credData = (CredentialData_t *) ctx;
 196     (void)UNUSED;
 197
 198     OCProvisionResultCB resultCallback = credData->resultCallback;
 199     OIC_LOG(INFO, TAG, "provisionCredentialCB2 called");
 200     if (clientResponse)
 201     {
 202         if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
 203         {
 204             registerResultForCredProvisioning(credData, OC_STACK_RESOURCE_CREATED, 2);
 205             OCStackResult res =  PDMLinkDevices(&credData->deviceInfo1->doxm->deviceID,
 206                     &credData->deviceInfo2->doxm->deviceID);
 207             if (OC_STACK_OK != res)
 208             {
 209                 OIC_LOG(ERROR, TAG, "Error occured on PDMLinkDevices");
 210                 return OC_STACK_DELETE_TRANSACTION;
 211             }
 212             OIC_LOG(INFO, TAG, "Link created successfully");
 213
 214             ((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
 215                                                     credData->resArr,
 216                                                     false);
 217              OICFree(credData->resArr);
 218              OICFree(credData);
 219              return OC_STACK_DELETE_TRANSACTION;
 220         }
 221
 222     }
 223     OIC_LOG(INFO, TAG, "provisionCredentialCB2 received Null clientResponse");
 224     registerResultForCredProvisioning(credData, OC_STACK_ERROR, 2);
 225     ((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
 226                                             credData->resArr,
 227                                             true);
 228     OICFree(credData->resArr);
 229     OICFree(credData);
 230     return OC_STACK_DELETE_TRANSACTION;
 231 }
 232
 233 /**
 234  * Callback handler for handling callback of provisioning device 1.
 235  *
 236  * @param[in] ctx             ctx value passed to callback from calling function.
 237  * @param[in] UNUSED          handle to an invocation
 238  * @param[in] clientResponse  Response from queries to remote servers.
 239  * @return  OC_STACK_DELETE_TRANSACTION to delete the transaction
 240  *          and  OC_STACK_KEEP_TRANSACTION to keep it.
 241  */
 242 static OCStackApplicationResult provisionCredentialCB1(void *ctx, OCDoHandle UNUSED,
 243                                                        OCClientResponse *clientResponse)
 244 {
 245     VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
 246     (void)UNUSED;
 247     CredentialData_t* credData = (CredentialData_t*) ctx;
 248     OICFree(credData->credInfoFirst);
 249     const OCProvisionDev_t *deviceInfo = credData->deviceInfo2;
 250     OicSecCred_t *credInfo = credData->credInfo;
 251     const OCProvisionResultCB resultCallback = credData->resultCallback;
 252     if (clientResponse)
 253     {
 254         if (OC_STACK_RESOURCE_CREATED == clientResponse->result)
 255         {
 256             // send credentials to second device
 257             registerResultForCredProvisioning(credData, OC_STACK_RESOURCE_CREATED,1);
 258             OCStackResult res = provisionCredentials(credInfo, deviceInfo, credData,
 259                     provisionCredentialCB2);
 260             DeleteCredList(credInfo);
 261             if (OC_STACK_OK != res)
 262             {
 263                 registerResultForCredProvisioning(credData, res,2);
 264                 ((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
 265                                                         credData->resArr,
 266                                                         true);
 267                 OICFree(credData->resArr);
 268                 OICFree(credData);
 269                 credData = NULL;
 270             }
 271         }
 272         else
 273         {
 274             registerResultForCredProvisioning(credData, OC_STACK_ERROR,1);
 275             ((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
 276                                                     credData->resArr,
 277                                                     true);
 278             OICFree(credData->resArr);
 279             OICFree(credData);
 280             credData = NULL;
 281         }
 282     }
 283     else
 284     {
 285         OIC_LOG(INFO, TAG, "provisionCredentialCB received Null clientResponse for first device");
 286         registerResultForCredProvisioning(credData, OC_STACK_ERROR,1);
 287        ((OCProvisionResultCB)(resultCallback))(credData->ctx, credData->numOfResults,
 288                                                      credData->resArr,
 289                                                      true);
 290         DeleteCredList(credInfo);
 291         OICFree(credData->resArr);
 292         OICFree(credData);
 293         credData = NULL;
 294     }
 295     return OC_STACK_DELETE_TRANSACTION;
 296 }
 297
 298
 299
 300 /**
 301  * Internal function for handling credential generation and sending credential to resource server.
 302  *
 303  * @param[in] cred Instance of cred resource.
 304  * @param[in] deviceInfo information about device to which credential is to be provisioned.
 305  * @param[in] responseHandler callbak called by OC stack when request API receives response.
 306  * @return  OC_STACK_OK in case of success and other value otherwise.
 307  */
 308 static OCStackResult provisionCredentials(const OicSecCred_t *cred,
 309         const OCProvisionDev_t *deviceInfo, CredentialData_t *credData,
 310         OCClientResponseHandler responseHandler)
 311 {
 312     OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
 313     if (!secPayload)
 314     {
 315         OIC_LOG(ERROR, TAG, "Failed to memory allocation");
 316         return OC_STACK_NO_MEMORY;
 317     }
 318     secPayload->base.type = PAYLOAD_TYPE_SECURITY;
 319     int secureFlag = 0;
 320     OCStackResult res = CredToCBORPayload(cred, &secPayload->securityData,
 321                                           &secPayload->payloadSize, secureFlag);
 322     if((OC_STACK_OK != res) && (NULL == secPayload->securityData))
 323     {
 324         OCPayloadDestroy((OCPayload *)secPayload);
 325         OIC_LOG(ERROR, TAG, "Failed to CredToCBORPayload");
 326         return OC_STACK_NO_MEMORY;
 327     }
 328
 329     OIC_LOG(DEBUG, TAG, "Created payload for Cred:");
 330     OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize);
 331     char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
 332     if(!PMGenerateQuery(true,
 333                         deviceInfo->endpoint.addr,
 334                         deviceInfo->securePort,
 335                         deviceInfo->connType,
 336                         query, sizeof(query), OIC_RSRC_CRED_URI))
 337     {
 338         OIC_LOG(ERROR, TAG, "DeviceDiscoveryHandler : Failed to generate query");
 339         return OC_STACK_ERROR;
 340     }
 341     OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
 342
 343     OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL};
 344     cbData.cb = responseHandler;
 345     cbData.context = (void *) credData;
 346     cbData.cd = NULL;
 347
 348     OCDoHandle handle = NULL;
 349     OCMethod method = OC_REST_POST;
 350     OCStackResult ret = OCDoResource(&handle, method, query, 0, (OCPayload*)secPayload,
 351             deviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
 352     OIC_LOG_V(INFO, TAG, "OCDoResource::Credential provisioning returned : %d",ret);
 353     if (ret != OC_STACK_OK)
 354     {
 355         OIC_LOG(ERROR, TAG, "OCStack resource error");
 356         return ret;
 357     }
 358     return OC_STACK_OK;
 359 }
 360
 361 #ifdef __WITH_X509__
 362 /**
 363  * Structure to carry certificate data to callback.
 364  */
 365 typedef struct CertificateData CertData_t;
 366 struct CertificateData
 367 {
 368     void *ctx;                                  /**< Pointer to user context.**/
 369     const OCProvisionDev_t *deviceInfo;        /**< Pointer to OCProvisionDev_t.**/
 370     OicSecCred_t *credInfo;                     /**< Pointer to OicSecCred_t.**/
 371     OCProvisionResultCB resultCallback;         /**< Pointer to result callback.**/
 372     OCProvisionResult_t *resArr;                /**< Result array.**/
 373     int numOfResults;                           /**< Number of results in result array.**/
 374 };
 375
 376 /**
 377  * Structure to carry CRL provision API data to callback.
 378  */
 379 typedef struct CRLData CRLData_t;
 380 struct CRLData
 381 {
 382     void *ctx;                                  /**< Pointer to user context.**/
 383     const OCProvisionDev_t *deviceInfo;         /**< Pointer to PMDevInfo_t.**/
 384     OCProvisionResultCB resultCallback;         /**< Pointer to result callback.**/
 385     OCProvisionResult_t *resArr;                /**< Result array.**/
 386     int numOfResults;                           /**< Number of results in result array.**/
 387 };
 388
 389 /**
 390  * Internal function to update result in result array.
 391  */
 392 static void registerResultForCertProvisioning(CertData_t *certData,
 393                                               OCStackResult stackresult)
 394 {
 395
 396    OIC_LOG_V(INFO,TAG,"value of credData->numOfResults is %d",certData->numOfResults);
 397    memcpy(certData->resArr[(certData->numOfResults)].deviceId.id,
 398           certData->deviceInfo->doxm->deviceID.id,UUID_LENGTH);
 399    certData->resArr[(certData->numOfResults)].res = stackresult;
 400    ++(certData->numOfResults);
 401 }
 402
 403 /**
 404  * Internal Function to store results in result array during ACL provisioning.
 405  */
 406 static void registerResultForCRLProvisioning(CRLData_t *crlData,
 407                                              OCStackResult stackresult)
 408 {
 409    OIC_LOG_V(INFO, TAG, "Inside registerResultForCRLProvisioning crlData->numOfResults is %d\n",
 410                        crlData->numOfResults);
 411    memcpy(crlData->resArr[(crlData->numOfResults)].deviceId.id,
 412           crlData->deviceInfo->doxm->deviceID.id, UUID_LENGTH);
 413    crlData->resArr[(crlData->numOfResults)].res = stackresult;
 414    ++(crlData->numOfResults);
 415 }
 416
 417
 418 /**
 419  * Callback handler of SRPProvisionCRL.
 420  *
 421  * @param[in] ctx             ctx value passed to callback from calling function.
 422  * @param[in] UNUSED          handle to an invocation
 423  * @param[in] clientResponse  Response from queries to remote servers.
 424  * @return  OC_STACK_DELETE_TRANSACTION to delete the transaction
 425  *          and  OC_STACK_KEEP_TRANSACTION to keep it.
 426  */
 427 static OCStackApplicationResult SRPProvisionCRLCB(void *ctx, OCDoHandle UNUSED,
 428                                                   OCClientResponse *clientResponse)
 429 {
 430     OIC_LOG_V(INFO, TAG, "Inside SRPProvisionCRLCB.");
 431     (void)UNUSED;
 432     VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
 433     CRLData_t *crlData = (CRLData_t*)ctx;
 434     OCProvisionResultCB resultCallback = crlData->resultCallback;
 435
 436     if (clientResponse)
 437     {
 438         if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
 439         {
 440             registerResultForCRLProvisioning(crlData, OC_STACK_RESOURCE_CREATED);
 441             ((OCProvisionResultCB)(resultCallback))(crlData->ctx, crlData->numOfResults,
 442                                                     crlData->resArr,
 443                                                     false);
 444              OICFree(crlData->resArr);
 445              OICFree(crlData);
 446              return OC_STACK_DELETE_TRANSACTION;
 447         }
 448     }
 449     registerResultForCRLProvisioning(crlData, OC_STACK_ERROR);
 450     ((OCProvisionResultCB)(resultCallback))(crlData->ctx, crlData->numOfResults,
 451                                             crlData->resArr,
 452                                             true);
 453     OIC_LOG_V(ERROR, TAG, "SRPProvisionCRLCB received Null clientResponse");
 454     OICFree(crlData->resArr);
 455     OICFree(crlData);
 456     return OC_STACK_DELETE_TRANSACTION;
 457 }
 458
 459 OCStackResult SRPProvisionCRL(void *ctx, const OCProvisionDev_t *selectedDeviceInfo,
 460         OicSecCrl_t *crl, OCProvisionResultCB resultCallback)
 461 {
 462     VERIFY_NON_NULL(TAG, selectedDeviceInfo, ERROR,  OC_STACK_INVALID_PARAM);
 463     VERIFY_NON_NULL(TAG, crl, ERROR,  OC_STACK_INVALID_PARAM);
 464     VERIFY_NON_NULL(TAG, resultCallback, ERROR,  OC_STACK_INVALID_CALLBACK);
 465
 466     OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
 467     if (!secPayload)
 468     {
 469         OIC_LOG(ERROR, TAG, "Failed to memory allocation");
 470         return OC_STACK_NO_MEMORY;
 471     }
 472
 473     secPayload->base.type = PAYLOAD_TYPE_SECURITY;
 474     OCStackResult res = CrlToCBORPayload(crl, &secPayload->securityData, &secPayload->payloadSize);
 475     if((OC_STACK_OK != res) && (NULL == secPayload->securityData))
 476     {
 477         OICFree(secPayload);
 478         OIC_LOG(ERROR, TAG, "Failed to BinToCrlJSON");
 479         return OC_STACK_NO_MEMORY;
 480     }
 481     OIC_LOG(DEBUG, TAG, "Created payload for CRL:");
 482     OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize);
 483
 484     char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
 485     if(!PMGenerateQuery(true,
 486                         selectedDeviceInfo->endpoint.addr,
 487                         selectedDeviceInfo->securePort,
 488                         selectedDeviceInfo->connType,
 489                         query, sizeof(query), OIC_RSRC_CRL_URI))
 490     {
 491         OIC_LOG(ERROR, TAG, "DeviceDiscoveryHandler : Failed to generate query");
 492         OCPayloadDestroy((OCPayload *)secPayload);
 493         return OC_STACK_ERROR;
 494     }
 495     OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
 496
 497     OCCallbackData cbData =  {.context=NULL, .cb=NULL, .cd=NULL};
 498     cbData.cb = &SRPProvisionCRLCB;
 499     CRLData_t *crlData = (CRLData_t *) OICCalloc(1, sizeof(CRLData_t));
 500     if (crlData == NULL)
 501     {
 502         OCPayloadDestroy((OCPayload *)secPayload);
 503         OIC_LOG(ERROR, TAG, "Unable to allocate memory");
 504         return OC_STACK_NO_MEMORY;
 505     }
 506
 507     crlData->deviceInfo = selectedDeviceInfo;
 508     crlData->resultCallback = resultCallback;
 509     crlData->numOfResults=0;
 510     crlData->ctx = ctx;
 511
 512     crlData->resArr = (OCProvisionResult_t*)OICCalloc(1, sizeof(OCProvisionResult_t));
 513     if (crlData->resArr == NULL)
 514     {
 515         OCPayloadDestroy((OCPayload *)secPayload);
 516         OIC_LOG(ERROR, TAG, "Unable to allocate memory");
 517         return OC_STACK_NO_MEMORY;
 518     }
 519
 520     cbData.context = (void *)crlData;
 521     cbData.cd = NULL;
 522     OCMethod method = OC_REST_POST;
 523     OCDoHandle handle = NULL;
 524     OIC_LOG(DEBUG, TAG, "Sending CRL info to resource server");
 525
 526     OCStackResult ret = OCDoResource(&handle, method, query,
 527             &selectedDeviceInfo->endpoint, (OCPayload*)secPayload,
 528             selectedDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
 529
 530     if (ret != OC_STACK_OK)
 531     {
 532         OICFree(crlData->resArr);
 533         OICFree(crlData);
 534     }
 535
 536     return ret;
 537 }
 538
 539 /**
 540  * Internal function for handling credential generation and sending cretificate credential.
 541  *
 542  * @param[in] cred Instance of cred resource.
 543  * @param[in] deviceInfo information about device to which credential is to be provisioned.
 544  * @param[in] responseHandler callbak called by OC stack when request API receives response.
 545  * @return  OC_STACK_OK in case of success and other value otherwise.
 546  */
 547 static OCStackResult provisionCertCred(const OicSecCred_t *cred,
 548         const OCProvisionDev_t *deviceInfo, CertData_t *certData,
 549         OCClientResponseHandler responseHandler)
 550 {
 551     OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
 552     if(!secPayload)
 553     {
 554         OIC_LOG(ERROR, TAG, "Failed to memory allocation");
 555         return OC_STACK_NO_MEMORY;
 556     }
 557     secPayload->base.type = PAYLOAD_TYPE_SECURITY;
 558     int secureFlag = 0;
 559     OCStackResult res = CredToCBORPayload(cred, &secPayload->securityData,
 560         &secPayload->payloadSize, secureFlag);
 561
 562     if ((OC_STACK_OK != res) || (NULL == secPayload->securityData))
 563     {
 564         OICFree(secPayload);
 565         OIC_LOG(ERROR, TAG, "Failed to CredToCBORPayload");
 566         return OC_STACK_NO_MEMORY;
 567     }
 568
 569     OIC_LOG(DEBUG, TAG, "Created payload for Cred:");
 570     OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize);
 571     char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
 572     if(!PMGenerateQuery(true,
 573                         deviceInfo->endpoint.addr,
 574                         deviceInfo->securePort,
 575                         deviceInfo->connType,
 576                         query, sizeof(query), OIC_RSRC_CRED_URI))
 577     {
 578         OIC_LOG(ERROR, TAG, "DeviceDiscoveryHandler : Failed to generate query");
 579         OCPayloadDestroy((OCPayload *)secPayload);
 580         return OC_STACK_ERROR;
 581     }
 582     OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
 583
 584     OCCallbackData cbData = {.context=NULL, .cb=NULL, .cd=NULL};
 585     cbData.cb = responseHandler;
 586     cbData.context = (void *) certData;
 587     cbData.cd = NULL;
 588
 589     OCDoHandle handle = NULL;
 590     OCMethod method = OC_REST_POST;
 591     OCStackResult ret = OCDoResource(&handle, method, query, 0, (OCPayload*)secPayload,
 592             deviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
 593     OIC_LOG_V(INFO, TAG, "OCDoResource::Certificate provisioning returned : %d",ret);
 594     if (ret != OC_STACK_OK)
 595     {
 596         OIC_LOG(ERROR, TAG, "OCStack resource error");
 597     }
 598
 599     return ret;
 600 }
 601
 602 /**
 603  * Callback handler for handling callback of certificate provisioning device.
 604  *
 605  * @param[in] ctx             ctx value passed to callback from calling function.
 606  * @param[in] UNUSED          handle to an invocation
 607  * @param[in] clientResponse  Response from queries to remote servers.
 608  * @return  OC_STACK_DELETE_TRANSACTION to delete the transaction
 609  *          and  OC_STACK_KEEP_TRANSACTION to keep it.
 610  */
 611 static OCStackApplicationResult provisionCertCB(void *ctx, OCDoHandle UNUSED,
 612                                                        OCClientResponse *clientResponse)
 613 {
 614     VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
 615     CertData_t *certData = (CertData_t *) ctx;
 616     (void)UNUSED;
 617
 618     OCProvisionResultCB resultCallback = certData->resultCallback;
 619     OIC_LOG(INFO, TAG, "provisionCertCred called");
 620     if (clientResponse)
 621     {
 622         if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
 623         {
 624             registerResultForCertProvisioning(certData, OC_STACK_RESOURCE_CREATED);
 625             ((OCProvisionResultCB)(resultCallback))(certData->ctx, certData->numOfResults,
 626                                                     certData->resArr,
 627                                                     false);
 628              OICFree(certData->resArr);
 629              OICFree(certData);
 630              return OC_STACK_DELETE_TRANSACTION;
 631         }
 632
 633     }
 634     OIC_LOG(INFO, TAG, "provisionCertCredCB received Null clientResponse");
 635     registerResultForCertProvisioning(certData, OC_STACK_ERROR);
 636     ((OCProvisionResultCB)(resultCallback))(certData->ctx, certData->numOfResults,
 637                                             certData->resArr,
 638                                             true);
 639     OICFree(certData->resArr);
 640     OICFree(certData);
 641     return OC_STACK_DELETE_TRANSACTION;
 642 }
 643 #endif // __WITH_X509__
 644
 645 OCStackResult SRPProvisionCredentials(void *ctx, OicSecCredType_t type, size_t keySize,
 646                                       const OCProvisionDev_t *pDev1,
 647                                       const OCProvisionDev_t *pDev2,
 648                                       OCProvisionResultCB resultCallback)
 649 {
 650     VERIFY_NON_NULL(TAG, pDev1, ERROR,  OC_STACK_INVALID_PARAM);
 651     if (SYMMETRIC_PAIR_WISE_KEY == type)
 652     {
 653         VERIFY_NON_NULL(TAG, pDev2, ERROR,  OC_STACK_INVALID_PARAM);
 654     }
 655     if (!resultCallback)
 656     {
 657         OIC_LOG(INFO, TAG, "SRPUnlinkDevices : NULL Callback");
 658         return OC_STACK_INVALID_CALLBACK;
 659     }
 660     if (SYMMETRIC_PAIR_WISE_KEY == type &&
 661         0 == memcmp(&pDev1->doxm->deviceID, &pDev2->doxm->deviceID, sizeof(OicUuid_t)))
 662     {
 663         OIC_LOG(INFO, TAG, "SRPUnlinkDevices : Same device ID");
 664         return OC_STACK_INVALID_PARAM;
 665     }
 666
 667     if (SYMMETRIC_PAIR_WISE_KEY == type &&
 668        !(OWNER_PSK_LENGTH_128 == keySize || OWNER_PSK_LENGTH_256 == keySize))
 669     {
 670         OIC_LOG(INFO, TAG, "Invalid key size");
 671         return OC_STACK_INVALID_PARAM;
 672     }
 673
 674     OIC_LOG(INFO, TAG, "In SRPProvisionCredentials");
 675
 676     if (SYMMETRIC_PAIR_WISE_KEY == type)
 677     {
 678         bool linkExisits = true;
 679         OCStackResult res = PDMIsLinkExists(&pDev1->doxm->deviceID, &pDev2->doxm->deviceID, &linkExisits);
 680
 681         if (res != OC_STACK_OK)
 682         {
 683             OIC_LOG(ERROR, TAG, "Internal error occured");
 684             return res;
 685         }
 686         if (linkExisits)
 687         {
 688             OIC_LOG(ERROR, TAG, "Link already exists");
 689             return OC_STACK_INVALID_PARAM;
 690         }
 691     }
 692
 693     OicUuid_t provTooldeviceID =   {{0,}};
 694     if (OC_STACK_OK != GetDoxmDeviceID(&provTooldeviceID))
 695     {
 696         OIC_LOG(ERROR, TAG, "Error while retrieving provisioning tool's device ID");
 697         return OC_STACK_ERROR;
 698     }
 699     OIC_LOG(INFO, TAG, "retrieved deviceid");
 700     switch (type)
 701     {
 702         case SYMMETRIC_PAIR_WISE_KEY:
 703         {
 704             const OCProvisionDev_t *firstDevice = pDev1;
 705             const OCProvisionDev_t *secondDevice = pDev2;
 706
 707             OicSecCred_t *firstCred = NULL;
 708             OicSecCred_t *secondCred = NULL;
 709             OCStackResult res = PMGeneratePairWiseCredentials(type, keySize, &provTooldeviceID,
 710                     &firstDevice->doxm->deviceID, &secondDevice->doxm->deviceID,
 711                     &firstCred, &secondCred);
 712             VERIFY_SUCCESS(TAG, (res==OC_STACK_OK), ERROR, OC_STACK_ERROR);
 713             OIC_LOG(INFO, TAG, "Credentials generated successfully");
 714             CredentialData_t *credData =
 715                 (CredentialData_t *) OICCalloc(1, sizeof(CredentialData_t));
 716             if (NULL == credData)
 717             {
 718                 OICFree(firstCred);
 719                 OICFree(secondCred);
 720                 OIC_LOG(ERROR, TAG, "Memory allocation problem");
 721                 return OC_STACK_NO_MEMORY;
 722             }
 723             credData->deviceInfo1 = firstDevice;
 724             credData->deviceInfo2 = secondDevice;
 725             credData->credInfo = secondCred;
 726             credData->ctx = ctx;
 727             credData->credInfoFirst = firstCred;
 728             credData->numOfResults = 0;
 729             credData->resultCallback = resultCallback;
 730             // first call to provision creds to device1.
 731             // second call to provision creds to device2.
 732             int noOfRiCalls = 2;
 733             credData->resArr =
 734                 (OCProvisionResult_t*)OICCalloc(noOfRiCalls, sizeof(OCProvisionResult_t));
 735             if (NULL == credData->resArr)
 736             {
 737                 OICFree(firstCred);
 738                 OICFree(secondCred);
 739                 OICFree(credData);
 740                 OIC_LOG(ERROR, TAG, "Memory allocation problem");
 741                 return OC_STACK_NO_MEMORY;
 742             }
 743             res = provisionCredentials(firstCred, firstDevice, credData, &provisionCredentialCB1);
 744             if (OC_STACK_OK != res)
 745             {
 746                 DeleteCredList(firstCred);
 747                 DeleteCredList(secondCred);
 748                 OICFree(credData->resArr);
 749                 OICFree(credData);
 750             }
 751             OIC_LOG_V(INFO, TAG, "provisionCredentials returned: %d",res);
 752             VERIFY_SUCCESS(TAG, (res==OC_STACK_OK), ERROR, OC_STACK_ERROR);
 753             return res;
 754         }
 755 #ifdef __WITH_X509__
 756         case SIGNED_ASYMMETRIC_KEY:
 757         {
 758             const OCProvisionDev_t *firstDevice = pDev1;
 759             OicSecCred_t *cred = NULL;
 760             OCStackResult res = PMGenerateCertificateCredentials(&provTooldeviceID,
 761                                                                 &firstDevice->doxm->deviceID,&cred);
 762             VERIFY_SUCCESS(TAG, (res==OC_STACK_OK), ERROR, OC_STACK_ERROR);
 763             OIC_LOG(INFO, TAG, "Certificate credentials generated successfully");
 764             CertData_t *certData = (CertData_t *) OICCalloc(1, sizeof(CertData_t));
 765             if (NULL == certData)
 766             {
 767                 OICFree(cred);
 768                 OIC_LOG(ERROR, TAG, "Memory allocation problem");
 769                 return OC_STACK_NO_MEMORY;
 770             }
 771
 772             certData->deviceInfo = firstDevice;
 773             certData->ctx = ctx;
 774             certData->credInfo = cred;
 775             certData->numOfResults = 0;
 776             certData->resultCallback = resultCallback;
 777
 778             certData->resArr = (OCProvisionResult_t*)OICCalloc(1, sizeof(OCProvisionResult_t));
 779             if (NULL == certData->resArr)
 780             {
 781                 DeleteCredList(cred);
 782                 OICFree(certData);
 783                 OIC_LOG(ERROR, TAG, "Memory allocation problem");
 784                 return OC_STACK_NO_MEMORY;
 785             }
 786
 787             res = provisionCertCred(cred, firstDevice, certData, &provisionCertCB);
 788             if (OC_STACK_OK != res)
 789             {
 790                 OICFree(certData->resArr);
 791                 OICFree(certData);
 792             }
 793             DeleteCredList(cred);
 794             OIC_LOG_V(INFO, TAG, "provisionCertCredentials returned: %d",res);
 795
 796             return res;
 797         }
 798 #endif
 799         default:
 800         {
 801             OIC_LOG(ERROR, TAG, "Invalid option.");
 802             return OC_STACK_INVALID_PARAM;
 803         }
 804     }
 805     return OC_STACK_ERROR;
 806 }
 807
 808 /**
 809  * Internal Function to store results in result array during ACL provisioning.
 810  */
 811 static void registerResultForACLProvisioning(ACLData_t *aclData,
 812                                              OCStackResult stackresult)
 813 {
 814    OIC_LOG_V(INFO, TAG, "Inside registerResultForACLProvisioning aclData->numOfResults is %d\n",
 815                        aclData->numOfResults);
 816    memcpy(aclData->resArr[(aclData->numOfResults)].deviceId.id,
 817           aclData->deviceInfo->doxm->deviceID.id, UUID_LENGTH);
 818    aclData->resArr[(aclData->numOfResults)].res = stackresult;
 819    ++(aclData->numOfResults);
 820 }
 821
 822 /**
 823  * Callback handler of SRPProvisionACL.
 824  *
 825  * @param[in] ctx             ctx value passed to callback from calling function.
 826  * @param[in] UNUSED          handle to an invocation
 827  * @param[in] clientResponse  Response from queries to remote servers.
 828  * @return  OC_STACK_DELETE_TRANSACTION to delete the transaction
 829  *          and  OC_STACK_KEEP_TRANSACTION to keep it.
 830  */
 831 static OCStackApplicationResult SRPProvisionACLCB(void *ctx, OCDoHandle UNUSED,
 832                                                   OCClientResponse *clientResponse)
 833 {
 834     OIC_LOG_V(INFO, TAG, "Inside SRPProvisionACLCB.");
 835     (void)UNUSED;
 836     VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
 837     ACLData_t *aclData = (ACLData_t*)ctx;
 838     OCProvisionResultCB resultCallback = aclData->resultCallback;
 839
 840     if (clientResponse)
 841     {
 842         if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
 843         {
 844             registerResultForACLProvisioning(aclData, OC_STACK_RESOURCE_CREATED);
 845             ((OCProvisionResultCB)(resultCallback))(aclData->ctx, aclData->numOfResults,
 846                                                     aclData->resArr,
 847                                                     false);
 848              OICFree(aclData->resArr);
 849              OICFree(aclData);
 850              return OC_STACK_DELETE_TRANSACTION;
 851         }
 852     }
 853     registerResultForACLProvisioning(aclData, OC_STACK_ERROR);
 854     ((OCProvisionResultCB)(resultCallback))(aclData->ctx, aclData->numOfResults,
 855                                             aclData->resArr,
 856                                             true);
 857     OIC_LOG_V(ERROR, TAG, "SRPProvisionACLCB received Null clientResponse");
 858     OICFree(aclData->resArr);
 859     OICFree(aclData);
 860     return OC_STACK_DELETE_TRANSACTION;
 861 }
 862
 863 OCStackResult SRPProvisionACL(void *ctx, const OCProvisionDev_t *selectedDeviceInfo,
 864         OicSecAcl_t *acl, OCProvisionResultCB resultCallback)
 865 {
 866     VERIFY_NON_NULL(TAG, selectedDeviceInfo, ERROR,  OC_STACK_INVALID_PARAM);
 867     VERIFY_NON_NULL(TAG, acl, ERROR,  OC_STACK_INVALID_PARAM);
 868     VERIFY_NON_NULL(TAG, resultCallback, ERROR,  OC_STACK_INVALID_CALLBACK);
 869
 870     OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
 871     if(!secPayload)
 872     {
 873         OIC_LOG(ERROR, TAG, "Failed to memory allocation");
 874         return OC_STACK_NO_MEMORY;
 875     }
 876     secPayload->base.type = PAYLOAD_TYPE_SECURITY;
 877     if(OC_STACK_OK != AclToCBORPayload(acl, &secPayload->securityData, &secPayload->payloadSize))
 878     {
 879         OCPayloadDestroy((OCPayload *)secPayload);
 880         OIC_LOG(ERROR, TAG, "Failed to AclToCBORPayload");
 881         return OC_STACK_NO_MEMORY;
 882     }
 883     OIC_LOG(DEBUG, TAG, "Created payload for ACL:");
 884     OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize);
 885
 886     char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
 887     if(!PMGenerateQuery(true,
 888                         selectedDeviceInfo->endpoint.addr,
 889                         selectedDeviceInfo->securePort,
 890                         selectedDeviceInfo->connType,
 891                         query, sizeof(query), OIC_RSRC_ACL_URI))
 892     {
 893         OIC_LOG(ERROR, TAG, "DeviceDiscoveryHandler : Failed to generate query");
 894         return OC_STACK_ERROR;
 895     }
 896     OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
 897
 898     OCCallbackData cbData =  {.context=NULL, .cb=NULL, .cd=NULL};
 899     cbData.cb = &SRPProvisionACLCB;
 900     ACLData_t *aclData = (ACLData_t *) OICCalloc(1, sizeof(ACLData_t));
 901     if (aclData == NULL)
 902     {
 903         OCPayloadDestroy((OCPayload *)secPayload);
 904         OIC_LOG(ERROR, TAG, "Unable to allocate memory");
 905         return OC_STACK_NO_MEMORY;
 906     }
 907     aclData->deviceInfo = selectedDeviceInfo;
 908     aclData->resultCallback = resultCallback;
 909     aclData->numOfResults=0;
 910     aclData->ctx = ctx;
 911     // call to provision ACL to device1.
 912     int noOfRiCalls = 1;
 913     aclData->resArr = (OCProvisionResult_t*)OICCalloc(noOfRiCalls, sizeof(OCProvisionResult_t));
 914     if (aclData->resArr == NULL)
 915     {
 916         OICFree(aclData);
 917         OCPayloadDestroy((OCPayload *)secPayload);
 918         OIC_LOG(ERROR, TAG, "Unable to allocate memory");
 919         return OC_STACK_NO_MEMORY;
 920     }
 921     cbData.context = (void *)aclData;
 922     cbData.cd = NULL;
 923     OCMethod method = OC_REST_POST;
 924     OCDoHandle handle = NULL;
 925     OIC_LOG(DEBUG, TAG, "Sending ACL info to resource server");
 926     OCStackResult ret = OCDoResource(&handle, method, query,
 927             &selectedDeviceInfo->endpoint, (OCPayload*)secPayload,
 928             selectedDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
 929     if (ret != OC_STACK_OK)
 930     {
 931         OICFree(aclData->resArr);
 932         OICFree(aclData);
 933     }
 934     VERIFY_SUCCESS(TAG, (OC_STACK_OK == ret), ERROR, OC_STACK_ERROR);
 935     return OC_STACK_OK;
 936 }
 937
 938 /**
 939  * Internal Function to store results in result array during Direct-Pairing provisioning.
 940  */
 941 static void registerResultForDirectPairingProvisioning(PconfData_t *pconfData,
 942                                              OCStackResult stackresult)
 943 {
 944    OIC_LOG_V(INFO, TAG, "Inside registerResultForDirectPairingProvisioning "
 945            "pconfData->numOfResults is %d\n", pconfData->numOfResults);
 946    memcpy(pconfData->resArr[(pconfData->numOfResults)].deviceId.id,
 947           pconfData->deviceInfo->doxm->deviceID.id, UUID_LENGTH);
 948    pconfData->resArr[(pconfData->numOfResults)].res = stackresult;
 949    ++(pconfData->numOfResults);
 950 }
 951
 952 /**
 953  * Callback handler of SRPProvisionDirectPairing.
 954  *
 955  * @param[in] ctx             ctx value passed to callback from calling function.
 956  * @param[in] UNUSED          handle to an invocation
 957  * @param[in] clientResponse  Response from queries to remote servers.
 958  * @return  OC_STACK_DELETE_TRANSACTION to delete the transaction
 959  *          and  OC_STACK_KEEP_TRANSACTION to keep it.
 960  */
 961 static OCStackApplicationResult SRPProvisionDirectPairingCB(void *ctx, OCDoHandle UNUSED,
 962                                                   OCClientResponse *clientResponse)
 963 {
 964     OIC_LOG_V(INFO, TAG, "Inside SRPProvisionDirectPairingCB.");
 965     (void)UNUSED;
 966     VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
 967     PconfData_t *pconfData = (PconfData_t*)ctx;
 968     OCProvisionResultCB resultCallback = pconfData->resultCallback;
 969
 970     if (clientResponse)
 971     {
 972         if(OC_STACK_RESOURCE_CREATED == clientResponse->result)
 973         {
 974             registerResultForDirectPairingProvisioning(pconfData, OC_STACK_OK);
 975             ((OCProvisionResultCB)(resultCallback))(pconfData->ctx, pconfData->numOfResults,
 976                                                     pconfData->resArr,
 977                                                     false);
 978              OICFree(pconfData->resArr);
 979              OICFree(pconfData);
 980              return OC_STACK_DELETE_TRANSACTION;
 981         }
 982     }
 983     registerResultForDirectPairingProvisioning(pconfData, OC_STACK_ERROR);
 984     ((OCProvisionResultCB)(resultCallback))(pconfData->ctx, pconfData->numOfResults,
 985                                             pconfData->resArr,
 986                                             true);
 987     OIC_LOG_V(ERROR, TAG, "SRPProvisionDirectPairingCB received Null clientResponse");
 988     OICFree(pconfData->resArr);
 989     OICFree(pconfData);
 990     return OC_STACK_DELETE_TRANSACTION;
 991 }
 992
 993 OCStackResult SRPProvisionDirectPairing(void *ctx, const OCProvisionDev_t *selectedDeviceInfo,
 994         OicSecPconf_t *pconf, OCProvisionResultCB resultCallback)
 995 {
 996     VERIFY_NON_NULL(TAG, selectedDeviceInfo, ERROR,  OC_STACK_INVALID_PARAM);
 997     VERIFY_NON_NULL(TAG, pconf, ERROR,  OC_STACK_INVALID_PARAM);
 998     VERIFY_NON_NULL(TAG, resultCallback, ERROR,  OC_STACK_INVALID_CALLBACK);
 999
1000     // check direct-pairing capability
1001     if (true != selectedDeviceInfo->doxm->dpc)
1002     {
1003         OIC_LOG(ERROR, TAG, "Resouce server does not have Direct-Pairing Capability ");
1004         return OC_STACK_UNAUTHORIZED_REQ;
1005     }
1006
1007     OicUuid_t provTooldeviceID =   {.id={0}};
1008     if (OC_STACK_OK != GetDoxmDeviceID(&provTooldeviceID))
1009     {
1010         OIC_LOG(ERROR, TAG, "Error while retrieving provisioning tool's device ID");
1011         return OC_STACK_ERROR;
1012     }
1013     memcpy(&pconf->rownerID, &provTooldeviceID, sizeof(OicUuid_t));
1014
1015     OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
1016     if(!secPayload)
1017     {
1018         OIC_LOG(ERROR, TAG, "Failed to memory allocation");
1019         return OC_STACK_NO_MEMORY;
1020     }
1021     secPayload->base.type = PAYLOAD_TYPE_SECURITY;
1022
1023     if (OC_STACK_OK != PconfToCBORPayload(pconf, &(secPayload->securityData),
1024                 &(secPayload->payloadSize)))
1025     {
1026         OCPayloadDestroy((OCPayload*)secPayload);
1027         OIC_LOG(ERROR, TAG, "Failed to PconfToCborPayload");
1028         return OC_STACK_NO_MEMORY;
1029     }
1030     OIC_LOG(DEBUG, TAG, "Created payload for pconf set");
1031     OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize);
1032
1033
1034     char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
1035     if(!PMGenerateQuery(true,
1036                 selectedDeviceInfo->endpoint.addr,
1037                 selectedDeviceInfo->securePort,
1038                 selectedDeviceInfo->connType,
1039                 query, sizeof(query), OIC_RSRC_PCONF_URI))
1040     {
1041         OIC_LOG(ERROR, TAG, "SRPProvisionDirectPairing : Failed to generate query");
1042         return OC_STACK_ERROR;
1043     }
1044     OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
1045
1046     OCCallbackData cbData =  {.context=NULL, .cb=NULL, .cd=NULL};
1047     cbData.cb = &SRPProvisionDirectPairingCB;
1048     PconfData_t *pconfData = (PconfData_t *) OICCalloc(1, sizeof(PconfData_t));
1049     if (NULL == pconfData)
1050     {
1051         OCPayloadDestroy((OCPayload*)secPayload);
1052         OIC_LOG(ERROR, TAG, "Unable to allocate memory");
1053         return OC_STACK_NO_MEMORY;
1054     }
1055     pconfData->deviceInfo = selectedDeviceInfo;
1056     pconfData->resultCallback = resultCallback;
1057     pconfData->numOfResults=0;
1058     pconfData->ctx = ctx;
1059     // call to provision PCONF to device1.
1060     int noOfRiCalls = 1;
1061     pconfData->resArr = (OCProvisionResult_t*)OICCalloc(noOfRiCalls, sizeof(OCProvisionResult_t));
1062     if (NULL == pconfData->resArr)
1063     {
1064         OICFree(pconfData);
1065         OCPayloadDestroy((OCPayload*)secPayload);
1066         OIC_LOG(ERROR, TAG, "Unable to allocate memory");
1067         return OC_STACK_NO_MEMORY;
1068     }
1069     cbData.context = (void *)pconfData;
1070     cbData.cd = NULL;
1071     OCMethod method = OC_REST_POST;
1072     OCDoHandle handle = NULL;
1073     OIC_LOG(DEBUG, TAG, "Sending PCONF info to resource server");
1074     OCStackResult ret = OCDoResource(&handle, method, query,
1075             &selectedDeviceInfo->endpoint, (OCPayload*)secPayload,
1076             selectedDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
1077     if (OC_STACK_OK != ret)
1078     {
1079         OICFree(pconfData->resArr);
1080         OICFree(pconfData);
1081     }
1082     VERIFY_SUCCESS(TAG, (OC_STACK_OK == ret), ERROR, OC_STACK_ERROR);
1083     return OC_STACK_OK;
1084 }
1085
1086 static void DeleteUnlinkData_t(UnlinkData_t *unlinkData)
1087 {
1088     if (unlinkData)
1089     {
1090         OICFree(unlinkData->unlinkDev);
1091         OICFree(unlinkData->unlinkRes);
1092         OICFree(unlinkData);
1093     }
1094 }
1095
1096 static void registerResultForUnlinkDevices(UnlinkData_t *unlinkData, OCStackResult stackresult,
1097                                            IdxUnlinkRes_t idx)
1098 {
1099     if (NULL != unlinkData)
1100     {
1101         OIC_LOG_V(INFO, TAG, "Inside registerResultForUnlinkDevices unlinkData->numOfResults is %d\n",
1102                             unlinkData->numOfResults);
1103         OIC_LOG_V(INFO, TAG, "Stack result :: %d", stackresult);
1104
1105         OicUuid_t *pUuid = &unlinkData->unlinkRes[(unlinkData->numOfResults)].deviceId;
1106
1107         // Set result in the result array according to the position (devNum).
1108         if (idx != IDX_DB_UPDATE_RES)
1109         {
1110             memcpy(pUuid->id, unlinkData->unlinkDev[idx].doxm->deviceID.id, sizeof(pUuid->id));
1111         }
1112         else
1113         {   // When deivce ID is 000... this means it's the result of database update.
1114             memset(pUuid->id, 0, sizeof(pUuid->id));
1115         }
1116         unlinkData->unlinkRes[(unlinkData->numOfResults)].res = stackresult;
1117         ++(unlinkData->numOfResults);
1118         OIC_LOG (INFO, TAG, "Out registerResultForUnlinkDevices");
1119     }
1120 }
1121
1122 static OCStackResult SendDeleteCredentialRequest(void* ctx,
1123                                                  OCClientResponseHandler respHandler,
1124                                                  const OCProvisionDev_t* revokedDev,
1125                                                  const OCProvisionDev_t* destDev)
1126 {
1127     OIC_LOG(DEBUG, TAG, "IN SendDeleteCredentialRequest");
1128
1129     if (NULL == ctx || NULL == respHandler || NULL == revokedDev || NULL == destDev)
1130     {
1131         return OC_STACK_INVALID_PARAM;
1132     }
1133
1134     char *subID = NULL;
1135     OCStackResult ret = ConvertUuidToStr(&revokedDev->doxm->deviceID, &subID);
1136     if(OC_STACK_OK != ret)
1137     {
1138         OIC_LOG(ERROR, TAG, "SendDeleteCredentialRequest : Failed to canonical UUID encoding");
1139         return OC_STACK_ERROR;
1140     }
1141
1142     char reqBuf[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
1143     int snRet = 0;
1144                     //coaps://0.0.0.0:5684/oic/sec/cred?subjectid=(Canonical ENCODED UUID)
1145     snRet = snprintf(reqBuf, sizeof(reqBuf), SRP_FORM_DELETE_CREDENTIAL, destDev->endpoint.addr,
1146                      destDev->securePort, OIC_RSRC_CRED_URI, OIC_JSON_SUBJECTID_NAME, subID);
1147     OICFree(subID);
1148     if (snRet < 0)
1149     {
1150         OIC_LOG_V(ERROR, TAG, "SendDeleteCredentialRequest : Error (snprintf) %d\n", snRet);
1151         return OC_STACK_ERROR;
1152     }
1153     else if ((size_t)snRet >= sizeof(reqBuf))
1154     {
1155         OIC_LOG_V(ERROR, TAG, "SendDeleteCredentialRequest : Truncated (snprintf) %d\n", snRet);
1156         return OC_STACK_ERROR;
1157     }
1158
1159     OCCallbackData cbData;
1160     memset(&cbData, 0, sizeof(cbData));
1161     cbData.context = ctx;
1162     cbData.cb = respHandler;
1163     cbData.cd = NULL;
1164     OIC_LOG_V(INFO, TAG, "URI: %s",reqBuf);
1165
1166     OIC_LOG(DEBUG, TAG, "Sending remove credential request to resource server");
1167
1168     ret = OCDoResource(NULL, OC_REST_DELETE, reqBuf,
1169                                      &destDev->endpoint, NULL,
1170                                      CT_ADAPTER_IP, OC_HIGH_QOS, &cbData, NULL, 0);
1171     if (OC_STACK_OK != ret)
1172     {
1173         OIC_LOG_V(ERROR, TAG, "SendDeleteCredentialRequest : Error in OCDoResource %d", ret);
1174     }
1175     OIC_LOG(DEBUG, TAG, "OUT SendDeleteCredentialRequest");
1176
1177     return ret;
1178 }
1179
1180 static OCStackResult SendDeleteACLRequest(void* ctx,
1181                                                  OCClientResponseHandler respHandler,
1182                                                  const OCProvisionDev_t* revokedDev,
1183                                                  const OCProvisionDev_t* destDev)
1184 {
1185     OIC_LOG(DEBUG, TAG, "IN SendDeleteACLRequest");
1186
1187     if (NULL == ctx || NULL == respHandler || NULL == revokedDev || NULL == destDev)
1188     {
1189         return OC_STACK_INVALID_PARAM;
1190     }
1191
1192     char *subID = NULL;
1193     OCStackResult ret = ConvertUuidToStr(&revokedDev->doxm->deviceID, &subID);
1194     if(OC_STACK_OK != ret)
1195     {
1196         OIC_LOG(ERROR, TAG, "SendDeleteACLRequest : Failed to canonical UUID encoding");
1197         return OC_STACK_ERROR;
1198     }
1199
1200     char reqBuf[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
1201     int snRet = 0;
1202                     //coaps://0.0.0.0:5684/oic/sec/acl?subjectuuid=(Canonical ENCODED UUID)
1203     snRet = snprintf(reqBuf, sizeof(reqBuf), SRP_FORM_DELETE_CREDENTIAL, destDev->endpoint.addr,
1204                      destDev->securePort, OIC_RSRC_ACL_URI, OIC_JSON_SUBJECTID_NAME, subID);
1205     OICFree(subID);
1206     if (snRet < 0)
1207     {
1208         OIC_LOG_V(ERROR, TAG, "SendDeleteACLRequest : Error (snprintf) %d\n", snRet);
1209         return OC_STACK_ERROR;
1210     }
1211     else if ((size_t)snRet >= sizeof(reqBuf))
1212     {
1213         OIC_LOG_V(ERROR, TAG, "SendDeleteACLRequest : Truncated (snprintf) %d\n", snRet);
1214         return OC_STACK_ERROR;
1215     }
1216
1217     OCCallbackData cbData;
1218     memset(&cbData, 0, sizeof(cbData));
1219     cbData.context = ctx;
1220     cbData.cb = respHandler;
1221     cbData.cd = NULL;
1222     OIC_LOG_V(INFO, TAG, "URI: %s",reqBuf);
1223
1224     OIC_LOG(DEBUG, TAG, "Sending remove ACL request to resource server");
1225
1226     ret = OCDoResource(NULL, OC_REST_DELETE, reqBuf,
1227                                      &destDev->endpoint, NULL,
1228                                      CT_ADAPTER_IP, OC_HIGH_QOS, &cbData, NULL, 0);
1229     if (OC_STACK_OK != ret)
1230     {
1231         OIC_LOG_V(ERROR, TAG, "SendDeleteACLRequest : Error in OCDoResource %d", ret);
1232     }
1233     OIC_LOG(DEBUG, TAG, "OUT SendDeleteACLRequest");
1234
1235     return ret;
1236 }
1237
1238 /**
1239  * Callback handler of unlink second device.
1240  *
1241  * @param[in] ctx             ctx value passed to callback from calling function.
1242  * @param[in] handle          handle to an invocation
1243  * @param[in] clientResponse  Response from queries to remote servers.
1244  * @return  OC_STACK_DELETE_TRANSACTION to delete the transaction and
1245  *          OC_STACK_KEEP_TRANSACTION to keep it.
1246  */
1247 static OCStackApplicationResult SRPUnlinkDevice2CB(void *unlinkCtx, OCDoHandle handle,
1248         OCClientResponse *clientResponse)
1249 {
1250     (void) handle;
1251     OIC_LOG(DEBUG, TAG, "IN SRPUnlinkDevice2CB");
1252     VERIFY_NON_NULL(TAG, unlinkCtx, ERROR, OC_STACK_DELETE_TRANSACTION);
1253     UnlinkData_t* unlinkData = (UnlinkData_t*)unlinkCtx;
1254
1255     if (clientResponse)
1256     {
1257         OIC_LOG(DEBUG, TAG, "Valid client response for device 2");
1258         registerResultForUnlinkDevices(unlinkData, clientResponse->result, IDX_SECOND_DEVICE_RES);
1259
1260         if (OC_STACK_RESOURCE_DELETED == clientResponse->result)
1261         {
1262             OIC_LOG(DEBUG, TAG, "Credential of device2 revoked");
1263         }
1264         else
1265         {
1266             OIC_LOG(ERROR, TAG, "Unable to delete credential information from device 2");
1267             unlinkData->resultCallback(unlinkData->ctx,
1268                                        unlinkData->numOfResults, unlinkData->unlinkRes, true);
1269             goto error;
1270         }
1271     }
1272     else
1273     {
1274         registerResultForUnlinkDevices(unlinkData, OC_STACK_INVALID_REQUEST_HANDLE,
1275                                        IDX_SECOND_DEVICE_RES);
1276         unlinkData->resultCallback(unlinkData->ctx,
1277                                    unlinkData->numOfResults, unlinkData->unlinkRes, true);
1278         OIC_LOG(ERROR, TAG, "SRPUnlinkDevice2CB received Null clientResponse");
1279         goto error;
1280     }
1281
1282     //Update provisioning DB when succes case.
1283     if (OC_STACK_OK != PDMUnlinkDevices(&unlinkData->unlinkDev[0].doxm->deviceID,
1284                                        &unlinkData->unlinkDev[1].doxm->deviceID))
1285     {
1286         OIC_LOG(FATAL, TAG, "All requests are successfully done but update provisioning DB FAILED.");
1287         registerResultForUnlinkDevices(unlinkData, OC_STACK_INCONSISTENT_DB, IDX_DB_UPDATE_RES);
1288         unlinkData->resultCallback(unlinkData->ctx,
1289                                    unlinkData->numOfResults, unlinkData->unlinkRes, true);
1290         goto error;
1291     }
1292     unlinkData->resultCallback(unlinkData->ctx, unlinkData->numOfResults, unlinkData->unlinkRes,
1293                                false);
1294
1295 error:
1296     DeleteUnlinkData_t(unlinkData);
1297     OIC_LOG(DEBUG, TAG, "OUT SRPUnlinkDevice2CB");
1298     return OC_STACK_DELETE_TRANSACTION;
1299
1300 }
1301
1302 /**
1303  * Callback handler of unlink first device.
1304  *
1305  * @param[in] ctx             ctx value passed to callback from calling function.
1306  * @param[in] handle          handle to an invocation
1307  * @param[in] clientResponse  Response from queries to remote servers.
1308  * @return  OC_STACK_DELETE_TRANSACTION to delete the transaction and
1309  *          OC_STACK_KEEP_TRANSACTION to keep it.
1310  */
1311 static OCStackApplicationResult SRPUnlinkDevice1CB(void *unlinkCtx, OCDoHandle handle,
1312         OCClientResponse *clientResponse)
1313 {
1314     OIC_LOG_V(INFO, TAG, "Inside SRPUnlinkDevice1CB ");
1315     VERIFY_NON_NULL(TAG, unlinkCtx, ERROR, OC_STACK_DELETE_TRANSACTION);
1316     UnlinkData_t* unlinkData = (UnlinkData_t*)unlinkCtx;
1317     (void) handle;
1318
1319     if (clientResponse)
1320     {
1321         OIC_LOG(DEBUG, TAG, "Valid client response for device 1");
1322         registerResultForUnlinkDevices(unlinkData, clientResponse->result, IDX_FIRST_DEVICE_RES);
1323
1324         if (OC_STACK_RESOURCE_DELETED == clientResponse->result)
1325         {
1326             OIC_LOG(DEBUG, TAG, "Credential of device 1 is revoked");
1327
1328             // Second revocation request to second device.
1329             OCStackResult res = SendDeleteCredentialRequest((void*)unlinkData, &SRPUnlinkDevice2CB,
1330                                                     &unlinkData->unlinkDev[0],
1331                                                     &unlinkData->unlinkDev[1] /*Dest*/);
1332             OIC_LOG_V(DEBUG, TAG, "Credential revocation request device 2, result :: %d",res);
1333             if (OC_STACK_OK != res)
1334             {
1335                  OIC_LOG(ERROR, TAG, "Error while sending revocation request for device 2");
1336                  registerResultForUnlinkDevices(unlinkData, OC_STACK_INVALID_REQUEST_HANDLE,
1337                                                 IDX_SECOND_DEVICE_RES);
1338                  unlinkData->resultCallback(unlinkData->ctx,
1339                                             unlinkData->numOfResults, unlinkData->unlinkRes, true);
1340                  goto error;
1341             }
1342             else
1343             {
1344                 OIC_LOG(DEBUG, TAG, "Request for credential revocation successfully sent");
1345                 return OC_STACK_DELETE_TRANSACTION;
1346             }
1347         }
1348         else
1349         {
1350             OIC_LOG(ERROR, TAG, "Unable to delete credential information from device 1");
1351
1352             unlinkData->resultCallback(unlinkData->ctx, unlinkData->numOfResults,
1353                                             unlinkData->unlinkRes, true);
1354             goto error;
1355         }
1356     }
1357     else
1358     {
1359         OIC_LOG(DEBUG, TAG, "Invalid response from server");
1360         registerResultForUnlinkDevices(unlinkData, OC_STACK_INVALID_REQUEST_HANDLE,
1361                                        IDX_FIRST_DEVICE_RES );
1362         unlinkData->resultCallback(unlinkData->ctx,
1363                                    unlinkData->numOfResults, unlinkData->unlinkRes,
1364                                    true);
1365         OIC_LOG(ERROR, TAG, "SRPUnlinkDevice1CB received Null clientResponse");
1366     }
1367
1368 error:
1369     OIC_LOG_V(INFO, TAG, "Out SRPUnlinkDevice1CB");
1370     DeleteUnlinkData_t(unlinkData);
1371     return OC_STACK_DELETE_TRANSACTION;
1372 }
1373
1374 /*
1375 * Function to unlink devices.
1376 * This function will remove the credential & relationship between the two devices.
1377 *
1378 * @param[in] ctx Application context would be returned in result callback
1379 * @param[in] pTargetDev1 first device information to be unlinked.
1380 * @param[in] pTargetDev2 second device information to be unlinked.
1381 * @param[in] resultCallback callback provided by API user, callback will be called when
1382 *            device unlink is finished.
1383  * @return  OC_STACK_OK in case of success and other value otherwise.
1384 */
1385 OCStackResult SRPUnlinkDevices(void* ctx,
1386                                const OCProvisionDev_t* pTargetDev1,
1387                                const OCProvisionDev_t* pTargetDev2,
1388                                OCProvisionResultCB resultCallback)
1389 {
1390     OIC_LOG(INFO, TAG, "IN SRPUnlinkDevices");
1391
1392     if (!pTargetDev1 || !pTargetDev2 || !pTargetDev1->doxm || !pTargetDev2->doxm)
1393     {
1394         OIC_LOG(INFO, TAG, "SRPUnlinkDevices : NULL parameters");
1395         return OC_STACK_INVALID_PARAM;
1396     }
1397     if (!resultCallback)
1398     {
1399         OIC_LOG(INFO, TAG, "SRPUnlinkDevices : NULL Callback");
1400         return OC_STACK_INVALID_CALLBACK;
1401     }
1402     if (0 == memcmp(&pTargetDev1->doxm->deviceID, &pTargetDev2->doxm->deviceID, sizeof(OicUuid_t)))
1403     {
1404         OIC_LOG(INFO, TAG, "SRPUnlinkDevices : Same device ID");
1405         return OC_STACK_INVALID_PARAM;
1406     }
1407
1408     OIC_LOG(INFO, TAG, "Unlinking following devices: ");
1409     PMPrintOCProvisionDev(pTargetDev1);
1410     PMPrintOCProvisionDev(pTargetDev2);
1411
1412     // Mark the link status stale
1413     OCStackResult res = PDMSetLinkStale(&pTargetDev1->doxm->deviceID, &pTargetDev2->doxm->deviceID);
1414     if (OC_STACK_OK != res)
1415     {
1416         OIC_LOG(FATAL, TAG, "unable to update DB. Try again.");
1417         return res;
1418     }
1419
1420     UnlinkData_t* unlinkData = (UnlinkData_t*)OICCalloc(1, sizeof(UnlinkData_t));
1421     VERIFY_NON_NULL(TAG, unlinkData, ERROR, OC_STACK_NO_MEMORY);
1422
1423     //Initialize unlink data
1424     unlinkData->ctx = ctx;
1425     unlinkData->unlinkDev = (OCProvisionDev_t*)OICCalloc(2, sizeof(OCProvisionDev_t));
1426     if (NULL == unlinkData->unlinkDev)
1427     {
1428         OIC_LOG(ERROR, TAG, "Memory allocation failed");
1429         res = OC_STACK_NO_MEMORY;
1430         goto error;
1431     }
1432
1433     unlinkData->unlinkRes = (OCProvisionResult_t*)OICCalloc(3, sizeof(OCProvisionResult_t));
1434     if (NULL == unlinkData->unlinkRes)
1435     {
1436         OIC_LOG(ERROR, TAG, "Memory allocation failed");
1437         res = OC_STACK_NO_MEMORY;
1438         goto error;
1439     }
1440
1441     memcpy(&unlinkData->unlinkDev[0], pTargetDev1, sizeof(OCProvisionDev_t));
1442     memcpy(&unlinkData->unlinkDev[1], pTargetDev2, sizeof(OCProvisionDev_t));
1443
1444     unlinkData->numOfResults = 0;
1445     unlinkData->resultCallback = resultCallback;
1446
1447     res = SendDeleteCredentialRequest((void*)unlinkData, &SRPUnlinkDevice1CB,
1448                                        &unlinkData->unlinkDev[1], &unlinkData->unlinkDev[0]);
1449     if (OC_STACK_OK != res)
1450     {
1451         OIC_LOG(ERROR, TAG, "SRPUnlinkDevices : SendDeleteCredentialRequest failed");
1452         goto error;
1453     }
1454
1455     return res;
1456
1457 error:
1458     OIC_LOG(INFO, TAG, "OUT SRPUnlinkDevices");
1459     DeleteUnlinkData_t(unlinkData);
1460     return res;
1461 }
1462
1463 static void DeleteRemoveData_t(RemoveData_t* pRemoveData)
1464 {
1465     if (pRemoveData)
1466     {
1467         OICFree(pRemoveData->revokeTargetDev);
1468         OCDeleteDiscoveredDevices(pRemoveData->linkedDevList);
1469         OICFree(pRemoveData->removeRes);
1470         OICFree(pRemoveData);
1471     }
1472 }
1473
1474 static void registerResultForRemoveDevice(RemoveData_t *removeData, OicUuid_t *pLinkedDevId,
1475                                           OCStackResult stackresult, bool hasError)
1476 {
1477     OIC_LOG_V(INFO, TAG, "Inside registerResultForRemoveDevice removeData->numOfResults is %zu\n",
1478                          removeData->numOfResults + 1);
1479     if (pLinkedDevId)
1480     {
1481         memcpy(removeData->removeRes[(removeData->numOfResults)].deviceId.id,
1482                &pLinkedDevId->id, sizeof(pLinkedDevId->id));
1483     }
1484     else
1485     {
1486         memset(removeData->removeRes[(removeData->numOfResults)].deviceId.id,
1487                0, sizeof(pLinkedDevId->id) );
1488     }
1489     removeData->removeRes[(removeData->numOfResults)].res = stackresult;
1490     removeData->hasError = hasError;
1491     ++(removeData->numOfResults);
1492
1493     // If we get suffcient result from linked devices, we have to call user callback and do free
1494     if (removeData->sizeOfResArray == removeData->numOfResults)
1495     {
1496         if(!removeData->hasError)
1497         {
1498             // Remove device info from prvisioning database
1499             if (OC_STACK_OK != PDMDeleteDevice(&removeData->revokeTargetDev->doxm->deviceID))
1500             {
1501                 OIC_LOG(ERROR, TAG, "ResultForRemoveDevice : Failed to remove device in PDM.");
1502                 removeData->hasError = true;
1503             }
1504         }
1505         removeData->resultCallback(removeData->ctx, removeData->numOfResults, removeData->removeRes,
1506                                    removeData->hasError);
1507         DeleteRemoveData_t(removeData);
1508     }
1509  }
1510
1511 static void registerResultForResetDevice(RemoveData_t *removeData, OicUuid_t *pLinkedDevId,
1512                                           OCStackResult stackresult, bool hasError)
1513 {
1514     OIC_LOG_V(INFO, TAG, "Inside registerResultForResetDevice removeData->numOfResults is %zu\n",
1515                          removeData->numOfResults + 1);
1516     if (pLinkedDevId)
1517     {
1518         memcpy(removeData->removeRes[(removeData->numOfResults)].deviceId.id,
1519                &pLinkedDevId->id, sizeof(pLinkedDevId->id));
1520     }
1521     else
1522     {
1523         memset(removeData->removeRes[(removeData->numOfResults)].deviceId.id,
1524                0, sizeof(pLinkedDevId->id) );
1525     }
1526     removeData->removeRes[(removeData->numOfResults)].res = stackresult;
1527     removeData->hasError = hasError;
1528     ++(removeData->numOfResults);
1529
1530     // If we get suffcient result from linked devices, we have to call user callback and do free
1531     if (removeData->sizeOfResArray == removeData->numOfResults)
1532     {
1533         removeData->resultCallback(removeData->ctx, removeData->numOfResults, removeData->removeRes,
1534                                    removeData->hasError);
1535         DeleteRemoveData_t(removeData);
1536     }
1537 }
1538
1539 /**
1540  * Callback handler of unlink first device.
1541  *
1542  * @param[in] ctx             ctx value passed to callback from calling function.
1543  * @param[in] handle          handle to an invocation
1544  * @param[in] clientResponse  Response from queries to remote servers.
1545  * @return  OC_STACK_DELETE_TRANSACTION to delete the transaction
1546  *          and  OC_STACK_KEEP_TRANSACTION to keep it.
1547  */
1548 static OCStackApplicationResult SRPRemoveDeviceCB(void *delDevCtx, OCDoHandle handle,
1549         OCClientResponse *clientResponse)
1550 {
1551     //Update the delete credential into delete device context
1552     //Save the deleted status in delDevCtx
1553     (void)handle;
1554     OIC_LOG_V(INFO, TAG, "Inside SRPRemoveDeviceCB.");
1555     VERIFY_NON_NULL(TAG, delDevCtx, ERROR, OC_STACK_DELETE_TRANSACTION);
1556     OCStackResult res = OC_STACK_ERROR;
1557
1558     RemoveData_t* removeData = (RemoveData_t*)delDevCtx;
1559
1560     if (clientResponse)
1561     {
1562         OicUuid_t revDevUuid = {.id={0}};
1563         if(UUID_LENGTH == clientResponse->identity.id_length)
1564         {
1565             memcpy(revDevUuid.id, clientResponse->identity.id, sizeof(revDevUuid.id));
1566             if (OC_STACK_RESOURCE_DELETED == clientResponse->result)
1567             {
1568                 res = PDMUnlinkDevices(&removeData->revokeTargetDev->doxm->deviceID, &revDevUuid);
1569                 if (OC_STACK_OK != res)
1570                 {
1571                     OIC_LOG(ERROR, TAG, "PDMSetLinkStale() FAIL: PDB is an obsolete one.");
1572                            registerResultForRemoveDevice(removeData, &revDevUuid,
1573                            OC_STACK_INCONSISTENT_DB, true);
1574
1575                     return OC_STACK_DELETE_TRANSACTION;
1576                 }
1577
1578                 registerResultForRemoveDevice(removeData, &revDevUuid,
1579                                               OC_STACK_RESOURCE_DELETED, false);
1580             }
1581             else
1582             {
1583                 registerResultForRemoveDevice(removeData, &revDevUuid,
1584                                               clientResponse->result, true);
1585                 OIC_LOG(ERROR, TAG, "Unexpected result from DELETE credential request!");
1586             }
1587         }
1588         else
1589         {
1590             OIC_LOG_V(WARNING, TAG, "Incorrect length of device UUID was sent from %s:%d",
1591                      clientResponse->devAddr.addr, clientResponse->devAddr.port);
1592
1593             if (OC_STACK_RESOURCE_DELETED == clientResponse->result)
1594             {
1595                 /**
1596                   * Since server's credential was deleted,
1597                   * register result as OC_STACK_INCONSISTENT_DB with NULL UUID.
1598                   */
1599                 OIC_LOG_V(ERROR, TAG, "But server's credential was deleted.");
1600                 registerResultForRemoveDevice(removeData, NULL, OC_STACK_INCONSISTENT_DB, true);
1601             }
1602             else
1603             {
1604                 registerResultForRemoveDevice(removeData, NULL, clientResponse->result, true);
1605             }
1606         }
1607     }
1608     else
1609     {
1610         registerResultForRemoveDevice(removeData, NULL, OC_STACK_ERROR, true);
1611         OIC_LOG(ERROR, TAG, "SRPRemoveDevices received Null clientResponse");
1612     }
1613
1614
1615     return OC_STACK_DELETE_TRANSACTION;
1616 }
1617
1618 /**
1619  * Callback handler of reset device.
1620  *
1621  * @param[in] ctx             ctx value passed to callback from calling function.
1622  * @param[in] handle          handle to an invocation
1623  * @param[in] clientResponse  Response from queries to remote servers.
1624  * @return  OC_STACK_DELETE_TRANSACTION to delete the transaction
1625  *          and  OC_STACK_KEEP_TRANSACTION to keep it.
1626  */
1627 static OCStackApplicationResult SRPSyncDeviceCredCB(void *delDevCtx, OCDoHandle handle,
1628         OCClientResponse *clientResponse)
1629 {
1630     //Update the delete credential into delete device context
1631     //Save the deleted status in delDevCtx
1632     (void)handle;
1633     OIC_LOG_V(INFO, TAG, "Inside SRPSyncDeviceCredCB.");
1634     VERIFY_NON_NULL(TAG, delDevCtx, ERROR, OC_STACK_DELETE_TRANSACTION);
1635     OCStackResult res = OC_STACK_ERROR;
1636
1637     RemoveData_t* removeData = (RemoveData_t*)delDevCtx;
1638     OCProvisionDev_t * pTargetDev = PMCloneOCProvisionDev(removeData->revokeTargetDev);
1639     OCProvisionResultCB resultCallback = removeData->resultCallback;
1640     if (clientResponse)
1641     {
1642         OicUuid_t revDevUuid = {.id={0}};
1643         if(UUID_LENGTH == clientResponse->identity.id_length)
1644         {
1645             memcpy(revDevUuid.id, clientResponse->identity.id, sizeof(revDevUuid.id));
1646             if (OC_STACK_RESOURCE_DELETED == clientResponse->result)
1647             {
1648                 res = PDMUnlinkDevices(&removeData->revokeTargetDev->doxm->deviceID, &revDevUuid);
1649                 if (OC_STACK_OK != res)
1650                 {
1651                     OIC_LOG(ERROR, TAG, "PDMSetLinkStale() FAIL: PDB is an obsolete one.");
1652                            registerResultForResetDevice(removeData, &revDevUuid,
1653                            OC_STACK_INCONSISTENT_DB, true);
1654
1655                     return OC_STACK_DELETE_TRANSACTION;
1656                 }
1657
1658                 registerResultForResetDevice(removeData, &revDevUuid,
1659                                               OC_STACK_RESOURCE_DELETED, false);
1660             }
1661             else
1662             {
1663                 registerResultForResetDevice(removeData, &revDevUuid,
1664                                               clientResponse->result, false);
1665                 OIC_LOG(ERROR, TAG, "Unexpected result from DELETE credential request!");
1666             }
1667         }
1668         else
1669         {
1670             OIC_LOG_V(WARNING, TAG, "Incorrect length of device UUID was sent from %s:%d",
1671                      clientResponse->devAddr.addr, clientResponse->devAddr.port);
1672
1673             if (OC_STACK_RESOURCE_DELETED == clientResponse->result)
1674             {
1675                 /**
1676                   * Since server's credential was deleted,
1677                   * register result as OC_STACK_INCONSISTENT_DB with NULL UUID.
1678                   */
1679                 OIC_LOG_V(ERROR, TAG, "But server's credential was deleted.");
1680                 registerResultForResetDevice(removeData, NULL, OC_STACK_INCONSISTENT_DB, true);
1681             }
1682             else
1683             {
1684                 registerResultForResetDevice(removeData, NULL, clientResponse->result, true);
1685             }
1686         }
1687     }
1688     else
1689     {
1690         registerResultForResetDevice(removeData, NULL, OC_STACK_ERROR, true);
1691         OIC_LOG(ERROR, TAG, "SRPSyncDevice received Null clientResponse");
1692     }
1693
1694     SRPResetDevice(pTargetDev, resultCallback);
1695
1696     return OC_STACK_DELETE_TRANSACTION;
1697 }
1698
1699 /**
1700  * Callback handler of reset device sync-up
1701  *
1702  * @param[in] ctx             ctx value passed to callback from calling function.
1703  * @param[in] handle          handle to an invocation
1704  * @param[in] clientResponse  Response from queries to remote servers.
1705  * @return  OC_STACK_DELETE_TRANSACTION to delete the transaction
1706  *          and  OC_STACK_KEEP_TRANSACTION to keep it.
1707  */
1708 static OCStackApplicationResult SRPSyncDeviceACLCB(void *ctx, OCDoHandle handle,
1709         OCClientResponse *clientResponse)
1710 {
1711     return OC_STACK_DELETE_TRANSACTION;
1712 }
1713
1714 /**
1715  * Callback handler of device remote reset.
1716  *
1717  * @param[in] ctx             ctx value passed to callback from calling function.
1718  * @param[in] handle          handle to an invocation
1719  * @param[in] clientResponse  Response from queries to remote servers.
1720  * @return  OC_STACK_DELETE_TRANSACTION to delete the transaction
1721  *          and  OC_STACK_KEEP_TRANSACTION to keep it.
1722  */
1723 static OCStackApplicationResult SRPResetDeviceCB(void *ctx, OCDoHandle handle,
1724         OCClientResponse *clientResponse)
1725 {
1726     OIC_LOG(DEBUG, TAG, "IN SRPResetDeviceCB");
1727     if(OC_STACK_OK == clientResponse->result)
1728     {
1729         OIC_LOG(DEBUG, TAG, "Change Target Device Pstat Cm SUCCEEDED");
1730     }
1731
1732     // Delete Cred and ACL related to the target device.
1733     const OicSecCred_t *cred = NULL;
1734     OCProvisionDev_t * pTargetDev = (OCProvisionDev_t *)ctx;
1735     cred = GetCredResourceData(&pTargetDev->doxm->deviceID);
1736     if (cred == NULL)
1737     {
1738         OIC_LOG(ERROR, TAG, "OCResetDevice : Failed to get credential of target device.");
1739         goto error;
1740     }
1741
1742     OCStackResult res = RemoveCredential(&cred->subject);
1743     if (res != OC_STACK_RESOURCE_DELETED && res != OC_STACK_NO_RESOURCE)
1744     {
1745         OIC_LOG(ERROR, TAG, "OCResetDevice : Failed to remove credential.");
1746         goto error;
1747     }
1748
1749     res = RemoveACE(&cred->subject, NULL);
1750     if (res != OC_STACK_RESOURCE_DELETED && res != OC_STACK_NO_RESOURCE)
1751     {
1752         OIC_LOG(ERROR, TAG, "OCResetDevice : Failed to remove ACL.");
1753         goto error;
1754     }
1755     if (OC_STACK_OK != PDMDeleteDevice(&pTargetDev->doxm->deviceID))
1756     {
1757         OIC_LOG(ERROR, TAG, "OCResetDevice : Failed to delete device from PDM");
1758     }
1759
1760     //Close the DTLS session of the reset device.
1761     CAEndpoint_t* endpoint = (CAEndpoint_t *)&clientResponse->devAddr;
1762     CAResult_t caResult = CACloseDtlsSession(endpoint);
1763     if(CA_STATUS_OK != caResult)
1764     {
1765         OIC_LOG_V(WARNING, TAG, "OCResetDevice : Failed to close DTLS session : %d", caResult);
1766     }
1767
1768     /**
1769      * If there is no linked device, PM does not send any request.
1770      * So we should directly invoke the result callback to inform the result of OCResetDevice.
1771      */
1772     if(OC_STACK_NO_RESOURCE == res)
1773     {
1774         res = OC_STACK_OK;
1775     }
1776
1777 error:
1778     OICFree(pTargetDev);
1779     return OC_STACK_DELETE_TRANSACTION;
1780
1781 }
1782
1783 static OCStackResult GetListofDevToReqDeleteCred(const OCProvisionDev_t* pRevokeTargetDev,
1784                                                  OCProvisionDev_t* pOwnedDevList,
1785                                                  OCUuidList_t* pLinkedUuidList,
1786                                                  OCProvisionDev_t** ppLinkedDevList,
1787                                                  size_t *numOfLinkedDev)
1788 {
1789     // pOwnedDevList could be NULL. It means no alived and owned device now.
1790     if (pRevokeTargetDev == NULL || pLinkedUuidList == NULL ||\
1791         ppLinkedDevList == NULL || numOfLinkedDev == NULL)
1792     {
1793         return OC_STACK_INVALID_PARAM;
1794     }
1795
1796     size_t cnt = 0;
1797     OCUuidList_t *curUuid = NULL, *tmpUuid = NULL;
1798     LL_FOREACH_SAFE(pLinkedUuidList, curUuid, tmpUuid)
1799     {
1800         // Mark the link status stale.
1801         OCStackResult res = PDMSetLinkStale(&curUuid->dev, &pRevokeTargetDev->doxm->deviceID);
1802         if (OC_STACK_OK != res)
1803         {
1804             OIC_LOG(FATAL, TAG, "PDMSetLinkStale() FAIL: PDB is an obsolete one.");
1805             return OC_STACK_INCONSISTENT_DB;
1806         }
1807
1808         if (pOwnedDevList)
1809         {
1810             // If this linked device is alive (power-on), add the deivce to the list.
1811             OCProvisionDev_t *curDev = NULL, *tmpDev = NULL;
1812             LL_FOREACH_SAFE(pOwnedDevList, curDev, tmpDev)
1813             {
1814                 if (memcmp(curDev->doxm->deviceID.id, curUuid->dev.id, sizeof(curUuid->dev.id)) == 0)
1815                 {
1816                     OCProvisionDev_t* targetDev = PMCloneOCProvisionDev(curDev);
1817                     if (NULL == targetDev)
1818                     {
1819                         OIC_LOG(ERROR, TAG, "SRPRemoveDevice : Cloning OCProvisionDev_t Failed.");
1820                         return OC_STACK_NO_MEMORY;
1821                     }
1822
1823                     LL_PREPEND(*ppLinkedDevList, targetDev);
1824                     cnt++;
1825                     break;
1826                 }
1827             }
1828         }
1829     }
1830     *numOfLinkedDev = cnt;
1831     return OC_STACK_OK;
1832 }
1833
1834 /*
1835 * Function to device revocation
1836 * This function will remove credential of target device from all devices in subnet.
1837 *
1838 * @param[in] ctx Application context would be returned in result callback
1839 * @param[in] waitTimeForOwnedDeviceDiscovery Maximum wait time for owned device discovery.(seconds)
1840 * @param[in] pTargetDev Device information to be revoked.
1841 * @param[in] resultCallback callback provided by API user, callback will be called when
1842 *            credential revocation is finished.
1843 * @return  OC_STACK_OK in case of success and other value otherwise.
1844 *          If OC_STACK_OK is returned, the caller of this API should wait for callback.
1845 *          OC_STACK_CONTINUE means operation is success but no request is need to be initiated.
1846 */
1847 OCStackResult SRPRemoveDevice(void* ctx, unsigned short waitTimeForOwnedDeviceDiscovery,
1848                              const OCProvisionDev_t* pTargetDev, OCProvisionResultCB resultCallback)
1849 {
1850     OIC_LOG(INFO, TAG, "IN SRPRemoveDevice");
1851
1852     if (!pTargetDev  || 0 == waitTimeForOwnedDeviceDiscovery)
1853     {
1854         OIC_LOG(INFO, TAG, "SRPRemoveDevice : NULL parameters");
1855         return OC_STACK_INVALID_PARAM;
1856     }
1857     if (!resultCallback)
1858     {
1859         OIC_LOG(INFO, TAG, "SRPRemoveDevice : NULL Callback");
1860         return OC_STACK_INVALID_CALLBACK;
1861     }
1862
1863     // Declare variables in here to handle error cases with goto statement.
1864     OCProvisionDev_t* pOwnedDevList = NULL;
1865     OCProvisionDev_t* pLinkedDevList = NULL;
1866     RemoveData_t* removeData = NULL;
1867
1868     //1. Find all devices that has a credential of the revoked device
1869     OCUuidList_t* pLinkedUuidList = NULL;
1870     size_t numOfDevices = 0;
1871     OCStackResult res = OC_STACK_ERROR;
1872     res = PDMGetLinkedDevices(&pTargetDev->doxm->deviceID, &pLinkedUuidList, &numOfDevices);
1873     if (OC_STACK_OK != res)
1874     {
1875         OIC_LOG(ERROR, TAG, "SRPRemoveDevice : Failed to get linked devices information");
1876         return res;
1877     }
1878     // if there is no related device, we can skip further process.
1879     if (0 == numOfDevices)
1880     {
1881         OIC_LOG(DEBUG, TAG, "SRPRemoveDevice : No linked device found.");
1882         res = OC_STACK_CONTINUE;
1883         goto error;
1884     }
1885
1886     //2. Find owned device from the network
1887     res = PMDeviceDiscovery(waitTimeForOwnedDeviceDiscovery, true, &pOwnedDevList);
1888     if (OC_STACK_OK != res)
1889     {
1890         OIC_LOG(ERROR, TAG, "SRPRemoveDevice : Failed to PMDeviceDiscovery");
1891         goto error;
1892     }
1893
1894     //3. Make a list of devices to send DELETE credential request
1895     //   by comparing owned devices from provisioning database with mutlicast discovery result.
1896     size_t numOfLinkedDev = 0;
1897     res = GetListofDevToReqDeleteCred(pTargetDev, pOwnedDevList, pLinkedUuidList,
1898                                       &pLinkedDevList, &numOfLinkedDev);
1899     if (OC_STACK_OK != res)
1900     {
1901         OIC_LOG(ERROR, TAG, "SRPRemoveDevice : GetListofDevToReqDeleteCred() failed");
1902         goto error;
1903     }
1904     if (0 == numOfLinkedDev) // This case means, there is linked device but it's not alive now.
1905     {                       // So we don't have to send request message.
1906         OIC_LOG(DEBUG, TAG, "SRPRemoveDevice : No alived & linked device found.");
1907         res = OC_STACK_CONTINUE;
1908         goto error;
1909     }
1910
1911     // 4. Prepare RemoveData Context data.
1912     removeData = (RemoveData_t*)OICCalloc(1, sizeof(RemoveData_t));
1913     if (!removeData)
1914     {
1915         OIC_LOG(ERROR, TAG, "SRPRemoveDevices : Failed to memory allocation");
1916         res = OC_STACK_NO_MEMORY;
1917         goto error;
1918     }
1919
1920     removeData->revokeTargetDev = PMCloneOCProvisionDev(pTargetDev);
1921     if (!removeData->revokeTargetDev)
1922     {
1923         OIC_LOG(ERROR, TAG, "SRPRemoveDevices : PMCloneOCProvisionDev Failed");
1924         res = OC_STACK_NO_MEMORY;
1925         goto error;
1926     }
1927
1928     removeData->removeRes =
1929         (OCProvisionResult_t*)OICCalloc(numOfLinkedDev, sizeof(OCProvisionResult_t));
1930     if (!removeData->removeRes)
1931     {
1932         OIC_LOG(ERROR, TAG, "SRPRemoveDevices : Failed to memory allocation");
1933         res = OC_STACK_NO_MEMORY;
1934         goto error;
1935     }
1936
1937     removeData->ctx = ctx;
1938     removeData->linkedDevList = pLinkedDevList;
1939     removeData->resultCallback = resultCallback;
1940     removeData->numOfResults = 0;
1941     removeData->sizeOfResArray = numOfLinkedDev;
1942     removeData->hasError = false;
1943
1944     // 5. Send DELETE credential request to linked devices.
1945     OCProvisionDev_t *curDev = NULL, *tmpDev = NULL;
1946     OCStackResult totalRes = OC_STACK_ERROR;  /* variable for checking request is sent or not */
1947     LL_FOREACH_SAFE(pLinkedDevList, curDev, tmpDev)
1948     {
1949         res = SendDeleteCredentialRequest((void*)removeData, &SRPRemoveDeviceCB,
1950                                            removeData->revokeTargetDev, curDev);
1951         if (OC_STACK_OK != res)
1952         {
1953             OIC_LOG_V(ERROR, TAG, "SRPRemoveDevice : Fail to send the DELETE credential request to\
1954                      %s:%u", curDev->endpoint.addr, curDev->endpoint.port);
1955         }
1956         else
1957         {
1958             totalRes = OC_STACK_OK; // This means at least one request is successfully sent.
1959         }
1960     }
1961
1962     PDMDestoryOicUuidLinkList(pLinkedUuidList); //TODO: Modify API name to have unified convention.
1963     PMDeleteDeviceList(pOwnedDevList);
1964     OIC_LOG(INFO, TAG, "OUT SRPRemoveDevice");
1965
1966     return totalRes; // Caller of this API should wait callback if totalRes == OC_STACK_OK.
1967
1968 error:
1969     PDMDestoryOicUuidLinkList(pLinkedUuidList);
1970     PMDeleteDeviceList(pOwnedDevList);
1971     PMDeleteDeviceList(pLinkedDevList);
1972     if (removeData)
1973     {
1974         OICFree(removeData->revokeTargetDev);
1975         OICFree(removeData->removeRes);
1976         OICFree(removeData);
1977     }
1978     OIC_LOG(INFO, TAG, "OUT ERROR case SRPRemoveDevice");
1979     return res;
1980 }
1981
1982 /*
1983  * Function to sync-up credential and ACL of the target device.
1984  * This function will remove credential and ACL of target device from all devices in subnet.
1985  *
1986  * @param[in] ctx Application context would be returned in result callback
1987  * @param[in] waitTimeForOwnedDeviceDiscovery Maximum wait time for owned device discovery.(seconds)
1988  * @param[in] pTargetDev Device information to be revoked.
1989  * @param[in] resultCallback callback provided by API user, callback will be called when
1990  *            credential revocation is finished.
1991  *            when there is an error, this user callback is called immediately.
1992  * @return OC_STACK_OK in case of success and other value otherwise.
1993  *         If OC_STACK_OK is returned, the caller of this API should wait for callback.
1994  *         OC_STACK_CONTINUE means operation is success but no request is need to be initiated.
1995  */
1996 OCStackResult SRPSyncDevice(void* ctx, unsigned short waitTimeForOwnedDeviceDiscovery,
1997                          const OCProvisionDev_t* pTargetDev, OCProvisionResultCB resultCallback)
1998 {
1999     OIC_LOG(INFO, TAG, "IN SRPSyncDevice");
2000     if (!pTargetDev  || 0 == waitTimeForOwnedDeviceDiscovery)
2001     {
2002         OIC_LOG(INFO, TAG, "SRPSyncDevice : NULL parameters");
2003         return OC_STACK_INVALID_PARAM;
2004     }
2005     if (!resultCallback)
2006     {
2007         OIC_LOG(INFO, TAG, "SRPSyncDevice : NULL Callback");
2008         return OC_STACK_INVALID_CALLBACK;
2009     }
2010
2011     // Declare variables in here to handle error cases with goto statement.
2012     OCProvisionDev_t* pOwnedDevList = NULL;
2013     OCProvisionDev_t* pLinkedDevList = NULL;
2014     RemoveData_t* removeData = NULL;
2015
2016     //1. Find all devices that has a credential of the revoked device
2017     OCUuidList_t* pLinkedUuidList = NULL;
2018     size_t numOfDevices = 0;
2019     OCStackResult res = OC_STACK_ERROR;
2020     res = PDMGetLinkedDevices(&pTargetDev->doxm->deviceID, &pLinkedUuidList, &numOfDevices);
2021     if (OC_STACK_OK != res)
2022     {
2023         OIC_LOG(ERROR, TAG, "SRPSyncDevice : Failed to get linked devices information");
2024         return res;
2025     }
2026     // if there is no related device, we can skip further process.
2027     if (0 == numOfDevices)
2028     {
2029         OIC_LOG(DEBUG, TAG, "SRPSyncDevice : No linked device found.");
2030         res = OC_STACK_CONTINUE;
2031         goto error;
2032     }
2033
2034     //2. Find owned device from the network
2035     res = PMDeviceDiscovery(waitTimeForOwnedDeviceDiscovery, true, &pOwnedDevList);
2036     if (OC_STACK_OK != res)
2037     {
2038         OIC_LOG(ERROR, TAG, "SRPSyncDevice : Failed to PMDeviceDiscovery");
2039         goto error;
2040     }
2041
2042     //3. Make a list of devices to send DELETE credential request
2043     //   by comparing owned devices from provisioning database with mutlicast discovery result.
2044     size_t numOfLinkedDev = 0;
2045     res = GetListofDevToReqDeleteCred(pTargetDev, pOwnedDevList, pLinkedUuidList,
2046                                       &pLinkedDevList, &numOfLinkedDev);
2047     if (OC_STACK_OK != res)
2048     {
2049         OIC_LOG(ERROR, TAG, "SRPSyncDevice : GetListofDevToReqDeleteCred() failed");
2050         goto error;
2051     }
2052     if (0 == numOfLinkedDev) // This case means, there is linked device but it's not alive now.
2053     {                       // So we don't have to send request message.
2054         OIC_LOG(DEBUG, TAG, "SRPSyncDevice : No alived & linked device found.");
2055         res = OC_STACK_CONTINUE;
2056         goto error;
2057     }
2058
2059     // 4. Prepare RemoveData Context data.
2060     removeData = (RemoveData_t*)OICCalloc(1, sizeof(RemoveData_t));
2061     if (!removeData)
2062     {
2063         OIC_LOG(ERROR, TAG, "SRPSyncDevice : Failed to memory allocation");
2064         res = OC_STACK_NO_MEMORY;
2065         goto error;
2066     }
2067
2068     removeData->revokeTargetDev = PMCloneOCProvisionDev(pTargetDev);
2069     if (!removeData->revokeTargetDev)
2070     {
2071         OIC_LOG(ERROR, TAG, "SRPSyncDevice : PMCloneOCProvisionDev Failed");
2072         res = OC_STACK_NO_MEMORY;
2073         goto error;
2074     }
2075
2076     removeData->removeRes =
2077         (OCProvisionResult_t*)OICCalloc(numOfLinkedDev, sizeof(OCProvisionResult_t));
2078     if (!removeData->removeRes)
2079     {
2080         OIC_LOG(ERROR, TAG, "SRPSyncDevice : Failed to allocate memory");
2081         res = OC_STACK_NO_MEMORY;
2082         goto error;
2083     }
2084
2085     removeData->ctx = ctx;
2086     removeData->linkedDevList = pLinkedDevList;
2087     removeData->resultCallback = resultCallback;
2088     removeData->numOfResults = 0;
2089     removeData->sizeOfResArray = numOfLinkedDev;
2090     removeData->hasError = false;
2091
2092     // 5. Send DELETE credential request to linked devices.
2093     OCProvisionDev_t *curDev = NULL, *tmpDev = NULL;
2094     OCStackResult totalRes = OC_STACK_ERROR;  /* variable for checking request is sent or not */
2095     LL_FOREACH_SAFE(pLinkedDevList, curDev, tmpDev)
2096     {
2097         res = SendDeleteACLRequest((void*)removeData, &SRPSyncDeviceACLCB,
2098                                            removeData->revokeTargetDev, curDev);
2099         if (OC_STACK_OK != res)
2100         {
2101             OIC_LOG_V(ERROR, TAG, "SRPSyncDevice : Fail to send the DELETE ACL request to\
2102                      %s:%u", curDev->endpoint.addr, curDev->endpoint.port);
2103             goto error;
2104         }
2105         res = SendDeleteCredentialRequest((void*)removeData, &SRPSyncDeviceCredCB,
2106                                            removeData->revokeTargetDev, curDev);
2107         if (OC_STACK_OK != res)
2108         {
2109             OIC_LOG_V(ERROR, TAG, "SRPSyncDevice : Fail to send the DELETE credential request to\
2110                      %s:%u", curDev->endpoint.addr, curDev->endpoint.port);
2111             totalRes = OC_STACK_ERROR;
2112         }
2113         else
2114         {
2115             totalRes = OC_STACK_OK; // This means at least one request is successfully sent.
2116         }
2117     }
2118
2119     PDMDestoryOicUuidLinkList(pLinkedUuidList); //TODO: Modify API name to have unified convention.
2120     PMDeleteDeviceList(pOwnedDevList);
2121     OIC_LOG(INFO, TAG, "OUT SRPSyncDevice");
2122
2123     return totalRes; // Caller of this API should wait callback if totalRes == OC_STACK_OK.
2124
2125 error:
2126     PDMDestoryOicUuidLinkList(pLinkedUuidList);
2127     PMDeleteDeviceList(pOwnedDevList);
2128     PMDeleteDeviceList(pLinkedDevList);
2129     if (removeData)
2130     {
2131         OICFree(removeData->revokeTargetDev);
2132         OICFree(removeData->removeRes);
2133         OICFree(removeData);
2134     }
2135     OIC_LOG(INFO, TAG, "OUT ERROR case SRPSyncDevice");
2136     return res;
2137 }
2138
2139 /*
2140  * Function for remote reset
2141  * This function will send pstat PUT message to the target device to initiate remote reset.
2142  *
2143  * @param[in] pTargetDev Device information to be revoked.
2144  * @param[in] resultCallback callback provided by API user, callback will be called when
2145  *            credential revocation is finished.
2146  *            when there is an error, this user callback is called immediately.
2147  * @return OC_STACK_OK in case of success and other value otherwise.
2148  *         If OC_STACK_OK is returned, the caller of this API should wait for callback.
2149  *         OC_STACK_CONTINUE means operation is success but no request is need to be initiated.
2150  */
2151 OCStackResult SRPResetDevice(const OCProvisionDev_t* pTargetDev,
2152         OCProvisionResultCB resultCallback)
2153 {
2154     OIC_LOG(INFO, TAG, "IN SRPResetDevice");
2155     if (!pTargetDev)
2156     {
2157         OIC_LOG(INFO, TAG, "SRPResetDevice : NULL parameters");
2158         return OC_STACK_INVALID_PARAM;
2159     }
2160     if (!resultCallback)
2161     {
2162         OIC_LOG(INFO, TAG, "SRPResetDevice : NULL Callback");
2163         return OC_STACK_INVALID_CALLBACK;
2164     }
2165
2166     OCStackResult res = OC_STACK_ERROR;
2167     OicSecPstat_t * pstat = (OicSecPstat_t *) OICCalloc(1, sizeof(OicSecPstat_t));
2168     if (!pstat)
2169     {
2170         OIC_LOG(ERROR, TAG, "Failed to allocate memory");
2171         return OC_STACK_NO_MEMORY;
2172     }
2173
2174     pstat->cm = (OicSecDpm_t) 1;
2175     pstat->isOp = 0;
2176     memcpy(pstat->deviceID.id, pTargetDev->doxm->deviceID.id, sizeof(OicUuid_t));
2177     pstat->tm = (OicSecDpm_t) 2;
2178     pstat->om = (OicSecDpom_t) 0;
2179     pstat->smLen = 1;
2180     pstat->sm = (OicSecDpom_t *) OICCalloc(pstat->smLen, sizeof(OicSecDpom_t));
2181     if (NULL == pstat->sm)
2182     {
2183         OIC_LOG(ERROR, TAG, "Failed to allocate memory");
2184         OICFree(pstat);
2185         return OC_STACK_NO_MEMORY;
2186     }
2187     pstat->sm[0] = (OicSecDpom_t) 3;
2188
2189     OCSecurityPayload * secPayload = (OCSecurityPayload *) OICCalloc(1, sizeof(OCSecurityPayload));
2190     if (!secPayload)
2191     {
2192         OIC_LOG(ERROR, TAG, "Failed to allocate memory");
2193         res = OC_STACK_NO_MEMORY;
2194         goto error;
2195     }
2196     secPayload->base.type = PAYLOAD_TYPE_SECURITY;
2197
2198     if (OC_STACK_OK != PstatToCBORPayload(pstat, &(secPayload->securityData),
2199                 &(secPayload->payloadSize)))
2200     {
2201         OCPayloadDestroy((OCPayload *) secPayload);
2202         OIC_LOG(ERROR, TAG, "Failed to PstatToCBORPayload");
2203         res = OC_STACK_NO_MEMORY;
2204         goto error;
2205     }
2206     OIC_LOG(DEBUG, TAG, "Created payload for pstat set");
2207     OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize);
2208
2209     char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
2210     if (!PMGenerateQuery(true,
2211                 pTargetDev->endpoint.addr,
2212                 pTargetDev->securePort,
2213                 pTargetDev->connType,
2214                 query, sizeof(query), OIC_RSRC_PSTAT_URI))
2215     {
2216         OIC_LOG(ERROR, TAG, "SRPResetDevice : Failed to generate query");
2217         OCPayloadDestroy((OCPayload *) secPayload);
2218         res = OC_STACK_ERROR;
2219         goto error;
2220     }
2221     OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
2222
2223     OCProvisionDev_t * targetDev = PMCloneOCProvisionDev(pTargetDev);
2224     OCCallbackData cbData = { .context = NULL, .cb = NULL, .cd = NULL };
2225     cbData.cb = &SRPResetDeviceCB;
2226     cbData.context = (void *) targetDev;
2227     cbData.cd = NULL;
2228     OCMethod method = OC_REST_POST;
2229     OCDoHandle handle = NULL;
2230     OIC_LOG(DEBUG, TAG, "Sending PSTAT info to resource server");
2231     res = OCDoResource(&handle, method, query,
2232             &targetDev->endpoint, (OCPayload *)secPayload,
2233             targetDev->connType, OC_LOW_QOS, &cbData, NULL, 0);\
2234     if (OC_STACK_OK != res)
2235     {
2236         OIC_LOG(ERROR, TAG, "OCStack resource error");
2237     }
2238
2239 error:
2240     OICFree(pstat->sm);
2241     OICFree(pstat);
2242     OIC_LOG(INFO, TAG, "OUT SRPResetDevice");
2243     return res;
2244 }
2245
2246 /**
2247  * Internal Function to store results in result array during GetCredResourceCB.
2248  */
2249 static void registerResultForGetCredResourceCB(GetSecData_t *GetSecData,
2250                                              OCStackResult stackresult)
2251 {
2252    OIC_LOG_V(INFO, TAG, "Inside registerResultForGetCredResourceCB "
2253            "GetSecData->numOfResults is %d\n", GetSecData->numOfResults);
2254    memcpy(GetSecData->resArr[(GetSecData->numOfResults)].deviceId.id,
2255           GetSecData->deviceInfo->doxm->deviceID.id, UUID_LENGTH);
2256    GetSecData->resArr[(GetSecData->numOfResults)].res = stackresult;
2257    ++(GetSecData->numOfResults);
2258 }
2259
2260 /**
2261  * Callback handler of SRPGetCredResource.
2262  *
2263  * @param[in] ctx             ctx value passed to callback from calling function.
2264  * @param[in] UNUSED          handle to an invocation
2265  * @param[in] clientResponse  Response from queries to remote servers.
2266  * @return  OC_STACK_DELETE_TRANSACTION to delete the transaction
2267  *          and  OC_STACK_KEEP_TRANSACTION to keep it.
2268  */
2269 static OCStackApplicationResult SRPGetCredResourceCB(void *ctx, OCDoHandle UNUSED,
2270                                                   OCClientResponse *clientResponse)
2271 {
2272     OIC_LOG_V(INFO, TAG, "Inside SRPGetCredResourceCB.");
2273     (void)UNUSED;
2274     VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
2275     GetSecData_t *GetSecData = (GetSecData_t*)ctx;
2276     OCProvisionResultCB resultCallback = GetSecData->resultCallback;
2277
2278     if (clientResponse)
2279     {
2280         if(OC_STACK_OK == clientResponse->result)
2281         {
2282             uint8_t *payload = ((OCSecurityPayload*)clientResponse->payload)->securityData;
2283             size_t size = ((OCSecurityPayload*)clientResponse->payload)->payloadSize;
2284
2285             OIC_LOG_BUFFER(DEBUG, TAG, payload, size);
2286
2287             registerResultForGetCredResourceCB(GetSecData, OC_STACK_OK);
2288             ((OCProvisionResultCB)(resultCallback))(GetSecData->ctx, GetSecData->numOfResults,
2289                                                     GetSecData->resArr,
2290                                                     false);
2291              OICFree(GetSecData->resArr);
2292              OICFree(GetSecData);
2293
2294             return OC_STACK_DELETE_TRANSACTION;
2295         }
2296     }
2297     registerResultForGetCredResourceCB(GetSecData, OC_STACK_OK);
2298     ((OCProvisionResultCB)(resultCallback))(GetSecData->ctx, GetSecData->numOfResults,
2299                                             GetSecData->resArr,
2300                                             false);
2301     OIC_LOG_V(ERROR, TAG, "SRPGetCredResourceCB received Null clientResponse");
2302     OICFree(GetSecData->resArr);
2303     OICFree(GetSecData);
2304
2305     return OC_STACK_DELETE_TRANSACTION;
2306 }
2307
2308
2309 OCStackResult SRPGetCredResource(void *ctx, const OCProvisionDev_t *selectedDeviceInfo,
2310         OCProvisionResultCB resultCallback)
2311 {
2312     VERIFY_NON_NULL(TAG, selectedDeviceInfo, ERROR,  OC_STACK_INVALID_PARAM);
2313     VERIFY_NON_NULL(TAG, resultCallback, ERROR,  OC_STACK_INVALID_CALLBACK);
2314
2315     char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
2316     if(!PMGenerateQuery(true,
2317                         selectedDeviceInfo->endpoint.addr,
2318                         selectedDeviceInfo->securePort,
2319                         selectedDeviceInfo->connType,
2320                         query, sizeof(query), OIC_RSRC_CRED_URI))
2321     {
2322         OIC_LOG(ERROR, TAG, "SRPGetCredResource : Failed to generate query");
2323         return OC_STACK_ERROR;
2324     }
2325     OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
2326
2327     OCCallbackData cbData =  {.context=NULL, .cb=NULL, .cd=NULL};
2328     cbData.cb = &SRPGetCredResourceCB;
2329     GetSecData_t* GetSecData = (GetSecData_t*)OICCalloc(1, sizeof(GetSecData_t));
2330     if (NULL == GetSecData)
2331     {
2332         OIC_LOG(ERROR, TAG, "Unable to allocate memory");
2333         return OC_STACK_NO_MEMORY;
2334     }
2335     GetSecData->deviceInfo = selectedDeviceInfo;
2336     GetSecData->resultCallback = resultCallback;
2337     GetSecData->numOfResults=0;
2338     GetSecData->ctx = ctx;
2339
2340     int noOfRiCalls = 1;
2341     GetSecData->resArr = (OCProvisionResult_t*)OICCalloc(noOfRiCalls, sizeof(OCProvisionResult_t));
2342     if (NULL == GetSecData->resArr)
2343     {
2344         OICFree(GetSecData);
2345         OIC_LOG(ERROR, TAG, "Unable to allocate memory");
2346         return OC_STACK_NO_MEMORY;
2347     }
2348     cbData.context = (void *)GetSecData;
2349     cbData.cd = NULL;
2350     OCMethod method = OC_REST_GET;
2351     OCDoHandle handle = NULL;
2352     OIC_LOG(DEBUG, TAG, "Sending Get Cred to  resource server");
2353     OCStackResult ret = OCDoResource(&handle, method, query, NULL, NULL,
2354             selectedDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
2355     if (OC_STACK_OK != ret)
2356     {
2357         OIC_LOG(ERROR, TAG, "OCStack resource error");
2358         OICFree(GetSecData->resArr);
2359         OICFree(GetSecData);
2360     }
2361     VERIFY_SUCCESS(TAG, (OC_STACK_OK == ret), ERROR, OC_STACK_ERROR);
2362     OIC_LOG(DEBUG, TAG, "OUT SRPGetCredResource");
2363
2364     return OC_STACK_OK;
2365 }
2366
2367 /**
2368  * Internal Function to store results in result array during GetACLResourceCB.
2369  */
2370 static void registerResultForGetACLResourceCB(GetSecData_t *GetSecData,
2371                                              OCStackResult stackresult)
2372 {
2373    OIC_LOG_V(INFO, TAG, "Inside registerResultForGetACLResourceCB "
2374            "GetSecData->numOfResults is %d\n", GetSecData->numOfResults);
2375    memcpy(GetSecData->resArr[(GetSecData->numOfResults)].deviceId.id,
2376           GetSecData->deviceInfo->doxm->deviceID.id, UUID_LENGTH);
2377    GetSecData->resArr[(GetSecData->numOfResults)].res = stackresult;
2378    ++(GetSecData->numOfResults);
2379 }
2380
2381 /**
2382  * Callback handler of SRPGetACLResource.
2383  *
2384  * @param[in] ctx             ctx value passed to callback from calling function.
2385  * @param[in] UNUSED          handle to an invocation
2386  * @param[in] clientResponse  Response from queries to remote servers.
2387  * @return  OC_STACK_DELETE_TRANSACTION to delete the transaction
2388  *          and  OC_STACK_KEEP_TRANSACTION to keep it.
2389  */
2390 static OCStackApplicationResult SRPGetACLResourceCB(void *ctx, OCDoHandle UNUSED,
2391                                                   OCClientResponse *clientResponse)
2392 {
2393     OIC_LOG_V(INFO, TAG, "Inside SRPGetACLResourceCB.");
2394     (void)UNUSED;
2395     VERIFY_NON_NULL(TAG, ctx, ERROR, OC_STACK_DELETE_TRANSACTION);
2396     GetSecData_t *GetSecData = (GetSecData_t*)ctx;
2397     OCProvisionResultCB resultCallback = GetSecData->resultCallback;
2398
2399     if (clientResponse)
2400     {
2401         if(OC_STACK_OK == clientResponse->result)
2402         {
2403             uint8_t *payload = ((OCSecurityPayload*)clientResponse->payload)->securityData;
2404             size_t size = ((OCSecurityPayload*)clientResponse->payload)->payloadSize;
2405
2406             OIC_LOG_BUFFER(DEBUG, TAG, payload, size);
2407
2408             registerResultForGetACLResourceCB(GetSecData, OC_STACK_OK);
2409             ((OCProvisionResultCB)(resultCallback))(GetSecData->ctx, GetSecData->numOfResults,
2410                                                     GetSecData->resArr,
2411                                                     false);
2412              OICFree(GetSecData->resArr);
2413              OICFree(GetSecData);
2414
2415             return OC_STACK_DELETE_TRANSACTION;
2416         }
2417     }
2418     registerResultForGetACLResourceCB(GetSecData, OC_STACK_OK);
2419     ((OCProvisionResultCB)(resultCallback))(GetSecData->ctx, GetSecData->numOfResults,
2420                                             GetSecData->resArr,
2421                                             false);
2422     OIC_LOG_V(ERROR, TAG, "SRPGetACLResourceCB received Null clientResponse");
2423     OICFree(GetSecData->resArr);
2424     OICFree(GetSecData);
2425
2426     return OC_STACK_DELETE_TRANSACTION;
2427 }
2428
2429
2430 OCStackResult SRPGetACLResource(void *ctx, const OCProvisionDev_t *selectedDeviceInfo,
2431         OCProvisionResultCB resultCallback)
2432 {
2433     VERIFY_NON_NULL(TAG, selectedDeviceInfo, ERROR,  OC_STACK_INVALID_PARAM);
2434     VERIFY_NON_NULL(TAG, resultCallback, ERROR,  OC_STACK_INVALID_CALLBACK);
2435
2436     char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
2437     if(!PMGenerateQuery(true,
2438                         selectedDeviceInfo->endpoint.addr,
2439                         selectedDeviceInfo->securePort,
2440                         selectedDeviceInfo->connType,
2441                         query, sizeof(query), OIC_RSRC_ACL_URI))
2442     {
2443         OIC_LOG(ERROR, TAG, "SRPGetACLResource : Failed to generate query");
2444         return OC_STACK_ERROR;
2445     }
2446     OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
2447
2448     OCCallbackData cbData =  {.context=NULL, .cb=NULL, .cd=NULL};
2449     cbData.cb = &SRPGetACLResourceCB;
2450     GetSecData_t* GetSecData = (GetSecData_t*)OICCalloc(1, sizeof(GetSecData_t));
2451     if (NULL == GetSecData)
2452     {
2453         OIC_LOG(ERROR, TAG, "Unable to allocate memory");
2454         return OC_STACK_NO_MEMORY;
2455     }
2456     GetSecData->deviceInfo = selectedDeviceInfo;
2457     GetSecData->resultCallback = resultCallback;
2458     GetSecData->numOfResults=0;
2459     GetSecData->ctx = ctx;
2460
2461     int noOfRiCalls = 1;
2462     GetSecData->resArr = (OCProvisionResult_t*)OICCalloc(noOfRiCalls, sizeof(OCProvisionResult_t));
2463     if (NULL == GetSecData->resArr)
2464     {
2465         OICFree(GetSecData);
2466         OIC_LOG(ERROR, TAG, "Unable to allocate memory");
2467         return OC_STACK_NO_MEMORY;
2468     }
2469     cbData.context = (void *)GetSecData;
2470     cbData.cd = NULL;
2471     OCMethod method = OC_REST_GET;
2472     OCDoHandle handle = NULL;
2473     OIC_LOG(DEBUG, TAG, "Sending Get ACL to resource server");
2474     OCStackResult ret = OCDoResource(&handle, method, query, NULL, NULL,
2475             selectedDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
2476     if (OC_STACK_OK != ret)
2477     {
2478         OIC_LOG(ERROR, TAG, "OCStack resource error");
2479         OICFree(GetSecData->resArr);
2480         OICFree(GetSecData);
2481     }
2482     VERIFY_SUCCESS(TAG, (OC_STACK_OK == ret), ERROR, OC_STACK_ERROR);
2483     OIC_LOG(DEBUG, TAG, "OUT SRPGetACLResource");
2484
2485     return OC_STACK_OK;
2486 }