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 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(input);
 282             updateWiFiResource(input);
 283             updateDevConfResource(input);
 284         }
 285     }
 286 }
 287
 288 void updateWiFiResource(OCRepPayload* input)
 289 {
 290     ESWiFiProvData* wiFiData = (ESWiFiProvData*)OICMalloc(sizeof(ESWiFiProvData));
 291
 292     if(wiFiData == NULL)
 293     {
 294         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
 295         return ;
 296     }
 297
 298     memset(wiFiData->ssid, 0, MAX_WEBLINKLEN);
 299     memset(wiFiData->pwd, 0, MAX_WEBLINKLEN);
 300     wiFiData->authtype = NONE_AUTH;
 301     wiFiData->enctype = NONE_AUTH;
 302     wiFiData->userdata = NULL;
 303
 304     char* ssid = NULL;
 305     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_SSID, &ssid))
 306     {
 307         OICStrcpy(gWiFiResource.ssid, sizeof(gWiFiResource.ssid), ssid);
 308         OICStrcpy(wiFiData->ssid, sizeof(wiFiData->ssid), ssid);
 309         OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.ssid : %s", gWiFiResource.ssid);
 310     }
 311
 312     char* cred = NULL;
 313     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CRED, &cred))
 314     {
 315         OICStrcpy(gWiFiResource.cred, sizeof(gWiFiResource.cred), cred);
 316         OICStrcpy(wiFiData->pwd, sizeof(wiFiData->pwd), cred);
 317         OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.cred %s", gWiFiResource.cred);
 318     }
 319
 320     int64_t authType = -1;
 321     if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_AUTHTYPE, &authType))
 322     {
 323         gWiFiResource.authType = authType;
 324         wiFiData->authtype = gWiFiResource.authType;
 325         OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.authType %u", gWiFiResource.authType);
 326     }
 327
 328     int64_t encType = -1;
 329     if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_ENCTYPE, &encType))
 330     {
 331         gWiFiResource.encType = encType;
 332         wiFiData->enctype = gWiFiResource.encType;
 333         OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.encType %u", gWiFiResource.encType);
 334     }
 335
 336     if(gReadUserdataCb)
 337     {
 338         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_WIFI, &wiFiData->userdata);
 339     }
 340
 341     if(ssid || cred || authType!= -1 || encType != -1)
 342     {
 343         OIC_LOG(INFO, ES_RH_TAG, "Send WiFiRsrc Callback To ES");
 344
 345         // TODO : Need to check appropriateness of gWiFiData
 346         if(gWifiRsrcEvtCb != NULL)
 347         {
 348             gWifiRsrcEvtCb(ES_OK, wiFiData);
 349         }
 350         else
 351         {
 352             OIC_LOG(ERROR, ES_RH_TAG, "gWifiRsrcEvtCb is NULL");
 353         }
 354     }
 355
 356     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(gWiFiResource.handle, OC_HIGH_QOS))
 357     {
 358         OIC_LOG(INFO, ES_RH_TAG, "Enrollee doesn't have any observers.");
 359     }
 360
 361     OICFree(wiFiData);
 362 }
 363
 364 void updateCloudResource(OCRepPayload* input)
 365 {
 366     ESCloudProvData* cloudData = (ESCloudProvData*)OICMalloc(sizeof(ESCloudProvData));
 367
 368     if(cloudData == NULL)
 369     {
 370         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
 371         return;
 372     }
 373
 374     memset(cloudData->authCode, 0, OIC_STRING_MAX_VALUE);
 375     memset(cloudData->authProvider, 0, OIC_STRING_MAX_VALUE);
 376     memset(cloudData->ciServer, 0, OIC_STRING_MAX_VALUE);
 377     cloudData->userdata = NULL;
 378
 379     char *authCode = NULL;
 380     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_AUTHCODE, &authCode))
 381     {
 382         OICStrcpy(gCloudResource.authCode, sizeof(gCloudResource.authCode), authCode);
 383         OICStrcpy(cloudData->authCode, sizeof(cloudData->authCode), authCode);
 384         OIC_LOG_V(INFO, ES_RH_TAG, "gCloudResource.authCode %s", gCloudResource.authCode);
 385     }
 386
 387     char *authProvider = NULL;
 388     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_AUTHPROVIDER, &authProvider))
 389     {
 390         OICStrcpy(gCloudResource.authProvider, sizeof(gCloudResource.authProvider), authProvider);
 391         OICStrcpy(cloudData->authProvider, sizeof(cloudData->authProvider), authProvider);
 392         OIC_LOG_V(INFO, ES_RH_TAG, "gCloudResource.authServerUrl %s", gCloudResource.authProvider);
 393     }
 394
 395     char *ciServer = NULL;
 396     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CISERVER, &ciServer))
 397     {
 398         OICStrcpy(gCloudResource.ciServer, sizeof(gCloudResource.ciServer), ciServer);
 399         OICStrcpy(cloudData->ciServer, sizeof(cloudData->ciServer), ciServer);
 400         OIC_LOG_V(INFO, ES_RH_TAG, "gCloudResource.ciServer %s", gCloudResource.ciServer);
 401     }
 402
 403     if(gReadUserdataCb)
 404     {
 405         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER, &cloudData->userdata);
 406     }
 407
 408     if(authCode || authProvider || ciServer)
 409     {
 410         OIC_LOG(INFO, ES_RH_TAG, "Send CloudRsrc Callback To ES");
 411
 412         // TODO : Need to check appropriateness of gCloudData
 413         if(gCloudRsrcEvtCb != NULL)
 414         {
 415             gCloudRsrcEvtCb(ES_OK, cloudData);
 416         }
 417         else
 418         {
 419             OIC_LOG(ERROR, ES_RH_TAG, "gCloudRsrcEvtCb is NULL");
 420         }
 421     }
 422
 423     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(gCloudResource.handle, OC_HIGH_QOS))
 424     {
 425         OIC_LOG(INFO, ES_RH_TAG, "cloudResource doesn't have any observers.");
 426     }
 427
 428     OICFree(cloudData);
 429 }
 430
 431 void updateDevConfResource(OCRepPayload* input)
 432 {
 433     ESDevConfProvData* devConfData = (ESDevConfProvData*)OICMalloc(sizeof(ESDevConfProvData));
 434
 435     if(devConfData == NULL)
 436     {
 437         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
 438         return;
 439     }
 440     memset(devConfData->language, 0, OIC_STRING_MAX_VALUE);
 441     memset(devConfData->country, 0, OIC_STRING_MAX_VALUE);
 442     devConfData->userdata = NULL;
 443
 444     char *location = NULL;
 445     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_LOCATION, &location))
 446     {
 447         OICStrcpy(gDevConfResource.location, sizeof(gDevConfResource.location), location);
 448         OICStrcpy(devConfData->location, sizeof(devConfData->location), location);
 449         OIC_LOG_V(INFO, ES_RH_TAG, "gDevConfResource.location %s", gDevConfResource.location);
 450     }
 451
 452     char *country = NULL;
 453     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_COUNTRY, &country))
 454     {
 455         OICStrcpy(gDevConfResource.country, sizeof(gDevConfResource.country), country);
 456         OICStrcpy(devConfData->country, sizeof(devConfData->country), country);
 457         OIC_LOG_V(INFO, ES_RH_TAG, "gDevConfResource.country %s", gDevConfResource.country);
 458     }
 459
 460     char *language = NULL;
 461     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_LANGUAGE, &language))
 462     {
 463         OICStrcpy(gDevConfResource.language, sizeof(gDevConfResource.language), language);
 464         OICStrcpy(devConfData->language, sizeof(devConfData->language), language);
 465         OIC_LOG_V(INFO, ES_RH_TAG, "gDevConfResource.language %s", gDevConfResource.language);
 466     }
 467
 468     if(gReadUserdataCb)
 469     {
 470         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_DEVCONF, &devConfData->userdata);
 471     }
 472
 473     if(country || language)
 474     {
 475         OIC_LOG(INFO, ES_RH_TAG, "Send DevConfRsrc Callback To ES");
 476
 477         // TODO : Need to check appropriateness of gDevConfData
 478         if(gDevConfRsrcEvtCb != NULL)
 479         {
 480             gDevConfRsrcEvtCb(ES_OK, devConfData);
 481         }
 482         else
 483         {
 484             OIC_LOG(ERROR, ES_RH_TAG, "gDevConfRsrcEvtCb is NULL");
 485         }
 486     }
 487
 488     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(gDevConfResource.handle, OC_HIGH_QOS))
 489     {
 490         OIC_LOG(INFO, ES_RH_TAG, "devConfResource doesn't have any observers.");
 491     }
 492
 493     OICFree(devConfData);
 494 }
 495
 496 OCRepPayload* constructResponseOfWiFi()
 497 {
 498     OCRepPayload* payload = OCRepPayloadCreate();
 499     if (!payload)
 500     {
 501         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 502         return NULL;
 503     }
 504
 505     if(gWiFiResource.handle == NULL)
 506     {
 507         OIC_LOG(ERROR, ES_RH_TAG, "WiFi resource is not created");
 508         return NULL;
 509     }
 510
 511     OIC_LOG(INFO, ES_RH_TAG, "constructResponse wifi res");
 512     OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_WIFI);
 513     OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_DEFAULT);
 514     OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_WIFI);
 515
 516     size_t dimensions[MAX_REP_ARRAY_DEPTH] = {gWiFiResource.numMode, 0, 0};
 517     int64_t *modes_64 = (int64_t *)OICMalloc(gWiFiResource.numMode * sizeof(int64_t));
 518     for(int i = 0 ; i < gWiFiResource.numMode ; ++i)
 519     {
 520         modes_64[i] = gWiFiResource.supportedMode[i];
 521     }
 522     OCRepPayloadSetIntArray(payload, OC_RSRVD_ES_SUPPORTEDWIFIMODE, (int64_t *)modes_64, dimensions);
 523
 524     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_SUPPORTEDWIFIFREQ, gWiFiResource.supportedFreq);
 525     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_SSID, gWiFiResource.ssid);
 526     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CRED, gWiFiResource.cred);
 527     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_AUTHTYPE, (int) gWiFiResource.authType);
 528     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_ENCTYPE, (int) gWiFiResource.encType);
 529
 530     if(gWriteUserdataCb)
 531     {
 532         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_WIFI);
 533     }
 534
 535     return payload;
 536 }
 537
 538 OCRepPayload* constructResponseOfCloud()
 539 {
 540     OCRepPayload* payload = OCRepPayloadCreate();
 541     if (!payload)
 542     {
 543         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 544         return NULL;
 545     }
 546
 547     if(gCloudResource.handle == NULL)
 548     {
 549         OIC_LOG(ERROR, ES_RH_TAG, "CloudServer resource is not created");
 550         return NULL;
 551     }
 552
 553     OIC_LOG(INFO, ES_RH_TAG, "constructResponse cloudserver res");
 554     OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_CLOUDSERVER);
 555     OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_DEFAULT);
 556     OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER);
 557
 558     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_AUTHCODE, gCloudResource.authCode);
 559     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_AUTHPROVIDER, gCloudResource.authProvider);
 560     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CISERVER, gCloudResource.ciServer);
 561
 562     if(gWriteUserdataCb)
 563     {
 564         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER);
 565     }
 566
 567     return payload;
 568 }
 569
 570 OCRepPayload* constructResponseOfDevConf()
 571 {
 572     OCRepPayload* payload = OCRepPayloadCreate();
 573     if (!payload)
 574     {
 575         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 576         return NULL;
 577     }
 578
 579     if(gDevConfResource.handle == NULL)
 580     {
 581         OIC_LOG(ERROR, ES_RH_TAG, "DevConf resource is not created");
 582         return NULL;
 583     }
 584
 585     OIC_LOG(INFO, ES_RH_TAG, "constructResponse devconf res");
 586     OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_DEVCONF);
 587     OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_DEFAULT);
 588     OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_DEVCONF);
 589
 590     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_DEVNAME, gDevConfResource.devName);
 591     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_MODELNUMBER, gDevConfResource.modelNumber);
 592     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_LOCATION, gDevConfResource.location);
 593     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_LANGUAGE, gDevConfResource.language);
 594     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_COUNTRY, gDevConfResource.country);
 595
 596     if(gWriteUserdataCb)
 597     {
 598         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_DEVCONF);
 599     }
 600
 601     return payload;
 602 }
 603
 604 OCRepPayload* constructResponseOfProv(OCEntityHandlerRequest *ehRequest)
 605 {
 606     OCRepPayload* payload = OCRepPayloadCreate();
 607     if (!payload)
 608     {
 609         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 610         return NULL;
 611     }
 612
 613     // Requested interface is Link list interface
 614     //if(ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_LL))
 615     if(!ehRequest->query ||
 616         (ehRequest->query && !strcmp(ehRequest->query, "")) ||
 617         (ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_LL)) ||
 618         (ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT)))
 619     {
 620         const OCRepPayload *arrayPayload[3] = {NULL};
 621
 622         int childResCnt = 0;
 623
 624         if(gWiFiResource.handle != NULL)
 625         {
 626             OCRepPayload *add = OCRepPayloadCreate();
 627             if(!add)
 628             {
 629                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 630                 return NULL;
 631             }
 632
 633             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
 634             char **resourceType = NULL;
 635             resourceType = (char **)OICMalloc(sizeof(char *) * 1);
 636             char **resourceInterface = NULL;
 637             resourceInterface = (char **)OICMalloc(sizeof(char *) * 1);
 638
 639             if(!resourceType || !resourceInterface)
 640             {
 641                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 642                 return NULL;
 643             }
 644
 645             resourceType[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_WIFI);
 646             resourceInterface[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
 647
 648             add->base.type = PAYLOAD_TYPE_REPRESENTATION;
 649             OCRepPayloadSetPropString(add, OC_RSRVD_HREF, OC_RSRVD_ES_URI_WIFI);
 650             OCRepPayloadSetStringArray(add, OC_RSRVD_RESOURCE_TYPE,
 651                                             (const char **)resourceType, dimensions);
 652             OCRepPayloadSetStringArray(add, OC_RSRVD_INTERFACE,
 653                                             (const char **)resourceInterface, dimensions);
 654
 655             arrayPayload[childResCnt++] = add;
 656         }
 657
 658         if(gDevConfResource.handle != NULL)
 659         {
 660             OCRepPayload *add = OCRepPayloadCreate();
 661             if(!add)
 662             {
 663                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 664                 return NULL;
 665             }
 666
 667             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
 668             char **resourceType = NULL;
 669             resourceType = (char **)OICMalloc(sizeof(char *) * 1);
 670             char **resourceInterface = NULL;
 671             resourceInterface = (char **)OICMalloc(sizeof(char *) * 1);
 672
 673             if(!resourceType || !resourceInterface)
 674             {
 675                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 676                 return NULL;
 677             }
 678
 679             resourceType[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_DEVCONF);
 680             resourceInterface[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
 681
 682             add->base.type = PAYLOAD_TYPE_REPRESENTATION;
 683             OCRepPayloadSetPropString(add, OC_RSRVD_HREF, OC_RSRVD_ES_URI_DEVCONF);
 684             OCRepPayloadSetStringArray(add, OC_RSRVD_RESOURCE_TYPE,
 685                                             (const char **)resourceType, dimensions);
 686             OCRepPayloadSetStringArray(add, OC_RSRVD_INTERFACE,
 687                                             (const char **)resourceInterface, dimensions);
 688
 689             arrayPayload[childResCnt++] = add;
 690         }
 691
 692         if(gCloudResource.handle != NULL)
 693         {
 694             OCRepPayload *add = OCRepPayloadCreate();
 695             if(!add)
 696             {
 697                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 698                 return NULL;
 699             }
 700
 701             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
 702             char **resourceType = NULL;
 703             resourceType = (char **)OICMalloc(sizeof(char *) * 1);
 704             char **resourceInterface = NULL;
 705             resourceInterface = (char **)OICMalloc(sizeof(char *) * 1);
 706
 707             if(!resourceType || !resourceInterface)
 708             {
 709                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 710                 return NULL;
 711             }
 712
 713             resourceType[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_CLOUDSERVER);
 714             resourceInterface[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
 715
 716             add->base.type = PAYLOAD_TYPE_REPRESENTATION;
 717             OCRepPayloadSetPropString(add, OC_RSRVD_HREF, OC_RSRVD_ES_URI_CLOUDSERVER);
 718             OCRepPayloadSetStringArray(add, OC_RSRVD_RESOURCE_TYPE,
 719                                             (const char **)resourceType, dimensions);
 720             OCRepPayloadSetStringArray(add, OC_RSRVD_INTERFACE,
 721                                             (const char **)resourceInterface, dimensions);
 722
 723             arrayPayload[childResCnt++] = add;
 724         }
 725
 726         size_t dimensions[MAX_REP_ARRAY_DEPTH] = {childResCnt, 0, 0};
 727
 728         if(!ehRequest->query ||
 729             (ehRequest->query && !strcmp(ehRequest->query, "")) ||
 730             (ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT)))
 731         {
 732             OIC_LOG(INFO, ES_RH_TAG, "constructResponse prov res");
 733             OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_PROV);
 734             OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_DEFAULT);
 735             OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_LL);
 736             OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_BATCH);
 737             OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_PROV);
 738
 739             OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_PROVSTATUS, gProvResource.status);
 740             OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_LAST_ERRORCODE, gProvResource.lastErrCode);
 741
 742             OCRepPayloadSetPropObjectArray(payload, OC_RSRVD_ES_LINKS, arrayPayload, dimensions);
 743         }
 744         else    // link list interface
 745         {
 746             OCRepPayload* head = payload;
 747             OCRepPayload* nextPayload = NULL;
 748
 749             for(int i = 0 ; i < childResCnt ; ++i)
 750             {
 751                 nextPayload = arrayPayload[i];
 752                 if(nextPayload != NULL)
 753                 {
 754                     payload->next = nextPayload;
 755                     payload = payload->next;
 756                 }
 757             }
 758             if(head->next != NULL)
 759             {
 760                 payload = head->next;
 761             }
 762             else
 763             {
 764                 payload = head;
 765             }
 766         }
 767     } else if (
 768         ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH))
 769
 770     {
 771         OIC_LOG(INFO, ES_RH_TAG, "constructResponse prov res");
 772         OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_PROV);
 773         OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_DEFAULT);
 774         OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_LL);
 775         OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_BATCH);
 776         OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_PROV);
 777
 778         OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_PROVSTATUS, gProvResource.status);
 779         OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_LAST_ERRORCODE, gProvResource.lastErrCode);
 780     }
 781
 782     if(gWriteUserdataCb)
 783     {
 784         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_PROV);
 785     }
 786
 787     if(ehRequest->query)
 788     {
 789         if(CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH))
 790         {// When Provisioning resource has a GET with BatchInterface
 791             OCRepPayload* head = payload;
 792             OCRepPayload* nextPayload = NULL;
 793
 794             nextPayload = constructResponseOfWiFi();
 795             if(nextPayload != NULL)
 796             {
 797                 payload->next = nextPayload;
 798                 payload = payload->next;
 799             }
 800
 801             nextPayload = constructResponseOfCloud();
 802             if(nextPayload != NULL)
 803             {
 804                 payload->next = nextPayload;
 805                 payload = payload->next;
 806             }
 807
 808             nextPayload = constructResponseOfDevConf();
 809             if(nextPayload != NULL)
 810             {
 811                 payload->next = nextPayload;
 812                 payload = payload->next;
 813             }
 814
 815             payload = head;
 816         }
 817     }
 818
 819     return payload;
 820 }
 821
 822
 823 OCStackResult CreateEasySetupResources(bool isSecured, ESResourceMask resourceMask)
 824 {
 825     OCStackResult res = OC_STACK_ERROR;
 826     bool maskFlag = false;
 827
 828     res = initProvResource(isSecured);
 829     if(res != OC_STACK_OK)
 830     {
 831         // TODO: destroy logic will be added
 832         OIC_LOG_V(ERROR, ES_RH_TAG, "initProvResource result: %s", getResult(res));
 833
 834         return res;
 835     }
 836
 837     if((resourceMask & ES_WIFI_RESOURCE) == ES_WIFI_RESOURCE)
 838     {
 839         maskFlag = true;
 840         res = initWiFiResource(isSecured);
 841         if(res != OC_STACK_OK)
 842         {
 843             OIC_LOG_V(ERROR, ES_RH_TAG, "initWiFiResource result: %s", getResult(res));
 844             return res;
 845         }
 846
 847         res = OCBindResource(gProvResource.handle, gWiFiResource.handle);
 848         if(res != OC_STACK_OK)
 849         {
 850             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind WiFiResource result: %s", getResult(res));
 851             return res;
 852         }
 853
 854     }
 855
 856     if((resourceMask & ES_CLOUD_RESOURCE) == ES_CLOUD_RESOURCE)
 857     {
 858         maskFlag = true;
 859         res = initCloudServerResource(isSecured);
 860         if(res != OC_STACK_OK)
 861         {
 862             OIC_LOG_V(ERROR, ES_RH_TAG, "initCloudResource result: %s", getResult(res));
 863             return res;
 864         }
 865
 866         res = OCBindResource(gProvResource.handle, gCloudResource.handle);
 867         if(res != OC_STACK_OK)
 868         {
 869             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind CloudResource result: %s", getResult(res));
 870             return res;
 871         }
 872     }
 873
 874     if((resourceMask & ES_DEVCONF_RESOURCE) == ES_DEVCONF_RESOURCE)
 875     {
 876         maskFlag = true;
 877         res = initDevConfResource(isSecured);
 878         if(res != OC_STACK_OK)
 879         {
 880             OIC_LOG_V(ERROR, ES_RH_TAG, "initDevConf result: %s", getResult(res));
 881             return res;
 882         }
 883
 884         res = OCBindResource(gProvResource.handle, gDevConfResource.handle);
 885         if(res != OC_STACK_OK)
 886         {
 887             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind DevConfResource result: %s", getResult(res));
 888             return res;
 889         }
 890     }
 891
 892
 893     if(maskFlag == false)
 894     {
 895         OIC_LOG_V(ERROR, ES_RH_TAG, "Invalid ResourceMask");
 896         return OC_STACK_ERROR;
 897
 898     }
 899
 900     OIC_LOG_V(INFO, ES_RH_TAG, "Created all resources with result: %s", getResult(res));
 901
 902     return res;
 903 }
 904
 905 OCStackResult DeleteProvisioningResource()
 906 {
 907     OCStackResult res = OCDeleteResource(gProvResource.handle);
 908     if (res != OC_STACK_OK)
 909     {
 910         OIC_LOG_V(INFO, ES_RH_TAG, "Deleting Prov resource error with result: %s", getResult(res));
 911     }
 912
 913     return res;
 914 }
 915
 916 OCStackResult DeleteEasySetupResources()
 917 {
 918     OCStackResult res = OC_STACK_ERROR;
 919     if (gWiFiResource.handle != NULL)
 920     {
 921         res = OCUnBindResource(gProvResource.handle, gWiFiResource.handle);
 922         if(res != OC_STACK_OK)
 923         {
 924             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind WiFi resource error with result: %s", getResult(res));
 925         }
 926     }
 927     if (gCloudResource.handle != NULL)
 928     {
 929         res = OCUnBindResource(gProvResource.handle, gCloudResource.handle);
 930         if(res != OC_STACK_OK)
 931         {
 932             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind CloudServer resource error with result: %s", getResult(res));
 933         }
 934     }
 935     if (gDevConfResource.handle != NULL)
 936     {
 937         res = OCUnBindResource(gProvResource.handle, gDevConfResource.handle);
 938         if(res != OC_STACK_OK)
 939         {
 940             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind DevConf resource error with result: %s", getResult(res));
 941         }
 942     }
 943
 944     if (gWiFiResource.handle != NULL)
 945     {
 946         res = OCDeleteResource(gWiFiResource.handle);
 947         if (res != OC_STACK_OK)
 948         {
 949             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting WiFi resource error with result: %s", getResult(res));
 950         }
 951     }
 952
 953     if(gCloudResource.handle != NULL)
 954     {
 955         res = OCDeleteResource(gCloudResource.handle);
 956         if (res != OC_STACK_OK)
 957         {
 958             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting CloudServer resource error with result: %s", getResult(res));
 959         }
 960     }
 961
 962     if(gDevConfResource.handle != NULL)
 963     {
 964         res = OCDeleteResource(gDevConfResource.handle);
 965         if (res != OC_STACK_OK)
 966         {
 967             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting DevConf resource error with result: %s", getResult(res));
 968         }
 969     }
 970
 971     if(gProvResource.handle != NULL)
 972     {
 973         res = OCDeleteResource(gProvResource.handle);
 974         if (res != OC_STACK_OK)
 975         {
 976             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting Prov resource error with result: %s", getResult(res));
 977         }
 978     }
 979
 980     return res;
 981 }
 982
 983 OCEntityHandlerResult ProcessGetRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload **payload)
 984 {
 985     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 986     if (!ehRequest)
 987     {
 988         OIC_LOG(ERROR, ES_RH_TAG, "Request is Null");
 989         return ehResult;
 990     }
 991     if (ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
 992     {
 993         OIC_LOG(ERROR, ES_RH_TAG, "Incoming payload not a representation");
 994         return ehResult;
 995     }
 996
 997     OCRepPayload *getResp = NULL;
 998     *payload = NULL;
 999
1000     if(ehRequest->resource == gProvResource.handle)
1001     {
1002         if(ehRequest->query &&
1003             strcmp(ehRequest->query, "") &&
1004             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_LL) &&
1005             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH) &&
1006             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
1007         {
1008             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1009             return OC_EH_BAD_REQ;
1010         }
1011         else
1012         {
1013             getResp = constructResponseOfProv(ehRequest);
1014         }
1015     }
1016     else if(ehRequest->resource == gWiFiResource.handle)
1017     {
1018         if(CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1019         {
1020             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1021             return OC_EH_BAD_REQ;
1022         }
1023         else
1024         {
1025             getResp = constructResponseOfWiFi();
1026         }
1027     }
1028     else if(ehRequest->resource == gCloudResource.handle)
1029     {
1030         if(CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1031         {
1032             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1033             return OC_EH_BAD_REQ;
1034         }
1035         else
1036         {
1037             getResp = constructResponseOfCloud();
1038         }
1039     }
1040     else if(ehRequest->resource == gDevConfResource.handle)
1041     {
1042         if(CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1043         {
1044             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1045             return OC_EH_BAD_REQ;
1046         }
1047         else
1048         {
1049             getResp = constructResponseOfDevConf();
1050         }
1051     }
1052
1053     if (!getResp)
1054     {
1055         OIC_LOG(ERROR, ES_RH_TAG, "constructResponse failed");
1056         return OC_EH_ERROR;
1057     }
1058
1059     *payload = getResp;
1060     ehResult = OC_EH_OK;
1061
1062     return ehResult;
1063 }
1064
1065 OCEntityHandlerResult ProcessPostRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload)
1066 {
1067     OIC_LOG(INFO, ES_RH_TAG, "ProcessPostRequest enter");
1068     OCEntityHandlerResult ehResult = OC_EH_ERROR;
1069     if (ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
1070     {
1071         OIC_LOG(ERROR, ES_RH_TAG, "Incoming payload not a representation");
1072         return ehResult;
1073     }
1074
1075     OCRepPayload* input = (OCRepPayload*) (ehRequest->payload);
1076     if (!input)
1077     {
1078         OIC_LOG(ERROR, ES_RH_TAG, "Failed to parse");
1079         return ehResult;
1080     }
1081
1082     if(ehRequest->resource == gProvResource.handle)
1083     {
1084         if(ehRequest->query &&
1085             strcmp(ehRequest->query, "") &&
1086             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH) &&
1087             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
1088         {
1089             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1090             return OC_EH_BAD_REQ;
1091         }
1092         else
1093         {
1094             updateProvResource(ehRequest, input);
1095         }
1096     }
1097     else if(ehRequest->resource == gWiFiResource.handle)
1098     {
1099         if(CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1100         {
1101             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1102             return OC_EH_BAD_REQ;
1103         }
1104         else
1105         {
1106             updateWiFiResource(input);
1107         }
1108     }
1109     else if(ehRequest->resource == gCloudResource.handle)
1110     {
1111         if(CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1112         {
1113             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1114             return OC_EH_BAD_REQ;
1115         }
1116         else
1117         {
1118             updateCloudResource(input);
1119         }
1120     }
1121     else if(ehRequest->resource == gDevConfResource.handle)
1122     {
1123         if(CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1124         {
1125             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1126             return OC_EH_BAD_REQ;
1127         }
1128         else
1129         {
1130             updateDevConfResource(input);
1131         }
1132     }
1133
1134     OCRepPayload *getResp = NULL;
1135     if(ehRequest->resource == gProvResource.handle)
1136     {
1137         getResp = constructResponseOfProv(ehRequest);
1138     }
1139     else if(ehRequest->resource == gWiFiResource.handle)
1140     {
1141         getResp = constructResponseOfWiFi();
1142     }
1143     else if(ehRequest->resource == gCloudResource.handle)
1144     {
1145         getResp = constructResponseOfCloud();
1146     }
1147     else if(ehRequest->resource == gDevConfResource.handle)
1148     {
1149         getResp = constructResponseOfDevConf();
1150     }
1151
1152     if (!getResp)
1153     {
1154         OIC_LOG(ERROR, ES_RH_TAG, "constructResponse failed");
1155         return OC_EH_ERROR;
1156     }
1157
1158     *payload = getResp;
1159     ehResult = OC_EH_OK;
1160
1161     return ehResult;
1162 }
1163
1164 OCEntityHandlerResult ProcessPutRequest(OCEntityHandlerRequest * ehRequest,
1165         OCRepPayload** payload)
1166 {
1167     (void) ehRequest;
1168     (void) payload;
1169     OCEntityHandlerResult ehResult = OC_EH_BAD_REQ;
1170
1171     return ehResult;
1172 }
1173 /**
1174  * This is the entity handler for the registered resource.
1175  * This is invoked by OCStack whenever it recevies a request for this resource.
1176  */
1177 OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag,
1178         OCEntityHandlerRequest* entityHandlerRequest, void *callback)
1179 {
1180     (void) callback;
1181     OCEntityHandlerResult ehRet = OC_EH_OK;
1182     OCEntityHandlerResponse response =
1183     { 0, 0, OC_EH_ERROR, 0, 0,
1184     { },
1185     { 0 }, false };
1186     OCRepPayload* payload = NULL;
1187
1188     if (entityHandlerRequest && (flag & OC_REQUEST_FLAG))
1189     {
1190         if (OC_REST_GET == entityHandlerRequest->method)
1191         {
1192             OIC_LOG(INFO, ES_RH_TAG, "Received GET request");
1193             ehRet = ProcessGetRequest(entityHandlerRequest, &payload);
1194         }
1195         else if (OC_REST_PUT == entityHandlerRequest->method)
1196         {
1197             OIC_LOG(INFO, ES_RH_TAG, "Received PUT request");
1198
1199             //PUT request will be handled in the internal implementation
1200             if (gProvResource.handle != NULL)
1201             {
1202                 ehRet = ProcessPutRequest(entityHandlerRequest, &payload);
1203             }
1204             else
1205             {
1206                 OIC_LOG(ERROR, ES_RH_TAG, "Cannot process put");
1207                 ehRet = OC_EH_ERROR;
1208             }
1209         }
1210         else if (OC_REST_POST == entityHandlerRequest->method)
1211         {
1212             OIC_LOG(INFO, ES_RH_TAG, "Received OC_REST_POST from client");
1213             if (gProvResource.handle != NULL)
1214             {
1215                 ehRet = ProcessPostRequest(entityHandlerRequest, &payload);
1216             }
1217             else
1218             {
1219                 OIC_LOG(ERROR, ES_RH_TAG, "Cannot process put");
1220                 ehRet = OC_EH_ERROR;
1221             }
1222         }
1223
1224         // Format the response.  Note this requires some info about the request
1225         response.requestHandle = entityHandlerRequest->requestHandle;
1226         response.resourceHandle = entityHandlerRequest->resource;
1227         response.ehResult = ehRet;
1228         //response uses OCPaylod while all get,put methodes use OCRepPayload
1229         response.payload = (OCPayload*) (payload);
1230         response.numSendVendorSpecificHeaderOptions = 0;
1231         memset(response.sendVendorSpecificHeaderOptions, 0,
1232                 sizeof(response.sendVendorSpecificHeaderOptions));
1233         memset(response.resourceUri, 0, sizeof(response.resourceUri));
1234         // Indicate that response is NOT in a persistent buffer
1235         response.persistentBufferFlag = 0;
1236
1237         // Send the response
1238         if (OCDoResponse(&response) != OC_STACK_OK)
1239         {
1240             OIC_LOG(ERROR, ES_RH_TAG, "Error sending response");
1241             ehRet = OC_EH_ERROR;
1242         }
1243     }
1244     if (entityHandlerRequest && (flag & OC_OBSERVE_FLAG))
1245     {
1246         OIC_LOG(INFO, ES_RH_TAG, "Flag includes OC_OBSERVE_FLAG");
1247
1248         if (OC_OBSERVE_REGISTER == entityHandlerRequest->obsInfo.action)
1249         {
1250             OIC_LOG (INFO, ES_RH_TAG, "Received OC_OBSERVE_REGISTER from Mediator");
1251         }
1252         else if (OC_OBSERVE_DEREGISTER == entityHandlerRequest->obsInfo.action)
1253         {
1254             OIC_LOG (INFO, ES_RH_TAG, "Received OC_OBSERVE_DEREGISTER from Mediator");
1255         }
1256     }
1257     return ehRet;
1258 }
1259
1260 OCStackResult SetDeviceProperty(ESDeviceProperty *deviceProperty)
1261 {
1262     OIC_LOG(INFO, ES_RH_TAG, "SetDeviceProperty IN");
1263
1264     gWiFiResource.supportedFreq = (deviceProperty->WiFi).freq;
1265     OIC_LOG_V(INFO, ES_RH_TAG, "WiFi Freq : %d", gWiFiResource.supportedFreq);
1266
1267     int modeIdx = 0;
1268     while((deviceProperty->WiFi).mode[modeIdx] != WiFi_EOF)
1269     {
1270         gWiFiResource.supportedMode[modeIdx] = (deviceProperty->WiFi).mode[modeIdx];
1271         OIC_LOG_V(INFO, ES_RH_TAG, "WiFi Mode : %d", gWiFiResource.supportedMode[modeIdx]);
1272         modeIdx ++;
1273     }
1274     gWiFiResource.numMode = modeIdx;
1275
1276     OICStrcpy(gDevConfResource.devName, OIC_STRING_MAX_VALUE, (deviceProperty->DevConf).deviceName);
1277     OIC_LOG_V(INFO, ES_RH_TAG, "Device Name : %s", gDevConfResource.devName);
1278
1279     OICStrcpy(gDevConfResource.modelNumber, OIC_STRING_MAX_VALUE,
1280                                                             (deviceProperty->DevConf).modelNumber);
1281     OIC_LOG_V(INFO, ES_RH_TAG, "Model Number : %s", gDevConfResource.modelNumber);
1282
1283     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(gWiFiResource.handle, OC_HIGH_QOS))
1284     {
1285         OIC_LOG(INFO, ES_RH_TAG, "wifiResource doesn't have any observers.");
1286     }
1287
1288     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(gDevConfResource.handle, OC_HIGH_QOS))
1289     {
1290         OIC_LOG(INFO, ES_RH_TAG, "devConfResource doesn't have any observers.");
1291     }
1292
1293     OIC_LOG(INFO, ES_RH_TAG, "SetDeviceProperty OUT");
1294     return OC_STACK_OK;
1295 }
1296
1297 OCStackResult SetEnrolleeState(ESEnrolleeState esState)
1298 {
1299     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeState IN");
1300
1301     gProvResource.status = esState;
1302     OIC_LOG_V(INFO, ES_RH_TAG, "Enrollee Status : %d", gProvResource.status);
1303
1304     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(gProvResource.handle, OC_HIGH_QOS))
1305     {
1306         OIC_LOG(INFO, ES_RH_TAG, "provResource doesn't have any observers.");
1307     }
1308
1309     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeState OUT");
1310     return OC_STACK_OK;
1311 }
1312
1313 OCStackResult SetEnrolleeErrCode(ESErrorCode esErrCode)
1314 {
1315     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeErrCode IN");
1316
1317     gProvResource.lastErrCode = esErrCode;
1318     OIC_LOG_V(INFO, ES_RH_TAG, "Enrollee ErrorCode : %d", gProvResource.lastErrCode);
1319
1320     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(gProvResource.handle, OC_HIGH_QOS))
1321     {
1322         OIC_LOG(INFO, ES_RH_TAG, "provResource doesn't have any observers.");
1323     }
1324
1325     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeErrCode OUT");
1326     return OC_STACK_OK;
1327 }
1328
1329 OCEntityHandlerResult CheckEhRequestPayload(OCEntityHandlerRequest *ehRequest)
1330 {
1331     if( !(ehRequest->query) ||
1332                 (ehRequest->query &&
1333                 (strcmp(ehRequest->query, "") && !CompareResourceInterface(ehRequest->query,
1334                                                                         OC_RSRVD_INTERFACE_DEFAULT))))
1335     {
1336         OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1337         return OC_EH_BAD_REQ;
1338     }
1339     return OC_EH_OK;
1340 }
1341
1342 const char *getResult(OCStackResult result)
1343 {
1344     switch (result)
1345     {
1346         case OC_STACK_OK:
1347             return "OC_STACK_OK";
1348         case OC_STACK_INVALID_URI:
1349             return "OC_STACK_INVALID_URI";
1350         case OC_STACK_INVALID_QUERY:
1351             return "OC_STACK_INVALID_QUERY";
1352         case OC_STACK_INVALID_IP:
1353             return "OC_STACK_INVALID_IP";
1354         case OC_STACK_INVALID_PORT:
1355             return "OC_STACK_INVALID_PORT";
1356         case OC_STACK_INVALID_CALLBACK:
1357             return "OC_STACK_INVALID_CALLBACK";
1358         case OC_STACK_INVALID_METHOD:
1359             return "OC_STACK_INVALID_METHOD";
1360         case OC_STACK_NO_MEMORY:
1361             return "OC_STACK_NO_MEMORY";
1362         case OC_STACK_COMM_ERROR:
1363             return "OC_STACK_COMM_ERROR";
1364         case OC_STACK_INVALID_PARAM:
1365             return "OC_STACK_INVALID_PARAM";
1366         case OC_STACK_NOTIMPL:
1367             return "OC_STACK_NOTIMPL";
1368         case OC_STACK_NO_RESOURCE:
1369             return "OC_STACK_NO_RESOURCE";
1370         case OC_STACK_RESOURCE_ERROR:
1371             return "OC_STACK_RESOURCE_ERROR";
1372         case OC_STACK_SLOW_RESOURCE:
1373             return "OC_STACK_SLOW_RESOURCE";
1374         case OC_STACK_NO_OBSERVERS:
1375             return "OC_STACK_NO_OBSERVERS";
1376         case OC_STACK_ERROR:
1377             return "OC_STACK_ERROR";
1378         default:
1379             return "UNKNOWN";
1380     }
1381 }