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             OCRepPayload* head = payload;
 556             OCRepPayload* nextPayload = NULL;
 557
 558             nextPayload = constructResponseOfWiFi();
 559             if(nextPayload != NULL)
 560             {
 561                 payload->next = nextPayload;
 562                 payload = payload->next;
 563             }
 564
 565             nextPayload = constructResponseOfCloud();
 566             if(nextPayload != NULL)
 567             {
 568                 payload->next = nextPayload;
 569                 payload = payload->next;
 570             }
 571
 572             nextPayload = constructResponseOfDevConf();
 573             if(nextPayload != NULL)
 574             {
 575                 payload->next = nextPayload;
 576                 payload = payload->next;
 577             }
 578
 579             payload = head;
 580         }
 581     }
 582
 583     return payload;
 584 }
 585
 586
 587 OCStackResult CreateEasySetupResources(bool isSecured, ESResourceMask resourceMask)
 588 {
 589     OCStackResult res = OC_STACK_ERROR;
 590     bool maskFlag = false;
 591
 592     res = initProvResource(isSecured);
 593     if(res != OC_STACK_OK)
 594     {
 595         // TODO: destroy logic will be added
 596         OIC_LOG_V(ERROR, ES_RH_TAG, "initProvResource result: %s", getResult(res));
 597
 598         return res;
 599     }
 600
 601     if((resourceMask & ES_WIFI_RESOURCE) == ES_WIFI_RESOURCE)
 602     {
 603         maskFlag = true;
 604         res = initWiFiResource(isSecured);
 605         if(res != OC_STACK_OK)
 606         {
 607             OIC_LOG_V(ERROR, ES_RH_TAG, "initWiFiResource result: %s", getResult(res));
 608             return res;
 609         }
 610
 611         res = OCBindResource(gProvResource.handle, gWiFiResource.handle);
 612         if(res != OC_STACK_OK)
 613         {
 614             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind WiFiResource result: %s", getResult(res));
 615             return res;
 616         }
 617
 618     }
 619
 620     if((resourceMask & ES_CLOUD_RESOURCE) == ES_CLOUD_RESOURCE)
 621     {
 622         maskFlag = true;
 623         res = initCloudServerResource(isSecured);
 624         if(res != OC_STACK_OK)
 625         {
 626             OIC_LOG_V(ERROR, ES_RH_TAG, "initCloudResource result: %s", getResult(res));
 627             return res;
 628         }
 629
 630         res = OCBindResource(gProvResource.handle, gCloudResource.handle);
 631         if(res != OC_STACK_OK)
 632         {
 633             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind CloudResource result: %s", getResult(res));
 634             return res;
 635         }
 636     }
 637
 638     if((resourceMask & ES_DEVCONF_RESOURCE) == ES_DEVCONF_RESOURCE)
 639     {
 640         maskFlag = true;
 641         res = initDevConfResource(isSecured);
 642         if(res != OC_STACK_OK)
 643         {
 644             OIC_LOG_V(ERROR, ES_RH_TAG, "initDevConf result: %s", getResult(res));
 645             return res;
 646         }
 647
 648         res = OCBindResource(gProvResource.handle, gDevConfResource.handle);
 649         if(res != OC_STACK_OK)
 650         {
 651             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind DevConfResource result: %s", getResult(res));
 652             return res;
 653         }
 654     }
 655
 656
 657     if(maskFlag == false)
 658     {
 659         OIC_LOG_V(ERROR, ES_RH_TAG, "Invalid ResourceMask");
 660         return OC_STACK_ERROR;
 661
 662     }
 663
 664     OIC_LOG_V(INFO, ES_RH_TAG, "Created all resources with result: %s", getResult(res));
 665
 666     return res;
 667 }
 668
 669 OCStackResult DeleteProvisioningResource()
 670 {
 671     OCStackResult res = OCDeleteResource(gProvResource.handle);
 672     if (res != OC_STACK_OK)
 673     {
 674         OIC_LOG_V(INFO, ES_RH_TAG, "Deleting Prov resource error with result: %s", getResult(res));
 675     }
 676
 677     return res;
 678 }
 679
 680 OCStackResult DeleteEasySetupResources()
 681 {
 682     OCStackResult res = OCDeleteResource(gWiFiResource.handle);
 683     if (res != OC_STACK_OK)
 684     {
 685         OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting WiFi resource error with result: %s", getResult(res));
 686     }
 687     res = OCDeleteResource(gCloudResource.handle);
 688     if (res != OC_STACK_OK)
 689     {
 690         OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting CloudServer resource error with result: %s", getResult(res));
 691     }
 692     res = OCDeleteResource(gDevConfResource.handle);
 693     if (res != OC_STACK_OK)
 694     {
 695         OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting DevConf resource error with result: %s", getResult(res));
 696     }
 697
 698     res = OCDeleteResource(gProvResource.handle);
 699     if (res != OC_STACK_OK)
 700     {
 701         OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting Prov resource error with result: %s", getResult(res));
 702     }
 703
 704     return res;
 705 }
 706
 707 OCEntityHandlerResult ProcessGetRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload **payload)
 708 {
 709     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 710     if (!ehRequest)
 711     {
 712         OIC_LOG(ERROR, ES_RH_TAG, "Request is Null");
 713         return ehResult;
 714     }
 715     if (ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
 716     {
 717         OIC_LOG(ERROR, ES_RH_TAG, "Incoming payload not a representation");
 718         return ehResult;
 719     }
 720
 721     OCRepPayload *getResp = NULL;
 722
 723     if(ehRequest->resource == gProvResource.handle)
 724     {
 725         getResp = constructResponseOfProv(ehRequest);
 726     }
 727     else if(ehRequest->resource == gWiFiResource.handle)
 728     {
 729         getResp = constructResponseOfWiFi();
 730     }
 731     else if(ehRequest->resource == gCloudResource.handle)
 732     {
 733         getResp = constructResponseOfCloud();
 734     }
 735     else if(ehRequest->resource == gDevConfResource.handle)
 736     {
 737         getResp = constructResponseOfDevConf();
 738     }
 739
 740     if (!getResp)
 741     {
 742         OIC_LOG(ERROR, ES_RH_TAG, "constructResponse failed");
 743         return OC_EH_ERROR;
 744     }
 745
 746     *payload = getResp;
 747     ehResult = OC_EH_OK;
 748
 749     return ehResult;
 750 }
 751
 752 OCEntityHandlerResult ProcessPostRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload)
 753 {
 754     OIC_LOG(INFO, ES_RH_TAG, "ProcessPostRequest enter");
 755     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 756     if (ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
 757     {
 758         OIC_LOG(ERROR, ES_RH_TAG, "Incoming payload not a representation");
 759         return ehResult;
 760     }
 761
 762     OCRepPayload* input = (OCRepPayload*) (ehRequest->payload);
 763     if (!input)
 764     {
 765         OIC_LOG(ERROR, ES_RH_TAG, "Failed to parse");
 766         return ehResult;
 767     }
 768
 769     if(ehRequest->resource == gProvResource.handle)
 770     {
 771         updateProvResource(ehRequest, input);
 772     }
 773     else if(ehRequest->resource == gWiFiResource.handle)
 774     {
 775         updateWiFiResource(input);
 776     }
 777     else if(ehRequest->resource == gCloudResource.handle)
 778     {
 779         updateCloudResource(input);
 780     }
 781     else if(ehRequest->resource == gDevConfResource.handle)
 782     {
 783         updateDevConfResource(input);
 784     }
 785
 786     OCRepPayload *getResp = NULL;
 787     if(ehRequest->resource == gProvResource.handle)
 788     {
 789         getResp = constructResponseOfProv(ehRequest);
 790     }
 791     else if(ehRequest->resource == gWiFiResource.handle)
 792     {
 793         getResp = constructResponseOfWiFi();
 794     }
 795     else if(ehRequest->resource == gCloudResource.handle)
 796     {
 797         getResp = constructResponseOfCloud();
 798     }
 799     else if(ehRequest->resource == gDevConfResource.handle)
 800     {
 801         getResp = constructResponseOfDevConf();
 802     }
 803
 804     if (!getResp)
 805     {
 806         OIC_LOG(ERROR, ES_RH_TAG, "constructResponse failed");
 807         return OC_EH_ERROR;
 808     }
 809
 810     *payload = getResp;
 811     ehResult = OC_EH_OK;
 812
 813     return ehResult;
 814 }
 815
 816 OCEntityHandlerResult ProcessPutRequest(OCEntityHandlerRequest * ehRequest,
 817         OCRepPayload** payload)
 818 {
 819     (void) ehRequest;
 820     (void) payload;
 821     OCEntityHandlerResult ehResult = OC_EH_ERROR;
 822
 823     return ehResult;
 824 }
 825 /**
 826  * This is the entity handler for the registered resource.
 827  * This is invoked by OCStack whenever it recevies a request for this resource.
 828  */
 829 OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag,
 830         OCEntityHandlerRequest* entityHandlerRequest, void *callback)
 831 {
 832     (void) callback;
 833     OCEntityHandlerResult ehRet = OC_EH_OK;
 834     OCEntityHandlerResponse response =
 835     { 0, 0, OC_EH_ERROR, 0, 0,
 836     { },
 837     { 0 }, false };
 838     OCRepPayload* payload = NULL;
 839
 840     if (entityHandlerRequest && (flag & OC_REQUEST_FLAG))
 841     {
 842         if (OC_REST_GET == entityHandlerRequest->method)
 843         {
 844             OIC_LOG(INFO, ES_RH_TAG, "Received GET request");
 845             ehRet = ProcessGetRequest(entityHandlerRequest, &payload);
 846         }
 847         else if (OC_REST_PUT == entityHandlerRequest->method)
 848         {
 849             OIC_LOG(INFO, ES_RH_TAG, "Received PUT request");
 850
 851             //PUT request will be handled in the internal implementation
 852             if (gProvResource.handle != NULL)
 853             {
 854                 ehRet = ProcessPutRequest(entityHandlerRequest, &payload);
 855             }
 856             else
 857             {
 858                 OIC_LOG(ERROR, ES_RH_TAG, "Cannot process put");
 859                 ehRet = OC_EH_ERROR;
 860             }
 861         }
 862         else if (OC_REST_POST == entityHandlerRequest->method)
 863         {
 864             OIC_LOG(INFO, ES_RH_TAG, "Received OC_REST_POST from client");
 865             if (gProvResource.handle != NULL)
 866             {
 867                 ehRet = ProcessPostRequest(entityHandlerRequest, &payload);
 868             }
 869             else
 870             {
 871                 OIC_LOG(ERROR, ES_RH_TAG, "Cannot process put");
 872                 ehRet = OC_EH_ERROR;
 873             }
 874         }
 875
 876         if (ehRet == OC_EH_OK)
 877         {
 878             // Format the response.  Note this requires some info about the request
 879             response.requestHandle = entityHandlerRequest->requestHandle;
 880             response.resourceHandle = entityHandlerRequest->resource;
 881             response.ehResult = ehRet;
 882             //response uses OCPaylod while all get,put methodes use OCRepPayload
 883             response.payload = (OCPayload*) (payload);
 884             response.numSendVendorSpecificHeaderOptions = 0;
 885             memset(response.sendVendorSpecificHeaderOptions, 0,
 886                     sizeof(response.sendVendorSpecificHeaderOptions));
 887             memset(response.resourceUri, 0, sizeof(response.resourceUri));
 888             // Indicate that response is NOT in a persistent buffer
 889             response.persistentBufferFlag = 0;
 890
 891             // Send the response
 892             if (OCDoResponse(&response) != OC_STACK_OK)
 893             {
 894                 OIC_LOG(ERROR, ES_RH_TAG, "Error sending response");
 895                 ehRet = OC_EH_ERROR;
 896             }
 897         }
 898     }
 899
 900     return ehRet;
 901 }
 902
 903 OCStackResult SetDeviceProperty(ESDeviceProperty *deviceProperty)
 904 {
 905     OIC_LOG(INFO, ES_RH_TAG, "SetDeviceProperty IN");
 906
 907     gWiFiResource.supportedFreq = (deviceProperty->WiFi).freq;
 908     OIC_LOG_V(INFO, ES_RH_TAG, "WiFi Freq : %d", gWiFiResource.supportedFreq);
 909
 910     int modeIdx = 0;
 911     while((deviceProperty->WiFi).mode[modeIdx] != WiFi_EOF)
 912     {
 913         gWiFiResource.supportedMode[modeIdx] = (deviceProperty->WiFi).mode[modeIdx];
 914         OIC_LOG_V(INFO, ES_RH_TAG, "WiFi Mode : %d", gWiFiResource.supportedMode[modeIdx]);
 915         modeIdx ++;
 916     }
 917     gWiFiResource.numMode = modeIdx;
 918
 919     OICStrcpy(gDevConfResource.devName, MAX_DEVICELEN, (deviceProperty->DevConf).deviceName);
 920     OIC_LOG_V(INFO, ES_RH_TAG, "Device Name : %s", gDevConfResource.devName);
 921
 922     OIC_LOG(INFO, ES_RH_TAG, "SetDeviceProperty OUT");
 923     return OC_STACK_OK;
 924 }
 925
 926 OCStackResult SetEnrolleeState(ESEnrolleeState esState)
 927 {
 928     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeState IN");
 929
 930     gProvResource.status = esState;
 931     OIC_LOG_V(INFO, ES_RH_TAG, "Enrollee Status : %d", gProvResource.status);
 932
 933     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeState OUT");
 934     return OC_STACK_OK;
 935 }
 936
 937 OCStackResult SetEnrolleeErrCode(ESErrorCode esErrCode)
 938 {
 939     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeErrCode IN");
 940
 941     gProvResource.lastErrCode = esErrCode;
 942     OIC_LOG_V(INFO, ES_RH_TAG, "Enrollee ErrorCode : %d", gProvResource.lastErrCode);
 943
 944     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeErrCode OUT");
 945     return OC_STACK_OK;
 946 }
 947
 948 const char *getResult(OCStackResult result)
 949 {
 950     switch (result)
 951     {
 952         case OC_STACK_OK:
 953             return "OC_STACK_OK";
 954         case OC_STACK_INVALID_URI:
 955             return "OC_STACK_INVALID_URI";
 956         case OC_STACK_INVALID_QUERY:
 957             return "OC_STACK_INVALID_QUERY";
 958         case OC_STACK_INVALID_IP:
 959             return "OC_STACK_INVALID_IP";
 960         case OC_STACK_INVALID_PORT:
 961             return "OC_STACK_INVALID_PORT";
 962         case OC_STACK_INVALID_CALLBACK:
 963             return "OC_STACK_INVALID_CALLBACK";
 964         case OC_STACK_INVALID_METHOD:
 965             return "OC_STACK_INVALID_METHOD";
 966         case OC_STACK_NO_MEMORY:
 967             return "OC_STACK_NO_MEMORY";
 968         case OC_STACK_COMM_ERROR:
 969             return "OC_STACK_COMM_ERROR";
 970         case OC_STACK_INVALID_PARAM:
 971             return "OC_STACK_INVALID_PARAM";
 972         case OC_STACK_NOTIMPL:
 973             return "OC_STACK_NOTIMPL";
 974         case OC_STACK_NO_RESOURCE:
 975             return "OC_STACK_NO_RESOURCE";
 976         case OC_STACK_RESOURCE_ERROR:
 977             return "OC_STACK_RESOURCE_ERROR";
 978         case OC_STACK_SLOW_RESOURCE:
 979             return "OC_STACK_SLOW_RESOURCE";
 980         case OC_STACK_NO_OBSERVERS:
 981             return "OC_STACK_NO_OBSERVERS";
 982         case OC_STACK_ERROR:
 983             return "OC_STACK_ERROR";
 984         default:
 985             return "UNKNOWN";
 986     }
 987 }