resource/csdk/security/src/directpairing.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 #ifndef _POSIX_C_SOURCE
  21 #define _POSIX_C_SOURCE 200112L
  22 #endif
  23 #include "iotivity_config.h"
  24 #ifdef HAVE_UNISTD_H
  25 #include <unistd.h>
  26 #endif
  27 #ifdef HAVE_TIME_H
  28 #include <time.h>
  29 #endif
  30 #ifdef HAVE_SYS_TIME_H
  31 #include <sys/time.h>
  32 #endif
  33 #ifdef HAVE_STRING_H
  34 #include <string.h>
  35 #endif
  36
  37 #include "ocstack.h"
  38 #include "oic_malloc.h"
  39 #include "oic_string.h"
  40 #include "logger.h"
  41 #if defined (__TIZENRT__)
  42 #include <apps/netutils/cJSON.h>
  43 #else
  44 #include "cJSON.h"
  45 #endif
  46 #include "utlist.h"
  47 #include "ocpayload.h"
  48 #include "payload_logging.h"
  49 #include "cainterface.h"
  50
  51 #include "directpairing.h"
  52 #include "srmresourcestrings.h" //@note: SRM's internal header
  53 #include "doxmresource.h"       //@note: SRM's internal header
  54 #include "pconfresource.h"       //@note: SRM's internal header
  55 #include "dpairingresource.h"       //@note: SRM's internal header
  56 #include "credresource.h"
  57
  58 #include "pmtypes.h"
  59 #include "pmutility.h"
  60
  61 #include "srmutility.h"
  62
  63 #define TAG ("OIC_DP")
  64 static const uint16_t CBOR_SIZE = 1024;
  65
  66 /**
  67  * Structure to carry direct-pairing API data to callback.
  68  */
  69 typedef struct DPairData
  70 {
  71     OCDirectPairingDev_t        *peer;                         /**< Pointer to pairing target info.**/
  72     char                                  pin[DP_PIN_LENGTH];  /**< PIN **/
  73     OCDirectPairingResultCB    resultCallback;           /**< Pointer to result callback.**/
  74     void *userCtx;                                      /** < user context to pass in callback **/
  75 } DPairData_t;
  76
  77 static OCDirectPairingDev_t *g_dp_paired = NULL;
  78 static OCDirectPairingDev_t *g_dp_discover = NULL;
  79 static DPairData_t *g_dp_proceed_ctx = NULL;
  80
  81
  82 /**
  83  * Function to search node in linked list that matches given IP and port.
  84  *
  85  * @param[in] pList         List of OCProvisionDev_t.
  86  * @param[in] addr          address of target device.
  87  * @param[in] port          port of remote server.
  88  *
  89  * @return pointer of OCProvisionDev_t if exist, otherwise NULL
  90  */
  91 OCDirectPairingDev_t* getDev(OCDirectPairingDev_t **ppList, const char* addr, const uint16_t port)
  92 {
  93     if(NULL == addr)
  94     {
  95         OIC_LOG_V(ERROR, TAG, "Invalid Input parameters in [%s]\n", __FUNCTION__);
  96         return NULL;
  97     }
  98
  99     OCDirectPairingDev_t *ptr = NULL;
 100     LL_FOREACH(*ppList, ptr)
 101     {
 102         if( strcmp(ptr->endpoint.addr, addr) == 0 && port == ptr->endpoint.port)
 103         {
 104             return ptr;
 105         }
 106     }
 107
 108     return NULL;
 109 }
 110
 111
 112
 113 /**
 114  * Add device information to list.
 115  *
 116  * @param[in] pList         List of OCProvisionDev_t.
 117  * @param[in] addr          address of target device.
 118  * @param[in] port          port of remote server.
 119  * @param[in] adapter       adapter type of endpoint.
 120  * @param[in] doxm          pointer to doxm instance.
 121  * @param[in] connType  connectivity type of endpoint
 122  *
 123  * @return OC_STACK_OK for success and errorcode otherwise.
 124  */
 125 OCStackResult addDev(OCDirectPairingDev_t **ppList, OCDevAddr *endpoint,
 126                                       OCConnectivityType conn, OicSecPconf_t *pconf)
 127 {
 128     if(NULL == endpoint || NULL == pconf)
 129     {
 130         OIC_LOG_V(ERROR, TAG, "Invalid Input parameters in [%s]\n", __FUNCTION__);
 131         return OC_STACK_INVALID_PARAM;
 132     }
 133
 134     OCDirectPairingDev_t *ptr = getDev(ppList, endpoint->addr, endpoint->port);
 135     if(!ptr)
 136     {
 137         ptr = (OCDirectPairingDev_t *)OICCalloc(1, sizeof (OCDirectPairingDev_t));
 138         if (NULL == ptr)
 139         {
 140             OIC_LOG(ERROR, TAG, "Error while allocating memory for linkedlist node !!");
 141             return OC_STACK_NO_MEMORY;
 142         }
 143
 144         memcpy(&ptr->endpoint, endpoint, sizeof(OCDevAddr));
 145         ptr->connType = conn;
 146         ptr->securePort = DEFAULT_SECURE_PORT;
 147         ptr->edp = pconf->edp;
 148         ptr->prm = pconf->prm;
 149         pconf->prm = NULL;  // to prevent free
 150         ptr->prmLen = pconf->prmLen;
 151         memcpy(&ptr->deviceID, &pconf->deviceID, sizeof(OicUuid_t));
 152         memcpy(&ptr->rowner, &pconf->rownerID, sizeof(OicUuid_t));
 153         ptr->next = NULL;
 154
 155         LL_PREPEND(*ppList, ptr);
 156         OIC_LOG(INFO, TAG, "device added !");
 157     }
 158
 159     return OC_STACK_OK;
 160 }
 161
 162
 163 /**
 164  * Add device information to list.
 165  *
 166  * @param[in] ppList         List of OCProvisionDev_t.
 167  * @param[in] pDev          target device.
 168  *
 169  * @return OC_STACK_OK for success and errorcode otherwise.
 170  */
 171 OCStackResult addDev2(OCDirectPairingDev_t **ppList, OCDirectPairingDev_t *pDev)
 172 {
 173     if(NULL == pDev)
 174     {
 175         OIC_LOG_V(ERROR, TAG, "Invalid Input parameters in [%s]\n", __FUNCTION__);
 176         return OC_STACK_INVALID_PARAM;
 177     }
 178
 179     OCDirectPairingDev_t *ptr = getDev(ppList, pDev->endpoint.addr, pDev->endpoint.port);
 180     if(!ptr)
 181     {
 182         ptr = (OCDirectPairingDev_t *)OICCalloc(1, sizeof (OCDirectPairingDev_t));
 183         if (NULL == ptr)
 184         {
 185             OIC_LOG(ERROR, TAG, "Error while allocating memory for linkedlist node !!");
 186             return OC_STACK_NO_MEMORY;
 187         }
 188
 189         memcpy(&ptr->endpoint, &pDev->endpoint, sizeof(OCDevAddr));
 190         ptr->connType = pDev->connType;
 191         ptr->securePort = pDev->securePort;
 192         ptr->edp = pDev->edp;
 193         ptr->prmLen = pDev->prmLen;
 194         ptr->prm = (OicSecPrm_t*)OICCalloc(ptr->prmLen, sizeof (OicSecPrm_t));
 195         if (NULL == ptr->prm)
 196         {
 197             OIC_LOG(ERROR, TAG, "Error while allocating memory for prm !!");
 198             OICFree(ptr);
 199             return OC_STACK_NO_MEMORY;
 200         }
 201         memcpy(ptr->prm, pDev->prm, sizeof(OicSecPrm_t)*ptr->prmLen);
 202         memcpy(&ptr->deviceID, &pDev->deviceID, sizeof(OicUuid_t));
 203         memcpy(&ptr->rowner, &pDev->rowner, sizeof(OicUuid_t));
 204         ptr->next = NULL;
 205
 206         LL_PREPEND(*ppList, ptr);
 207         OIC_LOG(INFO, TAG, "device added !");
 208     }
 209
 210     return OC_STACK_OK;
 211 }
 212
 213
 214
 215 /**
 216  * This function deletes list of provision target devices
 217  *
 218  * @param[in] pDevicesList         List of OCProvisionDev_t.
 219  */
 220 void delList(OCDirectPairingDev_t *pList)
 221 {
 222     if(pList)
 223     {
 224         OCDirectPairingDev_t *del = NULL, *tmp = NULL;
 225         LL_FOREACH_SAFE(pList, del, tmp)
 226         {
 227             LL_DELETE(pList, del);
 228             if (del && del->prm)
 229             {
 230                 OICFree(del->prm);
 231             }
 232         }
 233     }
 234 }
 235
 236 bool DPGenerateQuery(bool isSecure,
 237                      const char* address, const uint16_t port,
 238                      const OCConnectivityType connType,
 239                      char* buffer, size_t bufferSize, const char* uri)
 240 {
 241     if(!address || !buffer || !uri)
 242     {
 243         OIC_LOG(ERROR, TAG, "DPGenerateQuery : Invalid parameters.");
 244         return false;
 245     }
 246
 247     static char QPREFIX_COAP[] =  "coap://";
 248     static char QPREFIX_COAPS[] = "coaps://";
 249     static char QPREFIX_COAP_TCP[] =  "coap+tcp://";
 250     static char QPREFIX_COAPS_TCP[] = "coaps+tcp://";
 251
 252     int snRet = 0;
 253     char* prefix = (isSecure == true) ? QPREFIX_COAPS : QPREFIX_COAP;
 254
 255     switch(connType & CT_MASK_ADAPTER)
 256     {
 257 // @todo: Remove this ifdef. On Arduino, CT_ADAPTER_TCP resolves to the same value
 258 // as CT_ADAPTER_IP, resulting in a compiler error.
 259 #ifdef WITH_TCP
 260 #ifndef WITH_ARDUINO
 261         case CT_ADAPTER_TCP:
 262             prefix = (isSecure == true) ? QPREFIX_COAPS_TCP : QPREFIX_COAP_TCP;
 263             /*FALLTHROUGH*/
 264 #endif
 265 #endif
 266         case CT_ADAPTER_IP:
 267             switch(connType & CT_MASK_FLAGS & ~CT_FLAG_SECURE)
 268             {
 269                 case CT_IP_USE_V4:
 270                     snRet = snprintf(buffer, bufferSize, "%s%s:%d%s",
 271                                      prefix, address, port, uri);
 272                     break;
 273                 case CT_IP_USE_V6:
 274                 {
 275                     char addressEncoded[CA_MAX_URI_LENGTH] = {0};
 276
 277                     OCStackResult result = OCEncodeAddressForRFC6874(addressEncoded,
 278                                                                      sizeof(addressEncoded),
 279                                                                      address);
 280                     if (OC_STACK_OK != result)
 281                     {
 282                         OIC_LOG_V(ERROR, TAG, "DPGenerateQuery : encoding error %d\n", result);
 283                         return false;
 284                     }
 285
 286                     snRet = snprintf(buffer, bufferSize, "%s[%s]:%d%s",
 287                                      prefix, addressEncoded, port, uri);
 288                     break;
 289                 }
 290                 default:
 291                     OIC_LOG(ERROR, TAG, "Unknown address format.");
 292                     return false;
 293             }
 294             // snprintf return value check
 295             if (snRet < 0)
 296             {
 297                 OIC_LOG_V(ERROR, TAG, "DPGenerateQuery : Error (snprintf) %d\n", snRet);
 298                 return false;
 299             }
 300             else if ((size_t)snRet >= bufferSize)
 301             {
 302                 OIC_LOG_V(ERROR, TAG, "DPGenerateQuery : Truncated (snprintf) %d\n", snRet);
 303                 return false;
 304             }
 305
 306             break;
 307 #ifndef WITH_ARDUINO
 308         // TODO: We need to verify tinyDTLS in below cases
 309         case CT_ADAPTER_GATT_BTLE:
 310         case CT_ADAPTER_RFCOMM_BTEDR:
 311             OIC_LOG(ERROR, TAG, "Not supported connectivity adapter.");
 312             return false;
 313             break;
 314 #endif
 315         default:
 316             OIC_LOG(ERROR, TAG, "Unknown connectivity adapter.");
 317             return false;
 318     }
 319
 320     return true;
 321 }
 322
 323 const OCDirectPairingDev_t* DPGetDiscoveredDevices()
 324 {
 325     return g_dp_discover;
 326 }
 327
 328 const OCDirectPairingDev_t* DPGetPairedDevices()
 329 {
 330     return g_dp_paired;
 331 }
 332
 333 void DPDeleteLists()
 334 {
 335     delList(g_dp_discover);
 336     delList(g_dp_paired);
 337 }
 338
 339 /**
 340  * Callback handler of FinalizeDirectPairing.
 341  *
 342  * @param[in] ctx             ctx value passed to callback from calling function.
 343  * @param[in] UNUSED          handle to an invocation
 344  * @param[in] clientResponse  Response from queries to remote servers.
 345  * @return  OC_STACK_DELETE_TRANSACTION to delete the transaction
 346  *          and  OC_STACK_KEEP_TRANSACTION to keep it.
 347  */
 348 static OCStackApplicationResult DirectPairingFinalizeHandler(void *ctx, OCDoHandle UNUSED,
 349                                                   OCClientResponse *clientResponse)
 350 {
 351     OIC_LOG_V(INFO, TAG, "IN DirectPairingFinalizeHandler()");
 352     (void)UNUSED;
 353     if(NULL == ctx)
 354     {
 355         OIC_LOG(ERROR, TAG, "Context is Null");
 356         return OC_STACK_DELETE_TRANSACTION;
 357     }
 358
 359     OCStackResult res;
 360     DPairData_t *dpairData = (DPairData_t*)ctx;
 361     OCDirectPairingDev_t *peer = dpairData->peer;
 362     OCDirectPairingResultCB resultCallback = dpairData->resultCallback;
 363
 364     if (clientResponse)
 365     {
 366         if(OC_STACK_RESOURCE_CHANGED == clientResponse->result)
 367         {
 368             // result
 369             OIC_LOG(INFO, TAG, "DirectPairingFinalizeHandler : success PUT"
 370                     " request to /oic/sec/dpairing");
 371
 372             CAEndpoint_t endpoint;
 373             memset(&endpoint, 0x00, sizeof(CAEndpoint_t));
 374             OICStrcpy(endpoint.addr, MAX_ADDR_STR_SIZE_CA, peer->endpoint.addr);
 375             endpoint.addr[MAX_ADDR_STR_SIZE_CA - 1] = '\0';
 376             endpoint.port = peer->securePort;
 377
 378             OicUuid_t ptDeviceID = {.id={0}};
 379             if (OC_STACK_OK != GetDoxmDeviceID(&ptDeviceID))
 380             {
 381                 OIC_LOG(ERROR, TAG, "Error while retrieving provisioning tool's device ID");
 382                 resultCallback(dpairData->userCtx, peer, OC_STACK_ERROR);
 383                 return OC_STACK_DELETE_TRANSACTION;
 384             }
 385
 386 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
 387             res = SavePairingPSK((OCDevAddr*)&endpoint, &peer->deviceID, &ptDeviceID, false);
 388             if(OC_STACK_OK != res)
 389             {
 390                 OIC_LOG(ERROR, TAG, "Failed to PairingPSK generation");
 391                 resultCallback(dpairData->userCtx, peer, res);
 392                 return OC_STACK_DELETE_TRANSACTION;
 393             }
 394
 395             //  close temporary sesion
 396             CAResult_t caResult = CAcloseSslSession((const CAEndpoint_t*)&endpoint);
 397             if(CA_STATUS_OK != caResult)
 398             {
 399                 OIC_LOG(INFO, TAG, "Fail to close temporary dtls session");
 400             }
 401 #endif // __WITH_DTLS__ or __WITH_TLS__
 402
 403             OIC_LOG(INFO, TAG, "Direct-Papring was successfully completed.");
 404
 405             // update paired list
 406             OCDirectPairingDev_t *dev = getDev(&g_dp_discover, peer->endpoint.addr,
 407                     peer->endpoint.port);
 408             res = addDev2(&g_dp_paired, dev);
 409             if (OC_STACK_OK != res)
 410             {
 411                 OIC_LOG(ERROR, TAG, "Error while adding a device to paired list.");
 412             }
 413
 414             resultCallback(dpairData->userCtx, peer, OC_STACK_OK);
 415
 416             return OC_STACK_DELETE_TRANSACTION;
 417         }
 418         else
 419         {
 420             OIC_LOG(INFO, TAG, "Direct-Papring received error response.");
 421         }
 422     }
 423     else
 424     {
 425         OIC_LOG(ERROR, TAG, "DirectPairingFinalizeHandler received Null clientResponse");
 426     }
 427
 428     resultCallback(dpairData->userCtx, peer, OC_STACK_ERROR);
 429     OICFree(dpairData);
 430     return OC_STACK_DELETE_TRANSACTION;
 431 }
 432
 433 /**
 434  * Finalize direct-pairing .
 435  *
 436  * @param[in] peer  target device to establish direct-pairing.
 437  * @param[in] resultCallback  result event callback.
 438  *
 439  * @return OC_STACK_OK on success otherwise error.
 440  */
 441 OCStackResult FinalizeDirectPairing(void *ctx, OCDirectPairingDev_t* peer,
 442                                                      OCDirectPairingResultCB resultCallback)
 443 {
 444     if(NULL == peer)
 445     {
 446         return OC_STACK_INVALID_PARAM;
 447     }
 448
 449     OicUuid_t deviceID =   {.id={0}};
 450     if (OC_STACK_OK != GetDoxmDeviceID(&deviceID))
 451     {
 452         OIC_LOG(ERROR, TAG, "Error while retrieving device ID");
 453         return OC_STACK_ERROR;
 454     }
 455
 456     OicSecDpairing_t dpair;
 457     memset(&dpair, 0, sizeof(OicSecDpairing_t));
 458     dpair.spm = (OicSecPrm_t)PRM_NOT_ALLOWED;
 459     memcpy(&dpair.pdeviceID, &deviceID, sizeof(OicUuid_t));
 460
 461     OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
 462     if(!secPayload)
 463     {
 464         OIC_LOG(ERROR, TAG, "Failed to memory allocation");
 465         return OC_STACK_NO_MEMORY;
 466     }
 467     secPayload->base.type = PAYLOAD_TYPE_SECURITY;
 468
 469     OCStackResult ret = DpairingToCBORPayload(&dpair, &(secPayload->securityData),
 470             &(secPayload->payloadSize));
 471
 472     if(OC_STACK_OK != ret)
 473     {
 474         OICFree(secPayload);
 475         OIC_LOG(ERROR, TAG, "Failed to DpairingToCBORPayload");
 476         return OC_STACK_NO_MEMORY;
 477     }
 478     OIC_LOG(DEBUG, TAG, "DPARING CBOR data:");
 479     OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize);
 480
 481     char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
 482     if(!DPGenerateQuery(true,
 483                         peer->endpoint.addr,
 484                         peer->securePort,
 485                         peer->connType,
 486                         query, sizeof(query), OIC_RSRC_DPAIRING_URI))
 487     {
 488         OIC_LOG(ERROR, TAG, "DPDirectPairing : Failed to generate query");
 489         return OC_STACK_ERROR;
 490     }
 491     OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
 492
 493     DPairData_t *dpairData = (DPairData_t *) OICCalloc(1, sizeof(DPairData_t));
 494     if (dpairData == NULL)
 495     {
 496         OICFree(secPayload->securityData);
 497         OICFree(secPayload);
 498         OIC_LOG(ERROR, TAG, "Unable to allocate memory");
 499         return OC_STACK_NO_MEMORY;
 500     }
 501     dpairData->peer = peer;
 502     dpairData->resultCallback = resultCallback;
 503     dpairData->userCtx = ctx;
 504
 505     OCCallbackData cbData =  {.context=NULL, .cb=NULL, .cd=NULL};
 506     cbData.cb = DirectPairingFinalizeHandler;
 507     cbData.context = (void*)dpairData;
 508     cbData.cd = NULL;
 509
 510     OCMethod method = OC_REST_PUT;
 511     OCDoHandle handle = NULL;
 512     OIC_LOG(DEBUG, TAG, "Sending DPAIRNG setting to resource server");
 513     ret = OCDoResource(&handle, method, query,
 514             &peer->endpoint, (OCPayload*)secPayload,
 515             peer->connType, OC_LOW_QOS, &cbData, NULL, 0);
 516     if(OC_STACK_OK != ret)
 517     {
 518         OIC_LOG(ERROR, TAG, "error in OCDoResource");
 519         return OC_STACK_ERROR;
 520     }
 521
 522     return OC_STACK_OK;
 523  }
 524
 525 /**
 526  * Function to handle the handshake result in Direct-Pairing.
 527  * This function will be invoked after DTLS handshake
 528  * @param   endPoint  [IN] The remote endpoint.
 529  * @param   errorInfo [IN] Error information from the endpoint.
 530  * @return  NONE
 531  */
 532 void DirectPairingDTLSHandshakeCB(const CAEndpoint_t *endpoint, const CAErrorInfo_t *info)
 533 {
 534     OIC_LOG_V(INFO, TAG, "IN DirectPairingDTLSHandshakeCB");
 535
 536
 537     if(g_dp_proceed_ctx && g_dp_proceed_ctx->peer && endpoint && info)
 538     {
 539         OIC_LOG_V(INFO, TAG, "Received status from remote device(%s:%d) : %d",
 540                  endpoint->addr, endpoint->port, info->result);
 541
 542         OCDirectPairingDev_t *peer = g_dp_proceed_ctx->peer;
 543         OCDirectPairingResultCB resultCallback = g_dp_proceed_ctx->resultCallback;
 544         OCStackResult res;
 545
 546         //Make sure the address matches.
 547         if(strncmp(peer->endpoint.addr, endpoint->addr, sizeof(endpoint->addr)) == 0 &&
 548                          peer->securePort == endpoint->port)
 549         {
 550             //In case of success, send next coaps request.
 551             if(CA_STATUS_OK == info->result)
 552             {
 553                 OIC_LOG(INFO, TAG, "Now, finalize Direct-Pairing procedure.");
 554
 555                 res = FinalizeDirectPairing(g_dp_proceed_ctx->userCtx, peer, resultCallback);
 556                 if(OC_STACK_OK != res)
 557                 {
 558                     OIC_LOG(ERROR, TAG, "Failed to finalize direct-pairing");
 559                     resultCallback(g_dp_proceed_ctx->userCtx, peer, res);
 560                 }
 561             }
 562             else if(CA_DTLS_AUTHENTICATION_FAILURE == info->result)
 563             {
 564                 OIC_LOG(INFO, TAG, "DirectPairingDTLSHandshakeCB - Authentication failed");
 565                 resultCallback(g_dp_proceed_ctx->userCtx, peer, OC_STACK_AUTHENTICATION_FAILURE);
 566             }
 567
 568 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
 569             CAregisterSslHandshakeCallback(NULL);
 570 #endif // __WITH_DTLS__ or __WITH_TLS__
 571             res = RemoveCredential(&peer->deviceID);
 572             if(OC_STACK_RESOURCE_DELETED != res)
 573             {
 574                 OIC_LOG_V(ERROR, TAG, "Failed to remove temporal PSK : %d", res);
 575             }
 576
 577             OICFree(g_dp_proceed_ctx);
 578             g_dp_proceed_ctx = NULL;
 579         }
 580         else
 581         {
 582             OIC_LOG_V(INFO, TAG, "DirectPairingDTLSHandshakeCB - Not matched to peer address");
 583         }
 584     }
 585
 586     OIC_LOG_V(INFO, TAG, "OUT DirectPairingDTLSHandshakeCB");
 587 }
 588
 589 /**
 590  * Callback handler of DPDirectPairing.
 591  *
 592  * @param[in] ctx             ctx value passed to callback from calling function.
 593  * @param[in] UNUSED          handle to an invocation
 594  * @param[in] clientResponse  Response from queries to remote servers.
 595  * @return  OC_STACK_DELETE_TRANSACTION to delete the transaction
 596  *          and  OC_STACK_KEEP_TRANSACTION to keep it.
 597  */
 598 static OCStackApplicationResult DirectPairingHandler(void *ctx, OCDoHandle UNUSED,
 599                                                   OCClientResponse *clientResponse)
 600 {
 601     OIC_LOG_V(INFO, TAG, "IN DirectPairingHandler.");
 602     (void)UNUSED;
 603     if(NULL == ctx)
 604     {
 605         OIC_LOG(ERROR, TAG, "Context is Null");
 606         return OC_STACK_DELETE_TRANSACTION;
 607     }
 608
 609     OCStackResult res = OC_STACK_ERROR;
 610     DPairData_t *dpairData = (DPairData_t*)ctx;
 611     OCDirectPairingResultCB resultCallback = (OCDirectPairingResultCB)dpairData->resultCallback;
 612     OicUuid_t subjectId = {.id={0}};
 613
 614     if (clientResponse)
 615     {
 616         if(OC_STACK_RESOURCE_CHANGED == clientResponse->result)
 617         {
 618             // result
 619             OIC_LOG(INFO, TAG, "DirectPairingHandler : success POST request to /oic/sec/dpairing");
 620
 621 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
 622             // Add temporary psk
 623             res = AddTmpPskWithPIN(&dpairData->peer->deviceID,
 624                            SYMMETRIC_PAIR_WISE_KEY,
 625                            (char*)dpairData->pin, DP_PIN_LENGTH,
 626                            &dpairData->peer->rowner, &subjectId);
 627             VERIFY_SUCCESS(TAG, OC_STACK_OK == res, ERROR);
 628
 629
 630             // Start to establish a secure channel with Pin-based PSK cipher suite
 631             CAResult_t caresult;
 632
 633             caresult = CAEnableAnonECDHCipherSuite(false);
 634             VERIFY_SUCCESS(TAG, CA_STATUS_OK == caresult, ERROR);
 635
 636             caresult = CASelectCipherSuite(MBEDTLS_TLS_ECDHE_PSK_WITH_AES_128_CBC_SHA256, CA_ADAPTER_IP);
 637             VERIFY_SUCCESS(TAG, CA_STATUS_OK == caresult, ERROR);
 638
 639             //Register proceeding peer info. & DTLS event handler to catch the dtls event while handshake
 640             g_dp_proceed_ctx = dpairData;
 641             res = CAregisterSslHandshakeCallback(DirectPairingDTLSHandshakeCB);
 642             VERIFY_SUCCESS(TAG, CA_STATUS_OK == caresult, ERROR);
 643
 644             // initiate dtls
 645             CAEndpoint_t *endpoint = (CAEndpoint_t *)OICCalloc(1, sizeof (CAEndpoint_t));
 646             VERIFY_NON_NULL(TAG, endpoint, FATAL);
 647             memcpy(endpoint,&dpairData->peer->endpoint,sizeof(CAEndpoint_t));
 648             endpoint->port = dpairData->peer->securePort;
 649             OIC_LOG_V(INFO, TAG, "Initiate DTLS handshake to %s(%d)", endpoint->addr,
 650                     endpoint->port);
 651
 652             caresult = CAInitiateHandshake(endpoint);
 653             OICFree(endpoint);
 654             VERIFY_SUCCESS(TAG, CA_STATUS_OK == caresult, ERROR);
 655 #endif // __WITH_DTLS__ or __WITH_TLS__
 656
 657             res = OC_STACK_OK;
 658         }
 659         else
 660         {
 661             // result
 662             OIC_LOG(INFO, TAG, "DirectPairingHandler : fail POST request to /oic/sec/dpairing");
 663         }
 664     }
 665     else
 666     {
 667         OIC_LOG(ERROR, TAG, "DirectPairingHandler received Null clientResponse");
 668     }
 669
 670 #if defined(__WITH_DTLS__) || defined(__WITH_TLS__)
 671 exit:
 672 #endif // __WITH_DTLS__ or __WITH_TLS__
 673
 674     if (OC_STACK_OK != res)
 675     {
 676         if (0 < strlen((const char*)subjectId.id))
 677         {
 678             RemoveCredential(&dpairData->peer->deviceID);
 679             OICFree(dpairData);
 680             g_dp_proceed_ctx = NULL;
 681             OIC_LOG_V(INFO, TAG, "OUT DirectPairingHandler.");
 682             return OC_STACK_DELETE_TRANSACTION;
 683         }
 684
 685         resultCallback(dpairData->userCtx, dpairData->peer, res);
 686     }
 687     OIC_LOG_V(INFO, TAG, "OUT DirectPairingHandler.");
 688     return OC_STACK_DELETE_TRANSACTION;
 689 }
 690
 691 /**
 692  * Start direct-pairing .
 693  *
 694  * @param[in] peer  target device to establish direct-pairing.
 695  * @param[in] pmSel  selected pairing method.
 696  * @param[in] pinNumber  secret value for dtls connection.
 697  *
 698  * @return OC_STACK_OK on success otherwise error.
 699  */
 700 OCStackResult DPDirectPairing(void *ctx, OCDirectPairingDev_t* peer, OicSecPrm_t pmSel,
 701                                 char *pinNumber, OCDirectPairingResultCB resultCallback)
 702 {
 703     if(NULL == peer || NULL == pinNumber)
 704     {
 705         return OC_STACK_INVALID_PARAM;
 706     }
 707
 708     OicUuid_t deviceID =   {.id={0}};
 709     if (OC_STACK_OK != GetDoxmDeviceID(&deviceID))
 710     {
 711         OIC_LOG(ERROR, TAG, "Error while retrieving device ID");
 712         return OC_STACK_ERROR;
 713     }
 714
 715     OicSecDpairing_t dpair;
 716     memset(&dpair, 0, sizeof(OicSecDpairing_t));
 717     dpair.spm = pmSel;
 718     memcpy(&dpair.pdeviceID, &deviceID, sizeof(OicUuid_t));
 719
 720     OCSecurityPayload* secPayload = (OCSecurityPayload*)OICCalloc(1, sizeof(OCSecurityPayload));
 721     if(!secPayload)
 722     {
 723         OIC_LOG(ERROR, TAG, "Failed to memory allocation");
 724         return OC_STACK_NO_MEMORY;
 725     }
 726     secPayload->base.type = PAYLOAD_TYPE_SECURITY;
 727
 728     OCStackResult ret = DpairingToCBORPayload(&dpair, &(secPayload->securityData),
 729             &(secPayload->payloadSize));
 730
 731     if(OC_STACK_OK != ret)
 732     {
 733         OICFree(secPayload);
 734         OIC_LOG(ERROR, TAG, "Failed to DpairingToCBORPayload");
 735         return OC_STACK_NO_MEMORY;
 736     }
 737     OIC_LOG(DEBUG, TAG, "DPARING CBOR data:");
 738     OIC_LOG_BUFFER(DEBUG, TAG, secPayload->securityData, secPayload->payloadSize);
 739
 740     char query[MAX_URI_LENGTH + MAX_QUERY_LENGTH] = {0};
 741     if(!DPGenerateQuery(false,
 742                         peer->endpoint.addr,
 743                         peer->endpoint.port,
 744                         //peer->securePort,
 745                         peer->connType,
 746                         query, sizeof(query), OIC_RSRC_DPAIRING_URI))
 747     {
 748         OIC_LOG(ERROR, TAG, "DPDirectPairing : Failed to generate query");
 749         return OC_STACK_ERROR;
 750     }
 751     OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
 752
 753     DPairData_t *dpairData = (DPairData_t *) OICCalloc(1, sizeof(DPairData_t));
 754     if (dpairData == NULL)
 755     {
 756         OICFree(secPayload->securityData);
 757         OICFree(secPayload);
 758         OIC_LOG(ERROR, TAG, "Unable to allocate memory");
 759         return OC_STACK_NO_MEMORY;
 760     }
 761     dpairData->peer = peer;
 762     memcpy(dpairData->pin, pinNumber, DP_PIN_LENGTH);
 763     dpairData->resultCallback = resultCallback;
 764     dpairData->userCtx = ctx;
 765
 766     OCCallbackData cbData =  {.context=NULL, .cb=NULL, .cd=NULL};
 767     cbData.cb = DirectPairingHandler;
 768     cbData.context = (void*)dpairData;
 769     cbData.cd = NULL;
 770
 771     OCMethod method = OC_REST_POST;
 772     OCDoHandle handle = NULL;
 773     OIC_LOG(DEBUG, TAG, "Sending DPAIRNG setting to resource server");
 774     ret = OCDoResource(&handle, method, query,
 775             &peer->endpoint, (OCPayload*)secPayload,
 776             peer->connType, OC_LOW_QOS, &cbData, NULL, 0);
 777     if(OC_STACK_OK != ret)
 778     {
 779         OIC_LOG(ERROR, TAG, "error in OCDoResource");
 780         return OC_STACK_ERROR;
 781     }
 782
 783     return OC_STACK_OK;
 784
 785  }
 786
 787 /**
 788  * Callback handler for getting secure port information using /oic/res discovery.
 789  *
 790  * @param[in] ctx             user context
 791  * @param[in] handle          Handle for response
 792  * @param[in] clientResponse  Response information(It will contain payload)
 793  *
 794  * @return OC_STACK_KEEP_TRANSACTION to keep transaction and
 795  *         OC_STACK_DELETE_TRANSACTION to delete it.
 796  */
 797 static OCStackApplicationResult DirectPairingPortDiscoveryHandler(void *ctx, OCDoHandle UNUSED,
 798                                  OCClientResponse *clientResponse)
 799 {
 800     OIC_LOG(INFO, TAG, "Callback Context for Direct-Pairing Secure Port DISCOVER "
 801             "query recvd successfully");
 802
 803     (void)ctx;
 804     (void)UNUSED;
 805     if (clientResponse)
 806     {
 807         if  (NULL == clientResponse->payload)
 808         {
 809             OIC_LOG(INFO, TAG, "Skiping Null payload");
 810         }
 811         else
 812         {
 813             if (PAYLOAD_TYPE_DISCOVERY != clientResponse->payload->type)
 814             {
 815                 OIC_LOG(INFO, TAG, "Wrong payload type");
 816                 return OC_STACK_DELETE_TRANSACTION;
 817             }
 818
 819             uint16_t securePort = 0;
 820             OCResourcePayload* resPayload = ((OCDiscoveryPayload*)clientResponse->payload)->resources;
 821             OIC_LOG_PAYLOAD(INFO, clientResponse->payload);
 822
 823             if (resPayload && resPayload->secure)
 824             {
 825                 securePort = resPayload->port;
 826             }
 827             else
 828             {
 829                 OIC_LOG(INFO, TAG, "Can not find secure port information.");
 830                 return OC_STACK_DELETE_TRANSACTION;
 831             }
 832
 833             OCDirectPairingDev_t *ptr = getDev(&g_dp_discover,
 834                     clientResponse->devAddr.addr, clientResponse->devAddr.port);
 835             if(!ptr)
 836             {
 837                 OIC_LOG(ERROR, TAG, "Can not find device information in the discovery device list");
 838                 return OC_STACK_DELETE_TRANSACTION;
 839             }
 840             ptr->securePort = securePort;
 841
 842             OIC_LOG(INFO, TAG, "Exiting DirectPairingPortDiscoveryHandler.");
 843         }
 844
 845         return  OC_STACK_DELETE_TRANSACTION;
 846     }
 847     else
 848     {
 849         OIC_LOG(INFO, TAG, "Skiping Null response");
 850     }
 851     return  OC_STACK_DELETE_TRANSACTION;
 852 }
 853
 854 /**
 855  * Callback handler for DPDeviceDiscovery API.
 856  *
 857  * @param[in] ctx             User context
 858  * @param[in] handle          Handler for response
 859  * @param[in] clientResponse  Response information (It will contain payload)
 860  * @return OC_STACK_KEEP_TRANSACTION to keep transaction and
 861  *         OC_STACK_DELETE_TRANSACTION to delete it.
 862  */
 863 static OCStackApplicationResult DirectPairingDiscoveryHandler(void* ctx, OCDoHandle UNUSED,
 864         OCClientResponse * clientResponse)
 865 {
 866     OIC_LOG(INFO, TAG, "Callback Context for Direct-Pairing DISCOVER query recvd successfully");
 867
 868     (void)ctx;
 869     (void)UNUSED;
 870     if (clientResponse)
 871     {
 872         OIC_LOG_V(INFO, TAG, "StackResult: %d", clientResponse->result);
 873         OIC_LOG_V(INFO, TAG,
 874                 "Device =============> Discovered @ %s:%d",
 875                 clientResponse->devAddr.addr,
 876                 clientResponse->devAddr.port);
 877
 878         if  (NULL == clientResponse->payload)
 879         {
 880             OIC_LOG(INFO, TAG, "Skiping Null payload");
 881             return OC_STACK_KEEP_TRANSACTION;
 882         }
 883         if (OC_STACK_OK != clientResponse->result)
 884         {
 885             OIC_LOG(INFO, TAG, "Error in response");
 886             return OC_STACK_KEEP_TRANSACTION;
 887         }
 888
 889         OIC_LOG_PAYLOAD(INFO, clientResponse->payload);
 890         OicSecPconf_t *pconf = NULL;
 891
 892         OCStackResult res = CBORPayloadToPconf(
 893                 ((OCSecurityPayload*)clientResponse->payload)->securityData,
 894                 CBOR_SIZE,&pconf);
 895         if (OC_STACK_OK != res )
 896         {
 897             OIC_LOG(INFO, TAG, "Ignoring malformed CBOR");
 898             return OC_STACK_KEEP_TRANSACTION;
 899         }
 900         else
 901         {
 902             if(pconf->edp)
 903             {
 904                 OCDevAddr endpoint;
 905                 memcpy(&endpoint, &clientResponse->devAddr, sizeof(OCDevAddr));
 906
 907                 OCStackResult res = addDev(&g_dp_discover, &endpoint,
 908                             clientResponse->connType, pconf);
 909                 DeletePconfBinData(pconf);
 910                 if (OC_STACK_OK != res)
 911                 {
 912                     OIC_LOG(ERROR, TAG, "Error while adding data to linkedlist.");
 913                     return OC_STACK_KEEP_TRANSACTION;
 914                 }
 915
 916
 917                 char rsrc_uri[MAX_URI_LENGTH+1] = {0};
 918                 int wr_len = snprintf(rsrc_uri, sizeof(rsrc_uri), "%s?%s=%s",
 919                           OC_RSRVD_WELL_KNOWN_URI, OC_RSRVD_RESOURCE_TYPE, OIC_RSRC_TYPE_SEC_DPAIRING);
 920                 if(wr_len <= 0 || (size_t)wr_len >= sizeof(rsrc_uri))
 921                 {
 922                     OIC_LOG(ERROR, TAG, "rsrc_uri_string_print failed");
 923                     return OC_STACK_KEEP_TRANSACTION;
 924                 }
 925
 926                 //Try to the unicast discovery to getting secure port
 927                 char query[MAX_URI_LENGTH+MAX_QUERY_LENGTH+1] = {0};
 928                 if(!DPGenerateQuery(false,
 929                                     clientResponse->devAddr.addr, clientResponse->devAddr.port,
 930                                     clientResponse->connType,
 931                                     query, sizeof(query), rsrc_uri))
 932                 {
 933                     OIC_LOG(ERROR, TAG, "DirectPairingDiscoveryHandler : Failed to generate query");
 934                     return OC_STACK_KEEP_TRANSACTION;
 935                 }
 936                 OIC_LOG_V(DEBUG, TAG, "Query=%s", query);
 937
 938                 OCCallbackData cbData;
 939                 cbData.cb = &DirectPairingPortDiscoveryHandler;
 940                 cbData.context = NULL;
 941                 cbData.cd = NULL;
 942                 OCStackResult ret = OCDoResource(NULL, OC_REST_DISCOVER, query, 0, 0,
 943                         clientResponse->connType, OC_LOW_QOS, &cbData, NULL, 0);
 944                 if(OC_STACK_OK != ret)
 945                 {
 946                     OIC_LOG(ERROR, TAG, "Failed to Secure Port Discovery");
 947                     return OC_STACK_KEEP_TRANSACTION;
 948                 }
 949                 else
 950                 {
 951                     OIC_LOG_V(INFO, TAG, "OCDoResource with [%s] Success", query);
 952                 }
 953             }
 954             return  OC_STACK_KEEP_TRANSACTION;
 955         }
 956     }
 957     else
 958     {
 959         OIC_LOG(INFO, TAG, "Skiping Null response");
 960     }
 961
 962     return OC_STACK_DELETE_TRANSACTION;
 963 }
 964 #ifndef WITH_ARDUINO
 965 /**
 966  * Discover direct-pairing devices in the same IP subnet. .
 967  *
 968  * @param[in] waittime  Timeout in seconds.
 969  *
 970  * @return OC_STACK_OK on success otherwise error.
 971  */
 972 OCStackResult DPDeviceDiscovery(unsigned short waittime)
 973 {
 974     OIC_LOG(DEBUG, TAG, "IN DPDeviceDiscovery");
 975
 976     if (g_dp_discover)
 977     {
 978         delList(g_dp_discover);
 979         g_dp_discover = NULL;
 980     }
 981
 982     OCStackResult ret;
 983
 984     const char DP_DISCOVERY_QUERY[] = "/oic/sec/pconf";
 985
 986     OCCallbackData cbData;
 987     cbData.cb = DirectPairingDiscoveryHandler;
 988     cbData.context = NULL;
 989     cbData.cd = NULL;
 990
 991     /* Start a DP discovery query*/
 992     OIC_LOG_V(INFO, TAG, "Initiating Direct-Pairing Discovery : %s\n", DP_DISCOVERY_QUERY);
 993     OCDoHandle handle = NULL;
 994     ret = OCDoResource(&handle, OC_REST_DISCOVER, DP_DISCOVERY_QUERY, 0, 0, CT_DEFAULT,
 995                        OC_LOW_QOS, &cbData, NULL, 0);
 996     if (ret != OC_STACK_OK)
 997     {
 998         OIC_LOG(ERROR, TAG, "OCStack resource error");
 999         return ret;
1000     }
1001
1002     // wait..
1003
1004     int clock_res = -1;
1005 #if defined(_MSC_VER)
1006     time_t startTime = NULL;
1007     clock_res = (time(&startTime) == -1);
1008 #else
1009     struct timespec startTime = {.tv_sec=0, .tv_nsec=0};
1010 #if defined(__ANDROID__) || _POSIX_TIMERS > 0
1011     clock_res = clock_gettime(CLOCK_MONOTONIC, &startTime);
1012 #endif
1013 #endif
1014     if (0 != clock_res)
1015     {
1016         OIC_LOG(ERROR, TAG, "clock error");
1017         if(OC_STACK_OK !=  OCCancel(handle, OC_LOW_QOS, NULL, 0))
1018         {
1019             OIC_LOG(ERROR, TAG, "Failed to remove registered callback");
1020         }
1021         return OC_STACK_ERROR;
1022     }
1023
1024     while (1)
1025     {
1026 #if defined(_MSC_VER)
1027         time_t currTime = NULL;
1028         clock_res = (time(&currTime) == -1);
1029 #else
1030         struct timespec currTime  = {.tv_sec=0, .tv_nsec=0};
1031 #if defined(__ANDROID__) || _POSIX_TIMERS > 0
1032         clock_res = clock_gettime(CLOCK_MONOTONIC, &currTime);
1033 #endif
1034 #endif
1035         if (0 != clock_res)
1036         {
1037             OIC_LOG(ERROR, TAG, "clock error");
1038             ret = OC_STACK_ERROR;
1039             break;
1040         }
1041 #if defined(_MSC_VER)
1042         long elapsed = currTime - startTime;
1043 #else
1044         long elapsed = (currTime.tv_sec - startTime.tv_sec);
1045 #endif
1046         if (elapsed > waittime)
1047         {
1048             break;
1049         }
1050         else
1051         {
1052             struct timespec timeout = {.tv_sec=0, .tv_nsec=100000000L};
1053             OCProcess();
1054             nanosleep(&timeout, NULL);
1055         }
1056     }
1057
1058     // Waiting for each response.
1059     ret = OCCancel(handle, OC_LOW_QOS, NULL, 0);
1060     if (OC_STACK_OK != ret)
1061     {
1062         OIC_LOG(ERROR, TAG, "Failed to remove registered callback");
1063     }
1064     OIC_LOG(DEBUG, TAG, "OUT DPDeviceDiscovery");
1065     return ret;
1066 }
1067 #endif