service/easy-setup/sdk/mediator/src/provisioninghandler.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2015 Samsung Electronics All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <signal.h>
  25 #include <unistd.h>
  26 #include "ocpayload.h"
  27 #include "provisioninghandler.h"
  28 #include "common.h"
  29 // External includes
  30
  31 #include "camutex.h"
  32 #include "cathreadpool.h"
  33 #include "logger.h"
  34 #include "oic_malloc.h"
  35
  36 /**
  37  * @var g_provisioningMutex
  38  * @brief Mutex to synchronize access to g_caDtlsContext.
  39  */
  40 static ca_mutex g_provisioningMutex = NULL;
  41 static ca_cond g_provisioningCond = NULL;
  42 bool g_provisioningCondFlag = false;
  43
  44 static EnrolleeNWProvInfo_t* netProvInfo;
  45
  46 /**
  47  * @var cbData
  48  * @brief Callback for providing provisioning status callback to application
  49  */
  50 static OCProvisioningStatusCB cbData = NULL;
  51 static ca_thread_pool_t g_threadPoolHandle = NULL;
  52
  53 void ErrorCallback(ProvStatus status)
  54 {
  55     ProvisioningInfo *provInfo = GetCallbackObjectOnError(status);
  56     cbData(provInfo);
  57 }
  58
  59 OCStackResult InitProvisioningHandler()
  60 {
  61     OCStackResult ret = OC_STACK_ERROR;
  62     /* Initialize OCStack*/
  63     if (OCInit(NULL, 0, OC_CLIENT) != OC_STACK_OK)
  64     {
  65         OIC_LOG(ERROR, TAG, "OCStack init error");
  66         return ret;
  67     }
  68
  69     g_provisioningMutex = ca_mutex_new();
  70
  71     OIC_LOG(DEBUG, TAG, "ca_thread_pool_init initializing");
  72
  73     if (CA_STATUS_OK != ca_thread_pool_init(2, &g_threadPoolHandle))
  74     {
  75         OIC_LOG(DEBUG, TAG, "thread_pool_init failed");
  76         return OC_STACK_ERROR;
  77     }
  78
  79     g_provisioningCond = ca_cond_new();
  80     if (NULL == g_provisioningCond)
  81     {
  82         OIC_LOG(DEBUG, TAG, "Failed to create condition");
  83         ca_mutex_free(g_provisioningMutex);
  84         ca_thread_pool_free(g_threadPoolHandle);
  85         return OC_STACK_ERROR;
  86     }
  87
  88     char *string = "listeningFunc invoked in a thread";
  89     if (CA_STATUS_OK != ca_thread_pool_add_task(g_threadPoolHandle, listeningFunc, (void *) string))
  90     {
  91         OIC_LOG(DEBUG, TAG, "thread_pool_add_task failed");
  92         ca_thread_pool_free(g_threadPoolHandle);
  93         ca_mutex_unlock(g_provisioningMutex);
  94         ca_mutex_free(g_provisioningMutex);
  95         ca_cond_free(g_provisioningCond);
  96         return OC_STACK_ERROR;
  97     }
  98     return OC_STACK_OK;
  99 }
 100
 101 OCStackResult TerminateProvisioningHandler()
 102 {
 103     OCStackResult ret = OC_STACK_ERROR;
 104     if (OCStop() != OC_STACK_OK)
 105     {
 106         OIC_LOG(ERROR, TAG, "OCStack stop error");
 107     }
 108
 109     ca_mutex_lock(g_provisioningMutex);
 110     g_provisioningCondFlag = true;
 111     //ca_cond_signal(g_provisioningCond);
 112     ca_mutex_unlock(g_provisioningMutex);
 113
 114     ca_mutex_free(g_provisioningMutex);
 115     g_provisioningMutex = NULL;
 116
 117     ca_thread_pool_free(g_threadPoolHandle);
 118     g_threadPoolHandle = NULL;
 119
 120     ret = OC_STACK_OK;
 121     return ret;
 122 }
 123
 124 void listeningFunc(void *data)
 125 {
 126     while (!g_provisioningCondFlag)
 127     {
 128         OCStackResult result;
 129
 130         ca_mutex_lock(g_provisioningMutex);
 131         result = OCProcess();
 132         ca_mutex_unlock(g_provisioningMutex);
 133
 134         if (result != OC_STACK_OK)
 135         {
 136             OIC_LOG(ERROR, TAG, "OCStack stop error");
 137         }
 138
 139         // To minimize CPU utilization we may wish to do this with sleep
 140         sleep(1);
 141     }
 142 }
 143
 144 OCStackApplicationResult ProvisionEnrolleeResponse(void* ctx, OCDoHandle handle,
 145         OCClientResponse * clientResponse)
 146 {
 147
 148     ProvisioningInfo *provInfo;
 149
 150     if (!ValidateEnrolleResponse(clientResponse))
 151     {
 152         ErrorCallback( DEVICE_NOT_PROVISIONED);
 153         return OC_STACK_DELETE_TRANSACTION;
 154     }
 155
 156     char* tnn;
 157     char* cd;
 158
 159     OCRepPayload* input = (OCRepPayload*) (clientResponse->payload);
 160
 161     while (input)
 162     {
 163
 164         int64_t ps;
 165         if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_PS, &ps))
 166         {
 167
 168             if (ps == 1)
 169             {
 170                 OIC_LOG_V(DEBUG, TAG, "PS is proper");
 171                 input = input->next;
 172                 continue;
 173             }
 174             else
 175             {
 176                 OIC_LOG_V(DEBUG, TAG, "PS is NOT proper");
 177                 goto Error;
 178
 179             }
 180         }
 181
 182         if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_TNN, &tnn))
 183         {
 184             if (!strcmp(tnn, netProvInfo->netAddressInfo.WIFI.ssid))
 185             {
 186                 OIC_LOG_V(DEBUG, TAG, "SSID is proper");
 187                 input = input->next;
 188                 continue;
 189             }
 190             else
 191             {
 192                 OIC_LOG_V(DEBUG, TAG, "SSID is NOT proper");
 193                 goto Error;
 194             }
 195         }
 196
 197         if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CD, &cd))
 198         {
 199             if (!strcmp(cd, netProvInfo->netAddressInfo.WIFI.pwd))
 200             {
 201                 OIC_LOG_V(DEBUG, TAG, "Password is proper");
 202                 input = input->next;
 203                 continue;
 204             }
 205             else
 206             {
 207                 OIC_LOG_V(DEBUG, TAG, "Password is NOT proper");
 208                 goto Error;
 209             }
 210         }
 211
 212         LogProvisioningResponse(input->values);
 213
 214         input = input->next;
 215
 216     }
 217
 218     SuccessCallback(clientResponse);
 219
 220     return OC_STACK_KEEP_TRANSACTION;
 221
 222     Error:
 223     {
 224
 225         ErrorCallback( DEVICE_NOT_PROVISIONED);
 226
 227         return OC_STACK_DELETE_TRANSACTION;
 228     }
 229
 230 }
 231
 232 OCStackResult ProvisionEnrollee(OCQualityOfService qos, const char* query, const char* resUri,
 233         OCDevAddr *destination)
 234 {
 235     OIC_LOG_V(INFO, TAG, "\n\nExecuting ProvisionEnrollee%s", __func__);
 236
 237     OCRepPayload* payload = OCRepPayloadCreate();
 238
 239     OCRepPayloadSetUri(payload, resUri);
 240     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_TNN, netProvInfo->netAddressInfo.WIFI.ssid);
 241     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CD, netProvInfo->netAddressInfo.WIFI.pwd);
 242
 243     OIC_LOG_V(DEBUG, TAG, "OCPayload ready for ProvisionEnrollee");
 244
 245     OCStackResult ret = InvokeOCDoResource(query, OC_REST_PUT, destination, OC_HIGH_QOS,
 246             ProvisionEnrolleeResponse, payload, NULL, 0);
 247
 248     return ret;
 249 }
 250
 251 OCStackApplicationResult GetProvisioningStatusResponse(void* ctx, OCDoHandle handle,
 252         OCClientResponse * clientResponse)
 253 {
 254
 255     ProvisioningInfo *provInfo;
 256
 257     if (!ValidateEnrolleResponse(clientResponse))
 258     {
 259         ErrorCallback( DEVICE_NOT_PROVISIONED);
 260         ClearMemory();
 261         return OC_STACK_DELETE_TRANSACTION;
 262     }
 263
 264     OCRepPayload* input = (OCRepPayload*) (clientResponse->payload);
 265
 266     char query[OIC_STRING_MAX_VALUE] =
 267     { '\0' };
 268     char resURI[MAX_URI_LENGTH] =
 269     { '\0' };
 270
 271     OIC_LOG_V(DEBUG, TAG, "resUri = %s", input->uri);
 272
 273     strncpy(resURI, input->uri, sizeof(resURI));
 274
 275     snprintf(query, sizeof(query), UNICAST_PROV_STATUS_QUERY, clientResponse->addr->addr, IP_PORT,
 276             resURI);
 277
 278     //OCPayloadLogRep(DEBUG,TAG,input);
 279
 280     if (ProvisionEnrollee(OC_HIGH_QOS, query, OC_RSRVD_ES_URI_PROV, clientResponse->addr)
 281             != OC_STACK_OK)
 282     {
 283         OIC_LOG(INFO, TAG,
 284                 "GetProvisioningStatusResponse received NULL clientResponse.Invoking Provisioing Status Callback");
 285
 286         ErrorCallback( DEVICE_NOT_PROVISIONED);
 287         ClearMemory();
 288         return OC_STACK_DELETE_TRANSACTION;
 289     }
 290
 291     return OC_STACK_KEEP_TRANSACTION;
 292
 293 }
 294
 295 OCStackResult InvokeOCDoResource(const char* query, OCMethod method, const OCDevAddr *dest,
 296         OCQualityOfService qos, OCClientResponseHandler cb, OCRepPayload* payload,
 297         OCHeaderOption * options, uint8_t numOptions)
 298 {
 299     OCStackResult ret;
 300     OCCallbackData cbData;
 301
 302     cbData.cb = cb;
 303     cbData.context = (void*) DEFAULT_CONTEXT_VALUE;
 304     cbData.cd = NULL;
 305
 306     ret = OCDoResource(NULL, method, query, dest, (OCPayload*) payload, OC_CONNTYPE, qos, &cbData,
 307             options, numOptions);
 308
 309     if (ret != OC_STACK_OK)
 310     {
 311         OIC_LOG_V(ERROR, TAG, "OCDoResource returns error %d with method %d", ret, method);
 312     }
 313
 314     return ret;
 315 }
 316
 317 OCStackResult GetProvisioningStatus(OCQualityOfService qos, const char* query,
 318         const OCDevAddr *destination)
 319 {
 320     OCStackResult ret = OC_STACK_ERROR;
 321     OCHeaderOption options[MAX_HEADER_OPTIONS];
 322
 323     OIC_LOG_V(INFO, TAG, "\n\nExecuting %s", __func__);
 324
 325     uint8_t option0[] =
 326     { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
 327     uint8_t option1[] =
 328     { 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 };
 329     memset(options, 0, sizeof(OCHeaderOption) * MAX_HEADER_OPTIONS);
 330     options[0].protocolID = OC_COAP_ID;
 331     options[0].optionID = 2048;
 332     memcpy(options[0].optionData, option0, sizeof(option0));
 333     options[0].optionLength = 10;
 334     options[1].protocolID = OC_COAP_ID;
 335     options[1].optionID = 3000;
 336     memcpy(options[1].optionData, option1, sizeof(option1));
 337     options[1].optionLength = 10;
 338
 339     ret = InvokeOCDoResource(query, OC_REST_GET, destination, OC_HIGH_QOS,
 340             GetProvisioningStatusResponse, NULL, options, 2);
 341     return ret;
 342 }
 343
 344 OCStackResult StartProvisioningProcess(const EnrolleeNWProvInfo_t *netInfo,
 345         OCProvisioningStatusCB provisioningStatusCallback)
 346 {
 347
 348     OCStackResult result = OC_STACK_ERROR;
 349
 350     if (!ValidateEasySetupParams(netInfo, provisioningStatusCallback))
 351     {
 352         goto Error;
 353     }
 354
 355     //Only basis test is done for below API
 356     if (!SetProgress(provisioningStatusCallback))
 357     {
 358         // Device provisioning session is running already.
 359         OIC_LOG(INFO, TAG, PCF("Device provisioning session is running already"));
 360         goto Error;
 361     }
 362
 363     if (!ConfigEnrolleeObject(netInfo))
 364     {
 365         goto Error;
 366     }
 367
 368     if (CA_STATUS_OK != ca_thread_pool_add_task(g_threadPoolHandle, FindProvisioningResource,
 369             (void *) ""))
 370     {
 371         goto Error;
 372     }
 373
 374     return OC_STACK_OK;
 375
 376     Error:
 377     {
 378         ErrorCallback( DEVICE_NOT_PROVISIONED);
 379         ClearMemory();
 380         return OC_STACK_ERROR;
 381     }
 382
 383 }
 384
 385 void StopProvisioningProcess()
 386 {
 387     //Only basis test is done for below API
 388     ResetProgress();
 389 }
 390
 391 // This is a function called back when a device is discovered
 392 OCStackApplicationResult FindProvisioningResourceResponse(void* ctx, OCDoHandle handle,
 393         OCClientResponse * clientResponse)
 394 {
 395
 396     OIC_LOG(INFO, TAG, PCF("Entering FindProvisioningResourceResponse"));
 397
 398     if (!ValidateFinddResourceResponse(clientResponse))
 399     {
 400         ErrorCallback( DEVICE_NOT_PROVISIONED);
 401         return OC_STACK_DELETE_TRANSACTION;
 402     }
 403
 404     OCStackApplicationResult response = OC_STACK_DELETE_TRANSACTION;
 405
 406     ProvisioningInfo *provInfo;
 407     char szQueryUri[64] =
 408     { 0 };
 409
 410     OCDiscoveryPayload* discoveryPayload = (OCDiscoveryPayload*) (clientResponse->payload);
 411
 412     // Need to conform if below check is required or not. As Null check of clientResponse->payload is already performed above
 413     if (!discoveryPayload)
 414     {
 415         OIC_LOG_V(DEBUG, TAG, "Failed To parse");
 416         ErrorCallback( DEVICE_NOT_PROVISIONED);
 417         return OC_STACK_DELETE_TRANSACTION;
 418     }
 419
 420     OIC_LOG_V(DEBUG, TAG, "resUri = %s", discoveryPayload->resources->uri);
 421
 422     snprintf(szQueryUri, sizeof(szQueryUri), UNICAST_PROV_STATUS_QUERY,
 423             clientResponse->devAddr.addr, IP_PORT, discoveryPayload->resources->uri);
 424
 425     OIC_LOG_V(DEBUG, TAG, "query before GetProvisioningStatus call = %s", szQueryUri);
 426
 427     if (GetProvisioningStatus(OC_HIGH_QOS, szQueryUri, &clientResponse->devAddr) != OC_STACK_OK)
 428     {
 429         ErrorCallback( DEVICE_NOT_PROVISIONED);
 430         return OC_STACK_DELETE_TRANSACTION;
 431     }
 432
 433     return OC_STACK_KEEP_TRANSACTION;
 434
 435 }
 436
 437 void FindProvisioningResource(void *data)
 438 {
 439     OCStackResult ret = OC_STACK_ERROR;
 440
 441     /* Start a discovery query*/
 442     char szQueryUri[64] =
 443     { 0 };
 444
 445     snprintf(szQueryUri, sizeof(szQueryUri), UNICAST_PROVISIONING_QUERY,
 446             netProvInfo->netAddressInfo.WIFI.ipAddress, IP_PORT);
 447
 448     OIC_LOG_V(DEBUG, TAG, "szQueryUri = %s", szQueryUri);
 449
 450     OCCallbackData ocCBData;
 451
 452     ocCBData.cb = FindProvisioningResourceResponse;
 453     ocCBData.context = (void*) DEFAULT_CONTEXT_VALUE;
 454     ocCBData.cd = NULL;
 455
 456     ret = OCDoResource(NULL, OC_REST_DISCOVER, szQueryUri, NULL, NULL, OC_CONNTYPE, OC_LOW_QOS,
 457             &ocCBData, NULL, 0);
 458
 459     if (ret != OC_STACK_OK)
 460     {
 461         ErrorCallback( DEVICE_NOT_PROVISIONED);
 462         ClearMemory();
 463     }
 464 }
 465
 466 OCStackApplicationResult SubscribeProvPresenceCallback(void* ctx, OCDoHandle handle,
 467         OCClientResponse* clientResponse)
 468 {
 469     OIC_LOG(INFO, TAG, PCF("Entering SubscribeProvPresenceCallback"));
 470
 471     OCStackApplicationResult response = OC_STACK_DELETE_TRANSACTION;
 472
 473     if (clientResponse->result != OC_STACK_OK)
 474     {
 475         OIC_LOG(ERROR, TAG, "OCStack stop error");
 476         return response;
 477     }
 478
 479     if (clientResponse)
 480     {
 481         OIC_LOG(INFO, TAG, PCF("Client Response exists"));
 482
 483         if (clientResponse->payload && clientResponse->payload->type != PAYLOAD_TYPE_REPRESENTATION)
 484         {
 485             OIC_LOG_V(DEBUG, TAG, "Incoming payload not a representation");
 486             return response;
 487         }
 488
 489         OCRepPayload* discoveryPayload = (OCRepPayload*) (clientResponse->payload);
 490         if (!discoveryPayload)
 491         {
 492             OIC_LOG_V(DEBUG, TAG, "invalid payload");
 493             return response;
 494         }
 495
 496         char sourceIPAddr[OIC_STRING_MAX_VALUE] =
 497         { '\0' };
 498         snprintf(sourceIPAddr, sizeof(sourceIPAddr), "%s", clientResponse->addr->addr);
 499
 500         OIC_LOG_V(DEBUG, TAG, "Discovered %s @ %s", discoveryPayload->uri, sourceIPAddr);
 501
 502         /* Start a discovery query*/
 503         char szQueryUri[64] =
 504         { 0 };
 505
 506         snprintf(szQueryUri, sizeof(szQueryUri), UNICAST_PROVISIONING_QUERY, sourceIPAddr, IP_PORT);
 507
 508         /*if (FindProvisioningResource(qos, szQueryUri) != OC_STACK_OK) {
 509          OIC_LOG(ERROR, TAG, "FindProvisioningResource failed");
 510          return OC_STACK_KEEP_TRANSACTION;
 511          }*/
 512     }
 513     else
 514     {
 515         // clientResponse is invalid
 516         OIC_LOG(ERROR, TAG, PCF("Client Response is NULL!"));
 517     }
 518     return OC_STACK_KEEP_TRANSACTION;
 519 }
 520
 521 OCStackResult SubscribeProvPresence(OCQualityOfService qos, const char* requestURI)
 522 {
 523     OCStackResult ret = OC_STACK_ERROR;
 524
 525     OCCallbackData cbData;
 526
 527     cbData.cb = &SubscribeProvPresenceCallback;
 528     cbData.context = (void*) DEFAULT_CONTEXT_VALUE;
 529     cbData.cd = NULL;
 530
 531     ret = OCDoResource(NULL, OC_REST_PRESENCE, requestURI, 0, 0, OC_CONNTYPE, OC_LOW_QOS, &cbData,
 532             NULL, 0);
 533
 534     if (ret != OC_STACK_OK)
 535     {
 536         OIC_LOG(ERROR, TAG, "OCStack resource error");
 537     }
 538
 539     return ret;
 540 }
 541
 542 OCStackResult FindNetworkResource()
 543 {
 544     OCStackResult ret = OC_STACK_ERROR;
 545     if (OCStop() != OC_STACK_OK)
 546     {
 547         OIC_LOG(ERROR, TAG, "OCStack stop error");
 548     }
 549
 550     return ret;
 551 }
 552
 553 ProvisioningInfo* PrepareProvisioingStatusCB(OCClientResponse * clientResponse,
 554         ProvStatus provStatus)
 555 {
 556
 557     ProvisioningInfo *provInfo = (ProvisioningInfo *) OICCalloc(1, sizeof(ProvisioningInfo));
 558
 559     if (provInfo == NULL)
 560     {
 561         OIC_LOG_V(ERROR, TAG, "Failed to allocate memory");
 562         return NULL;
 563     }
 564
 565     OCDevAddr *devAddr = (OCDevAddr *) OICCalloc(1, sizeof(OCDevAddr));
 566
 567     if (devAddr == NULL)
 568     {
 569         OIC_LOG_V(ERROR, TAG, "Failed to allocate memory");
 570         return NULL;
 571     }
 572
 573     strncpy(devAddr->addr, clientResponse->addr->addr, sizeof(devAddr->addr));
 574     devAddr->port = clientResponse->addr->port;
 575
 576     provInfo->provDeviceInfo.addr = devAddr;
 577
 578     provInfo->provStatus = provStatus;
 579
 580     return provInfo;
 581 }
 582
 583 bool ValidateEasySetupParams(const EnrolleeNWProvInfo_t *netInfo,
 584         OCProvisioningStatusCB provisioningStatusCallback)
 585 {
 586
 587     if (netInfo == NULL || netInfo->netAddressInfo.WIFI.ipAddress == NULL)
 588     {
 589         OIC_LOG(ERROR, TAG, "Request URI is NULL");
 590         return false;
 591     }
 592
 593     if (provisioningStatusCallback == NULL)
 594     {
 595         OIC_LOG(ERROR, TAG, "ProvisioningStatusCallback is NULL");
 596         return false;
 597     }
 598
 599     return true;
 600
 601 }
 602
 603 bool InProgress()
 604 {
 605
 606     // It means already Easy Setup provisioning session is going on.
 607     if (NULL != cbData)
 608     {
 609         OIC_LOG(ERROR, TAG, "Easy setup session is already in progress");
 610         return true;
 611     }
 612
 613     return false;
 614 }
 615
 616 bool SetProgress(OCProvisioningStatusCB provisioningStatusCallback)
 617 {
 618     ca_mutex_lock(g_provisioningMutex);
 619
 620     if (InProgress())
 621         return false;
 622
 623     cbData = provisioningStatusCallback;
 624
 625     ca_mutex_unlock(g_provisioningMutex);
 626
 627     return true;
 628 }
 629
 630 bool ResetProgress()
 631 {
 632     ca_mutex_lock(g_provisioningMutex);
 633
 634     cbData = NULL;
 635
 636     ca_mutex_unlock(g_provisioningMutex);
 637 }
 638
 639 ProvisioningInfo* CreateCallBackObject()
 640 {
 641
 642     ProvisioningInfo *provInfo = (ProvisioningInfo *) OICCalloc(1, sizeof(ProvisioningInfo));
 643
 644     if (provInfo == NULL)
 645     {
 646         OIC_LOG_V(ERROR, TAG, "Failed to allocate memory");
 647         return NULL;
 648     }
 649
 650     OCDevAddr *devAddr = (OCDevAddr *) OICCalloc(1, sizeof(OCDevAddr));
 651
 652     if (devAddr == NULL)
 653     {
 654         OIC_LOG_V(ERROR, TAG, "Failed to allocate memory");
 655         return NULL;
 656     }
 657
 658     provInfo->provDeviceInfo.addr = devAddr;
 659
 660     return provInfo;
 661
 662 }
 663
 664 ProvisioningInfo* GetCallbackObjectOnError(ProvStatus status)
 665 {
 666
 667     ProvisioningInfo *provInfo = CreateCallBackObject();
 668     strncpy(provInfo->provDeviceInfo.addr->addr, netProvInfo->netAddressInfo.WIFI.ipAddress,
 669             sizeof(provInfo->provDeviceInfo.addr->addr));
 670     provInfo->provDeviceInfo.addr->port = IP_PORT;
 671     provInfo->provStatus = status;
 672     return provInfo;
 673 }
 674
 675 ProvisioningInfo* GetCallbackObjectOnSuccess(OCClientResponse * clientResponse,
 676         ProvStatus provStatus)
 677 {
 678     ProvisioningInfo *provInfo = CreateCallBackObject();
 679     strncpy(provInfo->provDeviceInfo.addr->addr, clientResponse->addr->addr,
 680             sizeof(provInfo->provDeviceInfo.addr->addr));
 681     provInfo->provDeviceInfo.addr->port = clientResponse->addr->port;
 682     provInfo->provStatus = provStatus;
 683     return provInfo;
 684 }
 685
 686 bool ValidateFinddResourceResponse(OCClientResponse * clientResponse)
 687 {
 688
 689     if (!(clientResponse) || !(clientResponse->payload))
 690     {
 691
 692         OIC_LOG_V(INFO, TAG, "ProvisionEnrolleeResponse received Null clientResponse");
 693
 694         return false;
 695
 696     }
 697 return true;
 698 }
 699
 700 bool ValidateEnrolleResponse(OCClientResponse * clientResponse)
 701 {
 702
 703     if (!(clientResponse) || !(clientResponse->payload))
 704     {
 705
 706         OIC_LOG_V(INFO, TAG, "ProvisionEnrolleeResponse received Null clientResponse");
 707
 708         return false;
 709
 710     }
 711
 712     if (clientResponse->payload->type != PAYLOAD_TYPE_REPRESENTATION)
 713     {
 714
 715         OIC_LOG_V(DEBUG, TAG, "Incoming payload not a representation");
 716         return false;
 717
 718     }
 719
 720     // If flow reachese here means no error condition hit.
 721     return true;
 722
 723 }
 724
 725
 726 void SuccessCallback(OCClientResponse * clientResponse)
 727 {
 728     ProvisioningInfo *provInfo = GetCallbackObjectOnSuccess(clientResponse, DEVICE_PROVISIONED);
 729     cbData(provInfo);
 730 }
 731
 732 bool ClearMemory()
 733 {
 734
 735     OIC_LOG(DEBUG, TAG, "thread_pool_add_task of FindProvisioningResource failed");
 736     ca_thread_pool_free(g_threadPoolHandle);
 737     ca_mutex_unlock(g_provisioningMutex);
 738     ca_mutex_free(g_provisioningMutex);
 739     ca_cond_free(g_provisioningCond);
 740
 741     return true;
 742
 743 }
 744
 745 bool ConfigEnrolleeObject(const EnrolleeNWProvInfo_t *netInfo)
 746 {
 747
 748     //Copy Network Provisioning  Information
 749     netProvInfo = (EnrolleeNWProvInfo_t *) OICCalloc(1, sizeof(EnrolleeNWProvInfo_t));
 750
 751     if (netProvInfo == NULL)
 752     {
 753         OIC_LOG(ERROR, TAG, "Invalid input..");
 754         return false;
 755     }
 756
 757     memcpy(netProvInfo, netInfo, sizeof(EnrolleeNWProvInfo_t));
 758
 759     OIC_LOG_V(DEBUG, TAG, "Network Provisioning Info. SSID = %s",
 760             netProvInfo->netAddressInfo.WIFI.ssid);
 761
 762     OIC_LOG_V(DEBUG, TAG, "Network Provisioning Info. PWD = %s",
 763             netProvInfo->netAddressInfo.WIFI.pwd);
 764
 765     return true;
 766
 767 }
 768
 769 void LogProvisioningResponse(OCRepPayloadValue* val)
 770 {
 771
 772     switch (val->type)
 773     {
 774         case OCREP_PROP_NULL:
 775             OIC_LOG_V(DEBUG, TAG, "\t\t%s: NULL", val->name);
 776             break;
 777         case OCREP_PROP_INT:
 778             OIC_LOG_V(DEBUG, TAG, "\t\t%s(int):%lld", val->name, val->i);
 779             break;
 780         case OCREP_PROP_DOUBLE:
 781             OIC_LOG_V(DEBUG, TAG, "\t\t%s(double):%f", val->name, val->d);
 782             break;
 783         case OCREP_PROP_BOOL:
 784             OIC_LOG_V(DEBUG, TAG, "\t\t%s(bool):%s", val->name, val->b ? "true" : "false");
 785             break;
 786         case OCREP_PROP_STRING:
 787             OIC_LOG_V(DEBUG, TAG, "\t\t%s(string):%s", val->name, val->str);
 788             break;
 789         case OCREP_PROP_OBJECT:
 790             // Note: Only prints the URI (if available), to print further, you'll
 791             // need to dig into the object better!
 792             OIC_LOG_V(DEBUG, TAG, "\t\t%s(OCRep):%s", val->name, val->obj->uri);
 793             break;
 794         case OCREP_PROP_ARRAY:
 795             switch (val->arr.type)
 796             {
 797                 case OCREP_PROP_INT:
 798                     OIC_LOG_V(DEBUG, TAG, "\t\t%s(int array):%lld x %lld x %lld", val->name,
 799                             val->arr.dimensions[0], val->arr.dimensions[1], val->arr.dimensions[2]);
 800                     break;
 801                 case OCREP_PROP_DOUBLE:
 802                     OIC_LOG_V(DEBUG, TAG, "\t\t%s(double array):%lld x %lld x %lld", val->name,
 803                             val->arr.dimensions[0], val->arr.dimensions[1], val->arr.dimensions[2]);
 804                     break;
 805                 case OCREP_PROP_BOOL:
 806                     OIC_LOG_V(DEBUG, TAG, "\t\t%s(bool array):%lld x %lld x %lld", val->name,
 807                             val->arr.dimensions[0], val->arr.dimensions[1], val->arr.dimensions[2]);
 808                     break;
 809                 case OCREP_PROP_STRING:
 810                     OIC_LOG_V(DEBUG, TAG, "\t\t%s(string array):%lld x %lld x %lld", val->name,
 811                             val->arr.dimensions[0], val->arr.dimensions[1], val->arr.dimensions[2]);
 812                     break;
 813                 case OCREP_PROP_OBJECT:
 814                     OIC_LOG_V(DEBUG, TAG, "\t\t%s(OCRep array):%lld x %lld x %lld", val->name,
 815                             val->arr.dimensions[0], val->arr.dimensions[1], val->arr.dimensions[2]);
 816                     break;
 817                 default:
 818                     //OIC_LOG_V(ERROR, TAG, "\t\t%s <-- Unknown/unsupported array type!",
 819                     //  val->name);
 820                     break;
 821             }
 822             break;
 823         default:
 824             /*OC_LOG_V(ERROR, TAG
 825              , "\t\t%s <-- Unknown type!", val->name);*/
 826             break;
 827     }
 828 }
 829