[IOT-2928][IOT-3017][IOT-3022] 27/24427/19
authorOleksii Beketov <ol.beketov@samsung.com>
Wed, 28 Mar 2018 14:57:05 +0000 (17:57 +0300)
committerAleksey Volkov <a.volkov@samsung.com>
Thu, 29 Mar 2018 08:44:23 +0000 (08:44 +0000)
The cloud provisioning:
1. sid add
2. get cloud status request add
3. Remove 'accesstoken' from coapcloudconf resource response

Change-Id: I5f5c1aa7ae414f02f6d1c288258084cacfdd1ed0
Signed-off-by: Oleksandr Dmytrenko <o.dmytrenko@samsung.com>
Signed-off-by: Oleksii Beketov <ol.beketov@samsung.com>
12 files changed:
resource/csdk/security/provisioning/include/cloud/auth.h
resource/csdk/security/provisioning/include/cloud/cloudresource.h
resource/csdk/security/provisioning/include/cloud/occloudprovisioning.h
resource/csdk/security/provisioning/include/internal/secureresourceprovider.h
resource/csdk/security/provisioning/sample/cloud/cloudCommon.c
resource/csdk/security/provisioning/sample/provisioningclient.c
resource/csdk/security/provisioning/src/cloud/auth.c
resource/csdk/security/provisioning/src/cloud/cloudresource.c
resource/csdk/security/provisioning/src/cloud/config.c
resource/csdk/security/provisioning/src/secureresourceprovider.c
resource/csdk/security/provisioning/unittest/cloudresource.cpp
resource/provisioning/examples/cloudWrapper.cpp

index cec87ba..26bb72a 100644 (file)
@@ -74,6 +74,7 @@ struct OicCloud
     char        *apn;   // Authorization Provider Name
     char        *cis;   // OCF Cloud URL
     char        *at;    // Access Token
+    char        *sid;   // Cloud UUID
     CloudStatus stat;
     oc_thread   pid;
     session_t   *session;
@@ -84,7 +85,8 @@ struct OicCloud
 #define OIC_JSON_CLOUD_APN      "apn"
 #define OIC_JSON_CLOUD_CIS      "cis"
 #define OIC_JSON_CLOUD_AT       "at"
-#define OIC_JSON_CLOUD_ATT      "att"
+#define OIC_JSON_CLOUD_SID      "sid"
+#define OIC_JSON_CLOUD_CLEC     "clec"
 
 /**
  * Sends Sign UP request to cloud
@@ -126,6 +128,16 @@ void FreeCloud(OicCloud_t *cloud);
  */
 OCStackResult CloudToCBORPayload(const OicCloud_t *clouds, uint8_t **payload, size_t *size);
 
+/**
+ * Cloud to CBOR for resource
+ *
+ * @param[in] cloud
+ * @param[out] payload
+ * @param[out] size
+ * @return  OCStackResult application result
+ */
+OCStackResult CloudToCBORPayloadResource(const OicCloud_t *clouds, uint8_t **payload, size_t *size);
+
 /**
  * CBOR to Cloud
  *
index 5705f5f..fb6442d 100644 (file)
@@ -55,16 +55,6 @@ OCStackResult CreateCloudResource();
 */
 bool UpdateCloudPersistentStorage();
 
-/**
- * Parse GET cloudconf payload
- *
- * @param[in] cborPayload       payload to parse
- * @param[in] size              payload size
- * @param[out] cloudState       cloud state
- * @return ::OC_STACK_OK for Success, otherwise some error value.
- */
-OCStackResult CloudGetRequestPayloadParse(const uint8_t *cborPayload, size_t size, int *cloudState);
-
 #ifdef __cplusplus
 }
 #endif
index 15e22b0..91c1d84 100644 (file)
@@ -58,6 +58,20 @@ typedef struct {
     stringArrayPair_t invited;
 }inviteResponse_t;
 
+typedef struct CloudData
+{
+    void *ctx;                                  /**< Pointer to user context.**/
+    const OCProvisionDev_t *targetDev;          /**< Pointer to OCProvisionDev_t.**/
+    OicSecCred_t *credInfo;                     /**< Array of pointers to OicSecCred_t.**/
+    OCProvisionResultCB resultCallback;         /**< Pointer to result callback.**/
+    OCProvisionResult_t *resArr;                /**< Result array.**/
+    int numOfResults;                           /**< Number of results in result array.**/
+    const char* cloudURI;                       /**< Cloud URI.**/
+    const char* oauthProvider;                  /**< Authorisation provider name.**/
+    const char* accessToken;                    /**< Access token that can be validated by the Cloud.**/
+    const char* sid;                            /**< Cloud UUID.**/
+} CloudData_t;
+
 /**
  * Certificate-Issue request function
  *
@@ -441,7 +455,7 @@ OCStackResult OCCloudAclPolicyCheck(void* ctx,
  *
  * @param[in] ctx               user-defined context
  * @param[in] pDev              provision device
- * @param[in] cloud             provisioned parameters
+ * @param[in] cloud             struct containing provisioned parameters
  * @param[in] resultCallback    optional result callback, can be NULL if not required
  * @return  OCStackResult application result
  */
@@ -450,6 +464,34 @@ OCStackResult OCProvisionCloudConfig(void *ctx,
                                      const OicCloud_t *cloud,
                                      OCClientResponseHandler resultCallback);
 
+/**
+ * Get cloud status of the selected device
+ *
+ * @param[in] ctx               user-defined context
+ * @param[in] pDev              provision device
+ * @param[in] cloud             struct containing cloud URL
+ * @param[in] resultCallback    optional result callback, can be NULL if not required
+ * @return  OCStackResult application result
+ */
+OCStackResult OCGetCloudStatusRequest(void *ctx,
+                                      const OCProvisionDev_t *pDev,
+                                      const OicCloud_t *cloud,
+                                      OCClientResponseHandler resultCallback);
+
+/**
+ * Delete CoAPCloudConf and cloud related ACLs from the selected device by cloud id
+ *
+ * @param[in] ctx               user-defined context
+ * @param[in] pDev              provision device
+ * @param[in] cloud             struct containing cloud UUID
+ * @param[in] resultCallback    optional result callback, can be NULL if not required
+ * @return  OCStackResult application result
+ */
+OCStackResult OCRemoveCloudConfig(void *ctx,
+                                  const OCProvisionDev_t *pDev,
+                                  const OicCloud_t *cloud,
+                                  OCProvisionResultCB resultCallback);
+
 #ifdef __cplusplus
 }
 #endif // __cplusplus
index e2d1860..f30e941 100644 (file)
@@ -35,6 +35,9 @@ typedef enum
     PSK_TYPE,                             /**< Pre-Shared Key.**/
     CERT_TYPE,                            /**< X.509 certificate.**/
     SP_TYPE,                              /**< Security Profiles. **/
+#if defined(WITH_CLOUD)
+    CLOUD_TYPE,                           /**< CoAP Cloud Conf.**/
+#endif
     MOT_TYPE                              /**< Multiple Ownership Transfer.**/
 } DataType_t;
 
index 8da1aac..18625d4 100644 (file)
@@ -429,7 +429,7 @@ static void *userRequests(void *data)
         return NULL;
     }
     cloud->cis = (char *)OICCalloc(1,1024 * 4);
