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