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 "logger.h"
  26 #include "ocpayload.h"
  27 #include "ocrandom.h"
  28 #include "ocresourcehandler.h"
  29 #include "cbor.h"
  30
  31 #define TAG "OCPayloadConvert"
  32 // Arbitrarily chosen size that seems to contain the majority of packages
  33 #define INIT_SIZE (255)
  34
  35 // Functions all return either a CborError, or a negative version of the OC_STACK return values
  36 static int64_t OCConvertPayloadHelper(OCPayload* payload, uint8_t* outPayload, size_t* size);
  37 static int64_t OCConvertDiscoveryPayload(OCDiscoveryPayload* payload, uint8_t* outPayload,
  38         size_t* size);
  39 static int64_t OCConvertDevicePayload(OCDevicePayload* payload, uint8_t* outPayload,
  40         size_t* size);
  41 static int64_t OCConvertPlatformPayload(OCPlatformPayload* payload, uint8_t* outPayload,
  42         size_t* size);
  43 static int64_t OCConvertRepPayload(OCRepPayload* payload, uint8_t* outPayload, size_t* size);
  44 static int64_t OCConvertPresencePayload(OCPresencePayload* payload, uint8_t* outPayload,
  45         size_t* size);
  46 static int64_t OCConvertSecurityPayload(OCSecurityPayload* payload, uint8_t* outPayload,
  47         size_t* size);
  48 static int64_t OCConvertSingleRepPayload(CborEncoder* parent, const OCRepPayload* payload);
  49 static int64_t OCConvertArray(CborEncoder* parent, const OCRepPayloadValueArray* valArray);
  50
  51 static int64_t AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
  52         const char* value);
  53
  54 static int64_t ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
  55         const char* value);
  56
  57 OCStackResult OCConvertPayload(OCPayload* payload, uint8_t** outPayload, size_t* size)
  58 {
  59     // TinyCbor Version 47a78569c0 or better on master is required for the re-allocation
  60     // strategy to work.  If you receive the following assertion error, please do a git-pull
  61     // from the extlibs/tinycbor/tinycbor directory
  62     #define CborNeedsUpdating  (CborErrorOutOfMemory < CborErrorDataTooLarge)
  63     OC_STATIC_ASSERT(!CborNeedsUpdating, "tinycbor needs to be updated to at least 47a78569c0");
  64     #undef CborNeedsUpdating
  65     if (!payload)
  66     {
  67         OC_LOG(ERROR, TAG, "Payload parameter NULL");
  68         return OC_STACK_INVALID_PARAM;
  69     }
  70
  71     if (!outPayload || !size)
  72     {
  73         OC_LOG(ERROR, TAG, "Out parameter/s parameter NULL");
  74         return OC_STACK_INVALID_PARAM;
  75     }
  76
  77     OC_LOG_V(INFO, TAG, "Converting payload of type %d", payload->type);
  78
  79     size_t curSize = INIT_SIZE;
  80     uint8_t* out = (uint8_t*)OICCalloc(1, curSize);
  81     int64_t err = OCConvertPayloadHelper(payload, out, &curSize);
  82
  83     if (err == CborErrorOutOfMemory)
  84     {
  85         // reallocate "out" and try again!
  86         uint8_t* out2 = (uint8_t*)OICRealloc(out, curSize);
  87
  88         if (!out2)
  89         {
  90             OICFree(out);
  91             return OC_STACK_NO_MEMORY;
  92         }
  93
  94         out = out2;
  95         err = OCConvertPayloadHelper(payload, out, &curSize);
  96     }
  97
  98     if (err == 0)
  99     {
 100         if (curSize < INIT_SIZE)
 101         {
 102             uint8_t* out2 = (uint8_t*)OICRealloc(out, curSize);
 103
 104             if (!out2)
 105             {
 106                 OICFree(out);
 107                 return OC_STACK_NO_MEMORY;
 108             }
 109
 110             out = out2;
 111         }
 112
 113         *size = curSize;
 114         *outPayload = out;
 115         return OC_STACK_OK;
 116     }
 117     else if (err < 0)
 118     {
 119         return (OCStackResult)-err;
 120     }
 121     else
 122     {
 123         return OC_STACK_ERROR;
 124     }
 125 }
 126
 127 static int64_t OCConvertPayloadHelper(OCPayload* payload, uint8_t* outPayload, size_t* size)
 128 {
 129     switch(payload->type)
 130     {
 131         case PAYLOAD_TYPE_DISCOVERY:
 132             return OCConvertDiscoveryPayload((OCDiscoveryPayload*)payload, outPayload, size);
 133         case PAYLOAD_TYPE_DEVICE:
 134             return OCConvertDevicePayload((OCDevicePayload*)payload, outPayload, size);
 135         case PAYLOAD_TYPE_PLATFORM:
 136             return OCConvertPlatformPayload((OCPlatformPayload*)payload, outPayload, size);
 137         case PAYLOAD_TYPE_REPRESENTATION:
 138             return OCConvertRepPayload((OCRepPayload*)payload, outPayload, size);
 139         case PAYLOAD_TYPE_PRESENCE:
 140             return OCConvertPresencePayload((OCPresencePayload*)payload, outPayload, size);
 141         case PAYLOAD_TYPE_SECURITY:
 142             return OCConvertSecurityPayload((OCSecurityPayload*)payload, outPayload, size);
 143         default:
 144             OC_LOG_V(INFO,TAG, "ConvertPayload default %d", payload->type);
 145             return OC_STACK_NOTIMPL;
 146     }
 147 }
 148
 149 static int64_t checkError(int64_t err, CborEncoder* encoder, uint8_t* outPayload, size_t* size)
 150 {
 151     if (err == CborErrorOutOfMemory)
 152     {
 153         *size += encoder->ptr - encoder->end;
 154         return err;
 155     }
 156     else if (err != 0)
 157     {
 158         OC_LOG_V(ERROR, TAG, "Convert Payload failed", err);
 159         return err;
 160     }
 161     else
 162     {
 163         *size = encoder->ptr - outPayload;
 164         return 0;
 165     }
 166 }
 167 static int64_t OCConvertSecurityPayload(OCSecurityPayload* payload, uint8_t* outPayload,
 168         size_t* size)
 169 {
 170     CborEncoder encoder;
 171     int64_t err = 0;
 172
 173     cbor_encoder_init(&encoder, outPayload, *size, 0);
 174
 175     CborEncoder rootArray;
 176     err = err | cbor_encoder_create_array(&encoder, &rootArray, 1);
 177     CborEncoder map;
 178
 179     err = err | cbor_encoder_create_map(&rootArray, &map, CborIndefiniteLength);
 180
 181     if(payload->securityData)
 182     {
 183         err = err | AddTextStringToMap(&map, OC_RSRVD_REPRESENTATION,
 184                 sizeof(OC_RSRVD_REPRESENTATION) - 1,
 185                 payload->securityData);
 186     }
 187
 188     err = err | cbor_encoder_close_container(&rootArray, &map);
 189
 190     err = err | cbor_encoder_close_container(&encoder, &rootArray);
 191     return checkError(err, &encoder, outPayload, size);
 192
 193 }
 194
 195 static int64_t OCConvertDiscoveryPayload(OCDiscoveryPayload* payload, uint8_t* outPayload,
 196         size_t* size)
 197 {
 198     CborEncoder encoder = {0};
 199     int64_t err = 0;
 200     size_t resourceCount =  OCDiscoveryPayloadGetResourceCount(payload);
 201
 202     cbor_encoder_init(&encoder, outPayload, *size, 0);
 203
 204     CborEncoder rootArray;
 205     err = err | cbor_encoder_create_array(&encoder, &rootArray, resourceCount);
 206
 207     for(size_t i = 0; i < resourceCount; ++i)
 208     {
 209         CborEncoder map;
 210         OCResourcePayload* resource = OCDiscoveryPayloadGetResource(payload, i);
 211
 212         if(!resource)
 213         {
 214             return OC_STACK_INVALID_PARAM;
 215         }
 216
 217         err = err | cbor_encoder_create_map(&rootArray, &map, 3);
 218         // Uri
 219         err = err | AddTextStringToMap(&map, OC_RSRVD_HREF,
 220                 sizeof(OC_RSRVD_HREF) - 1,
 221                 resource->uri);
 222
 223         // Server ID
 224         err = err | cbor_encode_text_string(&map, OC_RSRVD_SERVER_INSTANCE_ID,
 225                 sizeof(OC_RSRVD_SERVER_INSTANCE_ID) - 1);
 226         err = err | cbor_encode_byte_string(&map, resource->sid, UUID_SIZE);
 227         // Prop Tag
 228         {
 229             CborEncoder propMap;
 230             err = err | cbor_encode_text_string(&map, OC_RSRVD_PROPERTY,
 231                     sizeof(OC_RSRVD_PROPERTY) -1 );
 232             err = err | cbor_encoder_create_map(&map, &propMap, 3);
 233
 234             // Resource Type
 235             {
 236                 CborEncoder rtArray;
 237                 err = err | cbor_encode_text_string(&propMap, OC_RSRVD_RESOURCE_TYPE,
 238                     sizeof(OC_RSRVD_RESOURCE_TYPE) - 1);
 239                 err = err | cbor_encoder_create_array(&propMap, &rtArray, CborIndefiniteLength);
 240
 241                 OCStringLL* rtPtr = resource->types;
 242                 while(rtPtr)
 243                 {
 244                     err = err | cbor_encode_text_string(&rtArray, rtPtr->value,
 245                             strlen(rtPtr->value));
 246                     rtPtr = rtPtr->next;
 247                 }
 248
 249                 err = err | cbor_encoder_close_container(&propMap, &rtArray);
 250             }
 251
 252             // Interface Types
 253             {
 254                 CborEncoder ifArray;
 255                 err = err | cbor_encode_text_string(&propMap, OC_RSRVD_INTERFACE,
 256                         sizeof(OC_RSRVD_INTERFACE) - 1);
 257                 err = err | cbor_encoder_create_array(&propMap, &ifArray, CborIndefiniteLength);
 258                 OCStringLL* ifPtr = resource->interfaces;
 259
 260                 while(ifPtr)
 261                 {
 262                     err = err | cbor_encode_text_string(&ifArray, ifPtr->value,
 263                         strlen(ifPtr->value));
 264                     ifPtr= ifPtr->next;
 265                 }
 266
 267                 err = err | cbor_encoder_close_container(&propMap, &ifArray);
 268             }
 269             // Policy
 270             {
 271                 CborEncoder policyMap;
 272                 err = err | cbor_encode_text_string(&propMap, OC_RSRVD_POLICY,
 273                         sizeof(OC_RSRVD_POLICY) - 1);
 274                 err = err | cbor_encoder_create_map(&propMap, &policyMap, CborIndefiniteLength);
 275
 276                 // Bitmap
 277                 err = err | cbor_encode_text_string(&policyMap, OC_RSRVD_BITMAP,
 278                         sizeof(OC_RSRVD_BITMAP) - 1);
 279                 err = err | cbor_encode_uint(&policyMap, resource->bitmap);
 280
 281                 if(resource->secure)
 282                 {
 283                     err = err | cbor_encode_text_string(&policyMap, OC_RSRVD_SECURE,
 284                             sizeof(OC_RSRVD_SECURE) - 1);
 285                     err = err | cbor_encode_boolean(&policyMap, OC_RESOURCE_SECURE);
 286
 287                     if(resource->port != 0)
 288                     {
 289                         err = err | cbor_encode_text_string(&policyMap, OC_RSRVD_HOSTING_PORT,
 290                                 sizeof(OC_RSRVD_HOSTING_PORT) - 1);
 291                         err = err | cbor_encode_uint(&policyMap, resource->port);
 292                     }
 293                 }
 294
 295                 err = err | cbor_encoder_close_container(&propMap, &policyMap);
 296             }
 297             // Close
 298             err = err | cbor_encoder_close_container(&map, &propMap);
 299         }
 300         // Close Item
 301         err = err | cbor_encoder_close_container(&rootArray, &map);
 302     }
 303     // Close main array
 304     err = err | cbor_encoder_close_container(&encoder, &rootArray);
 305
 306     return checkError(err, &encoder, outPayload, size);
 307 }
 308
 309 static int64_t OCConvertDevicePayload(OCDevicePayload* payload, uint8_t* outPayload,
 310         size_t* size)
 311 {
 312     CborEncoder encoder = {0};
 313     int64_t err = 0;
 314
 315     cbor_encoder_init(&encoder, outPayload, *size, 0);
 316     CborEncoder rootArray;
 317     err = err | cbor_encoder_create_array(&encoder, &rootArray, 1);
 318
 319     {
 320         CborEncoder map;
 321         err = err | cbor_encoder_create_map(&rootArray, &map, 2);
 322
 323         // uri
 324         err = err | AddTextStringToMap(&map, OC_RSRVD_HREF, sizeof(OC_RSRVD_HREF) - 1,
 325                 payload->uri);
 326
 327         // Rep Map
 328         {
 329             CborEncoder repMap;
 330             err = err | cbor_encode_text_string(&map, OC_RSRVD_REPRESENTATION,
 331                     sizeof(OC_RSRVD_REPRESENTATION) - 1);
 332             err = err | cbor_encoder_create_map(&map, &repMap, 4);
 333
 334             // Device ID
 335             err = err | cbor_encode_text_string(&repMap, OC_RSRVD_DEVICE_ID,
 336                     sizeof(OC_RSRVD_DEVICE_ID) - 1);
 337             err = err | cbor_encode_byte_string(&repMap, payload->sid, UUID_SIZE);
 338
 339             // Device Name
 340             err = err | AddTextStringToMap(&repMap, OC_RSRVD_DEVICE_NAME,
 341                     sizeof(OC_RSRVD_DEVICE_NAME) - 1,
 342                     payload->deviceName);
 343
 344             // Device Spec Version
 345             err = err | AddTextStringToMap(&repMap, OC_RSRVD_SPEC_VERSION,
 346                     sizeof(OC_RSRVD_SPEC_VERSION) - 1,
 347                     payload->specVersion);
 348
 349             // Device data Model Version
 350             err = err | AddTextStringToMap(&repMap, OC_RSRVD_DATA_MODEL_VERSION,
 351                     sizeof(OC_RSRVD_DATA_MODEL_VERSION) - 1,
 352                     payload->dataModelVersion);
 353
 354             err = err | cbor_encoder_close_container(&map, &repMap);
 355         }
 356
 357         // Close Map
 358         err = err | cbor_encoder_close_container(&rootArray, &map);
 359     }
 360
 361     // Close main array
 362     err = err | cbor_encoder_close_container(&encoder, &rootArray);
 363
 364     return checkError(err, &encoder, outPayload, size);
 365 }
 366
 367 static int64_t OCConvertPlatformPayload(OCPlatformPayload* payload, uint8_t* outPayload,
 368         size_t* size)
 369 {
 370     CborEncoder encoder = {0};
 371     int64_t err = 0;
 372
 373     cbor_encoder_init(&encoder, outPayload, *size, 0);
 374     CborEncoder rootArray;
 375     err = err | cbor_encoder_create_array(&encoder, &rootArray, 1);
 376     {
 377         CborEncoder map;
 378         err = err | cbor_encoder_create_map(&rootArray, &map, CborIndefiniteLength);
 379
 380         // uri
 381         err = err | AddTextStringToMap(&map, OC_RSRVD_HREF, sizeof(OC_RSRVD_HREF) - 1,
 382                 payload->uri);
 383
 384         // Rep Map
 385         {
 386             CborEncoder repMap;
 387             err = err | cbor_encode_text_string(&map, OC_RSRVD_REPRESENTATION,
 388                     sizeof(OC_RSRVD_REPRESENTATION) - 1);
 389             err = err | cbor_encoder_create_map(&map, &repMap, CborIndefiniteLength);
 390
 391             // Platform ID
 392             err = err | AddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_ID,
 393                     sizeof(OC_RSRVD_PLATFORM_ID) - 1,
 394                     payload->info.platformID);
 395
 396             // MFG Name
 397             err = err | AddTextStringToMap(&repMap, OC_RSRVD_MFG_NAME,
 398                     sizeof(OC_RSRVD_MFG_NAME) - 1,
 399                     payload->info.manufacturerName);
 400
 401             // MFG Url
 402             err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_URL,
 403                     sizeof(OC_RSRVD_MFG_URL) - 1,
 404                     payload->info.manufacturerUrl);
 405
 406             // Model Num
 407             err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MODEL_NUM,
 408                     sizeof(OC_RSRVD_MODEL_NUM) - 1,
 409                     payload->info.modelNumber);
 410
 411             // Date of Mfg
 412             err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_DATE,
 413                     sizeof(OC_RSRVD_MFG_DATE) - 1,
 414                     payload->info.dateOfManufacture);
 415
 416             // Platform Version
 417             err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_VERSION,
 418                     sizeof(OC_RSRVD_PLATFORM_VERSION) - 1,
 419                     payload->info.platformVersion);
 420
 421             // OS Version
 422             err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_OS_VERSION,
 423                     sizeof(OC_RSRVD_OS_VERSION) - 1,
 424                     payload->info.operatingSystemVersion);
 425
 426             // Hardware Version
 427             err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_HARDWARE_VERSION,
 428                     sizeof(OC_RSRVD_HARDWARE_VERSION) - 1,
 429                     payload->info.hardwareVersion);
 430
 431             // Firmware Version
 432             err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_FIRMWARE_VERSION,
 433                     sizeof(OC_RSRVD_FIRMWARE_VERSION) - 1,
 434                     payload->info.firmwareVersion);
 435
 436             // Support URL
 437             err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SUPPORT_URL,
 438                     sizeof(OC_RSRVD_SUPPORT_URL) - 1,
 439                     payload->info.supportUrl);
 440
 441             // System Time
 442             err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SYSTEM_TIME,
 443                     sizeof(OC_RSRVD_SYSTEM_TIME) - 1,
 444                     payload->info.systemTime);
 445             err = err | cbor_encoder_close_container(&map, &repMap);
 446         }
 447
 448         // Close Map
 449         err = err | cbor_encoder_close_container(&rootArray, &map);
 450     }
 451
 452     // Close main array
 453     err = err | cbor_encoder_close_container(&encoder, &rootArray);
 454
 455     return checkError(err, &encoder, outPayload, size);
 456 }
 457
 458 static int64_t OCConvertArrayItem(CborEncoder* array, const OCRepPayloadValueArray* valArray,
 459         size_t index)
 460 {
 461     int64_t err = 0;
 462     switch (valArray->type)
 463     {
 464         case OCREP_PROP_NULL:
 465             OC_LOG(ERROR, TAG, "ConvertArray Invalid NULL");
 466             err = CborUnknownError;
 467             break;
 468         case OCREP_PROP_INT:
 469             err = err | cbor_encode_int(array, valArray->iArray[index]);
 470             break;
 471         case OCREP_PROP_DOUBLE:
 472             err = err | cbor_encode_double(array, valArray->dArray[index]);
 473             break;
 474         case OCREP_PROP_BOOL:
 475             err = err | cbor_encode_boolean(array, valArray->bArray[index]);
 476             break;
 477         case OCREP_PROP_STRING:
 478             if (!valArray->strArray[index])
 479             {
 480                 err = err | cbor_encode_null(array);
 481             }
 482             else
 483             {
 484                 err = err | cbor_encode_text_string(array, valArray->strArray[index],
 485                         strlen(valArray->strArray[index]));
 486             }
 487             break;
 488         case OCREP_PROP_OBJECT:
 489             if (!valArray->objArray[index])
 490             {
 491                 err = err | cbor_encode_null(array);
 492             }
 493             else
 494             {
 495                 err = OCConvertSingleRepPayload(array, valArray->objArray[index]);
 496             }
 497             break;
 498         case OCREP_PROP_ARRAY:
 499             OC_LOG(ERROR, TAG, "ConvertArray Invalid child array");
 500             err = CborUnknownError;
 501             break;
 502     }
 503
 504     return err;
 505 }
 506 static int64_t OCConvertArray(CborEncoder* parent, const OCRepPayloadValueArray* valArray)
 507 {
 508     CborEncoder array;
 509     int64_t err = 0;
 510
 511     err = err | cbor_encoder_create_array(parent, &array, valArray->dimensions[0]);
 512
 513     for (size_t i = 0; i < valArray->dimensions[0];++i)
 514     {
 515         if (valArray->dimensions[1] != 0)
 516         {
 517             CborEncoder array2;
 518             err = err | cbor_encoder_create_array(&array, &array2, valArray->dimensions[1]);
 519
 520             for (size_t j = 0; j < valArray->dimensions[1]; ++j)
 521             {
 522                 if (valArray->dimensions[2] != 0)
 523                 {
 524                     CborEncoder array3;
 525                     err = err | cbor_encoder_create_array(&array2, &array3,
 526                             valArray->dimensions[2]);
 527
 528                     for(size_t k = 0; k < valArray->dimensions[2]; ++k)
 529                     {
 530                         OCConvertArrayItem(&array3, valArray,
 531                             j * valArray->dimensions[2] +
 532                             i * valArray->dimensions[2] * valArray->dimensions[1] +
 533                             k);
 534                     }
 535                     err = err | cbor_encoder_close_container(&array2, &array3);
 536                 }
 537                 else
 538                 {
 539                     OCConvertArrayItem(&array2, valArray,
 540                             i * valArray->dimensions[1] + j);
 541                 }
 542             }
 543             err = err | cbor_encoder_close_container(&array, &array2);
 544         }
 545         else
 546         {
 547             OCConvertArrayItem(&array, valArray, i);
 548         }
 549     }
 550     err = err | cbor_encoder_close_container(parent, &array);
 551     return err;
 552 }
 553
 554 static int64_t OCConvertSingleRepPayload(CborEncoder* parent, const OCRepPayload* payload)
 555 {
 556     int64_t err = 0;
 557     CborEncoder map;
 558     err = err | cbor_encoder_create_map(parent, &map, CborIndefiniteLength);
 559
 560     // Uri
 561     err = err | ConditionalAddTextStringToMap(&map, OC_RSRVD_HREF,
 562             sizeof(OC_RSRVD_HREF) - 1,
 563             payload->uri);
 564
 565     // Prop Map
 566     // resource types, interfaces
 567     if(payload->types || payload->interfaces)
 568     {
 569         OC_LOG(INFO, TAG, "Payload has types or interfaces");
 570         err = err | cbor_encode_text_string(&map,
 571                 OC_RSRVD_PROPERTY,
 572                 sizeof(OC_RSRVD_PROPERTY) - 1);
 573         CborEncoder propMap;
 574         err = err | cbor_encoder_create_map(&map, &propMap, 2);
 575
 576         CborEncoder curArray;
 577         if(payload->types)
 578         {
 579             err = err | cbor_encode_text_string(&propMap,
 580                     OC_RSRVD_RESOURCE_TYPE,
 581                     sizeof(OC_RSRVD_RESOURCE_TYPE) - 1);
 582             err = err | cbor_encoder_create_array(&propMap, &curArray, CborIndefiniteLength);
 583             OCStringLL* val = payload->types;
 584             while(val)
 585             {
 586                 err = err | cbor_encode_text_string(&curArray, val->value, strlen(val->value));
 587                 val = val->next;
 588             }
 589             err = err | cbor_encoder_close_container(&propMap, &curArray);
 590         }
 591         if(payload->interfaces)
 592         {
 593             err = err | cbor_encode_text_string(&propMap,
 594                     OC_RSRVD_INTERFACE,
 595                     sizeof(OC_RSRVD_INTERFACE) - 1);
 596             err = err | cbor_encoder_create_array(&propMap, &curArray, CborIndefiniteLength);
 597             OCStringLL* val = payload->interfaces;
 598             while(val)
 599             {
 600                 err = err | cbor_encode_text_string(&curArray, val->value, strlen(val->value));
 601                 val = val->next;
 602             }
 603             err = err | cbor_encoder_close_container(&propMap, &curArray);
 604         }
 605         err = err | cbor_encoder_close_container(&map, &propMap);
 606     }
 607
 608     // Rep Map
 609     {
 610         CborEncoder repMap;
 611         err = err | cbor_encode_text_string(&map,
 612                 OC_RSRVD_REPRESENTATION,
 613                 sizeof(OC_RSRVD_REPRESENTATION) - 1);
 614         err = err | cbor_encoder_create_map(&map, &repMap, CborIndefiniteLength);
 615         OCRepPayloadValue* value = payload->values;
 616         while(value)
 617         {
 618             err = err | cbor_encode_text_string(&repMap,
 619                     value->name,
 620                     strlen(value->name));
 621             switch(value->type)
 622             {
 623                 case OCREP_PROP_NULL:
 624                     err = err | cbor_encode_null(&repMap);
 625                     break;
 626                 case OCREP_PROP_INT:
 627                     err = err | cbor_encode_int(&repMap,
 628                             value->i);
 629                     break;
 630                 case OCREP_PROP_DOUBLE:
 631                     err = err | cbor_encode_double(&repMap,
 632                             value->d);
 633                     break;
 634                 case OCREP_PROP_BOOL:
 635                     err = err | cbor_encode_boolean(&repMap,
 636                             value->b);
 637                     break;
 638                 case OCREP_PROP_STRING:
 639                     err = err | cbor_encode_text_string(&repMap,
 640                             value->str, strlen(value->str));
 641                     break;
 642                 case OCREP_PROP_OBJECT:
 643                     err = err | OCConvertSingleRepPayload(&repMap, value->obj);
 644                     break;
 645                 case OCREP_PROP_ARRAY:
 646                     err = err | OCConvertArray(&repMap, &value->arr);
 647                     break;
 648                 default:
 649                     OC_LOG_V(ERROR, TAG, "Invalid Prop type: %d",
 650                             value->type);
 651                     break;
 652             }
 653             value = value->next;
 654         }
 655
 656         err = err | cbor_encoder_close_container(&map, &repMap);
 657     }
 658
 659     // Close Map
 660     err = err | cbor_encoder_close_container(parent, &map);
 661
 662     return err;
 663 }
 664
 665 static int64_t OCConvertRepPayload(OCRepPayload* payload, uint8_t* outPayload, size_t* size)
 666 {
 667     CborEncoder encoder = {0};
 668     int64_t err = 0;
 669
 670     cbor_encoder_init(&encoder, outPayload, *size, 0);
 671     CborEncoder rootArray;
 672     err = err | cbor_encoder_create_array(&encoder, &rootArray, CborIndefiniteLength);
 673
 674     while(payload != NULL && (err == 0 || err == CborErrorOutOfMemory))
 675     {
 676         err = err | OCConvertSingleRepPayload(&rootArray, payload);
 677         payload = payload->next;
 678     }
 679
 680     // Close main array
 681     err = err | cbor_encoder_close_container(&encoder, &rootArray);
 682
 683     return checkError(err, &encoder, outPayload, size);
 684 }
 685
 686 static int64_t OCConvertPresencePayload(OCPresencePayload* payload,
 687         uint8_t* outPayload, size_t* size)
 688 {
 689     CborEncoder encoder = {0};
 690     int64_t err = 0;
 691
 692     cbor_encoder_init(&encoder, outPayload, *size, 0);
 693     CborEncoder rootArray;
 694
 695     err = err | cbor_encoder_create_array(&encoder, &rootArray, 1);
 696
 697     CborEncoder map;
 698     err = err | cbor_encoder_create_map(&rootArray, &map, CborIndefiniteLength);
 699
 700     // Sequence Number
 701     err = err | cbor_encode_text_string(&map,
 702             OC_RSRVD_NONCE,
 703             sizeof(OC_RSRVD_NONCE) - 1);
 704     err = err | cbor_encode_uint(&map, payload->sequenceNumber);
 705
 706     // Max Age
 707     err = err | cbor_encode_text_string(&map,
 708             OC_RSRVD_TTL,
 709             sizeof(OC_RSRVD_TTL) - 1);
 710     err = err | cbor_encode_uint(&map, payload->maxAge);
 711
 712     // Trigger
 713     const char* triggerStr = convertTriggerEnumToString(payload->trigger);
 714     err = err | AddTextStringToMap(&map, OC_RSRVD_TRIGGER, sizeof(OC_RSRVD_TRIGGER) - 1,
 715             triggerStr);
 716
 717     // Resource type name
 718     if(payload->trigger != OC_PRESENCE_TRIGGER_DELETE)
 719     {
 720         err = err | ConditionalAddTextStringToMap(&map, OC_RSRVD_RESOURCE_TYPE,
 721                 sizeof(OC_RSRVD_RESOURCE_TYPE) - 1, payload->resourceType);
 722     }
 723
 724     // Close Map
 725     err = err | cbor_encoder_close_container(&rootArray, &map);
 726     err = err | cbor_encoder_close_container(&encoder, &rootArray);
 727
 728     return checkError(err, &encoder, outPayload, size);
 729 }
 730
 731 static int64_t AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
 732         const char* value)
 733 {
 734     return cbor_encode_text_string(map, key, keylen) |
 735            cbor_encode_text_string(map, value, strlen(value));
 736 }
 737
 738 static int64_t ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
 739         const char* value)
 740 {
 741     return value ? AddTextStringToMap(map, key, keylen, value) : 0;
 742 }