Update all of easysetup log message's level
[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_ESEasySetupResource
39  * @brief Structure for holding the Provisioning status
40  */
41 EasySetupResource g_ESEasySetupResource;
42 WiFiConfResource g_ESWiFiConfResource;
43 CoapCloudConfResource g_ESCoapCloudConfResource;
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 updateEasySetupResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input);
55 void updateWiFiConfResource(OCRepPayload* input);
56 void updateCoapCloudConfResource(OCRepPayload* input);
57 void updateDevConfResource(OCRepPayload* input);
58 const char *getResult(OCStackResult result);
59
60 ESWiFiConfCB gWifiConfRsrcEvtCb = NULL;
61 ESCoapCloudConfCB gCoapCloudConfRsrcEvtCb = 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(DEBUG, 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(ESWiFiConfCB cb)
109 {
110     gWifiConfRsrcEvtCb = cb;
111 }
112
113 void RegisterCloudRsrcEventCallBack(ESCoapCloudConfCB cb)
114 {
115     gCoapCloudConfRsrcEvtCb = cb;
116 }
117
118 void RegisterDevConfRsrcEventCallBack(ESDevConfCB cb)
119 {
120     gDevConfRsrcEvtCb = cb;
121 }
122
123 void UnRegisterResourceEventCallBack()
124 {
125     if (gWifiConfRsrcEvtCb)
126     {
127         gWifiConfRsrcEvtCb = NULL;
128     }
129     if (gCoapCloudConfRsrcEvtCb)
130     {
131         gCoapCloudConfRsrcEvtCb = NULL;
132     }
133     if (gDevConfRsrcEvtCb)
134     {
135         gDevConfRsrcEvtCb = NULL;
136     }
137 }
138
139 OCStackResult initEasySetupResource(bool isSecured)
140 {
141     g_ESEasySetupResource.status = ES_STATE_INIT;
142     g_ESEasySetupResource.lastErrCode = ES_ERRCODE_NO_ERROR;
143
144     OCStackResult res = OC_STACK_ERROR;
145     if (isSecured)
146     {
147         res = OCCreateResource(&g_ESEasySetupResource.handle, OC_RSRVD_ES_RES_TYPE_EASYSETUP,
148         OC_RSRVD_INTERFACE_DEFAULT,
149         OC_RSRVD_ES_URI_EASYSETUP, OCEntityHandlerCb,
150         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
151     }else
152     {
153         res = OCCreateResource(&g_ESEasySetupResource.handle, OC_RSRVD_ES_RES_TYPE_EASYSETUP,
154         OC_RSRVD_INTERFACE_DEFAULT,
155         OC_RSRVD_ES_URI_EASYSETUP, OCEntityHandlerCb,
156         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
157     }
158     if(res != OC_STACK_OK)
159     {
160         OIC_LOG_V(ERROR, ES_RH_TAG, "Created EasySetup resource with result: %s", getResult(res));
161         return res;
162     }
163
164     res = OCBindResourceTypeToResource(g_ESEasySetupResource.handle, OC_RSRVD_ES_RES_TYPE_COL);
165     if(res != OC_STACK_OK)
166     {
167         OIC_LOG_V(ERROR, ES_RH_TAG, "Binding Resource type with result: %s", getResult(res));
168         return res;
169     }
170
171     res = OCBindResourceInterfaceToResource(g_ESEasySetupResource.handle, OC_RSRVD_INTERFACE_LL);
172     if(res != OC_STACK_OK)
173     {
174         OIC_LOG_V(ERROR, ES_RH_TAG, "Binding Resource interface with result: %s", getResult(res));
175         return res;
176     }
177     res = OCBindResourceInterfaceToResource(g_ESEasySetupResource.handle, OC_RSRVD_INTERFACE_BATCH);
178     if(res != OC_STACK_OK)
179     {
180         OIC_LOG_V(ERROR, ES_RH_TAG, "Binding Resource interface with result: %s", getResult(res));
181         return res;
182     }
183
184     OIC_LOG_V(DEBUG, ES_RH_TAG, "Created EasySetup resource with result: %s", getResult(res));
185     return res;
186 }
187
188 OCStackResult initWiFiConfResource(bool isSecured)
189 {
190     OCStackResult res = OC_STACK_ERROR;
191
192     g_ESWiFiConfResource.supportedFreq = WIFI_BOTH;
193     g_ESWiFiConfResource.supportedMode[0] = WIFI_11A;
194     g_ESWiFiConfResource.supportedMode[1] = WIFI_11B;
195     g_ESWiFiConfResource.supportedMode[2] = WIFI_11G;
196     g_ESWiFiConfResource.supportedMode[3] = WIFI_11N;
197     g_ESWiFiConfResource.numMode = 4;
198     g_ESWiFiConfResource.authType = NONE_AUTH;
199     g_ESWiFiConfResource.encType = NONE_ENC;
200     OICStrcpy(g_ESWiFiConfResource.ssid, sizeof(g_ESWiFiConfResource.ssid), "");
201     OICStrcpy(g_ESWiFiConfResource.cred, sizeof(g_ESWiFiConfResource.cred), "");
202
203     if (isSecured)
204     {
205         res = OCCreateResource(&g_ESWiFiConfResource.handle, OC_RSRVD_ES_RES_TYPE_WIFICONF,
206         OC_RSRVD_INTERFACE_DEFAULT,
207         OC_RSRVD_ES_URI_WIFICONF, OCEntityHandlerCb,
208         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
209     }else
210     {
211         res = OCCreateResource(&g_ESWiFiConfResource.handle, OC_RSRVD_ES_RES_TYPE_WIFICONF,
212         OC_RSRVD_INTERFACE_DEFAULT,
213         OC_RSRVD_ES_URI_WIFICONF, OCEntityHandlerCb,
214         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
215     }
216
217     OIC_LOG_V(DEBUG, ES_RH_TAG, "Created WiFiConf resource with result: %s", getResult(res));
218     return res;
219
220 }
221
222 OCStackResult initCoapCloudConfResource(bool isSecured)
223 {
224     OCStackResult res = OC_STACK_ERROR;
225
226     OICStrcpy(g_ESCoapCloudConfResource.authCode, sizeof(g_ESCoapCloudConfResource.authCode), "");
227     OICStrcpy(g_ESCoapCloudConfResource.accessToken, sizeof(g_ESCoapCloudConfResource.accessToken), "");
228     g_ESCoapCloudConfResource.accessTokenType = NONE_OAUTH_TOKENTYPE;
229     OICStrcpy(g_ESCoapCloudConfResource.authProvider, sizeof(g_ESCoapCloudConfResource.authProvider), "");
230     OICStrcpy(g_ESCoapCloudConfResource.ciServer, sizeof(g_ESCoapCloudConfResource.ciServer), "");
231
232     if (isSecured)
233     {
234         res = OCCreateResource(&g_ESCoapCloudConfResource.handle, OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF,
235         OC_RSRVD_INTERFACE_DEFAULT,
236         OC_RSRVD_ES_URI_COAPCLOUDCONF, OCEntityHandlerCb,
237         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
238     }else
239     {
240         res = OCCreateResource(&g_ESCoapCloudConfResource.handle, OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF,
241         OC_RSRVD_INTERFACE_DEFAULT,
242         OC_RSRVD_ES_URI_COAPCLOUDCONF, OCEntityHandlerCb,
243         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
244     }
245
246     OIC_LOG_V(DEBUG, ES_RH_TAG, "Created CoapCloudConf 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(DEBUG, ES_RH_TAG, "Created DevConf resource with result: %s", getResult(res));
276     return res;
277
278 }
279
280 void updateEasySetupResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input)
281 {
282     OIC_LOG_V(DEBUG, ES_RH_TAG, "g_ESEasySetupResource.status %d", g_ESEasySetupResource.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             updateCoapCloudConfResource(input);
290             updateWiFiConfResource(input);
291             updateDevConfResource(input);
292         }
293     }
294 }
295
296 void updateWiFiConfResource(OCRepPayload* input)
297 {
298     ESWiFiConfData* wiFiData = (ESWiFiConfData*)OICMalloc(sizeof(ESWiFiConfData));
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_ESWiFiConfResource.ssid, sizeof(g_ESWiFiConfResource.ssid), ssid);
316         OICStrcpy(wiFiData->ssid, sizeof(wiFiData->ssid), ssid);
317         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESWiFiConfResource.ssid : %s", g_ESWiFiConfResource.ssid);
318     }
319
320     char* cred = NULL;
321     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CRED, &cred))
322     {
323         OICStrcpy(g_ESWiFiConfResource.cred, sizeof(g_ESWiFiConfResource.cred), cred);
324         OICStrcpy(wiFiData->pwd, sizeof(wiFiData->pwd), cred);
325         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESWiFiConfResource.cred %s", g_ESWiFiConfResource.cred);
326     }
327
328     int64_t authType = -1;
329     if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_AUTHTYPE, &authType))
330     {
331         g_ESWiFiConfResource.authType = authType;
332         wiFiData->authtype = g_ESWiFiConfResource.authType;
333         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESWiFiConfResource.authType %u", g_ESWiFiConfResource.authType);
334     }
335
336     int64_t encType = -1;
337     if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_ENCTYPE, &encType))
338     {
339         g_ESWiFiConfResource.encType = encType;
340         wiFiData->enctype = g_ESWiFiConfResource.encType;
341         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESWiFiConfResource.encType %u", g_ESWiFiConfResource.encType);
342     }
343
344     if(gReadUserdataCb)
345     {
346         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_WIFICONF, &wiFiData->userdata);
347     }
348
349     if(ssid || cred || authType!= -1 || encType != -1)
350     {
351         OIC_LOG(DEBUG, ES_RH_TAG, "Send WiFiConfRsrc Callback To ES");
352
353         // TODO : Need to check appropriateness of gWiFiData
354         if(gWifiConfRsrcEvtCb != NULL)
355         {
356             gWifiConfRsrcEvtCb(ES_OK, wiFiData);
357         }
358         else
359         {
360             OIC_LOG(ERROR, ES_RH_TAG, "gWifiConfRsrcEvtCb is NULL");
361         }
362     }
363
364     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESWiFiConfResource.handle, OC_HIGH_QOS))
365     {
366         OIC_LOG(DEBUG, ES_RH_TAG, "Enrollee doesn't have any observer.");
367     }
368
369     OICFree(wiFiData);
370 }
371
372 void updateCoapCloudConfResource(OCRepPayload* input)
373 {
374     ESCoapCloudConfData* cloudData = (ESCoapCloudConfData*)OICMalloc(sizeof(ESCoapCloudConfData));
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_ESCoapCloudConfResource.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_ESCoapCloudConfResource.authCode, sizeof(g_ESCoapCloudConfResource.authCode), authCode);
393         OICStrcpy(cloudData->authCode, sizeof(cloudData->authCode), authCode);
394         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESCoapCloudConfResource.authCode %s", g_ESCoapCloudConfResource.authCode);
395     }
396
397     char *accessToken = NULL;
398     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_ACCESSTOKEN, &accessToken))
399     {
400         OICStrcpy(g_ESCoapCloudConfResource.accessToken, sizeof(g_ESCoapCloudConfResource.accessToken), accessToken);
401         OICStrcpy(cloudData->accessToken, sizeof(cloudData->accessToken), accessToken);
402         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESCoapCloudConfResource.accessToken %s", g_ESCoapCloudConfResource.accessToken);
403     }
404
405     int64_t accessTokenType = -1;
406     if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_ACCESSTOKEN_TYPE, &accessTokenType))
407     {
408         g_ESCoapCloudConfResource.accessTokenType = accessTokenType;
409         cloudData->accessTokenType = g_ESCoapCloudConfResource.accessTokenType;
410         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESCoapCloudConfResource.accessTokenType %d", g_ESCoapCloudConfResource.accessTokenType);
411     }
412
413     char *authProvider = NULL;
414     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_AUTHPROVIDER, &authProvider))
415     {
416         OICStrcpy(g_ESCoapCloudConfResource.authProvider, sizeof(g_ESCoapCloudConfResource.authProvider), authProvider);
417         OICStrcpy(cloudData->authProvider, sizeof(cloudData->authProvider), authProvider);
418         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESCoapCloudConfResource.authServerUrl %s", g_ESCoapCloudConfResource.authProvider);
419     }
420
421     char *ciServer = NULL;
422     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CISERVER, &ciServer))
423     {
424         OICStrcpy(g_ESCoapCloudConfResource.ciServer, sizeof(g_ESCoapCloudConfResource.ciServer), ciServer);
425         OICStrcpy(cloudData->ciServer, sizeof(cloudData->ciServer), ciServer);
426         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESCoapCloudConfResource.ciServer %s", g_ESCoapCloudConfResource.ciServer);
427     }
428
429     if(gReadUserdataCb)
430     {
431         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF, &cloudData->userdata);
432     }
433
434     if(authCode || accessToken || authProvider || ciServer)
435     {
436         OIC_LOG(DEBUG, ES_RH_TAG, "Send CoapCloudConfRsrc Callback To ES");
437
438         // TODO : Need to check appropriateness of gCloudData
439         if(gCoapCloudConfRsrcEvtCb != NULL)
440         {
441             gCoapCloudConfRsrcEvtCb(ES_OK, cloudData);
442         }
443         else
444         {
445             OIC_LOG(DEBUG, ES_RH_TAG, "gCoapCloudConfRsrcEvtCb is NULL");
446         }
447     }
448
449     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESCoapCloudConfResource.handle, OC_HIGH_QOS))
450     {
451         OIC_LOG(DEBUG, ES_RH_TAG, "CoapCloudConf resource doesn't have any observer.");
452     }
453
454     OICFree(cloudData);
455 }
456
457 void updateDevConfResource(OCRepPayload* input)
458 {
459     ESDevConfData* devConfData = (ESDevConfData*)OICMalloc(sizeof(ESDevConfData));
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_PRIVATE, 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_PRIVATE, 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_PRIVATE, 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(DEBUG, 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(DEBUG, 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(DEBUG, ES_RH_TAG, "devConfResource doesn't have any observer.");
517     }
518
519     OICFree(devConfData);
520 }
521
522 OCRepPayload* constructResponseOfWiFiConf(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_ESWiFiConfResource.handle == NULL)
532     {
533         OIC_LOG(ERROR, ES_RH_TAG, "WiFiConf resource is not created");
534         return NULL;
535     }
536
537     OIC_LOG(DEBUG, ES_RH_TAG, "constructResponse WiFiConf res");
538     OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_WIFICONF);
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_WIFICONF);
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_WIFICONF);
572     }
573
574     size_t dimensions[MAX_REP_ARRAY_DEPTH] = {g_ESWiFiConfResource.numMode, 0, 0};
575     int64_t *modes_64 = (int64_t *)OICMalloc(g_ESWiFiConfResource.numMode * sizeof(int64_t));
576     for(int i = 0 ; i < g_ESWiFiConfResource.numMode ; ++i)
577     {
578         modes_64[i] = g_ESWiFiConfResource.supportedMode[i];
579     }
580     OCRepPayloadSetIntArray(payload, OC_RSRVD_ES_SUPPORTEDWIFIMODE, (int64_t *)modes_64, dimensions);
581
582     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_SUPPORTEDWIFIFREQ, g_ESWiFiConfResource.supportedFreq);
583     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_SSID, g_ESWiFiConfResource.ssid);
584     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CRED, g_ESWiFiConfResource.cred);
585     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_AUTHTYPE, (int) g_ESWiFiConfResource.authType);
586     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_ENCTYPE, (int) g_ESWiFiConfResource.encType);
587
588     if(gWriteUserdataCb)
589     {
590         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_WIFICONF);
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* constructResponseOfCoapCloudConf(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_ESCoapCloudConfResource.handle == NULL)
612     {
613         OIC_LOG(ERROR, ES_RH_TAG, "CoapCloudConf resource is not created");
614         return NULL;
615     }
616
617     OIC_LOG(DEBUG, ES_RH_TAG, "constructResponse CoapCloudConf res");
618     OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_COAPCLOUDCONF);
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_COAPCLOUDCONF);
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_COAPCLOUDCONF);
652     }
653
654     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_AUTHCODE, g_ESCoapCloudConfResource.authCode);
655     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_ACCESSTOKEN, g_ESCoapCloudConfResource.accessToken);
656     OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_ACCESSTOKEN_TYPE, (int)g_ESCoapCloudConfResource.accessTokenType);
657     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_AUTHPROVIDER, g_ESCoapCloudConfResource.authProvider);
658     OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CISERVER, g_ESCoapCloudConfResource.ciServer);
659
660     if(gWriteUserdataCb)
661     {
662         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF);
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(DEBUG, 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* constructResponseOfEasySetup(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_ESWiFiConfResource.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_WIFICONF);
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_WIFICONF);
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_ESWiFiConfResource.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_ESCoapCloudConfResource.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_COAPCLOUDCONF);
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_COAPCLOUDCONF);
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_ESCoapCloudConfResource.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(DEBUG, ES_RH_TAG, "constructResponse EasySetup res");
935             OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_EASYSETUP);
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_EASYSETUP);
940             OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_COL);
941
942             OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_PROVSTATUS, g_ESEasySetupResource.status);
943             OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_LAST_ERRORCODE, g_ESEasySetupResource.lastErrCode);
944
945             if(gWriteUserdataCb)
946             {
947                 gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_EASYSETUP);
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(DEBUG, ES_RH_TAG, "constructResponse EasySetup res");
961         OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_EASYSETUP);
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_EASYSETUP);
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_ESEasySetupResource.status);
1000         OCRepPayloadSetPropInt(repPayload, OC_RSRVD_ES_LAST_ERRORCODE, g_ESEasySetupResource.lastErrCode);
1001
1002         if(gWriteUserdataCb)
1003         {
1004             gWriteUserdataCb(repPayload, OC_RSRVD_ES_RES_TYPE_EASYSETUP);
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 = constructResponseOfWiFiConf(OC_RSRVD_INTERFACE_BATCH);
1018             if(nextPayload != NULL)
1019             {
1020                 payload->next = nextPayload;
1021                 payload = payload->next;
1022             }
1023
1024             nextPayload = constructResponseOfCoapCloudConf(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 = initEasySetupResource(isSecured);
1051     if(res != OC_STACK_OK)
1052     {
1053         // TODO: destroy logic will be added
1054         OIC_LOG_V(ERROR, ES_RH_TAG, "initEasySetupResource result: %s", getResult(res));
1055
1056         return res;
1057     }
1058
1059     if((resourceMask & ES_WIFICONF_RESOURCE) == ES_WIFICONF_RESOURCE)
1060     {
1061         maskFlag = true;
1062         res = initWiFiConfResource(isSecured);
1063         if(res != OC_STACK_OK)
1064         {
1065             OIC_LOG_V(ERROR, ES_RH_TAG, "initWiFiConfResource result: %s", getResult(res));
1066             return res;
1067         }
1068
1069         res = OCBindResource(g_ESEasySetupResource.handle, g_ESWiFiConfResource.handle);
1070         if(res != OC_STACK_OK)
1071         {
1072             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind WiFiConfResource result: %s", getResult(res));
1073             return res;
1074         }
1075
1076     }
1077
1078     if((resourceMask & ES_COAPCLOUDCONF_RESOURCE) == ES_COAPCLOUDCONF_RESOURCE)
1079     {
1080         maskFlag = true;
1081         res = initCoapCloudConfResource(isSecured);
1082         if(res != OC_STACK_OK)
1083         {
1084             OIC_LOG_V(ERROR, ES_RH_TAG, "initCoapCloudConfResource result: %s", getResult(res));
1085             return res;
1086         }
1087
1088         res = OCBindResource(g_ESEasySetupResource.handle, g_ESCoapCloudConfResource.handle);
1089         if(res != OC_STACK_OK)
1090         {
1091             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind CoapCloudConfResource 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_ESEasySetupResource.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     if(maskFlag == false)
1115     {
1116         OIC_LOG_V(ERROR, ES_RH_TAG, "Invalid ResourceMask");
1117         return OC_STACK_ERROR;
1118
1119     }
1120
1121     OIC_LOG_V(DEBUG, ES_RH_TAG, "Created all resources with result: %s", getResult(res));
1122
1123     return res;
1124 }
1125
1126 OCStackResult DeleteEasySetupResources()
1127 {
1128     OCStackResult res = OC_STACK_ERROR;
1129     if (g_ESWiFiConfResource.handle != NULL)
1130     {
1131         res = OCUnBindResource(g_ESEasySetupResource.handle, g_ESWiFiConfResource.handle);
1132         if(res != OC_STACK_OK)
1133         {
1134             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind WiFi resource error with result: %s", getResult(res));
1135         }
1136     }
1137     if (g_ESCoapCloudConfResource.handle != NULL)
1138     {
1139         res = OCUnBindResource(g_ESEasySetupResource.handle, g_ESCoapCloudConfResource.handle);
1140         if(res != OC_STACK_OK)
1141         {
1142             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind CloudServer resource error with result: %s", getResult(res));
1143         }
1144     }
1145     if (g_ESDevConfResource.handle != NULL)
1146     {
1147         res = OCUnBindResource(g_ESEasySetupResource.handle, g_ESDevConfResource.handle);
1148         if(res != OC_STACK_OK)
1149         {
1150             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind DevConf resource error with result: %s", getResult(res));
1151         }
1152     }
1153
1154     if (g_ESWiFiConfResource.handle != NULL)
1155     {
1156         res = OCDeleteResource(g_ESWiFiConfResource.handle);
1157         if (res != OC_STACK_OK)
1158         {
1159             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting WiFi resource error with result: %s", getResult(res));
1160         }
1161     }
1162
1163     if(g_ESCoapCloudConfResource.handle != NULL)
1164     {
1165         res = OCDeleteResource(g_ESCoapCloudConfResource.handle);
1166         if (res != OC_STACK_OK)
1167         {
1168             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting CloudServer resource error with result: %s", getResult(res));
1169         }
1170     }
1171
1172     if(g_ESDevConfResource.handle != NULL)
1173     {
1174         res = OCDeleteResource(g_ESDevConfResource.handle);
1175         if (res != OC_STACK_OK)
1176         {
1177             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting DevConf resource error with result: %s", getResult(res));
1178         }
1179     }
1180
1181     if(g_ESEasySetupResource.handle != NULL)
1182     {
1183         res = OCDeleteResource(g_ESEasySetupResource.handle);
1184         if (res != OC_STACK_OK)
1185         {
1186             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting Prov resource error with result: %s", getResult(res));
1187         }
1188     }
1189
1190     return res;
1191 }
1192
1193 OCEntityHandlerResult ProcessGetRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload **payload)
1194 {
1195     OCEntityHandlerResult ehResult = OC_EH_ERROR;
1196     if (!ehRequest)
1197     {
1198         OIC_LOG(ERROR, ES_RH_TAG, "Request is Null");
1199         return ehResult;
1200     }
1201     if (ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
1202     {
1203         OIC_LOG(ERROR, ES_RH_TAG, "Incoming payload not a representation");
1204         return ehResult;
1205     }
1206
1207     OCRepPayload *getResp = NULL;
1208     *payload = NULL;
1209
1210     if(ehRequest->resource == g_ESEasySetupResource.handle)
1211     {
1212         if(ehRequest->query &&
1213             strcmp(ehRequest->query, "") &&
1214             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_LL) &&
1215             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH) &&
1216             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
1217         {
1218             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1219             return OC_EH_BAD_REQ;
1220         }
1221         else
1222         {
1223             getResp = constructResponseOfEasySetup(ehRequest);
1224         }
1225     }
1226     else if(ehRequest->resource == g_ESWiFiConfResource.handle)
1227     {
1228         if(CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1229         {
1230             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1231             return OC_EH_BAD_REQ;
1232         }
1233         else
1234         {
1235             getResp = constructResponseOfWiFiConf(OC_RSRVD_INTERFACE_DEFAULT);
1236         }
1237     }
1238     else if(ehRequest->resource == g_ESCoapCloudConfResource.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 = constructResponseOfCoapCloudConf(OC_RSRVD_INTERFACE_DEFAULT);
1248         }
1249     }
1250     else if(ehRequest->resource == g_ESDevConfResource.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 = constructResponseOfDevConf(OC_RSRVD_INTERFACE_DEFAULT);
1260         }
1261     }
1262
1263     if (!getResp)
1264     {
1265         OIC_LOG(ERROR, ES_RH_TAG, "constructResponse failed");
1266         return OC_EH_ERROR;
1267     }
1268
1269     *payload = getResp;
1270     ehResult = OC_EH_OK;
1271
1272     return ehResult;
1273 }
1274
1275 OCEntityHandlerResult ProcessPostRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload)
1276 {
1277     OIC_LOG(DEBUG, ES_RH_TAG, "ProcessPostRequest enter");
1278     OCEntityHandlerResult ehResult = OC_EH_ERROR;
1279     if (ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
1280     {
1281         OIC_LOG(ERROR, ES_RH_TAG, "Incoming payload not a representation");
1282         return ehResult;
1283     }
1284
1285     OCRepPayload* input = (OCRepPayload*) (ehRequest->payload);
1286     if (!input)
1287     {
1288         OIC_LOG(ERROR, ES_RH_TAG, "Failed to parse");
1289         return ehResult;
1290     }
1291
1292     if(ehRequest->resource == g_ESEasySetupResource.handle)
1293     {
1294         if(ehRequest->query &&
1295             strcmp(ehRequest->query, "") &&
1296             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH) &&
1297             !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
1298         {
1299             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1300             return OC_EH_BAD_REQ;
1301         }
1302         else
1303         {
1304             updateEasySetupResource(ehRequest, input);
1305         }
1306     }
1307     else if(ehRequest->resource == g_ESWiFiConfResource.handle)
1308     {
1309         if(CheckEhRequestPayload(ehRequest) != OC_EH_OK)
1310         {
1311             OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1312             return OC_EH_BAD_REQ;
1313         }
1314         else
1315         {
1316             updateWiFiConfResource(input);
1317         }
1318     }
1319     else if(ehRequest->resource == g_ESCoapCloudConfResource.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             updateCoapCloudConfResource(input);
1329         }
1330     }
1331     else if(ehRequest->resource == g_ESDevConfResource.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             updateDevConfResource(input);
1341         }
1342     }
1343
1344     OCRepPayload *getResp = NULL;
1345     if(ehRequest->resource == g_ESEasySetupResource.handle)
1346     {
1347         getResp = constructResponseOfEasySetup(ehRequest);
1348     }
1349     else if(ehRequest->resource == g_ESWiFiConfResource.handle)
1350     {
1351         getResp = constructResponseOfWiFiConf(OC_RSRVD_INTERFACE_DEFAULT);
1352     }
1353     else if(ehRequest->resource == g_ESCoapCloudConfResource.handle)
1354     {
1355         getResp = constructResponseOfCoapCloudConf(OC_RSRVD_INTERFACE_DEFAULT);
1356     }
1357     else if(ehRequest->resource == g_ESDevConfResource.handle)
1358     {
1359         getResp = constructResponseOfDevConf(OC_RSRVD_INTERFACE_DEFAULT);
1360     }
1361
1362     if (!getResp)
1363     {
1364         OIC_LOG(ERROR, ES_RH_TAG, "constructResponse failed");
1365         return OC_EH_ERROR;
1366     }
1367
1368     *payload = getResp;
1369     ehResult = OC_EH_OK;
1370
1371     return ehResult;
1372 }
1373
1374 OCEntityHandlerResult ProcessPutRequest(OCEntityHandlerRequest * ehRequest,
1375         OCRepPayload** payload)
1376 {
1377     (void) ehRequest;
1378     (void) payload;
1379     OCEntityHandlerResult ehResult = OC_EH_BAD_REQ;
1380
1381     return ehResult;
1382 }
1383 /**
1384  * This is the entity handler for the registered resource.
1385  * This is invoked by OCStack whenever it recevies a request for this resource.
1386  */
1387 OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag,
1388         OCEntityHandlerRequest* entityHandlerRequest, void *callback)
1389 {
1390     (void) callback;
1391     OCEntityHandlerResult ehRet = OC_EH_OK;
1392     OCEntityHandlerResponse response =
1393     { 0, 0, OC_EH_ERROR, 0, 0,
1394     { },
1395     { 0 }, false };
1396     OCRepPayload* payload = NULL;
1397
1398     if (entityHandlerRequest && (flag & OC_REQUEST_FLAG))
1399     {
1400         if (OC_REST_GET == entityHandlerRequest->method)
1401         {
1402             OIC_LOG(DEBUG, ES_RH_TAG, "Received GET request");
1403             ehRet = ProcessGetRequest(entityHandlerRequest, &payload);
1404         }
1405         else if (OC_REST_PUT == entityHandlerRequest->method)
1406         {
1407             OIC_LOG(DEBUG, ES_RH_TAG, "Received PUT request");
1408
1409             //PUT request will be handled in the internal implementation
1410             if (g_ESEasySetupResource.handle != NULL)
1411             {
1412                 ehRet = ProcessPutRequest(entityHandlerRequest, &payload);
1413             }
1414             else
1415             {
1416                 OIC_LOG(ERROR, ES_RH_TAG, "Cannot process put");
1417                 ehRet = OC_EH_ERROR;
1418             }
1419         }
1420         else if (OC_REST_POST == entityHandlerRequest->method)
1421         {
1422             OIC_LOG(DEBUG, ES_RH_TAG, "Received OC_REST_POST from client");
1423             if (g_ESEasySetupResource.handle != NULL)
1424             {
1425                 ehRet = ProcessPostRequest(entityHandlerRequest, &payload);
1426             }
1427             else
1428             {
1429                 OIC_LOG(ERROR, ES_RH_TAG, "Cannot process put");
1430                 ehRet = OC_EH_ERROR;
1431             }
1432         }
1433
1434         // Format the response.  Note this requires some info about the request
1435         response.requestHandle = entityHandlerRequest->requestHandle;
1436         response.resourceHandle = entityHandlerRequest->resource;
1437         response.ehResult = ehRet;
1438         //response uses OCPaylod while all get,put methodes use OCRepPayload
1439         response.payload = (OCPayload*) (payload);
1440         response.numSendVendorSpecificHeaderOptions = 0;
1441         memset(response.sendVendorSpecificHeaderOptions, 0,
1442                 sizeof(response.sendVendorSpecificHeaderOptions));
1443         memset(response.resourceUri, 0, sizeof(response.resourceUri));
1444         // Indicate that response is NOT in a persistent buffer
1445         response.persistentBufferFlag = 0;
1446
1447         // Send the response
1448         if (OCDoResponse(&response) != OC_STACK_OK)
1449         {
1450             OIC_LOG(ERROR, ES_RH_TAG, "Error sending response");
1451             ehRet = OC_EH_ERROR;
1452         }
1453     }
1454     if (entityHandlerRequest && (flag & OC_OBSERVE_FLAG))
1455     {
1456         OIC_LOG(DEBUG, ES_RH_TAG, "Flag includes OC_OBSERVE_FLAG");
1457
1458         if (OC_OBSERVE_REGISTER == entityHandlerRequest->obsInfo.action)
1459         {
1460             OIC_LOG(DEBUG, ES_RH_TAG, "Received OC_OBSERVE_REGISTER from Mediator");
1461         }
1462         else if (OC_OBSERVE_DEREGISTER == entityHandlerRequest->obsInfo.action)
1463         {
1464             OIC_LOG(DEBUG, ES_RH_TAG, "Received OC_OBSERVE_DEREGISTER from Mediator");
1465         }
1466     }
1467     return ehRet;
1468 }
1469
1470 OCStackResult SetDeviceProperty(ESDeviceProperty *deviceProperty)
1471 {
1472     OIC_LOG(DEBUG, ES_RH_TAG, "SetDeviceProperty IN");
1473
1474     g_ESWiFiConfResource.supportedFreq = (deviceProperty->WiFi).freq;
1475     OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "WiFi Freq : %d", g_ESWiFiConfResource.supportedFreq);
1476
1477     int modeIdx = 0;
1478     while((deviceProperty->WiFi).mode[modeIdx] != WiFi_EOF)
1479     {
1480         g_ESWiFiConfResource.supportedMode[modeIdx] = (deviceProperty->WiFi).mode[modeIdx];
1481         OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "WiFi Mode : %d", g_ESWiFiConfResource.supportedMode[modeIdx]);
1482         modeIdx ++;
1483     }
1484     g_ESWiFiConfResource.numMode = modeIdx;
1485
1486     OICStrcpy(g_ESDevConfResource.devName, OIC_STRING_MAX_VALUE, (deviceProperty->DevConf).deviceName);
1487     OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "Device Name : %s", g_ESDevConfResource.devName);
1488
1489     OICStrcpy(g_ESDevConfResource.modelNumber, OIC_STRING_MAX_VALUE,
1490                                                             (deviceProperty->DevConf).modelNumber);
1491     OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "Model Number : %s", g_ESDevConfResource.modelNumber);
1492
1493     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESWiFiConfResource.handle, OC_HIGH_QOS))
1494     {
1495         OIC_LOG(DEBUG, ES_RH_TAG, "wifiResource doesn't have any observers.");
1496     }
1497
1498     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESDevConfResource.handle, OC_HIGH_QOS))
1499     {
1500         OIC_LOG(DEBUG, ES_RH_TAG, "devConfResource doesn't have any observers.");
1501     }
1502
1503     OIC_LOG(DEBUG, ES_RH_TAG, "SetDeviceProperty OUT");
1504     return OC_STACK_OK;
1505 }
1506
1507 OCStackResult SetEnrolleeState(ESEnrolleeState esState)
1508 {
1509     OIC_LOG(DEBUG, ES_RH_TAG, "SetEnrolleeState IN");
1510
1511     g_ESEasySetupResource.status = esState;
1512     OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "Enrollee Status : %d", g_ESEasySetupResource.status);
1513
1514     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESEasySetupResource.handle, OC_HIGH_QOS))
1515     {
1516         OIC_LOG(DEBUG, ES_RH_TAG, "provResource doesn't have any observers.");
1517     }
1518
1519     OIC_LOG(DEBUG, ES_RH_TAG, "SetEnrolleeState OUT");
1520     return OC_STACK_OK;
1521 }
1522
1523 OCStackResult SetEnrolleeErrCode(ESErrorCode esErrCode)
1524 {
1525     OIC_LOG(DEBUG, ES_RH_TAG, "SetEnrolleeErrCode IN");
1526
1527     g_ESEasySetupResource.lastErrCode = esErrCode;
1528     OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "Enrollee ErrorCode : %d", g_ESEasySetupResource.lastErrCode);
1529
1530     if(OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESEasySetupResource.handle, OC_HIGH_QOS))
1531     {
1532         OIC_LOG(DEBUG, ES_RH_TAG, "provResource doesn't have any observers.");
1533     }
1534
1535     OIC_LOG(DEBUG, ES_RH_TAG, "SetEnrolleeErrCode OUT");
1536     return OC_STACK_OK;
1537 }
1538
1539 OCEntityHandlerResult CheckEhRequestPayload(OCEntityHandlerRequest *ehRequest)
1540 {
1541     if( !(ehRequest->query) ||
1542                 (ehRequest->query &&
1543                 (strcmp(ehRequest->query, "") && !CompareResourceInterface(ehRequest->query,
1544                                                                         OC_RSRVD_INTERFACE_DEFAULT))))
1545     {
1546         OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
1547         return OC_EH_BAD_REQ;
1548     }
1549     return OC_EH_OK;
1550 }
1551
1552 const char *getResult(OCStackResult result)
1553 {
1554     switch (result)
1555     {
1556         case OC_STACK_OK:
1557             return "OC_STACK_OK";
1558         case OC_STACK_INVALID_URI:
1559             return "OC_STACK_INVALID_URI";
1560         case OC_STACK_INVALID_QUERY:
1561             return "OC_STACK_INVALID_QUERY";
1562         case OC_STACK_INVALID_IP:
1563             return "OC_STACK_INVALID_IP";
1564         case OC_STACK_INVALID_PORT:
1565             return "OC_STACK_INVALID_PORT";
1566         case OC_STACK_INVALID_CALLBACK:
1567             return "OC_STACK_INVALID_CALLBACK";
1568         case OC_STACK_INVALID_METHOD:
1569             return "OC_STACK_INVALID_METHOD";
1570         case OC_STACK_NO_MEMORY:
1571             return "OC_STACK_NO_MEMORY";
1572         case OC_STACK_COMM_ERROR:
1573             return "OC_STACK_COMM_ERROR";
1574         case OC_STACK_INVALID_PARAM:
1575             return "OC_STACK_INVALID_PARAM";
1576         case OC_STACK_NOTIMPL:
1577             return "OC_STACK_NOTIMPL";
1578         case OC_STACK_NO_RESOURCE:
1579             return "OC_STACK_NO_RESOURCE";
1580         case OC_STACK_RESOURCE_ERROR:
1581             return "OC_STACK_RESOURCE_ERROR";
1582         case OC_STACK_SLOW_RESOURCE:
1583             return "OC_STACK_SLOW_RESOURCE";
1584         case OC_STACK_NO_OBSERVERS:
1585             return "OC_STACK_NO_OBSERVERS";
1586         case OC_STACK_ERROR:
1587             return "OC_STACK_ERROR";
1588         default:
1589             return "UNKNOWN";
1590     }
1591 }