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