Merge branch '1.3-rel' (5fdb8a1)
[iotivity.git] / service / easy-setup / enrollee / src / resourcehandler.c
old mode 100755 (executable)
new mode 100644 (file)
index 2fcf719..54b75f2
 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
 
 #include "resourcehandler.h"
+#include "internal/es_util.h"
 
 #include "ocpayload.h"
 #include "oic_string.h"
 #include "oic_malloc.h"
+#include "cautilinterface.h"
+#include "experimental/payload_logging.h"
+
+// TODO: Remove this flag and enable the code it guards.
+// This is a temporary workaround to ignore the failure of OCLinksPayloadArrayCreate
+// in some cases. This allows the response to still be made, even though links property will be
+// missing.
+// Bug: IOT-2762
+#define ES_IGNORE_OCLinksPayloadArrayCreate_FAILIURE
 
 /**
  * @var ES_RH_TAG
 //-----------------------------------------------------------------------------
 
 /**
- * @var gProvResource
- * @brief Structure for holding the Provisioning status and target information required to
- * connect to the target network
+ * @var g_ESEasySetupResource
+ * @brief Structure for holding the Provisioning status
  */
-static ProvResource gProvResource;
-static WiFiResource gWiFiResource;
-static CloudResource gCloudResource;
-static DevConfResource gDevConfResource;
+EasySetupResource g_ESEasySetupResource;
+WiFiConfResource g_ESWiFiConfResource;
+CoapCloudConfResource g_ESCoapCloudConfResource;
+DevConfResource g_ESDevConfResource;
 
 //-----------------------------------------------------------------------------
 // Private internal function prototypes
@@ -51,53 +60,73 @@ OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag, OCEntityHandle
 OCEntityHandlerResult ProcessGetRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload);
 OCEntityHandlerResult ProcessPutRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload);
 OCEntityHandlerResult ProcessPostRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload);
-void updateProvResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input);
-void updateWiFiResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input);
-void updateCloudResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input);
-void updateDevConfResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input);
+OCEntityHandlerResult updateEasySetupResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input);
+void updateEasySetupConnectProperty(OCRepPayload* input);
+OCEntityHandlerResult updateWiFiConfResource(OCRepPayload* input);
+void updateCoapCloudConfResource(OCRepPayload* input);
+void updateDevConfResource(OCRepPayload* input);
+bool isAuthTypeSupported(WIFI_AUTHTYPE authType);
+bool isEncTypeSupported(WIFI_ENCTYPE encType);
 const char *getResult(OCStackResult result);
 
-ESWiFiCB gWifiRsrcEvtCb = NULL;
-ESCloudCB gCloudRsrcEvtCb = NULL;
+ESConnectRequestCB gConnectRequestEvtCb = NULL;
+ESWiFiConfCB gWifiConfRsrcEvtCb = NULL;
+ESCoapCloudConfCB gCoapCloudConfRsrcEvtCb = NULL;
 ESDevConfCB gDevConfRsrcEvtCb = NULL;
 
 ESReadUserdataCb gReadUserdataCb = NULL;
 ESWriteUserdataCb gWriteUserdataCb = NULL;
 
-bool CompareResourceInterface(char *from, char *iface)
+void GetInterfaceNameFromQuery(const char *query, char **iface)
 {
-    char *str = OICStrdup(from);
-    char *ptr = strtok(str, ";");
-
-    if(ptr == NULL)
+    if (!iface)
     {
-        return false;
+        return;
     }
+    *iface = NULL;
+    char *str = OICStrdup(query);
+    char *ptr = strtok(str, ";");
 
-    do
+    while (ptr)
     {
-        if(strstr(ptr, ".if."))
+        if (strstr(ptr, ".if."))
         {
             char *if_ptr = NULL;
             if_ptr = strtok(ptr, "=");
             if_ptr = strtok(NULL, "=");
 
-            if(!strcmp(if_ptr, iface))
-            {
-                return true;
-            }
+            *iface = OICStrdup(if_ptr);
+            break;
         }
+        ptr = strtok(NULL, ";");
+    }
+
+    OICFree(str);
+}
 
-    } while (ptr = strtok(NULL, ";"));
+bool CompareResourceInterface(const char *from, const char *iface)
+{
+    char *if_ptr = NULL;
+    GetInterfaceNameFromQuery(from, &if_ptr);
+    if (!if_ptr)
+    {
+        return false;
+    }
+    if (!strcmp(if_ptr, iface))
+    {
+        OICFree(if_ptr);
+        return true;
+    }
+    OICFree(if_ptr);
 
     return false;
 }
 
 ESResult SetCallbackForUserData(ESReadUserdataCb readCb, ESWriteUserdataCb writeCb)
 {
-    if(!readCb && !writeCb)
+    if (!readCb && !writeCb)
     {
-        OIC_LOG(INFO, ES_RH_TAG, "Both of callbacks for user data are null");
+        OIC_LOG(DEBUG, ES_RH_TAG, "Both of callbacks for user data are null");
         return ES_ERROR;
     }
     gReadUserdataCb = readCb;
@@ -105,14 +134,14 @@ ESResult SetCallbackForUserData(ESReadUserdataCb readCb, ESWriteUserdataCb write
     return ES_OK;
 }
 
-void RegisterWifiRsrcEventCallBack(ESWiFiCB cb)
+void RegisterWifiRsrcEventCallBack(ESWiFiConfCB cb)
 {
-    gWifiRsrcEvtCb = cb;
+    gWifiConfRsrcEvtCb = cb;
 }
 
-void RegisterCloudRsrcEventCallBack(ESCloudCB cb)
+void RegisterCloudRsrcEventCallBack(ESCoapCloudConfCB cb)
 {
-    gCloudRsrcEvtCb = cb;
+    gCoapCloudConfRsrcEvtCb = cb;
 }
 
 void RegisterDevConfRsrcEventCallBack(ESDevConfCB cb)
@@ -120,501 +149,898 @@ void RegisterDevConfRsrcEventCallBack(ESDevConfCB cb)
     gDevConfRsrcEvtCb = cb;
 }
 
+void RegisterConnectRequestEventCallBack(ESConnectRequestCB cb)
+{
+    gConnectRequestEvtCb = cb;
+}
+
 void UnRegisterResourceEventCallBack()
 {
-    if (gWifiRsrcEvtCb)
+    if (gWifiConfRsrcEvtCb)
     {
-        gWifiRsrcEvtCb = NULL;
+        gWifiConfRsrcEvtCb = NULL;
     }
-    if (gCloudRsrcEvtCb)
+    if (gCoapCloudConfRsrcEvtCb)
     {
-        gCloudRsrcEvtCb = NULL;
+        gCoapCloudConfRsrcEvtCb = NULL;
     }
     if (gDevConfRsrcEvtCb)
     {
         gDevConfRsrcEvtCb = NULL;
     }
+    if (gConnectRequestEvtCb)
+    {
+        gConnectRequestEvtCb = NULL;
+    }
 }
 
