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(OCRepPayload* input);
  56 void updateCloudResource(OCRepPayload* input);
  57 void updateDevConfResource(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 ESResult SetCallbackForUserData(ESReadUserdataCb readCb, ESWriteUserdataCb writeCb)
  68 {
  69     if(!readCb && !writeCb)
  70     {
  71         OIC_LOG(INFO, ES_RH_TAG, "Both of callbacks for user data are null");
  72         return ES_ERROR;
  73     }
  74     gReadUserdataCb = readCb;
  75     gWriteUserdataCb = writeCb;
  76     return ES_OK;
  77 }
  78
  79 void RegisterWifiRsrcEventCallBack(ESWiFiCB cb)
  80 {
  81     gWifiRsrcEvtCb = cb;
  82 }
  83
  84 void RegisterCloudRsrcEventCallBack(ESCloudCB cb)
  85 {
  86     gCloudRsrcEvtCb = cb;
  87 }
  88
  89 void RegisterDevConfRsrcEventCallBack(ESDevConfCB cb)
  90 {
  91     gDevConfRsrcEvtCb = cb;
  92 }
  93
  94 void UnRegisterResourceEventCallBack()
  95 {
  96     if (gWifiRsrcEvtCb)
  97     {
  98         gWifiRsrcEvtCb = NULL;
  99     }
 100     if (gCloudRsrcEvtCb)
 101     {
 102         gCloudRsrcEvtCb = NULL;
 103     }
 104     if (gDevConfRsrcEvtCb)
 105     {
 106         gDevConfRsrcEvtCb = NULL;
 107     }
 108 }
 109
 110 void GetTargetNetworkInfoFromProvResource(char *name, char *pass)
 111 {
 112     if (name != NULL && pass != NULL)
 113     {
 114         OICStrcpy(name, MAX_SSIDLEN, gWiFiResource.ssid);
 115         OICStrcpy(pass, MAX_CREDLEN, gWiFiResource.cred);
 116     }
 117 }
 118
 119 OCStackResult initProvResource(bool isSecured)
 120 {
 121     gProvResource.status = ES_STATE_INIT;
 122     gProvResource.lastErrCode = ES_ERRCODE_NO_ERROR;
 123     OICStrcpy(gProvResource.ocfWebLinks, MAX_WEBLINKLEN, "");
 124
 125     OCStackResult res = OC_STACK_ERROR;
 126     if (isSecured)
 127     {
 128         res = OCCreateResource(&gProvResource.handle, OC_RSRVD_ES_RES_TYPE_PROV,
 129         OC_RSRVD_INTERFACE_DEFAULT,
 130         OC_RSRVD_ES_URI_PROV, OCEntityHandlerCb,
 131         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
 132     }else
 133     {
 134         res = OCCreateResource(&gProvResource.handle, OC_RSRVD_ES_RES_TYPE_PROV,
 135         OC_RSRVD_INTERFACE_DEFAULT,
 136         OC_RSRVD_ES_URI_PROV, OCEntityHandlerCb,
 137         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
 138     }
 139     if(res)
 140     {
 141         OIC_LOG_V(INFO, ES_RH_TAG, "Created Prov resource with result: %s", getResult(res));
 142         return res;
 143     }
 144
 145     res = OCBindResourceInterfaceToResource(gProvResource.handle, OC_RSRVD_INTERFACE_LL);
 146     if(res)
 147     {
 148         OIC_LOG_V(INFO, ES_RH_TAG, "Binding Resource interface with result: %s", getResult(res));
 149         return res;
 150     }
 151     res = OCBindResourceInterfaceToResource(gProvResource.handle, OC_RSRVD_INTERFACE_BATCH);
 152     if(res)
 153     {
 154         OIC_LOG_V(INFO, ES_RH_TAG, "Binding Resource interface with result: %s", getResult(res));
 155         return res;
 156     }
 157
 158     OIC_LOG_V(INFO, ES_RH_TAG, "Created Prov resource with result: %s", getResult(res));
 159     return res;
 160 }
 161
 162 OCStackResult initWiFiResource(bool isSecured)
 163 {
 164     OCStackResult res = OC_STACK_ERROR;
 165
 166     gWiFiResource.supportedFreq = WIFI_BOTH;
 167     gWiFiResource.supportedMode[0] = WIFI_11A;
 168     gWiFiResource.supportedMode[1] = WIFI_11B;
 169     gWiFiResource.supportedMode[2] = WIFI_11G;
 170     gWiFiResource.supportedMode[3] = WIFI_11N;
 171     gWiFiResource.numMode = 4;
 172     gWiFiResource.authType = NONE_AUTH;
 173     gWiFiResource.encType = NONE_ENC;
 174     OICStrcpy(gWiFiResource.ssid, sizeof(gWiFiResource.ssid), "");
 175     OICStrcpy(gWiFiResource.cred, sizeof(gWiFiResource.cred), "");
 176
 177     if (isSecured)
 178     {
 179         res = OCCreateResource(&gWiFiResource.handle, OC_RSRVD_ES_RES_TYPE_WIFI,
 180         OC_RSRVD_INTERFACE_DEFAULT,
 181         OC_RSRVD_ES_URI_WIFI, OCEntityHandlerCb,
 182         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
 183     }else
 184     {
 185         res = OCCreateResource(&gWiFiResource.handle, OC_RSRVD_ES_RES_TYPE_WIFI,
 186         OC_RSRVD_INTERFACE_DEFAULT,
 187         OC_RSRVD_ES_URI_WIFI, OCEntityHandlerCb,
 188         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
 189     }
 190
 191     OIC_LOG_V(INFO, ES_RH_TAG, "Created WiFi resource with result: %s", getResult(res));
 192     return res;
 193
 194 }
 195
 196 OCStackResult initCloudServerResource(bool isSecured)
 197 {
 198     OCStackResult res = OC_STACK_ERROR;
 199
 200     OICStrcpy(gCloudResource.authCode, sizeof(gCloudResource.authCode), "");
 201     OICStrcpy(gCloudResource.authProvider, sizeof(gCloudResource.authProvider), "");
 202     OICStrcpy(gCloudResource.ciServer, sizeof(gCloudResource.ciServer), "");
 203
 204     if (isSecured)
 205     {
 206         res = OCCreateResource(&gCloudResource.handle, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER,
 207         OC_RSRVD_INTERFACE_DEFAULT,
 208         OC_RSRVD_ES_URI_CLOUDSERVER, OCEntityHandlerCb,
 209         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
 210     }else
 211     {
 212         res = OCCreateResource(&gCloudResource.handle, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER,
 213         OC_RSRVD_INTERFACE_DEFAULT,
 214         OC_RSRVD_ES_URI_CLOUDSERVER, OCEntityHandlerCb,
 215         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
 216     }
 217
 218     OIC_LOG_V(INFO, ES_RH_TAG, "Created CloudServer resource with result: %s", getResult(res));
 219     return res;
 220
 221 }
 222
 223 OCStackResult initDevConfResource(bool isSecured)
 224 {
 225     OCStackResult res = OC_STACK_ERROR;
 226
 227     OICStrcpy(gDevConfResource.devName, sizeof(gDevConfResource.devName), "");
 228     OICStrcpy(gDevConfResource.country, sizeof(gDevConfResource.country), "");
 229     OICStrcpy(gDevConfResource.language, sizeof(gDevConfResource.language), "");
 230
 231     if (isSecured)
 232     {
 233         res = OCCreateResource(&gDevConfResource.handle, OC_RSRVD_ES_RES_TYPE_DEVCONF,
 234         OC_RSRVD_INTERFACE_DEFAULT,
 235         OC_RSRVD_ES_URI_DEVCONF, OCEntityHandlerCb,
 236         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
 237     }else
 238     {
 239         res = OCCreateResource(&gDevConfResource.handle, OC_RSRVD_ES_RES_TYPE_DEVCONF,
 240         OC_RSRVD_INTERFACE_DEFAULT,
 241         OC_RSRVD_ES_URI_DEVCONF, OCEntityHandlerCb,
 242         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
 243     }
 244
 245     OIC_LOG_V(INFO, ES_RH_TAG, "Created DevConf resource with result: %s", getResult(res));
 246     return res;
 247
 248 }
 249
 250 void updateProvResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input)
 251 {
 252     OIC_LOG_V(INFO, ES_RH_TAG, "gProvResource.status %d", gProvResource.status);
 253
 254     if(ehRequest->query)
 255     {
 256         if(strstr(ehRequest->query, OC_RSRVD_INTERFACE_BATCH))
 257         {
 258         // When Provisioning resource has a POST with BatchInterface
 259             updateCloudResource(input);
 260             updateWiFiResource(input);
 261             updateDevConfResource(input);
 262         }
 263     }
 264 }
 265
 266 void updateWiFiResource(OCRepPayload* input)
 267 {
 268     ESWiFiProvData* wiFiData = (ESWiFiProvData*)OICMalloc(sizeof(ESWiFiProvData));
 269     if(wiFiData == NULL)
 270     {
 271         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
 272     }
 273     wiFiData->userdata = NULL;
 274
 275     char* ssid = NULL;
 276     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_SSID, &ssid))
 277     {
 278         OICStrcpy(gWiFiResource.ssid, sizeof(gWiFiResource.ssid), ssid);
 279         OICStrcpy(wiFiData->ssid, sizeof(wiFiData->ssid), ssid);
 280         OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.ssid : %s", gWiFiResource.ssid);
 281     }
 282
 283     char* cred = NULL;
 284     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CRED, &cred))
 285     {
 286         OICStrcpy(gWiFiResource.cred, sizeof(gWiFiResource.cred), cred);
 287         OICStrcpy(wiFiData->pwd, sizeof(wiFiData->pwd), cred);
 288         OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.cred %s", gWiFiResource.cred);
 289     }
 290
 291     int64_t authType = -1;
 292     if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_AUTHTYPE, &authType))
 293     {
 294         gWiFiResource.authType = authType;
 295         wiFiData->authtype = gWiFiResource.authType;
 296         OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.authType %u", gWiFiResource.authType);
 297     }
 298
 299     int64_t encType = -1;
 300     if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_ENCTYPE, &encType))
 301     {
 302         gWiFiResource.encType = encType;
 303         wiFiData->enctype = gWiFiResource.encType;
 304         OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.encType %u", gWiFiResource.encType);
 305     }
 306
 307     if(gReadUserdataCb)
 308     {
 309         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_WIFI, wiFiData->userdata);
 310     }
 311
 312     if(ssid || cred || authType!= -1 || encType != -1)
 313     {
 314         OIC_LOG(INFO, ES_RH_TAG, "Send WiFiRsrc Callback To ES");
 315
 316         // TODO : Need to check appropriateness of gWiFiData
 317         if(gWifiRsrcEvtCb != NULL)
 318         {
 319             gWifiRsrcEvtCb(ES_OK, wiFiData);
 320         }
 321         else
 322         {
 323             OIC_LOG(ERROR, ES_RH_TAG, "gWifiRsrcEvtCb is NULL");
 324         }
 325     }
 326
 327     OICFree(wiFiData);
 328 }
 329
 330 void updateCloudResource(OCRepPayload* input)
 331 {
 332     ESCloudProvData* cloudData = (ESCloudProvData*)OICMalloc(sizeof(ESCloudProvData));
 333     if(cloudData == NULL)
 334     {
 335         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
 336     }
 337     cloudData->userdata = NULL;
 338
 339     char *authCode = NULL;
 340     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_AUTHCODE, &authCode))
 341     {
 342         OICStrcpy(gCloudResource.authCode, sizeof(gCloudResource.authCode), authCode);
 343         OICStrcpy(cloudData->authCode, sizeof(cloudData->authCode), authCode);
 344         OIC_LOG_V(INFO, ES_RH_TAG, "gCloudResource.authCode %s", gCloudResource.authCode);
 345     }
 346
 347     char *authProvider = NULL;
 348     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_AUTHPROVIDER, &authProvider))
 349     {
 350         OICStrcpy(gCloudResource.authProvider, sizeof(gCloudResource.authProvider), authProvider);
 351         OICStrcpy(cloudData->authProvider, sizeof(cloudData->authProvider), authProvider);
 352         OIC_LOG_V(INFO, ES_RH_TAG, "gCloudResource.authServerUrl %s", gCloudResource.authProvider);
 353     }
 354
 355     char *ciServer = NULL;
 356     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CISERVER, &ciServer))
 357     {
 358         OICStrcpy(gCloudResource.ciServer, sizeof(gCloudResource.ciServer), ciServer);
 359         OICStrcpy(cloudData->ciServer, sizeof(cloudData->ciServer), ciServer);
 360         OIC_LOG_V(INFO, ES_RH_TAG, "gCloudResource.ciServer %s", gCloudResource.ciServer);
 361     }
 362
 363     if(gReadUserdataCb)
 364     {
 365         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER, cloudData->userdata);
 366     }
 367
 368     if(authCode || authProvider || ciServer)
 369     {
 370         OIC_LOG(INFO, ES_RH_TAG, "Send CloudRsrc Callback To ES");
 371
 372         // TODO : Need to check appropriateness of gCloudData
 373         if(gCloudRsrcEvtCb != NULL)
 374         {
 375             gCloudRsrcEvtCb(ES_OK, cloudData);
 376         }
 377         else
 378         {
 379             OIC_LOG(ERROR, ES_RH_TAG, "gCloudRsrcEvtCb is NULL");
 380         }
 381     }
 382
 383     OICFree(cloudData);
 384 }
 385
 386 void updateDevConfResource(OCRepPayload* input)
 387 {
 388     ESDevConfProvData* devConfData = (ESDevConfProvData*)OICMalloc(sizeof(ESDevConfProvData));
 389     if(devConfData == NULL)
 390     {
 391         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
 392     }
 393     devConfData->userdata = NULL;
 394
 395     char *country = NULL;
 396     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_COUNTRY, &country))
 397     {
 398         OICStrcpy(gDevConfResource.country, sizeof(gDevConfResource.country), country);
 399         OICStrcpy(devConfData->country, sizeof(devConfData->country), country);
 400         OIC_LOG_V(INFO, ES_RH_TAG, "gDevConfResource.country %s", gDevConfResource.country);
 401     }
 402
 403     char *language = NULL;
 404     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_LANGUAGE, &language))
 405     {
 406         OICStrcpy(gDevConfResource.language, sizeof(gDevConfResource.language), language);
 407         OICStrcpy(devConfData->language, sizeof(devConfData->language), language);
 408         OIC_LOG_V(INFO, ES_RH_TAG, "gDevConfResource.language %s", gDevConfResource.language);
 409     }
 410
 411     if(gReadUserdataCb)
 412     {
 413         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_DEVCONF, devConfData->userdata);
 414     }
 415
 416     if(country || language)
 417     {
 418         OIC_LOG(INFO, ES_RH_TAG, "Send DevConfRsrc Callback To ES");
 419
 420         // TODO : Need to check appropriateness of gDevConfData
 421         if(gDevConfRsrcEvtCb != NULL)
 422         {
 423             gDevConfRsrcEvtCb(ES_OK, devConfData);
 424         }
 425         else
 426         {
 427             OIC_LOG(ERROR, ES_RH_TAG, "gDevConfRsrcEvtCb is NULL");
 428         }
 429     }
 430
 431     OICFree(devConfData);
 432 }
 433
 434 OCRepPayload* constructResponseOfWiFi()
 435 {
 436     OCRepPayload* payload = OCRepPayloadCreate();
 437     if (!payload)
 438     {
 439         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 440         return NULL;
 441     }
 442
 443     OIC_LOG(INFO, ES_RH_TAG, "constructResponse wifi res");
 444     OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_WIFI);
 445
 446     size_t dimensions[MAX_REP_ARRAY_DEPTH] = {gWiFiResource.numMode, 0, 0};
 447     int64_t *modes_64 = (int64_t *)OICMalloc(gWiFiResource.numMode * sizeof(int64_t));
 448     for(int i = 0 ; i < gWiFiResource.numMode ; ++i)
 449         modes_64[i] = gWiFiResource.supportedMode[i];
 450     OCRepPayloadSetIntArray(payload, OC_RSRVD_ES_SUPPORTEDWIFIMODE, (int64_t *)modes_64, dimensions);
 451
 452     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_SUPPORTEDWIFIFREQ, gWiFiResource.supportedFreq);
 453     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_SSID, gWiFiResource.ssid);
 454     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CRED, gWiFiResource.cred);
 455     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_AUTHTYPE, (int) gWiFiResource.authType);
 456     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_ENCTYPE, (int) gWiFiResource.encType);
 457
 458     if(gWriteUserdataCb)
 459     {
 460         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_WIFI);
 461     }
 462
 463     return payload;
 464 }
 465
 466 OCRepPayload* constructResponseOfCloud()
 467 {
 468     OCRepPayload* payload = OCRepPayloadCreate();
 469     if (!payload)
 470     {
 471         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 472         return NULL;
 473     }
 474
 475     OIC_LOG(INFO, ES_RH_TAG, "constructResponse prov res");
 476     OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_CLOUDSERVER);
 477     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_AUTHCODE, gCloudResource.authCode);
 478     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_AUTHPROVIDER, gCloudResource.authProvider);
 479     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CISERVER, gCloudResource.ciServer);
 480
 481     if(gWriteUserdataCb)
 482         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER);
 483
 484     return payload;
 485 }
 486
 487 OCRepPayload* constructResponseOfDevConf()
 488 {
 489     OCRepPayload* payload = OCRepPayloadCreate();
 490     if (!payload)
 491     {
 492         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 493         return NULL;
 494     }
 495
 496     OIC_LOG(INFO, ES_RH_TAG, "constructResponse prov res");
 497     OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_DEVCONF);
 498     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_DEVNAME, gDevConfResource.devName);
 499     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_LANGUAGE, gDevConfResource.language);
 500     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_COUNTRY, gDevConfResource.country);
 501
 502     if(gWriteUserdataCb)
 503     {
 504         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_DEVCONF);
 505     }
 506
 507     return payload;
 508 }
 509
 510 OCRepPayload* constructResponseOfProv(OCEntityHandlerRequest *ehRequest)
 511 {
 512     OCRepPayload* payload = OCRepPayloadCreate();
 513     if (!payload)
 514     {
 515         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 516         return NULL;
 517     }
 518
 519     OIC_LOG(INFO, ES_RH_TAG, "constructResponse prov res");
 520     OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_PROV);
 521     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_PROVSTATUS, gProvResource.status);
 522     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_LAST_ERRORCODE, gProvResource.lastErrCode);
 523     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_LINKS, gProvResource.ocfWebLinks);
 524
 525     if(gWriteUserdataCb)
 526     {
 527         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_PROV);
 528     }
 529
 530     if(ehRequest->query)
 531     {
 532         if(strstr(ehRequest->query, OC_RSRVD_INTERFACE_BATCH))
 533         {// When Provisioning resource has a GET with BatchInterface
 534             payload->next = constructResponseOfWiFi();
 535
 536             if(payload->next)
 537                 payload->next->next = constructResponseOfCloud();
 538             else
 539                 return payload;
 540
 541             if(payload->next->next)
 542                 payload->next->next->next = constructResponseOfDevConf();
 543             else
 544                 return payload;
 545         }
 546     }
 547
 548     return payload;
 549 }
 550
 551
 552 OCStackResult CreateEasySetupResources(bool isSecured, ESResourceMask resourceMask)
 553 {
 554     OCStackResult res = OC_STACK_ERROR;
 555     bool maskFlag = false;
 556
 557     res = initProvResource(isSecured);
 558     if(res != OC_STACK_OK)
 559     {
 560         // TODO: destroy logic will be added
 561         OIC_LOG_V(ERROR, ES_RH_TAG, "initProvResource result: %s", getResult(res));
 562
 563         return res;
 564     }
 565
 566     if((resourceMask & ES_WIFI_RESOURCE) == ES_WIFI_RESOURCE)
 567     {
 568         maskFlag = true;
 569         res = initWiFiResource(isSecured);
 570         if(res != OC_STACK_OK)
 571         {
 572             OIC_LOG_V(ERROR, ES_RH_TAG, "initWiFiResource result: %s", getResult(res));
 573             return res;
 574         }
 575
 576         res = OCBindResource(gProvResource.handle, gWiFiResource.handle);
 577         if(res != OC_STACK_OK)
 578         {
 579             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind WiFiResource result: %s", getResult(res));
 580             return res;
 581         }
 582
 583     }
 584
 585     if((resourceMask & ES_CLOUD_RESOURCE) == ES_CLOUD_RESOURCE)
 586     {
 587         maskFlag = true;
 588         res = initCloudServerResource(isSecured);
 589         if(res != OC_STACK_OK)
 590         {
 591             OIC_LOG_V(ERROR, ES_RH_TAG, "initCloudResource result: %s", getResult(res));
 592             return res;
 593         }
 594
 595         res = OCBindResource(gProvResource.handle, gCloudResource.handle);
 596         if(res != OC_STACK_OK)
 597         {
 598             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind CloudResource result: %s", getResult(res));
 599             return res;
 600         }
 601     }
 602
 603     if((resourceMask & ES_DEVCONF_RESOURCE) == ES_DEVCONF_RESOURCE)
 604     {
 605         maskFlag = true;
 606         res = initDevConfResource(isSecured);
 607         if(res != OC_STACK_OK)
 608         {
 609             OIC_LOG_V(ERROR, ES_RH_TAG, "initDevConf result: %s", getResult(res));
 610             return res;
 611         }
 612
 613         res = OCBindResource(gProvResource.handle, gDevConfResource.handle);
 614         if(res != OC_STACK_OK)
 615         {
 616             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind DevConfResource result: %s", getResult(res));
 617             return res;
 618         }
 619     }
 620
 621
 622     if(maskFlag == false)
 623     {
 624         OIC_LOG_V(ERROR, ES_RH_TAG, "Invalid ResourceMask");
 625         return OC_STACK_ERROR;
 626
 627     }
 628
 629     OIC_LOG_V(INFO, ES_RH_TAG, "Created all resources with result: %s", getResult(res));
 630
 631     return res;
 632 }
 633
 634 OCStackResult DeleteProvisioningResource()
 635 {
 636     OCStackResult res = OCDeleteResource(gProvResource.handle);
 637     if (res != OC_STACK_OK)
 638     {
 639         OIC_LOG_V(INFO, ES_RH_TAG, "Deleting Prov resource error with result: %s", getResult(res));
 640     }
 641
 642     return res;
 643 }
 644
 645 OCStackResult DeleteEasySetupResources()
 646 {
 647     OCStackResult res = OCDeleteResource(gWiFiResource.handle);
 648     if (res != OC_STACK_OK)
 649     {
 650         OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting WiFi resource error with result: %s", getResult(res));
 651     }
 652     res = OCDeleteResource(gCloudResource.handle);
 653     if (res != OC_STACK_OK)
 654     {
 655         OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting CloudServer resource error with result: %s", getResult(res));
 656     }
 657     res = OCDeleteResource(gDevConfResource.handle);
 658     if (res != OC_STACK_OK)
 659     {
 660         OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting DevConf resource error with result: %s", getResult(res));
 661     }
 662
 663     res = OCDeleteResource(gProvResource.handle);
 664     if (res != OC_STACK_OK)
 665     {
 666         OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting Prov resource error with result: %s", getResult(res));
 667     }
 668
 669     return res;
 670 }
 671
 672 OCEntityHandlerResult ProcessGetRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload **payload)
 673 {
 674     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 675     if (!ehRequest)
 676     {
 677         OIC_LOG(ERROR, ES_RH_TAG, "Request is Null");
 678         return ehResult;
 679     }
 680     if (ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
 681     {
 682         OIC_LOG(ERROR, ES_RH_TAG, "Incoming payload not a representation");
 683         return ehResult;
 684     }
 685
 686     OCRepPayload *getResp = NULL;
 687
 688     if(ehRequest->resource == gProvResource.handle)
 689     {
 690         getResp = constructResponseOfProv(ehRequest);
 691     }
 692     else if(ehRequest->resource == gWiFiResource.handle)
 693     {
 694         getResp = constructResponseOfWiFi();
 695     }
 696     else if(ehRequest->resource == gCloudResource.handle)
 697     {
 698         getResp = constructResponseOfCloud();
 699     }
 700     else if(ehRequest->resource == gDevConfResource.handle)
 701     {
 702         getResp = constructResponseOfDevConf();
 703     }
 704
 705     if (!getResp)
 706     {
 707         OIC_LOG(ERROR, ES_RH_TAG, "constructResponse failed");
 708         return OC_EH_ERROR;
 709     }
 710
 711     *payload = getResp;
 712     ehResult = OC_EH_OK;
 713
 714     return ehResult;
 715 }
 716
 717 OCEntityHandlerResult ProcessPostRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload)
 718 {
 719     OIC_LOG(INFO, ES_RH_TAG, "ProcessPostRequest enter");
 720     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 721     if (ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
 722     {
 723         OIC_LOG(ERROR, ES_RH_TAG, "Incoming payload not a representation");
 724         return ehResult;
 725     }
 726
 727     OCRepPayload* input = (OCRepPayload*) (ehRequest->payload);
 728     if (!input)
 729     {
 730         OIC_LOG(ERROR, ES_RH_TAG, "Failed to parse");
 731         return ehResult;
 732     }
 733
 734     if(ehRequest->resource == gProvResource.handle)
 735     {
 736         updateProvResource(ehRequest, input);
 737     }
 738     else if(ehRequest->resource == gWiFiResource.handle)
 739     {
 740         updateWiFiResource(input);
 741     }
 742     else if(ehRequest->resource == gCloudResource.handle)
 743     {
 744         updateCloudResource(input);
 745     }
 746     else if(ehRequest->resource == gDevConfResource.handle)
 747     {
 748         updateDevConfResource(input);
 749     }
 750
 751     OCRepPayload *getResp = NULL;
 752     if(ehRequest->resource == gProvResource.handle)
 753     {
 754         getResp = constructResponseOfProv(ehRequest);
 755     }
 756     else if(ehRequest->resource == gWiFiResource.handle)
 757     {
 758         getResp = constructResponseOfWiFi();
 759     }
 760     else if(ehRequest->resource == gCloudResource.handle)
 761     {
 762         getResp = constructResponseOfCloud();
 763     }
 764     else if(ehRequest->resource == gDevConfResource.handle)
 765     {
 766         getResp = constructResponseOfDevConf();
 767     }
 768
 769     if (!getResp)
 770     {
 771         OIC_LOG(ERROR, ES_RH_TAG, "constructResponse failed");
 772         return OC_EH_ERROR;
 773     }
 774
 775     *payload = getResp;
 776     ehResult = OC_EH_OK;
 777
 778     return ehResult;
 779 }
 780
 781 OCEntityHandlerResult ProcessPutRequest(OCEntityHandlerRequest * ehRequest,
 782         OCRepPayload** payload)
 783 {
 784     (void) ehRequest;
 785     (void) payload;
 786     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 787
 788     return ehResult;
 789 }
 790 /**
 791  * This is the entity handler for the registered resource.
 792  * This is invoked by OCStack whenever it recevies a request for this resource.
 793  */
 794 OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag,
 795         OCEntityHandlerRequest* entityHandlerRequest, void *callback)
 796 {
 797     (void) callback;
 798     OCEntityHandlerResult ehRet = OC_EH_OK;
 799     OCEntityHandlerResponse response =
 800     { 0, 0, OC_EH_ERROR, 0, 0,
 801     { },
 802     { 0 }, false };
 803     OCRepPayload* payload = NULL;
 804
 805     if (entityHandlerRequest && (flag & OC_REQUEST_FLAG))
 806     {
 807         if (OC_REST_GET == entityHandlerRequest->method)
 808         {
 809             OIC_LOG(INFO, ES_RH_TAG, "Received GET request");
 810             ehRet = ProcessGetRequest(entityHandlerRequest, &payload);
 811         }
 812         else if (OC_REST_PUT == entityHandlerRequest->method)
 813         {
 814             OIC_LOG(INFO, ES_RH_TAG, "Received PUT request");
 815
 816             //PUT request will be handled in the internal implementation
 817             if (gProvResource.handle != NULL)
 818             {
 819                 ehRet = ProcessPutRequest(entityHandlerRequest, &payload);
 820             }
 821             else
 822             {
 823                 OIC_LOG(ERROR, ES_RH_TAG, "Cannot process put");
 824                 ehRet = OC_EH_ERROR;
 825             }
 826         }
 827         else if (OC_REST_POST == entityHandlerRequest->method)
 828         {
 829             OIC_LOG(INFO, ES_RH_TAG, "Received OC_REST_POST from client");
 830             if (gProvResource.handle != NULL)
 831             {
 832                 ehRet = ProcessPostRequest(entityHandlerRequest, &payload);
 833             }
 834             else
 835             {
 836                 OIC_LOG(ERROR, ES_RH_TAG, "Cannot process put");
 837                 ehRet = OC_EH_ERROR;
 838             }
 839         }
 840
 841         if (ehRet == OC_EH_OK)
 842         {
 843             // Format the response.  Note this requires some info about the request
 844             response.requestHandle = entityHandlerRequest->requestHandle;
 845             response.resourceHandle = entityHandlerRequest->resource;
 846             response.ehResult = ehRet;
 847             //response uses OCPaylod while all get,put methodes use OCRepPayload
 848             response.payload = (OCPayload*) (payload);
 849             response.numSendVendorSpecificHeaderOptions = 0;
 850             memset(response.sendVendorSpecificHeaderOptions, 0,
 851                     sizeof(response.sendVendorSpecificHeaderOptions));
 852             memset(response.resourceUri, 0, sizeof(response.resourceUri));
 853             // Indicate that response is NOT in a persistent buffer
 854             response.persistentBufferFlag = 0;
 855
 856             // Send the response
 857             if (OCDoResponse(&response) != OC_STACK_OK)
 858             {
 859                 OIC_LOG(ERROR, ES_RH_TAG, "Error sending response");
 860                 ehRet = OC_EH_ERROR;
 861             }
 862         }
 863     }
 864
 865     return ehRet;
 866 }
 867
 868 OCStackResult SetDeviceProperty(ESDeviceProperty *deviceProperty)
 869 {
 870     OIC_LOG(INFO, ES_RH_TAG, "SetDeviceProperty IN");
 871
 872     gWiFiResource.supportedFreq = (deviceProperty->WiFi).freq;
 873     OIC_LOG_V(INFO, ES_RH_TAG, "WiFi Freq : %d", gWiFiResource.supportedFreq);
 874
 875     int modeIdx = 0;
 876     while((deviceProperty->WiFi).mode[modeIdx] != WiFi_EOF)
 877     {
 878         gWiFiResource.supportedMode[modeIdx] = (deviceProperty->WiFi).mode[modeIdx];
 879         OIC_LOG_V(INFO, ES_RH_TAG, "WiFi Mode : %d", gWiFiResource.supportedMode[modeIdx]);
 880         modeIdx ++;
 881     }
 882     gWiFiResource.numMode = modeIdx;
 883
 884     OICStrcpy(gDevConfResource.devName, MAX_DEVICELEN, (deviceProperty->DevConf).deviceName);
 885     OIC_LOG_V(INFO, ES_RH_TAG, "Device Name : %s", gDevConfResource.devName);
 886
 887     OIC_LOG(INFO, ES_RH_TAG, "SetDeviceProperty OUT");
 888     return OC_STACK_OK;
 889 }
 890
 891 OCStackResult SetEnrolleeState(ESEnrolleeState esState)
 892 {
 893     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeState IN");
 894
 895     gProvResource.status = esState;
 896     OIC_LOG_V(INFO, ES_RH_TAG, "Enrollee Status : %d", gProvResource.status);
 897
 898     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeState OUT");
 899     return OC_STACK_OK;
 900 }
 901
 902 OCStackResult SetEnrolleeErrCode(ESErrorCode esErrCode)
 903 {
 904     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeErrCode IN");
 905
 906     gProvResource.lastErrCode = esErrCode;
 907     OIC_LOG_V(INFO, ES_RH_TAG, "Enrollee ErrorCode : %d", gProvResource.lastErrCode);
 908
 909     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeErrCode OUT");
 910     return OC_STACK_OK;
 911 }
 912
 913 const char *getResult(OCStackResult result)
 914 {
 915     switch (result)
 916     {
 917         case OC_STACK_OK:
 918             return "OC_STACK_OK";
 919         case OC_STACK_INVALID_URI:
 920             return "OC_STACK_INVALID_URI";
 921         case OC_STACK_INVALID_QUERY:
 922             return "OC_STACK_INVALID_QUERY";
 923         case OC_STACK_INVALID_IP:
 924             return "OC_STACK_INVALID_IP";
 925         case OC_STACK_INVALID_PORT:
 926             return "OC_STACK_INVALID_PORT";
 927         case OC_STACK_INVALID_CALLBACK:
 928             return "OC_STACK_INVALID_CALLBACK";
 929         case OC_STACK_INVALID_METHOD:
 930             return "OC_STACK_INVALID_METHOD";
 931         case OC_STACK_NO_MEMORY:
 932             return "OC_STACK_NO_MEMORY";
 933         case OC_STACK_COMM_ERROR:
 934             return "OC_STACK_COMM_ERROR";
 935         case OC_STACK_INVALID_PARAM:
 936             return "OC_STACK_INVALID_PARAM";
 937         case OC_STACK_NOTIMPL:
 938             return "OC_STACK_NOTIMPL";
 939         case OC_STACK_NO_RESOURCE:
 940             return "OC_STACK_NO_RESOURCE";
 941         case OC_STACK_RESOURCE_ERROR:
 942             return "OC_STACK_RESOURCE_ERROR";
 943         case OC_STACK_SLOW_RESOURCE:
 944             return "OC_STACK_SLOW_RESOURCE";
 945         case OC_STACK_NO_OBSERVERS:
 946             return "OC_STACK_NO_OBSERVERS";
 947         case OC_STACK_ERROR:
 948             return "OC_STACK_ERROR";
 949         default:
 950             return "UNKNOWN";
 951     }
 952 }