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