-OCStackResult initProvResource(bool isSecured)
+OCStackResult initEasySetupResource(bool isSecured)
 {
-    gProvResource.status = ES_STATE_INIT;
-    gProvResource.lastErrCode = ES_ERRCODE_NO_ERROR;
-    OICStrcpy(gProvResource.ocfWebLinks, MAX_WEBLINKLEN, "");
+    g_ESEasySetupResource.status = ES_STATE_INIT;
+    g_ESEasySetupResource.lastErrCode = ES_ERRCODE_NO_ERROR;
+    for (int i = 0; i < NUM_CONNECT_TYPE; ++i)
+    {
+        g_ESEasySetupResource.connectRequest[i] = ES_CONNECT_NONE;
+    }
+    g_ESEasySetupResource.numRequest = 0;
 
     OCStackResult res = OC_STACK_ERROR;
     if (isSecured)
     {
-        res = OCCreateResource(&gProvResource.handle, OC_RSRVD_ES_RES_TYPE_PROV,
+        res = OCCreateResource(&g_ESEasySetupResource.handle, OC_RSRVD_ES_RES_TYPE_EASYSETUP,
         OC_RSRVD_INTERFACE_DEFAULT,
-        OC_RSRVD_ES_URI_PROV, OCEntityHandlerCb,
+        OC_RSRVD_ES_URI_EASYSETUP, OCEntityHandlerCb,
         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
-    }else
+    }
+    else
     {
-        res = OCCreateResource(&gProvResource.handle, OC_RSRVD_ES_RES_TYPE_PROV,
+        res = OCCreateResource(&g_ESEasySetupResource.handle, OC_RSRVD_ES_RES_TYPE_EASYSETUP,
         OC_RSRVD_INTERFACE_DEFAULT,
-        OC_RSRVD_ES_URI_PROV, OCEntityHandlerCb,
+        OC_RSRVD_ES_URI_EASYSETUP, OCEntityHandlerCb,
         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
     }
-    if(res)
+    if (res != OC_STACK_OK)
     {
-        OIC_LOG_V(INFO, ES_RH_TAG, "Created Prov resource with result: %s", getResult(res));
+        OIC_LOG_V(ERROR, ES_RH_TAG, "Created EasySetup resource with result: %s", getResult(res));
         return res;
     }
 
-    res = OCBindResourceInterfaceToResource(gProvResource.handle, OC_RSRVD_INTERFACE_LL);
-    if(res)
+    res = OCBindResourceTypeToResource(g_ESEasySetupResource.handle, OC_RSRVD_ES_RES_TYPE_COL);
+    if (res != OC_STACK_OK)
     {
-        OIC_LOG_V(INFO, ES_RH_TAG, "Binding Resource interface with result: %s", getResult(res));
+        OIC_LOG_V(ERROR, ES_RH_TAG, "Binding Resource type with result: %s", getResult(res));
         return res;
     }
-    res = OCBindResourceInterfaceToResource(gProvResource.handle, OC_RSRVD_INTERFACE_BATCH);
-    if(res)
+
+    res = OCBindResourceInterfaceToResource(g_ESEasySetupResource.handle, OC_RSRVD_INTERFACE_LL);
+    if (res != OC_STACK_OK)
     {
-        OIC_LOG_V(INFO, ES_RH_TAG, "Binding Resource interface with result: %s", getResult(res));
+        OIC_LOG_V(ERROR, ES_RH_TAG, "Binding Resource interface with result: %s", getResult(res));
+        return res;
+    }
+    res = OCBindResourceInterfaceToResource(g_ESEasySetupResource.handle, OC_RSRVD_INTERFACE_BATCH);
+    if (res != OC_STACK_OK)
+    {
+        OIC_LOG_V(ERROR, ES_RH_TAG, "Binding Resource interface with result: %s", getResult(res));
         return res;
     }
 
-    OIC_LOG_V(INFO, ES_RH_TAG, "Created Prov resource with result: %s", getResult(res));
+    OIC_LOG_V(DEBUG, ES_RH_TAG, "Created EasySetup resource with result: %s", getResult(res));
     return res;
 }
 
-OCStackResult initWiFiResource(bool isSecured)
+OCStackResult initWiFiConfResource(bool isSecured)
 {
     OCStackResult res = OC_STACK_ERROR;
 
-    gWiFiResource.supportedFreq = WIFI_BOTH;
-    gWiFiResource.supportedMode[0] = WIFI_11A;
-    gWiFiResource.supportedMode[1] = WIFI_11B;
-    gWiFiResource.supportedMode[2] = WIFI_11G;
-    gWiFiResource.supportedMode[3] = WIFI_11N;
-    gWiFiResource.numMode = 4;
-    gWiFiResource.authType = NONE_AUTH;
-    gWiFiResource.encType = NONE_ENC;
-    OICStrcpy(gWiFiResource.ssid, sizeof(gWiFiResource.ssid), "");
-    OICStrcpy(gWiFiResource.cred, sizeof(gWiFiResource.cred), "");
+    g_ESWiFiConfResource.supportedFreq[0] = WIFI_24G;
+    g_ESWiFiConfResource.supportedFreq[1] = WIFI_5G;
+    g_ESWiFiConfResource.numSupportedFreq=2;
+    g_ESWiFiConfResource.supportedMode[0] = WIFI_11A;
+    g_ESWiFiConfResource.supportedMode[1] = WIFI_11B;
+    g_ESWiFiConfResource.supportedMode[2] = WIFI_11G;
+    g_ESWiFiConfResource.supportedMode[3] = WIFI_11N;
+    g_ESWiFiConfResource.numMode = 4;
+    g_ESWiFiConfResource.authType = NONE_AUTH;
+    g_ESWiFiConfResource.encType = NONE_ENC;
+    OICStrcpy(g_ESWiFiConfResource.ssid, sizeof(g_ESWiFiConfResource.ssid), "");
+    OICStrcpy(g_ESWiFiConfResource.cred, sizeof(g_ESWiFiConfResource.cred), "");
 
     if (isSecured)
     {
-        res = OCCreateResource(&gWiFiResource.handle, OC_RSRVD_ES_RES_TYPE_WIFI,
+        res = OCCreateResource(&g_ESWiFiConfResource.handle, OC_RSRVD_ES_RES_TYPE_WIFICONF,
         OC_RSRVD_INTERFACE_DEFAULT,
-        OC_RSRVD_ES_URI_WIFI, OCEntityHandlerCb,
+        OC_RSRVD_ES_URI_WIFICONF, OCEntityHandlerCb,
         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
-    }else
+    }
+    else
     {
-        res = OCCreateResource(&gWiFiResource.handle, OC_RSRVD_ES_RES_TYPE_WIFI,
+        res = OCCreateResource(&g_ESWiFiConfResource.handle, OC_RSRVD_ES_RES_TYPE_WIFICONF,
         OC_RSRVD_INTERFACE_DEFAULT,
-        OC_RSRVD_ES_URI_WIFI, OCEntityHandlerCb,
+        OC_RSRVD_ES_URI_WIFICONF, OCEntityHandlerCb,
         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
     }
 
-    OIC_LOG_V(INFO, ES_RH_TAG, "Created WiFi resource with result: %s", getResult(res));
+    if (res != OC_STACK_OK)
+    {
+        OIC_LOG_V(ERROR, ES_RH_TAG, "Failed to create WiFiConf resource with result: %s",
+            getResult(res));
+        return res;
+    }
+
+    res = OCBindResourceInterfaceToResource(g_ESWiFiConfResource.handle,
+    OC_RSRVD_INTERFACE_READ_WRITE);
+    if (res != OC_STACK_OK)
+    {
+        OIC_LOG_V(ERROR, ES_RH_TAG, "Binding Resource interface with result: %s", getResult(res));
+        return res;
+    }
+
+    OIC_LOG_V(DEBUG, ES_RH_TAG, "Created WiFiConf resource with result: %s", getResult(res));
     return res;
 
 }
 
-OCStackResult initCloudServerResource(bool isSecured)
+OCStackResult initCoapCloudConfResource(bool isSecured)
 {
     OCStackResult res = OC_STACK_ERROR;
 
-    OICStrcpy(gCloudResource.authCode, sizeof(gCloudResource.authCode), "");
-    OICStrcpy(gCloudResource.authProvider, sizeof(gCloudResource.authProvider), "");
-    OICStrcpy(gCloudResource.ciServer, sizeof(gCloudResource.ciServer), "");
+    OICStrcpy(g_ESCoapCloudConfResource.authCode, sizeof(g_ESCoapCloudConfResource.authCode), "");
+    OICStrcpy(g_ESCoapCloudConfResource.accessToken, sizeof(g_ESCoapCloudConfResource.accessToken),
+            "");
+    g_ESCoapCloudConfResource.accessTokenType = NONE_OAUTH_TOKENTYPE;
+    OICStrcpy(g_ESCoapCloudConfResource.authProvider,
+            sizeof(g_ESCoapCloudConfResource.authProvider), "");
+    OICStrcpy(g_ESCoapCloudConfResource.ciServer, sizeof(g_ESCoapCloudConfResource.ciServer), "");
 
     if (isSecured)
     {
-        res = OCCreateResource(&gCloudResource.handle, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER,
-        OC_RSRVD_INTERFACE_DEFAULT,
-        OC_RSRVD_ES_URI_CLOUDSERVER, OCEntityHandlerCb,
-        NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
-    }else
+        res = OCCreateResource(&g_ESCoapCloudConfResource.handle,
+                OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF,
+                OC_RSRVD_INTERFACE_DEFAULT,
+                OC_RSRVD_ES_URI_COAPCLOUDCONF, OCEntityHandlerCb,
+                NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
+    }
+    else
     {
-        res = OCCreateResource(&gCloudResource.handle, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER,
-        OC_RSRVD_INTERFACE_DEFAULT,
-        OC_RSRVD_ES_URI_CLOUDSERVER, OCEntityHandlerCb,
-        NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
+        res = OCCreateResource(&g_ESCoapCloudConfResource.handle,
+                OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF,
+                OC_RSRVD_INTERFACE_DEFAULT,
+                OC_RSRVD_ES_URI_COAPCLOUDCONF, OCEntityHandlerCb,
+                NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
     }
 
-    OIC_LOG_V(INFO, ES_RH_TAG, "Created CloudServer resource with result: %s", getResult(res));
-    return res;
+    if (res != OC_STACK_OK)
+    {
+        OIC_LOG_V(ERROR, ES_RH_TAG, "Failed to create CoapCloudConf resource with result: %s",
+            getResult(res));
+        return res;
+    }
+
+    res = OCBindResourceInterfaceToResource(g_ESCoapCloudConfResource.handle,
+            OC_RSRVD_INTERFACE_READ_WRITE);
+    if (res != OC_STACK_OK)
+    {
+        OIC_LOG_V(ERROR, ES_RH_TAG, "Binding Resource interface with result: %s", getResult(res));
+        return res;
+    }
 
+    OIC_LOG_V(DEBUG, ES_RH_TAG, "Created CoapCloudConf resource with result: %s", getResult(res));
+    return res;
 }
 
 OCStackResult initDevConfResource(bool isSecured)
 {
     OCStackResult res = OC_STACK_ERROR;
 
-    OICStrcpy(gDevConfResource.devName, sizeof(gDevConfResource.devName), "");
-    OICStrcpy(gDevConfResource.modelNumber, sizeof(gDevConfResource.modelNumber), "");
-    OICStrcpy(gDevConfResource.location, sizeof(gDevConfResource.location), "");
-    OICStrcpy(gDevConfResource.country, sizeof(gDevConfResource.country), "");
-    OICStrcpy(gDevConfResource.language, sizeof(gDevConfResource.language), "");
+    OICStrcpy(g_ESDevConfResource.devName, sizeof(g_ESDevConfResource.devName), "");
 
     if (isSecured)
     {
-        res = OCCreateResource(&gDevConfResource.handle, OC_RSRVD_ES_RES_TYPE_DEVCONF,
+        res = OCCreateResource(&g_ESDevConfResource.handle, OC_RSRVD_ES_RES_TYPE_DEVCONF,
         OC_RSRVD_INTERFACE_DEFAULT,
         OC_RSRVD_ES_URI_DEVCONF, OCEntityHandlerCb,
         NULL, OC_DISCOVERABLE | OC_OBSERVABLE | OC_SECURE);
-    }else
+    }
+    else
     {
-        res = OCCreateResource(&gDevConfResource.handle, OC_RSRVD_ES_RES_TYPE_DEVCONF,
+        res = OCCreateResource(&g_ESDevConfResource.handle, OC_RSRVD_ES_RES_TYPE_DEVCONF,
         OC_RSRVD_INTERFACE_DEFAULT,
         OC_RSRVD_ES_URI_DEVCONF, OCEntityHandlerCb,
         NULL, OC_DISCOVERABLE | OC_OBSERVABLE);
     }
 
-    OIC_LOG_V(INFO, ES_RH_TAG, "Created DevConf resource with result: %s", getResult(res));
+    if (res != OC_STACK_OK)
+    {
+        OIC_LOG_V(ERROR, ES_RH_TAG, "Failed to create DevConf resource with result: %s",
+            getResult(res));
+        return res;
+    }
+
+    res = OCBindResourceInterfaceToResource(g_ESDevConfResource.handle, OC_RSRVD_INTERFACE_READ);
+    if (res != OC_STACK_OK)
+    {
+        OIC_LOG_V(ERROR, ES_RH_TAG, "Binding Resource interface with result: %s", getResult(res));
+        return res;
+    }
+
+    OIC_LOG_V(DEBUG, ES_RH_TAG, "Created DevConf resource with result: %s", getResult(res));
     return res;
 
 }
 
-void updateProvResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input)
+OCEntityHandlerResult updateEasySetupResource(OCEntityHandlerRequest* ehRequest,
+    OCRepPayload* input)
 {
-    OIC_LOG_V(INFO, ES_RH_TAG, "gProvResource.status %d", gProvResource.status);
+    OIC_LOG_V(DEBUG, ES_RH_TAG, "g_ESEasySetupResource.status %d", g_ESEasySetupResource.status);
 
-    if(ehRequest->query)
+    OCEntityHandlerResult ehResult = OC_EH_OK;
+    if (ehRequest->query)
     {
-        if(CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH))
+        if (CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH))
         {
+            bool hasError = false;
             // When Provisioning resource has a POST with BatchInterface
-            updateCloudResource(NULL, input);
-            updateWiFiResource(NULL, input);
-            updateDevConfResource(NULL, input);
+            // Parsing POST request on Batch Interface cosidering same format as GET using batch.
+            OCRepPayload *children = input;
+            while(children)
+            {
+                char* uri = children->uri;
+                if (NULL == uri)
+                {
+                    OIC_LOG(DEBUG, ES_RH_TAG, "No URI found in request");
+                }
+                else
+                {
+                    OIC_LOG_V(DEBUG, ES_RH_TAG, "Request URI [%s]", uri);
+                }
+
+                OCRepPayload *repPayload = NULL;
+                OCRepPayloadGetPropObject(children, OC_RSRVD_REPRESENTATION, &repPayload);
+                if (NULL == repPayload)
+                {
+                    OIC_LOG(ERROR, ES_RH_TAG, "repPayload is null!");
+                    children = children->next;
+                    continue;
+                }
+
+                // If uri is NULL, rep is applied to all resources in collection;
+                // otherwise its applied to specific target resources.
+                if (NULL == uri || 0 == strlen(uri) || 0 == strcmp(uri, OC_RSRVD_ES_URI_EASYSETUP))
+                {
+                    updateEasySetupConnectProperty(repPayload);
+                }
+
+                if (NULL == uri || 0 == strlen(uri)
+                    || 0 == strcmp(uri, OC_RSRVD_ES_URI_WIFICONF))
+                {
+                    if (updateWiFiConfResource(repPayload) != OC_EH_OK)
+                    {
+                        // Possibility of failure exist only when updating WiFiConf resource.
+                        // So error code is checked only for this function.
+                        OIC_LOG(ERROR, ES_RH_TAG, "Failed to update WiFiConf resource.");
+                        hasError = true;
+                    }
+                }
+
+                if (NULL == uri ||  0 == strlen(uri)
+                    || 0 == strcmp(uri, OC_RSRVD_ES_URI_COAPCLOUDCONF))
+                {
+                    updateCoapCloudConfResource(repPayload);
+                }
+
+                if (NULL == uri ||  0 == strlen(uri)
+                    || 0 == strcmp(uri, OC_RSRVD_ES_URI_DEVCONF))
+                {
+                    updateDevConfResource(repPayload);
+                }
+
+                children = children->next;
+                OCRepPayloadDestroy(repPayload);
+            }
+
+            if (hasError)
+            {
+               ehResult = OC_EH_BAD_REQ;
+            }
+        }
+        else if (CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
+        {
+            OIC_LOG(DEBUG, ES_RH_TAG, "Handling POST request on default interface");
+            updateEasySetupConnectProperty(input);
         }
     }
+
+    OIC_LOG(DEBUG, ES_RH_TAG, "updateEasySetupResource exit");
+    return ehResult;
 }
 
-void updateWiFiResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input)
+void updateEasySetupConnectProperty(OCRepPayload* input)
 {
-    if(ehRequest &&
-        strcmp(ehRequest->query, "") &&
-        !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
+    int64_t *connect_req = NULL;
+    size_t dimensions[MAX_REP_ARRAY_DEPTH] = { 0 };
+    if (OCRepPayloadGetIntArray(input, OC_RSRVD_ES_CONNECT, &connect_req, dimensions))
     {
-        // In case of link list, batch interface
-        OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
-        return ;
-    }
+        ESConnectRequest* connectRequest = (ESConnectRequest*)OICMalloc(sizeof(ESConnectRequest));
+        if (!connectRequest)
+        {
+            OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
+            return;
+        }
+
+        int cntRequest = 0;
+        for (unsigned int i = 0 ; i < NUM_CONNECT_TYPE ; ++i)
+        {
+            g_ESEasySetupResource.connectRequest[i] = ES_CONNECT_NONE;
+            connectRequest->connect[i] = ES_CONNECT_NONE;
+
+            if (i < dimensions[0] &&
+                (connect_req[i] == ES_CONNECT_WIFI || connect_req[i] == ES_CONNECT_COAPCLOUD))
+            {
+                g_ESEasySetupResource.connectRequest[cntRequest] = connect_req[i];
+                connectRequest->connect[cntRequest] = connect_req[i];
+                OIC_LOG_V(DEBUG, ES_RH_TAG, "g_ESEasySetupResource.connectType[%d] : %d",
+                                                    cntRequest, g_ESEasySetupResource.connectRequest[cntRequest]);
+                cntRequest++;
+            }
+        }
+        connectRequest->numRequest = cntRequest;
+        g_ESEasySetupResource.numRequest = cntRequest;
 
-    ESWiFiProvData* wiFiData = (ESWiFiProvData*)OICMalloc(sizeof(ESWiFiProvData));
+        if (g_ESEasySetupResource.connectRequest[0] != ES_CONNECT_NONE)
+        {
+            OIC_LOG(DEBUG, ES_RH_TAG, "Send ConnectRequest Callback To ES");
 
-    if(wiFiData == NULL)
+            //@todo Need to check appropriateness of gWiFiData
+            if (gConnectRequestEvtCb != NULL)
+            {
+                gConnectRequestEvtCb(ES_OK, connectRequest);
+            }
+            else
+            {
+                OIC_LOG(ERROR, ES_RH_TAG, "gConnectRequestEvtCb is NULL");
+            }
+        }
+    }
+}
+
+OCEntityHandlerResult updateWiFiConfResource(OCRepPayload* input)
+{
+    OCEntityHandlerResult ehResult = OC_EH_ERROR;
+    ESWiFiConfData* wiFiData = (ESWiFiConfData*) OICMalloc(sizeof(ESWiFiConfData));
+    if (wiFiData == NULL)
     {
         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
-        return ;
+        return ehResult;
     }
 
-    memset(wiFiData->ssid, 0, MAX_WEBLINKLEN);
-    memset(wiFiData->pwd, 0, MAX_WEBLINKLEN);
+    char* ssid = NULL;
+    char* cred = NULL;
+    char *authType = NULL;
+    char *encType = NULL;
+    memset(wiFiData->ssid, 0, OIC_STRING_MAX_VALUE);
+    memset(wiFiData->pwd, 0, OIC_STRING_MAX_VALUE);
     wiFiData->authtype = NONE_AUTH;
     wiFiData->enctype = NONE_AUTH;
     wiFiData->userdata = NULL;
 
-    char* ssid = NULL;
-    if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_SSID, &ssid))
+    bool validAuthType = false;
+    if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_AUTHTYPE, &authType))
     {
-        OICStrcpy(gWiFiResource.ssid, sizeof(gWiFiResource.ssid), ssid);
-        OICStrcpy(wiFiData->ssid, sizeof(wiFiData->ssid), ssid);
-        OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.ssid : %s", gWiFiResource.ssid);
+        WIFI_AUTHTYPE tmp;
+        validAuthType = WiFiAuthTypeStringToEnum(authType, &tmp);
+        if (validAuthType && isAuthTypeSupported(tmp))
+        {
+            wiFiData->authtype = tmp;
+            OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESWiFiConfResource.authType %u",
+                    wiFiData->authtype);
+        }
+        else
+        {
+            OIC_LOG(ERROR, ES_RH_TAG, "AuthType is not supported.");
+            ehResult = OC_EH_BAD_REQ;
+            goto EXIT;
+        }
     }
 
-    char* cred = NULL;
-    if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CRED, &cred))
+    bool validEncType = false;
+    if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_ENCTYPE, &encType))
     {
-        OICStrcpy(gWiFiResource.cred, sizeof(gWiFiResource.cred), cred);
-        OICStrcpy(wiFiData->pwd, sizeof(wiFiData->pwd), cred);
-        OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.cred %s", gWiFiResource.cred);
+        WIFI_ENCTYPE tmp;
+        validEncType = WiFiEncTypeStringToEnum(encType, &tmp);
+        if (validEncType && isEncTypeSupported(tmp))
+        {
+            wiFiData->enctype = tmp;
+            OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESWiFiConfResource.encType %u",
+                    wiFiData->enctype);
+        }
+        else
+        {
+            OIC_LOG(ERROR, ES_RH_TAG, "EncType is not supported.");
+            ehResult = OC_EH_BAD_REQ;
+            goto EXIT;
+        }
+    }
+
+    if (validAuthType)
+    {
+        g_ESWiFiConfResource.authType = wiFiData->authtype;
     }
 
