service/easy-setup/enrollee/src/resourcehandler.c

   1 //******************************************************************
   2 //
   3 // Copyright 2015 Samsung Electronics All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include "resourcehandler.h"
  22
  23 #include "ocpayload.h"
  24 #include "oic_string.h"
  25 #include "oic_malloc.h"
  26
  27 /**
  28  * @var ES_RH_TAG
  29  * @brief Logging tag for module name.
  30  */
  31 #define ES_RH_TAG "ES_RH"
  32 //-----------------------------------------------------------------------------
  33 // Private variables
  34 //-----------------------------------------------------------------------------
  35
  36 /**
  37  * @var gProvResource
  38  * @brief Structure for holding the Provisioning status and target information required to
  39  * connect to the target network
  40  */
  41 static ProvResource gProvResource;
  42 static WiFiResource gWiFiResource;
  43 static CloudResource gCloudResource;
  44 static DevConfResource gDevConfResource;
  45
  46 //-----------------------------------------------------------------------------
  47 // Private internal function prototypes
  48 //-----------------------------------------------------------------------------
  49 OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag, OCEntityHandlerRequest *ehRequest,
  50         void *callback);
  51 OCEntityHandlerResult ProcessGetRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload);
  52 OCEntityHandlerResult ProcessPutRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload);
  53 OCEntityHandlerResult ProcessPostRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload);
  54 void updateProvResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input);
  55 void updateWiFiResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input);
  56 void updateCloudResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input);
  57 void updateDevConfResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input);
  58 const char *getResult(OCStackResult result);
  59
  60 ESWiFiCB gWifiRsrcEvtCb = NULL;
  61 ESCloudCB gCloudRsrcEvtCb = NULL;
  62 ESDevConfCB gDevConfRsrcEvtCb = NULL;
  63
  64 ESReadUserdataCb gReadUserdataCb = NULL;
  65 ESWriteUserdataCb gWriteUserdataCb = NULL;
  66
  67 bool CompareResourceInterface(char *from, char *iface)
  68 {
  69     char *str = OICStrdup(from);
  70     char *ptr = strtok(str, ";");
  71
  72     if(ptr == NULL)
  73     {
  74         return false;
  75     }
  76
  77     do
  78     {
  79         if(strstr(ptr, ".if."))
  80         {
  81             char *if_ptr = NULL;
  82             if_ptr = strtok(ptr, "=");
  83             if_ptr = strtok(NULL, "=");
  84
  85             if(!strcmp(if_ptr, iface))
  86             {
  87                 return true;
  88             }
  89         }
  90
  91     } while ((ptr = strtok(NULL, ";")));
  92
  93     return false;
  94 }
  95
  96 ESResult SetCallbackForUserData(ESReadUserdataCb readCb, ESWriteUserdataCb writeCb)
  97 {
  98     if(!readCb && !writeCb)
  99     {
 100         OIC_LOG(INFO, ES_RH_TAG, "Both of callbacks for user data are null");
 101         return ES_ERROR;
 102     }
 103     gReadUserdataCb = readCb;
 104     gWriteUserdataCb = writeCb;
 105     return ES_OK;
 106 }
 107
 108 void RegisterWifiRsrcEventCallBack(ESWiFiCB cb)
 109 {
 110     gWifiRsrcEvtCb = cb;
 111 }
 112
 113 void RegisterCloudRsrcEventCallBack(ESCloudCB cb)
 114 {
 115     gCloudRsrcEvtCb = cb;
 116 }
 117
 118 void RegisterDevConfRsrcEventCallBack(ESDevConfCB cb)
 119 {
 120     gDevConfRsrcEvtCb = cb;
 121 }
 122
 123 void UnRegisterResourceEventCallBack()
 124 {
 125     if (gWifiRsrcEvtCb)
 126     {
 127         gWifiRsrcEvtCb = NULL;
 128     }
 129     if (gCloudRsrcEvtCb)
 130     {
 131         gCloudRsrcEvtCb = NULL;
 132     }
 133     if (gDevConfRsrcEvtCb)
 134     {
 135         gDevConfRsrcEvtCb = NULL;
 136     }
 137 }
 138
 139 OCStackResult initProvResource(bool isSecured)
 140 {
 141     gProvResource.status = ES_STATE_INIT;
 142     gProvResource.lastErrCode = ES_ERRCODE_NO_ERROR;
 143     OICStrcpy(gProvResource.ocfWebLinks, MAX_WEBLINKLEN, "");
 144
 145     OCStackResult res = OC_STACK_ERROR;
 146     if (isSecured)
 147     {
 148         res = OCCreateResource(&gProvResource.handle, OC_RSRVD_ES_RES_TYPE_PROV,
 149         OC_RSRVD_INTERFACE_DEFAULT,
 150         OC_RSRVD_ES_URI_PROV, OCEntityHandlerCb,
 151         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
 152     }else
 153     {
 154         res = OCCreateResource(&gProvResource.handle, OC_RSRVD_ES_RES_TYPE_PROV,
 155         OC_RSRVD_INTERFACE_DEFAULT,
 156         OC_RSRVD_ES_URI_PROV, OCEntityHandlerCb,
 157         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
 158     }
 159     if(res)
 160     {
 161         OIC_LOG_V(INFO, ES_RH_TAG, "Created Prov resource with result: %s", getResult(res));
 162         return res;
 163     }
 164
 165     res = OCBindResourceInterfaceToResource(gProvResource.handle, OC_RSRVD_INTERFACE_LL);
 166     if(res)
 167     {
 168         OIC_LOG_V(INFO, ES_RH_TAG, "Binding Resource interface with result: %s", getResult(res));
 169         return res;
 170     }
 171     res = OCBindResourceInterfaceToResource(gProvResource.handle, OC_RSRVD_INTERFACE_BATCH);
 172     if(res)
 173     {
 174         OIC_LOG_V(INFO, ES_RH_TAG, "Binding Resource interface with result: %s", getResult(res));
 175         return res;
 176     }
 177
 178     OIC_LOG_V(INFO, ES_RH_TAG, "Created Prov resource with result: %s", getResult(res));
 179     return res;
 180 }
 181
 182 OCStackResult initWiFiResource(bool isSecured)
 183 {
 184     OCStackResult res = OC_STACK_ERROR;
 185
 186     gWiFiResource.supportedFreq = WIFI_BOTH;
 187     gWiFiResource.supportedMode[0] = WIFI_11A;
 188     gWiFiResource.supportedMode[1] = WIFI_11B;
 189     gWiFiResource.supportedMode[2] = WIFI_11G;
 190     gWiFiResource.supportedMode[3] = WIFI_11N;
 191     gWiFiResource.numMode = 4;
 192     gWiFiResource.authType = NONE_AUTH;
 193     gWiFiResource.encType = NONE_ENC;
 194     OICStrcpy(gWiFiResource.ssid, sizeof(gWiFiResource.ssid), "");
 195     OICStrcpy(gWiFiResource.cred, sizeof(gWiFiResource.cred), "");
 196
 197     if (isSecured)
 198     {
 199         res = OCCreateResource(&gWiFiResource.handle, OC_RSRVD_ES_RES_TYPE_WIFI,
 200         OC_RSRVD_INTERFACE_DEFAULT,
 201         OC_RSRVD_ES_URI_WIFI, OCEntityHandlerCb,
 202         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
 203     }else
 204     {
 205         res = OCCreateResource(&gWiFiResource.handle, OC_RSRVD_ES_RES_TYPE_WIFI,
 206         OC_RSRVD_INTERFACE_DEFAULT,
 207         OC_RSRVD_ES_URI_WIFI, OCEntityHandlerCb,
 208         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
 209     }
 210
 211     OIC_LOG_V(INFO, ES_RH_TAG, "Created WiFi resource with result: %s", getResult(res));
 212     return res;
 213
 214 }
 215
 216 OCStackResult initCloudServerResource(bool isSecured)
 217 {
 218     OCStackResult res = OC_STACK_ERROR;
 219
 220     OICStrcpy(gCloudResource.authCode, sizeof(gCloudResource.authCode), "");
 221     OICStrcpy(gCloudResource.authProvider, sizeof(gCloudResource.authProvider), "");
 222     OICStrcpy(gCloudResource.ciServer, sizeof(gCloudResource.ciServer), "");
 223
 224     if (isSecured)
 225     {
 226         res = OCCreateResource(&gCloudResource.handle, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER,
 227         OC_RSRVD_INTERFACE_DEFAULT,
 228         OC_RSRVD_ES_URI_CLOUDSERVER, OCEntityHandlerCb,
 229         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
 230     }else
 231     {
 232         res = OCCreateResource(&gCloudResource.handle, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER,
 233         OC_RSRVD_INTERFACE_DEFAULT,
 234         OC_RSRVD_ES_URI_CLOUDSERVER, OCEntityHandlerCb,
 235         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
 236     }
 237
 238     OIC_LOG_V(INFO, ES_RH_TAG, "Created CloudServer resource with result: %s", getResult(res));
 239     return res;
 240
 241 }
 242
 243 OCStackResult initDevConfResource(bool isSecured)
 244 {
 245     OCStackResult res = OC_STACK_ERROR;
 246
 247     OICStrcpy(gDevConfResource.devName, sizeof(gDevConfResource.devName), "");
 248     OICStrcpy(gDevConfResource.modelNumber, sizeof(gDevConfResource.modelNumber), "");
 249     OICStrcpy(gDevConfResource.location, sizeof(gDevConfResource.location), "");
 250     OICStrcpy(gDevConfResource.country, sizeof(gDevConfResource.country), "");
 251     OICStrcpy(gDevConfResource.language, sizeof(gDevConfResource.language), "");
 252
 253     if (isSecured)
 254     {
 255         res = OCCreateResource(&gDevConfResource.handle, OC_RSRVD_ES_RES_TYPE_DEVCONF,
 256         OC_RSRVD_INTERFACE_DEFAULT,
 257         OC_RSRVD_ES_URI_DEVCONF, OCEntityHandlerCb,
 258         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
 259     }else
 260     {
 261         res = OCCreateResource(&gDevConfResource.handle, OC_RSRVD_ES_RES_TYPE_DEVCONF,
 262         OC_RSRVD_INTERFACE_DEFAULT,
 263         OC_RSRVD_ES_URI_DEVCONF, OCEntityHandlerCb,
 264         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
 265     }
 266
 267     OIC_LOG_V(INFO, ES_RH_TAG, "Created DevConf resource with result: %s", getResult(res));
 268     return res;
 269
 270 }
 271
 272 void updateProvResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input)
 273 {
 274     OIC_LOG_V(INFO, ES_RH_TAG, "gProvResource.status %d", gProvResource.status);
 275
 276     if(ehRequest->query)
 277     {
 278         if(CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH))
 279         {
 280             // When Provisioning resource has a POST with BatchInterface
 281             updateCloudResource(NULL, input);
 282             updateWiFiResource(NULL, input);
 283             updateDevConfResource(NULL, input);
 284         }
 285     }
 286 }
 287
 288 void updateWiFiResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input)
 289 {
 290     if(ehRequest &&
 291         strcmp(ehRequest->query, "") &&
 292         !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
 293     {
 294         // In case of link list, batch interface
 295         OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
 296         return ;
 297     }
 298
 299     ESWiFiProvData* wiFiData = (ESWiFiProvData*)OICMalloc(sizeof(ESWiFiProvData));
 300
 301     if(wiFiData == NULL)
 302     {
 303         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
 304         return ;
 305     }
 306
 307     memset(wiFiData->ssid, 0, MAX_WEBLINKLEN);
 308     memset(wiFiData->pwd, 0, MAX_WEBLINKLEN);
 309     wiFiData->authtype = NONE_AUTH;
 310     wiFiData->enctype = NONE_AUTH;
 311     wiFiData->userdata = NULL;
 312
 313     char* ssid = NULL;
 314     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_SSID, &ssid))
 315     {
 316         OICStrcpy(gWiFiResource.ssid, sizeof(gWiFiResource.ssid), ssid);
 317         OICStrcpy(wiFiData->ssid, sizeof(wiFiData->ssid), ssid);
 318         OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.ssid : %s", gWiFiResource.ssid);
 319     }
 320
 321     char* cred = NULL;
 322     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CRED, &cred))
 323     {
 324         OICStrcpy(gWiFiResource.cred, sizeof(gWiFiResource.cred), cred);
 325         OICStrcpy(wiFiData->pwd, sizeof(wiFiData->pwd), cred);
 326         OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.cred %s", gWiFiResource.cred);
 327     }
 328
 329     int64_t authType = -1;
 330     if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_AUTHTYPE, &authType))
 331     {
 332         gWiFiResource.authType = authType;
 333         wiFiData->authtype = gWiFiResource.authType;
 334         OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.authType %u", gWiFiResource.authType);
 335     }
 336
 337     int64_t encType = -1;
 338     if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_ENCTYPE, &encType))
 339     {
 340         gWiFiResource.encType = encType;
 341         wiFiData->enctype = gWiFiResource.encType;
 342         OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.encType %u", gWiFiResource.encType);
 343     }
 344
 345     if(gReadUserdataCb)
 346     {
 347         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_WIFI, &wiFiData->userdata);
 348     }
 349
 350     if(ssid || cred || authType!= -1 || encType != -1)
 351     {
 352         OIC_LOG(INFO, ES_RH_TAG, "Send WiFiRsrc Callback To ES");
 353
 354         // TODO : Need to check appropriateness of gWiFiData
 355         if(gWifiRsrcEvtCb != NULL)
 356         {
 357             gWifiRsrcEvtCb(ES_OK, wiFiData);
 358         }
 359         else
 360         {
 361             OIC_LOG(ERROR, ES_RH_TAG, "gWifiRsrcEvtCb is NULL");
 362         }
 363     }
 364
 365     OICFree(wiFiData);
 366 }
 367
 368 void updateCloudResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input)
 369 {
 370     if(ehRequest &&
 371         strcmp(ehRequest->query, "") &&
 372         !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
 373     {
 374         // In case of link list, batch interface
 375         OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
 376         return ;
 377     }
 378
 379     ESCloudProvData* cloudData = (ESCloudProvData*)OICMalloc(sizeof(ESCloudProvData));
 380
 381     if(cloudData == NULL)
 382     {
 383         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
 384         return;
 385     }
 386
 387     memset(cloudData->authCode, 0, OIC_STRING_MAX_VALUE);
 388     memset(cloudData->authProvider, 0, OIC_STRING_MAX_VALUE);
 389     memset(cloudData->ciServer, 0, OIC_STRING_MAX_VALUE);
 390     cloudData->userdata = NULL;
 391
 392     char *authCode = NULL;
 393     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_AUTHCODE, &authCode))
 394     {
 395         OICStrcpy(gCloudResource.authCode, sizeof(gCloudResource.authCode), authCode);
 396         OICStrcpy(cloudData->authCode, sizeof(cloudData->authCode), authCode);
 397         OIC_LOG_V(INFO, ES_RH_TAG, "gCloudResource.authCode %s", gCloudResource.authCode);
 398     }
 399
 400     char *authProvider = NULL;
 401     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_AUTHPROVIDER, &authProvider))
 402     {
 403         OICStrcpy(gCloudResource.authProvider, sizeof(gCloudResource.authProvider), authProvider);
 404         OICStrcpy(cloudData->authProvider, sizeof(cloudData->authProvider), authProvider);
 405         OIC_LOG_V(INFO, ES_RH_TAG, "gCloudResource.authServerUrl %s", gCloudResource.authProvider);
 406     }
 407
 408     char *ciServer = NULL;
 409     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CISERVER, &ciServer))
 410     {
 411         OICStrcpy(gCloudResource.ciServer, sizeof(gCloudResource.ciServer), ciServer);
 412         OICStrcpy(cloudData->ciServer, sizeof(cloudData->ciServer), ciServer);
 413         OIC_LOG_V(INFO, ES_RH_TAG, "gCloudResource.ciServer %s", gCloudResource.ciServer);
 414     }
 415
 416     if(gReadUserdataCb)
 417     {
 418         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER, &cloudData->userdata);
 419     }
 420
 421     if(authCode || authProvider || ciServer)
 422     {
 423         OIC_LOG(INFO, ES_RH_TAG, "Send CloudRsrc Callback To ES");
 424
 425         // TODO : Need to check appropriateness of gCloudData
 426         if(gCloudRsrcEvtCb != NULL)
 427         {
 428             gCloudRsrcEvtCb(ES_OK, cloudData);
 429         }
 430         else
 431         {
 432             OIC_LOG(ERROR, ES_RH_TAG, "gCloudRsrcEvtCb is NULL");
 433         }
 434     }
 435
 436     OICFree(cloudData);
 437 }
 438
 439 void updateDevConfResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input)
 440 {
 441     if(ehRequest &&
 442         strcmp(ehRequest->query, "") &&
 443         !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
 444     {
 445         // In case of link list, batch interface
 446         OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
 447         return ;
 448     }
 449
 450     ESDevConfProvData* devConfData = (ESDevConfProvData*)OICMalloc(sizeof(ESDevConfProvData));
 451
 452     if(devConfData == NULL)
 453     {
 454         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
 455         return;
 456     }
 457     memset(devConfData->language, 0, OIC_STRING_MAX_VALUE);
 458     memset(devConfData->country, 0, OIC_STRING_MAX_VALUE);
 459     devConfData->userdata = NULL;
 460
 461     char *location = NULL;
 462     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_LOCATION, &location))
 463     {
 464         OICStrcpy(gDevConfResource.location, sizeof(gDevConfResource.location), location);
 465         OICStrcpy(devConfData->location, sizeof(devConfData->location), location);
 466         OIC_LOG_V(INFO, ES_RH_TAG, "gDevConfResource.location %s", gDevConfResource.location);
 467     }
 468
 469     char *country = NULL;
 470     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_COUNTRY, &country))
 471     {
 472         OICStrcpy(gDevConfResource.country, sizeof(gDevConfResource.country), country);
 473         OICStrcpy(devConfData->country, sizeof(devConfData->country), country);
 474         OIC_LOG_V(INFO, ES_RH_TAG, "gDevConfResource.country %s", gDevConfResource.country);
 475     }
 476
 477     char *language = NULL;
 478     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_LANGUAGE, &language))
 479     {
 480         OICStrcpy(gDevConfResource.language, sizeof(gDevConfResource.language), language);
 481         OICStrcpy(devConfData->language, sizeof(devConfData->language), language);
 482         OIC_LOG_V(INFO, ES_RH_TAG, "gDevConfResource.language %s", gDevConfResource.language);
 483     }
 484
 485     if(gReadUserdataCb)
 486     {
 487         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_DEVCONF, &devConfData->userdata);
 488     }
 489
 490     if(country || language)
 491     {
 492         OIC_LOG(INFO, ES_RH_TAG, "Send DevConfRsrc Callback To ES");
 493
 494         // TODO : Need to check appropriateness of gDevConfData
 495         if(gDevConfRsrcEvtCb != NULL)
 496         {
 497             gDevConfRsrcEvtCb(ES_OK, devConfData);
 498         }
 499         else
 500         {
 501             OIC_LOG(ERROR, ES_RH_TAG, "gDevConfRsrcEvtCb is NULL");
 502         }
 503     }
 504
 505     OICFree(devConfData);
 506 }
 507
 508 OCRepPayload* constructResponseOfWiFi(OCEntityHandlerRequest *ehRequest)
 509 {
 510     if(ehRequest &&
 511         strcmp(ehRequest->query, "") &&
 512         !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
 513     {
 514         // In case of link list, batch interface
 515         OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
 516         return NULL;
 517     }
 518
 519     OCRepPayload* payload = OCRepPayloadCreate();
 520     if (!payload)
 521     {
 522         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 523         return NULL;
 524     }
 525
 526     OIC_LOG(INFO, ES_RH_TAG, "constructResponse wifi res");
 527     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_HREF, OC_RSRVD_ES_URI_WIFI);
 528
 529     size_t dimensions[MAX_REP_ARRAY_DEPTH] = {gWiFiResource.numMode, 0, 0};
 530     int64_t *modes_64 = (int64_t *)OICMalloc(gWiFiResource.numMode * sizeof(int64_t));
 531     for(int i = 0 ; i < gWiFiResource.numMode ; ++i)
 532     {
 533         modes_64[i] = gWiFiResource.supportedMode[i];
 534     }
 535     OCRepPayloadSetIntArray(payload, OC_RSRVD_ES_SUPPORTEDWIFIMODE, (int64_t *)modes_64, dimensions);
 536
 537     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_SUPPORTEDWIFIFREQ, gWiFiResource.supportedFreq);
 538     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_SSID, gWiFiResource.ssid);
 539     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CRED, gWiFiResource.cred);
 540     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_AUTHTYPE, (int) gWiFiResource.authType);
 541     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_ENCTYPE, (int) gWiFiResource.encType);
 542
 543     if(gWriteUserdataCb)
 544     {
 545         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_WIFI);
 546     }
 547
 548     return payload;
 549 }
 550
 551 OCRepPayload* constructResponseOfCloud(OCEntityHandlerRequest *ehRequest)
 552 {
 553     if(ehRequest &&
 554         strcmp(ehRequest->query, "") &&
 555         !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
 556     {
 557         // In case of link list, batch interface
 558         OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
 559         return NULL;
 560     }
 561
 562     OCRepPayload* payload = OCRepPayloadCreate();
 563     if (!payload)
 564     {
 565         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 566         return NULL;
 567     }
 568
 569     OIC_LOG(INFO, ES_RH_TAG, "constructResponse prov res");
 570     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_HREF, OC_RSRVD_ES_URI_CLOUDSERVER);
 571     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_AUTHCODE, gCloudResource.authCode);
 572     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_AUTHPROVIDER, gCloudResource.authProvider);
 573     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CISERVER, gCloudResource.ciServer);
 574
 575     if(gWriteUserdataCb)
 576     {
 577         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER);
 578     }
 579
 580     return payload;
 581 }
 582
 583 OCRepPayload* constructResponseOfDevConf(OCEntityHandlerRequest *ehRequest)
 584 {
 585     if(ehRequest &&
 586         strcmp(ehRequest->query, "") &&
 587         !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
 588     {
 589         // In case of link list, batch interface
 590         OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
 591         return NULL;
 592     }
 593
 594     OCRepPayload* payload = OCRepPayloadCreate();
 595     if (!payload)
 596     {
 597         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 598         return NULL;
 599     }
 600
 601     OIC_LOG(INFO, ES_RH_TAG, "constructResponse prov res");
 602     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_HREF, OC_RSRVD_ES_URI_DEVCONF);
 603     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_DEVNAME, gDevConfResource.devName);
 604     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_MODELNUMBER, gDevConfResource.modelNumber);
 605     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_LOCATION, gDevConfResource.location);
 606     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_LANGUAGE, gDevConfResource.language);
 607     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_COUNTRY, gDevConfResource.country);
 608
 609     if(gWriteUserdataCb)
 610     {
 611         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_DEVCONF);
 612     }
 613
 614     return payload;
 615 }
 616
 617 OCRepPayload* constructResponseOfProv(OCEntityHandlerRequest *ehRequest)
 618 {
 619     OCRepPayload* payload = OCRepPayloadCreate();
 620     if (!payload)
 621     {
 622         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 623         return NULL;
 624     }
 625
 626     // Requested interface is Link list interface
 627     if(ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_LL))
 628     {
 629         const OCRepPayload *arrayPayload[3] = {NULL};
 630
 631         int childResCnt = 0;
 632
 633         if(gWiFiResource.handle != NULL)
 634         {
 635             OCRepPayload *add = OCRepPayloadCreate();
 636             if(!add)
 637             {
 638                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 639                 return NULL;
 640             }
 641
 642             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
 643             char **resourceType = NULL;
 644             resourceType = (char **)OICMalloc(sizeof(char *) * 1);
 645             char **resourceInterface = NULL;
 646             resourceInterface = (char **)OICMalloc(sizeof(char *) * 1);
 647
 648             if(!resourceType || !resourceInterface)
 649             {
 650                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 651                 return NULL;
 652             }
 653
 654             resourceType[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_WIFI);
 655             resourceInterface[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
 656
 657             add->base.type = PAYLOAD_TYPE_REPRESENTATION;
 658             OCRepPayloadSetPropString(add, OC_RSRVD_HREF, OC_RSRVD_ES_URI_WIFI);
 659             OCRepPayloadSetStringArray(add, OC_RSRVD_RESOURCE_TYPE,
 660                                             (const char **)resourceType, dimensions);
 661             OCRepPayloadSetStringArray(add, OC_RSRVD_INTERFACE,
 662                                             (const char **)resourceInterface, dimensions);
 663
 664             arrayPayload[childResCnt++] = add;
 665         }
 666
 667         if(gDevConfResource.handle != NULL)
 668         {
 669             OCRepPayload *add = OCRepPayloadCreate();
 670             if(!add)
 671             {
 672                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 673                 return NULL;
 674             }
 675
 676             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
 677             char **resourceType = NULL;
 678             resourceType = (char **)OICMalloc(sizeof(char *) * 1);
 679             char **resourceInterface = NULL;
 680             resourceInterface = (char **)OICMalloc(sizeof(char *) * 1);
 681
 682             if(!resourceType || !resourceInterface)
 683             {
 684                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 685                 return NULL;
 686             }
 687
 688             resourceType[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_DEVCONF);
 689             resourceInterface[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
 690
 691             add->base.type = PAYLOAD_TYPE_REPRESENTATION;
 692             OCRepPayloadSetPropString(add, OC_RSRVD_HREF, OC_RSRVD_ES_URI_DEVCONF);
 693             OCRepPayloadSetStringArray(add, OC_RSRVD_RESOURCE_TYPE,
 694                                             (const char **)resourceType, dimensions);
 695             OCRepPayloadSetStringArray(add, OC_RSRVD_INTERFACE,
 696                                             (const char **)resourceInterface, dimensions);
 697
 698             arrayPayload[childResCnt++] = add;
 699         }
 700
 701         if(gCloudResource.handle != NULL)
 702         {
 703             OCRepPayload *add = OCRepPayloadCreate();
 704             if(!add)
 705             {
 706                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 707                 return NULL;
 708             }
 709
 710             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
 711             char **resourceType = NULL;
 712             resourceType = (char **)OICMalloc(sizeof(char *) * 1);
 713             char **resourceInterface = NULL;
 714             resourceInterface = (char **)OICMalloc(sizeof(char *) * 1);
 715
 716             if(!resourceType || !resourceInterface)
 717             {
 718                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 719                 return NULL;
 720             }
 721
 722             resourceType[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_CLOUDSERVER);
 723             resourceInterface[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
 724
 725             add->base.type = PAYLOAD_TYPE_REPRESENTATION;
 726             OCRepPayloadSetPropString(add, OC_RSRVD_HREF, OC_RSRVD_ES_URI_CLOUDSERVER);
 727             OCRepPayloadSetStringArray(add, OC_RSRVD_RESOURCE_TYPE,
 728                                             (const char **)resourceType, dimensions);
 729             OCRepPayloadSetStringArray(add, OC_RSRVD_INTERFACE,
 730                                             (const char **)resourceInterface, dimensions);
 731
 732             arrayPayload[childResCnt++] = add;
 733         }
 734
 735         size_t dimensions[MAX_REP_ARRAY_DEPTH] = {childResCnt, 0, 0};
 736         OCRepPayloadSetPropObjectArray(payload, OC_RSRVD_ES_LINKS, arrayPayload, dimensions);
 737
 738         return payload;
 739     } else if (!ehRequest->query ||
 740         (ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH)) ||
 741         (ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT)))
 742     {
 743         OIC_LOG(INFO, ES_RH_TAG, "constructResponse prov res");
 744         OCRepPayloadSetPropString(payload, OC_RSRVD_ES_HREF, OC_RSRVD_ES_URI_PROV);
 745         OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_PROVSTATUS, gProvResource.status);
 746         OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_LAST_ERRORCODE, gProvResource.lastErrCode);
 747         OCRepPayloadSetPropString(payload, OC_RSRVD_ES_LINKS, gProvResource.ocfWebLinks);
 748     }
 749
 750     if(gWriteUserdataCb)
 751     {
 752         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_PROV);
 753     }
 754
 755     if(ehRequest->query)
 756     {
 757         if(CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH))
 758         {// When Provisioning resource has a GET with BatchInterface
 759             OCRepPayload* head = payload;
 760             OCRepPayload* nextPayload = NULL;
 761
 762             nextPayload = constructResponseOfWiFi(NULL);
 763             if(nextPayload != NULL)
 764             {
 765                 payload->next = nextPayload;
 766                 payload = payload->next;
 767             }
 768
 769             nextPayload = constructResponseOfCloud(NULL);
 770             if(nextPayload != NULL)
 771             {
 772                 payload->next = nextPayload;
 773                 payload = payload->next;
 774             }
 775
 776             nextPayload = constructResponseOfDevConf(NULL);
 777             if(nextPayload != NULL)
 778             {
 779                 payload->next = nextPayload;
 780                 payload = payload->next;
 781             }
 782
 783             payload = head;
 784         }
 785     }
 786
 787     return payload;
 788 }
 789
 790
 791 OCStackResult CreateEasySetupResources(bool isSecured, ESResourceMask resourceMask)
 792 {
 793     OCStackResult res = OC_STACK_ERROR;
 794     bool maskFlag = false;
 795
 796     res = initProvResource(isSecured);
 797     if(res != OC_STACK_OK)
 798     {
 799         // TODO: destroy logic will be added
 800         OIC_LOG_V(ERROR, ES_RH_TAG, "initProvResource result: %s", getResult(res));
 801
 802         return res;
 803     }
 804
 805     if((resourceMask & ES_WIFI_RESOURCE) == ES_WIFI_RESOURCE)
 806     {
 807         maskFlag = true;
 808         res = initWiFiResource(isSecured);
 809         if(res != OC_STACK_OK)
 810         {
 811             OIC_LOG_V(ERROR, ES_RH_TAG, "initWiFiResource result: %s", getResult(res));
 812             return res;
 813         }
 814
 815         res = OCBindResource(gProvResource.handle, gWiFiResource.handle);
 816         if(res != OC_STACK_OK)
 817         {
 818             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind WiFiResource result: %s", getResult(res));
 819             return res;
 820         }
 821
 822     }
 823
 824     if((resourceMask & ES_CLOUD_RESOURCE) == ES_CLOUD_RESOURCE)
 825     {
 826         maskFlag = true;
 827         res = initCloudServerResource(isSecured);
 828         if(res != OC_STACK_OK)
 829         {
 830             OIC_LOG_V(ERROR, ES_RH_TAG, "initCloudResource result: %s", getResult(res));
 831             return res;
 832         }
 833
 834         res = OCBindResource(gProvResource.handle, gCloudResource.handle);
 835         if(res != OC_STACK_OK)
 836         {
 837             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind CloudResource result: %s", getResult(res));
 838             return res;
 839         }
 840     }
 841
 842     if((resourceMask & ES_DEVCONF_RESOURCE) == ES_DEVCONF_RESOURCE)
 843     {
 844         maskFlag = true;
 845         res = initDevConfResource(isSecured);
 846         if(res != OC_STACK_OK)
 847         {
 848             OIC_LOG_V(ERROR, ES_RH_TAG, "initDevConf result: %s", getResult(res));
 849             return res;
 850         }
 851
 852         res = OCBindResource(gProvResource.handle, gDevConfResource.handle);
 853         if(res != OC_STACK_OK)
 854         {
 855             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind DevConfResource result: %s", getResult(res));
 856             return res;
 857         }
 858     }
 859
 860
 861     if(maskFlag == false)
 862     {
 863         OIC_LOG_V(ERROR, ES_RH_TAG, "Invalid ResourceMask");
 864         return OC_STACK_ERROR;
 865
 866     }
 867
 868     OIC_LOG_V(INFO, ES_RH_TAG, "Created all resources with result: %s", getResult(res));
 869
 870     return res;
 871 }
 872
 873 OCStackResult DeleteProvisioningResource()
 874 {
 875     OCStackResult res = OCDeleteResource(gProvResource.handle);
 876     if (res != OC_STACK_OK)
 877     {
 878         OIC_LOG_V(INFO, ES_RH_TAG, "Deleting Prov resource error with result: %s", getResult(res));
 879     }
 880
 881     return res;
 882 }
 883
 884 OCStackResult DeleteEasySetupResources()
 885 {
 886     OCStackResult res = OC_STACK_ERROR;
 887     if (gWiFiResource.handle != NULL)
 888     {
 889         res = OCUnBindResource(gProvResource.handle, gWiFiResource.handle);
 890         if(res != OC_STACK_OK)
 891         {
 892             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind WiFi resource error with result: %s", getResult(res));
 893         }
 894     }
 895     if (gCloudResource.handle != NULL)
 896     {
 897         res = OCUnBindResource(gProvResource.handle, gCloudResource.handle);
 898         if(res != OC_STACK_OK)
 899         {
 900             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind CloudServer resource error with result: %s", getResult(res));
 901         }
 902     }
 903     if (gDevConfResource.handle != NULL)
 904     {
 905         res = OCUnBindResource(gProvResource.handle, gDevConfResource.handle);
 906         if(res != OC_STACK_OK)
 907         {
 908             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind DevConf resource error with result: %s", getResult(res));
 909         }
 910     }
 911
 912     if (gWiFiResource.handle != NULL)
 913     {
 914         res = OCDeleteResource(gWiFiResource.handle);
 915         if (res != OC_STACK_OK)
 916         {
 917             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting WiFi resource error with result: %s", getResult(res));
 918         }
 919     }
 920
 921     if(gCloudResource.handle != NULL)
 922     {
 923         res = OCDeleteResource(gCloudResource.handle);
 924         if (res != OC_STACK_OK)
 925         {
 926             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting CloudServer resource error with result: %s", getResult(res));
 927         }
 928     }
 929
 930     if(gDevConfResource.handle != NULL)
 931     {
 932         res = OCDeleteResource(gDevConfResource.handle);
 933         if (res != OC_STACK_OK)
 934         {
 935             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting DevConf resource error with result: %s", getResult(res));
 936         }
 937     }
 938
 939     if(gProvResource.handle != NULL)
 940     {
 941         res = OCDeleteResource(gProvResource.handle);
 942         if (res != OC_STACK_OK)
 943         {
 944             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting Prov resource error with result: %s", getResult(res));
 945         }
 946     }
 947
 948     return res;
 949 }
 950
 951 OCEntityHandlerResult ProcessGetRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload **payload)
 952 {
 953     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 954     if (!ehRequest)
 955     {
 956         OIC_LOG(ERROR, ES_RH_TAG, "Request is Null");
 957         return ehResult;
 958     }
 959     if (ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
 960     {
 961         OIC_LOG(ERROR, ES_RH_TAG, "Incoming payload not a representation");
 962         return ehResult;
 963     }
 964
 965     OCRepPayload *getResp = NULL;
 966
 967     if(ehRequest->resource == gProvResource.handle)
 968     {
 969         getResp = constructResponseOfProv(ehRequest);
 970     }
 971     else if(ehRequest->resource == gWiFiResource.handle)
 972     {
 973         getResp = constructResponseOfWiFi(ehRequest);
 974     }
 975     else if(ehRequest->resource == gCloudResource.handle)
 976     {
 977         getResp = constructResponseOfCloud(ehRequest);
 978     }
 979     else if(ehRequest->resource == gDevConfResource.handle)
 980     {
 981         getResp = constructResponseOfDevConf(ehRequest);
 982     }
 983
 984     if (!getResp)
 985     {
 986         OIC_LOG(ERROR, ES_RH_TAG, "constructResponse failed");
 987         return OC_EH_ERROR;
 988     }
 989
 990     *payload = getResp;
 991     ehResult = OC_EH_OK;
 992
 993     return ehResult;
 994 }
 995
 996 OCEntityHandlerResult ProcessPostRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload)
 997 {
 998     OIC_LOG(INFO, ES_RH_TAG, "ProcessPostRequest enter");
 999     OCEntityHandlerResult ehResult = OC_EH_ERROR;
1000     if (ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
1001     {
1002         OIC_LOG(ERROR, ES_RH_TAG, "Incoming payload not a representation");
1003         return ehResult;
1004     }
1005
1006     OCRepPayload* input = (OCRepPayload*) (ehRequest->payload);
1007     if (!input)
1008     {
1009         OIC_LOG(ERROR, ES_RH_TAG, "Failed to parse");
1010         return ehResult;
1011     }
1012
1013     if(ehRequest->resource == gProvResource.handle)
1014     {
1015         updateProvResource(ehRequest, input);
1016     }
1017     else if(ehRequest->resource == gWiFiResource.handle)
1018     {
1019         updateWiFiResource(ehRequest, input);
1020     }
1021     else if(ehRequest->resource == gCloudResource.handle)
1022     {
1023         updateCloudResource(ehRequest, input);
1024     }
1025     else if(ehRequest->resource == gDevConfResource.handle)
1026     {
1027         updateDevConfResource(ehRequest, input);
1028     }
1029
1030     OCRepPayload *getResp = NULL;
1031     if(ehRequest->resource == gProvResource.handle)
1032     {
1033         getResp = constructResponseOfProv(ehRequest);
1034     }
1035     else if(ehRequest->resource == gWiFiResource.handle)
1036     {
1037         getResp = constructResponseOfWiFi(NULL);
1038     }
1039     else if(ehRequest->resource == gCloudResource.handle)
1040     {
1041         getResp = constructResponseOfCloud(NULL);
1042     }
1043     else if(ehRequest->resource == gDevConfResource.handle)
1044     {
1045         getResp = constructResponseOfDevConf(NULL);
1046     }
1047
1048     if (!getResp)
1049     {
1050         OIC_LOG(ERROR, ES_RH_TAG, "constructResponse failed");
1051         return OC_EH_ERROR;
1052     }
1053
1054     *payload = getResp;
1055     ehResult = OC_EH_OK;
1056
1057     return ehResult;
1058 }
1059
1060 OCEntityHandlerResult ProcessPutRequest(OCEntityHandlerRequest * ehRequest,
1061         OCRepPayload** payload)
1062 {
1063     (void) ehRequest;
1064     (void) payload;
1065     OCEntityHandlerResult ehResult = OC_EH_METHOD_NOT_ALLOWED;
1066
1067     return ehResult;
1068 }
1069 /**
1070  * This is the entity handler for the registered resource.
1071  * This is invoked by OCStack whenever it recevies a request for this resource.
1072  */
1073 OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag,
1074         OCEntityHandlerRequest* entityHandlerRequest, void *callback)
1075 {
1076     (void) callback;
1077     OCEntityHandlerResult ehRet = OC_EH_OK;
1078     OCEntityHandlerResponse response =
1079     { 0, 0, OC_EH_ERROR, 0, 0,
1080     { },
1081     { 0 }, false };
1082     OCRepPayload* payload = NULL;
1083
1084     if (entityHandlerRequest && (flag & OC_REQUEST_FLAG))
1085     {
1086         if (OC_REST_GET == entityHandlerRequest->method)
1087         {
1088             OIC_LOG(INFO, ES_RH_TAG, "Received GET request");
1089             ehRet = ProcessGetRequest(entityHandlerRequest, &payload);
1090         }
1091         else if (OC_REST_PUT == entityHandlerRequest->method)
1092         {
1093             OIC_LOG(INFO, ES_RH_TAG, "Received PUT request");
1094
1095             //PUT request will be handled in the internal implementation
1096             if (gProvResource.handle != NULL)
1097             {
1098                 ehRet = ProcessPutRequest(entityHandlerRequest, &payload);
1099             }
1100             else
1101             {
1102                 OIC_LOG(ERROR, ES_RH_TAG, "Cannot process put");
1103                 ehRet = OC_EH_ERROR;
1104             }
1105         }
1106         else if (OC_REST_POST == entityHandlerRequest->method)
1107         {
1108             OIC_LOG(INFO, ES_RH_TAG, "Received OC_REST_POST from client");
1109             if (gProvResource.handle != NULL)
1110             {
1111                 ehRet = ProcessPostRequest(entityHandlerRequest, &payload);
1112             }
1113             else
1114             {
1115                 OIC_LOG(ERROR, ES_RH_TAG, "Cannot process put");
1116                 ehRet = OC_EH_ERROR;
1117             }
1118         }
1119
1120         // Format the response.  Note this requires some info about the request
1121         response.requestHandle = entityHandlerRequest->requestHandle;
1122         response.resourceHandle = entityHandlerRequest->resource;
1123         response.ehResult = ehRet;
1124         //response uses OCPaylod while all get,put methodes use OCRepPayload
1125         response.payload = (OCPayload*) (payload);
1126         response.numSendVendorSpecificHeaderOptions = 0;
1127         memset(response.sendVendorSpecificHeaderOptions, 0,
1128                 sizeof(response.sendVendorSpecificHeaderOptions));
1129         memset(response.resourceUri, 0, sizeof(response.resourceUri));
1130         // Indicate that response is NOT in a persistent buffer
1131         response.persistentBufferFlag = 0;
1132
1133         // Send the response
1134         if (OCDoResponse(&response) != OC_STACK_OK)
1135         {
1136             OIC_LOG(ERROR, ES_RH_TAG, "Error sending response");
1137             ehRet = OC_EH_ERROR;
1138         }
1139     }
1140
1141     return ehRet;
1142 }
1143
1144 OCStackResult SetDeviceProperty(ESDeviceProperty *deviceProperty)
1145 {
1146     OIC_LOG(INFO, ES_RH_TAG, "SetDeviceProperty IN");
1147
1148     gWiFiResource.supportedFreq = (deviceProperty->WiFi).freq;
1149     OIC_LOG_V(INFO, ES_RH_TAG, "WiFi Freq : %d", gWiFiResource.supportedFreq);
1150
1151     int modeIdx = 0;
1152     while((deviceProperty->WiFi).mode[modeIdx] != WiFi_EOF)
1153     {
1154         gWiFiResource.supportedMode[modeIdx] = (deviceProperty->WiFi).mode[modeIdx];
1155         OIC_LOG_V(INFO, ES_RH_TAG, "WiFi Mode : %d", gWiFiResource.supportedMode[modeIdx]);
1156         modeIdx ++;
1157     }
1158     gWiFiResource.numMode = modeIdx;
1159
1160     OICStrcpy(gDevConfResource.devName, OIC_STRING_MAX_VALUE, (deviceProperty->DevConf).deviceName);
1161     OIC_LOG_V(INFO, ES_RH_TAG, "Device Name : %s", gDevConfResource.devName);
1162
1163     OICStrcpy(gDevConfResource.modelNumber, OIC_STRING_MAX_VALUE,
1164                                                             (deviceProperty->DevConf).modelNumber);
1165     OIC_LOG_V(INFO, ES_RH_TAG, "Model Number : %s", gDevConfResource.modelNumber);
1166
1167     OIC_LOG(INFO, ES_RH_TAG, "SetDeviceProperty OUT");
1168     return OC_STACK_OK;
1169 }
1170
1171 OCStackResult SetEnrolleeState(ESEnrolleeState esState)
1172 {
1173     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeState IN");
1174
1175     gProvResource.status = esState;
1176     OIC_LOG_V(INFO, ES_RH_TAG, "Enrollee Status : %d", gProvResource.status);
1177
1178     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeState OUT");
1179     return OC_STACK_OK;
1180 }
1181
1182 OCStackResult SetEnrolleeErrCode(ESErrorCode esErrCode)
1183 {
1184     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeErrCode IN");
1185
1186     gProvResource.lastErrCode = esErrCode;
1187     OIC_LOG_V(INFO, ES_RH_TAG, "Enrollee ErrorCode : %d", gProvResource.lastErrCode);
1188
1189     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeErrCode OUT");
1190     return OC_STACK_OK;
1191 }
1192
1193 const char *getResult(OCStackResult result)
1194 {
1195     switch (result)
1196     {
1197         case OC_STACK_OK:
1198             return "OC_STACK_OK";
1199         case OC_STACK_INVALID_URI:
1200             return "OC_STACK_INVALID_URI";
1201         case OC_STACK_INVALID_QUERY:
1202             return "OC_STACK_INVALID_QUERY";
1203         case OC_STACK_INVALID_IP:
1204             return "OC_STACK_INVALID_IP";
1205         case OC_STACK_INVALID_PORT:
1206             return "OC_STACK_INVALID_PORT";
1207         case OC_STACK_INVALID_CALLBACK:
1208             return "OC_STACK_INVALID_CALLBACK";
1209         case OC_STACK_INVALID_METHOD:
1210             return "OC_STACK_INVALID_METHOD";
1211         case OC_STACK_NO_MEMORY:
1212             return "OC_STACK_NO_MEMORY";
1213         case OC_STACK_COMM_ERROR:
1214             return "OC_STACK_COMM_ERROR";
1215         case OC_STACK_INVALID_PARAM:
1216             return "OC_STACK_INVALID_PARAM";
1217         case OC_STACK_NOTIMPL:
1218             return "OC_STACK_NOTIMPL";
1219         case OC_STACK_NO_RESOURCE:
1220             return "OC_STACK_NO_RESOURCE";
1221         case OC_STACK_RESOURCE_ERROR:
1222             return "OC_STACK_RESOURCE_ERROR";
1223         case OC_STACK_SLOW_RESOURCE:
1224             return "OC_STACK_SLOW_RESOURCE";
1225         case OC_STACK_NO_OBSERVERS:
1226             return "OC_STACK_NO_OBSERVERS";
1227         case OC_STACK_ERROR:
1228             return "OC_STACK_ERROR";
1229         default:
1230             return "UNKNOWN";
1231     }
1232 }