-    if (NULL == cloud)
+    if (NULL == cloud->cis)
     {
         OIC_LOG(ERROR, TAG, "cloud->cis calloc failed");
         OICFree(cloud);
index 05eff55..cb0277c 100644 (file)
@@ -77,8 +77,10 @@ extern "C"
 #define _35_PROVIS_CERT_            35
 #ifdef WITH_CLOUD
 #define _36_PROVIS_CLOUD_CONF_      36
+#define _37_GET_CLOUD_STAT_         37
+#define _38_REMOVE_CLOUD_CONF_      38
 #endif //WITH_CLOUD
-#define _37_PROVIS_SEC_PROFILE             37
+#define _39_PROVIS_SEC_PROFILE      39
 #define _40_UNLINK_PAIR_DEVS_       40
 #define _50_REMOVE_SELEC_DEV_       50
 #define _51_REMOVE_DEV_WITH_UUID_   51
@@ -241,11 +243,39 @@ static void provisionCloudConfigCB(void* ctx, size_t nOfRes, OCProvisionResult_t
 {
     if(!hasError)
     {
-        OIC_LOG_V(INFO, TAG, "Provision Pairwise SUCCEEDED - ctx: %s", (char*) ctx);
+        OIC_LOG_V(INFO, TAG, "Provision cloud config SUCCEEDED - ctx: %s", (char*) ctx);
     }
     else
     {
-        OIC_LOG_V(ERROR, TAG, "Provision Pairwise FAILED - ctx: %s", (char*) ctx);
+        OIC_LOG_V(ERROR, TAG, "Provision cloud config FAILED - ctx: %s", (char*) ctx);
+        printResultList((const OCProvisionResult_t*) arr, nOfRes);
+    }
+    g_doneCB = true;
+}
+
+static void getCloudStatusCB(void* ctx, size_t nOfRes, OCProvisionResult_t* arr, bool hasError)
+{
+    if(!hasError)
+    {
+        OIC_LOG_V(INFO, TAG, "Get cloud status SUCCEEDED - ctx: %s", (char*) ctx);
+    }
+    else
+    {
+        OIC_LOG_V(ERROR, TAG, "Get cloud status FAILED - ctx: %s", (char*) ctx);
+        printResultList((const OCProvisionResult_t*) arr, nOfRes);
+    }
+    g_doneCB = true;
+}
+
+static void removeCloudConfCB(void* ctx, size_t nOfRes, OCProvisionResult_t* arr, bool hasError)
+{
+    if(!hasError)
+    {
+        OIC_LOG_V(INFO, TAG, "Remove cloud ACL SUCCEEDED - ctx: %s", (char*) ctx);
+    }
+    else
+    {
+        OIC_LOG_V(ERROR, TAG, "Remove cloud ACL FAILED - ctx: %s", (char*) ctx);
         printResultList((const OCProvisionResult_t*) arr, nOfRes);
     }
     g_doneCB = true;
@@ -1417,7 +1447,7 @@ static int provisionCloudConfig(void)
         printf("   > Please Register Unowned Devices first, with [20] Menu\n");
         return 0;  // normal case
     }
-
+    int ret = -1;
     // select device for provisioning certificate
     int dev_num = 0;
     if (g_own_cnt == 1)
@@ -1488,41 +1518,43 @@ static int provisionCloudConfig(void)
         return -1;
     }
 
-    OicCloud_t *cloud = OICCalloc(1,sizeof(OicCloud_t));
+    OicCloud_t *cloud = OICCalloc(1, sizeof(OicCloud_t));
     if (NULL == cloud)
     {
         OIC_LOG(ERROR, TAG, "Error, invalid cloud");
         return -1;
     }
-    cloud->apn = (char*)OICCalloc(1,1024);
+    cloud->apn = (char*)OICCalloc(1, 1024);
     if (NULL == cloud->apn)
     {
-        OICFree(cloud);
         OIC_LOG(ERROR, TAG, "Error, invalid cloud->apn");
-        return -1;
+        goto PCC_ERROR;
     }
-    cloud->cis = (char*)OICCalloc(1,1024);
+    cloud->cis = (char*)OICCalloc(1, 1024);
     if (NULL == cloud->cis)
     {
-        OICFree(cloud->apn);
-        OICFree(cloud);
         OIC_LOG(ERROR, TAG, "Error, invalid cloud->cis");
-        return -1;
+        goto PCC_ERROR;
     }
-    cloud->at = (char*)OICCalloc(1,1024);
+    cloud->at = (char*)OICCalloc(1, 1024);
     if (NULL == cloud->at)
     {
-        OICFree(cloud->cis);
-        OICFree(cloud->apn);
-        OICFree(cloud);
         OIC_LOG(ERROR, TAG, "Error, invalid cloud->at");
-        return -1;
+        goto PCC_ERROR;
+    }
+    cloud->sid = (char*)OICCalloc(1, 1024);
+    if (NULL == cloud->sid)
+    {
+        OIC_LOG(ERROR, TAG, "Error, invalid cloud->sid");
+        goto PCC_ERROR;
     }
 
-    printf("   > cloud uri (coaps+tcp://ip:port): ");
+    snprintf(cloud->cis,13,"coaps+tcp://");
+
+    printf("   > cloud uri (host(ip):port): ");
     for(int ret=0; 1!=ret; )
     {
-        ret = scanf("%32s", cloud->cis);
+        ret = scanf("%32s", cloud->cis + 12);
         for( ; 0x20<=getchar(); );  // for removing overflow garbages
                                     // '0x20<=code' is character region
     }
@@ -1543,6 +1575,14 @@ static int provisionCloudConfig(void)
                                     // '0x20<=code' is character region
     }
 
+    printf("   > cloud id: ");
+    for(int ret=0; 1!=ret; )
+    {
+        ret = scanf("%32s", cloud->sid);
+        for( ; 0x20<=getchar(); );  // for removing overflow garbages
+                                    // '0x20<=code' is character region
+    }
+
     //Provision the new cert
     printf("   > Provisioning certificate credential to selected device..\n");
     g_doneCB = false;