-    int64_t authType = -1;
-    if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_AUTHTYPE, &authType))
+    if (validEncType)
     {
-        gWiFiResource.authType = authType;
-        wiFiData->authtype = gWiFiResource.authType;
-        OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.authType %u", gWiFiResource.authType);
+        g_ESWiFiConfResource.encType = wiFiData->enctype;
     }
 
-    int64_t encType = -1;
-    if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_ENCTYPE, &encType))
+    if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_SSID, &ssid))
     {
-        gWiFiResource.encType = encType;
-        wiFiData->enctype = gWiFiResource.encType;
-        OIC_LOG_V(INFO, ES_RH_TAG, "gWiFiResource.encType %u", gWiFiResource.encType);
+        OICStrcpy(g_ESWiFiConfResource.ssid, sizeof(g_ESWiFiConfResource.ssid), ssid);
+        OICStrcpy(wiFiData->ssid, sizeof(wiFiData->ssid), ssid);
+        OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESWiFiConfResource.ssid : %s",
+                g_ESWiFiConfResource.ssid);
+    }
+
+    if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CRED, &cred))
+    {
+        OICStrcpy(g_ESWiFiConfResource.cred, sizeof(g_ESWiFiConfResource.cred), cred);
+        OICStrcpy(wiFiData->pwd, sizeof(wiFiData->pwd), cred);
+        OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESWiFiConfResource.cred %s",
+                g_ESWiFiConfResource.cred);
     }
 
-    if(gReadUserdataCb)
+    if (gReadUserdataCb)
     {
-        gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_WIFI, &wiFiData->userdata);
+        gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_WIFICONF, &wiFiData->userdata);
     }
 
-    if(ssid || cred || authType!= -1 || encType != -1)
+    if (ssid || cred || validAuthType || validEncType)
     {
-        OIC_LOG(INFO, ES_RH_TAG, "Send WiFiRsrc Callback To ES");
+        OIC_LOG(DEBUG, ES_RH_TAG, "Send WiFiConfRsrc Callback To ES");
 
-        // TODO : Need to check appropriateness of gWiFiData
-        if(gWifiRsrcEvtCb != NULL)
+        //@todo Need to check appropriateness of gWiFiData
+        if (gWifiConfRsrcEvtCb != NULL)
         {
-            gWifiRsrcEvtCb(ES_OK, wiFiData);
+            gWifiConfRsrcEvtCb(ES_OK, wiFiData);
         }
         else
         {
-            OIC_LOG(ERROR, ES_RH_TAG, "gWifiRsrcEvtCb is NULL");
+            OIC_LOG(ERROR, ES_RH_TAG, "gWifiConfRsrcEvtCb is NULL");
         }
     }
 
+    if (OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESWiFiConfResource.handle, OC_HIGH_QOS))
+    {
+        OIC_LOG(DEBUG, ES_RH_TAG, "Enrollee doesn't have any observer.");
+    }
+
+    ehResult = OC_EH_OK;
+
+EXIT:
+    OICFree(encType);
+    OICFree(authType);
+    OICFree(cred);
+    OICFree(ssid);
     OICFree(wiFiData);
+    return ehResult;
 }
 
-void updateCloudResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input)
+void updateCoapCloudConfResource(OCRepPayload* input)
 {
-    if(ehRequest &&
-        strcmp(ehRequest->query, "") &&
-        !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
-    {
-        // In case of link list, batch interface
-        OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
-        return ;
-    }
+    ESCoapCloudConfData* cloudData = (ESCoapCloudConfData*)OICMalloc(sizeof(ESCoapCloudConfData));
 
-    ESCloudProvData* cloudData = (ESCloudProvData*)OICMalloc(sizeof(ESCloudProvData));
-
-    if(cloudData == NULL)
+    if (cloudData == NULL)
     {
         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
         return;
     }
 
     memset(cloudData->authCode, 0, OIC_STRING_MAX_VALUE);
+    memset(cloudData->accessToken, 0, OIC_STRING_MAX_VALUE);
+    g_ESCoapCloudConfResource.accessTokenType = NONE_OAUTH_TOKENTYPE;
     memset(cloudData->authProvider, 0, OIC_STRING_MAX_VALUE);
-    memset(cloudData->ciServer, 0, OIC_STRING_MAX_VALUE);
+    memset(cloudData->ciServer, 0, OIC_URI_STRING_MAX_VALUE);
     cloudData->userdata = NULL;
 
     char *authCode = NULL;
     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_AUTHCODE, &authCode))
     {
-        OICStrcpy(gCloudResource.authCode, sizeof(gCloudResource.authCode), authCode);
+        OICStrcpy(g_ESCoapCloudConfResource.authCode, sizeof(g_ESCoapCloudConfResource.authCode), authCode);
         OICStrcpy(cloudData->authCode, sizeof(cloudData->authCode), authCode);
-        OIC_LOG_V(INFO, ES_RH_TAG, "gCloudResource.authCode %s", gCloudResource.authCode);
+        OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESCoapCloudConfResource.authCode %s", g_ESCoapCloudConfResource.authCode);
+    }
+
+    char *accessToken = NULL;
+    if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_ACCESSTOKEN, &accessToken))
+    {
+        OICStrcpy(g_ESCoapCloudConfResource.accessToken, sizeof(g_ESCoapCloudConfResource.accessToken), accessToken);
+        OICStrcpy(cloudData->accessToken, sizeof(cloudData->accessToken), accessToken);
+        OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESCoapCloudConfResource.accessToken %s", g_ESCoapCloudConfResource.accessToken);
+    }
+
+    int64_t accessTokenType = -1;
+    if (OCRepPayloadGetPropInt(input, OC_RSRVD_ES_ACCESSTOKEN_TYPE, &accessTokenType))
+    {
+        g_ESCoapCloudConfResource.accessTokenType = accessTokenType;
+        cloudData->accessTokenType = g_ESCoapCloudConfResource.accessTokenType;
+        OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESCoapCloudConfResource.accessTokenType %d", g_ESCoapCloudConfResource.accessTokenType);
     }
 
     char *authProvider = NULL;
     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_AUTHPROVIDER, &authProvider))
     {
-        OICStrcpy(gCloudResource.authProvider, sizeof(gCloudResource.authProvider), authProvider);
+        OICStrcpy(g_ESCoapCloudConfResource.authProvider, sizeof(g_ESCoapCloudConfResource.authProvider), authProvider);
         OICStrcpy(cloudData->authProvider, sizeof(cloudData->authProvider), authProvider);
-        OIC_LOG_V(INFO, ES_RH_TAG, "gCloudResource.authServerUrl %s", gCloudResource.authProvider);
+        OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESCoapCloudConfResource.authServerUrl %s", g_ESCoapCloudConfResource.authProvider);
     }
 
     char *ciServer = NULL;
     if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_CISERVER, &ciServer))
     {
-        OICStrcpy(gCloudResource.ciServer, sizeof(gCloudResource.ciServer), ciServer);
+        OICStrcpy(g_ESCoapCloudConfResource.ciServer, sizeof(g_ESCoapCloudConfResource.ciServer), ciServer);
         OICStrcpy(cloudData->ciServer, sizeof(cloudData->ciServer), ciServer);
-        OIC_LOG_V(INFO, ES_RH_TAG, "gCloudResource.ciServer %s", gCloudResource.ciServer);
+        OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "g_ESCoapCloudConfResource.ciServer %s", g_ESCoapCloudConfResource.ciServer);
     }
 
-    if(gReadUserdataCb)
+    if (gReadUserdataCb)
     {
-        gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER, &cloudData->userdata);
+        gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF, &cloudData->userdata);
     }
 
