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