Merge branch 'master' into cloud-interface
[iotivity.git] / 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 #include "cautilinterface.h"
27
28 /**
29  * @var ES_RH_TAG
30  * @brief Logging tag for module name.
31  */
32 #define ES_RH_TAG "ES_RH"
33 //-----------------------------------------------------------------------------
34 // Private variables
35 //-----------------------------------------------------------------------------
36
37 /**
38  * @var g_ESEasySetupResource
39  * @brief Structure for holding the Provisioning status
40  */
41 EasySetupResource g_ESEasySetupResource;
42 WiFiConfResource g_ESWiFiConfResource;
43 CoapCloudConfResource g_ESCoapCloudConfResource;
44 DevConfResource g_ESDevConfResource;
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 updateEasySetupResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input);
55 void updateWiFiConfResource(OCRepPayload* input);
56 void updateCoapCloudConfResource(OCRepPayload* input);
57 void updateDevConfResource(OCRepPayload* input);
58 const char *getResult(OCStackResult result);
59
60 ESConnectRequestCB gConnectRequestEvtCb = NULL;
61 ESWiFiConfCB gWifiConfRsrcEvtCb = NULL;
62 ESCoapCloudConfCB gCoapCloudConfRsrcEvtCb = NULL;
63 ESDevConfCB gDevConfRsrcEvtCb = NULL;
64
65 ESReadUserdataCb gReadUserdataCb = NULL;
66 ESWriteUserdataCb gWriteUserdataCb = NULL;
67
68 bool CompareResourceInterface(char *from, char *iface)
69 {
70     char *str = OICStrdup(from);
71     char *ptr = strtok(str, ";");
72
73     if (ptr == NULL)
74     {
75         OICFree(str);
76         return false;
77     }
78
79     do
80     {
81         if (strstr(ptr, ".if."))
82         {
83             char *if_ptr = NULL;
84             if_ptr = strtok(ptr, "=");
85             if_ptr = strtok(NULL, "=");
86
87             if (!strcmp(if_ptr, iface))
88             {
89                 OICFree(str);
90                 return true;
91             }
92         }
93
94     } while ((ptr = strtok(NULL, ";")));
95
96     OICFree(str);
97     return false;
98 }
99
100 ESResult SetCallbackForUserData(ESReadUserdataCb readCb, ESWriteUserdataCb writeCb)
101 {
102     if (!readCb && !writeCb)
103     {
104         OIC_LOG(DEBUG, ES_RH_TAG, "Both of callbacks for user data are null");
105         return ES_ERROR;
106     }
107     gReadUserdataCb = readCb;
108     gWriteUserdataCb = writeCb;
109     return ES_OK;
110 }
111
112 void RegisterWifiRsrcEventCallBack(ESWiFiConfCB cb)
113 {
114     gWifiConfRsrcEvtCb = cb;
115 }
116
117 void RegisterCloudRsrcEventCallBack(ESCoapCloudConfCB cb)
118 {
119     gCoapCloudConfRsrcEvtCb = cb;
120 }
121
122 void RegisterDevConfRsrcEventCallBack(ESDevConfCB cb)
123 {
124     gDevConfRsrcEvtCb = cb;
125 }
126
127 void RegisterConnectRequestEventCallBack(ESConnectRequestCB cb)
128 {
129     gConnectRequestEvtCb = cb;
130 }
131
132 void UnRegisterResourceEventCallBack()
133 {
134     if (gWifiConfRsrcEvtCb)
135     {
136         gWifiConfRsrcEvtCb = NULL;
137     }
138     if (gCoapCloudConfRsrcEvtCb)
139     {
140         gCoapCloudConfRsrcEvtCb = NULL;
141     }
142     if (gDevConfRsrcEvtCb)
143     {
144         gDevConfRsrcEvtCb = NULL;
145     }
146     if (gConnectRequestEvtCb)
147     {
148         gConnectRequestEvtCb = NULL;
149     }
150 }
151
152 OCStackResult initEasySetupResource(bool isSecured)
153 {
154     g_ESEasySetupResource.status = ES_STATE_INIT;
155     g_ESEasySetupResource.lastErrCode = ES_ERRCODE_NO_ERROR;
156     for( int i = 0 ; i < NUM_CONNECT_TYPE ; ++i )
157     {
158         g_ESEasySetupResource.connectRequest[i] = ES_CONNECT_NONE;
159     }
160     g_ESEasySetupResource.numRequest = 0;
161
162     OCStackResult res = OC_STACK_ERROR;
163     if (isSecured)
164     {
165         res = OCCreateResource(&g_ESEasySetupResource.handle, OC_RSRVD_ES_RES_TYPE_EASYSETUP,
166         OC_RSRVD_INTERFACE_DEFAULT,
167         OC_RSRVD_ES_URI_EASYSETUP, OCEntityHandlerCb,
168         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
169     }else
170     {
171         res = OCCreateResource(&g_ESEasySetupResource.handle, OC_RSRVD_ES_RES_TYPE_EASYSETUP,
172         OC_RSRVD_INTERFACE_DEFAULT,
173         OC_RSRVD_ES_URI_EASYSETUP, OCEntityHandlerCb,
174         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
175     }
176     if (res != OC_STACK_OK)
177     {
178         OIC_LOG_V(ERROR, ES_RH_TAG, "Created EasySetup resource with result: %s", getResult(res));
179         return res;
180     }
181
182     res = OCBindResourceTypeToResource(g_ESEasySetupResource.handle, OC_RSRVD_ES_RES_TYPE_COL);
183     if (res != OC_STACK_OK)
184     {
185         OIC_LOG_V(ERROR, ES_RH_TAG, "Binding Resource type with result: %s", getResult(res));
186         return res;
187     }
188
189     res = OCBindResourceInterfaceToResource(g_ESEasySetupResource.handle, OC_RSRVD_INTERFACE_LL);
190     if (res != OC_STACK_OK)
191     {
192         OIC_LOG_V(ERROR, ES_RH_TAG, "Binding Resource interface with result: %s", getResult(res));
193         return res;
194     }
195     res = OCBindResourceInterfaceToResource(g_ESEasySetupResource.handle, OC_RSRVD_INTERFACE_BATCH);
196     if (res != OC_STACK_OK)
197     {
198         OIC_LOG_V(ERROR, ES_RH_TAG, "Binding Resource interface with result: %s", getResult(res));
199         return res;
200     }
201
202     OIC_LOG_V(DEBUG, ES_RH_TAG, "Created EasySetup resource with result: %s", getResult(res));
203     return res;
204 }
205
206 OCStackResult initWiFiConfResource(bool isSecured)
207 {
208     OCStackResult res = OC_STACK_ERROR;
209
210     g_ESWiFiConfResource.supportedFreq = WIFI_BOTH;
211     g_ESWiFiConfResource.supportedMode[0] = WIFI_11A;
212     g_ESWiFiConfResource.supportedMode[1] = WIFI_11B;
213     g_ESWiFiConfResource.supportedMode[2] = WIFI_11G;
214     g_ESWiFiConfResource.supportedMode[3] = WIFI_11N;
215     g_ESWiFiConfResource.numMode = 4;
216     g_ESWiFiConfResource.authType = NONE_AUTH;
217     g_ESWiFiConfResource.encType = NONE_ENC;
218     OICStrcpy(g_ESWiFiConfResource.ssid, sizeof(g_ESWiFiConfResource.ssid), "");
219     OICStrcpy(g_ESWiFiConfResource.cred, sizeof(g_ESWiFiConfResource.cred), "");
220
221     if (isSecured)
222     {
223         res = OCCreateResource(&g_ESWiFiConfResource.handle, OC_RSRVD_ES_RES_TYPE_WIFICONF,
224         OC_RSRVD_INTERFACE_DEFAULT,
225         OC_RSRVD_ES_URI_WIFICONF, OCEntityHandlerCb,
226         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
227     }else
228     {
229         res = OCCreateResource(&g_ESWiFiConfResource.handle, OC_RSRVD_ES_RES_TYPE_WIFICONF,
230         OC_RSRVD_INTERFACE_DEFAULT,
231         OC_RSRVD_ES_URI_WIFICONF, OCEntityHandlerCb,
232         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
233     }
234
235     OIC_LOG_V(DEBUG, ES_RH_TAG, "Created WiFiConf resource with result: %s", getResult(res));
236     return res;
237
238 }
239
240 OCStackResult initCoapCloudConfResource(bool isSecured)
241 {
242     OCStackResult res = OC_STACK_ERROR;
243
244     OICStrcpy(g_ESCoapCloudConfResource.authCode, sizeof(g_ESCoapCloudConfResource.authCode), "");
245     OICStrcpy(g_ESCoapCloudConfResource.accessToken, sizeof(g_ESCoapCloudConfResource.accessToken), "");
246     g_ESCoapCloudConfResource.accessTokenType = NONE_OAUTH_TOKENTYPE;
247     OICStrcpy(g_ESCoapCloudConfResource.authProvider, sizeof(g_ESCoapCloudConfResource.authProvider), "");
248     OICStrcpy(g_ESCoapCloudConfResource.ciServer, sizeof(g_ESCoapCloudConfResource.ciServer), "");
249
250     if (isSecured)
251     {
252         res = OCCreateResource(&g_ESCoapCloudConfResource.handle, OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF,
253         OC_RSRVD_INTERFACE_DEFAULT,
254         OC_RSRVD_ES_URI_COAPCLOUDCONF, OCEntityHandlerCb,
255         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
256     }else
257     {
258         res = OCCreateResource(&g_ESCoapCloudConfResource.handle, OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF,
259         OC_RSRVD_INTERFACE_DEFAULT,
260         OC_RSRVD_ES_URI_COAPCLOUDCONF, OCEntityHandlerCb,
261         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
262     }
263
264     OIC_LOG_V(DEBUG, ES_RH_TAG, "Created CoapCloudConf resource with result: %s", getResult(res));
265     return res;
266
267 }
268
269 OCStackResult initDevConfResource(bool isSecured)
270 {
271     OCStackResult res = OC_STACK_ERROR;
272
273     OICStrcpy(g_ESDevConfResource.devName, sizeof(g_ESDevConfResource.devName), "");
274     OICStrcpy(g_ESDevConfResource.modelNumber, sizeof(g_ESDevConfResource.modelNumber), "");
275     OICStrcpy(g_ESDevConfResource.location, sizeof(g_ESDevConfResource.location), "");
276     OICStrcpy(g_ESDevConfResource.country, sizeof(g_ESDevConfResource.country), "");
277     OICStrcpy(g_ESDevConfResource.language, sizeof(g_ESDevConfResource.language), "");
278
279     if (isSecured)
280     {
281         res = OCCreateResource(&g_ESDevConfResource.handle, OC_RSRVD_ES_RES_TYPE_DEVCONF,
282         OC_RSRVD_INTERFACE_DEFAULT,
283         OC_RSRVD_ES_URI_DEVCONF, OCEntityHandlerCb,
284         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
285     }else
286     {
287         res = OCCreateResource(&g_ESDevConfResource.handle, OC_RSRVD_ES_RES_TYPE_DEVCONF,
288         OC_RSRVD_INTERFACE_DEFAULT,
289         OC_RSRVD_ES_URI_DEVCONF, OCEntityHandlerCb,
290         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
291     }
292
293     OIC_LOG_V(DEBUG, ES_RH_TAG, "Created DevConf resource with result: %s", getResult(res));
294     return res;
295
296 }
297
298 void updateEasySetupResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input)
299 {
300     OIC_LOG_V(DEBUG, ES_RH_TAG, "g_ESEasySetupResource.status %d", g_ESEasySetupResource.status);
301
302     int64_t *connect_req = NULL;
303     size_t dimensions[MAX_REP_ARRAY_DEPTH] = { 0 };
304     if (OCRepPayloadGetIntArray(input, OC_RSRVD_ES_CONNECT, &connect_req, dimensions))
305     {
306         ESConnectRequest* connectRequest = (ESConnectRequest*)OICMalloc(sizeof(ESConnectRequest));
307         if (!connectRequest)
308         {
309             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
310             return;
311         }
312
313         int cntRequest = 0;
314         for (int i = 0 ; i < NUM_CONNECT_TYPE ; ++i)
315         {
316             g_ESEasySetupResource.connectRequest[i] = ES_CONNECT_NONE;
317             connectRequest->connect[i] = ES_CONNECT_NONE;
318
319             if (i < dimensions[0] &&
320                 (connect_req[i] == ES_CONNECT_WIFI || connect_req[i] == ES_CONNECT_COAPCLOUD))
321             {
322                 g_ESEasySetupResource.connectRequest[cntRequest] = connect_req[i];
323                 connectRequest->connect[cntRequest] = connect_req[i];
324                 OIC_LOG_V(DEBUG, ES_RH_TAG, "g_ESEasySetupResource.connectType[%d] : %d",
325                                                     cntRequest, g_ESEasySetupResource.connectRequest[cntRequest]);
326                 cntRequest++;
327             }
328         }
329         connectRequest->numRequest = cntRequest;
330         g_ESEasySetupResource.numRequest = cntRequest;
331
332         if (g_ESEasySetupResource.connectRequest[0] != ES_CONNECT_NONE)
333         {
334             OIC_LOG(DEBUG, ES_RH_TAG, "Send ConnectRequest Callback To ES");
335
336             //@todo Need to check appropriateness of gWiFiData
337             if (gConnectRequestEvtCb != NULL)
338             {
339                 gConnectRequestEvtCb(ES_OK, connectRequest);
340             }
341             else
342             {
343                 OIC_LOG(ERROR, ES_RH_TAG, "gConnectRequestEvtCb is NULL");
344             }
345         }
346     }
347
348     if (ehRequest->query)
349     {
350         if (CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH))
351         {
352             // When Provisioning resource has a POST with BatchInterface
353             updateCoapCloudConfResource(input);
354             updateWiFiConfResource(input);
355             updateDevConfResource(input);
356         }
357     }
358 }
359
360 void updateWiFiConfResource(OCRepPayload* input)
361 {
362     ESWiFiConfData* wiFiData = (ESWiFiConfData*)OICMalloc(sizeof(ESWiFiConfData));
363
364     if (wiFiData == NULL)
365     {
366         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
367         return ;
368     }
369
370     memset(wiFiData->ssid, 0, OIC_STRING_MAX_VALUE);
371     memset(wiFiData->pwd, 0, OIC_STRING_MAX_VALUE);
372     wiFiData->authtype = NONE_AUTH;
373     wiFiData->enctype = NONE_AUTH;
374     wiFiData->userdata = NULL;
375
376     char* ssid = NULL;
377     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_SSID, &ssid))
378     {
379         OICStrcpy(g_ESWiFiConfResource.ssid, sizeof(g_ESWiFiConfResource.ssid), ssid);
380         OICStrcpy(wiFiData->ssid, sizeof(wiFiData->ssid), ssid);
381         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESWiFiConfResource.ssid : %s", g_ESWiFiConfResource.ssid);
382     }
383
384     char* cred = NULL;
385     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CRED, &cred))
386     {
387         OICStrcpy(g_ESWiFiConfResource.cred, sizeof(g_ESWiFiConfResource.cred), cred);
388         OICStrcpy(wiFiData->pwd, sizeof(wiFiData->pwd), cred);
389         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESWiFiConfResource.cred %s", g_ESWiFiConfResource.cred);
390     }
391
392     int64_t authType = -1;
393     if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_AUTHTYPE, &authType))
394     {
395         g_ESWiFiConfResource.authType = authType;
396         wiFiData->authtype = g_ESWiFiConfResource.authType;
397         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESWiFiConfResource.authType %u", g_ESWiFiConfResource.authType);
398     }
399
400     int64_t encType = -1;
401     if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_ENCTYPE, &encType))
402     {
403         g_ESWiFiConfResource.encType = encType;
404         wiFiData->enctype = g_ESWiFiConfResource.encType;
405         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESWiFiConfResource.encType %u", g_ESWiFiConfResource.encType);
406     }
407
408     if (gReadUserdataCb)
409     {
410         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_WIFICONF, &wiFiData->userdata);
411     }
412
413     if (ssid || cred || authType!= -1 || encType != -1)
414     {
415         OIC_LOG(DEBUG, ES_RH_TAG, "Send WiFiConfRsrc Callback To ES");
416
417         //@todo Need to check appropriateness of gWiFiData
418         if (gWifiConfRsrcEvtCb != NULL)
419         {
420             gWifiConfRsrcEvtCb(ES_OK, wiFiData);
421         }
422         else
423         {
424             OIC_LOG(ERROR, ES_RH_TAG, "gWifiConfRsrcEvtCb is NULL");
425         }
426     }
427
428     if (OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESWiFiConfResource.handle, OC_HIGH_QOS))
429     {
430         OIC_LOG(DEBUG, ES_RH_TAG, "Enrollee doesn't have any observer.");
431     }
432
433     OICFree(wiFiData);
434 }
435
436 void updateCoapCloudConfResource(OCRepPayload* input)
437 {
438     ESCoapCloudConfData* cloudData = (ESCoapCloudConfData*)OICMalloc(sizeof(ESCoapCloudConfData));
439
440     if (cloudData == NULL)
441     {
442         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
443         return;
444     }
445
446     memset(cloudData->authCode, 0, OIC_STRING_MAX_VALUE);
447     memset(cloudData->accessToken, 0, OIC_STRING_MAX_VALUE);
448     g_ESCoapCloudConfResource.accessTokenType = NONE_OAUTH_TOKENTYPE;
449     memset(cloudData->authProvider, 0, OIC_STRING_MAX_VALUE);
450     memset(cloudData->ciServer, 0, OIC_URI_STRING_MAX_VALUE);
451     cloudData->userdata = NULL;
452
453     char *authCode = NULL;
454     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_AUTHCODE, &authCode))
455     {
456         OICStrcpy(g_ESCoapCloudConfResource.authCode, sizeof(g_ESCoapCloudConfResource.authCode), authCode);
457         OICStrcpy(cloudData->authCode, sizeof(cloudData->authCode), authCode);
458         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESCoapCloudConfResource.authCode %s", g_ESCoapCloudConfResource.authCode);
459     }
460
461     char *accessToken = NULL;
462     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_ACCESSTOKEN, &accessToken))
463     {
464         OICStrcpy(g_ESCoapCloudConfResource.accessToken, sizeof(g_ESCoapCloudConfResource.accessToken), accessToken);
465         OICStrcpy(cloudData->accessToken, sizeof(cloudData->accessToken), accessToken);
466         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESCoapCloudConfResource.accessToken %s", g_ESCoapCloudConfResource.accessToken);
467     }
468
469     int64_t accessTokenType = -1;
470     if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_ACCESSTOKEN_TYPE, &accessTokenType))
471     {
472         g_ESCoapCloudConfResource.accessTokenType = accessTokenType;
473         cloudData->accessTokenType = g_ESCoapCloudConfResource.accessTokenType;
474         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESCoapCloudConfResource.accessTokenType %d", g_ESCoapCloudConfResource.accessTokenType);
475     }
476
477     char *authProvider = NULL;
478     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_AUTHPROVIDER, &authProvider))
479     {
480         OICStrcpy(g_ESCoapCloudConfResource.authProvider, sizeof(g_ESCoapCloudConfResource.authProvider), authProvider);
481         OICStrcpy(cloudData->authProvider, sizeof(cloudData->authProvider), authProvider);
482         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESCoapCloudConfResource.authServerUrl %s", g_ESCoapCloudConfResource.authProvider);
483     }
484
485     char *ciServer = NULL;
486     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CISERVER, &ciServer))
487     {
488         OICStrcpy(g_ESCoapCloudConfResource.ciServer, sizeof(g_ESCoapCloudConfResource.ciServer), ciServer);
489         OICStrcpy(cloudData->ciServer, sizeof(cloudData->ciServer), ciServer);
490         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESCoapCloudConfResource.ciServer %s", g_ESCoapCloudConfResource.ciServer);
491     }
492
493     if (gReadUserdataCb)
494     {
495         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF, &cloudData->userdata);
496     }
497
498     if (authCode || accessToken || authProvider || ciServer)
499     {
500         OIC_LOG(DEBUG, ES_RH_TAG, "Send CoapCloudConfRsrc Callback To ES");
501
502         //@todo Need to check appropriateness of gCloudData
503         if (gCoapCloudConfRsrcEvtCb != NULL)
504         {
505             gCoapCloudConfRsrcEvtCb(ES_OK, cloudData);
506         }
507         else
508         {
509             OIC_LOG(DEBUG, ES_RH_TAG, "gCoapCloudConfRsrcEvtCb is NULL");
510         }
511     }
512
513     if (OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESCoapCloudConfResource.handle, OC_HIGH_QOS))
514     {
515         OIC_LOG(DEBUG, ES_RH_TAG, "CoapCloudConf resource doesn't have any observer.");
516     }
517
518     OICFree(cloudData);
519 }
520
521 void updateDevConfResource(OCRepPayload* input)
522 {
523     ESDevConfData* devConfData = (ESDevConfData*)OICMalloc(sizeof(ESDevConfData));
524
525     if (devConfData == NULL)
526     {
527         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
528         return;
529     }
530     memset(devConfData->language, 0, OIC_STRING_MAX_VALUE);
531     memset(devConfData->country, 0, OIC_STRING_MAX_VALUE);
532     devConfData->userdata = NULL;
533
534     char *location = NULL;
535     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_LOCATION, &location))
536     {
537         OICStrcpy(g_ESDevConfResource.location, sizeof(g_ESDevConfResource.location), location);
538         OICStrcpy(devConfData->location, sizeof(devConfData->location), location);
539         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESDevConfResource.location %s", g_ESDevConfResource.location);
540     }
541
542     char *country = NULL;
543     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_COUNTRY, &country))
544     {
545         OICStrcpy(g_ESDevConfResource.country, sizeof(g_ESDevConfResource.country), country);
546         OICStrcpy(devConfData->country, sizeof(devConfData->country), country);
547         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESDevConfResource.country %s", g_ESDevConfResource.country);
548     }
549
550     char *language = NULL;
551     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_LANGUAGE, &language))
552     {
553         OICStrcpy(g_ESDevConfResource.language, sizeof(g_ESDevConfResource.language), language);
554         OICStrcpy(devConfData->language, sizeof(devConfData->language), language);
555         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESDevConfResource.language %s", g_ESDevConfResource.language);
556     }
557
558     if (gReadUserdataCb)
559     {
560         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_DEVCONF, &devConfData->userdata);
561     }
562
563     if (country || language)
564     {
565         OIC_LOG(DEBUG, ES_RH_TAG, "Send DevConfRsrc Callback To ES");
566
567         //@todo : Need to check appropriateness of gDevConfData
568         if (gDevConfRsrcEvtCb != NULL)
569         {
570             gDevConfRsrcEvtCb(ES_OK, devConfData);
571         }
572         else
573         {
574             OIC_LOG(DEBUG, ES_RH_TAG, "gDevConfRsrcEvtCb is NULL");
575         }
576     }
577
578     if (OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESDevConfResource.handle, OC_HIGH_QOS))
579     {
580         OIC_LOG(DEBUG, ES_RH_TAG, "devConfResource doesn't have any observer.");
581     }
582
583     OICFree(devConfData);
584 }
585
586 OCRepPayload* constructResponseOfWiFiConf(char *interface)
587 {
588     OCRepPayload* payload = OCRepPayloadCreate();
589     if (!payload)
590     {
591         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
592         return NULL;
593     }
594
595     if (g_ESWiFiConfResource.handle == NULL)
596     {
597         OIC_LOG(ERROR, ES_RH_TAG, "WiFiConf resource is not created");
598         return NULL;
599     }
600
601     OIC_LOG(DEBUG, ES_RH_TAG, "constructResponse WiFiConf res");
602     OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_WIFICONF);
603
604     OCRepPayload* repPayload = NULL;
605     OCRepPayload* tempPayload = NULL;
606     if (!strcmp(interface, OC_RSRVD_INTERFACE_BATCH))
607     {
608         repPayload = OCRepPayloadCreate();
609         if (!repPayload)
610         {
611             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
612             return NULL;
613         }
614
615         tempPayload = payload;
616         payload = repPayload;
617
618         size_t interfacesDimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
619         char **interfaces = (char **)OICMalloc(3 * sizeof(char*));
620         if (!interfaces)
621         {
622             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
623             return NULL;
624         }
625
626         interfaces[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
627
628         OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_INTERFACE, (char **)interfaces, interfacesDimensions);
629
630         size_t resourceTypesDimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
631         char **resourceTypes = (char **)OICMalloc(2 * sizeof(char*));
632         if (!resourceTypes)
633         {
634             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
635             return NULL;
636         }
637
638         resourceTypes[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_WIFICONF);
639
640         OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_RES_TYPE, (char **)resourceTypes, resourceTypesDimensions);
641     }
642     else
643     {
644         OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_DEFAULT);
645         OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_WIFICONF);
646     }
647
648     size_t dimensions[MAX_REP_ARRAY_DEPTH] = {g_ESWiFiConfResource.numMode, 0, 0};
649     int64_t *modes_64 = (int64_t *)OICMalloc(g_ESWiFiConfResource.numMode * sizeof(int64_t));
650     if (!modes_64)
651     {
652         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
653         return NULL;
654     }
655
656     for (int i = 0 ; i < g_ESWiFiConfResource.numMode ; ++i)
657     {
658         modes_64[i] = g_ESWiFiConfResource.supportedMode[i];
659     }
660     OCRepPayloadSetIntArray(payload, OC_RSRVD_ES_SUPPORTEDWIFIMODE, (int64_t *)modes_64, dimensions);
661
662     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_SUPPORTEDWIFIFREQ, g_ESWiFiConfResource.supportedFreq);
663     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_SSID, g_ESWiFiConfResource.ssid);
664     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CRED, g_ESWiFiConfResource.cred);
665     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_AUTHTYPE, (int) g_ESWiFiConfResource.authType);
666     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_ENCTYPE, (int) g_ESWiFiConfResource.encType);
667
668     if (gWriteUserdataCb)
669     {
670         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_WIFICONF);
671     }
672
673     if (!strcmp(interface, OC_RSRVD_INTERFACE_BATCH))
674     {
675         payload = tempPayload;
676         OCRepPayloadSetPropObject(payload, OC_RSRVD_REPRESENTATION, repPayload);
677     }
678
679     return payload;
680 }
681
682 OCRepPayload* constructResponseOfCoapCloudConf(char *interface)
683 {
684     OCRepPayload* payload = OCRepPayloadCreate();
685     if (!payload)
686     {
687         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
688         return NULL;
689     }
690
691     if (g_ESCoapCloudConfResource.handle == NULL)
692     {
693         OIC_LOG(ERROR, ES_RH_TAG, "CoapCloudConf resource is not created");
694         return NULL;
695     }
696
697     OIC_LOG(DEBUG, ES_RH_TAG, "constructResponse CoapCloudConf res");
698     OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_COAPCLOUDCONF);
699
700     OCRepPayload* repPayload = NULL;
701     OCRepPayload* tempPayload = NULL;
702     if (!strcmp(interface, OC_RSRVD_INTERFACE_BATCH))
703     {
704         repPayload = OCRepPayloadCreate();
705         if (!repPayload)
706         {
707             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
708             return NULL;
709         }
710
711         tempPayload = payload;
712         payload = repPayload;
713
714         size_t interfacesDimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
715         char **interfaces = (char **)OICMalloc(3 * sizeof(char*));
716         if (!interfaces)
717         {
718             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
719             return NULL;
720         }
721
722         interfaces[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
723
724         OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_INTERFACE, (char **)interfaces, interfacesDimensions);
725
726         size_t resourceTypesDimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
727         char **resourceTypes = (char **)OICMalloc(2 * sizeof(char*));
728         if (!resourceTypes)
729         {
730             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
731             return NULL;
732         }
733
734         resourceTypes[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF);
735
736         OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_RES_TYPE, (char **)resourceTypes, resourceTypesDimensions);
737     }
738     else
739     {
740         OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_DEFAULT);
741         OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF);
742     }
743
744     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_AUTHCODE, g_ESCoapCloudConfResource.authCode);
745     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_ACCESSTOKEN, g_ESCoapCloudConfResource.accessToken);
746     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_ACCESSTOKEN_TYPE, (int)g_ESCoapCloudConfResource.accessTokenType);
747     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_AUTHPROVIDER, g_ESCoapCloudConfResource.authProvider);
748     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CISERVER, g_ESCoapCloudConfResource.ciServer);
749
750     if (gWriteUserdataCb)
751     {
752         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF);
753     }
754
755     if (!strcmp(interface, OC_RSRVD_INTERFACE_BATCH))
756     {
757         payload = tempPayload;
758         OCRepPayloadSetPropObject(payload, OC_RSRVD_REPRESENTATION, repPayload);
759     }
760
761     return payload;
762 }
763
764 OCRepPayload* constructResponseOfDevConf(char *interface)
765 {
766     OCRepPayload* payload = OCRepPayloadCreate();
767     if (!payload)
768     {
769         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
770         return NULL;
771     }
772
773     if (g_ESDevConfResource.handle == NULL)
774     {
775         OIC_LOG(ERROR, ES_RH_TAG, "DevConf resource is not created");
776         return NULL;
777     }
778
779     OIC_LOG(DEBUG, ES_RH_TAG, "constructResponse DevConf res");
780     OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_DEVCONF);
781
782     OCRepPayload* repPayload = NULL;
783     OCRepPayload* tempPayload = NULL;
784     if (!strcmp(interface, OC_RSRVD_INTERFACE_BATCH))
785     {
786         repPayload = OCRepPayloadCreate();
787         if (!repPayload)
788         {
789             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
790             return NULL;
791         }
792
793         tempPayload = payload;
794         payload = repPayload;
795
796         size_t interfacesDimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
797         char **interfaces = (char **)OICMalloc(3 * sizeof(char*));
798         if (!interfaces)
799         {
800             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
801             return NULL;
802         }
803
804         interfaces[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
805
806         OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_INTERFACE, (char **)interfaces, interfacesDimensions);
807
808         size_t resourceTypesDimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
809         char **resourceTypes = (char **)OICMalloc(2 * sizeof(char*));
810         if (!resourceTypes)
811         {
812             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
813             return NULL;
814         }
815
816         resourceTypes[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_DEVCONF);
817
818         OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_RES_TYPE, (char **)resourceTypes, resourceTypesDimensions);
819     }
820     else
821     {
822         OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_DEFAULT);
823         OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_DEVCONF);
824     }
825
826     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_DEVNAME, g_ESDevConfResource.devName);
827     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_MODELNUMBER, g_ESDevConfResource.modelNumber);
828     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_LOCATION, g_ESDevConfResource.location);
829     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_LANGUAGE, g_ESDevConfResource.language);
830     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_COUNTRY, g_ESDevConfResource.country);
831
832     if (gWriteUserdataCb)
833     {
834         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_DEVCONF);
835     }
836
837     if (!strcmp(interface, OC_RSRVD_INTERFACE_BATCH))
838     {
839         payload = tempPayload;
840         OCRepPayloadSetPropObject(payload, OC_RSRVD_REPRESENTATION, repPayload);
841     }
842
843     return payload;
844 }
845
846 OCRepPayload* constructResponseOfEasySetup(OCEntityHandlerRequest *ehRequest)
847 {
848     OCRepPayload* payload = OCRepPayloadCreate();
849     if (!payload)
850     {
851         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
852         return NULL;
853     }
854
855     // Requested interface is Link list interface
856     if (!ehRequest->query ||
857         (ehRequest->query && !strcmp(ehRequest->query, "")) ||
858         (ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_LL)) ||
859         (ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT)))
860     {
861         const OCRepPayload *arrayPayload[3] = {NULL};
862
863         int childResCnt = 0;
864
865         if (g_ESWiFiConfResource.handle != NULL)
866         {
867             OCRepPayload *add = OCRepPayloadCreate();
868             if (!add)
869             {
870                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
871                 return NULL;
872             }
873
874             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
875             char **resourceType = NULL;
876             resourceType = (char **)OICMalloc(sizeof(char *) * 1);
877             char **resourceInterface = NULL;
878             resourceInterface = (char **)OICMalloc(sizeof(char *) * 1);
879
880             if (!resourceType || !resourceInterface)
881             {
882                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
883                 return NULL;
884             }
885
886             resourceType[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_WIFICONF);
887             resourceInterface[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
888
889             add->base.type = PAYLOAD_TYPE_REPRESENTATION;
890             OCRepPayloadSetPropString(add, OC_RSRVD_HREF, OC_RSRVD_ES_URI_WIFICONF);
891             OCRepPayloadSetStringArray(add, OC_RSRVD_RESOURCE_TYPE,
892                                             (const char **)resourceType, dimensions);
893             OCRepPayloadSetStringArray(add, OC_RSRVD_INTERFACE,
894                                             (const char **)resourceInterface, dimensions);
895
896             OCResourceProperty p = OCGetResourceProperties((OCResourceHandle *)g_ESWiFiConfResource.handle);
897             OCRepPayload *policy = OCRepPayloadCreate();
898             if (!policy)
899             {
900                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
901                 return NULL;
902             }
903
904             OCRepPayloadSetPropInt(policy, OC_RSRVD_BITMAP,
905                                     ((p & OC_DISCOVERABLE) | (p & OC_OBSERVABLE)));
906             if (p & OC_SECURE)
907             {
908                 OCRepPayloadSetPropBool(policy, OC_RSRVD_SECURE, p & OC_SECURE);
909                 uint16_t securePort = CAGetAssignedPortNumber(ehRequest->devAddr.adapter,
910                                                                     ehRequest->devAddr.flags);
911                 OCRepPayloadSetPropInt(policy, OC_RSRVD_HOSTING_PORT, securePort);
912             }
913
914             OCRepPayloadSetPropObject(add, OC_RSRVD_POLICY, policy);
915
916             arrayPayload[childResCnt++] = add;
917         }
918
919         if (g_ESDevConfResource.handle != NULL)
920         {
921             OCRepPayload *add = OCRepPayloadCreate();
922             if (!add)
923             {
924                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
925                 return NULL;
926             }
927
928             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
929             char **resourceType = NULL;
930             resourceType = (char **)OICMalloc(sizeof(char *) * 1);
931             char **resourceInterface = NULL;
932             resourceInterface = (char **)OICMalloc(sizeof(char *) * 1);
933
934             if (!resourceType || !resourceInterface)
935             {
936                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
937                 return NULL;
938             }
939
940             resourceType[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_DEVCONF);
941             resourceInterface[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
942
943             add->base.type = PAYLOAD_TYPE_REPRESENTATION;
944             OCRepPayloadSetPropString(add, OC_RSRVD_HREF, OC_RSRVD_ES_URI_DEVCONF);
945             OCRepPayloadSetStringArray(add, OC_RSRVD_RESOURCE_TYPE,
946                                             (const char **)resourceType, dimensions);
947             OCRepPayloadSetStringArray(add, OC_RSRVD_INTERFACE,
948                                             (const char **)resourceInterface, dimensions);
949
950             OCResourceProperty p = OCGetResourceProperties((OCResourceHandle *)g_ESDevConfResource.handle);
951             OCRepPayload *policy = OCRepPayloadCreate();
952             if (!policy)
953             {
954                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
955                 return NULL;
956             }
957
958             OCRepPayloadSetPropInt(policy, OC_RSRVD_BITMAP,
959                                     ((p & OC_DISCOVERABLE) | (p & OC_OBSERVABLE)));
960             if (p & OC_SECURE)
961             {
962                 OCRepPayloadSetPropBool(policy, OC_RSRVD_SECURE, p & OC_SECURE);
963                 uint16_t securePort = CAGetAssignedPortNumber(ehRequest->devAddr.adapter,
964                                                                     ehRequest->devAddr.flags);
965                 OCRepPayloadSetPropInt(policy, OC_RSRVD_HOSTING_PORT, securePort);
966             }
967
968             OCRepPayloadSetPropObject(add, OC_RSRVD_POLICY, policy);
969
970             arrayPayload[childResCnt++] = add;
971         }
972
973         if (g_ESCoapCloudConfResource.handle != NULL)
974         {
975             OCRepPayload *add = OCRepPayloadCreate();
976             if (!add)
977             {
978                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
979                 return NULL;
980             }
981
982             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
983             char **resourceType = NULL;
984             resourceType = (char **)OICMalloc(sizeof(char *) * 1);
985             char **resourceInterface = NULL;
986             resourceInterface = (char **)OICMalloc(sizeof(char *) * 1);
987
988             if (!resourceType || !resourceInterface)
989             {
990                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
991                 return NULL;
992             }
993
994             resourceType[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF);
995             resourceInterface[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
996
997             add->base.type = PAYLOAD_TYPE_REPRESENTATION;
998             OCRepPayloadSetPropString(add, OC_RSRVD_HREF, OC_RSRVD_ES_URI_COAPCLOUDCONF);
999             OCRepPayloadSetStringArray(add, OC_RSRVD_RESOURCE_TYPE,
1000                                             (const char **)resourceType, dimensions);
1001             OCRepPayloadSetStringArray(add, OC_RSRVD_INTERFACE,
1002                                             (const char **)resourceInterface, dimensions);
1003
1004             OCResourceProperty p = OCGetResourceProperties((OCResourceHandle *)g_ESCoapCloudConfResource.handle);
1005             OCRepPayload *policy = OCRepPayloadCreate();
1006             if (!policy)
1007             {
1008                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
1009                 return NULL;
1010             }
1011
1012             OCRepPayloadSetPropInt(policy, OC_RSRVD_BITMAP,
1013                                     ((p & OC_DISCOVERABLE) | (p & OC_OBSERVABLE)));
1014             if (p & OC_SECURE)
1015             {
1016                 OCRepPayloadSetPropBool(policy, OC_RSRVD_SECURE, p & OC_SECURE);
1017                 uint16_t securePort = CAGetAssignedPortNumber(ehRequest->devAddr.adapter,
1018                                                                     ehRequest->devAddr.flags);
1019                 OCRepPayloadSetPropInt(policy, OC_RSRVD_HOSTING_PORT, securePort);
1020             }
1021
1022             OCRepPayloadSetPropObject(add, OC_RSRVD_POLICY, policy);
1023
1024             arrayPayload[childResCnt++] = add;
1025         }
1026
1027         size_t dimensions[MAX_REP_ARRAY_DEPTH] = {childResCnt, 0, 0};
1028
1029         if (!ehRequest->query ||
1030             (ehRequest->query && !strcmp(ehRequest->query, "")) ||
1031             (ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT)))
1032         {
1033             OIC_LOG(DEBUG, ES_RH_TAG, "constructResponse EasySetup res");
1034             OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_EASYSETUP);
1035             OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_DEFAULT);
1036             OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_LL);
1037             OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_BATCH);
1038             OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_EASYSETUP);
1039             OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_COL);
1040
1041             OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_PROVSTATUS, g_ESEasySetupResource.status);
1042             OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_LAST_ERRORCODE, g_ESEasySetupResource.lastErrCode);
1043
1044             if (g_ESEasySetupResource.numRequest > 0)
1045             {
1046                 size_t dimensions[MAX_REP_ARRAY_DEPTH] = {g_ESEasySetupResource.numRequest, 0, 0};
1047                 int64_t *connectRequest = (int64_t *)OICMalloc(g_ESEasySetupResource.numRequest  * sizeof(int64_t));
1048                 if (!connectRequest)
1049                 {
1050                     OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
1051                     return NULL;
1052                 }
1053
1054                 for(int i = 0 ; i < g_ESEasySetupResource.numRequest  ; ++i)
1055                 {
1056                     connectRequest[i] = g_ESEasySetupResource.connectRequest[i];
1057                 }
1058                 OCRepPayloadSetIntArray(payload, OC_RSRVD_ES_CONNECT, (int64_t *)connectRequest, dimensions);
1059             }
1060             else
1061             {
1062                 OIC_LOG(DEBUG, ES_RH_TAG, "g_ESEasySetupResource.numRequest is 0");
1063                 size_t dimensions[MAX_REP_ARRAY_DEPTH] = {0, 0, 0};
1064                 OCRepPayloadSetIntArray(payload, OC_RSRVD_ES_CONNECT, NULL, dimensions);
1065             }
1066
1067             if (gWriteUserdataCb)
1068             {
1069                 gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_EASYSETUP);
1070             }
1071
1072             OCRepPayloadSetPropObjectArray(payload, OC_RSRVD_ES_LINKS, arrayPayload, dimensions);
1073         }
1074         else    // link list interface
1075         {
1076             OCRepPayloadSetPropObjectArray(payload, OC_RSRVD_ES_LINKS, arrayPayload, dimensions);
1077         }
1078     } else if (
1079         ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH))
1080
1081     {
1082         OIC_LOG(DEBUG, ES_RH_TAG, "constructResponse EasySetup res");
1083         OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_EASYSETUP);
1084
1085         OCRepPayload* repPayload = NULL;
1086
1087         repPayload = OCRepPayloadCreate();
1088         if (!repPayload)
1089         {
1090             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
1091             return NULL;
1092         }
1093
1094         size_t interfacesDimensions[MAX_REP_ARRAY_DEPTH] = {3, 0, 0};
1095         char **interfaces = (char **)OICMalloc(3 * sizeof(char*));
1096         if (!interfaces)
1097         {
1098             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
1099             return NULL;
1100         }
1101
1102         interfaces[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
1103         interfaces[1] = OICStrdup(OC_RSRVD_INTERFACE_LL);
1104         interfaces[2] = OICStrdup(OC_RSRVD_INTERFACE_BATCH);
1105
1106         OCRepPayloadSetStringArray(repPayload, OC_RSRVD_ES_INTERFACE, (char **)interfaces, interfacesDimensions);
1107
1108         size_t resourceTypesDimensions[MAX_REP_ARRAY_DEPTH] = {2, 0, 0};
1109         char **resourceTypes = (char **)OICMalloc(2 * sizeof(char*));
1110         if (!resourceTypes)
1111         {
1112             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
1113             return NULL;
1114         }
1115
1116         resourceTypes[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_EASYSETUP);
1117         resourceTypes[1] = OICStrdup(OC_RSRVD_ES_RES_TYPE_COL);
1118
1119         OCRepPayloadSetStringArray(repPayload, OC_RSRVD_ES_RES_TYPE, (char **)resourceTypes, resourceTypesDimensions);
1120
1121         OCRepPayloadSetPropInt(repPayload, OC_RSRVD_ES_PROVSTATUS, g_ESEasySetupResource.status);
1122         OCRepPayloadSetPropInt(repPayload, OC_RSRVD_ES_LAST_ERRORCODE, g_ESEasySetupResource.lastErrCode);
1123         if (g_ESEasySetupResource.numRequest > 0)
1124         {
1125             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {g_ESEasySetupResource.numRequest, 0, 0};
1126             int64_t *connectRequest = (int64_t *)OICMalloc(g_ESEasySetupResource.numRequest  * sizeof(int64_t));
1127             if (!connectRequest)
1128             {
1129                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
1130                 return NULL;
1131             }
1132
1133             for (int i = 0 ; i < g_ESEasySetupResource.numRequest  ; ++i)
1134             {
1135                 connectRequest[i] = g_ESEasySetupResource.connectRequest[i];
1136             }
1137             OCRepPayloadSetIntArray(payload, OC_RSRVD_ES_CONNECT, (int64_t *)connectRequest, dimensions);
1138         }
1139         else
1140         {
1141             OIC_LOG(DEBUG, ES_RH_TAG, "g_ESEasySetupResource.numRequest is 0");
1142             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {0, 0, 0};
1143             OCRepPayloadSetIntArray(payload, OC_RSRVD_ES_CONNECT, NULL, dimensions);
1144         }
1145
1146         if (gWriteUserdataCb)
1147         {
1148             gWriteUserdataCb(repPayload, OC_RSRVD_ES_RES_TYPE_EASYSETUP);
1149         }
1150
1151         OCRepPayloadSetPropObject(payload, OC_RSRVD_REPRESENTATION, repPayload);
1152     }
1153
1154     if (ehRequest->query)
1155     {
1156         if (CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH))
1157         {// When Provisioning resource has a GET with BatchInterface
1158             OCRepPayload* head = payload;
1159             OCRepPayload* nextPayload = NULL;
1160
1161             nextPayload = constructResponseOfWiFiConf(OC_RSRVD_INTERFACE_BATCH);
1162             if (nextPayload != NULL)
1163             {
1164                 payload->next = nextPayload;
1165                 payload = payload->next;
1166             }
1167
1168             nextPayload = constructResponseOfCoapCloudConf(OC_RSRVD_INTERFACE_BATCH);
1169             if (nextPayload != NULL)
1170             {
1171                 payload->next = nextPayload;
1172                 payload = payload->next;
1173             }
1174
1175             nextPayload = constructResponseOfDevConf(OC_RSRVD_INTERFACE_BATCH);
1176             if (nextPayload != NULL)
1177             {
1178                 payload->next = nextPayload;
1179             }
1180
1181             payload = head;
1182         }
1183     }
1184
1185     return payload;
1186 }
1187
1188
1189 OCStackResult CreateEasySetupResources(bool isSecured, ESResourceMask resourceMask)
1190 {
1191     OCStackResult res = OC_STACK_ERROR;
1192     bool maskFlag = false;
1193
1194     res = initEasySetupResource(isSecured);
1195     if (res != OC_STACK_OK)
1196     {
1197         // TODO: destroy logic will be added
1198         OIC_LOG_V(ERROR, ES_RH_TAG, "initEasySetupResource result: %s", getResult(res));
1199
1200         return res;
1201     }
1202
1203     if ((resourceMask & ES_WIFICONF_RESOURCE) == ES_WIFICONF_RESOURCE)
1204     {
1205         maskFlag = true;
1206         res = initWiFiConfResource(isSecured);
1207         if (res != OC_STACK_OK)
1208         {
1209             OIC_LOG_V(ERROR, ES_RH_TAG, "initWiFiConfResource result: %s", getResult(res));
1210             return res;
1211         }
1212
1213         res = OCBindResource(g_ESEasySetupResource.handle, g_ESWiFiConfResource.handle);
1214         if (res != OC_STACK_OK)
1215         {
1216             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind WiFiConfResource result: %s", getResult(res));
1217             return res;
1218         }
1219
1220     }
1221
1222     if ((resourceMask & ES_COAPCLOUDCONF_RESOURCE) == ES_COAPCLOUDCONF_RESOURCE)
1223     {
1224         maskFlag = true;
1225         res = initCoapCloudConfResource(isSecured);
1226         if (res != OC_STACK_OK)
1227         {
1228             OIC_LOG_V(ERROR, ES_RH_TAG, "initCoapCloudConfResource result: %s", getResult(res));
1229             return res;
1230         }
1231
1232         res = OCBindResource(g_ESEasySetupResource.handle, g_ESCoapCloudConfResource.handle);
1233         if (res != OC_STACK_OK)
1234         {
1235             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind CoapCloudConfResource result: %s", getResult(res));
1236             return res;
1237         }
1238     }
1239
1240     if ((resourceMask & ES_DEVCONF_RESOURCE) == ES_DEVCONF_RESOURCE)
1241     {
1242         maskFlag = true;
1243         res = initDevConfResource(isSecured);
1244         if (res != OC_STACK_OK)
1245         {
1246             OIC_LOG_V(ERROR, ES_RH_TAG, "initDevConf result: %s", getResult(res));
1247             return res;
1248         }
1249
1250         res = OCBindResource(g_ESEasySetupResource.handle, g_ESDevConfResource.handle);
1251         if (res != OC_STACK_OK)
1252         {
1253             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind DevConfResource result: %s", getResult(res));
1254             return res;
1255         }
1256     }
1257
1258     if (maskFlag == false)
1259     {
1260         OIC_LOG_V(ERROR, ES_RH_TAG, "Invalid ResourceMask");
1261         return OC_STACK_ERROR;
1262
1263     }
1264
1265     OIC_LOG_V(DEBUG, ES_RH_TAG, "Created all resources with result: %s", getResult(res));
1266
1267     return res;
1268 }
1269
1270 OCStackResult DeleteEasySetupResources()
1271 {
1272     OCStackResult res = OC_STACK_ERROR;
1273     if (g_ESWiFiConfResource.handle != NULL)
1274     {
1275         res = OCUnBindResource(g_ESEasySetupResource.handle, g_ESWiFiConfResource.handle);
1276         if (res != OC_STACK_OK)
1277         {
1278             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind WiFi resource error with result: %s", getResult(res));
1279         }
1280     }
1281     if (g_ESCoapCloudConfResource.handle != NULL)
1282     {
1283         res = OCUnBindResource(g_ESEasySetupResource.handle, g_ESCoapCloudConfResource.handle);
1284         if (res != OC_STACK_OK)
1285         {
1286             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind CloudServer resource error with result: %s", getResult(res));
1287         }
1288     }
1289     if (g_ESDevConfResource.handle != NULL)
1290     {
1291         res = OCUnBindResource(g_ESEasySetupResource.handle, g_ESDevConfResource.handle);
1292         if (res != OC_STACK_OK)
1293         {
1294             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind DevConf resource error with result: %s", getResult(res));
1295         }
1296     }
1297
1298     if (g_ESWiFiConfResource.handle != NULL)
1299     {
1300         res = OCDeleteResource(g_ESWiFiConfResource.handle);
1301         if (res != OC_STACK_OK)
1302         {
1303             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting WiFi resource error with result: %s", getResult(res));
1304         }
1305     }
1306
1307     if (g_ESCoapCloudConfResource.handle != NULL)
1308     {
1309         res = OCDeleteResource(g_ESCoapCloudConfResource.handle);
1310         if (res != OC_STACK_OK)
1311         {
1312             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting CloudServer resource error with result: %s", getResult(res));
1313         }
1314     }
1315
1316     if (g_ESDevConfResource.handle != NULL)
1317     {
1318         res = OCDeleteResource(g_ESDevConfResource.handle);
1319         if (res != OC_STACK_OK)
1320         {
1321             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting DevConf resource error with result: %s", getResult(res));
1322         }
1323     }
1324
1325     if (g_ESEasySetupResource.handle != NULL)
1326     {
1327         res = OCDeleteResource(g_ESEasySetupResource.handle);
1328         if (res != OC_STACK_OK)
1329         {
1330             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting Prov resource error with result: %s", getResult(res));
1331         }
1332     }
1333
1334     return res;
1335 }
1336
1337 OCEntityHandlerResult ProcessGetRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload **payload)
1338 {
1339     OCEntityHandlerResult ehResult = OC_EH_ERROR;
1340     if (!ehRequest)
1341     {
1342         OIC_LOG(ERROR, ES_RH_TAG, "Request is Null");
1343         return ehResult;
1344     }
1345     if (ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
1346     {
1347         OIC_LOG(ERROR, ES_RH_TAG, "Incoming payload not a representation");
1348         return ehResult;
1349     }
1350
1351     OCRepPayload *getResp = NULL;
1352     *payload = NULL;
1353
1354     if (ehRequest->resource == g_ESEasySetupResource.handle)
1355     {
1356         if (ehRequest->query &&
1357             strcmp(ehRequest->query, "") &&
1358             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_LL) &&
1359             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH) &&
1360             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
1361         {
1362             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1363             return OC_EH_BAD_REQ;
1364         }
1365         else
1366         {
1367             getResp = constructResponseOfEasySetup(ehRequest);
1368         }
1369     }
1370     else if (ehRequest->resource == g_ESWiFiConfResource.handle)
1371     {
1372         if (CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1373         {
1374             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1375             return OC_EH_BAD_REQ;
1376         }
1377         else
1378         {
1379             getResp = constructResponseOfWiFiConf(OC_RSRVD_INTERFACE_DEFAULT);
1380         }
1381     }
1382     else if (ehRequest->resource == g_ESCoapCloudConfResource.handle)
1383     {
1384         if (CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1385         {
1386             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1387             return OC_EH_BAD_REQ;
1388         }
1389         else
1390         {
1391             getResp = constructResponseOfCoapCloudConf(OC_RSRVD_INTERFACE_DEFAULT);
1392         }
1393     }
1394     else if (ehRequest->resource == g_ESDevConfResource.handle)
1395     {
1396         if (CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1397         {
1398             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1399             return OC_EH_BAD_REQ;
1400         }
1401         else
1402         {
1403             getResp = constructResponseOfDevConf(OC_RSRVD_INTERFACE_DEFAULT);
1404         }
1405     }
1406
1407     if (!getResp)
1408     {
1409         OIC_LOG(ERROR, ES_RH_TAG, "constructResponse failed");
1410         return OC_EH_ERROR;
1411     }
1412
1413     *payload = getResp;
1414     ehResult = OC_EH_OK;
1415
1416     return ehResult;
1417 }
1418
1419 OCEntityHandlerResult ProcessPostRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload)
1420 {
1421     OIC_LOG(DEBUG, ES_RH_TAG, "ProcessPostRequest enter");
1422     OCEntityHandlerResult ehResult = OC_EH_ERROR;
1423     if (ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
1424     {
1425         OIC_LOG(ERROR, ES_RH_TAG, "Incoming payload not a representation");
1426         return ehResult;
1427     }
1428
1429     OCRepPayload* input = (OCRepPayload*) (ehRequest->payload);
1430     if (!input)
1431     {
1432         OIC_LOG(ERROR, ES_RH_TAG, "Failed to parse");
1433         return ehResult;
1434     }
1435
1436     if (ehRequest->resource == g_ESEasySetupResource.handle)
1437     {
1438         if (ehRequest->query &&
1439             strcmp(ehRequest->query, "") &&
1440             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH) &&
1441             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
1442         {
1443             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1444             return OC_EH_BAD_REQ;
1445         }
1446         else
1447         {
1448             updateEasySetupResource(ehRequest, input);
1449         }
1450     }
1451     else if (ehRequest->resource == g_ESWiFiConfResource.handle)
1452     {
1453         if (CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1454         {
1455             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1456             return OC_EH_BAD_REQ;
1457         }
1458         else
1459         {
1460             updateWiFiConfResource(input);
1461         }
1462     }
1463     else if (ehRequest->resource == g_ESCoapCloudConfResource.handle)
1464     {
1465         if (CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1466         {
1467             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1468             return OC_EH_BAD_REQ;
1469         }
1470         else
1471         {
1472             updateCoapCloudConfResource(input);
1473         }
1474     }
1475     else if (ehRequest->resource == g_ESDevConfResource.handle)
1476     {
1477         if (CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1478         {
1479             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1480             return OC_EH_BAD_REQ;
1481         }
1482         else
1483         {
1484             updateDevConfResource(input);
1485         }
1486     }
1487
1488     OCRepPayload *getResp = NULL;
1489     if (ehRequest->resource == g_ESEasySetupResource.handle)
1490     {
1491         getResp = constructResponseOfEasySetup(ehRequest);
1492     }
1493     else if (ehRequest->resource == g_ESWiFiConfResource.handle)
1494     {
1495         getResp = constructResponseOfWiFiConf(OC_RSRVD_INTERFACE_DEFAULT);
1496     }
1497     else if (ehRequest->resource == g_ESCoapCloudConfResource.handle)
1498     {
1499         getResp = constructResponseOfCoapCloudConf(OC_RSRVD_INTERFACE_DEFAULT);
1500     }
1501     else if (ehRequest->resource == g_ESDevConfResource.handle)
1502     {
1503         getResp = constructResponseOfDevConf(OC_RSRVD_INTERFACE_DEFAULT);
1504     }
1505
1506     if (!getResp)
1507     {
1508         OIC_LOG(ERROR, ES_RH_TAG, "constructResponse failed");
1509         return OC_EH_ERROR;
1510     }
1511
1512     *payload = getResp;
1513     ehResult = OC_EH_OK;
1514
1515     return ehResult;
1516 }
1517
1518 OCEntityHandlerResult ProcessPutRequest(OCEntityHandlerRequest * ehRequest,
1519         OCRepPayload** payload)
1520 {
1521     (void) ehRequest;
1522     (void) payload;
1523     OCEntityHandlerResult ehResult = OC_EH_BAD_REQ;
1524
1525     return ehResult;
1526 }
1527 /**
1528  * This is the entity handler for the registered resource.
1529  * This is invoked by OCStack whenever it recevies a request for this resource.
1530  */
1531 OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag,
1532         OCEntityHandlerRequest* entityHandlerRequest, void *callback)
1533 {
1534     (void) callback;
1535     OCEntityHandlerResult ehRet = OC_EH_OK;
1536     OCEntityHandlerResponse response =
1537     { 0, 0, OC_EH_ERROR, 0, 0,
1538     { },
1539     { 0 }, false };
1540     OCRepPayload* payload = NULL;
1541
1542     if (entityHandlerRequest && (flag & OC_REQUEST_FLAG))
1543     {
1544         if (OC_REST_GET == entityHandlerRequest->method)
1545         {
1546             OIC_LOG(DEBUG, ES_RH_TAG, "Received GET request");
1547             ehRet = ProcessGetRequest(entityHandlerRequest, &payload);
1548         }
1549         else if (OC_REST_PUT == entityHandlerRequest->method)
1550         {
1551             OIC_LOG(DEBUG, ES_RH_TAG, "Received PUT request");
1552
1553             //PUT request will be handled in the internal implementation
1554             if (g_ESEasySetupResource.handle != NULL)
1555             {
1556                 ehRet = ProcessPutRequest(entityHandlerRequest, &payload);
1557             }
1558             else
1559             {
1560                 OIC_LOG(ERROR, ES_RH_TAG, "Cannot process put");
1561                 ehRet = OC_EH_ERROR;
1562             }
1563         }
1564         else if (OC_REST_POST == entityHandlerRequest->method)
1565         {
1566             OIC_LOG(DEBUG, ES_RH_TAG, "Received OC_REST_POST from client");
1567             if (g_ESEasySetupResource.handle != NULL)
1568             {
1569                 ehRet = ProcessPostRequest(entityHandlerRequest, &payload);
1570             }
1571             else
1572             {
1573                 OIC_LOG(ERROR, ES_RH_TAG, "Cannot process put");
1574                 ehRet = OC_EH_ERROR;
1575             }
1576         }
1577
1578         // Format the response.  Note this requires some info about the request
1579         response.requestHandle = entityHandlerRequest->requestHandle;
1580         response.resourceHandle = entityHandlerRequest->resource;
1581         response.ehResult = ehRet;
1582         //response uses OCPaylod while all get,put methodes use OCRepPayload
1583         response.payload = (OCPayload*) (payload);
1584         response.numSendVendorSpecificHeaderOptions = 0;
1585         memset(response.sendVendorSpecificHeaderOptions, 0,
1586                 sizeof(response.sendVendorSpecificHeaderOptions));
1587         memset(response.resourceUri, 0, sizeof(response.resourceUri));
1588         // Indicate that response is NOT in a persistent buffer
1589         response.persistentBufferFlag = 0;
1590
1591         // Send the response
1592         if (OCDoResponse(&response) != OC_STACK_OK)
1593         {
1594             OIC_LOG(ERROR, ES_RH_TAG, "Error sending response");
1595             ehRet = OC_EH_ERROR;
1596         }
1597     }
1598     if (entityHandlerRequest && (flag & OC_OBSERVE_FLAG))
1599     {
1600         OIC_LOG(DEBUG, ES_RH_TAG, "Flag includes OC_OBSERVE_FLAG");
1601
1602         if (OC_OBSERVE_REGISTER == entityHandlerRequest->obsInfo.action)
1603         {
1604             OIC_LOG(DEBUG, ES_RH_TAG, "Received OC_OBSERVE_REGISTER from Mediator");
1605         }
1606         else if (OC_OBSERVE_DEREGISTER == entityHandlerRequest->obsInfo.action)
1607         {
1608             OIC_LOG(DEBUG, ES_RH_TAG, "Received OC_OBSERVE_DEREGISTER from Mediator");
1609         }
1610     }
1611     return ehRet;
1612 }
1613
1614 OCStackResult SetDeviceProperty(ESDeviceProperty *deviceProperty)
1615 {
1616     OIC_LOG(DEBUG, ES_RH_TAG, "SetDeviceProperty IN");
1617
1618     g_ESWiFiConfResource.supportedFreq = (deviceProperty->WiFi).freq;
1619     OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "WiFi Freq : %d", g_ESWiFiConfResource.supportedFreq);
1620
1621     int modeIdx = 0;
1622     while ((deviceProperty->WiFi).mode[modeIdx] != WiFi_EOF)
1623     {
1624         g_ESWiFiConfResource.supportedMode[modeIdx] = (deviceProperty->WiFi).mode[modeIdx];
1625         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "WiFi Mode : %d", g_ESWiFiConfResource.supportedMode[modeIdx]);
1626         modeIdx ++;
1627     }
1628     g_ESWiFiConfResource.numMode = modeIdx;
1629
1630     OICStrcpy(g_ESDevConfResource.devName, OIC_STRING_MAX_VALUE, (deviceProperty->DevConf).deviceName);
1631     OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "Device Name : %s", g_ESDevConfResource.devName);
1632
1633     OICStrcpy(g_ESDevConfResource.modelNumber, OIC_STRING_MAX_VALUE,
1634                                                             (deviceProperty->DevConf).modelNumber);
1635     OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "Model Number : %s", g_ESDevConfResource.modelNumber);
1636
1637     if (OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESWiFiConfResource.handle, OC_HIGH_QOS))
1638     {
1639         OIC_LOG(DEBUG, ES_RH_TAG, "wifiResource doesn't have any observers.");
1640     }
1641
1642     if (OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESDevConfResource.handle, OC_HIGH_QOS))
1643     {
1644         OIC_LOG(DEBUG, ES_RH_TAG, "devConfResource doesn't have any observers.");
1645     }
1646
1647     OIC_LOG(DEBUG, ES_RH_TAG, "SetDeviceProperty OUT");
1648     return OC_STACK_OK;
1649 }
1650
1651 OCStackResult SetEnrolleeState(ESEnrolleeState esState)
1652 {
1653     OIC_LOG(DEBUG, ES_RH_TAG, "SetEnrolleeState IN");
1654
1655     g_ESEasySetupResource.status = esState;
1656     OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "Enrollee Status : %d", g_ESEasySetupResource.status);
1657
1658     if (OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESEasySetupResource.handle, OC_HIGH_QOS))
1659     {
1660         OIC_LOG(DEBUG, ES_RH_TAG, "provResource doesn't have any observers.");
1661     }
1662
1663     OIC_LOG(DEBUG, ES_RH_TAG, "SetEnrolleeState OUT");
1664     return OC_STACK_OK;
1665 }
1666
1667 OCStackResult SetEnrolleeErrCode(ESErrorCode esErrCode)
1668 {
1669     OIC_LOG(DEBUG, ES_RH_TAG, "SetEnrolleeErrCode IN");
1670
1671     g_ESEasySetupResource.lastErrCode = esErrCode;
1672     OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "Enrollee ErrorCode : %d", g_ESEasySetupResource.lastErrCode);
1673
1674     if (OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESEasySetupResource.handle, OC_HIGH_QOS))
1675     {
1676         OIC_LOG(DEBUG, ES_RH_TAG, "provResource doesn't have any observers.");
1677     }
1678
1679     OIC_LOG(DEBUG, ES_RH_TAG, "SetEnrolleeErrCode OUT");
1680     return OC_STACK_OK;
1681 }
1682
1683 OCEntityHandlerResult CheckEhRequestPayload(OCEntityHandlerRequest *ehRequest)
1684 {
1685     if (!(ehRequest->query) ||
1686                 (ehRequest->query &&
1687                 (strcmp(ehRequest->query, "") && !CompareResourceInterface(ehRequest->query,
1688                                                                         OC_RSRVD_INTERFACE_DEFAULT))))
1689     {
1690         OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1691         return OC_EH_BAD_REQ;
1692     }
1693     return OC_EH_OK;
1694 }
1695
1696 const char *getResult(OCStackResult result)
1697 {
1698     switch (result)
1699     {
1700         case OC_STACK_OK:
1701             return "OC_STACK_OK";
1702         case OC_STACK_INVALID_URI:
1703             return "OC_STACK_INVALID_URI";
1704         case OC_STACK_INVALID_QUERY:
1705             return "OC_STACK_INVALID_QUERY";
1706         case OC_STACK_INVALID_IP:
1707             return "OC_STACK_INVALID_IP";
1708         case OC_STACK_INVALID_PORT:
1709             return "OC_STACK_INVALID_PORT";
1710         case OC_STACK_INVALID_CALLBACK:
1711             return "OC_STACK_INVALID_CALLBACK";
1712         case OC_STACK_INVALID_METHOD:
1713             return "OC_STACK_INVALID_METHOD";
1714         case OC_STACK_NO_MEMORY:
1715             return "OC_STACK_NO_MEMORY";
1716         case OC_STACK_COMM_ERROR:
1717             return "OC_STACK_COMM_ERROR";
1718         case OC_STACK_INVALID_PARAM:
1719             return "OC_STACK_INVALID_PARAM";
1720         case OC_STACK_NOTIMPL:
1721             return "OC_STACK_NOTIMPL";
1722         case OC_STACK_NO_RESOURCE:
1723             return "OC_STACK_NO_RESOURCE";
1724         case OC_STACK_RESOURCE_ERROR:
1725             return "OC_STACK_RESOURCE_ERROR";
1726         case OC_STACK_SLOW_RESOURCE:
1727             return "OC_STACK_SLOW_RESOURCE";
1728         case OC_STACK_NO_OBSERVERS:
1729             return "OC_STACK_NO_OBSERVERS";
1730         case OC_STACK_ERROR:
1731             return "OC_STACK_ERROR";
1732         default:
1733             return "UNKNOWN";
1734     }
1735 }