-    if(authCode || authProvider || ciServer)
+    if (authCode || accessToken || authProvider || ciServer)
     {
-        OIC_LOG(INFO, ES_RH_TAG, "Send CloudRsrc Callback To ES");
+        OIC_LOG(DEBUG, ES_RH_TAG, "Send CoapCloudConfRsrc Callback To ES");
 
-        // TODO : Need to check appropriateness of gCloudData
-        if(gCloudRsrcEvtCb != NULL)
+        //@todo Need to check appropriateness of gCloudData
+        if (gCoapCloudConfRsrcEvtCb != NULL)
         {
-            gCloudRsrcEvtCb(ES_OK, cloudData);
+            gCoapCloudConfRsrcEvtCb(ES_OK, cloudData);
         }
         else
         {
-            OIC_LOG(ERROR, ES_RH_TAG, "gCloudRsrcEvtCb is NULL");
+            OIC_LOG(DEBUG, ES_RH_TAG, "gCoapCloudConfRsrcEvtCb is NULL");
         }
     }
 
+    if (OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESCoapCloudConfResource.handle, OC_HIGH_QOS))
+    {
+        OIC_LOG(DEBUG, ES_RH_TAG, "CoapCloudConf resource doesn't have any observer.");
+    }
+
     OICFree(cloudData);
 }
 
-void updateDevConfResource(OCEntityHandlerRequest* ehRequest, OCRepPayload* input)
+void updateDevConfResource(OCRepPayload* input)
 {
-    if(ehRequest &&
-        strcmp(ehRequest->query, "") &&
-        !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
-    {
-        // In case of link list, batch interface
-        OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
-        return ;
-    }
-
-    ESDevConfProvData* devConfData = (ESDevConfProvData*)OICMalloc(sizeof(ESDevConfProvData));
+    ESDevConfData* devConfData = (ESDevConfData*)OICMalloc(sizeof(ESDevConfData));
 
-    if(devConfData == NULL)
+    if (devConfData == NULL)
     {
         OIC_LOG(DEBUG, ES_RH_TAG, "OICMalloc is failed");
         return;
     }
-    memset(devConfData->language, 0, OIC_STRING_MAX_VALUE);
-    memset(devConfData->country, 0, OIC_STRING_MAX_VALUE);
     devConfData->userdata = NULL;
 
-    char *location = NULL;
-    if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_LOCATION, &location))
-    {
-        OICStrcpy(gDevConfResource.location, sizeof(gDevConfResource.location), location);
-        OICStrcpy(devConfData->location, sizeof(devConfData->location), location);
-        OIC_LOG_V(INFO, ES_RH_TAG, "gDevConfResource.location %s", gDevConfResource.location);
-    }
-
-    char *country = NULL;
-    if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_COUNTRY, &country))
-    {
-        OICStrcpy(gDevConfResource.country, sizeof(gDevConfResource.country), country);
-        OICStrcpy(devConfData->country, sizeof(devConfData->country), country);
-        OIC_LOG_V(INFO, ES_RH_TAG, "gDevConfResource.country %s", gDevConfResource.country);
-    }
-
-    char *language = NULL;
-    if (OCRepPayloadGetPropString(input, OC_RSRVD_ES_LANGUAGE, &language))
-    {
-        OICStrcpy(gDevConfResource.language, sizeof(gDevConfResource.language), language);
-        OICStrcpy(devConfData->language, sizeof(devConfData->language), language);
-        OIC_LOG_V(INFO, ES_RH_TAG, "gDevConfResource.language %s", gDevConfResource.language);
-    }
-
-    if(gReadUserdataCb)
+    if (gReadUserdataCb)
     {
         gReadUserdataCb(input, OC_RSRVD_ES_RES_TYPE_DEVCONF, &devConfData->userdata);
     }
 
-    if(country || language)
+    // If a writable property in oic.r.devconf is added later,
+    // a condition for calling a resistered callback should be implemented also.
+    if (devConfData->userdata != NULL)
     {
-        OIC_LOG(INFO, ES_RH_TAG, "Send DevConfRsrc Callback To ES");
+        OIC_LOG(DEBUG, ES_RH_TAG, "Send DevConfRsrc Callback To ES");
 
-        // TODO : Need to check appropriateness of gDevConfData
-        if(gDevConfRsrcEvtCb != NULL)
+        //@todo : Need to check appropriateness of gDevConfData
+        if (gDevConfRsrcEvtCb != NULL)
         {
             gDevConfRsrcEvtCb(ES_OK, devConfData);
         }
         else
         {
-            OIC_LOG(ERROR, ES_RH_TAG, "gDevConfRsrcEvtCb is NULL");
+            OIC_LOG(DEBUG, ES_RH_TAG, "gDevConfRsrcEvtCb is NULL");
         }
     }
 
+    if (OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESDevConfResource.handle, OC_HIGH_QOS))
+    {
+        OIC_LOG(DEBUG, ES_RH_TAG, "devConfResource doesn't have any observer.");
+    }
+
     OICFree(devConfData);
 }
 
-OCRepPayload* constructResponseOfWiFi(OCEntityHandlerRequest *ehRequest)
+OCRepPayload* constructResponseOfWiFiConf(char *interface)
 {
-    if(ehRequest &&
-        strcmp(ehRequest->query, "") &&
-        !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
+    OCRepPayload* payload = OCRepPayloadCreate();
+    if (!payload)
     {
-        // In case of link list, batch interface
-        OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
+        OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
         return NULL;
     }
 
-    OCRepPayload* payload = OCRepPayloadCreate();
-    if (!payload)
+    if (g_ESWiFiConfResource.handle == NULL)
     {
-        OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
+        OIC_LOG(ERROR, ES_RH_TAG, "WiFiConf resource is not created");
         return NULL;
     }
 
-    OIC_LOG(INFO, ES_RH_TAG, "constructResponse wifi res");
-    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_HREF, OC_RSRVD_ES_URI_WIFI);
+    OIC_LOG(DEBUG, ES_RH_TAG, "constructResponse WiFiConf res");
+    OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_WIFICONF);
+
+    OCRepPayload* repPayload = NULL;
+    OCRepPayload* tempPayload = NULL;
+    if (!strcmp(interface, OC_RSRVD_INTERFACE_BATCH))
+    {
+        repPayload = OCRepPayloadCreate();
+        if (!repPayload)
+        {
+            OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
+            return NULL;
+        }
+
+        tempPayload = payload;
+        payload = repPayload;
+
+        size_t interfacesDimensions[MAX_REP_ARRAY_DEPTH] = {2, 0, 0};
+        char **interfaces = (char **)OICMalloc(3 * sizeof(char*));
+        if (!interfaces)
+        {
+            OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
+            return NULL;
+        }
+
+        interfaces[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
+        interfaces[1] = OICStrdup(OC_RSRVD_INTERFACE_READ_WRITE);
+
+        OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_INTERFACE, (const char **)interfaces, interfacesDimensions);
+
+        size_t resourceTypesDimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
+        char **resourceTypes = (char **)OICMalloc(2 * sizeof(char*));
+        if (!resourceTypes)
+        {
+            OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
+            return NULL;
+        }
+
+        resourceTypes[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_WIFICONF);
+
+        OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_RES_TYPE, (const char **)resourceTypes, resourceTypesDimensions);
+    }
+    else
+    {
+        OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_DEFAULT);
+        OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_READ_WRITE);
+        OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_WIFICONF);
+    }
+
+    // Do not add Read Only Properties when using OC_RSRVD_INTERFACE_READ_WRITE
+    if (strcmp(interface, OC_RSRVD_INTERFACE_READ_WRITE) != 0)
+    {
+        size_t dimensionsModes[MAX_REP_ARRAY_DEPTH] = { g_ESWiFiConfResource.numMode, 0, 0 };
+        const char *modes[NUM_WIFIMODE] = { 0, };
+        for (int i = 0; i < g_ESWiFiConfResource.numMode; ++i)
+        {
+            modes[i] = WiFiModeEnumToString(g_ESWiFiConfResource.supportedMode[i]);
+        }
+        OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_SUPPORTEDWIFIMODE, &modes[0],
+                dimensionsModes);
+
+        size_t dimensionsFreq[MAX_REP_ARRAY_DEPTH] = { g_ESWiFiConfResource.numSupportedFreq, 0, 0 };
+        const char *freq[NUM_WIFIFREQ] = { 0, };
+        for (int i = 0; i < g_ESWiFiConfResource.numSupportedFreq; ++i)
+        {
+            freq[i] = WiFiFreqEnumToString(g_ESWiFiConfResource.supportedFreq[i]);
+        }
+        OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_SUPPORTEDWIFIFREQ, freq, dimensionsFreq);
+    }
 
-    size_t dimensions[MAX_REP_ARRAY_DEPTH] = {gWiFiResource.numMode, 0, 0};
-    int64_t *modes_64 = (int64_t *)OICMalloc(gWiFiResource.numMode * sizeof(int64_t));
-    for(int i = 0 ; i < gWiFiResource.numMode ; ++i)
+    size_t dimensionsAuthType[MAX_REP_ARRAY_DEPTH] = { g_ESWiFiConfResource.numSupportedAuthType, 0,
+            0 };
+    const char *authType[NUM_WIFIAUTHTYPE] = { 0, };
+    for (int i = 0; i < g_ESWiFiConfResource.numSupportedAuthType; ++i)
     {
-        modes_64[i] = gWiFiResource.supportedMode[i];
+        authType[i] = WiFiAuthTypeEnumToString(g_ESWiFiConfResource.supportedAuthType[i]);
     }
-    OCRepPayloadSetIntArray(payload, OC_RSRVD_ES_SUPPORTEDWIFIMODE, (int64_t *)modes_64, dimensions);
+    OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_SUPPORTEDWIFIAUTHTYPE, authType,
+            dimensionsAuthType);
 
-    OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_SUPPORTEDWIFIFREQ, gWiFiResource.supportedFreq);
-    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_SSID, gWiFiResource.ssid);
-    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CRED, gWiFiResource.cred);
-    OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_AUTHTYPE, (int) gWiFiResource.authType);
-    OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_ENCTYPE, (int) gWiFiResource.encType);
+    size_t dimensionsEncType[MAX_REP_ARRAY_DEPTH] =
+            { g_ESWiFiConfResource.numSupportedEncType, 0, 0 };
+    const char *encType[NUM_WIFIENCTYPE] = { 0, };
+    for (int i = 0; i < g_ESWiFiConfResource.numSupportedEncType; ++i)
+    {
+        encType[i] = WiFiEncTypeEnumToString(g_ESWiFiConfResource.supportedEncType[i]);
+    }
+    OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_SUPPORTEDWIFIENCTYPE, encType,
+            dimensionsEncType);
 
-    if(gWriteUserdataCb)
+    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_SSID, g_ESWiFiConfResource.ssid);
+    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CRED, g_ESWiFiConfResource.cred);
+    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_AUTHTYPE,
+            WiFiAuthTypeEnumToString(g_ESWiFiConfResource.authType));
+    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_ENCTYPE,
+            WiFiEncTypeEnumToString(g_ESWiFiConfResource.encType));
+
+    if (gWriteUserdataCb)
     {
-        gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_WIFI);
+        gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_WIFICONF);
+    }
+
+    if (!strcmp(interface, OC_RSRVD_INTERFACE_BATCH))
+    {
+        payload = tempPayload;
+        OCRepPayloadSetPropObject(payload, OC_RSRVD_REPRESENTATION, repPayload);
     }
 
     return payload;
 }
 
-OCRepPayload* constructResponseOfCloud(OCEntityHandlerRequest *ehRequest)
+OCRepPayload* constructResponseOfCoapCloudConf(char *interface)
 {
-    if(ehRequest &&
-        strcmp(ehRequest->query, "") &&
-        !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
+    OCRepPayload* payload = OCRepPayloadCreate();
+    if (!payload)
     {
-        // In case of link list, batch interface
-        OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
+        OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
         return NULL;
     }
 
-    OCRepPayload* payload = OCRepPayloadCreate();
-    if (!payload)
+    if (g_ESCoapCloudConfResource.handle == NULL)
     {
-        OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
+        OIC_LOG(ERROR, ES_RH_TAG, "CoapCloudConf resource is not created");
         return NULL;
     }
 
-    OIC_LOG(INFO, ES_RH_TAG, "constructResponse prov res");
-    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_HREF, OC_RSRVD_ES_URI_CLOUDSERVER);
-    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_AUTHCODE, gCloudResource.authCode);
-    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_AUTHPROVIDER, gCloudResource.authProvider);
-    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CISERVER, gCloudResource.ciServer);
+    OIC_LOG(DEBUG, ES_RH_TAG, "constructResponse CoapCloudConf res");
+    OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_COAPCLOUDCONF);
 
