Fix a logic to handle collection resource payload construction for
[iotivity.git] / service / easy-setup / enrollee / src / resourcehandler.c
1 //******************************************************************
2 //
3 // Copyright 2015 Samsung Electronics All Rights Reserved.
4 //
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
6 //
7 // Licensed under the Apache License, Version 2.0 (the "License");
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
10 //
11 //      http://www.apache.org/licenses/LICENSE-2.0
12 //
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an "AS IS" BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
18 //
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
20
21 #include "resourcehandler.h"
22
23 #include "ocpayload.h"
24 #include "oic_string.h"
25 #include "oic_malloc.h"
26 #include "cautilinterface.h"
27
28 /**
29  * @var ES_RH_TAG
30  * @brief Logging tag for module name.
31  */
32 #define ES_RH_TAG "ES_RH"
33 //-----------------------------------------------------------------------------
34 // Private variables
35 //-----------------------------------------------------------------------------
36
37 /**
38  * @var g_ESProvResource
39  * @brief Structure for holding the Provisioning status
40  */
41 ProvResource g_ESProvResource;
42 WiFiResource g_ESWiFiResource;
43 CloudResource g_ESCloudResource;
44 DevConfResource g_ESDevConfResource;
45
46 //-----------------------------------------------------------------------------
47 // Private internal function prototypes
48 //-----------------------------------------------------------------------------
49 OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag, OCEntityHandlerRequest *ehRequest,
50         void *callback);
51 OCEntityHandlerResult ProcessGetRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload);
52 OCEntityHandlerResult ProcessPutRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload);
53 OCEntityHandlerResult ProcessPostRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload);
54 void updateProvResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input);
55 void updateWiFiResource(OCRepPayload* input);
56 void updateCloudResource(OCRepPayload* input);
57 void updateDevConfResource(OCRepPayload* input);
58 const char *getResult(OCStackResult result);
59
60 ESWiFiCB gWifiRsrcEvtCb = NULL;
61 ESCloudCB gCloudRsrcEvtCb = NULL;
62 ESDevConfCB gDevConfRsrcEvtCb = NULL;
63
64 ESReadUserdataCb gReadUserdataCb = NULL;
65 ESWriteUserdataCb gWriteUserdataCb = NULL;
66
67 bool CompareResourceInterface(char *from, char *iface)
68 {
69     char *str = OICStrdup(from);
70     char *ptr = strtok(str, ";");
71
72     if(ptr == NULL)
73     {
74         return false;
75     }
76
77     do
78     {
79         if(strstr(ptr, ".if."))
80         {
81             char *if_ptr = NULL;
82             if_ptr = strtok(ptr, "=");
83             if_ptr = strtok(NULL, "=");
84
85             if(!strcmp(if_ptr, iface))
86             {
87                 return true;
88             }
89         }
90
91     } while ((ptr = strtok(NULL, ";")));
92
93     return false;
94 }
95
96 ESResult SetCallbackForUserData(ESReadUserdataCb readCb, ESWriteUserdataCb writeCb)
97 {
98     if(!readCb && !writeCb)
99     {
100         OIC_LOG(INFO, ES_RH_TAG, "Both of callbacks for user data are null");
101         return ES_ERROR;
102     }
103     gReadUserdataCb = readCb;
104     gWriteUserdataCb = writeCb;
105     return ES_OK;
106 }
107
108 void RegisterWifiRsrcEventCallBack(ESWiFiCB cb)
109 {
110     gWifiRsrcEvtCb = cb;
111 }
112
113 void RegisterCloudRsrcEventCallBack(ESCloudCB cb)
114 {
115     gCloudRsrcEvtCb = cb;
116 }
117
118 void RegisterDevConfRsrcEventCallBack(ESDevConfCB cb)
119 {
120     gDevConfRsrcEvtCb = cb;
121 }
122
123 void UnRegisterResourceEventCallBack()
124 {
125     if (gWifiRsrcEvtCb)
126     {
127         gWifiRsrcEvtCb = NULL;
128     }
129     if (gCloudRsrcEvtCb)
130     {
131         gCloudRsrcEvtCb = NULL;
132     }
133     if (gDevConfRsrcEvtCb)
134     {
135         gDevConfRsrcEvtCb = NULL;
136     }
137 }
138
139 OCStackResult initProvResource(bool isSecured)
140 {
141     g_ESProvResource.status = ES_STATE_INIT;
142     g_ESProvResource.lastErrCode = ES_ERRCODE_NO_ERROR;
143
144     OCStackResult res = OC_STACK_ERROR;
145     if (isSecured)
146     {
147         res = OCCreateResource(&g_ESProvResource.handle, OC_RSRVD_ES_RES_TYPE_PROV,
148         OC_RSRVD_INTERFACE_DEFAULT,
149         OC_RSRVD_ES_URI_PROV, OCEntityHandlerCb,
150         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
151     }else
152     {
153         res = OCCreateResource(&g_ESProvResource.handle, OC_RSRVD_ES_RES_TYPE_PROV,
154         OC_RSRVD_INTERFACE_DEFAULT,
155         OC_RSRVD_ES_URI_PROV, OCEntityHandlerCb,
156         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
157     }
158     if(res)
159     {
160         OIC_LOG_V(INFO, ES_RH_TAG, "Created Prov resource with result: %s", getResult(res));
161         return res;
162     }
163
164     res = OCBindResourceTypeToResource(g_ESProvResource.handle, OC_RSRVD_ES_RES_TYPE_COL);
165     if(res)
166     {
167         OIC_LOG_V(INFO, ES_RH_TAG, "Binding Resource type with result: %s", getResult(res));
168         return res;
169     }
170
171     res = OCBindResourceInterfaceToResource(g_ESProvResource.handle, OC_RSRVD_INTERFACE_LL);
172     if(res)
173     {
174         OIC_LOG_V(INFO, ES_RH_TAG, "Binding Resource interface with result: %s", getResult(res));
175         return res;
176     }
177     res = OCBindResourceInterfaceToResource(g_ESProvResource.handle, OC_RSRVD_INTERFACE_BATCH);
178     if(res)
179     {
180         OIC_LOG_V(INFO, ES_RH_TAG, "Binding Resource interface with result: %s", getResult(res));
181         return res;
182     }
183
184     OIC_LOG_V(INFO, ES_RH_TAG, "Created Prov resource with result: %s", getResult(res));
185     return res;
186 }
187
188 OCStackResult initWiFiResource(bool isSecured)
189 {
190     OCStackResult res = OC_STACK_ERROR;
191
192     g_ESWiFiResource.supportedFreq = WIFI_BOTH;
193     g_ESWiFiResource.supportedMode[0] = WIFI_11A;
194     g_ESWiFiResource.supportedMode[1] = WIFI_11B;
195     g_ESWiFiResource.supportedMode[2] = WIFI_11G;
196     g_ESWiFiResource.supportedMode[3] = WIFI_11N;
197     g_ESWiFiResource.numMode = 4;
198     g_ESWiFiResource.authType = NONE_AUTH;
199     g_ESWiFiResource.encType = NONE_ENC;
200     OICStrcpy(g_ESWiFiResource.ssid, sizeof(g_ESWiFiResource.ssid), "");
201     OICStrcpy(g_ESWiFiResource.cred, sizeof(g_ESWiFiResource.cred), "");
202
203     if (isSecured)
204     {
205         res = OCCreateResource(&g_ESWiFiResource.handle, OC_RSRVD_ES_RES_TYPE_WIFI,
206         OC_RSRVD_INTERFACE_DEFAULT,
207         OC_RSRVD_ES_URI_WIFI, OCEntityHandlerCb,
208         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
209     }else
210     {
211         res = OCCreateResource(&g_ESWiFiResource.handle, OC_RSRVD_ES_RES_TYPE_WIFI,
212         OC_RSRVD_INTERFACE_DEFAULT,
213         OC_RSRVD_ES_URI_WIFI, OCEntityHandlerCb,
214         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
215     }
216
217     OIC_LOG_V(INFO, ES_RH_TAG, "Created WiFi resource with result: %s", getResult(res));
218     return res;
219
220 }
221
222 OCStackResult initCloudServerResource(bool isSecured)
223 {
224     OCStackResult res = OC_STACK_ERROR;
225
226     OICStrcpy(g_ESCloudResource.authCode, sizeof(g_ESCloudResource.authCode), "");
227     OICStrcpy(g_ESCloudResource.accessToken, sizeof(g_ESCloudResource.accessToken), "");
228     g_ESCloudResource.accessTokenType = NONE_OAUTH_TOKENTYPE;
229     OICStrcpy(g_ESCloudResource.authProvider, sizeof(g_ESCloudResource.authProvider), "");
230     OICStrcpy(g_ESCloudResource.ciServer, sizeof(g_ESCloudResource.ciServer), "");
231
232     if (isSecured)
233     {
234         res = OCCreateResource(&g_ESCloudResource.handle, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER,
235         OC_RSRVD_INTERFACE_DEFAULT,
236         OC_RSRVD_ES_URI_CLOUDSERVER, OCEntityHandlerCb,
237         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
238     }else
239     {
240         res = OCCreateResource(&g_ESCloudResource.handle, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER,
241         OC_RSRVD_INTERFACE_DEFAULT,
242         OC_RSRVD_ES_URI_CLOUDSERVER, OCEntityHandlerCb,
243         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
244     }
245
246     OIC_LOG_V(INFO, ES_RH_TAG, "Created CloudServer resource with result: %s", getResult(res));
247     return res;
248
249 }
250
251 OCStackResult initDevConfResource(bool isSecured)
252 {
253     OCStackResult res = OC_STACK_ERROR;
254
255     OICStrcpy(g_ESDevConfResource.devName, sizeof(g_ESDevConfResource.devName), "");
256     OICStrcpy(g_ESDevConfResource.modelNumber, sizeof(g_ESDevConfResource.modelNumber), "");
257     OICStrcpy(g_ESDevConfResource.location, sizeof(g_ESDevConfResource.location), "");
258     OICStrcpy(g_ESDevConfResource.country, sizeof(g_ESDevConfResource.country), "");
259     OICStrcpy(g_ESDevConfResource.language, sizeof(g_ESDevConfResource.language), "");
260
261     if (isSecured)
262     {
263         res = OCCreateResource(&g_ESDevConfResource.handle, OC_RSRVD_ES_RES_TYPE_DEVCONF,
264         OC_RSRVD_INTERFACE_DEFAULT,
265         OC_RSRVD_ES_URI_DEVCONF, OCEntityHandlerCb,
266         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
267     }else
268     {
269         res = OCCreateResource(&g_ESDevConfResource.handle, OC_RSRVD_ES_RES_TYPE_DEVCONF,
270         OC_RSRVD_INTERFACE_DEFAULT,
271         OC_RSRVD_ES_URI_DEVCONF, OCEntityHandlerCb,
272         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
273     }
274
275     OIC_LOG_V(INFO, ES_RH_TAG, "Created DevConf resource with result: %s", getResult(res));
276     return res;
277
278 }
279
280 void updateProvResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input)
281 {
282     OIC_LOG_V(INFO, ES_RH_TAG, "g_ESProvResource.status %d", g_ESProvResource.status);
283
284     if(ehRequest->query)
285     {
286         if(CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH))
287         {
288             // When Provisioning resource has a POST with BatchInterface
289             updateCloudResource(input);
290             updateWiFiResource(input);
291             updateDevConfResource(input);
292         }
293     }
294 }
295
296 void updateWiFiResource(OCRepPayload* input)
297 {
298     ESWiFiProvData* wiFiData = (ESWiFiProvData*)OICMalloc(sizeof(ESWiFiProvData));
299
300     if(wiFiData == NULL)
301     {
302         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
303         return ;
304     }
305
306     memset(wiFiData->ssid, 0, OIC_STRING_MAX_VALUE);
307     memset(wiFiData->pwd, 0, OIC_STRING_MAX_VALUE);
308     wiFiData->authtype = NONE_AUTH;
309     wiFiData->enctype = NONE_AUTH;
310     wiFiData->userdata = NULL;
311
312     char* ssid = NULL;
313     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_SSID, &ssid))
314     {
315         OICStrcpy(g_ESWiFiResource.ssid, sizeof(g_ESWiFiResource.ssid), ssid);
316         OICStrcpy(wiFiData->ssid, sizeof(wiFiData->ssid), ssid);
317         OIC_LOG_V(INFO, ES_RH_TAG, "g_ESWiFiResource.ssid : %s", g_ESWiFiResource.ssid);
318     }
319
320     char* cred = NULL;
321     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CRED, &cred))
322     {
323         OICStrcpy(g_ESWiFiResource.cred, sizeof(g_ESWiFiResource.cred), cred);
324         OICStrcpy(wiFiData->pwd, sizeof(wiFiData->pwd), cred);
325         OIC_LOG_V(INFO, ES_RH_TAG, "g_ESWiFiResource.cred %s", g_ESWiFiResource.cred);
326     }
327
328     int64_t authType = -1;
329     if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_AUTHTYPE, &authType))
330     {
331         g_ESWiFiResource.authType = authType;
332         wiFiData->authtype = g_ESWiFiResource.authType;
333         OIC_LOG_V(INFO, ES_RH_TAG, "g_ESWiFiResource.authType %u", g_ESWiFiResource.authType);
334     }
335
336     int64_t encType = -1;
337     if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_ENCTYPE, &encType))
338     {
339         g_ESWiFiResource.encType = encType;
340         wiFiData->enctype = g_ESWiFiResource.encType;
341         OIC_LOG_V(INFO, ES_RH_TAG, "g_ESWiFiResource.encType %u", g_ESWiFiResource.encType);
342     }
343
344     if(gReadUserdataCb)
345     {
346         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_WIFI, &wiFiData->userdata);
347     }
348
349     if(ssid || cred || authType!= -1 || encType != -1)
350     {
351         OIC_LOG(INFO, ES_RH_TAG, "Send WiFiRsrc Callback To ES");
352
353         // TODO : Need to check appropriateness of gWiFiData
354         if(gWifiRsrcEvtCb != NULL)
355         {
356             gWifiRsrcEvtCb(ES_OK, wiFiData);
357         }
358         else
359         {
360             OIC_LOG(ERROR, ES_RH_TAG, "gWifiRsrcEvtCb is NULL");
361         }
362     }
363
364     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESWiFiResource.handle, OC_HIGH_QOS))
365     {
366         OIC_LOG(INFO, ES_RH_TAG, "Enrollee doesn't have any observers.");
367     }
368
369     OICFree(wiFiData);
370 }
371
372 void updateCloudResource(OCRepPayload* input)
373 {
374     ESCloudProvData* cloudData = (ESCloudProvData*)OICMalloc(sizeof(ESCloudProvData));
375
376     if(cloudData == NULL)
377     {
378         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
379         return;
380     }
381
382     memset(cloudData->authCode, 0, OIC_STRING_MAX_VALUE);
383     memset(cloudData->accessToken, 0, OIC_STRING_MAX_VALUE);
384     g_ESCloudResource.accessTokenType = NONE_OAUTH_TOKENTYPE;
385     memset(cloudData->authProvider, 0, OIC_STRING_MAX_VALUE);
386     memset(cloudData->ciServer, 0, OIC_STRING_MAX_VALUE);
387     cloudData->userdata = NULL;
388
389     char *authCode = NULL;
390     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_AUTHCODE, &authCode))
391     {
392         OICStrcpy(g_ESCloudResource.authCode, sizeof(g_ESCloudResource.authCode), authCode);
393         OICStrcpy(cloudData->authCode, sizeof(cloudData->authCode), authCode);
394         OIC_LOG_V(INFO, ES_RH_TAG, "g_ESCloudResource.authCode %s", g_ESCloudResource.authCode);
395     }
396
397     char *accessToken = NULL;
398     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_ACCESSTOKEN, &accessToken))
399     {
400         OICStrcpy(g_ESCloudResource.accessToken, sizeof(g_ESCloudResource.accessToken), accessToken);
401         OICStrcpy(cloudData->accessToken, sizeof(cloudData->accessToken), accessToken);
402         OIC_LOG_V(INFO, ES_RH_TAG, "g_ESCloudResource.accessToken %s", g_ESCloudResource.accessToken);
403     }
404
405     int64_t accessTokenType = -1;
406     if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_ACCESSTOKEN_TYPE, &accessTokenType))
407     {
408         g_ESCloudResource.accessTokenType = accessTokenType;
409         cloudData->accessTokenType = g_ESCloudResource.accessTokenType;
410         OIC_LOG_V(INFO, ES_RH_TAG, "g_ESCloudResource.accessTokenType %d", g_ESCloudResource.accessTokenType);
411     }
412
413     char *authProvider = NULL;
414     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_AUTHPROVIDER, &authProvider))
415     {
416         OICStrcpy(g_ESCloudResource.authProvider, sizeof(g_ESCloudResource.authProvider), authProvider);
417         OICStrcpy(cloudData->authProvider, sizeof(cloudData->authProvider), authProvider);
418         OIC_LOG_V(INFO, ES_RH_TAG, "g_ESCloudResource.authServerUrl %s", g_ESCloudResource.authProvider);
419     }
420
421     char *ciServer = NULL;
422     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CISERVER, &ciServer))
423     {
424         OICStrcpy(g_ESCloudResource.ciServer, sizeof(g_ESCloudResource.ciServer), ciServer);
425         OICStrcpy(cloudData->ciServer, sizeof(cloudData->ciServer), ciServer);
426         OIC_LOG_V(INFO, ES_RH_TAG, "g_ESCloudResource.ciServer %s", g_ESCloudResource.ciServer);
427     }
428
429     if(gReadUserdataCb)
430     {
431         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER, &cloudData->userdata);
432     }
433
434     if(authCode || accessToken || authProvider || ciServer)
435     {
436         OIC_LOG(INFO, ES_RH_TAG, "Send CloudRsrc Callback To ES");
437
438         // TODO : Need to check appropriateness of gCloudData
439         if(gCloudRsrcEvtCb != NULL)
440         {
441             gCloudRsrcEvtCb(ES_OK, cloudData);
442         }
443         else
444         {
445             OIC_LOG(ERROR, ES_RH_TAG, "gCloudRsrcEvtCb is NULL");
446         }
447     }
448
449     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESCloudResource.handle, OC_HIGH_QOS))
450     {
451         OIC_LOG(INFO, ES_RH_TAG, "cloudResource doesn't have any observers.");
452     }
453
454     OICFree(cloudData);
455 }
456
457 void updateDevConfResource(OCRepPayload* input)
458 {
459     ESDevConfProvData* devConfData = (ESDevConfProvData*)OICMalloc(sizeof(ESDevConfProvData));
460
461     if(devConfData == NULL)
462     {
463         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
464         return;
465     }
466     memset(devConfData->language, 0, OIC_STRING_MAX_VALUE);
467     memset(devConfData->country, 0, OIC_STRING_MAX_VALUE);
468     devConfData->userdata = NULL;
469
470     char *location = NULL;
471     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_LOCATION, &location))
472     {
473         OICStrcpy(g_ESDevConfResource.location, sizeof(g_ESDevConfResource.location), location);
474         OICStrcpy(devConfData->location, sizeof(devConfData->location), location);
475         OIC_LOG_V(INFO, ES_RH_TAG, "g_ESDevConfResource.location %s", g_ESDevConfResource.location);
476     }
477
478     char *country = NULL;
479     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_COUNTRY, &country))
480     {
481         OICStrcpy(g_ESDevConfResource.country, sizeof(g_ESDevConfResource.country), country);
482         OICStrcpy(devConfData->country, sizeof(devConfData->country), country);
483         OIC_LOG_V(INFO, ES_RH_TAG, "g_ESDevConfResource.country %s", g_ESDevConfResource.country);
484     }
485
486     char *language = NULL;
487     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_LANGUAGE, &language))
488     {
489         OICStrcpy(g_ESDevConfResource.language, sizeof(g_ESDevConfResource.language), language);
490         OICStrcpy(devConfData->language, sizeof(devConfData->language), language);
491         OIC_LOG_V(INFO, ES_RH_TAG, "g_ESDevConfResource.language %s", g_ESDevConfResource.language);
492     }
493
494     if(gReadUserdataCb)
495     {
496         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_DEVCONF, &devConfData->userdata);
497     }
498
499     if(country || language)
500     {
501         OIC_LOG(INFO, ES_RH_TAG, "Send DevConfRsrc Callback To ES");
502
503         // TODO : Need to check appropriateness of gDevConfData
504         if(gDevConfRsrcEvtCb != NULL)
505         {
506             gDevConfRsrcEvtCb(ES_OK, devConfData);
507         }
508         else
509         {
510             OIC_LOG(ERROR, ES_RH_TAG, "gDevConfRsrcEvtCb is NULL");
511         }
512     }
513
514     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESDevConfResource.handle, OC_HIGH_QOS))
515     {
516         OIC_LOG(INFO, ES_RH_TAG, "devConfResource doesn't have any observers.");
517     }
518
519     OICFree(devConfData);
520 }
521
522 OCRepPayload* constructResponseOfWiFi(char *interface)
523 {
524     OCRepPayload* payload = OCRepPayloadCreate();
525     if (!payload)
526     {
527         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
528         return NULL;
529     }
530
531     if(g_ESWiFiResource.handle == NULL)
532     {
533         OIC_LOG(ERROR, ES_RH_TAG, "WiFi resource is not created");
534         return NULL;
535     }
536
537     OIC_LOG(INFO, ES_RH_TAG, "constructResponse wifi res");
538     OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_WIFI);
539
540     OCRepPayload* repPayload = NULL;
541     OCRepPayload* tempPayload = NULL;
542     if(!strcmp(interface, OC_RSRVD_INTERFACE_BATCH))
543     {
544         repPayload = OCRepPayloadCreate();
545         if (!repPayload)
546         {
547             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
548             return NULL;
549         }
550
551         tempPayload = payload;
552         payload = repPayload;
553
554         size_t interfacesDimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
555         char **interfaces = (char **)OICMalloc(3 * sizeof(char*));
556
557         interfaces[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
558
559         OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_INTERFACE, (char **)interfaces, interfacesDimensions);
560
561         size_t resourceTypesDimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
562         char **resourceTypes = (char **)OICMalloc(2 * sizeof(char*));
563
564         resourceTypes[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_WIFI);
565
566         OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_RES_TYPE, (char **)resourceTypes, resourceTypesDimensions);
567     }
568     else
569     {
570         OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_DEFAULT);
571         OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_WIFI);
572     }
573
574     size_t dimensions[MAX_REP_ARRAY_DEPTH] = {g_ESWiFiResource.numMode, 0, 0};
575     int64_t *modes_64 = (int64_t *)OICMalloc(g_ESWiFiResource.numMode * sizeof(int64_t));
576     for(int i = 0 ; i < g_ESWiFiResource.numMode ; ++i)
577     {
578         modes_64[i] = g_ESWiFiResource.supportedMode[i];
579     }
580     OCRepPayloadSetIntArray(payload, OC_RSRVD_ES_SUPPORTEDWIFIMODE, (int64_t *)modes_64, dimensions);
581
582     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_SUPPORTEDWIFIFREQ, g_ESWiFiResource.supportedFreq);
583     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_SSID, g_ESWiFiResource.ssid);
584     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CRED, g_ESWiFiResource.cred);
585     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_AUTHTYPE, (int) g_ESWiFiResource.authType);
586     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_ENCTYPE, (int) g_ESWiFiResource.encType);
587
588     if(gWriteUserdataCb)
589     {
590         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_WIFI);
591     }
592
593     if(!strcmp(interface, OC_RSRVD_INTERFACE_BATCH))
594     {
595         payload = tempPayload;
596         OCRepPayloadSetPropObject(payload, OC_RSRVD_REPRESENTATION, repPayload);
597     }
598
599     return payload;
600 }
601
602 OCRepPayload* constructResponseOfCloud(char *interface)
603 {
604     OCRepPayload* payload = OCRepPayloadCreate();
605     if (!payload)
606     {
607         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
608         return NULL;
609     }
610
611     if(g_ESCloudResource.handle == NULL)
612     {
613         OIC_LOG(ERROR, ES_RH_TAG, "CloudServer resource is not created");
614         return NULL;
615     }
616
617     OIC_LOG(INFO, ES_RH_TAG, "constructResponse cloudserver res");
618     OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_CLOUDSERVER);
619
620     OCRepPayload* repPayload = NULL;
621     OCRepPayload* tempPayload = NULL;
622     if(!strcmp(interface, OC_RSRVD_INTERFACE_BATCH))
623     {
624         repPayload = OCRepPayloadCreate();
625         if (!repPayload)
626         {
627             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
628             return NULL;
629         }
630
631         tempPayload = payload;
632         payload = repPayload;
633
634         size_t interfacesDimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
635         char **interfaces = (char **)OICMalloc(3 * sizeof(char*));
636
637         interfaces[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
638
639         OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_INTERFACE, (char **)interfaces, interfacesDimensions);
640
641         size_t resourceTypesDimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
642         char **resourceTypes = (char **)OICMalloc(2 * sizeof(char*));
643
644         resourceTypes[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_CLOUDSERVER);
645
646         OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_RES_TYPE, (char **)resourceTypes, resourceTypesDimensions);
647     }
648     else
649     {
650         OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_DEFAULT);
651         OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER);
652     }
653
654     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_AUTHCODE, g_ESCloudResource.authCode);
655     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_ACCESSTOKEN, g_ESCloudResource.accessToken);
656     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_ACCESSTOKEN_TYPE, (int)g_ESCloudResource.accessTokenType);
657     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_AUTHPROVIDER, g_ESCloudResource.authProvider);
658     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CISERVER, g_ESCloudResource.ciServer);
659
660     if(gWriteUserdataCb)
661     {
662         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER);
663     }
664
665     if(!strcmp(interface, OC_RSRVD_INTERFACE_BATCH))
666     {
667         payload = tempPayload;
668         OCRepPayloadSetPropObject(payload, OC_RSRVD_REPRESENTATION, repPayload);
669     }
670
671     return payload;
672 }
673
674 OCRepPayload* constructResponseOfDevConf(char *interface)
675 {
676     OCRepPayload* payload = OCRepPayloadCreate();
677     if (!payload)
678     {
679         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
680         return NULL;
681     }
682
683     if(g_ESDevConfResource.handle == NULL)
684     {
685         OIC_LOG(ERROR, ES_RH_TAG, "DevConf resource is not created");
686         return NULL;
687     }
688
689     OIC_LOG(INFO, ES_RH_TAG, "constructResponse devconf res");
690     OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_DEVCONF);
691
692     OCRepPayload* repPayload = NULL;
693     OCRepPayload* tempPayload = NULL;
694     if(!strcmp(interface, OC_RSRVD_INTERFACE_BATCH))
695     {
696         repPayload = OCRepPayloadCreate();
697         if (!repPayload)
698         {
699             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
700             return NULL;
701         }
702
703         tempPayload = payload;
704         payload = repPayload;
705
706         size_t interfacesDimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
707         char **interfaces = (char **)OICMalloc(3 * sizeof(char*));
708
709         interfaces[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
710
711         OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_INTERFACE, (char **)interfaces, interfacesDimensions);
712
713         size_t resourceTypesDimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
714         char **resourceTypes = (char **)OICMalloc(2 * sizeof(char*));
715
716         resourceTypes[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_DEVCONF);
717
718         OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_RES_TYPE, (char **)resourceTypes, resourceTypesDimensions);
719     }
720     else
721     {
722         OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_DEFAULT);
723         OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_DEVCONF);
724     }
725
726     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_DEVNAME, g_ESDevConfResource.devName);
727     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_MODELNUMBER, g_ESDevConfResource.modelNumber);
728     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_LOCATION, g_ESDevConfResource.location);
729     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_LANGUAGE, g_ESDevConfResource.language);
730     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_COUNTRY, g_ESDevConfResource.country);
731
732     if(gWriteUserdataCb)
733     {
734         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_DEVCONF);
735     }
736
737     if(!strcmp(interface, OC_RSRVD_INTERFACE_BATCH))
738     {
739         payload = tempPayload;
740         OCRepPayloadSetPropObject(payload, OC_RSRVD_REPRESENTATION, repPayload);
741     }
742
743     return payload;
744 }
745
746 OCRepPayload* constructResponseOfProv(OCEntityHandlerRequest *ehRequest)
747 {
748     OCRepPayload* payload = OCRepPayloadCreate();
749     if (!payload)
750     {
751         OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
752         return NULL;
753     }
754
755     // Requested interface is Link list interface
756     //if(ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_LL))
757     if(!ehRequest->query ||
758         (ehRequest->query && !strcmp(ehRequest->query, "")) ||
759         (ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_LL)) ||
760         (ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT)))
761     {
762         const OCRepPayload *arrayPayload[3] = {NULL};
763
764         int childResCnt = 0;
765
766         if(g_ESWiFiResource.handle != NULL)
767         {
768             OCRepPayload *add = OCRepPayloadCreate();
769             if(!add)
770             {
771                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
772                 return NULL;
773             }
774
775             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
776             char **resourceType = NULL;
777             resourceType = (char **)OICMalloc(sizeof(char *) * 1);
778             char **resourceInterface = NULL;
779             resourceInterface = (char **)OICMalloc(sizeof(char *) * 1);
780
781             if(!resourceType || !resourceInterface)
782             {
783                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
784                 return NULL;
785             }
786
787             resourceType[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_WIFI);
788             resourceInterface[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
789
790             add->base.type = PAYLOAD_TYPE_REPRESENTATION;
791             OCRepPayloadSetPropString(add, OC_RSRVD_HREF, OC_RSRVD_ES_URI_WIFI);
792             OCRepPayloadSetStringArray(add, OC_RSRVD_RESOURCE_TYPE,
793                                             (const char **)resourceType, dimensions);
794             OCRepPayloadSetStringArray(add, OC_RSRVD_INTERFACE,
795                                             (const char **)resourceInterface, dimensions);
796
797             OCResourceProperty p = OCGetResourceProperties((OCResourceHandle *)g_ESWiFiResource.handle);
798             OCRepPayload *policy = OCRepPayloadCreate();
799             if (!policy)
800             {
801                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
802                 return NULL;
803             }
804
805             OCRepPayloadSetPropInt(policy, OC_RSRVD_BITMAP,
806                                     ((p & OC_DISCOVERABLE) | (p & OC_OBSERVABLE)));
807             if (p & OC_SECURE)
808             {
809                 OCRepPayloadSetPropBool(policy, OC_RSRVD_SECURE, p & OC_SECURE);
810                 uint16_t securePort = CAGetAssignedPortNumber(ehRequest->devAddr.adapter,
811                                                                     ehRequest->devAddr.flags);
812                 OCRepPayloadSetPropInt(policy, OC_RSRVD_HOSTING_PORT, securePort);
813             }
814
815             OCRepPayloadSetPropObject(add, OC_RSRVD_POLICY, policy);
816
817             arrayPayload[childResCnt++] = add;
818         }
819
820         if(g_ESDevConfResource.handle != NULL)
821         {
822             OCRepPayload *add = OCRepPayloadCreate();
823             if(!add)
824             {
825                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
826                 return NULL;
827             }
828
829             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
830             char **resourceType = NULL;
831             resourceType = (char **)OICMalloc(sizeof(char *) * 1);
832             char **resourceInterface = NULL;
833             resourceInterface = (char **)OICMalloc(sizeof(char *) * 1);
834
835             if(!resourceType || !resourceInterface)
836             {
837                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
838                 return NULL;
839             }
840
841             resourceType[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_DEVCONF);
842             resourceInterface[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
843
844             add->base.type = PAYLOAD_TYPE_REPRESENTATION;
845             OCRepPayloadSetPropString(add, OC_RSRVD_HREF, OC_RSRVD_ES_URI_DEVCONF);
846             OCRepPayloadSetStringArray(add, OC_RSRVD_RESOURCE_TYPE,
847                                             (const char **)resourceType, dimensions);
848             OCRepPayloadSetStringArray(add, OC_RSRVD_INTERFACE,
849                                             (const char **)resourceInterface, dimensions);
850
851             OCResourceProperty p = OCGetResourceProperties((OCResourceHandle *)g_ESDevConfResource.handle);
852             OCRepPayload *policy = OCRepPayloadCreate();
853             if (!policy)
854             {
855                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
856                 return NULL;
857             }
858
859             OCRepPayloadSetPropInt(policy, OC_RSRVD_BITMAP,
860                                     ((p & OC_DISCOVERABLE) | (p & OC_OBSERVABLE)));
861             if (p & OC_SECURE)
862             {
863                 OCRepPayloadSetPropBool(policy, OC_RSRVD_SECURE, p & OC_SECURE);
864                 uint16_t securePort = CAGetAssignedPortNumber(ehRequest->devAddr.adapter,
865                                                                     ehRequest->devAddr.flags);
866                 OCRepPayloadSetPropInt(policy, OC_RSRVD_HOSTING_PORT, securePort);
867             }
868
869             OCRepPayloadSetPropObject(add, OC_RSRVD_POLICY, policy);
870
871             arrayPayload[childResCnt++] = add;
872         }
873
874         if(g_ESCloudResource.handle != NULL)
875         {
876             OCRepPayload *add = OCRepPayloadCreate();
877             if(!add)
878             {
879                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
880                 return NULL;
881             }
882
883             size_t dimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
884             char **resourceType = NULL;
885             resourceType = (char **)OICMalloc(sizeof(char *) * 1);
886             char **resourceInterface = NULL;
887             resourceInterface = (char **)OICMalloc(sizeof(char *) * 1);
888
889             if(!resourceType || !resourceInterface)
890             {
891                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
892                 return NULL;
893             }
894
895             resourceType[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_CLOUDSERVER);
896             resourceInterface[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
897
898             add->base.type = PAYLOAD_TYPE_REPRESENTATION;
899             OCRepPayloadSetPropString(add, OC_RSRVD_HREF, OC_RSRVD_ES_URI_CLOUDSERVER);
900             OCRepPayloadSetStringArray(add, OC_RSRVD_RESOURCE_TYPE,
901                                             (const char **)resourceType, dimensions);
902             OCRepPayloadSetStringArray(add, OC_RSRVD_INTERFACE,
903                                             (const char **)resourceInterface, dimensions);
904
905             OCResourceProperty p = OCGetResourceProperties((OCResourceHandle *)g_ESCloudResource.handle);
906             OCRepPayload *policy = OCRepPayloadCreate();
907             if (!policy)
908             {
909                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
910                 return NULL;
911             }
912
913             OCRepPayloadSetPropInt(policy, OC_RSRVD_BITMAP,
914                                     ((p & OC_DISCOVERABLE) | (p & OC_OBSERVABLE)));
915             if (p & OC_SECURE)
916             {
917                 OCRepPayloadSetPropBool(policy, OC_RSRVD_SECURE, p & OC_SECURE);
918                 uint16_t securePort = CAGetAssignedPortNumber(ehRequest->devAddr.adapter,
919                                                                     ehRequest->devAddr.flags);
920                 OCRepPayloadSetPropInt(policy, OC_RSRVD_HOSTING_PORT, securePort);
921             }
922
923             OCRepPayloadSetPropObject(add, OC_RSRVD_POLICY, policy);
924
925             arrayPayload[childResCnt++] = add;
926         }
927
928         size_t dimensions[MAX_REP_ARRAY_DEPTH] = {childResCnt, 0, 0};
929
930         if(!ehRequest->query ||
931             (ehRequest->query && !strcmp(ehRequest->query, "")) ||
932             (ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT)))
933         {
934             OIC_LOG(INFO, ES_RH_TAG, "constructResponse prov res");
935             OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_PROV);
936             OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_DEFAULT);
937             OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_LL);
938             OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_BATCH);
939             OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_PROV);
940             OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_COL);
941
942             OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_PROVSTATUS, g_ESProvResource.status);
943             OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_LAST_ERRORCODE, g_ESProvResource.lastErrCode);
944
945             if(gWriteUserdataCb)
946             {
947                 gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_PROV);
948             }
949
950             OCRepPayloadSetPropObjectArray(payload, OC_RSRVD_ES_LINKS, arrayPayload, dimensions);
951         }
952         else    // link list interface
953         {
954             OCRepPayloadSetPropObjectArray(payload, OC_RSRVD_ES_LINKS, arrayPayload, dimensions);
955         }
956     } else if (
957         ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH))
958
959     {
960         OIC_LOG(INFO, ES_RH_TAG, "constructResponse prov res");
961         OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_PROV);
962
963         OCRepPayload* repPayload = NULL;
964
965         repPayload = OCRepPayloadCreate();
966         if (!repPayload)
967         {
968             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
969             return NULL;
970         }
971
972         size_t interfacesDimensions[MAX_REP_ARRAY_DEPTH] = {3, 0, 0};
973         char **interfaces = (char **)OICMalloc(3 * sizeof(char*));
974         if(!interfaces)
975         {
976             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
977             return NULL;
978         }
979
980         interfaces[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
981         interfaces[1] = OICStrdup(OC_RSRVD_INTERFACE_LL);
982         interfaces[2] = OICStrdup(OC_RSRVD_INTERFACE_BATCH);
983
984         OCRepPayloadSetStringArray(repPayload, OC_RSRVD_ES_INTERFACE, (char **)interfaces, interfacesDimensions);
985
986         size_t resourceTypesDimensions[MAX_REP_ARRAY_DEPTH] = {2, 0, 0};
987         char **resourceTypes = (char **)OICMalloc(2 * sizeof(char*));
988         if(!resourceTypes)
989         {
990             OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
991             return NULL;
992         }
993
994         resourceTypes[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_PROV);
995         resourceTypes[1] = OICStrdup(OC_RSRVD_ES_RES_TYPE_COL);
996
997         OCRepPayloadSetStringArray(repPayload, OC_RSRVD_ES_RES_TYPE, (char **)resourceTypes, resourceTypesDimensions);
998
999         OCRepPayloadSetPropInt(repPayload, OC_RSRVD_ES_PROVSTATUS, g_ESProvResource.status);
1000         OCRepPayloadSetPropInt(repPayload, OC_RSRVD_ES_LAST_ERRORCODE, g_ESProvResource.lastErrCode);
1001
1002         if(gWriteUserdataCb)
1003         {
1004             gWriteUserdataCb(repPayload, OC_RSRVD_ES_RES_TYPE_PROV);
1005         }
1006
1007         OCRepPayloadSetPropObject(payload, OC_RSRVD_REPRESENTATION, repPayload);
1008     }
1009
1010     if(ehRequest->query)
1011     {
1012         if(CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH))
1013         {// When Provisioning resource has a GET with BatchInterface
1014             OCRepPayload* head = payload;
1015             OCRepPayload* nextPayload = NULL;
1016
1017             nextPayload = constructResponseOfWiFi(OC_RSRVD_INTERFACE_BATCH);
1018             if(nextPayload != NULL)
1019             {
1020                 payload->next = nextPayload;
1021                 payload = payload->next;
1022             }
1023
1024             nextPayload = constructResponseOfCloud(OC_RSRVD_INTERFACE_BATCH);
1025             if(nextPayload != NULL)
1026             {
1027                 payload->next = nextPayload;
1028                 payload = payload->next;
1029             }
1030
1031             nextPayload = constructResponseOfDevConf(OC_RSRVD_INTERFACE_BATCH);
1032             if(nextPayload != NULL)
1033             {
1034                 payload->next = nextPayload;
1035             }
1036
1037             payload = head;
1038         }
1039     }
1040
1041     return payload;
1042 }
1043
1044
1045 OCStackResult CreateEasySetupResources(bool isSecured, ESResourceMask resourceMask)
1046 {
1047     OCStackResult res = OC_STACK_ERROR;
1048     bool maskFlag = false;
1049
1050     res = initProvResource(isSecured);
1051     if(res != OC_STACK_OK)
1052     {
1053         // TODO: destroy logic will be added
1054         OIC_LOG_V(ERROR, ES_RH_TAG, "initProvResource result: %s", getResult(res));
1055
1056         return res;
1057     }
1058
1059     if((resourceMask & ES_WIFI_RESOURCE) == ES_WIFI_RESOURCE)
1060     {
1061         maskFlag = true;
1062         res = initWiFiResource(isSecured);
1063         if(res != OC_STACK_OK)
1064         {
1065             OIC_LOG_V(ERROR, ES_RH_TAG, "initWiFiResource result: %s", getResult(res));
1066             return res;
1067         }
1068
1069         res = OCBindResource(g_ESProvResource.handle, g_ESWiFiResource.handle);
1070         if(res != OC_STACK_OK)
1071         {
1072             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind WiFiResource result: %s", getResult(res));
1073             return res;
1074         }
1075
1076     }
1077
1078     if((resourceMask & ES_CLOUD_RESOURCE) == ES_CLOUD_RESOURCE)
1079     {
1080         maskFlag = true;
1081         res = initCloudServerResource(isSecured);
1082         if(res != OC_STACK_OK)
1083         {
1084             OIC_LOG_V(ERROR, ES_RH_TAG, "initCloudResource result: %s", getResult(res));
1085             return res;
1086         }
1087
1088         res = OCBindResource(g_ESProvResource.handle, g_ESCloudResource.handle);
1089         if(res != OC_STACK_OK)
1090         {
1091             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind CloudResource result: %s", getResult(res));
1092             return res;
1093         }
1094     }
1095
1096     if((resourceMask & ES_DEVCONF_RESOURCE) == ES_DEVCONF_RESOURCE)
1097     {
1098         maskFlag = true;
1099         res = initDevConfResource(isSecured);
1100         if(res != OC_STACK_OK)
1101         {
1102             OIC_LOG_V(ERROR, ES_RH_TAG, "initDevConf result: %s", getResult(res));
1103             return res;
1104         }
1105
1106         res = OCBindResource(g_ESProvResource.handle, g_ESDevConfResource.handle);
1107         if(res != OC_STACK_OK)
1108         {
1109             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind DevConfResource result: %s", getResult(res));
1110             return res;
1111         }
1112     }
1113
1114
1115     if(maskFlag == false)
1116     {
1117         OIC_LOG_V(ERROR, ES_RH_TAG, "Invalid ResourceMask");
1118         return OC_STACK_ERROR;
1119
1120     }
1121
1122     OIC_LOG_V(INFO, ES_RH_TAG, "Created all resources with result: %s", getResult(res));
1123
1124     return res;
1125 }
1126
1127 OCStackResult DeleteProvisioningResource()
1128 {
1129     OCStackResult res = OCDeleteResource(g_ESProvResource.handle);
1130     if (res != OC_STACK_OK)
1131     {
1132         OIC_LOG_V(INFO, ES_RH_TAG, "Deleting Prov resource error with result: %s", getResult(res));
1133     }
1134
1135     return res;
1136 }
1137
1138 OCStackResult DeleteEasySetupResources()
1139 {
1140     OCStackResult res = OC_STACK_ERROR;
1141     if (g_ESWiFiResource.handle != NULL)
1142     {
1143         res = OCUnBindResource(g_ESProvResource.handle, g_ESWiFiResource.handle);
1144         if(res != OC_STACK_OK)
1145         {
1146             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind WiFi resource error with result: %s", getResult(res));
1147         }
1148     }
1149     if (g_ESCloudResource.handle != NULL)
1150     {
1151         res = OCUnBindResource(g_ESProvResource.handle, g_ESCloudResource.handle);
1152         if(res != OC_STACK_OK)
1153         {
1154             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind CloudServer resource error with result: %s", getResult(res));
1155         }
1156     }
1157     if (g_ESDevConfResource.handle != NULL)
1158     {
1159         res = OCUnBindResource(g_ESProvResource.handle, g_ESDevConfResource.handle);
1160         if(res != OC_STACK_OK)
1161         {
1162             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind DevConf resource error with result: %s", getResult(res));
1163         }
1164     }
1165
1166     if (g_ESWiFiResource.handle != NULL)
1167     {
1168         res = OCDeleteResource(g_ESWiFiResource.handle);
1169         if (res != OC_STACK_OK)
1170         {
1171             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting WiFi resource error with result: %s", getResult(res));
1172         }
1173     }
1174
1175     if(g_ESCloudResource.handle != NULL)
1176     {
1177         res = OCDeleteResource(g_ESCloudResource.handle);
1178         if (res != OC_STACK_OK)
1179         {
1180             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting CloudServer resource error with result: %s", getResult(res));
1181         }
1182     }
1183
1184     if(g_ESDevConfResource.handle != NULL)
1185     {
1186         res = OCDeleteResource(g_ESDevConfResource.handle);
1187         if (res != OC_STACK_OK)
1188         {
1189             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting DevConf resource error with result: %s", getResult(res));
1190         }
1191     }
1192
1193     if(g_ESProvResource.handle != NULL)
1194     {
1195         res = OCDeleteResource(g_ESProvResource.handle);
1196         if (res != OC_STACK_OK)
1197         {
1198             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting Prov resource error with result: %s", getResult(res));
1199         }
1200     }
1201
1202     return res;
1203 }
1204
1205 OCEntityHandlerResult ProcessGetRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload **payload)
1206 {
1207     OCEntityHandlerResult ehResult = OC_EH_ERROR;
1208     if (!ehRequest)
1209     {
1210         OIC_LOG(ERROR, ES_RH_TAG, "Request is Null");
1211         return ehResult;
1212     }
1213     if (ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
1214     {
1215         OIC_LOG(ERROR, ES_RH_TAG, "Incoming payload not a representation");
1216         return ehResult;
1217     }
1218
1219     OCRepPayload *getResp = NULL;
1220     *payload = NULL;
1221
1222     if(ehRequest->resource == g_ESProvResource.handle)
1223     {
1224         if(ehRequest->query &&
1225             strcmp(ehRequest->query, "") &&
1226             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_LL) &&
1227             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH) &&
1228             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
1229         {
1230             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1231             return OC_EH_BAD_REQ;
1232         }
1233         else
1234         {
1235             getResp = constructResponseOfProv(ehRequest);
1236         }
1237     }
1238     else if(ehRequest->resource == g_ESWiFiResource.handle)
1239     {
1240         if(CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1241         {
1242             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1243             return OC_EH_BAD_REQ;
1244         }
1245         else
1246         {
1247             getResp = constructResponseOfWiFi(OC_RSRVD_INTERFACE_DEFAULT);
1248         }
1249     }
1250     else if(ehRequest->resource == g_ESCloudResource.handle)
1251     {
1252         if(CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1253         {
1254             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1255             return OC_EH_BAD_REQ;
1256         }
1257         else
1258         {
1259             getResp = constructResponseOfCloud(OC_RSRVD_INTERFACE_DEFAULT);
1260         }
1261     }
1262     else if(ehRequest->resource == g_ESDevConfResource.handle)
1263     {
1264         if(CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1265         {
1266             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1267             return OC_EH_BAD_REQ;
1268         }
1269         else
1270         {
1271             getResp = constructResponseOfDevConf(OC_RSRVD_INTERFACE_DEFAULT);
1272         }
1273     }
1274
1275     if (!getResp)
1276     {
1277         OIC_LOG(ERROR, ES_RH_TAG, "constructResponse failed");
1278         return OC_EH_ERROR;
1279     }
1280
1281     *payload = getResp;
1282     ehResult = OC_EH_OK;
1283
1284     return ehResult;
1285 }
1286
1287 OCEntityHandlerResult ProcessPostRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload)
1288 {
1289     OIC_LOG(INFO, ES_RH_TAG, "ProcessPostRequest enter");
1290     OCEntityHandlerResult ehResult = OC_EH_ERROR;
1291     if (ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
1292     {
1293         OIC_LOG(ERROR, ES_RH_TAG, "Incoming payload not a representation");
1294         return ehResult;
1295     }
1296
1297     OCRepPayload* input = (OCRepPayload*) (ehRequest->payload);
1298     if (!input)
1299     {
1300         OIC_LOG(ERROR, ES_RH_TAG, "Failed to parse");
1301         return ehResult;
1302     }
1303
1304     if(ehRequest->resource == g_ESProvResource.handle)
1305     {
1306         if(ehRequest->query &&
1307             strcmp(ehRequest->query, "") &&
1308             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH) &&
1309             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
1310         {
1311             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1312             return OC_EH_BAD_REQ;
1313         }
1314         else
1315         {
1316             updateProvResource(ehRequest, input);
1317         }
1318     }
1319     else if(ehRequest->resource == g_ESWiFiResource.handle)
1320     {
1321         if(CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1322         {
1323             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1324             return OC_EH_BAD_REQ;
1325         }
1326         else
1327         {
1328             updateWiFiResource(input);
1329         }
1330     }
1331     else if(ehRequest->resource == g_ESCloudResource.handle)
1332     {
1333         if(CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1334         {
1335             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1336             return OC_EH_BAD_REQ;
1337         }
1338         else
1339         {
1340             updateCloudResource(input);
1341         }
1342     }
1343     else if(ehRequest->resource == g_ESDevConfResource.handle)
1344     {
1345         if(CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1346         {
1347             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1348             return OC_EH_BAD_REQ;
1349         }
1350         else
1351         {
1352             updateDevConfResource(input);
1353         }
1354     }
1355
1356     OCRepPayload *getResp = NULL;
1357     if(ehRequest->resource == g_ESProvResource.handle)
1358     {
1359         getResp = constructResponseOfProv(ehRequest);
1360     }
1361     else if(ehRequest->resource == g_ESWiFiResource.handle)
1362     {
1363         getResp = constructResponseOfWiFi(OC_RSRVD_INTERFACE_DEFAULT);
1364     }
1365     else if(ehRequest->resource == g_ESCloudResource.handle)
1366     {
1367         getResp = constructResponseOfCloud(OC_RSRVD_INTERFACE_DEFAULT);
1368     }
1369     else if(ehRequest->resource == g_ESDevConfResource.handle)
1370     {
1371         getResp = constructResponseOfDevConf(OC_RSRVD_INTERFACE_DEFAULT);
1372     }
1373
1374     if (!getResp)
1375     {
1376         OIC_LOG(ERROR, ES_RH_TAG, "constructResponse failed");
1377         return OC_EH_ERROR;
1378     }
1379
1380     *payload = getResp;
1381     ehResult = OC_EH_OK;
1382
1383     return ehResult;
1384 }
1385
1386 OCEntityHandlerResult ProcessPutRequest(OCEntityHandlerRequest * ehRequest,
1387         OCRepPayload** payload)
1388 {
1389     (void) ehRequest;
1390     (void) payload;
1391     OCEntityHandlerResult ehResult = OC_EH_BAD_REQ;
1392
1393     return ehResult;
1394 }
1395 /**
1396  * This is the entity handler for the registered resource.
1397  * This is invoked by OCStack whenever it recevies a request for this resource.
1398  */
1399 OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag,
1400         OCEntityHandlerRequest* entityHandlerRequest, void *callback)
1401 {
1402     (void) callback;
1403     OCEntityHandlerResult ehRet = OC_EH_OK;
1404     OCEntityHandlerResponse response =
1405     { 0, 0, OC_EH_ERROR, 0, 0,
1406     { },
1407     { 0 }, false };
1408     OCRepPayload* payload = NULL;
1409
1410     if (entityHandlerRequest && (flag & OC_REQUEST_FLAG))
1411     {
1412         if (OC_REST_GET == entityHandlerRequest->method)
1413         {
1414             OIC_LOG(INFO, ES_RH_TAG, "Received GET request");
1415             ehRet = ProcessGetRequest(entityHandlerRequest, &payload);
1416         }
1417         else if (OC_REST_PUT == entityHandlerRequest->method)
1418         {
1419             OIC_LOG(INFO, ES_RH_TAG, "Received PUT request");
1420
1421             //PUT request will be handled in the internal implementation
1422             if (g_ESProvResource.handle != NULL)
1423             {
1424                 ehRet = ProcessPutRequest(entityHandlerRequest, &payload);
1425             }
1426             else
1427             {
1428                 OIC_LOG(ERROR, ES_RH_TAG, "Cannot process put");
1429                 ehRet = OC_EH_ERROR;
1430             }
1431         }
1432         else if (OC_REST_POST == entityHandlerRequest->method)
1433         {
1434             OIC_LOG(INFO, ES_RH_TAG, "Received OC_REST_POST from client");
1435             if (g_ESProvResource.handle != NULL)
1436             {
1437                 ehRet = ProcessPostRequest(entityHandlerRequest, &payload);
1438             }
1439             else
1440             {
1441                 OIC_LOG(ERROR, ES_RH_TAG, "Cannot process put");
1442                 ehRet = OC_EH_ERROR;
1443             }
1444         }
1445
1446         // Format the response.  Note this requires some info about the request
1447         response.requestHandle = entityHandlerRequest->requestHandle;
1448         response.resourceHandle = entityHandlerRequest->resource;
1449         response.ehResult = ehRet;
1450         //response uses OCPaylod while all get,put methodes use OCRepPayload
1451         response.payload = (OCPayload*) (payload);
1452         response.numSendVendorSpecificHeaderOptions = 0;
1453         memset(response.sendVendorSpecificHeaderOptions, 0,
1454                 sizeof(response.sendVendorSpecificHeaderOptions));
1455         memset(response.resourceUri, 0, sizeof(response.resourceUri));
1456         // Indicate that response is NOT in a persistent buffer
1457         response.persistentBufferFlag = 0;
1458
1459         // Send the response
1460         if (OCDoResponse(&response) != OC_STACK_OK)
1461         {
1462             OIC_LOG(ERROR, ES_RH_TAG, "Error sending response");
1463             ehRet = OC_EH_ERROR;
1464         }
1465     }
1466     if (entityHandlerRequest && (flag & OC_OBSERVE_FLAG))
1467     {
1468         OIC_LOG(INFO, ES_RH_TAG, "Flag includes OC_OBSERVE_FLAG");
1469
1470         if (OC_OBSERVE_REGISTER == entityHandlerRequest->obsInfo.action)
1471         {
1472             OIC_LOG (INFO, ES_RH_TAG, "Received OC_OBSERVE_REGISTER from Mediator");
1473         }
1474         else if (OC_OBSERVE_DEREGISTER == entityHandlerRequest->obsInfo.action)
1475         {
1476             OIC_LOG (INFO, ES_RH_TAG, "Received OC_OBSERVE_DEREGISTER from Mediator");
1477         }
1478     }
1479     return ehRet;
1480 }
1481
1482 OCStackResult SetDeviceProperty(ESDeviceProperty *deviceProperty)
1483 {
1484     OIC_LOG(INFO, ES_RH_TAG, "SetDeviceProperty IN");
1485
1486     g_ESWiFiResource.supportedFreq = (deviceProperty->WiFi).freq;
1487     OIC_LOG_V(INFO, ES_RH_TAG, "WiFi Freq : %d", g_ESWiFiResource.supportedFreq);
1488
1489     int modeIdx = 0;
1490     while((deviceProperty->WiFi).mode[modeIdx] != WiFi_EOF)
1491     {
1492         g_ESWiFiResource.supportedMode[modeIdx] = (deviceProperty->WiFi).mode[modeIdx];
1493         OIC_LOG_V(INFO, ES_RH_TAG, "WiFi Mode : %d", g_ESWiFiResource.supportedMode[modeIdx]);
1494         modeIdx ++;
1495     }
1496     g_ESWiFiResource.numMode = modeIdx;
1497
1498     OICStrcpy(g_ESDevConfResource.devName, OIC_STRING_MAX_VALUE, (deviceProperty->DevConf).deviceName);
1499     OIC_LOG_V(INFO, ES_RH_TAG, "Device Name : %s", g_ESDevConfResource.devName);
1500
1501     OICStrcpy(g_ESDevConfResource.modelNumber, OIC_STRING_MAX_VALUE,
1502                                                             (deviceProperty->DevConf).modelNumber);
1503     OIC_LOG_V(INFO, ES_RH_TAG, "Model Number : %s", g_ESDevConfResource.modelNumber);
1504
1505     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESWiFiResource.handle, OC_HIGH_QOS))
1506     {
1507         OIC_LOG(INFO, ES_RH_TAG, "wifiResource doesn't have any observers.");
1508     }
1509
1510     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESDevConfResource.handle, OC_HIGH_QOS))
1511     {
1512         OIC_LOG(INFO, ES_RH_TAG, "devConfResource doesn't have any observers.");
1513     }
1514
1515     OIC_LOG(INFO, ES_RH_TAG, "SetDeviceProperty OUT");
1516     return OC_STACK_OK;
1517 }
1518
1519 OCStackResult SetEnrolleeState(ESEnrolleeState esState)
1520 {
1521     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeState IN");
1522
1523     g_ESProvResource.status = esState;
1524     OIC_LOG_V(INFO, ES_RH_TAG, "Enrollee Status : %d", g_ESProvResource.status);
1525
1526     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESProvResource.handle, OC_HIGH_QOS))
1527     {
1528         OIC_LOG(INFO, ES_RH_TAG, "provResource doesn't have any observers.");
1529     }
1530
1531     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeState OUT");
1532     return OC_STACK_OK;
1533 }
1534
1535 OCStackResult SetEnrolleeErrCode(ESErrorCode esErrCode)
1536 {
1537     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeErrCode IN");
1538
1539     g_ESProvResource.lastErrCode = esErrCode;
1540     OIC_LOG_V(INFO, ES_RH_TAG, "Enrollee ErrorCode : %d", g_ESProvResource.lastErrCode);
1541
1542     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESProvResource.handle, OC_HIGH_QOS))
1543     {
1544         OIC_LOG(INFO, ES_RH_TAG, "provResource doesn't have any observers.");
1545     }
1546
1547     OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeErrCode OUT");
1548     return OC_STACK_OK;
1549 }
1550
1551 OCEntityHandlerResult CheckEhRequestPayload(OCEntityHandlerRequest *ehRequest)
1552 {
1553     if( !(ehRequest->query) ||
1554                 (ehRequest->query &&
1555                 (strcmp(ehRequest->query, "") && !CompareResourceInterface(ehRequest->query,
1556                                                                         OC_RSRVD_INTERFACE_DEFAULT))))
1557     {
1558         OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1559         return OC_EH_BAD_REQ;
1560     }
1561     return OC_EH_OK;
1562 }
1563
1564 const char *getResult(OCStackResult result)
1565 {
1566     switch (result)
1567     {
1568         case OC_STACK_OK:
1569             return "OC_STACK_OK";
1570         case OC_STACK_INVALID_URI:
1571             return "OC_STACK_INVALID_URI";
1572         case OC_STACK_INVALID_QUERY:
1573             return "OC_STACK_INVALID_QUERY";
1574         case OC_STACK_INVALID_IP:
1575             return "OC_STACK_INVALID_IP";
1576         case OC_STACK_INVALID_PORT:
1577             return "OC_STACK_INVALID_PORT";
1578         case OC_STACK_INVALID_CALLBACK:
1579             return "OC_STACK_INVALID_CALLBACK";
1580         case OC_STACK_INVALID_METHOD:
1581             return "OC_STACK_INVALID_METHOD";
1582         case OC_STACK_NO_MEMORY:
1583             return "OC_STACK_NO_MEMORY";
1584         case OC_STACK_COMM_ERROR:
1585             return "OC_STACK_COMM_ERROR";
1586         case OC_STACK_INVALID_PARAM:
1587             return "OC_STACK_INVALID_PARAM";
1588         case OC_STACK_NOTIMPL:
1589             return "OC_STACK_NOTIMPL";
1590         case OC_STACK_NO_RESOURCE:
1591             return "OC_STACK_NO_RESOURCE";
1592         case OC_STACK_RESOURCE_ERROR:
1593             return "OC_STACK_RESOURCE_ERROR";
1594         case OC_STACK_SLOW_RESOURCE:
1595             return "OC_STACK_SLOW_RESOURCE";
1596         case OC_STACK_NO_OBSERVERS:
1597             return "OC_STACK_NO_OBSERVERS";
1598         case OC_STACK_ERROR:
1599             return "OC_STACK_ERROR";
1600         default:
1601             return "UNKNOWN";
1602     }
1603 }