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 #ifdef ARDUINO
  22 #define __STDC_LIMIT_MACROS
  23 #endif
  24
  25 #include "ocpayloadcbor.h"
  26 #include "platform_features.h"
  27 #include <stdlib.h>
  28 #include "oic_malloc.h"
  29 #include "oic_string.h"
  30 #include "logger.h"
  31 #include "ocpayload.h"
  32 #include "ocrandom.h"
  33 #include "ocresourcehandler.h"
  34 #include "cbor.h"
  35
  36 #define TAG "OIC_RI_PAYLOADCONVERT"
  37
  38 // Arbitrarily chosen size that seems to contain the majority of packages
  39 #define INIT_SIZE (255)
  40
  41 // Discovery Links Map Length.
  42 #define LINKS_MAP_LEN 4
  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 OCConvertRepPayload(OCRepPayload *payload, uint8_t *outPayload, size_t *size);
  49 static int64_t OCConvertRepMap(CborEncoder *map, const OCRepPayload *payload);
  50 #ifdef WITH_PRESENCE
  51 static int64_t OCConvertPresencePayload(OCPresencePayload *payload, uint8_t *outPayload,
  52         size_t *size);
  53 #endif
  54 static int64_t OCConvertSecurityPayload(OCSecurityPayload *payload, uint8_t *outPayload,
  55         size_t *size);
  56 static int64_t OCConvertSingleRepPayload(CborEncoder *parent, const OCRepPayload *payload);
  57 static int64_t OCConvertArray(CborEncoder *parent, const OCRepPayloadValueArray *valArray);
  58
  59 static int64_t AddTextStringToMap(CborEncoder *map, const char *key, size_t keylen,
  60         const char *value);
  61 static int64_t ConditionalAddTextStringToMap(CborEncoder *map, const char *key, size_t keylen,
  62         const char *value);
  63
  64 OCStackResult OCConvertPayload(OCPayload* payload, uint8_t** outPayload, size_t* size)
  65 {
  66     // TinyCbor Version 47a78569c0 or better on master is required for the re-allocation
  67     // strategy to work.  If you receive the following assertion error, please do a git-pull
  68     // from the extlibs/tinycbor/tinycbor directory
  69     #define CborNeedsUpdating  (((unsigned int)CborErrorOutOfMemory) < ((unsigned int)CborErrorDataTooLarge))
  70     OC_STATIC_ASSERT(!CborNeedsUpdating, "tinycbor needs to be updated to at least 47a78569c0");
  71     #undef CborNeedsUpdating
  72
  73     OCStackResult ret = OC_STACK_INVALID_PARAM;
  74     int64_t err;
  75     uint8_t *out = NULL;
  76     size_t curSize = INIT_SIZE;
  77
  78     VERIFY_PARAM_NON_NULL(TAG, payload, "Input param, payload is NULL");
  79     VERIFY_PARAM_NON_NULL(TAG, outPayload, "OutPayload parameter is NULL");
  80     VERIFY_PARAM_NON_NULL(TAG, size, "size parameter is NULL");
  81
  82     OIC_LOG_V(INFO, TAG, "Converting payload of type %d", payload->type);
  83     if (PAYLOAD_TYPE_SECURITY == payload->type)
  84     {
  85         size_t securityPayloadSize = ((OCSecurityPayload *)payload)->payloadSize;
  86         if (securityPayloadSize > 0)
  87         {
  88             out = (uint8_t *)OICCalloc(1, ((OCSecurityPayload *)payload)->payloadSize);
  89             VERIFY_PARAM_NON_NULL(TAG, out, "Failed to allocate security payload");
  90         }
  91     }
  92     if (out == NULL)
  93     {
  94         out = (uint8_t *)OICCalloc(1, curSize);
  95         VERIFY_PARAM_NON_NULL(TAG, out, "Failed to allocate payload");
  96     }
  97     err = OCConvertPayloadHelper(payload, out, &curSize);
  98     ret = OC_STACK_NO_MEMORY;
  99
 100     if (err == CborErrorOutOfMemory)
 101     {
 102         // reallocate "out" and try again!
 103         uint8_t *out2 = (uint8_t *)OICRealloc(out, curSize);
 104         VERIFY_PARAM_NON_NULL(TAG, out2, "Failed to increase payload size");
 105         memset(out2, 0, curSize);
 106         out = out2;
 107         err = OCConvertPayloadHelper(payload, out, &curSize);
 108         while (err == CborErrorOutOfMemory)
 109         {
 110             uint8_t *out2 = (uint8_t *)OICRealloc(out, curSize);
 111             VERIFY_PARAM_NON_NULL(TAG, out2, "Failed to increase payload size");
 112             memset(out2, 0, curSize);
 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_REPRESENTATION:
 149             return OCConvertRepPayload((OCRepPayload*)payload, outPayload, size);
 150 #ifdef WITH_PRESENCE
 151         case PAYLOAD_TYPE_PRESENCE:
 152             return OCConvertPresencePayload((OCPresencePayload*)payload, outPayload, size);
 153 #endif
 154         case PAYLOAD_TYPE_SECURITY:
 155             return OCConvertSecurityPayload((OCSecurityPayload*)payload, outPayload, size);
 156         default:
 157             OIC_LOG_V(INFO,TAG, "ConvertPayload default %d", payload->type);
 158             return CborErrorUnknownType;
 159     }
 160 }
 161
 162 static int64_t checkError(int64_t err, CborEncoder* encoder, uint8_t* outPayload, size_t* size)
 163 {
 164     if (err == CborErrorOutOfMemory)
 165     {
 166         *size += cbor_encoder_get_extra_bytes_needed(encoder);
 167         return err;
 168     }
 169     else if (err != CborNoError)
 170     {
 171         OIC_LOG_V(ERROR, TAG, "Convert Payload failed : %s", cbor_error_string(err));
 172         return err;
 173     }
 174     else
 175     {
 176         *size = cbor_encoder_get_buffer_size(encoder, outPayload);
 177         return err;
 178     }
 179 }
 180
 181 static int64_t OCConvertSecurityPayload(OCSecurityPayload* payload, uint8_t* outPayload,
 182         size_t* size)
 183 {
 184     memcpy(outPayload, payload->securityData, payload->payloadSize);
 185     *size = payload->payloadSize;
 186
 187     return CborNoError;
 188 }
 189
 190 static int64_t OCStringLLJoin(CborEncoder *map, char *type, OCStringLL *val)
 191 {
 192     uint16_t count = 0;
 193     int64_t err = CborNoError;
 194
 195     for (OCStringLL *temp = val; temp; temp = temp->next)
 196     {
 197         ++count;
 198     }
 199     if (count > 0)
 200     {
 201         CborEncoder array;
 202         err |= cbor_encode_text_string(map, type, strlen(type));
 203         err |= cbor_encoder_create_array(map, &array, count);
 204         while (val)
 205         {
 206             err |= cbor_encode_text_string(&array, val->value, strlen(val->value));
 207             val = val->next;
 208         }
 209         err |= cbor_encoder_close_container(map, &array);
 210     }
 211
 212     return err;
 213 }
 214
 215 static int64_t OCConvertDiscoveryPayload(OCDiscoveryPayload *payload, uint8_t *outPayload,
 216                                          size_t *size)
 217 {
 218     CborEncoder encoder;
 219     int64_t err = CborNoError;
 220
 221     cbor_encoder_init(&encoder, outPayload, *size, 0);
 222
 223     /*
 224     The format for the payload is "modelled" as JSON.
 225
 226     [                                                  // rootArray
 227         {                                              // rootMap
 228             "di" : UUID,                               // device ID
 229             "rt": ["oic.wk.res"]
 230             "n":"MyDevice"
 231             "if":"oic.if.ll oic.if.baseline"
 232             "di": "0685B960-736F-46F7-BEC0-9E6CBD61ADC1",
 233             links :[                                   // linksArray contains maps of resources
 234                         {
 235                             href, rt, if, policy       // Resource 1
 236                         },
 237                         {
 238                             href, rt, if, policy       // Resource 2
 239                         },
 240                         .
 241                         .
 242                         .
 243                     ]
 244         }
 245         {                                              // rootMap
 246             ...
 247         }
 248     ]
 249     */
 250
 251     // Open the main root array
 252     CborEncoder rootArray;
 253     err |= cbor_encoder_create_array(&encoder, &rootArray, 1);
 254     VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating discovery root array");
 255
 256     while (payload && payload->resources)
 257     {
 258         // Open the root map in the root array
 259         CborEncoder rootMap;
 260         err |= cbor_encoder_create_map(&rootArray, &rootMap, CborIndefiniteLength);
 261         VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating discovery map");
 262
 263         // Insert Name
 264         err |= ConditionalAddTextStringToMap(&rootMap, OC_RSRVD_DEVICE_NAME,
 265                 sizeof(OC_RSRVD_DEVICE_NAME) - 1, payload->name);
 266         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting name");
 267
 268         // Insert Device ID into the root map
 269         err |= AddTextStringToMap(&rootMap, OC_RSRVD_DEVICE_ID, sizeof(OC_RSRVD_DEVICE_ID) - 1,
 270                 payload->sid);
 271         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting device id");
 272
 273         // Insert Resource Type
 274         err |= OCStringLLJoin(&rootMap, OC_RSRVD_RESOURCE_TYPE, payload->type);
 275         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting RT");
 276
 277         // Insert interfaces
 278         if (payload->iface)
 279         {
 280             err |= OCStringLLJoin(&rootMap, OC_RSRVD_INTERFACE, payload->iface);
 281             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding interface types tag/value");
 282         }
 283
 284         // Insert baseURI if present
 285         err |= ConditionalAddTextStringToMap(&rootMap, OC_RSRVD_BASE_URI,
 286                                              sizeof(OC_RSRVD_BASE_URI) - 1,
 287                                              payload->baseURI);
 288         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting baseURI");
 289
 290         // Insert Links into the root map.
 291         CborEncoder linkArray;
 292         err |= cbor_encode_text_string(&rootMap, OC_RSRVD_LINKS, sizeof(OC_RSRVD_LINKS) - 1);
 293         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting links array tag");
 294         size_t resourceCount =  OCDiscoveryPayloadGetResourceCount(payload);
 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,
 319                                     "Failed adding resourceType tag/value to links map");
 320             }
 321             // Interface Types
 322             if (resource->interfaces)
 323             {
 324                 err |= OCStringLLJoin(&linkMap, OC_RSRVD_INTERFACE, resource->interfaces);
 325                 VERIFY_CBOR_SUCCESS(TAG, err,
 326                                     "Failed adding interfaces tag/value to links map");
 327             }
 328
 329             // Policy
 330             CborEncoder policyMap;
 331             err |= cbor_encode_text_string(&linkMap, OC_RSRVD_POLICY,
 332                                            sizeof(OC_RSRVD_POLICY) - 1);
 333             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding policy tag to links map");
 334             err |= cbor_encoder_create_map(&linkMap, &policyMap, CborIndefiniteLength);
 335             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding policy map to links map");
 336
 337             // Bitmap
 338             err |=  cbor_encode_text_string(&policyMap, OC_RSRVD_BITMAP,
 339                                             sizeof(OC_RSRVD_BITMAP) - 1);
 340             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding bitmap tag to policy map");
 341             err |= cbor_encode_uint(&policyMap, resource->bitmap);
 342             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding bitmap value to policy map");
 343
 344             // Secure
 345             err |= cbor_encode_text_string(&policyMap, OC_RSRVD_SECURE,
 346                                            sizeof(OC_RSRVD_SECURE) - 1);
 347             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure tag to policy map");
 348             err |= cbor_encode_boolean(&policyMap, resource->secure);
 349             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure value to policy map");
 350
 351             if (resource->secure || payload->baseURI)
 352             {
 353                 err |= cbor_encode_text_string(&policyMap, OC_RSRVD_HOSTING_PORT,
 354                                                sizeof(OC_RSRVD_HOSTING_PORT) - 1);
 355                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure port tag");
 356                 err |= cbor_encode_uint(&policyMap, resource->port);
 357                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding secure port value");
 358             }
 359
 360 #ifdef TCP_ADAPTER
 361 #ifdef __WITH_TLS__
 362             // tls
 363             if (resource->secure)
 364             {
 365                 err |= cbor_encode_text_string(&policyMap, OC_RSRVD_TLS_PORT,
 366                                                sizeof(OC_RSRVD_TLS_PORT) - 1);
 367                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding tcp secure port tag");
 368                 err |= cbor_encode_uint(&policyMap, resource->tcpPort);
 369                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding tcp secure port value");
 370             }
 371
 372             // tcp
 373             else
 374 #endif
 375             {
 376                 err |= cbor_encode_text_string(&policyMap, OC_RSRVD_TCP_PORT,
 377                                                sizeof(OC_RSRVD_TCP_PORT) - 1);
 378                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding tcp port tag");
 379                 err |= cbor_encode_uint(&policyMap, resource->tcpPort);
 380                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding tcp port value");
 381             }
 382 #endif
 383
 384             err |= cbor_encoder_close_container(&linkMap, &policyMap);
 385             VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing policy map");
 386
 387             // Finsihed encoding a resource, close the map.
 388             err |= cbor_encoder_close_container(&linkArray, &linkMap);
 389             VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing link map");
 390         }
 391         // Close links array inside the root map.
 392         err |= cbor_encoder_close_container(&rootMap, &linkArray);
 393         VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing link array");
 394         // close root map inside the root array.
 395         err |= cbor_encoder_close_container(&rootArray, &rootMap);
 396         VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root map");
 397
 398         payload = payload->next;
 399     }
 400
 401     // Close the final root array.
 402     err |= cbor_encoder_close_container(&encoder, &rootArray);
 403     VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root array");
 404
 405 exit:
 406     return checkError(err, &encoder, outPayload, size);
 407 }
 408
 409 static int64_t OCConvertArrayItem(CborEncoder *array, const OCRepPayloadValueArray *valArray,
 410         size_t index)
 411 {
 412     int64_t err = CborNoError;
 413     switch (valArray->type)
 414     {
 415         case OCREP_PROP_NULL:
 416             OIC_LOG(ERROR, TAG, "ConvertArray Invalid NULL");
 417             err = CborUnknownError;
 418             break;
 419         case OCREP_PROP_INT:
 420             if (valArray->iArray != 0)
 421             {
 422                 err |= cbor_encode_int(array, valArray->iArray[index]);
 423             }
 424             break;
 425         case OCREP_PROP_DOUBLE:
 426             if (valArray->dArray != 0)
 427             {
 428                 err |= cbor_encode_double(array, valArray->dArray[index]);
 429             }
 430             break;
 431         case OCREP_PROP_BOOL:
 432             if (valArray->bArray != 0)
 433             {
 434                 err |= cbor_encode_boolean(array, valArray->bArray[index]);
 435             }
 436             break;
 437         case OCREP_PROP_STRING:
 438             if (valArray->strArray != 0)
 439             {
 440                 err |= (!valArray->strArray[index]) ? cbor_encode_null(array) : cbor_encode_text_string(array,
 441                     valArray->strArray[index], strlen(valArray->strArray[index]));
 442             }
 443             break;
 444         case OCREP_PROP_BYTE_STRING:
 445             err |= (!valArray->ocByteStrArray[index].len) ? cbor_encode_null(array) : cbor_encode_byte_string(array,
 446                 valArray->ocByteStrArray[index].bytes, valArray->ocByteStrArray[index].len);
 447             break;
 448         case OCREP_PROP_OBJECT:
 449             if (valArray->objArray != 0)
 450             {
 451                 err |= (!valArray->objArray[index]) ? cbor_encode_null(array): OCConvertRepMap(array,
 452                         valArray->objArray[index]);
 453             }
 454             break;
 455         case OCREP_PROP_ARRAY:
 456             OIC_LOG(ERROR, TAG, "ConvertArray Invalid child array");
 457             err = CborUnknownError;
 458             break;
 459     }
 460
 461     return err;
 462 }
 463
 464 static int64_t OCConvertArray(CborEncoder *parent, const OCRepPayloadValueArray *valArray)
 465 {
 466     int64_t err = CborNoError;
 467     CborEncoder array;
 468     err |= cbor_encoder_create_array(parent, &array, valArray->dimensions[0]);
 469     VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep array");
 470     // empty array
 471     if (valArray->dimensions[0] == 0)
 472     {
 473         err |= OCConvertArrayItem(&array, valArray, 0);
 474         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep array value");
 475     }
 476     else
 477     {
 478         for (size_t i = 0; i < valArray->dimensions[0]; ++i)
 479         {
 480             if (0 != valArray->dimensions[1])
 481             {
 482                 CborEncoder array2;
 483                 err |= cbor_encoder_create_array(&array, &array2, valArray->dimensions[1]);
 484                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep array2");
 485
 486                 for (size_t j = 0; j < valArray->dimensions[1]; ++j)
 487                 {
 488                     if (0 != valArray->dimensions[2])
 489                     {
 490                         CborEncoder array3;
 491                         err |= cbor_encoder_create_array(&array2, &array3, valArray->dimensions[2]);
 492                         VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep array3");
 493
 494                         for(size_t k = 0; k < valArray->dimensions[2]; ++k)
 495                         {
 496                             err |= OCConvertArrayItem(&array3, valArray,
 497                                 j * valArray->dimensions[2] +
 498                                 i * valArray->dimensions[2] * valArray->dimensions[1] +
 499                                 k);
 500                             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep array3 value");
 501                         }
 502                         err |= cbor_encoder_close_container(&array2, &array3);
 503                         VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep array3");
 504                     }
 505                     else
 506                     {
 507                         err |= OCConvertArrayItem(&array2, valArray, i * valArray->dimensions[1] + j);
 508                         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep array2 value");
 509                     }
 510                 }
 511                 err |= cbor_encoder_close_container(&array, &array2);
 512                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep array2");
 513             }
 514             else
 515             {
 516                 err |= OCConvertArrayItem(&array, valArray, i);
 517                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep array value");
 518             }
 519         }
 520     }
 521     err |= cbor_encoder_close_container(parent, &array);
 522     VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep array");
 523
 524 exit:
 525     return err;
 526 }
 527
 528 static int64_t OCConvertRepMap(CborEncoder *map, const OCRepPayload *payload)
 529 {
 530     int64_t err = CborNoError;
 531     CborEncoder repMap;
 532     err |= cbor_encoder_create_map(map, &repMap, CborIndefiniteLength);
 533     VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating rep map");
 534     err |= OCConvertSingleRepPayload(&repMap, payload);
 535     VERIFY_CBOR_SUCCESS(TAG, err, "Failed converting single rep payload");
 536     err |= cbor_encoder_close_container(map, &repMap);
 537     VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing rep map");
 538 exit:
 539     return err;
 540 }
 541
 542 static int64_t OCConvertSingleRepPayload(CborEncoder *repMap, const OCRepPayload *payload)
 543 {
 544     int64_t err = CborNoError;
 545     OCRepPayloadValue *value = payload->values;
 546     while (value)
 547     {
 548         err |= cbor_encode_text_string(repMap, value->name, strlen(value->name));
 549         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding tag name");
 550
 551         switch (value->type)
 552         {
 553             case OCREP_PROP_NULL:
 554                 err |= cbor_encode_null(repMap);
 555                 break;
 556             case OCREP_PROP_INT:
 557                 err |= cbor_encode_int(repMap, value->i);
 558                 break;
 559             case OCREP_PROP_DOUBLE:
 560                 err |= cbor_encode_double(repMap, value->d);
 561                 break;
 562             case OCREP_PROP_BOOL:
 563                 err |= cbor_encode_boolean(repMap, value->b);
 564                 break;
 565             case OCREP_PROP_STRING:
 566                 err |= cbor_encode_text_string(repMap, value->str, strlen(value->str));
 567                 break;
 568             case OCREP_PROP_BYTE_STRING:
 569                 err |= cbor_encode_byte_string(repMap, value->ocByteStr.bytes, value->ocByteStr.len);
 570                 break;
 571             case OCREP_PROP_OBJECT:
 572                 err |= OCConvertRepMap(repMap, value->obj);
 573                 break;
 574             case OCREP_PROP_ARRAY:
 575                 err |= OCConvertArray(repMap, &value->arr);
 576                 break;
 577             default:
 578                 OIC_LOG_V(ERROR, TAG, "Invalid Prop type: %d", value->type);
 579                 break;
 580         }
 581         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding single rep value");
 582         value = value->next;
 583     }
 584
 585 exit:
 586     return err;
 587 }
 588
 589 static int64_t OCConvertRepPayload(OCRepPayload *payload, uint8_t *outPayload, size_t *size)
 590 {
 591     CborEncoder encoder;
 592     int64_t err = CborNoError;
 593
 594     cbor_encoder_init(&encoder, outPayload, *size, 0);
 595
 596     size_t arrayCount = 0;
 597     for (OCRepPayload *temp = payload; temp; temp = temp->next)
 598     {
 599         arrayCount++;
 600     }
 601     CborEncoder rootArray;
 602     if (arrayCount > 1)
 603     {
 604         err |= cbor_encoder_create_array(&encoder, &rootArray, arrayCount);
 605         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep root map");
 606     }
 607
 608     while (payload != NULL && (err == CborNoError))
 609     {
 610         CborEncoder rootMap;
 611         err |= cbor_encoder_create_map(((arrayCount == 1)? &encoder: &rootArray),
 612                                             &rootMap, CborIndefiniteLength);
 613         VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating root map");
 614
 615         // Only in case of collection href is included.
 616         if (arrayCount > 1 && payload->uri && strlen(payload->uri) > 0)
 617         {
 618             OIC_LOG(INFO, TAG, "Payload has uri");
 619             err |= cbor_encode_text_string(&rootMap, OC_RSRVD_HREF, strlen(OC_RSRVD_HREF));
 620             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep href tag");
 621             err |= cbor_encode_text_string(&rootMap, payload->uri, strlen(payload->uri));
 622             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding rep href value");
 623         }
 624         if (payload->types)
 625         {
 626             OIC_LOG(INFO, TAG, "Payload has types");
 627             err |= OCStringLLJoin(&rootMap, OC_RSRVD_RESOURCE_TYPE, payload->types);
 628             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding resource type.");
 629         }
 630         if (payload->interfaces)
 631         {
 632             OIC_LOG(INFO, TAG, "Payload has interfaces");
 633             err |= OCStringLLJoin(&rootMap, OC_RSRVD_INTERFACE, payload->interfaces);
 634             VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding platform interface type.");
 635         }
 636
 637         err |= OCConvertSingleRepPayload(&rootMap, payload);
 638         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting rep payload");
 639
 640         // Close main array
 641         err |= cbor_encoder_close_container(((arrayCount == 1) ? &encoder: &rootArray),
 642                 &rootMap);
 643         VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root map");
 644         payload = payload->next;
 645     }
 646     if (arrayCount > 1)
 647     {
 648         err |= cbor_encoder_close_container(&encoder, &rootArray);
 649         VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing root array");
 650     }
 651
 652 exit:
 653     return checkError(err, &encoder, outPayload, size);
 654 }
 655
 656 #ifdef WITH_PRESENCE
 657 static int64_t OCConvertPresencePayload(OCPresencePayload *payload, uint8_t *outPayload,
 658         size_t *size)
 659 {
 660     int64_t err = CborNoError;
 661     CborEncoder encoder;
 662
 663     cbor_encoder_init(&encoder, outPayload, *size, 0);
 664     CborEncoder map;
 665     err |= cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength);
 666     VERIFY_CBOR_SUCCESS(TAG, err, "Failed creating presence map");
 667
 668     // Sequence Number
 669     err |= cbor_encode_text_string(&map, OC_RSRVD_NONCE, sizeof(OC_RSRVD_NONCE) - 1);
 670     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding nonce tag to presence map");
 671     err |= cbor_encode_uint(&map, payload->sequenceNumber);
 672     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding nonce value to presence map");
 673
 674     // Max Age
 675     err |= cbor_encode_text_string(&map, OC_RSRVD_TTL, sizeof(OC_RSRVD_TTL) - 1);
 676     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding ttl tag to presence map");
 677     err |= cbor_encode_uint(&map, payload->maxAge);
 678     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding ttl value to presence map");
 679
 680     // Trigger
 681     err |= cbor_encode_text_string(&map, OC_RSRVD_TRIGGER, sizeof(OC_RSRVD_TRIGGER) - 1);
 682     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding trigger tag to presence map");
 683     err |= cbor_encode_simple_value(&map, payload->trigger);
 684     VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding trigger value to presence map");
 685
 686     // Resource type name
 687     if (payload->trigger != OC_PRESENCE_TRIGGER_DELETE)
 688     {
 689         err |= ConditionalAddTextStringToMap(&map, OC_RSRVD_RESOURCE_TYPE,
 690                 sizeof(OC_RSRVD_RESOURCE_TYPE) - 1, payload->resourceType);
 691         VERIFY_CBOR_SUCCESS(TAG, err, "Failed adding resource type to presence map");
 692     }
 693
 694     // Close Map
 695     err |= cbor_encoder_close_container(&encoder, &map);
 696     VERIFY_CBOR_SUCCESS(TAG, err, "Failed closing presence map");
 697
 698 exit:
 699     return checkError(err, &encoder, outPayload, size);
 700 }
 701 #endif // WITH_PRESENCE
 702
 703 static int64_t AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
 704         const char* value)
 705 {
 706     int64_t err = cbor_encode_text_string(map, key, keylen);
 707     if (CborNoError != err)
 708     {
 709         return err;
 710     }
 711     return cbor_encode_text_string(map, value, strlen(value));
 712 }
 713
 714 static int64_t ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
 715         const char* value)
 716 {
 717     return value ? AddTextStringToMap(map, key, keylen, value) : 0;
 718 }