Merge branch '1.3-rel' (be76a752)
[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");
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                 OCRepPayloadSetIntArray(payload, OC_RSRVD_ES_CONNECT, (int64_t *)connectRequest, dimensions);
1027             }
1028             else
1029             {
1030                 OIC_LOG(DEBUG, ES_RH_TAG, "g_ESEasySetupResource.numRequest is 0");
1031                 size_t dimensions[MAX_REP_ARRAY_DEPTH] = {0, 0, 0};
1032                 OCRepPayloadSetIntArray(payload, OC_RSRVD_ES_CONNECT, NULL, dimensions);
1033             }
1034
1035             if (gWriteUserdataCb)
1036             {
1037                 gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_EASYSETUP);
1038             }
1039
1040             OCRepPayloadSetPropObjectArray(payload, OC_RSRVD_ES_LINKS, arrayPayload, dimensions);
1041         }
1042         else    // link list interface
1043         {
1044             OCRepPayloadSetPropObjectArray(payload, OC_RSRVD_ES_LINKS, arrayPayload, dimensions);
1045         }
1046     } else if (
1047         ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH))
1048
1049     {
1050         OIC_LOG(DEBUG, ES_RH_TAG, "constructResponse EasySetup res");
1051         OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_EASYSETUP);
1052
1053         OCRepPayload* repPayload = NULL;
1054
1055         repPayload = OCRepPayloadCreate();
1056         if (!repPayload)
1057         {
1058             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
1059             return NULL;
1060         }
1061
1062         size_t interfacesDimensions[MAX_REP_ARRAY_DEPTH] = {3, 0, 0};
1063         char **interfaces = (char **)OICMalloc(3 * sizeof(char*));
1064         if (!interfaces)
1065         {
1066             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
1067             return NULL;
1068         }
1069
1070         interfaces[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
1071         interfaces[1] = OICStrdup(OC_RSRVD_INTERFACE_LL);
1072         interfaces[2] = OICStrdup(OC_RSRVD_INTERFACE_BATCH);
1073
1074         OCRepPayloadSetStringArray(repPayload, OC_RSRVD_ES_INTERFACE, (const char **)interfaces, interfacesDimensions);
1075
1076         size_t resourceTypesDimensions[MAX_REP_ARRAY_DEPTH] = {2, 0, 0};
1077         char **resourceTypes = (char **)OICMalloc(2 * sizeof(char*));
1078         if (!resourceTypes)
1079         {
1080             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
1081             return NULL;
1082         }
1083
1084         resourceTypes[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_EASYSETUP);
1085         resourceTypes[1] = OICStrdup(OC_RSRVD_ES_RES_TYPE_COL);
1086
1087         OCRepPayloadSetStringArray(repPayload, OC_RSRVD_ES_RES_TYPE, (const char **)resourceTypes, resourceTypesDimensions);
1088
1089         OCRepPayloadSetPropInt(repPayload, OC_RSRVD_ES_PROVSTATUS, g_ESEasySetupResource.status);
1090         OCRepPayloadSetPropInt(repPayload, OC_RSRVD_ES_LAST_ERRORCODE, g_ESEasySetupResource.lastErrCode);
1091         if (g_ESEasySetupResource.numRequest > 0)
1092         {
1093             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {g_ESEasySetupResource.numRequest, 0, 0};
1094             int64_t *connectRequest = (int64_t *)OICMalloc(g_ESEasySetupResource.numRequest  * sizeof(int64_t));
1095             if (!connectRequest)
1096             {
1097                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
1098                 return NULL;
1099             }
1100
1101             for (int i = 0 ; i < g_ESEasySetupResource.numRequest  ; ++i)
1102             {
1103                 connectRequest[i] = g_ESEasySetupResource.connectRequest[i];
1104             }
1105             OCRepPayloadSetIntArray(payload, OC_RSRVD_ES_CONNECT, (int64_t *)connectRequest, dimensions);
1106         }
1107         else
1108         {
1109             OIC_LOG(DEBUG, ES_RH_TAG, "g_ESEasySetupResource.numRequest is 0");
1110             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {0, 0, 0};
1111             OCRepPayloadSetIntArray(payload, OC_RSRVD_ES_CONNECT, NULL, dimensions);
1112         }
1113
1114         if (gWriteUserdataCb)
1115         {
1116             gWriteUserdataCb(repPayload, OC_RSRVD_ES_RES_TYPE_EASYSETUP);
1117         }
1118
1119         OCRepPayloadSetPropObject(payload, OC_RSRVD_REPRESENTATION, repPayload);
1120     }
1121
1122     if (ehRequest->query)
1123     {
1124         if (CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH))
1125         {// When Provisioning resource has a GET with BatchInterface
1126             OCRepPayload* head = payload;
1127             OCRepPayload* nextPayload = NULL;
1128
1129             nextPayload = constructResponseOfWiFiConf(OC_RSRVD_INTERFACE_BATCH);
1130             if (nextPayload != NULL)
1131             {
1132                 payload->next = nextPayload;
1133                 payload = payload->next;
1134             }
1135
1136             nextPayload = constructResponseOfCoapCloudConf(OC_RSRVD_INTERFACE_BATCH);
1137             if (nextPayload != NULL)
1138             {
1139                 payload->next = nextPayload;
1140                 payload = payload->next;
1141             }
1142
1143             nextPayload = constructResponseOfDevConf(OC_RSRVD_INTERFACE_BATCH);
1144             if (nextPayload != NULL)
1145             {
1146                 payload->next = nextPayload;
1147             }
1148
1149             payload = head;
1150         }
1151     }
1152
1153     return payload;
1154 }
1155
1156
1157 OCStackResult CreateEasySetupResources(bool isSecured, ESResourceMask resourceMask)
1158 {
1159     OCStackResult res = OC_STACK_ERROR;
1160     bool maskFlag = false;
1161
1162     res = initEasySetupResource(isSecured);
1163     if (res != OC_STACK_OK)
1164     {
1165         // TODO: destroy logic will be added
1166         OIC_LOG_V(ERROR, ES_RH_TAG, "initEasySetupResource result: %s", getResult(res));
1167
1168         return res;
1169     }
1170
1171     if ((resourceMask & ES_WIFICONF_RESOURCE) == ES_WIFICONF_RESOURCE)
1172     {
1173         maskFlag = true;
1174         res = initWiFiConfResource(isSecured);
1175         if (res != OC_STACK_OK)
1176         {
1177             OIC_LOG_V(ERROR, ES_RH_TAG, "initWiFiConfResource result: %s", getResult(res));
1178             return res;
1179         }
1180
1181         res = OCBindResource(g_ESEasySetupResource.handle, g_ESWiFiConfResource.handle);
1182         if (res != OC_STACK_OK)
1183         {
1184             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind WiFiConfResource result: %s", getResult(res));
1185             return res;
1186         }
1187
1188     }
1189
1190     if ((resourceMask & ES_COAPCLOUDCONF_RESOURCE) == ES_COAPCLOUDCONF_RESOURCE)
1191     {
1192         maskFlag = true;
1193         res = initCoapCloudConfResource(isSecured);
1194         if (res != OC_STACK_OK)
1195         {
1196             OIC_LOG_V(ERROR, ES_RH_TAG, "initCoapCloudConfResource result: %s", getResult(res));
1197             return res;
1198         }
1199
1200         res = OCBindResource(g_ESEasySetupResource.handle, g_ESCoapCloudConfResource.handle);
1201         if (res != OC_STACK_OK)
1202         {
1203             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind CoapCloudConfResource result: %s", getResult(res));
1204             return res;
1205         }
1206     }
1207
1208     if ((resourceMask & ES_DEVCONF_RESOURCE) == ES_DEVCONF_RESOURCE)
1209     {
1210         maskFlag = true;
1211         res = initDevConfResource(isSecured);
1212         if (res != OC_STACK_OK)
1213         {
1214             OIC_LOG_V(ERROR, ES_RH_TAG, "initDevConf result: %s", getResult(res));
1215             return res;
1216         }
1217
1218         res = OCBindResource(g_ESEasySetupResource.handle, g_ESDevConfResource.handle);
1219         if (res != OC_STACK_OK)
1220         {
1221             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind DevConfResource result: %s", getResult(res));
1222             return res;
1223         }
1224     }
1225
1226     if (maskFlag == false)
1227     {
1228         OIC_LOG_V(ERROR, ES_RH_TAG, "Invalid ResourceMask");
1229         return OC_STACK_ERROR;
1230
1231     }
1232
1233     OIC_LOG_V(DEBUG, ES_RH_TAG, "Created all resources with result: %s", getResult(res));
1234
1235     return res;
1236 }
1237
1238 OCStackResult DeleteEasySetupResources()
1239 {
1240     OCStackResult res = OC_STACK_ERROR;
1241     if (g_ESWiFiConfResource.handle != NULL)
1242     {
1243         res = OCUnBindResource(g_ESEasySetupResource.handle, g_ESWiFiConfResource.handle);
1244         if (res != OC_STACK_OK)
1245         {
1246             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind WiFi resource error with result: %s", getResult(res));
1247         }
1248     }
1249     if (g_ESCoapCloudConfResource.handle != NULL)
1250     {
1251         res = OCUnBindResource(g_ESEasySetupResource.handle, g_ESCoapCloudConfResource.handle);
1252         if (res != OC_STACK_OK)
1253         {
1254             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind CloudServer resource error with result: %s", getResult(res));
1255         }
1256     }
1257     if (g_ESDevConfResource.handle != NULL)
1258     {
1259         res = OCUnBindResource(g_ESEasySetupResource.handle, g_ESDevConfResource.handle);
1260         if (res != OC_STACK_OK)
1261         {
1262             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind DevConf resource error with result: %s", getResult(res));
1263         }
1264     }
1265
1266     if (g_ESWiFiConfResource.handle != NULL)
1267     {
1268         res = OCDeleteResource(g_ESWiFiConfResource.handle);
1269         if (res != OC_STACK_OK)
1270         {
1271             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting WiFi resource error with result: %s", getResult(res));
1272         }
1273     }
1274
1275     if (g_ESCoapCloudConfResource.handle != NULL)
1276     {
1277         res = OCDeleteResource(g_ESCoapCloudConfResource.handle);
1278         if (res != OC_STACK_OK)
1279         {
1280             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting CloudServer resource error with result: %s", getResult(res));
1281         }
1282     }
1283
1284     if (g_ESDevConfResource.handle != NULL)
1285     {
1286         res = OCDeleteResource(g_ESDevConfResource.handle);
1287         if (res != OC_STACK_OK)
1288         {
1289             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting DevConf resource error with result: %s", getResult(res));
1290         }
1291     }
1292
1293     if (g_ESEasySetupResource.handle != NULL)
1294     {
1295         res = OCDeleteResource(g_ESEasySetupResource.handle);
1296         if (res != OC_STACK_OK)
1297         {
1298             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting Prov resource error with result: %s", getResult(res));
1299         }
1300     }
1301
1302     return res;
1303 }
1304
1305 OCEntityHandlerResult ProcessGetRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload **payload)
1306 {
1307     OCEntityHandlerResult ehResult = OC_EH_ERROR;
1308     if (!ehRequest)
1309     {
1310         OIC_LOG(ERROR, ES_RH_TAG, "Request is Null");
1311         return ehResult;
1312     }
1313     if (ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
1314     {
1315         OIC_LOG(ERROR, ES_RH_TAG, "Incoming payload not a representation");
1316         return ehResult;
1317     }
1318
1319     OCRepPayload *getResp = NULL;
1320     *payload = NULL;
1321
1322     if (ehRequest->resource == g_ESEasySetupResource.handle)
1323     {
1324         if (ehRequest->query &&
1325             strcmp(ehRequest->query, "") &&
1326             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_LL) &&
1327             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH) &&
1328             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
1329         {
1330             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1331             return OC_EH_BAD_REQ;
1332         }
1333         else
1334         {
1335             getResp = constructResponseOfEasySetup(ehRequest);
1336         }
1337     }
1338     else if (ehRequest->resource == g_ESWiFiConfResource.handle)
1339     {
1340         if (CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1341         {
1342             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1343             return OC_EH_BAD_REQ;
1344         }
1345         else
1346         {
1347             getResp = constructResponseOfWiFiConf(OC_RSRVD_INTERFACE_DEFAULT);
1348         }
1349     }
1350     else if (ehRequest->resource == g_ESCoapCloudConfResource.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 = constructResponseOfCoapCloudConf(OC_RSRVD_INTERFACE_DEFAULT);
1360         }
1361     }
1362     else if (ehRequest->resource == g_ESDevConfResource.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 = constructResponseOfDevConf(OC_RSRVD_INTERFACE_DEFAULT);
1372         }
1373     }
1374
1375     if (!getResp)
1376     {
1377         OIC_LOG(ERROR, ES_RH_TAG, "constructResponse failed");
1378         return OC_EH_ERROR;
1379     }
1380
1381     *payload = getResp;
1382     ehResult = OC_EH_OK;
1383
1384     return ehResult;
1385 }
1386
1387 OCEntityHandlerResult ProcessPostRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload)
1388 {
1389     OIC_LOG(DEBUG, ES_RH_TAG, "ProcessPostRequest enter");
1390     OCEntityHandlerResult ehResult = OC_EH_ERROR;
1391     if (ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
1392     {
1393         OIC_LOG(ERROR, ES_RH_TAG, "Incoming payload not a representation");
1394         return ehResult;
1395     }
1396
1397     OCRepPayload* input = (OCRepPayload*) (ehRequest->payload);
1398     if (!input)
1399     {
1400         OIC_LOG(ERROR, ES_RH_TAG, "Failed to parse");
1401         return ehResult;
1402     }
1403
1404     if (ehRequest->resource == g_ESEasySetupResource.handle)
1405     {
1406         if (ehRequest->query &&
1407             strcmp(ehRequest->query, "") &&
1408             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH) &&
1409             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
1410         {
1411             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1412             return OC_EH_BAD_REQ;
1413         }
1414         else
1415         {
1416             updateEasySetupResource(ehRequest, input);
1417         }
1418     }
1419     else if (ehRequest->resource == g_ESWiFiConfResource.handle)
1420     {
1421         if (CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1422         {
1423             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1424             return OC_EH_BAD_REQ;
1425         }
1426         else
1427         {
1428             updateWiFiConfResource(input);
1429         }
1430     }
1431     else if (ehRequest->resource == g_ESCoapCloudConfResource.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             updateCoapCloudConfResource(input);
1441         }
1442     }
1443     else if (ehRequest->resource == g_ESDevConfResource.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             updateDevConfResource(input);
1453         }
1454     }
1455
1456     OCRepPayload *getResp = NULL;
1457     if (ehRequest->resource == g_ESEasySetupResource.handle)
1458     {
1459         getResp = constructResponseOfEasySetup(ehRequest);
1460     }
1461     else if (ehRequest->resource == g_ESWiFiConfResource.handle)
1462     {
1463         getResp = constructResponseOfWiFiConf(OC_RSRVD_INTERFACE_DEFAULT);
1464     }
1465     else if (ehRequest->resource == g_ESCoapCloudConfResource.handle)
1466     {
1467         getResp = constructResponseOfCoapCloudConf(OC_RSRVD_INTERFACE_DEFAULT);
1468     }
1469     else if (ehRequest->resource == g_ESDevConfResource.handle)
1470     {
1471         getResp = constructResponseOfDevConf(OC_RSRVD_INTERFACE_DEFAULT);
1472     }
1473
1474     if (!getResp)
1475     {
1476         OIC_LOG(ERROR, ES_RH_TAG, "constructResponse failed");
1477         return OC_EH_ERROR;
1478     }
1479
1480     *payload = getResp;
1481     ehResult = OC_EH_OK;
1482
1483     return ehResult;
1484 }
1485
1486 OCEntityHandlerResult ProcessPutRequest(OCEntityHandlerRequest * ehRequest,
1487         OCRepPayload** payload)
1488 {
1489     (void) ehRequest;
1490     (void) payload;
1491     OCEntityHandlerResult ehResult = OC_EH_BAD_REQ;
1492
1493     return ehResult;
1494 }
1495 /**
1496  * This is the entity handler for the registered resource.
1497  * This is invoked by OCStack whenever it recevies a request for this resource.
1498  */
1499 OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag,
1500         OCEntityHandlerRequest* entityHandlerRequest, void *callback)
1501 {
1502     (void) callback;
1503     OCEntityHandlerResult ehRet = OC_EH_OK;
1504     OCEntityHandlerResponse response =
1505     { 0, 0, OC_EH_ERROR, 0, 0,
1506     { },
1507     { 0 }, false };
1508     OCRepPayload* payload = NULL;
1509
1510     if (entityHandlerRequest && (flag & OC_REQUEST_FLAG))
1511     {
1512         if (OC_REST_GET == entityHandlerRequest->method)
1513         {
1514             OIC_LOG(DEBUG, ES_RH_TAG, "Received GET request");
1515             ehRet = ProcessGetRequest(entityHandlerRequest, &payload);
1516         }
1517         else if (OC_REST_PUT == entityHandlerRequest->method)
1518         {
1519             OIC_LOG(DEBUG, ES_RH_TAG, "Received PUT request");
1520
1521             //PUT request will be handled in the internal implementation
1522             if (g_ESEasySetupResource.handle != NULL)
1523             {
1524                 ehRet = ProcessPutRequest(entityHandlerRequest, &payload);
1525             }
1526             else
1527             {
1528                 OIC_LOG(ERROR, ES_RH_TAG, "Cannot process put");
1529                 ehRet = OC_EH_ERROR;
1530             }
1531         }
1532         else if (OC_REST_POST == entityHandlerRequest->method)
1533         {
1534             OIC_LOG(DEBUG, ES_RH_TAG, "Received OC_REST_POST from client");
1535             if (g_ESEasySetupResource.handle != NULL)
1536             {
1537                 ehRet = ProcessPostRequest(entityHandlerRequest, &payload);
1538             }
1539             else
1540             {
1541                 OIC_LOG(ERROR, ES_RH_TAG, "Cannot process put");
1542                 ehRet = OC_EH_ERROR;
1543             }
1544         }
1545
1546         // Format the response.  Note this requires some info about the request
1547         response.requestHandle = entityHandlerRequest->requestHandle;
1548         response.ehResult = ehRet;
1549         //response uses OCPaylod while all get,put methodes use OCRepPayload
1550         response.payload = (OCPayload*) (payload);
1551         response.numSendVendorSpecificHeaderOptions = 0;
1552         memset(response.sendVendorSpecificHeaderOptions, 0,
1553                 sizeof(response.sendVendorSpecificHeaderOptions));
1554         memset(response.resourceUri, 0, sizeof(response.resourceUri));
1555         // Indicate that response is NOT in a persistent buffer
1556         response.persistentBufferFlag = 0;
1557
1558         // Send the response
1559         if (OCDoResponse(&response) != OC_STACK_OK)
1560         {
1561             OIC_LOG(ERROR, ES_RH_TAG, "Error sending response");
1562             ehRet = OC_EH_ERROR;
1563         }
1564     }
1565     if (entityHandlerRequest && (flag & OC_OBSERVE_FLAG))
1566     {
1567         OIC_LOG(DEBUG, ES_RH_TAG, "Flag includes OC_OBSERVE_FLAG");
1568
1569         if (OC_OBSERVE_REGISTER == entityHandlerRequest->obsInfo.action)
1570         {
1571             OIC_LOG(DEBUG, ES_RH_TAG, "Received OC_OBSERVE_REGISTER from Mediator");
1572         }
1573         else if (OC_OBSERVE_DEREGISTER == entityHandlerRequest->obsInfo.action)
1574         {
1575             OIC_LOG(DEBUG, ES_RH_TAG, "Received OC_OBSERVE_DEREGISTER from Mediator");
1576         }
1577     }
1578     return ehRet;
1579 }
1580
1581 OCStackResult SetDeviceProperty(ESDeviceProperty *deviceProperty)
1582 {
1583     OIC_LOG(DEBUG, ES_RH_TAG, "SetDeviceProperty IN");
1584
1585     g_ESWiFiConfResource.supportedFreq = (deviceProperty->WiFi).freq;
1586     OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "WiFi Freq : %d", g_ESWiFiConfResource.supportedFreq);
1587
1588     int modeIdx = 0;
1589     while ((deviceProperty->WiFi).mode[modeIdx] != WiFi_EOF)
1590     {
1591         g_ESWiFiConfResource.supportedMode[modeIdx] = (deviceProperty->WiFi).mode[modeIdx];
1592         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "WiFi Mode : %d", g_ESWiFiConfResource.supportedMode[modeIdx]);
1593         modeIdx ++;
1594     }
1595     g_ESWiFiConfResource.numMode = modeIdx;
1596
1597     OICStrcpy(g_ESDevConfResource.devName, OIC_STRING_MAX_VALUE, (deviceProperty->DevConf).deviceName);
1598     OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "Device Name : %s", g_ESDevConfResource.devName);
1599
1600     if (OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESWiFiConfResource.handle, OC_HIGH_QOS))
1601     {
1602         OIC_LOG(DEBUG, ES_RH_TAG, "wifiResource doesn't have any observers.");
1603     }
1604
1605     if (OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESDevConfResource.handle, OC_HIGH_QOS))
1606     {
1607         OIC_LOG(DEBUG, ES_RH_TAG, "devConfResource doesn't have any observers.");
1608     }
1609
1610     OIC_LOG(DEBUG, ES_RH_TAG, "SetDeviceProperty OUT");
1611     return OC_STACK_OK;
1612 }
1613
1614 OCStackResult SetEnrolleeState(ESEnrolleeState esState)
1615 {
1616     OIC_LOG(DEBUG, ES_RH_TAG, "SetEnrolleeState IN");
1617
1618     g_ESEasySetupResource.status = esState;
1619     OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "Enrollee Status : %d", g_ESEasySetupResource.status);
1620
1621     if (OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESEasySetupResource.handle, OC_HIGH_QOS))
1622     {
1623         OIC_LOG(DEBUG, ES_RH_TAG, "provResource doesn't have any observers.");
1624     }
1625
1626     OIC_LOG(DEBUG, ES_RH_TAG, "SetEnrolleeState OUT");
1627     return OC_STACK_OK;
1628 }
1629
1630 OCStackResult SetEnrolleeErrCode(ESErrorCode esErrCode)
1631 {
1632     OIC_LOG(DEBUG, ES_RH_TAG, "SetEnrolleeErrCode IN");
1633
1634     g_ESEasySetupResource.lastErrCode = esErrCode;
1635     OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "Enrollee ErrorCode : %d", g_ESEasySetupResource.lastErrCode);
1636
1637     if (OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESEasySetupResource.handle, OC_HIGH_QOS))
1638     {
1639         OIC_LOG(DEBUG, ES_RH_TAG, "provResource doesn't have any observers.");
1640     }
1641
1642     OIC_LOG(DEBUG, ES_RH_TAG, "SetEnrolleeErrCode OUT");
1643     return OC_STACK_OK;
1644 }
1645
1646 OCEntityHandlerResult CheckEhRequestPayload(OCEntityHandlerRequest *ehRequest)
1647 {
1648     if (!(ehRequest->query) ||
1649                 (ehRequest->query &&
1650                 (strcmp(ehRequest->query, "") && !CompareResourceInterface(ehRequest->query,
1651                                                                         OC_RSRVD_INTERFACE_DEFAULT))))
1652     {
1653         OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1654         return OC_EH_BAD_REQ;
1655     }
1656     return OC_EH_OK;
1657 }
1658
1659 const char *getResult(OCStackResult result)
1660 {
1661     switch (result)
1662     {
1663         case OC_STACK_OK:
1664             return "OC_STACK_OK";
1665         case OC_STACK_INVALID_URI:
1666             return "OC_STACK_INVALID_URI";
1667         case OC_STACK_INVALID_QUERY:
1668             return "OC_STACK_INVALID_QUERY";
1669         case OC_STACK_INVALID_IP:
1670             return "OC_STACK_INVALID_IP";
1671         case OC_STACK_INVALID_PORT:
1672             return "OC_STACK_INVALID_PORT";
1673         case OC_STACK_INVALID_CALLBACK:
1674             return "OC_STACK_INVALID_CALLBACK";
1675         case OC_STACK_INVALID_METHOD:
1676             return "OC_STACK_INVALID_METHOD";
1677         case OC_STACK_NO_MEMORY:
1678             return "OC_STACK_NO_MEMORY";
1679         case OC_STACK_COMM_ERROR:
1680             return "OC_STACK_COMM_ERROR";
1681         case OC_STACK_INVALID_PARAM:
1682             return "OC_STACK_INVALID_PARAM";
1683         case OC_STACK_NOTIMPL:
1684             return "OC_STACK_NOTIMPL";
1685         case OC_STACK_NO_RESOURCE:
1686             return "OC_STACK_NO_RESOURCE";
1687         case OC_STACK_RESOURCE_ERROR:
1688             return "OC_STACK_RESOURCE_ERROR";
1689         case OC_STACK_SLOW_RESOURCE:
1690             return "OC_STACK_SLOW_RESOURCE";
1691         case OC_STACK_NO_OBSERVERS:
1692             return "OC_STACK_NO_OBSERVERS";
1693         case OC_STACK_ERROR:
1694             return "OC_STACK_ERROR";
1695         default:
1696             return "UNKNOWN";
1697     }
1698 }