@@ -1550,33 +1590,200 @@ static int provisionCloudConfig(void)
     if (OC_STACK_OK != rst)
     {
         OIC_LOG_V(ERROR, TAG, "OCProvisionCertificate returned error: %d", rst);
-        OICFree(cloud->at);
-        OICFree(cloud->cis);
-        OICFree(cloud->apn);
-        OICFree(cloud);
-        return -1;
+        goto PCC_ERROR;
     }
     if (waitCallbackRet())  // input |g_doneCB| flag implicitly
     {
         OIC_LOG(ERROR, TAG, "OCProvisionCertificate callback error");
-        OICFree(cloud->at);
-        OICFree(cloud->cis);
-        OICFree(cloud->apn);
-        OICFree(cloud);
-        return -1;
+        goto PCC_ERROR;
     }
     if (!g_successCB)
     {
-        OICFree(cloud->at);
-        OICFree(cloud->cis);
-        OICFree(cloud->apn);
-        OICFree(cloud);
+        goto PCC_ERROR;
+    }
+
+    printf("   > Provisioned cloud crendentials\n");
+
+    ret = 0;
+
+PCC_ERROR:
+    FreeCloud(cloud);
+    return ret;
+}
+
+static int getCloudStatus(void)
+{
+    int ret = -1;
+    // make sure we own at least one device to provision
+    if (!g_own_list || g_own_cnt == 0)
+    {
+        printf("   > Owned Device List, to Provision Credentials, is Empty\n");
+        printf("   > Please Register Unowned Devices first, with [20] Menu\n");
+        return 0;  // normal case
+    }
+
+    // select device for cloud state request
+    int dev_num = 0;
+    if (g_own_cnt == 1)
+    {
+        dev_num = 1;
+    }
+    else
+    {
+        for (; ; )
+        {
+            printf("   > Enter Device Number, for cloud state request: ");
+            for (int ret = 0; 1 != ret; )
+            {
+                ret = scanf("%d", &dev_num);
+                for (; 0x20 <= getchar(); );  // for removing overflow garbages
+                                          // '0x20<=code' is character region
+            }
+            if (0<dev_num && g_own_cnt >= dev_num)
+            {
+                break;
+            }
+            printf("     Entered Wrong Number. Please Enter Again\n");
+        }
+    }
+
+    OCProvisionDev_t* targetDevice = getDevInst((const OCProvisionDev_t*)g_own_list, dev_num);
+    if (targetDevice == NULL)
+    {
+        OIC_LOG(ERROR, TAG, "Error, invalid device %d");
         return -1;
     }
 
+    OicCloud_t *cloud = OICCalloc(1,sizeof(OicCloud_t));
+    cloud->cis = OICCalloc(1,1024);
+
+    snprintf(cloud->cis,13,"coaps+tcp://");
+
+    printf("   > cloud uri (host(ip):port): ");
+    for(int ret=0; 1!=ret; )
+    {
+        ret = scanf("%32s", cloud->cis + 12);
+        for( ; 0x20<=getchar(); );  // for removing overflow garbages
+                                    // '0x20<=code' is character region
+    }
+
+    //Provision the new cert
+    printf("   > Provisioning certificate credential to selected device..\n");
+    g_doneCB = false;
+    OCStackResult rst = OCGetCloudStatusRequest((void*)g_ctx, targetDevice, cloud, (OCClientResponseHandler)getCloudStatusCB);
+    if (OC_STACK_OK != rst)
+    {
+        OIC_LOG_V(ERROR, TAG, "OCProvisionCertificate returned error: %d", rst);
+        goto exit;
+    }
+    if (waitCallbackRet())  // input |g_doneCB| flag implicitly
+    {
+        OIC_LOG(ERROR, TAG, "OCProvisionCertificate callback error");
+        goto exit;
+    }
+    if (!g_successCB)
+    {
+        ret = -1;
+        goto exit;
+    }
+    ret = 0;
+exit:
+    FreeCloud(cloud);
+
     printf("   > Provisioned cloud crendentials\n");
 
-    return 0;
+    return ret;
+}
+
+static int removeCloudConf(void)
+{
+    // make sure we own at least one device to provision
+    if (!g_own_list || g_own_cnt == 0)
+    {
+        printf("   > Owned Device List, to Provision Credentials, is Empty\n");
+        printf("   > Please Register Unowned Devices first, with [20] Menu\n");
+        return 0;  // normal case
+    }
+
+    int res = -1;
+
+    // select device for provisioning certificate
+    int dev_num = 0;
+    if (g_own_cnt == 1)
+    {
+        dev_num = 1;
+    }
+    else
+    {
+        for (; ; )
+        {
+            printf("   > Enter Device Number, for certificate provisioning: ");
+            for (int ret = 0; 1 != ret; )
+            {
+                ret = scanf("%d", &dev_num);
+                for (; 0x20 <= getchar(); );  // for removing overflow garbages
+                                          // '0x20<=code' is character region
+            }
+            if (0<dev_num && g_own_cnt >= dev_num)
+            {
+                break;
+            }
+            printf("     Entered Wrong Number. Please Enter Again\n");
+        }
+    }
+
+    OCProvisionDev_t* targetDevice = getDevInst((const OCProvisionDev_t*)g_own_list, dev_num);
+    if (targetDevice == NULL)
+    {
+        OIC_LOG(ERROR, TAG, "Error, invalid device %d");
+        return res;
+    }
+
+    OicCloud_t *cloud = OICCalloc(1, sizeof(OicCloud_t));
+    if (NULL == cloud)
+    {
+        OIC_LOG(ERROR, TAG, "Error, invalid cloud");
+        return res;
+    }
+    cloud->sid = (char*)OICCalloc(1, 1024);
+    if (NULL == cloud->sid)
+    {
+        OIC_LOG(ERROR, TAG, "Error, invalid cloud->sid");
+        goto PCC_ERROR;
+    }
+    printf("   > cloud id: ");
+    for(int ret=0; 1!=ret; )
+    {
+        ret = scanf("%64s", cloud->sid);
+        for( ; 0x20<=getchar(); );  // for removing overflow garbages
+                                    // '0x20<=code' is character region
+    }
+
+    printf("   > Removing cloud related acl and coapcloudconf resource from the selected device..\n");
+    g_doneCB = false;
+    OCStackResult rst = OCRemoveCloudConfig((void*)g_ctx, targetDevice, cloud, removeCloudConfCB);
+    if (OC_STACK_OK != rst)
+    {
+        OIC_LOG_V(ERROR, TAG, "OCRemoveCloudConfig returned error: %d", rst);
+        goto PCC_ERROR;
+    }
+    if (waitCallbackRet())  // input |g_doneCB| flag implicitly
+    {
+        OIC_LOG(ERROR, TAG, "OCRemoveCloudConfig callback error");
+        goto PCC_ERROR;
+    }
+    if (!g_successCB)
+    {
+        goto PCC_ERROR;
+    }
+
+    printf("   > Removed coapcloudconf and cloud acl\n");
+
+    res = 0;
+
+PCC_ERROR:
+    FreeCloud(cloud);
+    return res;
 }
 #endif //WITH_CLOUD
 
@@ -3131,8 +3338,10 @@ static void printMenu(void)
     printf("** 34. Save the Selected Access Control List(ACL) into local SVR DB\n");
     printf("** 35. Provision certificate credential\n");
     printf("** 36. Provision cloud credential\n");
-    printf("** 37. Provision security profile info\n\n");
+    printf("** 37. Get cloud status request\n");
+    printf("** 38. Remove cloud credential\n\n");
 
+    printf("** 39. Provision security profile info\n\n");
 
     printf("** [D] UNLINK PAIRWISE THINGS\n");
     printf("** 40. Unlink Pairwise Things\n\n");
@@ -3324,8 +3533,20 @@ int main(void)
                 OIC_LOG(ERROR, TAG, "_36_PROVIS_CLOUD_CONF_: error");
             }
             break;
+        case _37_GET_CLOUD_STAT_:
+            if (getCloudStatus())
+            {
+                OIC_LOG(ERROR, TAG, "_37_GET_CLOUD_STAT_: error");
+            }
+            break;
+        case _38_REMOVE_CLOUD_CONF_:
+            if (removeCloudConf())
+            {
+                OIC_LOG(ERROR, TAG, "_38_REMOVE_CLOUD_CONF_: error");
+            }
+            break;
 #endif //WITH_CLOUD
