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