resource/csdk/stack/src/ocpayloadconvert.c

   1 //******************************************************************
   2 //
   3 // Copyright 2015 Intel Mobile Communications GmbH All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include "ocpayloadcbor.h"
  22 #include "platform_features.h"
  23 #include <stdlib.h>
  24 #include "oic_malloc.h"
  25 #include "oic_string.h"
  26 #include "logger.h"
  27 #include "ocpayload.h"
  28 #include "ocrandom.h"
  29 #include "ocresourcehandler.h"
  30 #include "cbor.h"
  31 #include "rdpayload.h"
  32
  33 #define TAG "OIC_RI_PAYLOADCONVERT"
  34
  35 // Arbitrarily chosen size that seems to contain the majority of packages
  36 #define INIT_SIZE (255)
  37
  38 // Discovery Links Map Length.
  39 #define LINKS_MAP_LEN 4
  40
  41 // Default data model versions in CVS form
  42 #define DEFAULT_DATA_MODEL_VERSIONS "res.1.1.0,sh.1.1.0"
  43
  44 // Functions all return either a CborError, or a negative version of the OC_STACK return values
  45 static int64_t OCConvertPayloadHelper(OCPayload *payload, uint8_t *outPayload, size_t *size);
  46 static int64_t OCConvertDiscoveryPayload(OCDiscoveryPayload *payload, uint8_t *outPayload,
  47         size_t *size);
  48 static int64_t OCConvertDevicePayload(OCDevicePayload *payload, uint8_t *outPayload,
  49         size_t *size);
  50 static int64_t OCConvertPlatformPayload(OCPlatformPayload *payload, uint8_t *outPayload,
  51         size_t *size);
  52 static int64_t OCConvertRepPayload(OCRepPayload *payload, uint8_t *outPayload, size_t *size);
  53 static int64_t OCConvertRepMap(CborEncoder *map, const OCRepPayload *payload);
  54 static int64_t OCConvertPresencePayload(OCPresencePayload *payload, uint8_t *outPayload,
  55         size_t *size);
  56 static int64_t OCConvertSecurityPayload(OCSecurityPayload *payload, uint8_t *outPayload,
  57         size_t *size);
  58 static int64_t OCConvertSingleRepPayload(CborEncoder *parent, const OCRepPayload *payload);
  59 static int64_t OCConvertArray(CborEncoder *parent, const OCRepPayloadValueArray *valArray);
  60
  61 static int64_t AddTextStringToMap(CborEncoder *map, const char *key, size_t keylen,
  62         const char *value);
  63 static int64_t ConditionalAddTextStringToMap(CborEncoder *map, const char *key, size_t keylen,
  64         const char *value);
  65
  66 OCStackResult OCConvertPayload(OCPayload* payload, uint8_t** outPayload, size_t* size)
  67 {
  68     // TinyCbor Version 47a78569c0 or better on master is required for the re-allocation
  69     // strategy to work.  If you receive the following assertion error, please do a git-pull
  70     // from the extlibs/tinycbor/tinycbor directory
  71     #define CborNeedsUpdating  (((unsigned int)CborErrorOutOfMemory) < ((unsigned int)CborErrorDataTooLarge))
  72     OC_STATIC_ASSERT(!CborNeedsUpdating, "tinycbor needs to be updated to at least 47a78569c0");
  73     #undef CborNeedsUpdating
  74
  75     OCStackResult ret = OC_STACK_INVALID_PARAM;
  76     int64_t err;
  77     uint8_t *out = NULL;
  78     size_t curSize = INIT_SIZE;
  79
  80     VERIFY_PARAM_NON_NULL(TAG, payload, "Input param, payload is NULL");
  81     VERIFY_PARAM_NON_NULL(TAG, outPayload, "OutPayload parameter is NULL");
  82     VERIFY_PARAM_NON_NULL(TAG, size, "size parameter is NULL");
  83
  84     OIC_LOG_V(INFO, TAG, "Converting payload of type %d", payload->type);
  85     if (PAYLOAD_TYPE_SECURITY == payload->type)
  86     {
  87         size_t securityPayloadSize = ((OCSecurityPayload *)payload)->payloadSize;
  88         if (securityPayloadSize > 0)
  89         {
  90             out = (uint8_t *)OICCalloc(1, ((OCSecurityPayload *)payload)->payloadSize);
  91             VERIFY_PARAM_NON_NULL(TAG, out, "Failed to allocate security payload");
  92         }
  93     }
  94     if (out == NULL)
  95     {
  96         out = (uint8_t *)OICCalloc(1, curSize);
  97         VERIFY_PARAM_NON_NULL(TAG, out, "Failed to allocate payload");
  98     }
  99     err = OCConvertPayloadHelper(payload, out, &curSize);
 100     ret = OC_STACK_NO_MEMORY;
 101
 102     if (err == CborErrorOutOfMemory)
 103     {
 104         // reallocate "out" and try again!
 105         uint8_t *out2 = (uint8_t *)OICRealloc(out, curSize);
 106         VERIFY_PARAM_NON_NULL(TAG, out2, "Failed to increase payload size");
 107         out = out2;
 108         err = OCConvertPayloadHelper(payload, out, &curSize);
 109         while (err == CborErrorOutOfMemory)
 110         {
 111             uint8_t *out2 = (uint8_t *)OICRealloc(out, curSize);
 112             VERIFY_PARAM_NON_NULL(TAG, out2, "Failed to increase payload size");
 113             out = out2;
 114             err = OCConvertPayloadHelper(payload, out, &curSize);
 115         }
 116     }
 117
 118     if (err == CborNoError)
 119     {
 120         if (curSize < INIT_SIZE && PAYLOAD_TYPE_SECURITY != payload->type)
 121         {
 122             uint8_t *out2 = (uint8_t *)OICRealloc(out, curSize);
 123             VERIFY_PARAM_NON_NULL(TAG, out2, "Failed to increase payload size");
 124             out = out2;
 125         }
 126
 127         *size = curSize;
 128         *outPayload = out;
 129         OIC_LOG_V(DEBUG, TAG, "Payload Size: %zd Payload : ", *size);
 130         OIC_LOG_BUFFER(DEBUG, TAG, *outPayload, *size);
 131         return OC_STACK_OK;
 132     }
 133
 134     //TODO: Proper conversion from CborError to OCStackResult.
 135     ret = (OCStackResult)-err;
 136
 137 exit:
 138     OICFree(out);
 139     return ret;
 140 }
 141
 142 static int64_t OCConvertPayloadHelper(OCPayload* payload, uint8_t* outPayload, size_t* size)
 143 {
 144     switch(payload->type)
 145     {
 146         case PAYLOAD_TYPE_DISCOVERY:
 147             return OCConvertDiscoveryPayload((OCDiscoveryPayload*)payload, outPayload, size);
 148         case PAYLOAD_TYPE_DEVICE:
 149             return OCConvertDevicePayload((OCDevicePayload*)payload, outPayload, size);
 150         case PAYLOAD_TYPE_PLATFORM:
 151             return OCConvertPlatformPayload((OCPlatformPayload*)payload, outPayload, size);
 152         case PAYLOAD_TYPE_REPRESENTATION:
 153             return OCConvertRepPayload((OCRepPayload*)payload, outPayload, size);
 154         case PAYLOAD_TYPE_PRESENCE:
 155             return OCConvertPresencePayload((OCPresencePayload*)payload, outPayload, size);
 156         case PAYLOAD_TYPE_SECURITY:
 157             return OCConvertSecurityPayload((OCSecurityPayload*)payload, outPayload, size);
 158         case PAYLOAD_TYPE_RD:
 159             return OCRDPayloadToCbor((OCRDPayload*)payload, outPayload, size);
 160         default:
 161             OIC_LOG_V(INFO,TAG, "ConvertPayload default %d", payload->type);
 162             return CborErrorUnknownType;
 163     }
 164 }
 165
 166 static int64_t checkError(int64_t err, CborEncoder* encoder, uint8_t* outPayload, size_t* size)
 167 {
 168     if (err == CborErrorOutOfMemory)
 169     {
 170         *size += encoder->ptr - encoder->end;
 171         return err;
 172     }
 173     else if (err != CborNoError)
 174     {
 175         OIC_LOG_V(ERROR, TAG, "Convert Payload failed : %s", cbor_error_string(err));
 176         return err;
 177     }
 178     else
 179     {
 180         *size = encoder->ptr - outPayload;
 181         return err;
 182     }
 183 }
 184
 185 static int64_t OCConvertSecurityPayload(OCSecurityPayload* payload, uint8_t* outPayload,
 186         size_t* size)
 187 {
 188     memcpy(outPayload, payload->securityData, payload->payloadSize);
 189     *size = payload->payloadSize;
 190
 191     return CborNoError;
 192 }
 193
 194 static int64_t OCStringLLJoin(CborEncoder *map, char *type, OCStringLL *val)
 195 {
 196     uint16_t count = 0;
 197     int64_t err = CborNoError;
 198
 199     for (OCStringLL *temp = val; temp; temp = temp->next)
 200     {
 201         ++count;
 202     }
 203     if (count > 0)
 204     {
 205         CborEncoder array;
 206         err |= cbor_encode_text_string(map, type, strlen(type));
 207         err |= cbor_encoder_create_array(map, &array, count);
 208         while (val)
 209         {
 210             err |= cbor_encode_text_string(&array, val->value, strlen(val->value));
 211             val = val->next;
 212         }
 213         err |= cbor_encoder_close_container(map, &array);
 214     }
 215
 216     return err;
 217 }
 218
 219 static int64_t OCConvertDiscoveryPayload(OCDiscoveryPayload *payload, uint8_t *outPayload,
 220         size_t *size)
 221 {
 222     CborEncoder encoder;
 223     int64_t err = CborNoError;
 224
 225     cbor_encoder_init(&encoder, outPayload, *size, 0);
 226
 227     if (payload->resources)
 228     {
 229         /*
 230         The format for the payload is "modelled" as JSON.
 231
 232         [                                                       // rootArray
 233             {                                                   // rootMap
 234                 "di" : UUID,                                    // device ID
 235                 "rt": ["oic.wk.res"]
 236                 "n":"MyDevice"
 237                 "if":"oic.if.ll oic.if.baseline"
 238                 "di": "0685B960-736F-46F7-BEC0-9E6CBD61ADC1",
 239                 links :[                                        // linksArray contains maps of resources
 240                             {
 241                                 href, rt, if, policy            // Resource 1
 242                             },
 243                             {
 244                                 href, rt, if, policy            // Resource 2
 245                             },
 246                             .
 247                             .
 248                             .
 249                         ]
 250             }
 251         ]
 252         */
 253         // Open the main root array
 254         CborEncoder rootArray;
 255         size_t resourceCount =  OCDiscoveryPayloadGetResourceCount(payload);
 256         err |= cbor_encoder_create_array(&encoder, &rootArray, 1);
 257         VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating discovery root array");
 258
 259         // Open the root map in the root array
 260         CborEncoder rootMap;
 261         err |= cbor_encoder_create_map(&rootArray, &rootMap, CborIndefiniteLength);
 262         VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating discovery map");
 263
 264         // Insert Name
 265         err |= ConditionalAddTextStringToMap(&rootMap, OC_RSRVD_DEVICE_NAME,
 266                 sizeof(OC_RSRVD_DEVICE_NAME) - 1, payload->name);
 267         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting name");
 268
 269         // Insert Device ID into the root map
 270         err |= AddTextStringToMap(&rootMap, OC_RSRVD_DEVICE_ID, sizeof(OC_RSRVD_DEVICE_ID) - 1,
 271                 payload->sid);
 272         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting device id");
 273
 274         // Insert Resource Type
 275         err |= OCStringLLJoin(&rootMap, OC_RSRVD_RESOURCE_TYPE, payload->type);
 276         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting RT");
 277
 278         // Insert interfaces
 279         if (payload->iface)
 280         {
 281             err |= OCStringLLJoin(&rootMap, OC_RSRVD_INTERFACE, payload->iface);
 282             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding interface types tag/value");
 283         }
 284
 285         // Insert baseURI if present
 286         err |= ConditionalAddTextStringToMap(&rootMap, OC_RSRVD_BASE_URI,
 287                                             sizeof(OC_RSRVD_BASE_URI) - 1,
 288                                             payload->baseURI);
 289         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting baseURI");
 290
 291         // Insert Links into the root map.
 292         CborEncoder linkArray;
 293         err |= cbor_encode_text_string(&rootMap, OC_RSRVD_LINKS, sizeof(OC_RSRVD_LINKS) - 1);
 294         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting links array tag");
 295         err |= cbor_encoder_create_array(&rootMap, &linkArray, resourceCount);
 296         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting links array");
 297
 298         for(size_t i = 0; i < resourceCount; ++i)
 299         {
 300             CborEncoder linkMap;
 301             OCResourcePayload *resource = OCDiscoveryPayloadGetResource(payload, i);
 302             VERIFY_PARAM_NON_NULL(TAG, resource, "Failed retrieving resource");
 303
 304             // resource map inside the links array.
 305             err |= cbor_encoder_create_map(&linkArray, &linkMap, LINKS_MAP_LEN);
 306             VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating links map");
 307
 308             // Below are insertions of the resource properties into the map.
 309             // Uri
 310             err |= AddTextStringToMap(&linkMap, OC_RSRVD_HREF, sizeof(OC_RSRVD_HREF) - 1,
 311                     resource->uri);
 312             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding uri to links map");
 313
 314             // Resource Type
 315             if (resource->types)
 316             {
 317                 err |= OCStringLLJoin(&linkMap, OC_RSRVD_RESOURCE_TYPE, resource->types);
 318                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding resourceType tag/value to links map");
 319             }
 320             // Interface Types
 321             if (resource->interfaces)
 322             {
 323                 err |= OCStringLLJoin(&linkMap, OC_RSRVD_INTERFACE, resource->interfaces);
 324                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding interfaces tag/value to links map");
 325             }
 326
 327             // Policy
 328             CborEncoder policyMap;
 329             err |= cbor_encode_text_string(&linkMap, OC_RSRVD_POLICY, sizeof(OC_RSRVD_POLICY) - 1);
 330             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding policy tag to links map");
 331             err |= cbor_encoder_create_map(&linkMap, &policyMap, CborIndefiniteLength);
 332             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding policy map to links map");
 333
 334             // Bitmap
 335             err |=  cbor_encode_text_string(&policyMap, OC_RSRVD_BITMAP, sizeof(OC_RSRVD_BITMAP) - 1);
 336             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding bitmap tag to policy map");
 337             err |= cbor_encode_uint(&policyMap, resource->bitmap);
 338             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding bitmap value to policy map");
 339
 340             // Secure
 341             err |= cbor_encode_text_string(&policyMap, OC_RSRVD_SECURE,
 342                     sizeof(OC_RSRVD_SECURE) - 1);
 343             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure tag to policy map");
 344             err |= cbor_encode_boolean(&policyMap, resource->secure);
 345             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure value to policy map");
 346
 347             if (resource->secure || payload->baseURI)
 348             {
 349                 err |= cbor_encode_text_string(&policyMap, OC_RSRVD_HOSTING_PORT,
 350                         sizeof(OC_RSRVD_HOSTING_PORT) - 1);
 351                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure port tag");
 352                 err |= cbor_encode_uint(&policyMap, resource->port);
 353                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure port value");
 354             }
 355
 356 #ifdef TCP_ADAPTER
 357             err |= cbor_encode_text_string(&policyMap, OC_RSRVD_TCP_PORT,
 358                                            sizeof(OC_RSRVD_TCP_PORT) - 1);
 359             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding tcp port tag");
 360             err |= cbor_encode_uint(&policyMap, resource->tcpPort);
 361             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding tcp port value");
 362 #endif
 363
 364             err |= cbor_encoder_close_container(&linkMap, &policyMap);
 365             VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing policy map");
 366
 367             // Finsihed encoding a resource, close the map.
 368             err |= cbor_encoder_close_container(&linkArray, &linkMap);
 369             VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing link map");
 370         }
 371         // Close links array inside the root map.
 372         err |= cbor_encoder_close_container(&rootMap, &linkArray);
 373         VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing link array");
 374         // close root map inside the root array.
 375         err |= cbor_encoder_close_container(&rootArray, &rootMap);
 376         VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root map");
 377         // Close the final root array.
 378         err |= cbor_encoder_close_container(&encoder, &rootArray);
 379         VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root array");
 380     }
 381
 382 exit:
 383     return checkError(err, &encoder, outPayload, size);
 384 }
 385
 386 static int64_t OCConvertDevicePayload(OCDevicePayload *payload, uint8_t *outPayload,
 387         size_t *size)
 388 {
 389     if (!payload)
 390     {
 391         return CborUnknownError;
 392     }
 393     int64_t err = CborNoError;
 394     CborEncoder encoder;
 395     char *dataModelVersions = 0;
 396
 397     cbor_encoder_init(&encoder, outPayload, *size, 0);
 398     CborEncoder repMap;
 399     err |= cbor_encoder_create_map(&encoder, &repMap, CborIndefiniteLength);
 400     VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating device map");
 401
 402     // Resource Type
 403     if (payload->types)
 404     {
 405         OIC_LOG(INFO, TAG, "Payload has types");
 406         err |= OCStringLLJoin(&repMap, OC_RSRVD_RESOURCE_TYPE, payload->types);
 407         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding resource type tag/value.");
 408     }
 409
 410     if (payload->interfaces)
 411     {
 412         OIC_LOG(INFO, TAG, "Payload has interface");
 413         err |= OCStringLLJoin(&repMap, OC_RSRVD_INTERFACE, payload->interfaces);
 414         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding interface type tag/value.");
 415     }
 416
 417     // Device ID
 418     err |= AddTextStringToMap(&repMap, OC_RSRVD_DEVICE_ID, sizeof(OC_RSRVD_DEVICE_ID) - 1 , payload->sid);
 419     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding device id");
 420
 421     // Device Name
 422     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_DEVICE_NAME,
 423             sizeof(OC_RSRVD_DEVICE_NAME) - 1, payload->deviceName);
 424     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding device name");
 425
 426     // Device Spec Version
 427     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SPEC_VERSION,
 428             sizeof(OC_RSRVD_SPEC_VERSION) - 1, payload->specVersion);
 429     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding data spec version");
 430
 431     // Device data Model Versions
 432     if (payload->dataModelVersions)
 433     {
 434         OIC_LOG(INFO, TAG, "Payload has data model versions");
 435         dataModelVersions = OCCreateString(payload->dataModelVersions);
 436     }
 437     else
 438     {
 439         dataModelVersions = OICStrdup(DEFAULT_DATA_MODEL_VERSIONS);
 440     }
 441     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_DATA_MODEL_VERSION,
 442         sizeof(OC_RSRVD_DATA_MODEL_VERSION) - 1, dataModelVersions);
 443     OICFree(dataModelVersions);
 444     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding data model versions");
 445
 446     err |= cbor_encoder_close_container(&encoder, &repMap);
 447     VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing device map");
 448
 449 exit:
 450     return checkError(err, &encoder, outPayload, size);
 451 }
 452
 453 static int64_t OCConvertPlatformPayload(OCPlatformPayload *payload, uint8_t *outPayload,
 454         size_t *size)
 455 {
 456     int64_t err = CborNoError;
 457     CborEncoder encoder;
 458
 459     cbor_encoder_init(&encoder, outPayload, *size, 0);
 460
 461     CborEncoder repMap;
 462     err |= cbor_encoder_create_map(&encoder, &repMap, CborIndefiniteLength);
 463     VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating platform map");
 464
 465     // Platform ID
 466     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_ID,
 467             sizeof(OC_RSRVD_PLATFORM_ID) - 1, payload->info.platformID);
 468     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding platform id");
 469
 470     // MFG Name
 471     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_NAME,
 472         sizeof(OC_RSRVD_MFG_NAME) - 1, payload->info.manufacturerName);
 473     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding mfg name");
 474
 475     // MFG Url
 476     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_URL,
 477         sizeof(OC_RSRVD_MFG_URL) - 1, payload->info.manufacturerUrl);
 478     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding mfg url");
 479
 480     // Model Num
 481     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MODEL_NUM,
 482             sizeof(OC_RSRVD_MODEL_NUM) -1, payload->info.modelNumber);
 483     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding model num");
 484
 485     // Date of Mfg
 486     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_DATE,
 487             sizeof(OC_RSRVD_MFG_DATE) - 1, payload->info.dateOfManufacture);
 488     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding mfg date");
 489
 490     // Platform Version
 491     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_VERSION,
 492             sizeof(OC_RSRVD_PLATFORM_VERSION) - 1, payload->info.platformVersion);
 493     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding platform version");
 494
 495     // OS Version
 496     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_OS_VERSION,
 497             sizeof(OC_RSRVD_OS_VERSION) - 1, payload->info.operatingSystemVersion);
 498     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding OS version");
 499
 500     // Hardware Version
 501     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_HARDWARE_VERSION,
 502             sizeof(OC_RSRVD_HARDWARE_VERSION) - 1, payload->info.hardwareVersion);
 503     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding HW version");
 504
 505     // Firmware Version
 506     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_FIRMWARE_VERSION,
 507             sizeof(OC_RSRVD_FIRMWARE_VERSION) - 1, payload->info.firmwareVersion);
 508     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding firmware version");
 509
 510     // Support URL
 511     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SUPPORT_URL,
 512             sizeof(OC_RSRVD_SUPPORT_URL) - 1, payload->info.supportUrl);
 513     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding support url");
 514
 515     // System Time
 516     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SYSTEM_TIME,
 517             sizeof(OC_RSRVD_SYSTEM_TIME) - 1, payload->info.systemTime);
 518     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding system time");
 519
 520     // Resource type
 521     if (payload->rt)
 522     {
 523         err |= OCStringLLJoin(&repMap, OC_RSRVD_RESOURCE_TYPE, payload->rt);
 524         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding resource type.");
 525     }
 526
 527     // Resource interfaces
 528     if (payload->interfaces)
 529     {
 530         err |= OCStringLLJoin(&repMap, OC_RSRVD_INTERFACE, payload->interfaces);
 531         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding platform interface type.");
 532     }
 533
 534     // Close Map
 535     err |= cbor_encoder_close_container(&encoder, &repMap);
 536     VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep map");
 537
 538 exit:
 539     return checkError(err, &encoder, outPayload, size);
 540 }
 541
 542 static int64_t OCConvertArrayItem(CborEncoder *array, const OCRepPayloadValueArray *valArray,
 543         size_t index)
 544 {
 545     int64_t err = CborNoError;
 546     switch (valArray->type)
 547     {
 548         case OCREP_PROP_NULL:
 549             OIC_LOG(ERROR, TAG, "ConvertArray Invalid NULL");
 550             err = CborUnknownError;
 551             break;
 552         case OCREP_PROP_INT:
 553             err |= cbor_encode_int(array, valArray->iArray[index]);
 554             break;
 555         case OCREP_PROP_DOUBLE:
 556             err |= cbor_encode_double(array, valArray->dArray[index]);
 557             break;
 558         case OCREP_PROP_BOOL:
 559             err |= cbor_encode_boolean(array, valArray->bArray[index]);
 560             break;
 561         case OCREP_PROP_STRING:
 562             if (!valArray->strArray[index])
 563             {
 564                 err |= cbor_encode_null(array);
 565             }
 566             else
 567             {
 568                 err |= cbor_encode_text_string(array, valArray->strArray[index],
 569                         strlen(valArray->strArray[index]));
 570             }
 571             break;
 572         case OCREP_PROP_BYTE_STRING:
 573             if (!valArray->strArray[index])
 574             {
 575                 err |= cbor_encode_null(array);
 576             }
 577             else
 578             {
 579                 err |= cbor_encode_byte_string(array, valArray->ocByteStrArray[index].bytes,
 580                         valArray->ocByteStrArray[index].len);
 581             }
 582             break;
 583         case OCREP_PROP_OBJECT:
 584             if (!valArray->objArray[index])
 585             {
 586                 err |= cbor_encode_null(array);
 587             }
 588             else
 589             {
 590                 err |= OCConvertRepMap(array, valArray->objArray[index]);
 591             }
 592             break;
 593         case OCREP_PROP_ARRAY:
 594             OIC_LOG(ERROR, TAG, "ConvertArray Invalid child array");
 595             err = CborUnknownError;
 596             break;
 597     }
 598
 599     return err;
 600 }
 601
 602 static int64_t OCConvertArray(CborEncoder *parent, const OCRepPayloadValueArray *valArray)
 603 {
 604     int64_t err = CborNoError;
 605     CborEncoder array;
 606     err |= cbor_encoder_create_array(parent, &array, valArray->dimensions[0]);
 607     VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep array");
 608
 609     for (size_t i = 0; i < valArray->dimensions[0]; ++i)
 610     {
 611         if (0 != valArray->dimensions[1])
 612         {
 613             CborEncoder array2;
 614             err |= cbor_encoder_create_array(&array, &array2, valArray->dimensions[1]);
 615             VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep array2");
 616
 617             for (size_t j = 0; j < valArray->dimensions[1]; ++j)
 618             {
 619                 if (0 != valArray->dimensions[2])
 620                 {
 621                     CborEncoder array3;
 622                     err |= cbor_encoder_create_array(&array2, &array3, valArray->dimensions[2]);
 623                     VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep array3");
 624
 625                     for(size_t k = 0; k < valArray->dimensions[2]; ++k)
 626                     {
 627                         err |= OCConvertArrayItem(&array3, valArray,
 628                             j * valArray->dimensions[2] +
 629                             i * valArray->dimensions[2] * valArray->dimensions[1] +
 630                             k);
 631                         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep array3 value");
 632                     }
 633                     err |= cbor_encoder_close_container(&array2, &array3);
 634                     VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep array3");
 635                 }
 636                 else
 637                 {
 638                     err |= OCConvertArrayItem(&array2, valArray, i * valArray->dimensions[1] + j);
 639                     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep array2 value");
 640                 }
 641             }
 642             err |= cbor_encoder_close_container(&array, &array2);
 643             VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep array2");
 644         }
 645         else
 646         {
 647             err |= OCConvertArrayItem(&array, valArray, i);
 648             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep array value");
 649         }
 650     }
 651     err |= cbor_encoder_close_container(parent, &array);
 652     VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep array");
 653
 654 exit:
 655     return err;
 656 }
 657
 658 static int64_t OCConvertRepMap(CborEncoder *map, const OCRepPayload *payload)
 659 {
 660     int64_t err = CborNoError;
 661     CborEncoder repMap;
 662     err |= cbor_encoder_create_map(map, &repMap, CborIndefiniteLength);
 663     VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep map");
 664     err |= OCConvertSingleRepPayload(&repMap, payload);
 665     VERIFY_CBOR_SUCCESS(TAG, err, "Failed converting single rep payload");
 666     err |= cbor_encoder_close_container(map, &repMap);
 667     VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep map");
 668 exit:
 669     return err;
 670 }
 671
 672 static int64_t OCConvertSingleRepPayload(CborEncoder *repMap, const OCRepPayload *payload)
 673 {
 674     int64_t err = CborNoError;
 675     OCRepPayloadValue *value = payload->values;
 676     while (value)
 677     {
 678         err |= cbor_encode_text_string(repMap, value->name, strlen(value->name));
 679         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding tag name");
 680
 681         switch (value->type)
 682         {
 683             case OCREP_PROP_NULL:
 684                 err |= cbor_encode_null(repMap);
 685                 break;
 686             case OCREP_PROP_INT:
 687                 err |= cbor_encode_int(repMap, value->i);
 688                 break;
 689             case OCREP_PROP_DOUBLE:
 690                 err |= cbor_encode_double(repMap, value->d);
 691                 break;
 692             case OCREP_PROP_BOOL:
 693                 err |= cbor_encode_boolean(repMap, value->b);
 694                 break;
 695             case OCREP_PROP_STRING:
 696                 err |= cbor_encode_text_string(repMap, value->str, strlen(value->str));
 697                 break;
 698             case OCREP_PROP_BYTE_STRING:
 699                 err |= cbor_encode_byte_string(repMap, value->ocByteStr.bytes, value->ocByteStr.len);
 700                 break;
 701             case OCREP_PROP_OBJECT:
 702                 err |= OCConvertRepMap(repMap, value->obj);
 703                 break;
 704             case OCREP_PROP_ARRAY:
 705                 err |= OCConvertArray(repMap, &value->arr);
 706                 break;
 707             default:
 708                 OIC_LOG_V(ERROR, TAG, "Invalid Prop type: %d", value->type);
 709                 break;
 710         }
 711         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding single rep value");
 712         value = value->next;
 713     }
 714
 715 exit:
 716     return err;
 717 }
 718
 719 static int64_t OCConvertRepPayload(OCRepPayload *payload, uint8_t *outPayload, size_t *size)
 720 {
 721     CborEncoder encoder;
 722     int64_t err = CborNoError;
 723
 724     cbor_encoder_init(&encoder, outPayload, *size, 0);
 725
 726     size_t arrayCount = 0;
 727     for (OCRepPayload *temp = payload; temp; temp = temp->next)
 728     {
 729         arrayCount++;
 730     }
 731     CborEncoder rootArray;
 732     if (arrayCount > 1)
 733     {
 734         err |= cbor_encoder_create_array(&encoder, &rootArray, arrayCount);
 735         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep root map");
 736     }
 737
 738     while (payload != NULL && (err == CborNoError))
 739     {
 740         CborEncoder rootMap;
 741         err |= cbor_encoder_create_map(((arrayCount == 1)? &encoder: &rootArray),
 742                                             &rootMap, CborIndefiniteLength);
 743         VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating root map");
 744
 745         // Only in case of collection href is included.
 746         if (arrayCount > 1 && payload->uri && strlen(payload->uri) > 0)
 747         {
 748             OIC_LOG(INFO, TAG, "Payload has uri");
 749             err |= cbor_encode_text_string(&rootMap, OC_RSRVD_HREF, strlen(OC_RSRVD_HREF));
 750             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep href tag");
 751             err |= cbor_encode_text_string(&rootMap, payload->uri, strlen(payload->uri));
 752             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep href value");
 753         }
 754         if (payload->types)
 755         {
 756             OIC_LOG(INFO, TAG, "Payload has types");
 757             err |= OCStringLLJoin(&rootMap, OC_RSRVD_RESOURCE_TYPE, payload->types);
 758             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding resource type.");
 759         }
 760         if (payload->interfaces)
 761         {
 762             OIC_LOG(INFO, TAG, "Payload has interfaces");
 763             err |= OCStringLLJoin(&rootMap, OC_RSRVD_INTERFACE, payload->interfaces);
 764             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding platform interface type.");
 765         }
 766
 767         err |= OCConvertSingleRepPayload(&rootMap, payload);
 768         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting rep payload");
 769
 770         // Close main array
 771         err |= cbor_encoder_close_container(((arrayCount == 1) ? &encoder: &rootArray),
 772                 &rootMap);
 773         VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root map");
 774         payload = payload->next;
 775     }
 776     if (arrayCount > 1)
 777     {
 778         err |= cbor_encoder_close_container(&encoder, &rootArray);
 779         VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root array");
 780     }
 781
 782 exit:
 783     return checkError(err, &encoder, outPayload, size);
 784 }
 785
 786 static int64_t OCConvertPresencePayload(OCPresencePayload *payload, uint8_t *outPayload,
 787         size_t *size)
 788 {
 789     int64_t err = CborNoError;
 790     CborEncoder encoder;
 791
 792     cbor_encoder_init(&encoder, outPayload, *size, 0);
 793     CborEncoder map;
 794     err |= cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength);
 795     VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating presence map");
 796
 797     // Sequence Number
 798     err |= cbor_encode_text_string(&map, OC_RSRVD_NONCE, sizeof(OC_RSRVD_NONCE) - 1);
 799     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding nonce tag to presence map");
 800     err |= cbor_encode_uint(&map, payload->sequenceNumber);
 801     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding nonce value to presence map");
 802
 803     // Max Age
 804     err |= cbor_encode_text_string(&map, OC_RSRVD_TTL, sizeof(OC_RSRVD_TTL) - 1);
 805     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding ttl tag to presence map");
 806     err |= cbor_encode_uint(&map, payload->maxAge);
 807     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding ttl value to presence map");
 808
 809     // Trigger
 810     err |= cbor_encode_text_string(&map, OC_RSRVD_TRIGGER, sizeof(OC_RSRVD_TRIGGER) - 1);
 811     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding trigger tag to presence map");
 812     err |= cbor_encode_simple_value(&map, payload->trigger);
 813     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding trigger value to presence map");
 814
 815     // Resource type name
 816     if (payload->trigger != OC_PRESENCE_TRIGGER_DELETE)
 817     {
 818         err |= ConditionalAddTextStringToMap(&map, OC_RSRVD_RESOURCE_TYPE,
 819                 sizeof(OC_RSRVD_RESOURCE_TYPE) - 1, payload->resourceType);
 820         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding resource type to presence map");
 821     }
 822
 823     // Close Map
 824     err |= cbor_encoder_close_container(&encoder, &map);
 825     VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing presence map");
 826
 827 exit:
 828     return checkError(err, &encoder, outPayload, size);
 829 }
 830
 831 static int64_t AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
 832         const char* value)
 833 {
 834     int64_t err = cbor_encode_text_string(map, key, keylen);
 835     if (CborNoError != err)
 836     {
 837         return err;
 838     }
 839     return cbor_encode_text_string(map, value, strlen(value));
 840 }
 841
 842 static int64_t ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
 843         const char* value)
 844 {
 845     return value ? AddTextStringToMap(map, key, keylen, value) : 0;
 846 }