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