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