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
 270     if(wiFiData == NULL)
 271     {
 272         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
 273         return ;
 274     }
 275
 276     memset(wiFiData->ssid, 0, MAX_SSIDLEN);
 277     memset(wiFiData->pwd, 0, MAX_CREDLEN);
 278     wiFiData->authtype = NONE_AUTH;
 279     wiFiData->enctype = NONE_AUTH;
 280     wiFiData->userdata = NULL;
 281
 282     char* ssid = NULL;
 283     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_SSID, &ssid))
 284     {
 285         OICStrcpy(gWiFiResource.ssid, sizeof(gWiFiResource.ssid), ssid);
 286         OICStrcpy(wiFiData->ssid, sizeof(wiFiData->ssid), ssid);
 287         OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.ssid : %s", gWiFiResource.ssid);
 288     }
 289
 290     char* cred = NULL;
 291     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CRED, &cred))
 292     {
 293         OICStrcpy(gWiFiResource.cred, sizeof(gWiFiResource.cred), cred);
 294         OICStrcpy(wiFiData->pwd, sizeof(wiFiData->pwd), cred);
 295         OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.cred %s", gWiFiResource.cred);
 296     }
 297
 298     int64_t authType = -1;
 299     if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_AUTHTYPE, &authType))
 300     {
 301         gWiFiResource.authType = authType;
 302         wiFiData->authtype = gWiFiResource.authType;
 303         OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.authType %u", gWiFiResource.authType);
 304     }
 305
 306     int64_t encType = -1;
 307     if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_ENCTYPE, &encType))
 308     {
 309         gWiFiResource.encType = encType;
 310         wiFiData->enctype = gWiFiResource.encType;
 311         OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.encType %u", gWiFiResource.encType);
 312     }
 313
 314     if(gReadUserdataCb)
 315     {
 316         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_WIFI, &wiFiData->userdata);
 317     }
 318
 319     if(ssid || cred || authType!= -1 || encType != -1)
 320     {
 321         OIC_LOG(INFO, ES_RH_TAG, "Send WiFiRsrc Callback To ES");
 322
 323         // TODO : Need to check appropriateness of gWiFiData
 324         if(gWifiRsrcEvtCb != NULL)
 325         {
 326             gWifiRsrcEvtCb(ES_OK, wiFiData);
 327         }
 328         else
 329         {
 330             OIC_LOG(ERROR, ES_RH_TAG, "gWifiRsrcEvtCb is NULL");
 331         }
 332     }
 333
 334     OICFree(wiFiData);
 335 }
 336
 337 void updateCloudResource(OCRepPayload* input)
 338 {
 339     ESCloudProvData* cloudData = (ESCloudProvData*)OICMalloc(sizeof(ESCloudProvData));
 340
 341     if(cloudData == NULL)
 342     {
 343         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
 344         return;
 345     }
 346
 347     memset(cloudData->authCode, 0, OIC_STRING_MAX_VALUE);
 348     memset(cloudData->authProvider, 0, OIC_STRING_MAX_VALUE);
 349     memset(cloudData->ciServer, 0, OIC_STRING_MAX_VALUE);
 350     cloudData->userdata = NULL;
 351
 352     char *authCode = NULL;
 353     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_AUTHCODE, &authCode))
 354     {
 355         OICStrcpy(gCloudResource.authCode, sizeof(gCloudResource.authCode), authCode);
 356         OICStrcpy(cloudData->authCode, sizeof(cloudData->authCode), authCode);
 357         OIC_LOG_V(INFO, ES_RH_TAG, "gCloudResource.authCode %s", gCloudResource.authCode);
 358     }
 359
 360     char *authProvider = NULL;
 361     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_AUTHPROVIDER, &authProvider))
 362     {
 363         OICStrcpy(gCloudResource.authProvider, sizeof(gCloudResource.authProvider), authProvider);
 364         OICStrcpy(cloudData->authProvider, sizeof(cloudData->authProvider), authProvider);
 365         OIC_LOG_V(INFO, ES_RH_TAG, "gCloudResource.authServerUrl %s", gCloudResource.authProvider);
 366     }
 367
 368     char *ciServer = NULL;
 369     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CISERVER, &ciServer))
 370     {
 371         OICStrcpy(gCloudResource.ciServer, sizeof(gCloudResource.ciServer), ciServer);
 372         OICStrcpy(cloudData->ciServer, sizeof(cloudData->ciServer), ciServer);
 373         OIC_LOG_V(INFO, ES_RH_TAG, "gCloudResource.ciServer %s", gCloudResource.ciServer);
 374     }
 375
 376     if(gReadUserdataCb)
 377     {
 378         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER, &cloudData->userdata);
 379     }
 380
 381     if(authCode || authProvider || ciServer)
 382     {
 383         OIC_LOG(INFO, ES_RH_TAG, "Send CloudRsrc Callback To ES");
 384
 385         // TODO : Need to check appropriateness of gCloudData
 386         if(gCloudRsrcEvtCb != NULL)
 387         {
 388             gCloudRsrcEvtCb(ES_OK, cloudData);
 389         }
 390         else
 391         {
 392             OIC_LOG(ERROR, ES_RH_TAG, "gCloudRsrcEvtCb is NULL");
 393         }
 394     }
 395
 396     OICFree(cloudData);
 397 }
 398
 399 void updateDevConfResource(OCRepPayload* input)
 400 {
 401     ESDevConfProvData* devConfData = (ESDevConfProvData*)OICMalloc(sizeof(ESDevConfProvData));
 402
 403     if(devConfData == NULL)
 404     {
 405         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
 406         return;
 407     }
 408     memset(devConfData->language, 0, OIC_STRING_MAX_VALUE);
 409     memset(devConfData->country, 0, OIC_STRING_MAX_VALUE);
 410     devConfData->userdata = NULL;
 411
 412     char *country = NULL;
 413     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_COUNTRY, &country))
 414     {
 415         OICStrcpy(gDevConfResource.country, sizeof(gDevConfResource.country), country);
 416         OICStrcpy(devConfData->country, sizeof(devConfData->country), country);
 417         OIC_LOG_V(INFO, ES_RH_TAG, "gDevConfResource.country %s", gDevConfResource.country);
 418     }
 419
 420     char *language = NULL;
 421     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_LANGUAGE, &language))
 422     {
 423         OICStrcpy(gDevConfResource.language, sizeof(gDevConfResource.language), language);
 424         OICStrcpy(devConfData->language, sizeof(devConfData->language), language);
 425         OIC_LOG_V(INFO, ES_RH_TAG, "gDevConfResource.language %s", gDevConfResource.language);
 426     }
 427
 428     if(gReadUserdataCb)
 429     {
 430         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_DEVCONF, &devConfData->userdata);
 431     }
 432
 433     if(country || language)
 434     {
 435         OIC_LOG(INFO, ES_RH_TAG, "Send DevConfRsrc Callback To ES");
 436
 437         // TODO : Need to check appropriateness of gDevConfData
 438         if(gDevConfRsrcEvtCb != NULL)
 439         {
 440             gDevConfRsrcEvtCb(ES_OK, devConfData);
 441         }
 442         else
 443         {
 444             OIC_LOG(ERROR, ES_RH_TAG, "gDevConfRsrcEvtCb is NULL");
 445         }
 446     }
 447
 448     OICFree(devConfData);
 449 }
 450
 451 OCRepPayload* constructResponseOfWiFi()
 452 {
 453     OCRepPayload* payload = OCRepPayloadCreate();
 454     if (!payload)
 455     {
 456         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 457         return NULL;
 458     }
 459
 460     OIC_LOG(INFO, ES_RH_TAG, "constructResponse wifi res");
 461     OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_WIFI);
 462
 463     size_t dimensions[MAX_REP_ARRAY_DEPTH] = {gWiFiResource.numMode, 0, 0};
 464     int64_t *modes_64 = (int64_t *)OICMalloc(gWiFiResource.numMode * sizeof(int64_t));
 465     for(int i = 0 ; i < gWiFiResource.numMode ; ++i)
 466     {
 467         modes_64[i] = gWiFiResource.supportedMode[i];
 468     }
 469     OCRepPayloadSetIntArray(payload, OC_RSRVD_ES_SUPPORTEDWIFIMODE, (int64_t *)modes_64, dimensions);
 470
 471     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_SUPPORTEDWIFIFREQ, gWiFiResource.supportedFreq);
 472     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_SSID, gWiFiResource.ssid);
 473     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CRED, gWiFiResource.cred);
 474     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_AUTHTYPE, (int) gWiFiResource.authType);
 475     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_ENCTYPE, (int) gWiFiResource.encType);
 476
 477     if(gWriteUserdataCb)
 478     {
 479         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_WIFI);
 480     }
 481
 482     return payload;
 483 }
 484
 485 OCRepPayload* constructResponseOfCloud()
 486 {
 487     OCRepPayload* payload = OCRepPayloadCreate();
 488     if (!payload)
 489     {
 490         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 491         return NULL;
 492     }
 493
 494     OIC_LOG(INFO, ES_RH_TAG, "constructResponse prov res");
 495     OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_CLOUDSERVER);
 496     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_AUTHCODE, gCloudResource.authCode);
 497     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_AUTHPROVIDER, gCloudResource.authProvider);
 498     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CISERVER, gCloudResource.ciServer);
 499
 500     if(gWriteUserdataCb)
 501     {
 502         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER);
 503     }
 504
 505     return payload;
 506 }
 507
 508 OCRepPayload* constructResponseOfDevConf()
 509 {
 510     OCRepPayload* payload = OCRepPayloadCreate();
 511     if (!payload)
 512     {
 513         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 514         return NULL;
 515     }
 516
 517     OIC_LOG(INFO, ES_RH_TAG, "constructResponse prov res");
 518     OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_DEVCONF);
 519     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_DEVNAME, gDevConfResource.devName);
 520     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_LANGUAGE, gDevConfResource.language);
 521     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_COUNTRY, gDevConfResource.country);
 522
 523     if(gWriteUserdataCb)
 524     {
 525         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_DEVCONF);
 526     }
 527
 528     return payload;
 529 }
 530
 531 OCRepPayload* constructResponseOfProv(OCEntityHandlerRequest *ehRequest)
 532 {
 533     OCRepPayload* payload = OCRepPayloadCreate();
 534     if (!payload)
 535     {
 536         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
 537         return NULL;
 538     }
 539
 540     OIC_LOG(INFO, ES_RH_TAG, "constructResponse prov res");
 541     OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_PROV);
 542     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_PROVSTATUS, gProvResource.status);
 543     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_LAST_ERRORCODE, gProvResource.lastErrCode);
 544     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_LINKS, gProvResource.ocfWebLinks);
 545
 546     if(gWriteUserdataCb)
 547     {
 548         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_PROV);
 549     }
 550
 551     if(ehRequest->query)
 552     {
 553         if(strstr(ehRequest->query, OC_RSRVD_INTERFACE_BATCH))
 554         {// When Provisioning resource has a GET with BatchInterface
 555             payload->next = constructResponseOfWiFi();
 556
 557             if(payload->next)
 558             {
 559                 payload->next->next = constructResponseOfCloud();
 560             }
 561             else
 562             {
 563                 return payload;
 564             }
 565
 566             if(payload->next->next)
 567             {
 568                 payload->next->next->next = constructResponseOfDevConf();
 569             }
 570             else
 571             {
 572                 return payload;
 573             }
 574         }
 575     }
 576
 577     return payload;
 578 }
 579
 580
 581 OCStackResult CreateEasySetupResources(bool isSecured, ESResourceMask resourceMask)
 582 {
 583     OCStackResult res = OC_STACK_ERROR;
 584     bool maskFlag = false;
 585
 586     res = initProvResource(isSecured);
 587     if(res != OC_STACK_OK)
 588     {
 589         // TODO: destroy logic will be added
 590         OIC_LOG_V(ERROR, ES_RH_TAG, "initProvResource result: %s", getResult(res));
 591
 592         return res;
 593     }
 594
 595     if((resourceMask & ES_WIFI_RESOURCE) == ES_WIFI_RESOURCE)
 596     {
 597         maskFlag = true;
 598         res = initWiFiResource(isSecured);
 599         if(res != OC_STACK_OK)
 600         {
 601             OIC_LOG_V(ERROR, ES_RH_TAG, "initWiFiResource result: %s", getResult(res));
 602             return res;
 603         }
 604
 605         res = OCBindResource(gProvResource.handle, gWiFiResource.handle);
 606         if(res != OC_STACK_OK)
 607         {
 608             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind WiFiResource result: %s", getResult(res));
 609             return res;
 610         }
 611
 612     }
 613
 614     if((resourceMask & ES_CLOUD_RESOURCE) == ES_CLOUD_RESOURCE)
 615     {
 616         maskFlag = true;
 617         res = initCloudServerResource(isSecured);
 618         if(res != OC_STACK_OK)
 619         {
 620             OIC_LOG_V(ERROR, ES_RH_TAG, "initCloudResource result: %s", getResult(res));
 621             return res;
 622         }
 623
 624         res = OCBindResource(gProvResource.handle, gCloudResource.handle);
 625         if(res != OC_STACK_OK)
 626         {
 627             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind CloudResource result: %s", getResult(res));
 628             return res;
 629         }
 630     }
 631
 632     if((resourceMask & ES_DEVCONF_RESOURCE) == ES_DEVCONF_RESOURCE)
 633     {
 634         maskFlag = true;
 635         res = initDevConfResource(isSecured);
 636         if(res != OC_STACK_OK)
 637         {
 638             OIC_LOG_V(ERROR, ES_RH_TAG, "initDevConf result: %s", getResult(res));
 639             return res;
 640         }
 641
 642         res = OCBindResource(gProvResource.handle, gDevConfResource.handle);
 643         if(res != OC_STACK_OK)
 644         {
 645             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind DevConfResource result: %s", getResult(res));
 646             return res;
 647         }
 648     }
 649
 650
 651     if(maskFlag == false)
 652     {
 653         OIC_LOG_V(ERROR, ES_RH_TAG, "Invalid ResourceMask");
 654         return OC_STACK_ERROR;
 655
 656     }
 657
 658     OIC_LOG_V(INFO, ES_RH_TAG, "Created all resources with result: %s", getResult(res));
 659
 660     return res;
 661 }
 662
 663 OCStackResult DeleteProvisioningResource()
 664 {
 665     OCStackResult res = OCDeleteResource(gProvResource.handle);
 666     if (res != OC_STACK_OK)
 667     {
 668         OIC_LOG_V(INFO, ES_RH_TAG, "Deleting Prov resource error with result: %s", getResult(res));
 669     }
 670
 671     return res;
 672 }
 673
 674 OCStackResult DeleteEasySetupResources()
 675 {
 676     OCStackResult res = OCDeleteResource(gWiFiResource.handle);
 677     if (res != OC_STACK_OK)
 678     {
 679         OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting WiFi resource error with result: %s", getResult(res));
 680     }
 681     res = OCDeleteResource(gCloudResource.handle);
 682     if (res != OC_STACK_OK)
 683     {
 684         OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting CloudServer resource error with result: %s", getResult(res));
 685     }
 686     res = OCDeleteResource(gDevConfResource.handle);
 687     if (res != OC_STACK_OK)
 688     {
 689         OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting DevConf resource error with result: %s", getResult(res));
 690     }
 691
 692     res = OCDeleteResource(gProvResource.handle);
 693     if (res != OC_STACK_OK)
 694     {
 695         OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting Prov resource error with result: %s", getResult(res));
 696     }
 697
 698     return res;
 699 }
 700
 701 OCEntityHandlerResult ProcessGetRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload **payload)
 702 {
 703     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 704     if (!ehRequest)
 705     {
 706         OIC_LOG(ERROR, ES_RH_TAG, "Request is Null");
 707         return ehResult;
 708     }
 709     if (ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
 710     {
 711         OIC_LOG(ERROR, ES_RH_TAG, "Incoming payload not a representation");
 712         return ehResult;
 713     }
 714
 715     OCRepPayload *getResp = NULL;
 716
 717     if(ehRequest->resource == gProvResource.handle)
 718     {
 719         getResp = constructResponseOfProv(ehRequest);
 720     }
 721     else if(ehRequest->resource == gWiFiResource.handle)
 722     {
 723         getResp = constructResponseOfWiFi();
 724     }
 725     else if(ehRequest->resource == gCloudResource.handle)
 726     {
 727         getResp = constructResponseOfCloud();
 728     }
 729     else if(ehRequest->resource == gDevConfResource.handle)
 730     {
 731         getResp = constructResponseOfDevConf();
 732     }
 733
 734     if (!getResp)
 735     {
 736         OIC_LOG(ERROR, ES_RH_TAG, "constructResponse failed");
 737         return OC_EH_ERROR;
 738     }
 739
 740     *payload = getResp;
 741     ehResult = OC_EH_OK;
 742
 743     return ehResult;
 744 }
 745
 746 OCEntityHandlerResult ProcessPostRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload)
 747 {
 748     OIC_LOG(INFO, ES_RH_TAG, "ProcessPostRequest enter");
 749     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 750     if (ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
 751     {
 752         OIC_LOG(ERROR, ES_RH_TAG, "Incoming payload not a representation");
 753         return ehResult;
 754     }
 755
 756     OCRepPayload* input = (OCRepPayload*) (ehRequest->payload);
 757     if (!input)
 758     {
 759         OIC_LOG(ERROR, ES_RH_TAG, "Failed to parse");
 760         return ehResult;
 761     }
 762
 763     if(ehRequest->resource == gProvResource.handle)
 764     {
 765         updateProvResource(ehRequest, input);
 766     }
 767     else if(ehRequest->resource == gWiFiResource.handle)
 768     {
 769         updateWiFiResource(input);
 770     }
 771     else if(ehRequest->resource == gCloudResource.handle)
 772     {
 773         updateCloudResource(input);
 774     }
 775     else if(ehRequest->resource == gDevConfResource.handle)
 776     {
 777         updateDevConfResource(input);
 778     }
 779
 780     OCRepPayload *getResp = NULL;
 781     if(ehRequest->resource == gProvResource.handle)
 782     {
 783         getResp = constructResponseOfProv(ehRequest);
 784     }
 785     else if(ehRequest->resource == gWiFiResource.handle)
 786     {
 787         getResp = constructResponseOfWiFi();
 788     }
 789     else if(ehRequest->resource == gCloudResource.handle)
 790     {
 791         getResp = constructResponseOfCloud();
 792     }
 793     else if(ehRequest->resource == gDevConfResource.handle)
 794     {
 795         getResp = constructResponseOfDevConf();
 796     }
 797
 798     if (!getResp)
 799     {
 800         OIC_LOG(ERROR, ES_RH_TAG, "constructResponse failed");
 801         return OC_EH_ERROR;
 802     }
 803
 804     *payload = getResp;
 805     ehResult = OC_EH_OK;
 806
 807     return ehResult;
 808 }
 809
 810 OCEntityHandlerResult ProcessPutRequest(OCEntityHandlerRequest * ehRequest,
 811         OCRepPayload** payload)
 812 {
 813     (void) ehRequest;
 814     (void) payload;
 815     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 816
 817     return ehResult;
 818 }
 819 /**
 820  * This is the entity handler for the registered resource.
 821  * This is invoked by OCStack whenever it recevies a request for this resource.
 822  */
 823 OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag,
 824         OCEntityHandlerRequest* entityHandlerRequest, void *callback)
 825 {
 826     (void) callback;
 827     OCEntityHandlerResult ehRet = OC_EH_OK;
 828     OCEntityHandlerResponse response =
 829     { 0, 0, OC_EH_ERROR, 0, 0,
 830     { },
 831     { 0 }, false };
 832     OCRepPayload* payload = NULL;
 833
 834     if (entityHandlerRequest && (flag & OC_REQUEST_FLAG))
 835     {
 836         if (OC_REST_GET == entityHandlerRequest->method)
 837         {
 838             OIC_LOG(INFO, ES_RH_TAG, "Received GET request");
 839             ehRet = ProcessGetRequest(entityHandlerRequest, &payload);
 840         }
 841         else if (OC_REST_PUT == entityHandlerRequest->method)
 842         {
 843             OIC_LOG(INFO, ES_RH_TAG, "Received PUT request");
 844
 845             //PUT request will be handled in the internal implementation
 846             if (gProvResource.handle != NULL)
 847             {
 848                 ehRet = ProcessPutRequest(entityHandlerRequest, &payload);
 849             }
 850             else
 851             {
 852                 OIC_LOG(ERROR, ES_RH_TAG, "Cannot process put");
 853                 ehRet = OC_EH_ERROR;
 854             }
 855         }
 856         else if (OC_REST_POST == entityHandlerRequest->method)
 857         {
 858             OIC_LOG(INFO, ES_RH_TAG, "Received OC_REST_POST from client");
 859             if (gProvResource.handle != NULL)
 860             {
 861                 ehRet = ProcessPostRequest(entityHandlerRequest, &payload);
 862             }
 863             else
 864             {
 865                 OIC_LOG(ERROR, ES_RH_TAG, "Cannot process put");
 866                 ehRet = OC_EH_ERROR;
 867             }
 868         }
 869
 870         if (ehRet == OC_EH_OK)
 871         {
 872             // Format the response.  Note this requires some info about the request
 873             response.requestHandle = entityHandlerRequest->requestHandle;
 874             response.resourceHandle = entityHandlerRequest->resource;
 875             response.ehResult = ehRet;
 876             //response uses OCPaylod while all get,put methodes use OCRepPayload
 877             response.payload = (OCPayload*) (payload);
 878             response.numSendVendorSpecificHeaderOptions = 0;
 879             memset(response.sendVendorSpecificHeaderOptions, 0,
 880                     sizeof(response.sendVendorSpecificHeaderOptions));
 881             memset(response.resourceUri, 0, sizeof(response.resourceUri));
 882             // Indicate that response is NOT in a persistent buffer
 883             response.persistentBufferFlag = 0;
 884
 885             // Send the response
 886             if (OCDoResponse(&response) != OC_STACK_OK)
 887             {
 888                 OIC_LOG(ERROR, ES_RH_TAG, "Error sending response");
 889                 ehRet = OC_EH_ERROR;
 890             }
 891         }
 892     }
 893
 894     return ehRet;
 895 }
 896
 897 OCStackResult SetDeviceProperty(ESDeviceProperty *deviceProperty)
 898 {
 899     OIC_LOG(INFO, ES_RH_TAG, "SetDeviceProperty IN");
 900
 901     gWiFiResource.supportedFreq = (deviceProperty->WiFi).freq;
 902     OIC_LOG_V(INFO, ES_RH_TAG, "WiFi Freq : %d", gWiFiResource.supportedFreq);
 903
 904     int modeIdx = 0;
 905     while((deviceProperty->WiFi).mode[modeIdx] != WiFi_EOF)
 906     {
 907         gWiFiResource.supportedMode[modeIdx] = (deviceProperty->WiFi).mode[modeIdx];
 908         OIC_LOG_V(INFO, ES_RH_TAG, "WiFi Mode : %d", gWiFiResource.supportedMode[modeIdx]);
 909         modeIdx ++;
 910     }
 911     gWiFiResource.numMode = modeIdx;
 912
 913     OICStrcpy(gDevConfResource.devName, MAX_DEVICELEN, (deviceProperty->DevConf).deviceName);
 914     OIC_LOG_V(INFO, ES_RH_TAG, "Device Name : %s", gDevConfResource.devName);
 915
 916     OIC_LOG(INFO, ES_RH_TAG, "SetDeviceProperty OUT");
 917     return OC_STACK_OK;
 918 }
 919
 920 OCStackResult SetEnrolleeState(ESEnrolleeState esState)
 921 {
 922     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeState IN");
 923
 924     gProvResource.status = esState;
 925     OIC_LOG_V(INFO, ES_RH_TAG, "Enrollee Status : %d", gProvResource.status);
 926
 927     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeState OUT");
 928     return OC_STACK_OK;
 929 }
 930
 931 OCStackResult SetEnrolleeErrCode(ESErrorCode esErrCode)
 932 {
 933     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeErrCode IN");
 934
 935     gProvResource.lastErrCode = esErrCode;
 936     OIC_LOG_V(INFO, ES_RH_TAG, "Enrollee ErrorCode : %d", gProvResource.lastErrCode);
 937
 938     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeErrCode OUT");
 939     return OC_STACK_OK;
 940 }
 941
 942 const char *getResult(OCStackResult result)
 943 {
 944     switch (result)
 945     {
 946         case OC_STACK_OK:
 947             return "OC_STACK_OK";
 948         case OC_STACK_INVALID_URI:
 949             return "OC_STACK_INVALID_URI";
 950         case OC_STACK_INVALID_QUERY:
 951             return "OC_STACK_INVALID_QUERY";
 952         case OC_STACK_INVALID_IP:
 953             return "OC_STACK_INVALID_IP";
 954         case OC_STACK_INVALID_PORT:
 955             return "OC_STACK_INVALID_PORT";
 956         case OC_STACK_INVALID_CALLBACK:
 957             return "OC_STACK_INVALID_CALLBACK";
 958         case OC_STACK_INVALID_METHOD:
 959             return "OC_STACK_INVALID_METHOD";
 960         case OC_STACK_NO_MEMORY:
 961             return "OC_STACK_NO_MEMORY";
 962         case OC_STACK_COMM_ERROR:
 963             return "OC_STACK_COMM_ERROR";
 964         case OC_STACK_INVALID_PARAM:
 965             return "OC_STACK_INVALID_PARAM";
 966         case OC_STACK_NOTIMPL:
 967             return "OC_STACK_NOTIMPL";
 968         case OC_STACK_NO_RESOURCE:
 969             return "OC_STACK_NO_RESOURCE";
 970         case OC_STACK_RESOURCE_ERROR:
 971             return "OC_STACK_RESOURCE_ERROR";
 972         case OC_STACK_SLOW_RESOURCE:
 973             return "OC_STACK_SLOW_RESOURCE";
 974         case OC_STACK_NO_OBSERVERS:
 975             return "OC_STACK_NO_OBSERVERS";
 976         case OC_STACK_ERROR:
 977             return "OC_STACK_ERROR";
 978         default:
 979             return "UNKNOWN";
 980     }
 981 }