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 PCF("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, PCF("Payload parameter NULL"));
  71         return OC_STACK_INVALID_PARAM;
  72     }
  73
  74     if (!outPayload || !size)
  75     {
  76         OC_LOG(ERROR, TAG, PCF("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
 114         *size = curSize;
 115         *outPayload = out;
 116         return OC_STACK_OK;
 117     }
 118     else if (err < 0)
 119     {
 120         return (OCStackResult)-err;
 121     }
 122     else
 123     {
 124         return OC_STACK_ERROR;
 125     }
 126 }
 127
 128 static int64_t OCConvertPayloadHelper(OCPayload* payload, uint8_t* outPayload, size_t* size)
 129 {
 130     switch(payload->type)
 131     {
 132         case PAYLOAD_TYPE_DISCOVERY:
 133             return OCConvertDiscoveryPayload((OCDiscoveryPayload*)payload, outPayload, size);
 134         case PAYLOAD_TYPE_DEVICE:
 135             return OCConvertDevicePayload((OCDevicePayload*)payload, outPayload, size);
 136         case PAYLOAD_TYPE_PLATFORM:
 137             return OCConvertPlatformPayload((OCPlatformPayload*)payload, outPayload, size);
 138         case PAYLOAD_TYPE_REPRESENTATION:
 139             return OCConvertRepPayload((OCRepPayload*)payload, outPayload, size);
 140         case PAYLOAD_TYPE_PRESENCE:
 141             return OCConvertPresencePayload((OCPresencePayload*)payload, outPayload, size);
 142         case PAYLOAD_TYPE_SECURITY:
 143             return OCConvertSecurityPayload((OCSecurityPayload*)payload, outPayload, size);
 144         default:
 145             OC_LOG_V(INFO,TAG, "ConvertPayload default %d", payload->type);
 146             return OC_STACK_NOTIMPL;
 147     }
 148 }
 149
 150 static int64_t checkError(int64_t err, CborEncoder* encoder, uint8_t* outPayload, size_t* size)
 151 {
 152     if (err == CborErrorOutOfMemory)
 153     {
 154         *size += encoder->ptr - encoder->end;
 155         return err;
 156     }
 157     else if (err != 0)
 158     {
 159         OC_LOG_V(ERROR, TAG, "Convert Payload failed", err);
 160         return err;
 161     }
 162     else
 163     {
 164         *size = encoder->ptr - outPayload;
 165         return 0;
 166     }
 167 }
 168 static int64_t OCConvertSecurityPayload(OCSecurityPayload* payload, uint8_t* outPayload,
 169         size_t* size)
 170 {
 171     CborEncoder encoder;
 172     int64_t err = 0;
 173
 174     cbor_encoder_init(&encoder, outPayload, *size, 0);
 175
 176     CborEncoder rootArray;
 177     err = err | cbor_encoder_create_array(&encoder, &rootArray, 2);
 178     err = err | cbor_encode_uint(&rootArray, PAYLOAD_TYPE_SECURITY);
 179
 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, 1 + resourceCount);
 209     err = err | cbor_encode_uint(&rootArray, PAYLOAD_TYPE_DISCOVERY);
 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, 2);
 322     err = err | cbor_encode_uint(&rootArray, PAYLOAD_TYPE_DEVICE);
 323
 324     {
 325         CborEncoder map;
 326         err = err | cbor_encoder_create_map(&rootArray, &map, 2);
 327
 328         // uri
 329         err = err | AddTextStringToMap(&map, OC_RSRVD_HREF, sizeof(OC_RSRVD_HREF) - 1,
 330                 payload->uri);
 331
 332         // Rep Map
 333         {
 334             CborEncoder repMap;
 335             err = err | cbor_encode_text_string(&map, OC_RSRVD_REPRESENTATION,
 336                     sizeof(OC_RSRVD_REPRESENTATION) - 1);
 337             err = err | cbor_encoder_create_map(&map, &repMap, 4);
 338
 339             // Device ID
 340             err = err | cbor_encode_text_string(&repMap, OC_RSRVD_DEVICE_ID,
 341                     sizeof(OC_RSRVD_DEVICE_ID) - 1);
 342             err = err | cbor_encode_byte_string(&repMap, payload->sid, UUID_SIZE);
 343
 344             // Device Name
 345             err = err | AddTextStringToMap(&repMap, OC_RSRVD_DEVICE_NAME,
 346                     sizeof(OC_RSRVD_DEVICE_NAME) - 1,
 347                     payload->deviceName);
 348
 349             // Device Spec Version
 350             err = err | AddTextStringToMap(&repMap, OC_RSRVD_SPEC_VERSION,
 351                     sizeof(OC_RSRVD_SPEC_VERSION) - 1,
 352                     payload->specVersion);
 353
 354             // Device data Model Version
 355             err = err | AddTextStringToMap(&repMap, OC_RSRVD_DATA_MODEL_VERSION,
 356                     sizeof(OC_RSRVD_DATA_MODEL_VERSION) - 1,
 357                     payload->dataModelVersion);
 358
 359             err = err | cbor_encoder_close_container(&map, &repMap);
 360         }
 361
 362         // Close Map
 363         err = err | cbor_encoder_close_container(&rootArray, &map);
 364     }
 365
 366     // Close main array
 367     err = err | cbor_encoder_close_container(&encoder, &rootArray);
 368
 369     return checkError(err, &encoder, outPayload, size);
 370 }
 371
 372 static int64_t OCConvertPlatformPayload(OCPlatformPayload* payload, uint8_t* outPayload,
 373         size_t* size)
 374 {
 375     CborEncoder encoder = {0};
 376     int64_t err = 0;
 377
 378     cbor_encoder_init(&encoder, outPayload, *size, 0);
 379     CborEncoder rootArray;
 380     err = err | cbor_encoder_create_array(&encoder, &rootArray, 2);
 381     err = err | cbor_encode_uint(&rootArray, PAYLOAD_TYPE_PLATFORM);
 382     {
 383         CborEncoder map;
 384         err = err | cbor_encoder_create_map(&rootArray, &map, CborIndefiniteLength);
 385
 386         // uri
 387         err = err | AddTextStringToMap(&map, OC_RSRVD_HREF, sizeof(OC_RSRVD_HREF) - 1,
 388                 payload->uri);
 389
 390         // Rep Map
 391         {
 392             CborEncoder repMap;
 393             err = err | cbor_encode_text_string(&map, OC_RSRVD_REPRESENTATION,
 394                     sizeof(OC_RSRVD_REPRESENTATION) - 1);
 395             err = err | cbor_encoder_create_map(&map, &repMap, CborIndefiniteLength);
 396
 397             // Platform ID
 398             err = err | AddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_ID,
 399                     sizeof(OC_RSRVD_PLATFORM_ID) - 1,
 400                     payload->info.platformID);
 401
 402             // MFG Name
 403             err = err | AddTextStringToMap(&repMap, OC_RSRVD_MFG_NAME,
 404                     sizeof(OC_RSRVD_MFG_NAME) - 1,
 405                     payload->info.manufacturerName);
 406
 407             // MFG Url
 408             err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_URL,
 409                     sizeof(OC_RSRVD_MFG_URL) - 1,
 410                     payload->info.manufacturerUrl);
 411
 412             // Model Num
 413             err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MODEL_NUM,
 414                     sizeof(OC_RSRVD_MODEL_NUM) - 1,
 415                     payload->info.modelNumber);
 416
 417             // Date of Mfg
 418             err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_DATE,
 419                     sizeof(OC_RSRVD_MFG_DATE) - 1,
 420                     payload->info.dateOfManufacture);
 421
 422             // Platform Version
 423             err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_VERSION,
 424                     sizeof(OC_RSRVD_PLATFORM_VERSION) - 1,
 425                     payload->info.platformVersion);
 426
 427             // OS Version
 428             err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_OS_VERSION,
 429                     sizeof(OC_RSRVD_OS_VERSION) - 1,
 430                     payload->info.operatingSystemVersion);
 431
 432             // Hardware Version
 433             err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_HARDWARE_VERSION,
 434                     sizeof(OC_RSRVD_HARDWARE_VERSION) - 1,
 435                     payload->info.hardwareVersion);
 436
 437             // Firmware Version
 438             err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_FIRMWARE_VERSION,
 439                     sizeof(OC_RSRVD_FIRMWARE_VERSION) - 1,
 440                     payload->info.firmwareVersion);
 441
 442             // Support URL
 443             err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SUPPORT_URL,
 444                     sizeof(OC_RSRVD_SUPPORT_URL) - 1,
 445                     payload->info.supportUrl);
 446
 447             // System Time
 448             err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SYSTEM_TIME,
 449                     sizeof(OC_RSRVD_SYSTEM_TIME) - 1,
 450                     payload->info.systemTime);
 451             err = err | cbor_encoder_close_container(&map, &repMap);
 452         }
 453
 454         // Close Map
 455         err = err | cbor_encoder_close_container(&rootArray, &map);
 456     }
 457
 458     // Close main array
 459     err = err | cbor_encoder_close_container(&encoder, &rootArray);
 460
 461     return checkError(err, &encoder, outPayload, size);
 462 }
 463
 464 static int64_t OCConvertArray(CborEncoder* parent, const OCRepPayloadValueArray* valArray)
 465 {
 466     CborEncoder array;
 467     int64_t err = 0;
 468
 469     err = err | cbor_encoder_create_array(parent, &array, CborIndefiniteLength);
 470     err = err | cbor_encode_uint(&array, valArray->type);
 471     for(int i = 0; i < MAX_REP_ARRAY_DEPTH; ++i)
 472     {
 473         err = err | cbor_encode_uint(&array, valArray->dimensions[i]);
 474     }
 475
 476     size_t dimTotal = calcDimTotal(valArray->dimensions);
 477
 478     for(size_t i = 0; i < dimTotal; ++i)
 479     {
 480         switch(valArray->type)
 481         {
 482             case OCREP_PROP_NULL:
 483                 OC_LOG(ERROR, TAG, PCF("ConvertArray Invalid NULL"));
 484                 err = CborUnknownError;
 485                 break;
 486             case OCREP_PROP_INT:
 487                 err = err | cbor_encode_int(&array, valArray->iArray[i]);
 488                 break;
 489             case OCREP_PROP_DOUBLE:
 490                 err = err | cbor_encode_double(&array, valArray->dArray[i]);
 491                 break;
 492             case OCREP_PROP_BOOL:
 493                 err = err | cbor_encode_boolean(&array, valArray->bArray[i]);
 494                 break;
 495             case OCREP_PROP_STRING:
 496                 err = err | cbor_encode_text_string(&array, valArray->strArray[i],
 497                         strlen(valArray->strArray[i]));
 498                 break;
 499             case OCREP_PROP_OBJECT:
 500                 err = OCConvertSingleRepPayload(&array, valArray->objArray[i]);
 501                 break;
 502             case OCREP_PROP_ARRAY:
 503                 OC_LOG(ERROR, TAG, PCF("ConvertArray Invalid child array"));
 504                 err = CborUnknownError;
 505                 break;
 506         }
 507     }
 508
 509     err = err | cbor_encoder_close_container(parent, &array);
 510     return err;
 511 }
 512
 513 static int64_t OCConvertSingleRepPayload(CborEncoder* parent, const OCRepPayload* payload)
 514 {
 515     int64_t err = 0;
 516     CborEncoder map;
 517     err = err | cbor_encoder_create_map(parent, &map, CborIndefiniteLength);
 518
 519     // Uri
 520     err = err | ConditionalAddTextStringToMap(&map, OC_RSRVD_HREF,
 521             sizeof(OC_RSRVD_HREF) - 1,
 522             payload->uri);
 523
 524     // Prop Map
 525     // resource types, interfaces
 526     if(payload->types || payload->interfaces)
 527     {
 528         OC_LOG_V(INFO, TAG, "Payload has types or interfaces");
 529         err = err | cbor_encode_text_string(&map,
 530                 OC_RSRVD_PROPERTY,
 531                 sizeof(OC_RSRVD_PROPERTY) - 1);
 532         CborEncoder propMap;
 533         err = err | cbor_encoder_create_map(&map, &propMap, 2);
 534
 535         CborEncoder curArray;
 536         if(payload->types)
 537         {
 538             err = err | cbor_encode_text_string(&propMap,
 539                     OC_RSRVD_RESOURCE_TYPE,
 540                     sizeof(OC_RSRVD_RESOURCE_TYPE) - 1);
 541             err = err | cbor_encoder_create_array(&propMap, &curArray, CborIndefiniteLength);
 542             OCStringLL* val = payload->types;
 543             while(val)
 544             {
 545                 err = err | cbor_encode_text_string(&curArray, val->value, strlen(val->value));
 546                 val = val->next;
 547             }
 548             err = err | cbor_encoder_close_container(&propMap, &curArray);
 549         }
 550         if(payload->interfaces)
 551         {
 552             err = err | cbor_encode_text_string(&propMap,
 553                     OC_RSRVD_INTERFACE,
 554                     sizeof(OC_RSRVD_INTERFACE) - 1);
 555             err = err | cbor_encoder_create_array(&propMap, &curArray, CborIndefiniteLength);
 556             OCStringLL* val = payload->interfaces;
 557             while(val)
 558             {
 559                 err = err | cbor_encode_text_string(&curArray, val->value, strlen(val->value));
 560                 val = val->next;
 561             }
 562             err = err | cbor_encoder_close_container(&propMap, &curArray);
 563         }
 564         err = err | cbor_encoder_close_container(&map, &propMap);
 565     }
 566
 567     // Rep Map
 568     {
 569         CborEncoder repMap;
 570         err = err | cbor_encode_text_string(&map,
 571                 OC_RSRVD_REPRESENTATION,
 572                 sizeof(OC_RSRVD_REPRESENTATION) - 1);
 573         err = err | cbor_encoder_create_map(&map, &repMap, CborIndefiniteLength);
 574         OCRepPayloadValue* value = payload->values;
 575         while(value)
 576         {
 577             err = err | cbor_encode_text_string(&repMap,
 578                     value->name,
 579                     strlen(value->name));
 580             switch(value->type)
 581             {
 582                 case OCREP_PROP_NULL:
 583                     err = err | cbor_encode_null(&repMap);
 584                     break;
 585                 case OCREP_PROP_INT:
 586                     err = err | cbor_encode_int(&repMap,
 587                             value->i);
 588                     break;
 589                 case OCREP_PROP_DOUBLE:
 590                     err = err | cbor_encode_double(&repMap,
 591                             value->d);
 592                     break;
 593                 case OCREP_PROP_BOOL:
 594                     err = err | cbor_encode_boolean(&repMap,
 595                             value->b);
 596                     break;
 597                 case OCREP_PROP_STRING:
 598                     err = err | cbor_encode_text_string(&repMap,
 599                             value->str, strlen(value->str));
 600                     break;
 601                 case OCREP_PROP_OBJECT:
 602                     err = err | OCConvertSingleRepPayload(&repMap, value->obj);
 603                     break;
 604                 case OCREP_PROP_ARRAY:
 605                     err = err | OCConvertArray(&repMap, &value->arr);
 606                     break;
 607                 default:
 608                     OC_LOG_V(ERROR, TAG, "Invalid Prop type: %d",
 609                             value->type);
 610                     break;
 611             }
 612             value = value->next;
 613         }
 614
 615         err = err | cbor_encoder_close_container(&map, &repMap);
 616     }
 617
 618     // Close Map
 619     err = err | cbor_encoder_close_container(parent, &map);
 620
 621     return err;
 622 }
 623
 624 static int64_t OCConvertRepPayload(OCRepPayload* payload, uint8_t* outPayload, size_t* size)
 625 {
 626     CborEncoder encoder = {0};
 627     int64_t err = 0;
 628
 629     cbor_encoder_init(&encoder, outPayload, *size, 0);
 630     CborEncoder rootArray;
 631     err = err | cbor_encoder_create_array(&encoder, &rootArray, CborIndefiniteLength);
 632     err = err | cbor_encode_uint(&rootArray, PAYLOAD_TYPE_REPRESENTATION);
 633
 634     while(payload != NULL && (err == 0 || err == CborErrorOutOfMemory))
 635     {
 636         err = err | OCConvertSingleRepPayload(&rootArray, payload);
 637         payload = payload->next;
 638     }
 639
 640     // Close main array
 641     err = err | cbor_encoder_close_container(&encoder, &rootArray);
 642
 643     return checkError(err, &encoder, outPayload, size);
 644 }
 645
 646 static int64_t OCConvertPresencePayload(OCPresencePayload* payload,
 647         uint8_t* outPayload, size_t* size)
 648 {
 649     CborEncoder encoder = {0};
 650     int64_t err = 0;
 651
 652     cbor_encoder_init(&encoder, outPayload, *size, 0);
 653     CborEncoder rootArray;
 654
 655     err = err | cbor_encoder_create_array(&encoder, &rootArray, 2);
 656     err = err | cbor_encode_uint(&rootArray, PAYLOAD_TYPE_PRESENCE);
 657
 658
 659     CborEncoder map;
 660     err = err | cbor_encoder_create_map(&rootArray, &map, CborIndefiniteLength);
 661
 662     // Sequence Number
 663     err = err | cbor_encode_text_string(&map,
 664             OC_RSRVD_NONCE,
 665             sizeof(OC_RSRVD_NONCE) - 1);
 666     err = err | cbor_encode_uint(&map, payload->sequenceNumber);
 667
 668     // Max Age
 669     err = err | cbor_encode_text_string(&map,
 670             OC_RSRVD_TTL,
 671             sizeof(OC_RSRVD_TTL) - 1);
 672     err = err | cbor_encode_uint(&map, payload->maxAge);
 673
 674     // Trigger
 675     const char* triggerStr = convertTriggerEnumToString(payload->trigger);
 676     err = err | AddTextStringToMap(&map, OC_RSRVD_TRIGGER, sizeof(OC_RSRVD_TRIGGER) - 1,
 677             triggerStr);
 678
 679     // Resource type name
 680     if(payload->trigger != OC_PRESENCE_TRIGGER_DELETE)
 681     {
 682         err = err | ConditionalAddTextStringToMap(&map, OC_RSRVD_RESOURCE_TYPE,
 683                 sizeof(OC_RSRVD_RESOURCE_TYPE) - 1, payload->resourceType);
 684     }
 685
 686     // Close Map
 687     err = err | cbor_encoder_close_container(&rootArray, &map);
 688     err = err | cbor_encoder_close_container(&encoder, &rootArray);
 689
 690     return checkError(err, &encoder, outPayload, size);
 691 }
 692
 693 static int64_t AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
 694         const char* value)
 695 {
 696     return cbor_encode_text_string(map, key, keylen) |
 697            cbor_encode_text_string(map, value, strlen(value));
 698 }
 699
 700 static int64_t ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
 701         const char* value)
 702 {
 703     return value ? AddTextStringToMap(map, key, keylen, value) : 0;
 704 }