-    if(gWriteUserdataCb)
+    OCRepPayload* repPayload = NULL;
+    OCRepPayload* tempPayload = NULL;
+    if (!strcmp(interface, OC_RSRVD_INTERFACE_BATCH))
     {
-        gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_CLOUDSERVER);
+        repPayload = OCRepPayloadCreate();
+        if (!repPayload)
+        {
+            OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
+            return NULL;
+        }
+
+        tempPayload = payload;
+        payload = repPayload;
+
+        size_t interfacesDimensions[MAX_REP_ARRAY_DEPTH] = {2, 0, 0};
+        char **interfaces = (char **)OICMalloc(3 * sizeof(char*));
+        if (!interfaces)
+        {
+            OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
+            return NULL;
+        }
+
+        interfaces[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
+        interfaces[1] = OICStrdup(OC_RSRVD_INTERFACE_READ_WRITE);
+
+        OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_INTERFACE, (const char **)interfaces, interfacesDimensions);
+
+        size_t resourceTypesDimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
+        char **resourceTypes = (char **)OICMalloc(2 * sizeof(char*));
+        if (!resourceTypes)
+        {
+            OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
+            return NULL;
+        }
+
+        resourceTypes[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF);
+
+        OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_RES_TYPE, (const char **)resourceTypes, resourceTypesDimensions);
+    }
+    else
+    {
+        OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_DEFAULT);
+        OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_READ_WRITE);
+        OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF);
+    }
+
+    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_AUTHCODE, g_ESCoapCloudConfResource.authCode);
+    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_ACCESSTOKEN, g_ESCoapCloudConfResource.accessToken);
+    OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_ACCESSTOKEN_TYPE, (int)g_ESCoapCloudConfResource.accessTokenType);
+    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_AUTHPROVIDER, g_ESCoapCloudConfResource.authProvider);
+    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_CISERVER, g_ESCoapCloudConfResource.ciServer);
+
+    if (gWriteUserdataCb)
+    {
+        gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_COAPCLOUDCONF);
+    }
+
+    if (!strcmp(interface, OC_RSRVD_INTERFACE_BATCH))
+    {
+        payload = tempPayload;
+        OCRepPayloadSetPropObject(payload, OC_RSRVD_REPRESENTATION, repPayload);
     }
 
     return payload;
 }
 
-OCRepPayload* constructResponseOfDevConf(OCEntityHandlerRequest *ehRequest)
+OCRepPayload* constructResponseOfDevConf(char *interface)
 {
-    if(ehRequest &&
-        strcmp(ehRequest->query, "") &&
-        !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
+    OCRepPayload* payload = OCRepPayloadCreate();
+    if (!payload)
     {
-        // In case of link list, batch interface
-        OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
+        OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
         return NULL;
     }
 
-    OCRepPayload* payload = OCRepPayloadCreate();
-    if (!payload)
+    if (g_ESDevConfResource.handle == NULL)
     {
-        OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
+        OIC_LOG(ERROR, ES_RH_TAG, "DevConf resource is not created");
         return NULL;
     }
 
-    OIC_LOG(INFO, ES_RH_TAG, "constructResponse prov res");
-    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_HREF, OC_RSRVD_ES_URI_DEVCONF);
-    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_DEVNAME, gDevConfResource.devName);
-    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_MODELNUMBER, gDevConfResource.modelNumber);
-    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_LOCATION, gDevConfResource.location);
-    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_LANGUAGE, gDevConfResource.language);
-    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_COUNTRY, gDevConfResource.country);
+    OIC_LOG(DEBUG, ES_RH_TAG, "constructResponse DevConf res");
+    OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_DEVCONF);
 
-    if(gWriteUserdataCb)
+    OCRepPayload* repPayload = NULL;
+    OCRepPayload* tempPayload = NULL;
+    if (!strcmp(interface, OC_RSRVD_INTERFACE_BATCH))
+    {
+        repPayload = OCRepPayloadCreate();
+        if (!repPayload)
+        {
+            OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
+            return NULL;
+        }
+
+        tempPayload = payload;
+        payload = repPayload;
+
+        size_t interfacesDimensions[MAX_REP_ARRAY_DEPTH] = {2, 0, 0};
+        char **interfaces = (char **)OICMalloc(3 * sizeof(char*));
+        if (!interfaces)
+        {
+            OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
+            return NULL;
+        }
+
+        interfaces[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
+        interfaces[1] = OICStrdup(OC_RSRVD_INTERFACE_READ);
+
+        OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_INTERFACE, (const char **)interfaces, interfacesDimensions);
+
+        size_t resourceTypesDimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
+        char **resourceTypes = (char **)OICMalloc(2 * sizeof(char*));
+        if (!resourceTypes)
+        {
+            OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
+            return NULL;
+        }
+
+        resourceTypes[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_DEVCONF);
+
+        OCRepPayloadSetStringArray(payload, OC_RSRVD_ES_RES_TYPE, (const char **)resourceTypes, resourceTypesDimensions);
+    }
+    else
+    {
+        OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_DEFAULT);
+        OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_READ);
+        OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_DEVCONF);
+    }
+
+    OCRepPayloadSetPropString(payload, OC_RSRVD_ES_DEVNAME, g_ESDevConfResource.devName);
+
+    if (gWriteUserdataCb)
     {
         gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_DEVCONF);
     }
 
+    if (!strcmp(interface, OC_RSRVD_INTERFACE_BATCH))
+    {
+        payload = tempPayload;
+        OCRepPayloadSetPropObject(payload, OC_RSRVD_REPRESENTATION, repPayload);
+    }
+
     return payload;
 }
 
-OCRepPayload* constructResponseOfProv(OCEntityHandlerRequest *ehRequest)
+OCRepPayload* constructResponseOfEasySetup(OCEntityHandlerRequest *ehRequest)
 {
     OCRepPayload* payload = OCRepPayloadCreate();
     if (!payload)
@@ -623,165 +1049,261 @@ OCRepPayload* constructResponseOfProv(OCEntityHandlerRequest *ehRequest)
         return NULL;
     }
 
-    // Requested interface is Link list interface
-    if(ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_LL))
-    {
-        const OCRepPayload *arrayPayload[3] = {NULL};
+    OIC_LOG_V(DEBUG, ES_RH_TAG, "constructResponseOfEasySetup: qry = %s",
+            (ehRequest->query) ? (ehRequest->query) : "null");
+
+    // Requested interface is Link list or baseline interface
+     if (!ehRequest->query ||
+         (ehRequest->query && !strcmp(ehRequest->query, "")) ||
+         (ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_LL)) ||
+         (ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT)))
+     {
+        size_t arraySize;
+        OCRepPayload **linkArr = OCLinksPayloadArrayCreate(OC_RSRVD_ES_URI_EASYSETUP, ehRequest,
+            true, &arraySize);
 
-        int childResCnt = 0;
+#ifdef ES_IGNORE_OCLinksPayloadArrayCreate_FAILIURE
+        bool linkArrConstructed = true; // TODO: Remove this when
+                                        // ES_IGNORE_OCLinksPayloadArrayCreate_FAILIURE is removed.
+#endif
 
-        if(gWiFiResource.handle != NULL)
+        if (!linkArr || (arraySize == 0))
+        {
+            OIC_LOG(ERROR, ES_RH_TAG, "Failed to create Easy Setup collections ll response.");
+
+#ifdef ES_IGNORE_OCLinksPayloadArrayCreate_FAILIURE
+            linkArrConstructed = false;
+#else
+            OICFree(linkArr);
+            OCRepPayloadDestroy(payload);
+            return NULL;
+#endif
+        }
+#ifndef ES_IGNORE_OCLinksPayloadArrayCreate_FAILIURE
+        else
         {
-            OCRepPayload *add = OCRepPayloadCreate();
-            if(!add)
+#endif
+            OIC_LOG(DEBUG, ES_RH_TAG, "Constructed links payload.");
+
+            if (!ehRequest->query || (ehRequest->query && !strcmp(ehRequest->query, ""))
+                    || (ehRequest->query
+                            && CompareResourceInterface(ehRequest->query,
+                                    OC_RSRVD_INTERFACE_DEFAULT)))
             {
-                OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
-                return NULL;
+                OIC_LOG(DEBUG, ES_RH_TAG, "constructResponse EasySetup res (Default interface)");
+                OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_EASYSETUP);
+                OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_DEFAULT);
+                OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_LL);
+                OCRepPayloadAddInterface(payload, OC_RSRVD_INTERFACE_BATCH);
+                OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_EASYSETUP);
+                OCRepPayloadAddResourceType(payload, OC_RSRVD_ES_RES_TYPE_COL);
+
+                OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_PROVSTATUS,
+                        g_ESEasySetupResource.status);
+                OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_LAST_ERRORCODE,
+                        g_ESEasySetupResource.lastErrCode);
+
+                if (g_ESEasySetupResource.numRequest > 0)
+                {
+                    size_t dimensions[MAX_REP_ARRAY_DEPTH] = { g_ESEasySetupResource.numRequest, 0,
+                            0 };
+                    int64_t *connectRequest = (int64_t *) OICMalloc(
+                            g_ESEasySetupResource.numRequest * sizeof(int64_t));
+                    if (!connectRequest)
+                    {
+                        OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
+                        return NULL;
+                    }
+
+                    for (int i = 0; i < g_ESEasySetupResource.numRequest; ++i)
+                    {
+                        connectRequest[i] = g_ESEasySetupResource.connectRequest[i];
+                    }
+
+                    bool b = OCRepPayloadSetIntArrayAsOwner(payload, OC_RSRVD_ES_CONNECT,
+                            (int64_t *) connectRequest, dimensions);
+                    if (!b)
+                    {
+                        OIC_LOG(ERROR, ES_RH_TAG, "Failed to set array value for Connect property");
+                        OICFree(connectRequest);
+                    }
+                }
+                else
+                {
+                    OIC_LOG(DEBUG, ES_RH_TAG, "g_ESEasySetupResource.numRequest is 0");
+                    size_t dimensions[MAX_REP_ARRAY_DEPTH] = { 0, 0, 0 };
+                    OCRepPayloadSetIntArrayAsOwner(payload, OC_RSRVD_ES_CONNECT, NULL, dimensions);
+                }
+
+                if (gWriteUserdataCb)
+                {
+                    gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_EASYSETUP);
+                }
+
+#ifdef ES_IGNORE_OCLinksPayloadArrayCreate_FAILIURE
+                if (linkArrConstructed)
+                {
+#endif
+                    size_t dimensions[MAX_REP_ARRAY_DEPTH] = { arraySize, 0, 0 };
+                    OCRepPayloadSetPropObjectArray(payload, OC_RSRVD_LINKS,
+                            (const OCRepPayload **) linkArr, dimensions);
+                    for (size_t i = 0; i < arraySize; ++i)
+                    {
+                        OCRepPayloadDestroy(linkArr[i]);
+                    }
+#ifdef ES_IGNORE_OCLinksPayloadArrayCreate_FAILIURE
+                }
+#endif
             }
-
-            size_t dimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
-            char **resourceType = NULL;
-            resourceType = (char **)OICMalloc(sizeof(char *) * 1);
-            char **resourceInterface = NULL;
-            resourceInterface = (char **)OICMalloc(sizeof(char *) * 1);
-
-            if(!resourceType || !resourceInterface)
+            else // link list interface
             {
-                OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
-                return NULL;
+#ifdef ES_IGNORE_OCLinksPayloadArrayCreate_FAILIURE
+                if (linkArrConstructed)
+                {
+#endif
+                    uint16_t acceptVersion = 0;
+                    OCPayloadFormat contentFormat; // not used
+                    OCGetRequestPayloadVersion(ehRequest, &contentFormat, &acceptVersion);
+                    // acceptVersion("OCF-Accept-Content-Format-Version") is present for OCF Request
+                    if (acceptVersion != 0)
+                    {
+                        for (size_t i = 0; i < arraySize - 1; ++i)
+                        {
+                            linkArr[i]->next = linkArr[i + 1];
+                        }
+                        // payload is directly the linkArr array, free earlier allocated memory.
+                        OCRepPayloadDestroy(payload);
+                        payload = linkArr[0];
+                    }
+                    else // for backward compatibility with OIC
+                    {
+                        size_t dimensions[MAX_REP_ARRAY_DEPTH] = { arraySize, 0, 0 };
+                        OCRepPayloadSetPropObjectArray(payload, OC_RSRVD_LINKS,
+                                (const OCRepPayload **) linkArr, dimensions);
+                        for (size_t i = 0; i < arraySize; ++i)
+                        {
+                            OCRepPayloadDestroy(linkArr[i]);
+                        }
+                    }
+#ifdef ES_IGNORE_OCLinksPayloadArrayCreate_FAILIURE
+                }
+#endif
             }
