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