-        case _37_PROVIS_SEC_PROFILE:
+        case _39_PROVIS_SEC_PROFILE:
             if (provisionSecurityProfileInfo())
             {
                 OIC_LOG(ERROR, TAG, "_37_PROVIS_SEC_PROFILE: error");
index e214eb4..cb6ad44 100644 (file)
@@ -48,8 +48,7 @@
 
 static const int TIME_OUT_SHIFT = 3;
 
-
-#define CBOR_CLOUD_MAP_SIZE 3
+#define CBOR_CLOUD_MAP_SIZE 4
 #define MAX_STR_LEN 2048
 
 const char *OIC_JSON_CLOUD_SESSION_ACCESS_TOKEN = "accesstoken";
@@ -87,6 +86,11 @@ void SessionFree(session_t *session)
 
 void FreeCloud(OicCloud_t *cloud)
 {
+    if (!cloud)
+    {
+        return;
+    }
+
     cloud->stat = OC_CLOUD_PROV;
 
 
@@ -110,6 +114,7 @@ void FreeCloud(OicCloud_t *cloud)
     OICFree(cloud->apn);
     OICFree(cloud->cis);
     OICFree(cloud->at);
+    OICFree(cloud->sid);
 
     if (cloud->session)
     {
@@ -196,7 +201,8 @@ exit:
     return ret;
 }
 
-OCStackResult CloudToCBORPayload(const OicCloud_t *clouds, uint8_t **payload, size_t *size)
+static OCStackResult CloudToCBORPayloadInternal(const OicCloud_t *clouds, uint8_t **payload,
+        size_t *size, bool secure)
 {
     OIC_LOG_V(DEBUG, TAG, "%s: IN", __func__);
 
@@ -204,7 +210,7 @@ OCStackResult CloudToCBORPayload(const OicCloud_t *clouds, uint8_t **payload, si
     VERIFY_NOT_NULL_RETURN(TAG, size, ERROR, OC_STACK_INVALID_PARAM);
     VERIFY_NOT_NULL_RETURN(TAG, payload, ERROR, OC_STACK_INVALID_PARAM);
 
-    if ( NULL != *payload)
+    if (NULL != *payload)
     {
         OIC_LOG_V(ERROR, TAG, "%s: *payload is not NULL", __func__);
         return OC_STACK_INVALID_PARAM;
@@ -244,7 +250,11 @@ OCStackResult CloudToCBORPayload(const OicCloud_t *clouds, uint8_t **payload, si
     while (cloud)
     {
         CborEncoder map;
-        size_t mapSize = CBOR_CLOUD_MAP_SIZE + SESSION_CBOR_CLOUD_MAP_SIZE;
+        size_t mapSize = CBOR_CLOUD_MAP_SIZE;
+        if (secure)
+        {
+            mapSize += SESSION_CBOR_CLOUD_MAP_SIZE + 1;
+        }
         cborError = cbor_encoder_create_map(&cloudArray, &map, mapSize);
         VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Failed add map");
 
@@ -260,19 +270,37 @@ OCStackResult CloudToCBORPayload(const OicCloud_t *clouds, uint8_t **payload, si
         cborError = cbor_encode_text_string(&map, cloud->cis, strnlen(cloud->cis, MAX_STR_LEN));
         VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Failed add value: cis");
 
-        cborError = cbor_encode_text_string(&map, OIC_JSON_CLOUD_AT,
-                                            sizeof(OIC_JSON_CLOUD_AT) + 1);
-        VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Failed add tag: at");
-        cborError = cbor_encode_text_string(&map, cloud->at, strnlen(cloud->at, MAX_STR_LEN));
-        VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Failed add value: at");
+        if (secure)
+        {
+            cborError = cbor_encode_text_string(&map, OIC_JSON_CLOUD_AT,
+                                                sizeof(OIC_JSON_CLOUD_AT) + 1);
+            VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Failed add tag: at");
+            cborError = cbor_encode_text_string(&map, cloud->at, strnlen(cloud->at, MAX_STR_LEN));
+            VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Failed add value: at");
+        }
+
+        cborError = cbor_encode_text_string(&map, OIC_JSON_CLOUD_SID,
+                                            sizeof(OIC_JSON_CLOUD_SID) + 1);
+        VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Failed add tag: sid");
+        cborError = cbor_encode_text_string(&map, cloud->sid, strnlen(cloud->sid, MAX_STR_LEN));
+        VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Failed add value: sid");
+
+        cborError = cbor_encode_text_string(&map, OIC_JSON_CLOUD_CLEC,
+                                            sizeof(OIC_JSON_CLOUD_CLEC) + 1);
+        VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Failed add tag: clec");
+        cborError = cbor_encode_int(&map, cloud->stat);
+        VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Failed add value: clec");
 
-        if (cloud->session)
+        if (secure)
         {
-            ret = CloudSessionToCBORPayload(cloud->session, &map);
-            if (OC_STACK_OK != ret)
+            if (cloud->session)
             {
-                OIC_LOG_V(ERROR, TAG, "%s: Failed convert session to cbor", __func__);
-                goto exit;
+                ret = CloudSessionToCBORPayload(cloud->session, &map);
+                if (OC_STACK_OK != ret)
+                {
+                    OIC_LOG_V(ERROR, TAG, "%s: Failed convert session to cbor", __func__);
+                    goto exit;
+                }
             }
         }
 
@@ -308,6 +336,17 @@ exit:
     return ret;
 }
 
+OCStackResult CloudToCBORPayload(const OicCloud_t *clouds, uint8_t **payload, size_t *size)
+{
+    return CloudToCBORPayloadInternal(clouds, payload, size, true);
+}
+
+OCStackResult CloudToCBORPayloadResource(const OicCloud_t *clouds, uint8_t **payload, size_t *size)
+{
+    return CloudToCBORPayloadInternal(clouds, payload, size, false);
+}
+
+
 OCStackResult CBORPayloadToCloud(const uint8_t *cborPayload, size_t size, OicCloud_t **clouds)
 {
     OIC_LOG_V(DEBUG, TAG, "%s: IN", __func__);
@@ -384,6 +423,8 @@ OCStackResult CBORPayloadToCloud(const uint8_t *cborPayload, size_t size, OicClo
             cloud->session = (session_t *) OICCalloc(1, sizeof(session_t));
             VERIFY_NOT_NULL(TAG, cloud->session, ERROR);
 
+            cloud->stat = OC_CLOUD_OK;
+
             LL_APPEND(*clouds, cloud);
 
             char *name = NULL;
@@ -426,6 +467,12 @@ OCStackResult CBORPayloadToCloud(const uint8_t *cborPayload, size_t size, OicClo
                     VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Failed get at value");
                     goto next;
                 }
+                else if (strncmp(name, OIC_JSON_CLOUD_SID, len)  == 0)
+                {
+                    cborError = cbor_value_dup_text_string(&map, &cloud->sid, &len, NULL);
+                    VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Failed get sid value");
+                    goto next;
+                }
                 else if (strncmp(name, OIC_JSON_CLOUD_SESSION_ACCESS_TOKEN, len)  == 0)
                 {
                     cborError = cbor_value_dup_text_string(&map, &cloud->session->accessToken, &len, NULL);
@@ -920,6 +967,7 @@ OCStackResult OCCloudSignUp(OicCloud_t *cloud)
     VERIFY_NOT_NULL_RETURN(TAG, cloud->cis, ERROR, OC_STACK_INVALID_PARAM);
     VERIFY_NOT_NULL_RETURN(TAG, cloud->apn, ERROR, OC_STACK_INVALID_PARAM);
     VERIFY_NOT_NULL_RETURN(TAG, cloud->at, ERROR, OC_STACK_INVALID_PARAM);
+    VERIFY_NOT_NULL_RETURN(TAG, cloud->sid, ERROR, OC_STACK_INVALID_PARAM);
 
     if (OC_CLOUD_PROV != cloud->stat)
     {
@@ -940,6 +988,7 @@ OCStackResult OCCloudSignUp(OicCloud_t *cloud)
     OCRepPayloadSetPropString(payload, OC_RSRVD_AUTHPROVIDER, cloud->apn);
 #endif // __MANDATORY__
     OCRepPayloadSetPropString(payload, OC_RSRVD_ACCESS_TOKEN, cloud->at);
+    OCRepPayloadSetPropString(payload, OC_RSRVD_SUBJECT_ID, cloud->sid);
 
     OCCallbackData cbData =
     {
index 4b47cad..61c5963 100644 (file)
@@ -49,13 +49,11 @@ static oc_mutex     gCloudMutex;
 #define OC_CLOUD_PROVISIONING_APN   "apn"
 #define OC_CLOUD_PROVISIONING_CIS   "cis"
 #define OC_CLOUD_PROVISIONING_AT    "at"
-
-#define OIC_JSON_CLOUD_CLEC         "clec"
-
-static const size_t CBOR_DEFAULT_SIZE = 512;
+#define OC_CLOUD_PROVISIONING_SID   "sid"
 
 static OicCloud_t gDefaultCloud =
 {
+    NULL,
     NULL,
     NULL,
     NULL,
@@ -192,6 +190,11 @@ static OCEntityHandlerResult HandleCloudPostRequest(OCEntityHandlerRequest *ehRe
         OIC_LOG_V(ERROR, TAG, "%s: Can't get: %s", __func__, OC_CLOUD_PROVISIONING_AT);
         goto exit;
     }
+    if (!OCRepPayloadGetPropString(payload, OC_CLOUD_PROVISIONING_SID, &newCloud->sid))
+    {
+        OIC_LOG_V(ERROR, TAG, "%s: Can't get: %s", __func__, OC_CLOUD_PROVISIONING_SID);
+        goto exit;
+    }
 
     if (!ValidCloud(newCloud))
     {
@@ -238,143 +241,38 @@ exit:
     return ehRet;
 }
 
-OCStackResult CloudGetRequestPayloadCreate(int cloudState, uint8_t **payload, size_t *size)
+OCRepPayload *CreateCloudGetPayload(const OicCloud_t *cloud)
 {
     OIC_LOG_V(DEBUG, TAG, "%s: IN", __func__);
 
-    VERIFY_NOT_NULL_RETURN(TAG, size, ERROR, OC_STACK_INVALID_PARAM);
-    VERIFY_NOT_NULL_RETURN(TAG, payload, ERROR, OC_STACK_INVALID_PARAM);
-
-    if ( NULL != *payload)
-    {
-        OIC_LOG_V(ERROR, TAG, "%s: *payload is not NULL", __func__);
-        return OC_STACK_INVALID_PARAM;
-    }
-
-    size_t cborLen = *size;
-    if (0 == cborLen)
-    {
-        cborLen = CBOR_DEFAULT_SIZE;
-    }
-    *payload = NULL;
-    *size = 0;
-
-    OCStackResult ret = OC_STACK_ERROR;
-
-    CborError cborError = CborNoError;
-
-    uint8_t *outPayload = (uint8_t *)OICCalloc(1, cborLen);
-    VERIFY_NOT_NULL_RETURN(TAG, outPayload, ERROR, OC_STACK_ERROR);
-
-    CborEncoder encoder;
-    cbor_encoder_init(&encoder, outPayload, cborLen, 0);
-
-    CborEncoder rootMap;
-    cborError = cbor_encoder_create_map(&encoder, &rootMap, 1);
-    VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Failed add root map");
-
-    cborError = cbor_encode_text_string(&rootMap, OIC_JSON_CLOUD_CLEC,
-                                        sizeof(OIC_JSON_CLOUD_CLEC) + 1);
-    VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Failed add tag: clec");
-
-    cborError = cbor_encode_int(&rootMap, cloudState);
-    VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Failed add value: clec");
-
-    cborError = cbor_encoder_close_container(&encoder, &rootMap);
-    VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Failed close root map");
-
-    if (CborNoError == cborError)
-    {
-        *size = cbor_encoder_get_buffer_size(&encoder, outPayload);
-        *payload = outPayload;
-        ret = OC_STACK_OK;
-    }
-exit:
-    if ((CborNoError != cborError) || (OC_STACK_OK != ret))
-    {
-        OIC_LOG_V(ERROR, TAG, "%s: Failed", __func__);
-        OICFree(outPayload);
-        outPayload = NULL;
-        *payload = NULL;
-        *size = 0;
-        ret = OC_STACK_ERROR;
-    }
-
-    OIC_LOG_V(DEBUG, TAG, "%s: OUT", __func__);
-    return ret;
-}
-
-OCStackResult CloudGetRequestPayloadParse(const uint8_t *cborPayload, size_t size, int *cloudState)
-{
-    OIC_LOG_V(DEBUG, TAG, "%s: IN", __func__);
-
-    VERIFY_NOT_NULL_RETURN(TAG, cborPayload, ERROR, OC_STACK_INVALID_PARAM);
-    VERIFY_NOT_NULL_RETURN(TAG, cloudState, ERROR, OC_STACK_INVALID_PARAM);
-
-    if (0 == size)
-    {
-        OIC_LOG_V(ERROR, TAG, "%s: zero size", __func__);
-        return OC_STACK_INVALID_PARAM;
-    }
-
-    OCStackResult ret = OC_STACK_ERROR;
-    CborValue cloudCbor = { NULL, NULL, 0, 0, 0, 0};
-    CborParser parser = { NULL, 0 };
-    CborError cborError = CborNoError;
-    char *name = NULL;
-    size_t len = 0;
-
-    cbor_parser_init(cborPayload, size, 0, &parser, &cloudCbor);
-
-    if (!cbor_value_is_container(&cloudCbor))
-    {
-        OIC_LOG_V(ERROR, TAG, "%s: it's not container", __func__);
-        return OC_STACK_ERROR;
-    }
-
-    CborValue map = { NULL, NULL, 0, 0, 0, 0 };
-    cborError = cbor_value_enter_container(&cloudCbor, &map);
-    VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Cant't find root map");
-
-    cborError = cbor_value_dup_text_string(&map, &name, &len, NULL);
-    VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Failed find name in map");
-
-    if (0 == len || NULL == name || 0 != strncmp(name, OIC_JSON_CLOUD_CLEC, len))
-    {
-        OIC_LOG_V(ERROR, TAG, "%s: wrong name", __func__);
-        goto exit;
-    }
+    OCRepPayload *payload = NULL;
+    payload = OCRepPayloadCreate();
+    VERIFY_NOT_NULL(TAG, payload, ERROR);
 
-    cborError = cbor_value_advance(&map);
-    VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Failed move");
+    VERIFY_NOT_NULL_RETURN(TAG, cloud, WARNING, payload);
 
-    cborError = cbor_value_get_int(&map, cloudState);
-    VERIFY_CBOR_SUCCESS_OR_OUT_OF_MEMORY(TAG, cborError, "Failed get cloud state");
+    OCRepPayloadSetPropString(payload, OIC_JSON_CLOUD_APN, cloud->apn);
+    OCRepPayloadSetPropString(payload, OIC_JSON_CLOUD_CIS, cloud->cis);
+    OCRepPayloadSetPropString(payload, OIC_JSON_CLOUD_SID, cloud->sid);
+    OCRepPayloadSetPropInt(payload, OIC_JSON_CLOUD_CLEC, (int64_t)cloud->stat);
 
-    ret = OC_STACK_OK;
 exit:
-    if ((CborNoError != cborError) || (OC_STACK_OK != ret))
-    {
-        OIC_LOG_V(ERROR, TAG, "%s: Failed", __func__);
-    }
     OIC_LOG_V(DEBUG, TAG, "%s: OUT", __func__);
-    return ret;
+    return payload;
 }
 
-
 static OCEntityHandlerResult HandleCloudGetRequest(OCEntityHandlerRequest *ehRequest)
 {
     OIC_LOG_V(DEBUG, TAG, "%s: IN", __func__);
     OCEntityHandlerResult ehRet = OC_EH_INTERNAL_SERVER_ERROR;
-    OicCloud_t *newCloud = NULL;
+    OicCloud_t *cloud = NULL;
     OCRepPayload *payload = NULL;
     bool isDeviceOwned = false;
-    uint8_t *payloadResponse = NULL;
-    size_t sizeResponse = 0;
     OicCloud_t *p1 = NULL, *p2 = NULL;
+    OCEntityHandlerResponse response;
 
     VERIFY_NOT_NULL(TAG, ehRequest, ERROR);
-    VERIFY_NOT_NULL(TAG, ehRequest->payload, ERROR);
+    VERIFY_NOT_NULL(TAG, gCloud, ERROR);
 
     OCGetDeviceOwnedState(&isDeviceOwned);
 
@@ -385,49 +283,51 @@ static OCEntityHandlerResult HandleCloudGetRequest(OCEntityHandlerRequest *ehReq
         goto exit;
     }
 
-    newCloud = (OicCloud_t *) OICCalloc(1, sizeof(OicCloud_t));
-    VERIFY_NOT_NULL(TAG, newCloud, ERROR);
+    cloud = (OicCloud_t *) OICCalloc(1, sizeof(OicCloud_t));
+    VERIFY_NOT_NULL(TAG, cloud, ERROR);
 
     payload = (OCRepPayload *)ehRequest->payload;
 
-    if (!OCRepPayloadGetPropString(payload, OC_CLOUD_PROVISIONING_CIS, &newCloud->cis))
+    if (!payload || !OCRepPayloadGetPropString(payload, OC_CLOUD_PROVISIONING_CIS, &cloud->cis))
     {
         OIC_LOG_V(ERROR, TAG, "%s: Can't get: %s", __func__, OC_CLOUD_PROVISIONING_CIS);
+        p1 = gCloud;
+        ehRet = OC_EH_OK;
         goto exit;
     }
-    if (!OCRepPayloadGetPropString(payload, OC_CLOUD_PROVISIONING_APN, &newCloud->apn))
+    if (!OCRepPayloadGetPropString(payload, OC_CLOUD_PROVISIONING_APN, &cloud->apn))
     {
         OIC_LOG_V(WARNING, TAG, "%s: Can't get: %s", __func__, OC_CLOUD_PROVISIONING_APN);
     }
-    if (!OCRepPayloadGetPropString(payload, OC_CLOUD_PROVISIONING_AT, &newCloud->at))
+    if (!OCRepPayloadGetPropString(payload, OC_CLOUD_PROVISIONING_AT, &cloud->at))
     {
         OIC_LOG_V(WARNING, TAG, "%s: Can't get: %s", __func__, OC_CLOUD_PROVISIONING_AT);
     }
 
     LL_FOREACH_SAFE(gCloud, p1, p2)
     {
-        if (0 == strcmp(p1->cis, newCloud->cis))
+        if (0 == strcmp(p1->cis, cloud->cis))
         {
-            if (OC_STACK_OK != CloudGetRequestPayloadCreate(p1->stat, &payloadResponse, &sizeResponse))
-            {
-                OIC_LOG_V(ERROR, TAG, "%s: Error create cbor", __func__);
-                goto exit;
-            }
+            ehRet = OC_EH_OK;
             break;
         }
     }
+exit:
+    payload = CreateCloudGetPayload(p1);
 
-    if (0 == sizeResponse)
-    {
-        ehRet = OC_EH_RESOURCE_NOT_FOUND;
-    }
-    else
+    response.requestHandle = ehRequest->requestHandle;
+    response.ehResult = payload ? ehRet : OC_EH_INTERNAL_SERVER_ERROR;
+    response.payload = (OCPayload *)payload;
+    response.payload->type = PAYLOAD_TYPE_REPRESENTATION;
+    response.persistentBufferFlag = 0;
+
+    if (OC_STACK_OK != OCDoResponse(&response))
     {
-        ehRet = OC_EH_OK;
+        OIC_LOG_V(ERROR, TAG, "%s: send response", __func__);
+        ehRet = OC_EH_ERROR;
     }
-exit:
-    ehRet = ((SendSRMResponse(ehRequest, ehRet, payloadResponse, sizeResponse)) == OC_STACK_OK) ?
-            OC_EH_OK : OC_EH_ERROR;
+
+    FreeCloud(cloud);
 
     OIC_LOG_V(DEBUG, TAG, "%s: OUT", __func__);
 
@@ -438,10 +338,11 @@ static OCEntityHandlerResult HandleCloudDeleteRequest(OCEntityHandlerRequest *eh
 {
     OIC_LOG_V(DEBUG, TAG, "%s: IN", __func__);
     OCEntityHandlerResult ehRet = OC_EH_INTERNAL_SERVER_ERROR;
-    OicCloud_t *newCloud = NULL;
+    OicCloud_t *cloud = NULL;
     OCRepPayload *payload = NULL;
     bool isDeviceOwned = false;
     OicCloud_t *p1 = NULL, *p2 = NULL;
+    OCEntityHandlerResponse response;
 
     VERIFY_NOT_NULL(TAG, ehRequest, ERROR);
     VERIFY_NOT_NULL(TAG, ehRequest->payload, ERROR);
@@ -455,40 +356,51 @@ static OCEntityHandlerResult HandleCloudDeleteRequest(OCEntityHandlerRequest *eh
         goto exit;
     }
 
-    newCloud = (OicCloud_t *) OICCalloc(1, sizeof(OicCloud_t));
-    VERIFY_NOT_NULL(TAG, newCloud, ERROR);
+    cloud = (OicCloud_t *) OICCalloc(1, sizeof(OicCloud_t));
+    VERIFY_NOT_NULL(TAG, cloud, ERROR);
 
     payload = (OCRepPayload *)ehRequest->payload;
 
-    if (!OCRepPayloadGetPropString(payload, OC_CLOUD_PROVISIONING_CIS, &newCloud->cis))
+    if (!OCRepPayloadGetPropString(payload, OC_CLOUD_PROVISIONING_CIS, &cloud->cis))
     {
         OIC_LOG_V(ERROR, TAG, "%s: Can't get: %s", __func__, OC_CLOUD_PROVISIONING_CIS);
         goto exit;
     }
-    if (!OCRepPayloadGetPropString(payload, OC_CLOUD_PROVISIONING_APN, &newCloud->apn))
+    if (!OCRepPayloadGetPropString(payload, OC_CLOUD_PROVISIONING_APN, &cloud->apn))
     {
         OIC_LOG_V(ERROR, TAG, "%s: Can't get: %s", __func__, OC_CLOUD_PROVISIONING_APN);
     }
-    if (!OCRepPayloadGetPropString(payload, OC_CLOUD_PROVISIONING_AT, &newCloud->at))
+    if (!OCRepPayloadGetPropString(payload, OC_CLOUD_PROVISIONING_AT, &cloud->at))
     {
         OIC_LOG_V(ERROR, TAG, "%s: Can't get: %s", __func__, OC_CLOUD_PROVISIONING_AT);
     }
 
     LL_FOREACH_SAFE(gCloud, p1, p2)
     {
-        if (0 == strcmp(p1->cis, newCloud->cis))
+        if (0 == strcmp(p1->cis, cloud->cis))
         {
             OIC_LOG_V(INFO, TAG, "%s: delete cloud: %s", __func__, p1->cis);
             p1->stat = OC_CLOUD_EXIT;
             LL_DELETE(gCloud, p1);
+            FreeCloud(p1);
+            ehRet = OC_EH_OK;
             break;
         }
     }
-
-    ehRet = OC_EH_OK;
 exit:
-    ehRet = ((SendSRMResponse(ehRequest, ehRet, NULL, 0)) == OC_STACK_OK) ?
-            OC_EH_OK : OC_EH_ERROR;
+    response.requestHandle = ehRequest->requestHandle;
+    response.ehResult = ehRet;
+    response.payload->type = PAYLOAD_TYPE_REPRESENTATION;
+    response.payload = (OCPayload *)OCRepPayloadCreate();
+    response.persistentBufferFlag = 0;
+
+    if (OC_STACK_OK != OCDoResponse(&response))
+    {
+        OIC_LOG_V(ERROR, TAG, "%s: send response", __func__);
+        ehRet = OC_EH_ERROR;
+    }
+
+    FreeCloud(cloud);
 
     OIC_LOG_V(DEBUG, TAG, "%s: OUT", __func__);
 
index aa3eff7..2e99469 100644 (file)
 #include "srmutility.h"
 #include "occloudprovisioning.h"
 #include "cloudresource.h"
+#include "srmresourcestrings.h"
+#include "doxmresource.h"
 
 #define TAG "OIC_CLOUD_CONFIG"
 
 OCStackResult OCProvisionCloudConfig(void *ctx,
-                                    const OCProvisionDev_t *pDev,
-                                    const OicCloud_t *cloud,
-                                    OCClientResponseHandler resultCallback)
+                                     const OCProvisionDev_t *pDev,
+                                     const OicCloud_t *cloud,
+                                     OCClientResponseHandler resultCallback)
 {
     OIC_LOG_V(INFO, TAG, "IN %s", __func__);
     OCStackResult ret = OC_STACK_ERROR;
@@ -54,36 +56,38 @@ OCStackResult OCProvisionCloudConfig(void *ctx,
     VERIFY_NOT_NULL_RETURN(TAG, cloud->cis, ERROR,  OC_STACK_INVALID_PARAM);
     VERIFY_NOT_NULL_RETURN(TAG, cloud->apn, ERROR,  OC_STACK_INVALID_PARAM);
     VERIFY_NOT_NULL_RETURN(TAG, cloud->at, ERROR,  OC_STACK_INVALID_PARAM);
+    VERIFY_NOT_NULL_RETURN(TAG, cloud->sid, ERROR,  OC_STACK_INVALID_PARAM);
     VERIFY_NOT_NULL_RETURN(TAG, resultCallback, ERROR,  OC_STACK_INVALID_PARAM);
 
-    OCRepPayloadpayload = OCRepPayloadCreate();
+    OCRepPayload *payload = OCRepPayloadCreate();
     VERIFY_NOT_NULL(TAG, payload, ERROR);
 
     OCRepPayloadSetPropString(payload, OIC_JSON_CLOUD_CIS, cloud->cis);
     OCRepPayloadSetPropString(payload, OIC_JSON_CLOUD_APN, cloud->apn);
     OCRepPayloadSetPropString(payload, OIC_JSON_CLOUD_AT, cloud->at);
+    OCRepPayloadSetPropString(payload, OIC_JSON_CLOUD_SID, cloud->sid);
 
     query = OICCalloc(1, DEFAULT_URI_LENGTH);
     VERIFY_NOT_NULL(TAG, query, ERROR);
 
     VERIFY_SUCCESS(TAG, PMGenerateQuery(true,
-                             pDev->endpoint.addr,
-                             pDev->securePort,
-                             pDev->connType,
-                             query, DEFAULT_URI_LENGTH, OIC_RSRC_CLOUDCONF_URI), ERROR);
+                                        pDev->endpoint.addr,
+                                        pDev->securePort,
+                                        pDev->connType,
+                                        query, DEFAULT_URI_LENGTH, OIC_RSRC_CLOUDCONF_URI), ERROR);
 
     OCCallbackData cbData =  {.context = ctx, .cb = resultCallback, .cd = NULL};
     OCDoHandle lHandle = NULL;
 
     ret = OCDoResource(&lHandle, OC_REST_POST, query,
-                                &pDev->endpoint, (OCPayload *)payload,
-                                pDev->connType, OC_HIGH_QOS, &cbData, NULL, 0);
+                       &pDev->endpoint, (OCPayload *)payload,
+                       pDev->connType, OC_HIGH_QOS, &cbData, NULL, 0);
     OIC_LOG_V(DEBUG, TAG, "POST:%s ret:%d", query, ret);
 exit:
     OICFree(query);
     if (OC_STACK_OK != ret)
     {
-        if(NULL != payload)
+        if (NULL != payload)
         {
             OCPayloadDestroy((OCPayload *)payload);
         }
@@ -93,3 +97,227 @@ exit:
 
     return ret;
 }
+
+/**
+ * Cloud status response to cloud handle
+ *
+ * @param[in] ctx                    context
+ * @param[in] handle                 handle
+ * @param[in] response               response from peer
+ * @return  OCStackApplicationResult application result
+ */
+static OCStackApplicationResult handleCloudStatusResponse(void *ctx,
+        OCDoHandle handle,
+        OCClientResponse *response)
+{
+    OIC_LOG_V(DEBUG, TAG, "%s: IN", __func__);
+
+    VERIFY_NOT_NULL_RETURN(TAG, response, ERROR, OC_STACK_DELETE_TRANSACTION);
+    VERIFY_NOT_NULL_RETURN(TAG, response->payload, ERROR, OC_STACK_DELETE_TRANSACTION);
+
+    OCRepPayload *payload = (OCRepPayload *)response->payload;
+    OicCloud_t *cloud = NULL;
+
+#if !defined(NDEBUG)
+    OIC_LOG_PAYLOAD(DEBUG, response->payload);
+#endif
+
+    if (PAYLOAD_TYPE_REPRESENTATION == response->payload->type)
+    {
+        cloud = (OicCloud_t *)OICCalloc(1, sizeof(OicCloud_t));
+        if (cloud)
+        {
+            if (!OCRepPayloadGetPropString(payload, OIC_JSON_CLOUD_APN, &cloud->apn))
+            {
+                OIC_LOG_V(ERROR, TAG, "%s parse %s", __func__, OIC_JSON_CLOUD_APN);
+                goto parse;
+            }
+            if (!OCRepPayloadGetPropString(payload, OIC_JSON_CLOUD_CIS, &cloud->cis))
+            {
+                OIC_LOG_V(ERROR, TAG, "%s parse %s", __func__, OIC_JSON_CLOUD_CIS);
+                goto parse;
+            }
+            if (!OCRepPayloadGetPropString(payload, OIC_JSON_CLOUD_SID, &cloud->sid))
+            {
+                OIC_LOG_V(ERROR, TAG, "%s parse %s", __func__, OIC_JSON_CLOUD_SID);
+                goto parse;
+            }
+            if (!OCRepPayloadGetPropInt(payload, OIC_JSON_CLOUD_CLEC, (int64_t *)(&cloud->stat)))
+            {
+                OIC_LOG_V(ERROR, TAG, "%s parse %s", __func__, OIC_JSON_CLOUD_CLEC);
+                goto parse;
+            }
+
+            OIC_LOG_V(DEBUG, TAG, "%s: OUT: cloud status(%d): %s", __func__, cloud->stat,
+                      GetCloudStatus(cloud));
+parse:
+            FreeCloud(cloud);
+        }
+    }
+    else
+    {
+        OIC_LOG_V(ERROR, TAG, "%s unknown payload type: %d", __func__, response->payload->type);
+    }
+
+    ((OCClientResponseHandler)ctx)(NULL, handle, response);
+
+    return OC_STACK_DELETE_TRANSACTION;
+}
+
+OCStackResult OCGetCloudStatusRequest(void *ctx,
+                                      const OCProvisionDev_t *pDev,
+                                      const OicCloud_t *cloud,
+                                      OCClientResponseHandler resultCallback)
+{
+    OIC_LOG_V(INFO, TAG, "IN %s", __func__);
+    OCStackResult ret = OC_STACK_ERROR;
+    char *query = NULL;
+
+    VERIFY_NOT_NULL_RETURN(TAG, ctx, ERROR,  OC_STACK_INVALID_PARAM);
+    VERIFY_NOT_NULL_RETURN(TAG, pDev, ERROR,  OC_STACK_INVALID_PARAM);
+    VERIFY_NOT_NULL_RETURN(TAG, cloud, ERROR,  OC_STACK_INVALID_PARAM);
+    VERIFY_NOT_NULL_RETURN(TAG, cloud->cis, ERROR,  OC_STACK_INVALID_PARAM);
+    VERIFY_NOT_NULL_RETURN(TAG, resultCallback, ERROR,  OC_STACK_INVALID_PARAM);
+
+    query = OICCalloc(1, DEFAULT_URI_LENGTH);
+    VERIFY_NOT_NULL(TAG, query, ERROR);
+
+    VERIFY_SUCCESS(TAG, PMGenerateQuery(true,
+                                        pDev->endpoint.addr,
+                                        pDev->securePort,
+                                        pDev->connType,
+                                        query, DEFAULT_URI_LENGTH, OIC_RSRC_CLOUDCONF_URI), ERROR);
+
+    OCCallbackData cbData =  {.context = resultCallback, .cb = handleCloudStatusResponse, .cd = NULL};
+    OCDoHandle lHandle = NULL;
+
+    ret = OCDoResource(&lHandle, OC_REST_GET, query,
+                       &pDev->endpoint, NULL,
+                       pDev->connType, OC_HIGH_QOS, &cbData, NULL, 0);
+    OIC_LOG_V(DEBUG, TAG, "GET:%s ret:%d", query, ret);
+
+exit:
+    OICFree(query);
+
+    OIC_LOG_V(INFO, TAG, "OUT %s", __func__);
+
+    return ret;
+}
+
+/**
+ * Callback for CoAPCloudConfig remove.
+ */
+static OCStackApplicationResult OCRemoveCloudConfigCB(void *ctx, OCDoHandle handle,
+        OCClientResponse *clientResponse)
+{
+    OIC_LOG_V(INFO, TAG, "IN %s", __func__);
+
+    OC_UNUSED(handle);
+    OCStackResult ret = OC_STACK_ERROR;
+    char *query = NULL;
+    const OCProvisionDev_t *pDev = NULL;
+    const char *sid = NULL;
+    char *buf = NULL;
+
+    VERIFY_NOT_NULL_RETURN(TAG, ctx, ERROR,  OC_STACK_INVALID_PARAM);
+    VERIFY_NOT_NULL_RETURN(TAG, clientResponse, ERROR,  OC_STACK_INVALID_PARAM);
+
+    VERIFY_SUCCESS_RETURN(TAG, (OC_STACK_RESOURCE_CHANGED == clientResponse->result), ERROR,
+                          OC_STACK_INVALID_PARAM);
+
+    Data_t *data = (Data_t *) ctx;
+    VERIFY_SUCCESS_RETURN(TAG, (CLOUD_TYPE == data->type), ERROR, OC_STACK_INVALID_PARAM);
+
+    CloudData_t *cloudData = (CloudData_t *) (data->ctx);
+    VERIFY_NOT_NULL(TAG, cloudData, ERROR);
+    pDev = cloudData->targetDev;
+    VERIFY_NOT_NULL(TAG, pDev, ERROR);
+    sid = cloudData->sid;
+    VERIFY_NOT_NULL(TAG, sid, ERROR);
+
+    query = OICCalloc(1, DEFAULT_URI_LENGTH);
+    VERIFY_NOT_NULL(TAG, query, ERROR);
+
+    int bufLen = strlen(OIC_RSRC_ACL2_URI) + strlen("?Subject=") + strlen(sid) + 1;
+    buf = (char *)OICCalloc(1, bufLen);
+    VERIFY_NOT_NULL(TAG, buf, ERROR);
+
+    int res = snprintf(buf, bufLen, "%s%s%s", OIC_RSRC_ACL2_URI, "?Subject=", sid);
+    if (res + 1 != bufLen)
+    {
+        OIC_LOG_V(ERROR, TAG, "%s: error assembling query", __func__);
+        goto exit;
+    }
+
+    VERIFY_SUCCESS(TAG, PMGenerateQuery(true,
+                                        pDev->endpoint.addr,
+                                        pDev->securePort,
+                                        pDev->connType,
+                                        query, DEFAULT_URI_LENGTH, buf), ERROR);
+
+    OCCallbackData cbData =  {.context = ctx, .cb = ProvisionCB, .cd = NULL};
+    OCDoHandle lHandle = NULL;
+
+    ret = OCDoResource(&lHandle, OC_REST_DELETE, query,
+                       &pDev->endpoint, NULL,
+                       pDev->connType, OC_HIGH_QOS, &cbData, NULL, 0);
+    OIC_LOG_V(DEBUG, TAG, "DELETE:%s ret:%d", query, ret);
+exit:
+    OICFree(query);
+    OICFree(buf);
+
+    OIC_LOG_V(INFO, TAG, "OUT %s", __func__);
+
+    return ret;
+}
+
+OCStackResult OCRemoveCloudConfig(void *ctx,
+                                  const OCProvisionDev_t *pDev,
+                                  const OicCloud_t *cloud,
+                                  OCProvisionResultCB resultCallback)
+{
+    OIC_LOG_V(INFO, TAG, "IN %s", __func__);
+
+    VERIFY_NOT_NULL_RETURN(TAG, pDev, ERROR,  OC_STACK_INVALID_PARAM);
+    VERIFY_NOT_NULL_RETURN(TAG, resultCallback, ERROR,  OC_STACK_INVALID_CALLBACK);
+    VERIFY_NOT_NULL_RETURN(TAG, cloud, ERROR,  OC_STACK_INVALID_CALLBACK);
+
+    OCStackResult ret = OC_STACK_ERROR;
+    Data_t *data = NULL;
+
+    OicUuid_t provTooldeviceID =   {{0,}};
+    if (OC_STACK_OK != GetDoxmDeviceID(&provTooldeviceID))
+    {
+        OIC_LOG(ERROR, TAG, "Error while retrieving provisioning tool's device ID");
+        return OC_STACK_ERROR;
+    }
+
+    data = (Data_t *)OICCalloc(1, sizeof(Data_t));
+    VERIFY_NOT_NULL(TAG, data, ERROR);
+    data->type = CLOUD_TYPE;
+
+    CloudData_t *cloudData = (CloudData_t *)OICCalloc(1, sizeof(CloudData_t));
+    VERIFY_NOT_NULL(TAG, cloudData, ERROR);
+    data->ctx = cloudData;
+    cloudData->ctx = ctx;
+    cloudData->targetDev = pDev;
+    cloudData->resultCallback = resultCallback;
+    cloudData->numOfResults = 0;
+    cloudData->credInfo = NULL;
+
+    cloudData->resArr = (OCProvisionResult_t *)OICCalloc(1, sizeof(OCProvisionResult_t));
+    VERIFY_NOT_NULL(TAG, cloudData->resArr, ERROR);
+
+    cloudData->sid = cloud->sid;
+
+    ret = SetDOS(data, DOS_RFPRO, OCRemoveCloudConfigCB);
+exit:
+    if (OC_STACK_OK != ret)
+    {
+        FreeData(data);
+    }
+
+    OIC_LOG_V(INFO, TAG, "OUT %s", __func__);
+
+    return ret;
+}
index 45eb0e2..5167153 100644 (file)
@@ -288,6 +288,15 @@ void FreeData(Data_t *data)
                 OICFree(motData);
                 break;
             }
+#if defined(WITH_CLOUD)
+        case CLOUD_TYPE:
+            {
+                CloudData_t *cloudData = (CloudData_t *) data->ctx;
+                OICFree(cloudData->resArr);
+                OICFree(cloudData);
+                break;
+            }
+#endif
         default:
             {
                 OIC_LOG_V(INFO, TAG, "Unknown type %d", data->type);
@@ -821,6 +830,23 @@ OCStackApplicationResult SetReadyForNormalOperationCB(void *ctx, OCDoHandle hand
             dataCtx = certData->ctx;
             break;
         }
+#if defined(WITH_CLOUD)
+        case CLOUD_TYPE:
+        {
+            CloudData_t *cloudData = (CloudData_t *) ((Data_t *) ctx)->ctx;
+            if (NULL == cloudData)
+            {
+                OIC_LOG_V(ERROR, TAG, "%s: cloudData is NULL", __func__);
+                break;
+            }
+            resultCallback = cloudData->resultCallback;
+            targetDev = cloudData->targetDev;
+            resArr = cloudData->resArr;
+            numOfResults = &(cloudData->numOfResults);
+            dataCtx = cloudData->ctx;
+            break;
+        }
+#endif
         default:
         {
             OIC_LOG_V(ERROR, TAG, "Unknown type %d", dataType);
@@ -908,6 +934,13 @@ OCStackResult SetDOS(const Data_t *data, OicSecDeviceOnboardingState_t dos,
             pTargetDev = ((OTMContext_t *)data->ctx)->selectedDeviceInfo;
             break;
         }
+#if defined(WITH_CLOUD)
+        case CLOUD_TYPE:
+        {
+            pTargetDev = ((CloudData_t *)data->ctx)->targetDev;
+            break;
+        }
+#endif
         default:
         {
             OIC_LOG_V(ERROR, TAG, "Unknown type: %d", data->type);
index 1a3c6df..69b9007 100644 (file)
@@ -66,12 +66,14 @@ OicCloud_t *getCloud()
     cloud->apn = (char *)OICCalloc(STR_LEN, sizeof(char));
     cloud->cis = (char *)OICCalloc(STR_LEN, sizeof(char));
     cloud->at = (char *)OICCalloc(STR_LEN, sizeof(char));
+    cloud->sid = (char *)OICCalloc(STR_LEN, sizeof(char));
 
     for (int i = 0; i < STR_LEN; i++)
     {
         cloud->apn[i] = sample[rand() % STR_LEN];
         cloud->cis[i] = sample[rand() % STR_LEN];
         cloud->at[i] = sample[rand() % STR_LEN];
+        cloud->sid[i] = sample[rand() % STR_LEN];
     }
 
     cloud->session = (session_t *)OICCalloc(STR_LEN, sizeof(session_t));
@@ -121,6 +123,19 @@ TEST(CloudResourceTest, CloudToCBORPayloadVALID)
     OICFree(payload);
 }
 
+TEST(CloudResourceTest, CloudToCBORPayloadResourceVALID)
+{
+    OicCloud_t *cloud = getCloud();
+
+    uint8_t *payload = NULL;
+    size_t size = 0;
+    EXPECT_EQ(OC_STACK_OK, CloudToCBORPayloadResource(cloud, &payload, &size));
+    EXPECT_TRUE(payload != NULL);
+
+    FreeCloud(cloud);
+    OICFree(payload);
+}
+
 TEST(CloudResourceTest, CBORPayloadToCloudNULL)
 {
     OicCloud_t *cloud = NULL;
@@ -147,6 +162,7 @@ TEST(CloudResourceTest, CBORPayloadToCloudFULL)
     ASSERT_STREQ(cloudX->apn, cloud->apn);
     ASSERT_STREQ(cloudX->cis, cloud->cis);
     ASSERT_STREQ(cloudX->at, cloud->at);
+    ASSERT_EQ(OC_CLOUD_OK, cloudX->stat);
 
     if (cloud->session && cloudX->session)
     {
@@ -165,6 +181,26 @@ TEST(CloudResourceTest, CBORPayloadToCloudFULL)
     OICFree(payload);
 }
 
+TEST(CloudResourceTest, CBORPayloadToCloudResourceFULL)
+{
+    OicCloud_t *cloud =  getCloud();
+    uint8_t *payload = NULL;
+    size_t size = 0;
+    EXPECT_EQ(OC_STACK_OK, CloudToCBORPayloadResource(cloud, &payload, &size));
+    EXPECT_TRUE(payload != NULL);
+
+    OicCloud_t *cloudX = NULL;
+    EXPECT_EQ(OC_STACK_OK, CBORPayloadToCloud(payload, size, &cloudX));
+    ASSERT_TRUE(cloudX != NULL);
+    ASSERT_STREQ(cloudX->apn, cloud->apn);
+    ASSERT_STREQ(cloudX->cis, cloud->cis);
+    ASSERT_EQ(OC_CLOUD_OK, cloudX->stat);
+
+    FreeCloud(cloudX);
+    FreeCloud(cloud);
+    OICFree(payload);
+}
+
 TEST(CloudResourceTest, ValidCloudFULL)
 {
     OicCloud_t *cloud =  getCloud();
@@ -173,16 +209,3 @@ TEST(CloudResourceTest, ValidCloudFULL)
     ASSERT_TRUE(true == ValidCloud(cloud));
     FreeCloud(cloud);
 }
-
-TEST(CloudResourceGetTest, PayloadFULL)
-{
-    int cloudState = rand();
-    int cloudStateX;
-    uint8_t *payload = NULL;
-    size_t size = 0;
-
-    ASSERT_TRUE(OC_STACK_OK == CloudGetRequestPayloadCreate(cloudState, &payload, &size));
-    ASSERT_TRUE(OC_STACK_OK == CloudGetRequestPayloadParse(payload, size, &cloudStateX));
-    ASSERT_TRUE(cloudState == cloudStateX);
-}
-
index a19285b..890e033 100644 (file)
@@ -350,8 +350,12 @@ OCStackResult OCWrapperAclIdGetByDevice(OCCloudProvisioning& ptr, AclIdResponseC
 
 const char *getUri(const OCDevAddr *ep)
 {
-    char *uri = (char *)OICCalloc(1,1024);
-    snprintf(uri,1024,"%s:%d",ep->addr, ep->port);
+    char *uri = NULL;
+    uri = (char *)OICCalloc(1,1024);
+    if (uri)
+    {
+        snprintf(uri,1024,"%s:%d",ep->addr, ep->port);
+    }
     return uri;
 }