+#ifndef ES_IGNORE_OCLinksPayloadArrayCreate_FAILIURE
+        }
+#endif
+        OICFree(linkArr);
+    }
+    else if (ehRequest->query
+            && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH))
+    {
+        OIC_LOG(DEBUG, ES_RH_TAG, "constructResponse EasySetup res (Batch Interface)");
+        OCRepPayloadSetUri(payload, OC_RSRVD_ES_URI_EASYSETUP);
 
-            resourceType[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_WIFI);
-            resourceInterface[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
-
-            add->base.type = PAYLOAD_TYPE_REPRESENTATION;
-            OCRepPayloadSetPropString(add, OC_RSRVD_HREF, OC_RSRVD_ES_URI_WIFI);
-            OCRepPayloadSetStringArray(add, OC_RSRVD_RESOURCE_TYPE,
-                                            (const char **)resourceType, dimensions);
-            OCRepPayloadSetStringArray(add, OC_RSRVD_INTERFACE,
-                                            (const char **)resourceInterface, dimensions);
+        OCRepPayload* repPayload = NULL;
 
-            arrayPayload[childResCnt++] = add;
+        repPayload = OCRepPayloadCreate();
+        if (!repPayload)
+        {
+            OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
+            return NULL;
         }
 
-        if(gDevConfResource.handle != NULL)
+        size_t interfacesDimensions[MAX_REP_ARRAY_DEPTH] = { 3, 0, 0 };
+        char **interfaces = (char **) OICMalloc(3 * sizeof(char*));
+        if (!interfaces)
         {
-            OCRepPayload *add = OCRepPayloadCreate();
-            if(!add)
-            {
-                OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
-                return NULL;
-            }
+            OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
+            return NULL;
+        }
 
-            size_t dimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
-            char **resourceType = NULL;
-            resourceType = (char **)OICMalloc(sizeof(char *) * 1);
-            char **resourceInterface = NULL;
-            resourceInterface = (char **)OICMalloc(sizeof(char *) * 1);
+        interfaces[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
+        interfaces[1] = OICStrdup(OC_RSRVD_INTERFACE_LL);
+        interfaces[2] = OICStrdup(OC_RSRVD_INTERFACE_BATCH);
 
-            if(!resourceType || !resourceInterface)
-            {
-                OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
-                return NULL;
-            }
+        OCRepPayloadSetStringArray(repPayload, OC_RSRVD_ES_INTERFACE, (const char **) interfaces,
+                interfacesDimensions);
 
-            resourceType[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_DEVCONF);
-            resourceInterface[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
+        size_t resourceTypesDimensions[MAX_REP_ARRAY_DEPTH] = { 2, 0, 0 };
+        char **resourceTypes = (char **) OICMalloc(2 * sizeof(char*));
+        if (!resourceTypes)
+        {
+            OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
+            return NULL;
+        }
 
-            add->base.type = PAYLOAD_TYPE_REPRESENTATION;
-            OCRepPayloadSetPropString(add, OC_RSRVD_HREF, OC_RSRVD_ES_URI_DEVCONF);
-            OCRepPayloadSetStringArray(add, OC_RSRVD_RESOURCE_TYPE,
-                                            (const char **)resourceType, dimensions);
-            OCRepPayloadSetStringArray(add, OC_RSRVD_INTERFACE,
-                                            (const char **)resourceInterface, dimensions);
+        resourceTypes[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_EASYSETUP);
+        resourceTypes[1] = OICStrdup(OC_RSRVD_ES_RES_TYPE_COL);
 
-            arrayPayload[childResCnt++] = add;
-        }
+        OCRepPayloadSetStringArray(repPayload, OC_RSRVD_ES_RES_TYPE, (const char **) resourceTypes,
+                resourceTypesDimensions);
 
-        if(gCloudResource.handle != NULL)
+        OCRepPayloadSetPropInt(repPayload, OC_RSRVD_ES_PROVSTATUS, g_ESEasySetupResource.status);
+        OCRepPayloadSetPropInt(repPayload, OC_RSRVD_ES_LAST_ERRORCODE,
+                g_ESEasySetupResource.lastErrCode);
+        if (g_ESEasySetupResource.numRequest > 0)
         {
-            OCRepPayload *add = OCRepPayloadCreate();
-            if(!add)
+            size_t dimensions[MAX_REP_ARRAY_DEPTH] = { g_ESEasySetupResource.numRequest, 0, 0 };
+            int64_t *connectRequest = (int64_t *) OICMalloc(
+                    g_ESEasySetupResource.numRequest * sizeof(int64_t));
+            if (!connectRequest)
             {
                 OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
                 return NULL;
             }
 
-            size_t dimensions[MAX_REP_ARRAY_DEPTH] = {1, 0, 0};
-            char **resourceType = NULL;
-            resourceType = (char **)OICMalloc(sizeof(char *) * 1);
-            char **resourceInterface = NULL;
-            resourceInterface = (char **)OICMalloc(sizeof(char *) * 1);
-
-            if(!resourceType || !resourceInterface)
+            for (int i = 0; i < g_ESEasySetupResource.numRequest; ++i)
             {
-                OIC_LOG(ERROR, ES_RH_TAG, "Failed to allocate Payload");
-                return NULL;
+                connectRequest[i] = g_ESEasySetupResource.connectRequest[i];
             }
 
-            resourceType[0] = OICStrdup(OC_RSRVD_ES_RES_TYPE_CLOUDSERVER);
-            resourceInterface[0] = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
-
-            add->base.type = PAYLOAD_TYPE_REPRESENTATION;
-            OCRepPayloadSetPropString(add, OC_RSRVD_HREF, OC_RSRVD_ES_URI_CLOUDSERVER);
-            OCRepPayloadSetStringArray(add, OC_RSRVD_RESOURCE_TYPE,
-                                            (const char **)resourceType, dimensions);
-            OCRepPayloadSetStringArray(add, OC_RSRVD_INTERFACE,
-                                            (const char **)resourceInterface, dimensions);
-
-            arrayPayload[childResCnt++] = add;
+            bool b = OCRepPayloadSetIntArrayAsOwner(repPayload, OC_RSRVD_ES_CONNECT,
+                    (int64_t *) connectRequest, dimensions);
+            if (!b)
+            {
+                OIC_LOG(ERROR, ES_RH_TAG, "Failed to set array value for Connect property");
+                OICFree(connectRequest);
+            }
+        }
+        else
+        {
+            OIC_LOG(DEBUG, ES_RH_TAG, "g_ESEasySetupResource.numRequest is 0");
+            size_t dimensions[MAX_REP_ARRAY_DEPTH] = { 0, 0, 0 };
+            OCRepPayloadSetIntArrayAsOwner(repPayload, OC_RSRVD_ES_CONNECT, NULL, dimensions);
         }
 
-        size_t dimensions[MAX_REP_ARRAY_DEPTH] = {childResCnt, 0, 0};
-        OCRepPayloadSetPropObjectArray(payload, OC_RSRVD_ES_LINKS, arrayPayload, dimensions);
+        if (gWriteUserdataCb)
+        {
+            gWriteUserdataCb(repPayload, OC_RSRVD_ES_RES_TYPE_EASYSETUP);
+        }
 
-        return payload;
-    } else if (!ehRequest->query ||
-        (ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH)) ||
-        (ehRequest->query && CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT)))
-    {
-        OIC_LOG(INFO, ES_RH_TAG, "constructResponse prov res");
-        OCRepPayloadSetPropString(payload, OC_RSRVD_ES_HREF, OC_RSRVD_ES_URI_PROV);
-        OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_PROVSTATUS, gProvResource.status);
-        OCRepPayloadSetPropInt(payload, OC_RSRVD_ES_LAST_ERRORCODE, gProvResource.lastErrCode);
-        OCRepPayloadSetPropString(payload, OC_RSRVD_ES_LINKS, gProvResource.ocfWebLinks);
-    }
+        OCRepPayloadSetPropObject(payload, OC_RSRVD_REPRESENTATION, repPayload);
 
-    if(gWriteUserdataCb)
-    {
-        gWriteUserdataCb(payload, OC_RSRVD_ES_RES_TYPE_PROV);
-    }
+        OCRepPayload* head = payload;
+        OCRepPayload* nextPayload = NULL;
 
-    if(ehRequest->query)
-    {
-        if(CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH))
-        {// When Provisioning resource has a GET with BatchInterface
-            OCRepPayload* head = payload;
-            OCRepPayload* nextPayload = NULL;
+        nextPayload = constructResponseOfWiFiConf(OC_RSRVD_INTERFACE_BATCH);
+        if (nextPayload != NULL)
+        {
+            payload->next = nextPayload;
+            payload = payload->next;
+        }
 
-            nextPayload = constructResponseOfWiFi(NULL);
-            if(nextPayload != NULL)
-            {
-                payload->next = nextPayload;
-                payload = payload->next;
-            }
+        nextPayload = constructResponseOfCoapCloudConf(OC_RSRVD_INTERFACE_BATCH);
+        if (nextPayload != NULL)
+        {
+            payload->next = nextPayload;
+            payload = payload->next;
+        }
 
-            nextPayload = constructResponseOfCloud(NULL);
-            if(nextPayload != NULL)
-            {
-                payload->next = nextPayload;
-                payload = payload->next;
-            }
+        nextPayload = constructResponseOfDevConf(OC_RSRVD_INTERFACE_BATCH);
+        if (nextPayload != NULL)
+        {
+            payload->next = nextPayload;
+        }
 
-            nextPayload = constructResponseOfDevConf(NULL);
-            if(nextPayload != NULL)
-            {
-                payload->next = nextPayload;
-                payload = payload->next;
-            }
+        payload = head;
 
-            payload = head;
-        }
     }
 
     return payload;
@@ -793,90 +1315,77 @@ OCStackResult CreateEasySetupResources(bool isSecured, ESResourceMask resourceMa
     OCStackResult res = OC_STACK_ERROR;
     bool maskFlag = false;
 
-    res = initProvResource(isSecured);
-    if(res != OC_STACK_OK)
+    res = initEasySetupResource(isSecured);
+    if (res != OC_STACK_OK)
     {
         // TODO: destroy logic will be added
-        OIC_LOG_V(ERROR, ES_RH_TAG, "initProvResource result: %s", getResult(res));
+        OIC_LOG_V(ERROR, ES_RH_TAG, "initEasySetupResource result: %s", getResult(res));
 
         return res;
     }
 
-    if((resourceMask & ES_WIFI_RESOURCE) == ES_WIFI_RESOURCE)
+    if ((resourceMask & ES_WIFICONF_RESOURCE) == ES_WIFICONF_RESOURCE)
     {
         maskFlag = true;
-        res = initWiFiResource(isSecured);
-        if(res != OC_STACK_OK)
+        res = initWiFiConfResource(isSecured);
+        if (res != OC_STACK_OK)
         {
-            OIC_LOG_V(ERROR, ES_RH_TAG, "initWiFiResource result: %s", getResult(res));
+            OIC_LOG_V(ERROR, ES_RH_TAG, "initWiFiConfResource result: %s", getResult(res));
             return res;
         }
 
-        res = OCBindResource(gProvResource.handle, gWiFiResource.handle);
-        if(res != OC_STACK_OK)
+        res = OCBindResource(g_ESEasySetupResource.handle, g_ESWiFiConfResource.handle);
+        if (res != OC_STACK_OK)
         {
-            OIC_LOG_V(ERROR, ES_RH_TAG, "Bind WiFiResource result: %s", getResult(res));
+            OIC_LOG_V(ERROR, ES_RH_TAG, "Bind WiFiConfResource result: %s", getResult(res));
             return res;
         }
-
     }
 
-    if((resourceMask & ES_CLOUD_RESOURCE) == ES_CLOUD_RESOURCE)
+    if ((resourceMask & ES_COAPCLOUDCONF_RESOURCE) == ES_COAPCLOUDCONF_RESOURCE)
     {
         maskFlag = true;
-        res = initCloudServerResource(isSecured);
-        if(res != OC_STACK_OK)
+        res = initCoapCloudConfResource(isSecured);
+        if (res != OC_STACK_OK)
         {
-            OIC_LOG_V(ERROR, ES_RH_TAG, "initCloudResource result: %s", getResult(res));
+            OIC_LOG_V(ERROR, ES_RH_TAG, "initCoapCloudConfResource result: %s", getResult(res));
             return res;
         }
 
-        res = OCBindResource(gProvResource.handle, gCloudResource.handle);
-        if(res != OC_STACK_OK)
+        res = OCBindResource(g_ESEasySetupResource.handle, g_ESCoapCloudConfResource.handle);
+        if (res != OC_STACK_OK)
         {
-            OIC_LOG_V(ERROR, ES_RH_TAG, "Bind CloudResource result: %s", getResult(res));
+            OIC_LOG_V(ERROR, ES_RH_TAG, "Bind CoapCloudConfResource result: %s", getResult(res));
             return res;
         }
     }
 
-    if((resourceMask & ES_DEVCONF_RESOURCE) == ES_DEVCONF_RESOURCE)
+    if ((resourceMask & ES_DEVCONF_RESOURCE) == ES_DEVCONF_RESOURCE)
     {
         maskFlag = true;
         res = initDevConfResource(isSecured);
-        if(res != OC_STACK_OK)
+        if (res != OC_STACK_OK)
         {
             OIC_LOG_V(ERROR, ES_RH_TAG, "initDevConf result: %s", getResult(res));
             return res;
         }
 
-        res = OCBindResource(gProvResource.handle, gDevConfResource.handle);
-        if(res != OC_STACK_OK)
+        res = OCBindResource(g_ESEasySetupResource.handle, g_ESDevConfResource.handle);
+        if (res != OC_STACK_OK)
         {
             OIC_LOG_V(ERROR, ES_RH_TAG, "Bind DevConfResource result: %s", getResult(res));
             return res;
         }
     }
 
-
-    if(maskFlag == false)
+    if (maskFlag == false)
     {
         OIC_LOG_V(ERROR, ES_RH_TAG, "Invalid ResourceMask");
         return OC_STACK_ERROR;
 
     }
 
-    OIC_LOG_V(INFO, ES_RH_TAG, "Created all resources with result: %s", getResult(res));
-
-    return res;
-}
-
-OCStackResult DeleteProvisioningResource()
-{
-    OCStackResult res = OCDeleteResource(gProvResource.handle);
-    if (res != OC_STACK_OK)
-    {
-        OIC_LOG_V(INFO, ES_RH_TAG, "Deleting Prov resource error with result: %s", getResult(res));
-    }
+    OIC_LOG_V(DEBUG, ES_RH_TAG, "Created all resources with result: %s", getResult(res));
 
     return res;
 }
