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