resource/csdk/security/src/directpairing.c

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