@@ -884,61 +1393,61 @@ OCStackResult DeleteProvisioningResource()
 OCStackResult DeleteEasySetupResources()
 {
     OCStackResult res = OC_STACK_ERROR;
-    if (gWiFiResource.handle != NULL)
+    if (g_ESWiFiConfResource.handle != NULL)
     {
-        res = OCUnBindResource(gProvResource.handle, gWiFiResource.handle);
-        if(res != OC_STACK_OK)
+        res = OCUnBindResource(g_ESEasySetupResource.handle, g_ESWiFiConfResource.handle);
+        if (res != OC_STACK_OK)
         {
             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind WiFi resource error with result: %s", getResult(res));
         }
     }
-    if (gCloudResource.handle != NULL)
+    if (g_ESCoapCloudConfResource.handle != NULL)
     {
-        res = OCUnBindResource(gProvResource.handle, gCloudResource.handle);
-        if(res != OC_STACK_OK)
+        res = OCUnBindResource(g_ESEasySetupResource.handle, g_ESCoapCloudConfResource.handle);
+        if (res != OC_STACK_OK)
         {
             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind CloudServer resource error with result: %s", getResult(res));
         }
     }
-    if (gDevConfResource.handle != NULL)
+    if (g_ESDevConfResource.handle != NULL)
     {
-        res = OCUnBindResource(gProvResource.handle, gDevConfResource.handle);
-        if(res != OC_STACK_OK)
+        res = OCUnBindResource(g_ESEasySetupResource.handle, g_ESDevConfResource.handle);
+        if (res != OC_STACK_OK)
         {
             OIC_LOG_V(ERROR, ES_RH_TAG, "Unbind DevConf resource error with result: %s", getResult(res));
         }
     }
 
-    if (gWiFiResource.handle != NULL)
+    if (g_ESWiFiConfResource.handle != NULL)
     {
-        res = OCDeleteResource(gWiFiResource.handle);
+        res = OCDeleteResource(g_ESWiFiConfResource.handle);
         if (res != OC_STACK_OK)
         {
             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting WiFi resource error with result: %s", getResult(res));
         }
     }
 
-    if(gCloudResource.handle != NULL)
+    if (g_ESCoapCloudConfResource.handle != NULL)
     {
-        res = OCDeleteResource(gCloudResource.handle);
+        res = OCDeleteResource(g_ESCoapCloudConfResource.handle);
         if (res != OC_STACK_OK)
         {
             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting CloudServer resource error with result: %s", getResult(res));
         }
     }
 
-    if(gDevConfResource.handle != NULL)
+    if (g_ESDevConfResource.handle != NULL)
     {
-        res = OCDeleteResource(gDevConfResource.handle);
+        res = OCDeleteResource(g_ESDevConfResource.handle);
         if (res != OC_STACK_OK)
         {
             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting DevConf resource error with result: %s", getResult(res));
         }
     }
 
-    if(gProvResource.handle != NULL)
+    if (g_ESEasySetupResource.handle != NULL)
     {
-        res = OCDeleteResource(gProvResource.handle);
+        res = OCDeleteResource(g_ESEasySetupResource.handle);
         if (res != OC_STACK_OK)
         {
             OIC_LOG_V(ERROR, ES_RH_TAG, "Deleting Prov resource error with result: %s", getResult(res));
@@ -948,6 +1457,13 @@ OCStackResult DeleteEasySetupResources()
     return res;
 }
 
+static bool isValidESResourceHandle(OCResourceHandle handle)
+{
+    return ((handle == g_ESEasySetupResource.handle) || (handle == g_ESWiFiConfResource.handle)
+            || (handle == g_ESCoapCloudConfResource.handle)
+            || (handle == g_ESDevConfResource.handle));
+}
+
 OCEntityHandlerResult ProcessGetRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload **payload)
 {
     OCEntityHandlerResult ehResult = OC_EH_ERROR;
@@ -961,25 +1477,45 @@ OCEntityHandlerResult ProcessGetRequest(OCEntityHandlerRequest *ehRequest, OCRep
         OIC_LOG(ERROR, ES_RH_TAG, "Incoming payload not a representation");
         return ehResult;
     }
+    if (!isValidESResourceHandle(ehRequest->resource))
+    {
+        OIC_LOG(ERROR, ES_RH_TAG, "Request does not have a valid Easy Setup Resource handle");
+        return ehResult;
+    }
+    if (CheckEhRequestPayload(ehRequest) != OC_EH_OK)
+    {
+        OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
+        return OC_EH_BAD_REQ;
+    }
 
     OCRepPayload *getResp = NULL;
+    *payload = NULL;
 
-    if(ehRequest->resource == gProvResource.handle)
+    char *iface_name = NULL;
+    GetInterfaceNameFromQuery(ehRequest->query, &iface_name);
+    if (!iface_name)
     {
-        getResp = constructResponseOfProv(ehRequest);
+        iface_name = OICStrdup(OC_RSRVD_INTERFACE_DEFAULT);
     }
-    else if(ehRequest->resource == gWiFiResource.handle)
+
+    if (ehRequest->resource == g_ESEasySetupResource.handle)
     {
-        getResp = constructResponseOfWiFi(ehRequest);
+            getResp = constructResponseOfEasySetup(ehRequest);
     }
-    else if(ehRequest->resource == gCloudResource.handle)
+    else if (ehRequest->resource == g_ESWiFiConfResource.handle)
     {
-        getResp = constructResponseOfCloud(ehRequest);
+            getResp = constructResponseOfWiFiConf(iface_name);
     }
-    else if(ehRequest->resource == gDevConfResource.handle)
+    else if (ehRequest->resource == g_ESCoapCloudConfResource.handle)
     {
-        getResp = constructResponseOfDevConf(ehRequest);
+            getResp = constructResponseOfCoapCloudConf(iface_name);
     }
+    else if (ehRequest->resource == g_ESDevConfResource.handle)
+    {
+            getResp = constructResponseOfDevConf(iface_name);
+    }
+
+    OICFree(iface_name);
 
     if (!getResp)
     {
@@ -995,7 +1531,8 @@ OCEntityHandlerResult ProcessGetRequest(OCEntityHandlerRequest *ehRequest, OCRep
 
 OCEntityHandlerResult ProcessPostRequest(OCEntityHandlerRequest *ehRequest, OCRepPayload** payload)
 {
-    OIC_LOG(INFO, ES_RH_TAG, "ProcessPostRequest enter");
+    OIC_LOG(DEBUG, ES_RH_TAG, "ProcessPostRequest enter");
+
     OCEntityHandlerResult ehResult = OC_EH_ERROR;
     if (ehRequest->payload && ehRequest->payload->type != PAYLOAD_TYPE_REPRESENTATION)
     {
@@ -1010,39 +1547,85 @@ OCEntityHandlerResult ProcessPostRequest(OCEntityHandlerRequest *ehRequest, OCRe
         return ehResult;
     }
 
-    if(ehRequest->resource == gProvResource.handle)
+    OIC_LOG_PAYLOAD(DEBUG, (OCPayload *)input);
+
+    if (ehRequest->resource == g_ESEasySetupResource.handle)
     {
-        updateProvResource(ehRequest, input);
+        if (ehRequest->query &&
+            strcmp(ehRequest->query, "") &&
+            !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_BATCH) &&
+            !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
+        {
+            OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
+            return OC_EH_BAD_REQ;
+        }
+        else
+        {
+            if (updateEasySetupResource(ehRequest, input) != OC_EH_OK)
+            {
+                OIC_LOG(ERROR, ES_RH_TAG, "Failed to update EasySetup resource.");
+                return OC_EH_BAD_REQ;
+            }
+        }
     }
-    else if(ehRequest->resource == gWiFiResource.handle)
+    else if (ehRequest->resource == g_ESWiFiConfResource.handle)
     {
-        updateWiFiResource(ehRequest, input);
+        if (CheckEhRequestPayload(ehRequest) != OC_EH_OK)
+        {
+            OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
+            return OC_EH_BAD_REQ;
+        }
+        else
+        {
+            if (updateWiFiConfResource(input) != OC_EH_OK)
+            {
+                OIC_LOG(ERROR, ES_RH_TAG, "Failed to update WifiConf resource.");
+                return OC_EH_BAD_REQ;
+            }
+        }
     }
-    else if(ehRequest->resource == gCloudResource.handle)
+    else if (ehRequest->resource == g_ESCoapCloudConfResource.handle)
     {
-        updateCloudResource(ehRequest, input);
+        if (CheckEhRequestPayload(ehRequest) != OC_EH_OK)
+        {
+            OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
+            return OC_EH_BAD_REQ;
+        }
+        else
+        {
+            updateCoapCloudConfResource(input);
+        }
     }
-    else if(ehRequest->resource == gDevConfResource.handle)
+    else if (ehRequest->resource == g_ESDevConfResource.handle)
     {
-        updateDevConfResource(ehRequest, input);
+        if (ehRequest->query && strcmp(ehRequest->query, "")
+                && !CompareResourceInterface(ehRequest->query, OC_RSRVD_INTERFACE_DEFAULT))
+        {
+            OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
+            return OC_EH_BAD_REQ;
+        }
+        else
+        {
+            updateDevConfResource(input);
+        }
     }
 
     OCRepPayload *getResp = NULL;
-    if(ehRequest->resource == gProvResource.handle)
+    if (ehRequest->resource == g_ESEasySetupResource.handle)
     {
-        getResp = constructResponseOfProv(ehRequest);
+        getResp = constructResponseOfEasySetup(ehRequest);
     }
-    else if(ehRequest->resource == gWiFiResource.handle)
+    else if (ehRequest->resource == g_ESWiFiConfResource.handle)
     {
-        getResp = constructResponseOfWiFi(NULL);
+        getResp = constructResponseOfWiFiConf(OC_RSRVD_INTERFACE_DEFAULT);
     }
-    else if(ehRequest->resource == gCloudResource.handle)
+    else if (ehRequest->resource == g_ESCoapCloudConfResource.handle)
     {
-        getResp = constructResponseOfCloud(NULL);
+        getResp = constructResponseOfCoapCloudConf(OC_RSRVD_INTERFACE_DEFAULT);
     }
-    else if(ehRequest->resource == gDevConfResource.handle)
+    else if (ehRequest->resource == g_ESDevConfResource.handle)
     {
-        getResp = constructResponseOfDevConf(NULL);
+        getResp = constructResponseOfDevConf(OC_RSRVD_INTERFACE_DEFAULT);
     }
 
     if (!getResp)
@@ -1062,10 +1645,11 @@ OCEntityHandlerResult ProcessPutRequest(OCEntityHandlerRequest * ehRequest,
 {
     (void) ehRequest;
     (void) payload;
-    OCEntityHandlerResult ehResult = OC_EH_METHOD_NOT_ALLOWED;
+    OCEntityHandlerResult ehResult = OC_EH_BAD_REQ;
 
     return ehResult;
 }
+
 /**
  * This is the entity handler for the registered resource.
  * This is invoked by OCStack whenever it recevies a request for this resource.
@@ -1085,15 +1669,15 @@ OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag,
     {
         if (OC_REST_GET == entityHandlerRequest->method)
         {
-            OIC_LOG(INFO, ES_RH_TAG, "Received GET request");
+            OIC_LOG(DEBUG, ES_RH_TAG, "Received GET request");
             ehRet = ProcessGetRequest(entityHandlerRequest, &payload);
         }
         else if (OC_REST_PUT == entityHandlerRequest->method)
         {
-            OIC_LOG(INFO, ES_RH_TAG, "Received PUT request");
+            OIC_LOG(DEBUG, ES_RH_TAG, "Received PUT request");
 
             //PUT request will be handled in the internal implementation
-            if (gProvResource.handle != NULL)
+            if (g_ESEasySetupResource.handle != NULL)
             {
                 ehRet = ProcessPutRequest(entityHandlerRequest, &payload);
             }
@@ -1105,8 +1689,8 @@ OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag,
         }
         else if (OC_REST_POST == entityHandlerRequest->method)
         {
-            OIC_LOG(INFO, ES_RH_TAG, "Received OC_REST_POST from client");
-            if (gProvResource.handle != NULL)
+            OIC_LOG(DEBUG, ES_RH_TAG, "Received OC_REST_POST from client");
+            if (g_ESEasySetupResource.handle != NULL)
             {
                 ehRet = ProcessPostRequest(entityHandlerRequest, &payload);
             }
@@ -1119,7 +1703,6 @@ OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag,
 
         // Format the response.  Note this requires some info about the request
         response.requestHandle = entityHandlerRequest->requestHandle;
-        response.resourceHandle = entityHandlerRequest->resource;
         response.ehResult = ehRet;
         //response uses OCPaylod while all get,put methodes use OCRepPayload
         response.payload = (OCPayload*) (payload);
@@ -1137,59 +1720,169 @@ OCEntityHandlerResult OCEntityHandlerCb(OCEntityHandlerFlag flag,
             ehRet = OC_EH_ERROR;
         }
     }
+    if (entityHandlerRequest && (flag & OC_OBSERVE_FLAG))
+    {
+        OIC_LOG(DEBUG, ES_RH_TAG, "Flag includes OC_OBSERVE_FLAG");
 
+        if (OC_OBSERVE_REGISTER == entityHandlerRequest->obsInfo.action)
+        {
+            OIC_LOG(DEBUG, ES_RH_TAG, "Received OC_OBSERVE_REGISTER from Mediator");
+        }
+        else if (OC_OBSERVE_DEREGISTER == entityHandlerRequest->obsInfo.action)
+        {
+            OIC_LOG(DEBUG, ES_RH_TAG, "Received OC_OBSERVE_DEREGISTER from Mediator");
+        }
+    }
     return ehRet;
 }
 
 OCStackResult SetDeviceProperty(ESDeviceProperty *deviceProperty)
 {
-    OIC_LOG(INFO, ES_RH_TAG, "SetDeviceProperty IN");
+    OIC_LOG(DEBUG, ES_RH_TAG, "SetDeviceProperty IN");
+
+    if (deviceProperty->WiFi.numSupportedMode > NUM_WIFIMODE
+            || deviceProperty->WiFi.numSupportedFreq > NUM_WIFIFREQ
+            || deviceProperty->WiFi.numSupportedAuthType > NUM_WIFIAUTHTYPE
+            || deviceProperty->WiFi.numSupportedEncType > NUM_WIFIENCTYPE)
+    {
+        OIC_LOG(ERROR, ES_RH_TAG, "SetDeviceProperty: Invalid Input Param");
+        return OC_STACK_INVALID_PARAM;
+    }
 
-    gWiFiResource.supportedFreq = (deviceProperty->WiFi).freq;
-    OIC_LOG_V(INFO, ES_RH_TAG, "WiFi Freq : %d", gWiFiResource.supportedFreq);
+    g_ESWiFiConfResource.numSupportedFreq = deviceProperty->WiFi.numSupportedFreq;
+    for (uint8_t i = 0; i < g_ESWiFiConfResource.numSupportedFreq; ++i)
+    {
+        g_ESWiFiConfResource.supportedFreq[i] = (deviceProperty->WiFi).supportedFreq[i];
+        OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "WiFi Freq : %d", g_ESWiFiConfResource.supportedFreq[i]);
+    }
 
-    int modeIdx = 0;
-    while((deviceProperty->WiFi).mode[modeIdx] != WiFi_EOF)
+    g_ESWiFiConfResource.numMode = deviceProperty->WiFi.numSupportedMode;
+    for (uint8_t i = 0; i < g_ESWiFiConfResource.numMode; ++i)
     {
-        gWiFiResource.supportedMode[modeIdx] = (deviceProperty->WiFi).mode[modeIdx];
-        OIC_LOG_V(INFO, ES_RH_TAG, "WiFi Mode : %d", gWiFiResource.supportedMode[modeIdx]);
-        modeIdx ++;
+        g_ESWiFiConfResource.supportedMode[i] = (deviceProperty->WiFi).supportedMode[i];
+        OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "WiFi Mode : %d", g_ESWiFiConfResource.supportedMode[i]);
     }
-    gWiFiResource.numMode = modeIdx;
 
-    OICStrcpy(gDevConfResource.devName, OIC_STRING_MAX_VALUE, (deviceProperty->DevConf).deviceName);
-    OIC_LOG_V(INFO, ES_RH_TAG, "Device Name : %s", gDevConfResource.devName);
+    g_ESWiFiConfResource.numSupportedAuthType = deviceProperty->WiFi.numSupportedAuthType;
+    for (uint8_t i = 0; i < g_ESWiFiConfResource.numSupportedAuthType; ++i)
+    {
+        g_ESWiFiConfResource.supportedAuthType[i] = (deviceProperty->WiFi).supportedAuthType[i];
+        OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "WiFi Auth Type : %d",
+                g_ESWiFiConfResource.supportedAuthType[i]);
+    }
 
-    OICStrcpy(gDevConfResource.modelNumber, OIC_STRING_MAX_VALUE,
-                                                            (deviceProperty->DevConf).modelNumber);
-    OIC_LOG_V(INFO, ES_RH_TAG, "Model Number : %s", gDevConfResource.modelNumber);
+    g_ESWiFiConfResource.numSupportedEncType = deviceProperty->WiFi.numSupportedEncType;
+    for (uint8_t i = 0; i < g_ESWiFiConfResource.numSupportedEncType; ++i)
+    {
+        g_ESWiFiConfResource.supportedEncType[i] = (deviceProperty->WiFi).supportedEncType[i];
+        OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "WiFi Enc Type : %d",
+                g_ESWiFiConfResource.supportedEncType[i]);
+    }
 
-    OIC_LOG(INFO, ES_RH_TAG, "SetDeviceProperty OUT");
+    OICStrcpy(g_ESDevConfResource.devName, OIC_STRING_MAX_VALUE,
+            (deviceProperty->DevConf).deviceName);
+    OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "Device Name : %s", g_ESDevConfResource.devName);
+
+    if (OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESWiFiConfResource.handle, OC_HIGH_QOS))
+    {
+        OIC_LOG(DEBUG, ES_RH_TAG, "wifiResource doesn't have any observers.");
+    }
+
+    if (OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESDevConfResource.handle, OC_HIGH_QOS))
+    {
+        OIC_LOG(DEBUG, ES_RH_TAG, "devConfResource doesn't have any observers.");
+    }
+
+    OIC_LOG(DEBUG, ES_RH_TAG, "SetDeviceProperty OUT");
     return OC_STACK_OK;
 }
 
 OCStackResult SetEnrolleeState(ESEnrolleeState esState)
 {
-    OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeState IN");
+    OIC_LOG(DEBUG, ES_RH_TAG, "SetEnrolleeState IN");
 
-    gProvResource.status = esState;
-    OIC_LOG_V(INFO, ES_RH_TAG, "Enrollee Status : %d", gProvResource.status);
+    g_ESEasySetupResource.status = esState;
+    OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "Enrollee Status : %d", g_ESEasySetupResource.status);
 
-    OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeState OUT");
+    if (OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESEasySetupResource.handle, OC_HIGH_QOS))
+    {
+        OIC_LOG(DEBUG, ES_RH_TAG, "provResource doesn't have any observers.");
+    }
+
+    OIC_LOG(DEBUG, ES_RH_TAG, "SetEnrolleeState OUT");
     return OC_STACK_OK;
 }
 
 OCStackResult SetEnrolleeErrCode(ESErrorCode esErrCode)
 {
-    OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeErrCode IN");
+    OIC_LOG(DEBUG, ES_RH_TAG, "SetEnrolleeErrCode IN");
 
-    gProvResource.lastErrCode = esErrCode;
-    OIC_LOG_V(INFO, ES_RH_TAG, "Enrollee ErrorCode : %d", gProvResource.lastErrCode);
+    g_ESEasySetupResource.lastErrCode = esErrCode;
+    OIC_LOG_V(INFO_PRIVATE, ES_RH_TAG, "Enrollee ErrorCode : %d", g_ESEasySetupResource.lastErrCode);
+
+    if (OC_STACK_NO_OBSERVERS == OCNotifyAllObservers(g_ESEasySetupResource.handle, OC_HIGH_QOS))
+    {
+        OIC_LOG(DEBUG, ES_RH_TAG, "provResource doesn't have any observers.");
+    }
 
-    OIC_LOG(INFO, ES_RH_TAG, "SetEnrolleeErrCode OUT");
+    OIC_LOG(DEBUG, ES_RH_TAG, "SetEnrolleeErrCode OUT");
     return OC_STACK_OK;
 }
 
+OCEntityHandlerResult CheckEhRequestPayload(OCEntityHandlerRequest *ehRequest)
+{
+    if (ehRequest->query && strcmp(ehRequest->query, ""))
+    {
+        uint8_t numResourceInterfaces = 0;
+        OCStackResult res = OCGetNumberOfResourceInterfaces(ehRequest->resource,
+                &numResourceInterfaces);
+        if (res != OC_STACK_OK)
+        {
+            OIC_LOG_V(ERROR, ES_RH_TAG, "Unable to get Number of Interfaces: %s", getResult(res));
+            return OC_EH_ERROR;
+        }
+        for (uint8_t i = 0; i < numResourceInterfaces; ++i)
+        {
+            const char *interfaceName = OCGetResourceInterfaceName(ehRequest->resource, i);
+            if (CompareResourceInterface(ehRequest->query, interfaceName))
+            {
+                return OC_EH_OK;
+            }
+        }
+        OIC_LOG(ERROR, ES_RH_TAG, "Not supported Interface");
+        return OC_EH_BAD_REQ;
+    }
+    return OC_EH_OK;
+}
+
+bool isAuthTypeSupported(WIFI_AUTHTYPE authType)
+{
+    bool supported = false;
+    for (uint8_t i = 0; i < g_ESWiFiConfResource.numSupportedAuthType; ++i)
+    {
+        if (g_ESWiFiConfResource.supportedAuthType[i] == authType)
+        {
+            supported = true;
+            break;
+        }
+    }
+    return supported;
+}
+
+bool isEncTypeSupported(WIFI_ENCTYPE encType)
+{
+    bool supported = false;
+    for (uint8_t i = 0; i < g_ESWiFiConfResource.numSupportedEncType; ++i)
+    {
+        if (g_ESWiFiConfResource.supportedEncType[i] == encType)
+        {
+            supported = true;
+            break;
+        }
+    }
+    return supported;
+}
+
 const char *getResult(OCStackResult result)
 {
     switch (result)