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