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

   1 /* *****************************************************************
   2  *
   3  * Copyright 2016 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
  21 #ifdef HAVE_TIME_H
  22 #include <time.h>
  23 #endif
  24 #ifdef HAVE_UNISTD_H
  25 #include <unistd.h>
  26 #endif
  27 #ifdef HAVE_SYS_TIME_H
  28 #include <sys/time.h>
  29 #endif
  30 #include <stdbool.h>
  31 #include <string.h>
  32
  33 #include "utlist.h"
  34 #include "logger.h"
  35 #include "oic_malloc.h"
  36 #include "oic_string.h"
  37 #include "cacommon.h"
  38 #include "cainterface.h"
  39 #include "base64.h"
  40 #if defined (__TIZENRT__)
  41 #include <apps/netutils/cJSON.h>
  42 #else
  43 #include "cJSON.h"
  44 #endif
  45
  46 #include "srmresourcestrings.h"
  47 #include "doxmresource.h"
  48 #include "pstatresource.h"
  49 #include "credresource.h"
  50 #include "aclresource.h"
  51 #include "ownershiptransfermanager.h"
  52 #include "securevirtualresourcetypes.h"
  53 #include "oxmjustworks.h"
  54 #include "pmtypes.h"
  55 #include "pmutility.h"
  56 #include "srmutility.h"
  57 #include "provisioningdatabasemanager.h"
  58 #include "oxmrandompin.h"
  59 #include "ocpayload.h"
  60 #include "payload_logging.h"
  61 #include "oxmjustworks.h"
  62 #include "oxmpreconfpin.h"
  63 #include "oxmrandompin.h"
  64 #include "otmcontextlist.h"
  65
  66 #define TAG "OIC_MULTIPLE_OTM"
  67
  68 /**********************************************************************
  69  * API for Super Owner
  70  **********************************************************************/
  71
  72 /**
  73  * Callback handler of security resource's POST request.
  74  *
  75  * @param[in] ctx             ctx value passed to callback from calling function.
  76  * @param[in] UNUSED          handle to an invocation
  77  * @param[in] clientResponse  Response from queries to remote servers.
  78  * @return  OC_STACK_DELETE_TRANSACTION to delete the transaction
  79  *          and  OC_STACK_KEEP_TRANSACTION to keep it.
  80  */
  81 static OCStackApplicationResult MOTUpdateSecurityResourceCB(void *ctx, OCDoHandle UNUSED,
  82                                                 OCClientResponse *clientResponse)
  83 {
  84     OIC_LOG_V(INFO, TAG, "In %s", __func__);
  85     (void)UNUSED;
  86     OTMContext_t *motCtx = (OTMContext_t*)ctx;
  87     VERIFY_NON_NULL(TAG, motCtx, ERROR);
  88     VERIFY_NON_NULL(TAG, motCtx->ctxResultCallback, ERROR);
  89     VERIFY_NON_NULL(TAG, motCtx->ctxResultArray, ERROR);
  90
  91     if(clientResponse)
  92     {
  93         memcpy(motCtx->ctxResultArray[0].deviceId.id,
  94                motCtx->selectedDeviceInfo->doxm->deviceID.id,
  95                sizeof(OicUuid_t));
  96         motCtx->ctxResultArray[0].res = clientResponse->result;
  97
  98         if(OC_STACK_RESOURCE_CHANGED == clientResponse->result)
  99         {
 100             motCtx->ctxHasError = false;
 101         }
 102         else
 103         {
 104             motCtx->ctxHasError = true;
 105         }
 106     }
 107     else
 108     {
 109         OIC_LOG_V(ERROR, TAG, "SRPGetACLResourceCB received Null clientResponse");
 110         motCtx->ctxResultArray[0].res = OC_STACK_ERROR;
 111         motCtx->ctxHasError = true;
 112     }
 113
 114     motCtx->ctxResultCallback(motCtx->userCtx, motCtx->ctxResultArraySize,
 115                               motCtx->ctxResultArray, motCtx->ctxHasError);
 116
 117 exit:
 118     if(motCtx)
 119     {
 120         OICFree(motCtx->ctxResultArray);
 121         OICFree(motCtx);
 122     }
 123     OIC_LOG_V(INFO, TAG, "Out %s", __func__);
 124     return OC_STACK_DELETE_TRANSACTION;
 125 }
 126
 127 /**
 128  * Callback handler of security resource's DELETE request.
 129  *
 130  * @param[in] ctx             ctx value passed to callback from calling function.
 131  * @param[in] UNUSED          handle to an invocation
 132  * @param[in] clientResponse  Response from queries to remote servers.
 133  * @return  OC_STACK_DELETE_TRANSACTION to delete the transaction
 134  *          and  OC_STACK_KEEP_TRANSACTION to keep it.
 135  */
 136 static OCStackApplicationResult MOTDeleteSecurityResourceCB(void *ctx, OCDoHandle UNUSED,
 137                                                 OCClientResponse *clientResponse)
 138 {
 139     OIC_LOG_V(INFO, TAG, "In %s", __func__);
 140     (void)UNUSED;
 141     OTMContext_t *motCtx = (OTMContext_t*)ctx;
 142     VERIFY_NON_NULL(TAG, motCtx, ERROR);
 143     VERIFY_NON_NULL(TAG, motCtx->ctxResultCallback, ERROR);
 144     VERIFY_NON_NULL(TAG, motCtx->ctxResultArray, ERROR);
 145
 146     if(clientResponse)
 147     {
 148         memcpy(motCtx->ctxResultArray[0].deviceId.id,
 149                motCtx->selectedDeviceInfo->doxm->deviceID.id,
 150                sizeof(OicUuid_t));
 151         motCtx->ctxResultArray[0].res = clientResponse->result;
 152
 153         if(OC_STACK_RESOURCE_DELETED == clientResponse->result)
 154         {
 155             motCtx->ctxHasError = false;
 156         }
 157         else
 158         {
 159             motCtx->ctxHasError = true;
 160         }
 161     }
 162     else
 163     {
 164         OIC_LOG_V(ERROR, TAG, "SRPGetACLResourceCB received Null clientResponse");
 165         motCtx->ctxResultArray[0].res = OC_STACK_ERROR;
 166         motCtx->ctxHasError = true;
 167     }
 168
 169     motCtx->ctxResultCallback(motCtx->userCtx, motCtx->ctxResultArraySize,
 170                               motCtx->ctxResultArray, motCtx->ctxHasError);
 171
 172 exit:
 173     if(motCtx)
 174     {
 175         OICFree(motCtx->ctxResultArray);
 176         OICFree(motCtx);
 177     }
 178     OIC_LOG_V(INFO, TAG, "Out %s", __func__);
 179
 180     return OC_STACK_DELETE_TRANSACTION;
 181
 182 }
 183
 184 /**
 185  * Internal API to send POST doxm request
 186  */
 187 static OCStackResult MOTSendPostDoxm(void *ctx,
 188                                      const OCProvisionDev_t *targetDeviceInfo,
 189                                      OCProvisionResultCB resultCallback,
 190                                      const OicSecDoxm_t* doxm)
 191 {
 192     OCStackResult postMomRes = OC_STACK_ERROR;
 193     OCSecurityPayload* secPayload = NULL;
 194     OTMContext_t *motCtx = NULL;
 195     bool freeFlag = true;
 196
 197     OIC_LOG_V(DEBUG, TAG, "In %s", __func__);
 198
 199     //Generate the security payload using updated doxm
 200     secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
 201     VERIFY_NON_NULL(TAG, secPayload, ERROR);
 202     secPayload->base.type = PAYLOAD_TYPE_SECURITY;
 203
 204     postMomRes = DoxmToCBORPayload(doxm, &secPayload->securityData, &secPayload->payloadSize, true);
 205     VERIFY_SUCCESS(TAG, (OC_STACK_OK == postMomRes), ERROR);
 206
 207     OIC_LOG(DEBUG, TAG, "Created doxm payload to update doxm:");
 208     OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize);
 209
 210     char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
 211     bool queryGenRes = PMGenerateQuery(true,
 212                                        targetDeviceInfo->endpoint.addr,
 213                                        targetDeviceInfo->securePort,
 214                                        targetDeviceInfo->connType,
 215                                        query, sizeof(query), OIC_RSRC_DOXM_URI);
 216     VERIFY_SUCCESS(TAG, (true == queryGenRes), ERROR);
 217     OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
 218
 219     //Create the MOT Context to handle the response message
 220     motCtx = (OTMContext_t*)OICCalloc(1, sizeof(OTMContext_t));
 221     VERIFY_NON_NULL(TAG, motCtx, ERROR);
 222     motCtx->selectedDeviceInfo = targetDeviceInfo;
 223     motCtx->ctxResultCallback = resultCallback;
 224     motCtx->ctxResultArraySize = 1;
 225     motCtx->ctxHasError = false;
 226     motCtx->userCtx = ctx;
 227     motCtx->ctxResultArray= (OCProvisionResult_t*)OICCalloc(1, sizeof(OCProvisionResult_t));
 228     VERIFY_NON_NULL(TAG, motCtx->ctxResultArray, ERROR);
 229
 230     //Send POST request
 231     OCCallbackData cbData =  {.context=NULL, .cb=NULL, .cd=NULL};
 232     cbData.cb = &MOTUpdateSecurityResourceCB;
 233     cbData.context = (void *)motCtx;
 234     OIC_LOG(DEBUG, TAG, "Sending POST 'doxm' request to resource server");
 235     postMomRes = OCDoResource(NULL, OC_REST_POST, query,
 236                               &targetDeviceInfo->endpoint, (OCPayload*)secPayload,
 237                               targetDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
 238     VERIFY_SUCCESS(TAG, (OC_STACK_OK == postMomRes), ERROR);
 239
 240     freeFlag = false;
 241
 242 exit:
 243     //If POST request successfully sent, motCtx will be cleaned from response handler.
 244     if(freeFlag && motCtx)
 245     {
 246         OICFree(motCtx->ctxResultArray);
 247         OICFree(motCtx);
 248     }
 249     OIC_LOG_V(DEBUG, TAG, "Out %s", __func__);
 250     return postMomRes;
 251 }
 252
 253 /**
 254  * API to update 'doxm.mom' to resource server.
 255  *
 256  * @param[in] targetDeviceInfo Selected target device.
 257  * @param[in] momType Mode of multiple ownership transfer (ref. oic.sec.mom)
 258  * @param[in] resultCallback callback provided by API user, callback will be called when
 259  *            POST 'mom' request recieves a response from resource server.
 260  * @return OC_STACK_OK in case of success and other value otherwise.
 261  */
 262 OCStackResult MOTChangeMode(void *ctx, const OCProvisionDev_t *targetDeviceInfo,
 263                             const OicSecMomType_t momType, OCProvisionResultCB resultCallback)
 264 {
 265     OCStackResult postMomRes = OC_STACK_INVALID_PARAM;
 266     OicSecDoxm_t* doxm = NULL;
 267     uint8_t* doxmPayload = NULL;
 268     size_t doxmPayloadLen = 0;
 269
 270     OIC_LOG_V(DEBUG, TAG, "In %s", __func__);
 271
 272     VERIFY_SUCCESS(TAG, (OIC_NUMBER_OF_MOM_TYPE > momType), ERROR);
 273     VERIFY_NON_NULL(TAG, targetDeviceInfo, ERROR);
 274     postMomRes = OC_STACK_INVALID_CALLBACK;
 275     VERIFY_NON_NULL(TAG, resultCallback, ERROR);
 276
 277     //Dulpicate doxm resource to update the 'mom' property
 278     postMomRes = DoxmToCBORPayload(targetDeviceInfo->doxm, &doxmPayload, &doxmPayloadLen, false);
 279     VERIFY_SUCCESS(TAG, (OC_STACK_OK == postMomRes), ERROR);
 280
 281     postMomRes = CBORPayloadToDoxm(doxmPayload, doxmPayloadLen, &doxm);
 282     VERIFY_SUCCESS(TAG, (OC_STACK_OK == postMomRes), ERROR);
 283     VERIFY_NON_NULL(TAG, doxm, ERROR);
 284
 285     if(NULL == doxm->mom)
 286     {
 287         postMomRes = OC_STACK_NO_MEMORY;
 288         doxm->mom = (OicSecMom_t*)OICCalloc(1, sizeof(OicSecMom_t));
 289         VERIFY_NON_NULL(TAG, (doxm->mom), ERROR);
 290     }
 291     doxm->mom->mode = momType;
 292
 293     //Send POST reuqest for update doxm
 294     postMomRes = MOTSendPostDoxm(ctx, targetDeviceInfo, resultCallback, doxm);
 295     VERIFY_SUCCESS(TAG, (OC_STACK_OK == postMomRes), ERROR);
 296
 297 exit:
 298     OICFree(doxmPayload);
 299     DeleteDoxmBinData(doxm);
 300     OIC_LOG_V(DEBUG, TAG, "Out %s", __func__);
 301     return postMomRes;
 302 }
 303
 304 /**
 305  * API to add 'doxm.oxms' to resource server.
 306  *
 307  * @param[in] targetDeviceInfo Selected target device.
 308  * @param[in] newOxm  OxMs to be added (ref. oic.sec.oxm)
 309  * @param[in] resultCallback callback provided by API user, callback will be called when
 310  *            POST 'oxms' request recieves a response from resource server.
 311  * @return OC_STACK_OK in case of success and other value otherwise.
 312  */
 313 OCStackResult MOTAddMOTMethod(void *ctx, OCProvisionDev_t *targetDeviceInfo,
 314                                  const OicSecOxm_t newOxm, OCProvisionResultCB resultCallback)
 315 {
 316     OCStackResult postOxmRes = OC_STACK_INVALID_PARAM;
 317     OicSecOxm_t* newOxms = NULL;
 318     uint8_t* doxmPayload = NULL;
 319     size_t doxmPayloadLen = 0;
 320
 321     OIC_LOG_V(DEBUG, TAG, "In %s", __func__);
 322
 323     VERIFY_SUCCESS(TAG, (OIC_OXM_COUNT > newOxm || OIC_PRECONFIG_PIN == newOxm), ERROR);
 324     VERIFY_NON_NULL(TAG, targetDeviceInfo, ERROR);
 325     postOxmRes = OC_STACK_INVALID_CALLBACK;
 326     VERIFY_NON_NULL(TAG, resultCallback, ERROR);
 327     postOxmRes = OC_STACK_NO_MEMORY;
 328
 329     for(size_t i = 0; i < targetDeviceInfo->doxm->oxmLen; i++)
 330     {
 331         if(targetDeviceInfo->doxm->oxm[i] == newOxm)
 332         {
 333             OIC_LOG_V(INFO, TAG, "[%d] OxM already supported", (int)newOxm);
 334             OCProvisionResult_t* resArr = (OCProvisionResult_t*)OICCalloc(1, sizeof(OCProvisionResult_t));
 335             VERIFY_NON_NULL(TAG, resArr, ERROR);
 336             resArr->res = OC_STACK_OK;
 337             memcpy(resArr->deviceId.id, targetDeviceInfo->doxm->deviceID.id, sizeof(resArr->deviceId.id));
 338             resultCallback(ctx, 1, resArr, false);
 339             return OC_STACK_OK;
 340         }
 341     }
 342
 343     newOxms = (OicSecOxm_t*)OICMalloc(sizeof(OicSecOxm_t) * (targetDeviceInfo->doxm->oxmLen + 1));
 344     VERIFY_NON_NULL(TAG, newOxms , ERROR);
 345
 346     for(size_t i = 0; i < targetDeviceInfo->doxm->oxmLen; i++)
 347     {
 348         newOxms[i] = targetDeviceInfo->doxm->oxm[i];
 349     }
 350     newOxms[targetDeviceInfo->doxm->oxmLen] = newOxm;
 351     targetDeviceInfo->doxm->oxmLen++;
 352     OICFree(targetDeviceInfo->doxm->oxm);
 353     targetDeviceInfo->doxm->oxm = newOxms;
 354
 355     //Send POST reuqest for update doxm
 356     postOxmRes = MOTSendPostDoxm(ctx, targetDeviceInfo, resultCallback, targetDeviceInfo->doxm);
 357     VERIFY_SUCCESS(TAG, (OC_STACK_OK == postOxmRes), ERROR);
 358
 359 exit:
 360     OICFree(doxmPayload);
 361     OIC_LOG_V(DEBUG, TAG, "Out %s", __func__);
 362     return postOxmRes;
 363 }
 364
 365 /**
 366  * API to update 'doxm.oxmsel' to resource server.
 367  *
 368  * @param[in] targetDeviceInfo Selected target device.
 369   * @param[in] oxmSelValue Method of multiple ownership transfer (ref. oic.sec.oxm)
 370  * @param[in] resultCallback callback provided by API user, callback will be called when
 371  *            POST 'oxmsel' request recieves a response from resource server.
 372  * @return OC_STACK_OK in case of success and other value otherwise.
 373  */
 374 OCStackResult MOTSelectMOTMethod(void *ctx, const OCProvisionDev_t *targetDeviceInfo,
 375                                  const OicSecOxm_t oxmSelValue, OCProvisionResultCB resultCallback)
 376 {
 377     OCStackResult postMomRes = OC_STACK_INVALID_CALLBACK;
 378     OicSecDoxm_t* doxm = NULL;
 379     uint8_t* doxmPayload = NULL;
 380     size_t doxmPayloadLen = 0;
 381
 382     OIC_LOG_V(DEBUG, TAG, "In %s", __func__);
 383
 384     VERIFY_NON_NULL(TAG, resultCallback, ERROR);
 385     postMomRes = OC_STACK_INVALID_PARAM;
 386     VERIFY_NON_NULL(TAG, targetDeviceInfo, ERROR);
 387
 388     bool isValidOxmsel = false;
 389     for(size_t i = 0; i < targetDeviceInfo->doxm->oxmLen; i++)
 390     {
 391         if(targetDeviceInfo->doxm->oxm[i] == oxmSelValue)
 392         {
 393             isValidOxmsel = true;
 394             break;
 395         }
 396     }
 397     VERIFY_SUCCESS(TAG, isValidOxmsel, ERROR);
 398
 399     //Dulpicate doxm resource to update the 'oxmsel' property
 400     postMomRes = DoxmToCBORPayload(targetDeviceInfo->doxm, &doxmPayload, &doxmPayloadLen, false);
 401     VERIFY_SUCCESS(TAG, (OC_STACK_OK == postMomRes), ERROR);
 402
 403     postMomRes = CBORPayloadToDoxm(doxmPayload, doxmPayloadLen, &doxm);
 404     VERIFY_SUCCESS(TAG, (OC_STACK_OK == postMomRes), ERROR);
 405     VERIFY_NON_NULL(TAG, doxm, ERROR);
 406
 407     doxm->oxmSel = oxmSelValue;
 408
 409     //Send POST reuqest for update doxm
 410     postMomRes = MOTSendPostDoxm(ctx, targetDeviceInfo, resultCallback, doxm);
 411     VERIFY_SUCCESS(TAG, (OC_STACK_OK == postMomRes), ERROR);
 412
 413 exit:
 414     OICFree(doxmPayload);
 415     DeleteDoxmBinData(doxm);
 416     OIC_LOG_V(DEBUG, TAG, "Out %s", __func__);
 417     return postMomRes;
 418 }
 419
 420 /**
 421  * API to provision preconfigured PIN to resource server.
 422  *
 423  * @param[in] targetDeviceInfo Selected target device.
 424  * @param[in] preconfPIN Preconfig PIN which is used while multiple owner authentication
 425  * @param[in] preconfPINLen Byte length of preconfig PIN
 426  * @param[in] resultCallback callback provided by API user, callback will be called when
 427  *            POST credential request recieves a response from resource server.
 428  * @return OC_STACK_OK in case of success and other value otherwise.
 429  */
 430 OCStackResult MOTProvisionPreconfigPIN(void *ctx, const OCProvisionDev_t *targetDeviceInfo,
 431                                  const char* preconfPIN, size_t preconfPINLen, OCProvisionResultCB resultCallback)
 432 {
 433     OCStackResult postCredRes = OC_STACK_INVALID_CALLBACK;
 434     bool freeFlag = true;
 435     OCSecurityPayload* secPayload = NULL;
 436     OTMContext_t *motCtx = NULL;
 437     OicSecCred_t* pinCred = NULL;
 438
 439     OIC_LOG_V(DEBUG, TAG, "In %s", __func__);
 440
 441     VERIFY_NON_NULL(TAG, resultCallback, ERROR);
 442     postCredRes = OC_STACK_INVALID_PARAM;
 443     VERIFY_NON_NULL(TAG, targetDeviceInfo, ERROR);
 444     VERIFY_NON_NULL(TAG, preconfPIN, ERROR);
 445     VERIFY_SUCCESS(TAG, (0 != preconfPINLen), ERROR);
 446     VERIFY_SUCCESS(TAG, (0 != preconfPINLen && OXM_PRECONFIG_PIN_MAX_SIZE >= preconfPINLen), ERROR);
 447
 448     postCredRes = OC_STACK_NO_MEMORY;
 449     //Generate PIN based credential
 450     pinCred = (OicSecCred_t*)OICCalloc(1, sizeof(OicSecCred_t));
 451     VERIFY_NON_NULL(TAG, pinCred, ERROR);
 452
 453     pinCred->privateData.data = (uint8_t*)OICMalloc(preconfPINLen + 1);
 454     VERIFY_NON_NULL(TAG, pinCred->privateData.data, ERROR);
 455
 456     memcpy(pinCred->privateData.data, preconfPIN, preconfPINLen);
 457     pinCred->privateData.data[preconfPINLen] = '\0';
 458     pinCred->privateData.len = preconfPINLen;
 459     pinCred->privateData.encoding = OIC_ENCODING_RAW;
 460     pinCred->credType = PIN_PASSWORD;
 461     OICStrcpy(pinCred->subject.id, sizeof(pinCred->subject.id), WILDCARD_SUBJECT_ID.id);
 462
 463     //Generate the security payload using updated doxm
 464     secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
 465     VERIFY_NON_NULL(TAG, secPayload, ERROR);
 466     secPayload->base.type = PAYLOAD_TYPE_SECURITY;
 467
 468     postCredRes = CredToCBORPayload(pinCred, &secPayload->securityData, &secPayload->payloadSize, false);
 469     VERIFY_SUCCESS(TAG, (OC_STACK_OK == postCredRes), ERROR);
 470
 471     OIC_LOG(DEBUG, TAG, "Created Credential payload to register PIN credential:");
 472     OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize);
 473
 474     char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
 475     bool queryGenRes = PMGenerateQuery(true,
 476                                        targetDeviceInfo->endpoint.addr,
 477                                        targetDeviceInfo->securePort,
 478                                        targetDeviceInfo->connType,
 479                                        query, sizeof(query), OIC_RSRC_CRED_URI);
 480     VERIFY_SUCCESS(TAG, (true == queryGenRes), ERROR);
 481     OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
 482
 483     //Create the MOT Context to handle the response message
 484     motCtx = (OTMContext_t*)OICCalloc(1, sizeof(OTMContext_t));
 485     VERIFY_NON_NULL(TAG, motCtx, ERROR);
 486     motCtx->selectedDeviceInfo= targetDeviceInfo;
 487     motCtx->ctxResultCallback = resultCallback;
 488     motCtx->ctxResultArraySize =1;
 489     motCtx->ctxHasError = false;
 490     motCtx->userCtx = ctx;
 491     motCtx->ctxResultArray = (OCProvisionResult_t*)OICCalloc(1, sizeof(OCProvisionResult_t));
 492     VERIFY_NON_NULL(TAG, motCtx->ctxResultArray, ERROR);
 493
 494     //Send POST request
 495     OCCallbackData cbData =  {.context=NULL, .cb=NULL, .cd=NULL};
 496     cbData.cb = &MOTUpdateSecurityResourceCB;
 497     cbData.context = (void *)motCtx;
 498     OIC_LOG(DEBUG, TAG, "Sending POST Preconfiged PIN credenatial request to resource server");
 499     postCredRes = OCDoResource(NULL, OC_REST_POST, query,
 500                               &targetDeviceInfo->endpoint, (OCPayload*)secPayload,
 501                               targetDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
 502     VERIFY_SUCCESS(TAG, (OC_STACK_OK == postCredRes), ERROR);
 503
 504     freeFlag = false;
 505
 506     OIC_LOG_V(DEBUG, TAG, "Out %s", __func__);
 507
 508     return postCredRes;
 509
 510 exit:
 511     //If POST request successfully sent, motCtx will be cleaned from response handler.
 512     if(freeFlag && motCtx)
 513     {
 514         OICFree(motCtx->ctxResultArray);
 515         OICFree(motCtx);
 516     }
 517     if(pinCred)
 518     {
 519         OICFree(pinCred->privateData.data);
 520         OICFree(pinCred);
 521     }
 522     OIC_LOG_V(DEBUG, TAG, "Out %s : %d", __func__, postCredRes);
 523     return postCredRes;
 524 }
 525
 526
 527 /**********************************************************************
 528  * API for Sub Owner
 529  **********************************************************************/
 530
 531 static OCStackResult StartMultipleOwnershipTransfer(OTMContext_t* motCtx,
 532                                                     OCProvisionDev_t* selectedDevice);
 533
 534 static OTMContext_t* g_MotCtx = NULL;
 535
 536 static bool IsComplete(OTMContext_t* otmCtx)
 537 {
 538     for(size_t i = 0; i < otmCtx->ctxResultArraySize; i++)
 539     {
 540         if(OC_STACK_CONTINUE == otmCtx->ctxResultArray[i].res)
 541         {
 542             return false;
 543         }
 544     }
 545
 546     return true;
 547 }
 548
 549 /**
 550  * Function to save the result of multiple ownership transfer.
 551  *
 552  * @param[in,out] motCtx   Context instance of multiple ownership transfer.
 553  * @param[in] res   result of multiple ownership transfer.
 554  */
 555 static void SetMOTResult(OTMContext_t* motCtx, const OCStackResult res)
 556 {
 557     OIC_LOG_V(DEBUG, TAG, "IN %s : %d ", __func__, res);
 558     VERIFY_NON_NULL(TAG, motCtx, ERROR);
 559
 560     if(motCtx->selectedDeviceInfo)
 561     {
 562         //Revert psk_info callback in case of random PIN OxM
 563         if(OIC_RANDOM_DEVICE_PIN == motCtx->selectedDeviceInfo->doxm->oxmSel ||
 564            OIC_PRECONFIG_PIN == motCtx->selectedDeviceInfo->doxm->oxmSel)
 565         {
 566             if(CA_STATUS_OK != CAregisterPskCredentialsHandler(GetDtlsPskCredentials))
 567             {
 568                 OIC_LOG(WARNING, TAG, "Failed to revert the DTLS credential handler.");
 569             }
 570             OicUuid_t emptyUuid = { .id={0}};
 571             SetUuidForPinBasedOxm(&emptyUuid);
 572         }
 573
 574         OCStackResult pdmRetVal = PDMSetDeviceState(&motCtx->selectedDeviceInfo->doxm->deviceID,
 575                                                     PDM_DEVICE_ACTIVE);
 576         if (OC_STACK_OK != pdmRetVal)
 577         {
 578             OIC_LOG_V(ERROR, TAG, "Failed to add device information into PDM_DB : %d", res);
 579         }
 580
 581         for(size_t i = 0; i < motCtx->ctxResultArraySize; i++)
 582         {
 583             if(memcmp(motCtx->selectedDeviceInfo->doxm->deviceID.id,
 584                       motCtx->ctxResultArray[i].deviceId.id, UUID_LENGTH) == 0)
 585             {
 586                 motCtx->ctxResultArray[i].res = res;
 587                 if(OC_STACK_OK != res)
 588                 {
 589                     motCtx->ctxHasError = true;
 590                 }
 591             }
 592         }
 593
 594         //Remove the current OTM Context from OTM queue
 595         RemoveOTMContext(motCtx->selectedDeviceInfo->endpoint.addr,
 596                          motCtx->selectedDeviceInfo->securePort);
 597
 598         //If there is a request being performed, cancel it to prevent retransmission.
 599         if(motCtx->ocDoHandle)
 600         {
 601             if (OC_STACK_OK !=  OCCancel(motCtx->ocDoHandle, OC_HIGH_QOS, NULL, 0))
 602             {
 603                 OIC_LOG(ERROR, TAG, "Failed to remove registered callback");
 604             }
 605             motCtx->ocDoHandle = NULL;
 606         }
 607
 608         //If all request is completed, invoke the user callback.
 609         if(IsComplete(motCtx))
 610         {
 611             motCtx->ctxResultCallback(motCtx->userCtx, motCtx->ctxResultArraySize,
 612                                        motCtx->ctxResultArray, motCtx->ctxHasError);
 613
 614             OICFree(motCtx->ctxResultArray);
 615             OICFree(motCtx);
 616             motCtx = NULL;
 617         }
 618         else
 619         {
 620             if(OC_STACK_OK != StartMultipleOwnershipTransfer(motCtx,
 621                                                      motCtx->selectedDeviceInfo->next))
 622             {
 623                 OIC_LOG(ERROR, TAG, "Failed to StartMultipleOwnershipTransfer");
 624             }
 625         }
 626     }
 627
 628 exit:
 629     OIC_LOG_V(DEBUG, TAG, "Out %s", __func__);
 630 }
 631
 632 /**
 633  * API to add preconfigured PIN to local SVR DB.
 634  *
 635  * @param[in] targetDeviceInfo Selected target device.
 636  * @param[in] preconfPIN Preconfig PIN which is used while multiple owner authentication
 637  * @param[in] preconfPINLen Byte length of preconfig PIN
 638  * @param[in] resultCallback callback provided by API user, callback will be called when
 639  *            POST credential request recieves a response from resource server.
 640  * @return OC_STACK_OK in case of success and other value otherwise.
 641  */
 642 OCStackResult MOTAddPreconfigPIN(const OCProvisionDev_t *targetDeviceInfo,
 643                                  const char* preconfPIN, size_t preconfPINLen)
 644 {
 645     OCStackResult addCredRes = OC_STACK_INVALID_PARAM;
 646     OicSecCred_t* pinCred = NULL;
 647     bool freeFlag = true;
 648
 649     OIC_LOG_V(DEBUG, TAG, "In %s", __func__);
 650
 651     VERIFY_NON_NULL(TAG, targetDeviceInfo, ERROR);
 652     VERIFY_NON_NULL(TAG, preconfPIN, ERROR);
 653     VERIFY_SUCCESS(TAG, (0 != preconfPINLen), ERROR);
 654     VERIFY_SUCCESS(TAG, (0 != preconfPINLen && OXM_PRECONFIG_PIN_MAX_SIZE >= preconfPINLen), ERROR);
 655
 656     OicSecCred_t* prevCred = GetCredResourceData(&targetDeviceInfo->doxm->deviceID);
 657     if(NULL != prevCred)
 658     {
 659         OIC_LOG(INFO, TAG, "PIN/PW Credential already exist!");
 660         return OC_STACK_OK;
 661     }
 662
 663     addCredRes = OC_STACK_NO_MEMORY;
 664     //Generate PIN based credential
 665     pinCred = (OicSecCred_t*)OICCalloc(1, sizeof(OicSecCred_t));
 666     VERIFY_NON_NULL(TAG, pinCred, ERROR);
 667
 668     pinCred->privateData.data = (uint8_t*)OICMalloc(preconfPINLen + 1);
 669     VERIFY_NON_NULL(TAG, pinCred->privateData.data, ERROR);
 670
 671     memcpy(pinCred->privateData.data, preconfPIN, preconfPINLen);
 672     pinCred->privateData.data[preconfPINLen] = '\0';
 673     pinCred->privateData.len = preconfPINLen;
 674     pinCred->privateData.encoding = OIC_ENCODING_RAW;
 675     pinCred->credType = PIN_PASSWORD;
 676     memcpy(pinCred->subject.id, targetDeviceInfo->doxm->deviceID.id, sizeof(pinCred->subject.id));
 677
 678     addCredRes = AddCredential(pinCred);
 679     VERIFY_SUCCESS(TAG, (OC_STACK_OK == addCredRes), ERROR);
 680
 681     OIC_LOG_V(DEBUG, TAG, "Out %s", __func__);
 682
 683     return addCredRes;
 684
 685 exit:
 686     if(pinCred)
 687     {
 688         OICFree(pinCred->privateData.data);
 689         OICFree(pinCred);
 690     }
 691     OIC_LOG_V(DEBUG, TAG, "In %s : %d", __func__, addCredRes);
 692     return addCredRes;
 693 }
 694
 695 /**
 696  * Function to save the SubOwner PSK.
 697  *
 698  * @param[in] selectedDeviceInfo   selected device information to performing provisioning.
 699  * @return  OC_STACK_OK on success
 700  */
 701 static OCStackResult SaveSubOwnerPSK(OCProvisionDev_t *selectedDeviceInfo)
 702 {
 703     OIC_LOG_V(DEBUG, TAG, "In %s", __func__);
 704
 705     OCStackResult res = OC_STACK_ERROR;
 706
 707     CAEndpoint_t endpoint;
 708     memset(&endpoint, 0x00, sizeof(CAEndpoint_t));
 709     OICStrcpy(endpoint.addr, MAX_ADDR_STR_SIZE_CA, selectedDeviceInfo->endpoint.addr);
 710     endpoint.addr[MAX_ADDR_STR_SIZE_CA - 1] = '\0';
 711     endpoint.port = selectedDeviceInfo->securePort;
 712     endpoint.adapter = selectedDeviceInfo->endpoint.adapter;
 713
 714     OicUuid_t ownerDeviceID = {.id={0}};
 715     if (OC_STACK_OK != GetDoxmDeviceID(&ownerDeviceID))
 716     {
 717         OIC_LOG(ERROR, TAG, "Error while retrieving SubOwner's device ID");
 718         return res;
 719     }
 720
 721     uint8_t ownerPSK[OWNER_PSK_LENGTH_128] = {0};
 722     OicSecKey_t ownerKey = {ownerPSK, OWNER_PSK_LENGTH_128};
 723
 724     //Generating SubOwnerPSK
 725     CAResult_t pskRet = CAGenerateOwnerPSK(&endpoint,
 726             (uint8_t *)GetOxmString(selectedDeviceInfo->doxm->oxmSel),
 727             strlen(GetOxmString(selectedDeviceInfo->doxm->oxmSel)),
 728             ownerDeviceID.id, sizeof(ownerDeviceID.id),
 729             selectedDeviceInfo->doxm->deviceID.id, sizeof(selectedDeviceInfo->doxm->deviceID.id),
 730             ownerPSK, OWNER_PSK_LENGTH_128);
 731
 732     if (CA_STATUS_OK == pskRet)
 733     {
 734         OIC_LOG(DEBUG, TAG, "SubOwner PSK dump:");
 735         OIC_LOG_BUFFER(DEBUG, TAG, ownerPSK, OWNER_PSK_LENGTH_128);
 736         //Generating new credential for provisioning tool
 737         OicSecCred_t *cred = GenerateCredential(&selectedDeviceInfo->doxm->deviceID,
 738                                       SYMMETRIC_PAIR_WISE_KEY, NULL,
 739                                       &ownerKey, &ownerDeviceID, &ownerDeviceID);
 740         VERIFY_NON_NULL(TAG, cred, ERROR);
 741
 742         uint32_t outSize = 0;
 743         size_t b64BufSize = B64ENCODE_OUT_SAFESIZE((OWNER_PSK_LENGTH_128 + 1));
 744         char* b64Buf = (uint8_t *)OICCalloc(1, b64BufSize);
 745         VERIFY_NON_NULL(TAG, b64Buf, ERROR);
 746         b64Encode(cred->privateData.data, cred->privateData.len, b64Buf, b64BufSize, &outSize);
 747
 748         OICFree( cred->privateData.data );
 749         cred->privateData.data = (uint8_t *)OICCalloc(1, outSize + 1);
 750         if (NULL == cred->privateData.data)
 751         {
 752             OICFree(b64Buf);
 753             return res;
 754         }
 755
 756         strncpy(cred->privateData.data, b64Buf, outSize);
 757         cred->privateData.data[outSize] = '\0';
 758         cred->privateData.encoding = OIC_ENCODING_BASE64;
 759         cred->privateData.len = outSize;
 760         OICFree(b64Buf);
 761
 762         //Add SubOwnerPSK
 763         res = AddCredential(cred);
 764         if(res != OC_STACK_OK)
 765         {
 766             DeleteCredList(cred);
 767             return res;
 768         }
 769     }
 770     else
 771     {
 772         OIC_LOG(ERROR, TAG, "CAGenerateOwnerPSK failed");
 773     }
 774
 775     OIC_LOG_V(DEBUG, TAG, "Out %s : %d", __func__, res);
 776 exit:
 777     return res;
 778 }
 779
 780
 781 /**
 782  * Response handler for update subowner crendetial request.
 783  *
 784  * @param[in] ctx             ctx value passed to callback from calling function.
 785  * @param[in] UNUSED          handle to an invocation
 786  * @param[in] clientResponse  Response from queries to remote servers.
 787  * @return  OC_STACK_DELETE_TRANSACTION to delete the transaction
 788  *          and  OC_STACK_KEEP_TRANSACTION to keep it.
 789  */
 790 static OCStackApplicationResult SubOwnerCredentialHandler(void *ctx, OCDoHandle UNUSED,
 791                                 OCClientResponse *clientResponse)
 792 {
 793     VERIFY_NON_NULL(TAG, clientResponse, WARNING);
 794     VERIFY_NON_NULL(TAG, ctx, WARNING);
 795
 796     OIC_LOG_V(DEBUG, TAG, "In %s", __func__);
 797
 798     (void)UNUSED;
 799     OTMContext_t* motCtx = (OTMContext_t*)ctx;
 800
 801     if(OC_STACK_RESOURCE_CHANGED == clientResponse->result)
 802     {
 803         if(motCtx && motCtx->selectedDeviceInfo)
 804         {
 805             //Delete previous credential such as preconfigured-pin
 806             RemoveCredential(&(motCtx->selectedDeviceInfo->doxm->deviceID));
 807             OCStackResult res = SaveSubOwnerPSK(motCtx->selectedDeviceInfo);
 808             if(OC_STACK_OK == res)
 809             {
 810                 //Close the temporal secure session to verify the owner credential
 811                 CAEndpoint_t* endpoint = (CAEndpoint_t *)&motCtx->selectedDeviceInfo->endpoint;
 812                 endpoint->port = motCtx->selectedDeviceInfo->securePort;
 813                 CAResult_t caResult = CAcloseSslSession(endpoint);
 814                 if(CA_STATUS_OK != caResult)
 815                 {
 816                     OIC_LOG(ERROR, TAG, "Failed to close DTLS session");
 817                     SetMOTResult(motCtx, OC_STACK_ERROR);
 818                     return OC_STACK_DELETE_TRANSACTION;
 819                 }
 820
 821                 // TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA_256 = 0xC037, /**< see RFC 5489 */
 822                 caResult = CASelectCipherSuite(0xC037, endpoint->adapter);
 823                 if(CA_STATUS_OK != caResult)
 824                 {
 825                     OIC_LOG(ERROR, TAG, "Failed to select TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA_256");
 826                     SetMOTResult(motCtx, OC_STACK_ERROR);
 827                     return OC_STACK_DELETE_TRANSACTION;
 828                 }
 829
 830                 SetMOTResult(motCtx, OC_STACK_OK);
 831             }
 832             else
 833             {
 834                 OIC_LOG(ERROR, TAG, "Failed to save the SubOwner PSK.");
 835                 SetMOTResult(motCtx, res);
 836                 return OC_STACK_DELETE_TRANSACTION;
 837             }
 838         }
 839     }
 840     else
 841     {
 842         OIC_LOG_V(ERROR, TAG, "SubOwnerCredentialHandler : Unexpected result %d",
 843                   clientResponse->result);
 844         SetMOTResult(motCtx, clientResponse->result);
 845     }
 846
 847     OIC_LOG_V(DEBUG, TAG, "Out %s", __func__);
 848
 849 exit:
 850     return  OC_STACK_DELETE_TRANSACTION;
 851 }
 852
 853
 854 static OCStackResult PostSubOwnerCredential(OTMContext_t* motCtx)
 855 {
 856     OIC_LOG_V(DEBUG, TAG, "In %s", __func__);
 857
 858     if(!motCtx || !motCtx->selectedDeviceInfo)
 859     {
 860         OIC_LOG(ERROR, TAG, "Invalid parameters");
 861         return OC_STACK_INVALID_PARAM;
 862     }
 863
 864     OCProvisionDev_t* deviceInfo = motCtx->selectedDeviceInfo;
 865     char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
 866
 867     if(!PMGenerateQuery(true,
 868                         deviceInfo->endpoint.addr, deviceInfo->securePort,
 869                         deviceInfo->connType,
 870                         query, sizeof(query), OIC_RSRC_CRED_URI))
 871     {
 872         OIC_LOG(ERROR, TAG, "PostSubOwnerCredential : Failed to generate query");
 873         return OC_STACK_ERROR;
 874     }
 875     OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
 876     OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
 877     if(!secPayload)
 878     {
 879         OIC_LOG(ERROR, TAG, "Failed to memory allocation");
 880         return OC_STACK_NO_MEMORY;
 881     }
 882
 883     //Generate sub-owner credential for new device
 884     secPayload->base.type = PAYLOAD_TYPE_SECURITY;
 885
 886     /**
 887      * Because of the deadlock issue, we can not get a server's session information at this time.
 888      * So use the dumpy owner credential instance to send POST credential request.
 889      */
 890     OicUuid_t ownerId = {.id={0}};
 891     if(OC_STACK_OK == GetDoxmDeviceID(&ownerId))
 892     {
 893         OicSecCred_t newCredential;
 894         memset(&newCredential, 0x0, sizeof(OicSecCred_t));
 895         newCredential.next = NULL;
 896         newCredential.credType = SYMMETRIC_PAIR_WISE_KEY;
 897
 898         //Set subject ID as SubOwner's ID
 899         memcpy(&(newCredential.subject), &ownerId, sizeof(OicUuid_t));
 900
 901         //Set eowner ID as SubOwner's ID
 902         if(NULL == newCredential.eownerID)
 903         {
 904             newCredential.eownerID = OICCalloc(1, sizeof(OicUuid_t));
 905             if(NULL == newCredential.eownerID)
 906             {
 907                 return OC_STACK_NO_MEMORY;
 908             }
 909         }
 910         memcpy(newCredential.eownerID->id, ownerId.id, sizeof(ownerId.id));
 911
 912         //Fill private data as empty string
 913         newCredential.privateData.data = "";
 914         newCredential.privateData.len = 0;
 915         newCredential.privateData.encoding = OIC_ENCODING_BASE64;
 916
 917 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
 918         newCredential.publicData.data = NULL;
 919         newCredential.publicData.len = 0;
 920         newCredential.publicData.encoding = OIC_ENCODING_RAW;
 921 #endif
 922         //Send owner credential to new device : POST /oic/sec/cred [ owner credential ]
 923         if (OC_STACK_OK != CredToCBORPayload(&newCredential, &secPayload->securityData,
 924                                         &secPayload->payloadSize, 0))
 925         {
 926             OICFree(secPayload);
 927             OIC_LOG(ERROR, TAG, "Error while converting bin to cbor.");
 928             return OC_STACK_ERROR;
 929         }
 930         OIC_LOG(DEBUG, TAG, "Cred Payload:");
 931         OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize);
 932         OICFree(newCredential.eownerID);
 933
 934         OCCallbackData cbData;
 935         cbData.cb = &SubOwnerCredentialHandler;
 936         cbData.context = (void *)motCtx;
 937         cbData.cd = NULL;
 938         OCStackResult res = OCDoResource(NULL, OC_REST_POST, query,
 939                                          &deviceInfo->endpoint, (OCPayload*)secPayload,
 940                                          deviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
 941         if (res != OC_STACK_OK)
 942         {
 943             OIC_LOG(ERROR, TAG, "OCStack resource error");
 944         }
 945     }
 946     else
 947     {
 948         OIC_LOG(ERROR, TAG, "Failed to read DOXM device ID.");
 949         return OC_STACK_NO_RESOURCE;
 950     }
 951
 952     OIC_LOG_V(DEBUG, TAG, "Out %s", __func__);
 953
 954     return OC_STACK_OK;
 955 }
 956
 957
 958 /**
 959  * Function to handle the handshake result in MOT.
 960  * This function will be invoked after DTLS handshake
 961  * @param   endPoint  [IN] The remote endpoint.
 962  * @param   errorInfo [IN] Error information from the endpoint.
 963  * @return  NONE
 964  */
 965 static void MOTDtlsHandshakeCB(const CAEndpoint_t *endpoint, const CAErrorInfo_t *info)
 966 {
 967     OIC_LOG_V(DEBUG, TAG, "In %s", __func__);
 968
 969     if(NULL != endpoint && NULL != info)
 970     {
 971         OIC_LOG_V(INFO, TAG, "Received status from remote device(%s:%d) : %d",
 972                  endpoint->addr, endpoint->port, info->result);
 973
 974         OTMContext_t* motCtx = GetOTMContext(endpoint->addr, endpoint->port);
 975         if(motCtx)
 976         {
 977             OicSecDoxm_t* newDevDoxm = motCtx->selectedDeviceInfo->doxm;
 978
 979             if(NULL != newDevDoxm)
 980             {
 981                 OicUuid_t emptyUuid = {.id={0}};
 982
 983                 //Make sure the address matches.
 984                 if(strncmp(motCtx->selectedDeviceInfo->endpoint.addr,
 985                    endpoint->addr,
 986                    sizeof(endpoint->addr)) == 0 &&
 987                    motCtx->selectedDeviceInfo->securePort == endpoint->port)
 988                 {
 989                     OCStackResult res = OC_STACK_ERROR;
 990
 991                     //If temporal secure sesstion established successfully
 992                     if(CA_STATUS_OK == info->result)
 993                     {
 994                         //POST sub owner credential to new device.
 995                         res = PostSubOwnerCredential(motCtx);
 996                         if(OC_STACK_OK != res)
 997                         {
 998                             OIC_LOG(ERROR, TAG,
 999                                     "Failed to send POST request for SubOwner Credential");
1000                             SetMOTResult(motCtx, res);
1001                         }
1002                     }
1003                     //In case of authentication failure
1004                     else if(CA_DTLS_AUTHENTICATION_FAILURE == info->result)
1005                     {
1006                         //in case of error from wrong PIN, re-start the ownership transfer
1007                         if(OIC_RANDOM_DEVICE_PIN == newDevDoxm->oxmSel)
1008                         {
1009                             OIC_LOG(ERROR, TAG, "The PIN number may incorrect.");
1010
1011                             motCtx->attemptCnt++;
1012
1013                             if(WRONG_PIN_MAX_ATTEMP > motCtx->attemptCnt)
1014                             {
1015                                 res = StartMultipleOwnershipTransfer(motCtx, motCtx->selectedDeviceInfo);
1016                                 if(OC_STACK_OK != res)
1017                                 {
1018                                     SetMOTResult(motCtx, res);
1019                                     OIC_LOG(ERROR, TAG, "Failed to Re-StartOwnershipTransfer");
1020                                 }
1021                             }
1022                             else
1023                             {
1024                                 OIC_LOG(ERROR, TAG, "User has exceeded the number of authentication attempts.");
1025                                 SetMOTResult(motCtx, OC_STACK_AUTHENTICATION_FAILURE);
1026                             }
1027                         }
1028                         else
1029                         {
1030                             OIC_LOG(ERROR, TAG, "Failed to establish DTLS session.");
1031                             SetMOTResult(motCtx, OC_STACK_AUTHENTICATION_FAILURE);
1032                         }
1033                     }
1034                 }
1035             }
1036         }
1037         else
1038         {
1039             OIC_LOG_V(ERROR, TAG, "Can not find the [%s:%d]'s OTMContext for MOT", endpoint->addr, endpoint->port);
1040         }
1041     }
1042
1043     OIC_LOG_V(DEBUG, TAG, "Out %s", __func__);
1044 }
1045
1046 static OCStackResult StartMultipleOwnershipTransfer(OTMContext_t* motCtx,
1047                                                     OCProvisionDev_t* selectedDevice)
1048 {
1049     OIC_LOG_V(DEBUG, TAG, "In %s", __func__);
1050     OCStackResult res = OC_STACK_INVALID_PARAM;
1051     OicUuid_t myUuid = {.id={0}};
1052
1053     VERIFY_NON_NULL(TAG, motCtx, ERROR);
1054     VERIFY_NON_NULL(TAG, selectedDevice, ERROR);
1055     VERIFY_NON_NULL(TAG, selectedDevice->doxm, ERROR);
1056     motCtx->selectedDeviceInfo = selectedDevice;
1057
1058     res = GetDoxmDeviceID(&myUuid);
1059     if(OC_STACK_OK != res)
1060     {
1061         OIC_LOG(ERROR, TAG, "Failed to GetDoxmDeviceID");
1062         SetMOTResult(motCtx, res);
1063         return res;
1064     }
1065     if(memcmp(selectedDevice->doxm->owner.id, myUuid.id, sizeof(myUuid.id)) == 0)
1066     {
1067         res = OC_STACK_INVALID_DEVICE_INFO;
1068         OIC_LOG(ERROR, TAG, "Owner cannot be registered as sub-owner.");
1069         SetMOTResult(motCtx, res);
1070         return res;
1071     }
1072     if (NULL == selectedDevice->doxm->mom ||
1073         (selectedDevice->doxm->mom &&
1074          OIC_MULTIPLE_OWNER_DISABLE == selectedDevice->doxm->mom->mode))
1075     {
1076         res = OC_STACK_NOT_ACCEPTABLE;
1077         OIC_LOG(ERROR, TAG, "Selected device's MOT is disabled.");
1078         SetMOTResult(motCtx, res);
1079         return res;
1080     }
1081
1082     //Checking duplication of Device ID.
1083     char* strUuid = NULL;
1084     PdmDeviceState_t deviceState = PDM_DEVICE_UNKNOWN;
1085     res = PDMGetDeviceState(&selectedDevice->doxm->deviceID, &deviceState);
1086     VERIFY_SUCCESS(TAG, OC_STACK_OK == res, ERROR);
1087
1088     res = ConvertUuidToStr(&selectedDevice->doxm->deviceID, &strUuid);
1089     if(OC_STACK_OK != res)
1090     {
1091         OIC_LOG(ERROR, TAG, "Failed to convert UUID to str");
1092         SetMOTResult(motCtx, res);
1093         return res;
1094     }
1095
1096     if(PDM_DEVICE_STALE == deviceState)
1097     {
1098         OIC_LOG_V(WARNING, TAG, "Detected duplicated UUID in stale status, "
1099                            "[%s] will be removed from PDM", strUuid);
1100
1101         res = PDMDeleteDevice(&selectedDevice->doxm->deviceID);
1102         if(OC_STACK_OK != res)
1103         {
1104             OIC_LOG(ERROR, TAG, "Internal error in PDMDeleteDevice");
1105             OICFree(strUuid);
1106             SetMOTResult(motCtx, res);
1107         }
1108     }
1109     else if(PDM_DEVICE_INIT == deviceState)
1110     {
1111         OIC_LOG_V(ERROR, TAG, "[%s]'s multiple owner transfer process is already started.", strUuid);
1112         OICFree(strUuid);
1113         SetMOTResult(motCtx, OC_STACK_DUPLICATE_REQUEST);
1114         return OC_STACK_OK;
1115     }
1116
1117     res = PDMAddDevice(&selectedDevice->doxm->deviceID);
1118     if (OC_STACK_OK != res)
1119     {
1120         OIC_LOG_V(INFO, TAG, "Error in PDMAddDevice for [%s]", strUuid);
1121         OICFree(strUuid);
1122         SetMOTResult(motCtx, res);
1123         return res;
1124     }
1125     OICFree(strUuid);
1126
1127     //Register DTLS event handler to catch the dtls event while handshake
1128     if(CA_STATUS_OK != CAregisterSslHandshakeCallback(MOTDtlsHandshakeCB))
1129     {
1130         OIC_LOG(WARNING, TAG, "StartOwnershipTransfer : Failed to register DTLS handshake callback.");
1131     }
1132
1133     OicSecOxm_t oxmSel = selectedDevice->doxm->oxmSel;
1134     OIC_LOG_V(DEBUG, TAG, "Multiple Ownership Transfer method = %d", (int)oxmSel);
1135
1136     if(OIC_PRECONFIG_PIN != oxmSel && OIC_RANDOM_DEVICE_PIN != oxmSel)
1137     {
1138         OIC_LOG(ERROR, TAG, "Unsupported OxM");
1139         return OC_STACK_ERROR;
1140     }
1141
1142     res = OTMSetOTCallback(selectedDevice->doxm->oxmSel, &motCtx->otmCallback);
1143     if(OC_STACK_OK != res)
1144     {
1145         OIC_LOG_V(ERROR, TAG, "Error in OTMSetOTCallback : %d", res);
1146         return res;
1147     }
1148     //Only two functions required for MOT
1149     VERIFY_NON_NULL(TAG, motCtx->otmCallback.loadSecretCB, ERROR);
1150     VERIFY_NON_NULL(TAG, motCtx->otmCallback.createSecureSessionCB, ERROR);
1151
1152     if(OIC_RANDOM_DEVICE_PIN == oxmSel)
1153     {
1154         if(CA_STATUS_OK != CAregisterPskCredentialsHandler(GetDtlsPskForRandomPinOxm))
1155         {
1156             OIC_LOG(ERROR, TAG, "Failed to register DTLS credential handler for Random PIN OxM.");
1157         }
1158     }
1159
1160     //Save the current context instance to use on the dtls handshake callback
1161     res = AddOTMContext(motCtx, selectedDevice->endpoint.addr, selectedDevice->securePort);
1162     VERIFY_SUCCESS(TAG, OC_STACK_OK == res, ERROR);
1163
1164     res = motCtx->otmCallback.loadSecretCB(motCtx);
1165     VERIFY_SUCCESS(TAG, OC_STACK_OK == res, ERROR);
1166
1167     res = motCtx->otmCallback.createSecureSessionCB(motCtx);
1168     VERIFY_SUCCESS(TAG, OC_STACK_OK == res, ERROR);
1169
1170     OIC_LOG_V(DEBUG, TAG, "Out %s", __func__);
1171
1172 exit:
1173     return res;
1174 }
1175
1176 OCStackResult MOTDoOwnershipTransfer(void* ctx,
1177                                      OCProvisionDev_t *selectedDevicelist,
1178                                      OCProvisionResultCB resultCallback)
1179 {
1180     OIC_LOG_V(DEBUG, TAG, "In %s", __func__);
1181     OCStackResult res = OC_STACK_INVALID_PARAM;
1182     OTMContext_t* motCtx = NULL;
1183     OCProvisionDev_t* pCurDev = NULL;
1184
1185     VERIFY_NON_NULL(TAG, selectedDevicelist, ERROR);
1186     VERIFY_NON_NULL(TAG, resultCallback, ERROR);
1187
1188     res = OC_STACK_NO_MEMORY;
1189     motCtx = (OTMContext_t*)OICCalloc(1,sizeof(OTMContext_t));
1190     VERIFY_NON_NULL(TAG, motCtx, ERROR);
1191
1192     motCtx->ctxResultCallback = resultCallback;
1193     motCtx->ctxHasError = false;
1194     motCtx->userCtx = ctx;
1195     motCtx->ctxResultArraySize = 0;
1196     LL_FOREACH(selectedDevicelist, pCurDev)
1197     {
1198         motCtx->ctxResultArraySize++;
1199     }
1200
1201     motCtx->ctxResultArray =
1202         (OCProvisionResult_t*)OICCalloc(motCtx->ctxResultArraySize, sizeof(OCProvisionResult_t));
1203     VERIFY_NON_NULL(TAG, motCtx->ctxResultArray, ERROR);
1204
1205     //Fill the device UUID for result array.
1206     size_t devIdx = 0;
1207     pCurDev = NULL;
1208     LL_FOREACH(selectedDevicelist, pCurDev)
1209     {
1210         memcpy(motCtx->ctxResultArray[devIdx].deviceId.id,
1211                pCurDev->doxm->deviceID.id,
1212                UUID_LENGTH);
1213         motCtx->ctxResultArray[devIdx].res = OC_STACK_CONTINUE;
1214         devIdx++;
1215     }
1216
1217     motCtx->selectedDeviceInfo = selectedDevicelist;
1218     res = StartMultipleOwnershipTransfer(motCtx, selectedDevicelist);
1219
1220     OIC_LOG_V(DEBUG, TAG, "Out %s", __func__);
1221
1222     return res;
1223 exit:
1224     if(OC_STACK_OK != res)
1225     {
1226         if(motCtx)
1227         {
1228             OICFree(motCtx->ctxResultArray);
1229             OICFree(motCtx);
1230         }
1231     }
1232     OIC_LOG_V(DEBUG, TAG, "Out %s : %d", __func__, res);
1233
1234     return res;
1235 }
1236
1237 OCStackResult MOTRemoveSubOwner(void* ctx,
1238                                 const OCProvisionDev_t *targetDeviceInfo,
1239                                 const OicUuid_t* subOwner,
1240                                 OCProvisionResultCB resultCallback)
1241 {
1242     OCStackResult deleteSubOwnerRes = OC_STACK_INVALID_CALLBACK;
1243     OTMContext_t *motCtx = NULL;
1244     char* strUuid = NULL;
1245
1246     OIC_LOG_V(DEBUG, TAG, "In %s", __func__);
1247
1248     VERIFY_NON_NULL(TAG, resultCallback, ERROR);
1249     deleteSubOwnerRes = OC_STACK_INVALID_PARAM;
1250     VERIFY_NON_NULL(TAG, targetDeviceInfo, ERROR);
1251     VERIFY_NON_NULL(TAG, subOwner, ERROR);
1252
1253     deleteSubOwnerRes = OC_STACK_NO_MEMORY;
1254     //Generate the qurey to delete sub-owner
1255     if (memcmp(subOwner->id, WILDCARD_SUBJECT_ID.id, sizeof(WILDCARD_SUBJECT_ID.id)) == 0)
1256     {
1257         strUuid = OICStrdup(WILDCARD_RESOURCE_URI);
1258         VERIFY_NON_NULL(TAG, strUuid, ERROR);
1259     }
1260     else
1261     {
1262         VERIFY_SUCCESS(TAG, (OC_STACK_OK == ConvertUuidToStr(subOwner, &strUuid)), ERROR);
1263     }
1264     char url[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
1265     snprintf(url, sizeof(url), "%s?%s=%s", OIC_RSRC_DOXM_URI, OIC_JSON_SUBOWNERID_NAME, strUuid);
1266
1267     char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
1268     bool queryGenRes = PMGenerateQuery(true,
1269                                        targetDeviceInfo->endpoint.addr,
1270                                        targetDeviceInfo->securePort,
1271                                        targetDeviceInfo->connType,
1272                                        query, sizeof(query), url);
1273     VERIFY_SUCCESS(TAG, (true == queryGenRes), ERROR);
1274
1275     OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
1276
1277     //Create the MOT Context to handle the response message
1278     motCtx = (OTMContext_t*)OICCalloc(1, sizeof(OTMContext_t));
1279     VERIFY_NON_NULL(TAG, motCtx, ERROR);
1280     motCtx->selectedDeviceInfo= targetDeviceInfo;
1281     motCtx->ctxResultCallback = resultCallback;
1282     motCtx->ctxResultArraySize =1;
1283     motCtx->ctxHasError = false;
1284     motCtx->userCtx = ctx;
1285     motCtx->ctxResultArray = (OCProvisionResult_t*)OICCalloc(1, sizeof(OCProvisionResult_t));
1286     VERIFY_NON_NULL(TAG, motCtx->ctxResultArray, ERROR);
1287
1288     //Send POST request
1289     OCCallbackData cbData =  {.context=NULL, .cb=NULL, .cd=NULL};
1290     cbData.cb = &MOTDeleteSecurityResourceCB;
1291     cbData.context = (void *)motCtx;
1292     OIC_LOG(DEBUG, TAG, "Sending DELETE sub-owner request to resource server");
1293     deleteSubOwnerRes = OCDoResource(NULL, OC_REST_DELETE, query,
1294                                      &targetDeviceInfo->endpoint, NULL,
1295                                      targetDeviceInfo->connType, OC_HIGH_QOS, &cbData, NULL, 0);
1296     VERIFY_SUCCESS(TAG, (OC_STACK_OK == deleteSubOwnerRes), ERROR);
1297
1298     OIC_LOG_V(DEBUG, TAG, "Out %s", __func__);
1299
1300     OICFree(strUuid);
1301
1302     return deleteSubOwnerRes;
1303
1304 exit:
1305     //If DELETE request successfully sent, motCtx will be cleaned from response handler.
1306     OICFree(strUuid);
1307     if (motCtx)
1308     {
1309         OICFree(motCtx->ctxResultArray);
1310         OICFree(motCtx);
1311     }
1312     OIC_LOG_V(DEBUG, TAG, "Out %s : %d", __func__, deleteSubOwnerRes);
1313     return deleteSubOwnerRes;
1314 }
1315