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     /*
 228     The format for the payload is "modelled" as JSON.
 229
 230     [                                                  // rootArray
 231         {                                              // rootMap
 232             "di" : UUID,                               // device ID
 233             "rt": ["oic.wk.res"]
 234             "n":"MyDevice"
 235             "if":"oic.if.ll oic.if.baseline"
 236             "di": "0685B960-736F-46F7-BEC0-9E6CBD61ADC1",
 237             links :[                                   // linksArray contains maps of resources
 238                         {
 239                             href, rt, if, policy       // Resource 1
 240                         },
 241                         {
 242                             href, rt, if, policy       // Resource 2
 243                         },
 244                         .
 245                         .
 246                         .
 247                     ]
 248         }
 249         {                                              // rootMap
 250             ...
 251         }
 252     ]
 253     */
 254
 255     // Open the main root array
 256     CborEncoder rootArray;
 257     err |= cbor_encoder_create_array(&encoder, &rootArray, 1);
 258     VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating discovery root array");
 259
 260     while (payload && payload->resources)
 261     {
 262         // Open the root map in the root array
 263         CborEncoder rootMap;
 264         err |= cbor_encoder_create_map(&rootArray, &rootMap, CborIndefiniteLength);
 265         VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating discovery map");
 266
 267         // Insert Name
 268         err |= ConditionalAddTextStringToMap(&rootMap, OC_RSRVD_DEVICE_NAME,
 269                 sizeof(OC_RSRVD_DEVICE_NAME) - 1, payload->name);
 270         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting name");
 271
 272         // Insert Device ID into the root map
 273         err |= AddTextStringToMap(&rootMap, OC_RSRVD_DEVICE_ID, sizeof(OC_RSRVD_DEVICE_ID) - 1,
 274                 payload->sid);
 275         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting device id");
 276
 277         // Insert Resource Type
 278         err |= OCStringLLJoin(&rootMap, OC_RSRVD_RESOURCE_TYPE, payload->type);
 279         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting RT");
 280
 281         // Insert interfaces
 282         if (payload->iface)
 283         {
 284             err |= OCStringLLJoin(&rootMap, OC_RSRVD_INTERFACE, payload->iface);
 285             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding interface types tag/value");
 286         }
 287
 288         // Insert baseURI if present
 289         err |= ConditionalAddTextStringToMap(&rootMap, OC_RSRVD_BASE_URI,
 290                                              sizeof(OC_RSRVD_BASE_URI) - 1,
 291                                              payload->baseURI);
 292         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting baseURI");
 293
 294         // Insert Links into the root map.
 295         CborEncoder linkArray;
 296         err |= cbor_encode_text_string(&rootMap, OC_RSRVD_LINKS, sizeof(OC_RSRVD_LINKS) - 1);
 297         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting links array tag");
 298         size_t resourceCount =  OCDiscoveryPayloadGetResourceCount(payload);
 299         err |= cbor_encoder_create_array(&rootMap, &linkArray, resourceCount);
 300         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting links array");
 301
 302         for (size_t i = 0; i < resourceCount; ++i)
 303         {
 304             CborEncoder linkMap;
 305             OCResourcePayload *resource = OCDiscoveryPayloadGetResource(payload, i);
 306             VERIFY_PARAM_NON_NULL(TAG, resource, "Failed retrieving resource");
 307
 308             // resource map inside the links array.
 309             err |= cbor_encoder_create_map(&linkArray, &linkMap, LINKS_MAP_LEN);
 310             VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating links map");
 311
 312             // Below are insertions of the resource properties into the map.
 313             // Uri
 314             err |= AddTextStringToMap(&linkMap, OC_RSRVD_HREF, sizeof(OC_RSRVD_HREF) - 1,
 315                     resource->uri);
 316             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding uri to links map");
 317
 318             // Resource Type
 319             if (resource->types)
 320             {
 321                 err |= OCStringLLJoin(&linkMap, OC_RSRVD_RESOURCE_TYPE, resource->types);
 322                 VERIFY_CBOR_SUCCESS(TAG, err,
 323                                     "Failed adding resourceType tag/value to links map");
 324             }
 325             // Interface Types
 326             if (resource->interfaces)
 327             {
 328                 err |= OCStringLLJoin(&linkMap, OC_RSRVD_INTERFACE, resource->interfaces);
 329                 VERIFY_CBOR_SUCCESS(TAG, err,
 330                                     "Failed adding interfaces tag/value to links map");
 331             }
 332
 333             // Policy
 334             CborEncoder policyMap;
 335             err |= cbor_encode_text_string(&linkMap, OC_RSRVD_POLICY,
 336                                            sizeof(OC_RSRVD_POLICY) - 1);
 337             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding policy tag to links map");
 338             err |= cbor_encoder_create_map(&linkMap, &policyMap, CborIndefiniteLength);
 339             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding policy map to links map");
 340
 341             // Bitmap
 342             err |=  cbor_encode_text_string(&policyMap, OC_RSRVD_BITMAP,
 343                                             sizeof(OC_RSRVD_BITMAP) - 1);
 344             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding bitmap tag to policy map");
 345             err |= cbor_encode_uint(&policyMap, resource->bitmap);
 346             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding bitmap value to policy map");
 347
 348             // Secure
 349             err |= cbor_encode_text_string(&policyMap, OC_RSRVD_SECURE,
 350                                            sizeof(OC_RSRVD_SECURE) - 1);
 351             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure tag to policy map");
 352             err |= cbor_encode_boolean(&policyMap, resource->secure);
 353             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure value to policy map");
 354
 355             if (resource->secure || payload->baseURI)
 356             {
 357                 err |= cbor_encode_text_string(&policyMap, OC_RSRVD_HOSTING_PORT,
 358                                                sizeof(OC_RSRVD_HOSTING_PORT) - 1);
 359                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure port tag");
 360                 err |= cbor_encode_uint(&policyMap, resource->port);
 361                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure port value");
 362             }
 363
 364 #ifdef TCP_ADAPTER
 365             err |= cbor_encode_text_string(&policyMap, OC_RSRVD_TCP_PORT,
 366                                            sizeof(OC_RSRVD_TCP_PORT) - 1);
 367             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding tcp port tag");
 368             err |= cbor_encode_uint(&policyMap, resource->tcpPort);
 369             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding tcp port value");
 370 #endif
 371
 372             err |= cbor_encoder_close_container(&linkMap, &policyMap);
 373             VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing policy map");
 374
 375             // Finsihed encoding a resource, close the map.
 376             err |= cbor_encoder_close_container(&linkArray, &linkMap);
 377             VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing link map");
 378         }
 379         // Close links array inside the root map.
 380         err |= cbor_encoder_close_container(&rootMap, &linkArray);
 381         VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing link array");
 382         // close root map inside the root array.
 383         err |= cbor_encoder_close_container(&rootArray, &rootMap);
 384         VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root map");
 385
 386         payload = payload->next;
 387     }
 388
 389     // Close the final root array.
 390     err |= cbor_encoder_close_container(&encoder, &rootArray);
 391     VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root array");
 392
 393 exit:
 394     return checkError(err, &encoder, outPayload, size);
 395 }
 396
 397 static int64_t OCConvertDevicePayload(OCDevicePayload *payload, uint8_t *outPayload,
 398         size_t *size)
 399 {
 400     if (!payload)
 401     {
 402         return CborUnknownError;
 403     }
 404     int64_t err = CborNoError;
 405     CborEncoder encoder;
 406     char *dataModelVersions = 0;
 407
 408     cbor_encoder_init(&encoder, outPayload, *size, 0);
 409     CborEncoder repMap;
 410     err |= cbor_encoder_create_map(&encoder, &repMap, CborIndefiniteLength);
 411     VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating device map");
 412
 413     // Resource Type
 414     if (payload->types)
 415     {
 416         OIC_LOG(INFO, TAG, "Payload has types");
 417         err |= OCStringLLJoin(&repMap, OC_RSRVD_RESOURCE_TYPE, payload->types);
 418         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding resource type tag/value.");
 419     }
 420
 421     if (payload->interfaces)
 422     {
 423         OIC_LOG(INFO, TAG, "Payload has interface");
 424         err |= OCStringLLJoin(&repMap, OC_RSRVD_INTERFACE, payload->interfaces);
 425         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding interface type tag/value.");
 426     }
 427
 428     // Device ID
 429     err |= AddTextStringToMap(&repMap, OC_RSRVD_DEVICE_ID, sizeof(OC_RSRVD_DEVICE_ID) - 1 , payload->sid);
 430     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding device id");
 431
 432     // Device Name
 433     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_DEVICE_NAME,
 434             sizeof(OC_RSRVD_DEVICE_NAME) - 1, payload->deviceName);
 435     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding device name");
 436
 437     // Device Spec Version
 438     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SPEC_VERSION,
 439             sizeof(OC_RSRVD_SPEC_VERSION) - 1, payload->specVersion);
 440     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding data spec version");
 441
 442     // Device data Model Versions
 443     if (payload->dataModelVersions)
 444     {
 445         OIC_LOG(INFO, TAG, "Payload has data model versions");
 446         dataModelVersions = OCCreateString(payload->dataModelVersions);
 447     }
 448     else
 449     {
 450         dataModelVersions = OICStrdup(DEFAULT_DATA_MODEL_VERSIONS);
 451     }
 452     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_DATA_MODEL_VERSION,
 453         sizeof(OC_RSRVD_DATA_MODEL_VERSION) - 1, dataModelVersions);
 454     OICFree(dataModelVersions);
 455     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding data model versions");
 456
 457     err |= cbor_encoder_close_container(&encoder, &repMap);
 458     VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing device map");
 459
 460 exit:
 461     return checkError(err, &encoder, outPayload, size);
 462 }
 463
 464 static int64_t OCConvertPlatformPayload(OCPlatformPayload *payload, uint8_t *outPayload,
 465         size_t *size)
 466 {
 467     int64_t err = CborNoError;
 468     CborEncoder encoder;
 469
 470     cbor_encoder_init(&encoder, outPayload, *size, 0);
 471
 472     CborEncoder repMap;
 473     err |= cbor_encoder_create_map(&encoder, &repMap, CborIndefiniteLength);
 474     VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating platform map");
 475
 476     // Platform ID
 477     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_ID,
 478             sizeof(OC_RSRVD_PLATFORM_ID) - 1, payload->info.platformID);
 479     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding platform id");
 480
 481     // MFG Name
 482     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_NAME,
 483         sizeof(OC_RSRVD_MFG_NAME) - 1, payload->info.manufacturerName);
 484     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding mfg name");
 485
 486     // MFG Url
 487     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_URL,
 488         sizeof(OC_RSRVD_MFG_URL) - 1, payload->info.manufacturerUrl);
 489     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding mfg url");
 490
 491     // Model Num
 492     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MODEL_NUM,
 493             sizeof(OC_RSRVD_MODEL_NUM) -1, payload->info.modelNumber);
 494     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding model num");
 495
 496     // Date of Mfg
 497     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_DATE,
 498             sizeof(OC_RSRVD_MFG_DATE) - 1, payload->info.dateOfManufacture);
 499     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding mfg date");
 500
 501     // Platform Version
 502     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_VERSION,
 503             sizeof(OC_RSRVD_PLATFORM_VERSION) - 1, payload->info.platformVersion);
 504     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding platform version");
 505
 506     // OS Version
 507     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_OS_VERSION,
 508             sizeof(OC_RSRVD_OS_VERSION) - 1, payload->info.operatingSystemVersion);
 509     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding OS version");
 510
 511     // Hardware Version
 512     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_HARDWARE_VERSION,
 513             sizeof(OC_RSRVD_HARDWARE_VERSION) - 1, payload->info.hardwareVersion);
 514     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding HW version");
 515
 516     // Firmware Version
 517     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_FIRMWARE_VERSION,
 518             sizeof(OC_RSRVD_FIRMWARE_VERSION) - 1, payload->info.firmwareVersion);
 519     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding firmware version");
 520
 521     // Support URL
 522     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SUPPORT_URL,
 523             sizeof(OC_RSRVD_SUPPORT_URL) - 1, payload->info.supportUrl);
 524     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding support url");
 525
 526     // System Time
 527     err |= ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SYSTEM_TIME,
 528             sizeof(OC_RSRVD_SYSTEM_TIME) - 1, payload->info.systemTime);
 529     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding system time");
 530
 531     // Resource type
 532     if (payload->rt)
 533     {
 534         err |= OCStringLLJoin(&repMap, OC_RSRVD_RESOURCE_TYPE, payload->rt);
 535         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding resource type.");
 536     }
 537
 538     // Resource interfaces
 539     if (payload->interfaces)
 540     {
 541         err |= OCStringLLJoin(&repMap, OC_RSRVD_INTERFACE, payload->interfaces);
 542         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding platform interface type.");
 543     }
 544
 545     // Close Map
 546     err |= cbor_encoder_close_container(&encoder, &repMap);
 547     VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep map");
 548
 549 exit:
 550     return checkError(err, &encoder, outPayload, size);
 551 }
 552
 553 static int64_t OCConvertArrayItem(CborEncoder *array, const OCRepPayloadValueArray *valArray,
 554         size_t index)
 555 {
 556     int64_t err = CborNoError;
 557     switch (valArray->type)
 558     {
 559         case OCREP_PROP_NULL:
 560             OIC_LOG(ERROR, TAG, "ConvertArray Invalid NULL");
 561             err = CborUnknownError;
 562             break;
 563         case OCREP_PROP_INT:
 564             err |= cbor_encode_int(array, valArray->iArray[index]);
 565             break;
 566         case OCREP_PROP_DOUBLE:
 567             err |= cbor_encode_double(array, valArray->dArray[index]);
 568             break;
 569         case OCREP_PROP_BOOL:
 570             err |= cbor_encode_boolean(array, valArray->bArray[index]);
 571             break;
 572         case OCREP_PROP_STRING:
 573             if (!valArray->strArray[index])
 574             {
 575                 err |= cbor_encode_null(array);
 576             }
 577             else
 578             {
 579                 err |= cbor_encode_text_string(array, valArray->strArray[index],
 580                         strlen(valArray->strArray[index]));
 581             }
 582             break;
 583         case OCREP_PROP_BYTE_STRING:
 584             if (!valArray->strArray[index])
 585             {
 586                 err |= cbor_encode_null(array);
 587             }
 588             else
 589             {
 590                 err |= cbor_encode_byte_string(array, valArray->ocByteStrArray[index].bytes,
 591                         valArray->ocByteStrArray[index].len);
 592             }
 593             break;
 594         case OCREP_PROP_OBJECT:
 595             if (!valArray->objArray[index])
 596             {
 597                 err |= cbor_encode_null(array);
 598             }
 599             else
 600             {
 601                 err |= OCConvertRepMap(array, valArray->objArray[index]);
 602             }
 603             break;
 604         case OCREP_PROP_ARRAY:
 605             OIC_LOG(ERROR, TAG, "ConvertArray Invalid child array");
 606             err = CborUnknownError;
 607             break;
 608     }
 609
 610     return err;
 611 }
 612
 613 static int64_t OCConvertArray(CborEncoder *parent, const OCRepPayloadValueArray *valArray)
 614 {
 615     int64_t err = CborNoError;
 616     CborEncoder array;
 617     err |= cbor_encoder_create_array(parent, &array, valArray->dimensions[0]);
 618     VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep array");
 619
 620     for (size_t i = 0; i < valArray->dimensions[0]; ++i)
 621     {
 622         if (0 != valArray->dimensions[1])
 623         {
 624             CborEncoder array2;
 625             err |= cbor_encoder_create_array(&array, &array2, valArray->dimensions[1]);
 626             VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep array2");
 627
 628             for (size_t j = 0; j < valArray->dimensions[1]; ++j)
 629             {
 630                 if (0 != valArray->dimensions[2])
 631                 {
 632                     CborEncoder array3;
 633                     err |= cbor_encoder_create_array(&array2, &array3, valArray->dimensions[2]);
 634                     VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep array3");
 635
 636                     for(size_t k = 0; k < valArray->dimensions[2]; ++k)
 637                     {
 638                         err |= OCConvertArrayItem(&array3, valArray,
 639                             j * valArray->dimensions[2] +
 640                             i * valArray->dimensions[2] * valArray->dimensions[1] +
 641                             k);
 642                         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep array3 value");
 643                     }
 644                     err |= cbor_encoder_close_container(&array2, &array3);
 645                     VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep array3");
 646                 }
 647                 else
 648                 {
 649                     err |= OCConvertArrayItem(&array2, valArray, i * valArray->dimensions[1] + j);
 650                     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep array2 value");
 651                 }
 652             }
 653             err |= cbor_encoder_close_container(&array, &array2);
 654             VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep array2");
 655         }
 656         else
 657         {
 658             err |= OCConvertArrayItem(&array, valArray, i);
 659             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep array value");
 660         }
 661     }
 662     err |= cbor_encoder_close_container(parent, &array);
 663     VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep array");
 664
 665 exit:
 666     return err;
 667 }
 668
 669 static int64_t OCConvertRepMap(CborEncoder *map, const OCRepPayload *payload)
 670 {
 671     int64_t err = CborNoError;
 672     CborEncoder repMap;
 673     err |= cbor_encoder_create_map(map, &repMap, CborIndefiniteLength);
 674     VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep map");
 675     err |= OCConvertSingleRepPayload(&repMap, payload);
 676     VERIFY_CBOR_SUCCESS(TAG, err, "Failed converting single rep payload");
 677     err |= cbor_encoder_close_container(map, &repMap);
 678     VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep map");
 679 exit:
 680     return err;
 681 }
 682
 683 static int64_t OCConvertSingleRepPayload(CborEncoder *repMap, const OCRepPayload *payload)
 684 {
 685     int64_t err = CborNoError;
 686     OCRepPayloadValue *value = payload->values;
 687     while (value)
 688     {
 689         err |= cbor_encode_text_string(repMap, value->name, strlen(value->name));
 690         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding tag name");
 691
 692         switch (value->type)
 693         {
 694             case OCREP_PROP_NULL:
 695                 err |= cbor_encode_null(repMap);
 696                 break;
 697             case OCREP_PROP_INT:
 698                 err |= cbor_encode_int(repMap, value->i);
 699                 break;
 700             case OCREP_PROP_DOUBLE:
 701                 err |= cbor_encode_double(repMap, value->d);
 702                 break;
 703             case OCREP_PROP_BOOL:
 704                 err |= cbor_encode_boolean(repMap, value->b);
 705                 break;
 706             case OCREP_PROP_STRING:
 707                 err |= cbor_encode_text_string(repMap, value->str, strlen(value->str));
 708                 break;
 709             case OCREP_PROP_BYTE_STRING:
 710                 err |= cbor_encode_byte_string(repMap, value->ocByteStr.bytes, value->ocByteStr.len);
 711                 break;
 712             case OCREP_PROP_OBJECT:
 713                 err |= OCConvertRepMap(repMap, value->obj);
 714                 break;
 715             case OCREP_PROP_ARRAY:
 716                 err |= OCConvertArray(repMap, &value->arr);
 717                 break;
 718             default:
 719                 OIC_LOG_V(ERROR, TAG, "Invalid Prop type: %d", value->type);
 720                 break;
 721         }
 722         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding single rep value");
 723         value = value->next;
 724     }
 725
 726 exit:
 727     return err;
 728 }
 729
 730 static int64_t OCConvertRepPayload(OCRepPayload *payload, uint8_t *outPayload, size_t *size)
 731 {
 732     CborEncoder encoder;
 733     int64_t err = CborNoError;
 734
 735     cbor_encoder_init(&encoder, outPayload, *size, 0);
 736
 737     size_t arrayCount = 0;
 738     for (OCRepPayload *temp = payload; temp; temp = temp->next)
 739     {
 740         arrayCount++;
 741     }
 742     CborEncoder rootArray;
 743     if (arrayCount > 1)
 744     {
 745         err |= cbor_encoder_create_array(&encoder, &rootArray, arrayCount);
 746         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep root map");
 747     }
 748
 749     while (payload != NULL && (err == CborNoError))
 750     {
 751         CborEncoder rootMap;
 752         err |= cbor_encoder_create_map(((arrayCount == 1)? &encoder: &rootArray),
 753                                             &rootMap, CborIndefiniteLength);
 754         VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating root map");
 755
 756         // Only in case of collection href is included.
 757         if (arrayCount > 1 && payload->uri && strlen(payload->uri) > 0)
 758         {
 759             OIC_LOG(INFO, TAG, "Payload has uri");
 760             err |= cbor_encode_text_string(&rootMap, OC_RSRVD_HREF, strlen(OC_RSRVD_HREF));
 761             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep href tag");
 762             err |= cbor_encode_text_string(&rootMap, payload->uri, strlen(payload->uri));
 763             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep href value");
 764         }
 765         if (payload->types)
 766         {
 767             OIC_LOG(INFO, TAG, "Payload has types");
 768             err |= OCStringLLJoin(&rootMap, OC_RSRVD_RESOURCE_TYPE, payload->types);
 769             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding resource type.");
 770         }
 771         if (payload->interfaces)
 772         {
 773             OIC_LOG(INFO, TAG, "Payload has interfaces");
 774             err |= OCStringLLJoin(&rootMap, OC_RSRVD_INTERFACE, payload->interfaces);
 775             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding platform interface type.");
 776         }
 777
 778         err |= OCConvertSingleRepPayload(&rootMap, payload);
 779         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting rep payload");
 780
 781         // Close main array
 782         err |= cbor_encoder_close_container(((arrayCount == 1) ? &encoder: &rootArray),
 783                 &rootMap);
 784         VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root map");
 785         payload = payload->next;
 786     }
 787     if (arrayCount > 1)
 788     {
 789         err |= cbor_encoder_close_container(&encoder, &rootArray);
 790         VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root array");
 791     }
 792
 793 exit:
 794     return checkError(err, &encoder, outPayload, size);
 795 }
 796
 797 static int64_t OCConvertPresencePayload(OCPresencePayload *payload, uint8_t *outPayload,
 798         size_t *size)
 799 {
 800     int64_t err = CborNoError;
 801     CborEncoder encoder;
 802
 803     cbor_encoder_init(&encoder, outPayload, *size, 0);
 804     CborEncoder map;
 805     err |= cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength);
 806     VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating presence map");
 807
 808     // Sequence Number
 809     err |= cbor_encode_text_string(&map, OC_RSRVD_NONCE, sizeof(OC_RSRVD_NONCE) - 1);
 810     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding nonce tag to presence map");
 811     err |= cbor_encode_uint(&map, payload->sequenceNumber);
 812     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding nonce value to presence map");
 813
 814     // Max Age
 815     err |= cbor_encode_text_string(&map, OC_RSRVD_TTL, sizeof(OC_RSRVD_TTL) - 1);
 816     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding ttl tag to presence map");
 817     err |= cbor_encode_uint(&map, payload->maxAge);
 818     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding ttl value to presence map");
 819
 820     // Trigger
 821     err |= cbor_encode_text_string(&map, OC_RSRVD_TRIGGER, sizeof(OC_RSRVD_TRIGGER) - 1);
 822     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding trigger tag to presence map");
 823     err |= cbor_encode_simple_value(&map, payload->trigger);
 824     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding trigger value to presence map");
 825
 826     // Resource type name
 827     if (payload->trigger != OC_PRESENCE_TRIGGER_DELETE)
 828     {
 829         err |= ConditionalAddTextStringToMap(&map, OC_RSRVD_RESOURCE_TYPE,
 830                 sizeof(OC_RSRVD_RESOURCE_TYPE) - 1, payload->resourceType);
 831         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding resource type to presence map");
 832     }
 833
 834     // Close Map
 835     err |= cbor_encoder_close_container(&encoder, &map);
 836     VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing presence map");
 837
 838 exit:
 839     return checkError(err, &encoder, outPayload, size);
 840 }
 841
 842 static int64_t AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
 843         const char* value)
 844 {
 845     int64_t err = cbor_encode_text_string(map, key, keylen);
 846     if (CborNoError != err)
 847     {
 848         return err;
 849     }
 850     return cbor_encode_text_string(map, value, strlen(value));
 851 }
 852
 853 static int64_t ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
 854         const char* value)
 855 {
 856     return value ? AddTextStringToMap(map, key, keylen, value) : 0;
 857 }