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             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 OCConvertArray(CborEncoder* parent, const OCRepPayloadValueArray* valArray)
 467 {
 468     CborEncoder array;
 469     int64_t err = 0;
 470
 471     err = err | cbor_encoder_create_array(parent, &array, CborIndefiniteLength);
 472     err = err | cbor_encode_uint(&array, valArray->type);
 473     for(int i = 0; i < MAX_REP_ARRAY_DEPTH; ++i)
 474     {
 475         err = err | cbor_encode_uint(&array, valArray->dimensions[i]);
 476     }
 477
 478     size_t dimTotal = calcDimTotal(valArray->dimensions);
 479
 480     for(size_t i = 0; i < dimTotal; ++i)
 481     {
 482         switch(valArray->type)
 483         {
 484             case OCREP_PROP_NULL:
 485                 OC_LOG(ERROR, TAG, PCF("ConvertArray Invalid NULL"));
 486                 err = CborUnknownError;
 487                 break;
 488             case OCREP_PROP_INT:
 489                 err = err | cbor_encode_int(&array, valArray->iArray[i]);
 490                 break;
 491             case OCREP_PROP_DOUBLE:
 492                 err = err | cbor_encode_double(&array, valArray->dArray[i]);
 493                 break;
 494             case OCREP_PROP_BOOL:
 495                 err = err | cbor_encode_boolean(&array, valArray->bArray[i]);
 496                 break;
 497             case OCREP_PROP_STRING:
 498                 err = err | cbor_encode_text_string(&array, valArray->strArray[i],
 499                         strlen(valArray->strArray[i]));
 500                 break;
 501             case OCREP_PROP_OBJECT:
 502                 err = OCConvertSingleRepPayload(&array, valArray->objArray[i]);
 503                 break;
 504             case OCREP_PROP_ARRAY:
 505                 OC_LOG(ERROR, TAG, PCF("ConvertArray Invalid child array"));
 506                 err = CborUnknownError;
 507                 break;
 508         }
 509     }
 510
 511     err = err | cbor_encoder_close_container(parent, &array);
 512     return err;
 513 }
 514
 515 static int64_t OCConvertSingleRepPayload(CborEncoder* parent, const OCRepPayload* payload)
 516 {
 517     int64_t err = 0;
 518     CborEncoder map;
 519     err = err | cbor_encoder_create_map(parent, &map, CborIndefiniteLength);
 520
 521     // Uri
 522     err = err | ConditionalAddTextStringToMap(&map, OC_RSRVD_HREF,
 523             sizeof(OC_RSRVD_HREF) - 1,
 524             payload->uri);
 525
 526     // Prop Map
 527     // resource types, interfaces
 528     if(payload->types || payload->interfaces)
 529     {
 530         OC_LOG_V(INFO, TAG, "Payload has types or interfaces");
 531         err = err | cbor_encode_text_string(&map,
 532                 OC_RSRVD_PROPERTY,
 533                 sizeof(OC_RSRVD_PROPERTY) - 1);
 534         CborEncoder propMap;
 535         err = err | cbor_encoder_create_map(&map, &propMap, 2);
 536
 537         CborEncoder curArray;
 538         if(payload->types)
 539         {
 540             err = err | cbor_encode_text_string(&propMap,
 541                     OC_RSRVD_RESOURCE_TYPE,
 542                     sizeof(OC_RSRVD_RESOURCE_TYPE) - 1);
 543             err = err | cbor_encoder_create_array(&propMap, &curArray, CborIndefiniteLength);
 544             OCStringLL* val = payload->types;
 545             while(val)
 546             {
 547                 err = err | cbor_encode_text_string(&curArray, val->value, strlen(val->value));
 548                 val = val->next;
 549             }
 550             err = err | cbor_encoder_close_container(&propMap, &curArray);
 551         }
 552         if(payload->interfaces)
 553         {
 554             err = err | cbor_encode_text_string(&propMap,
 555                     OC_RSRVD_INTERFACE,
 556                     sizeof(OC_RSRVD_INTERFACE) - 1);
 557             err = err | cbor_encoder_create_array(&propMap, &curArray, CborIndefiniteLength);
 558             OCStringLL* val = payload->interfaces;
 559             while(val)
 560             {
 561                 err = err | cbor_encode_text_string(&curArray, val->value, strlen(val->value));
 562                 val = val->next;
 563             }
 564             err = err | cbor_encoder_close_container(&propMap, &curArray);
 565         }
 566         err = err | cbor_encoder_close_container(&map, &propMap);
 567     }
 568
 569     // Rep Map
 570     {
 571         CborEncoder repMap;
 572         err = err | cbor_encode_text_string(&map,
 573                 OC_RSRVD_REPRESENTATION,
 574                 sizeof(OC_RSRVD_REPRESENTATION) - 1);
 575         err = err | cbor_encoder_create_map(&map, &repMap, CborIndefiniteLength);
 576         OCRepPayloadValue* value = payload->values;
 577         while(value)
 578         {
 579             err = err | cbor_encode_text_string(&repMap,
 580                     value->name,
 581                     strlen(value->name));
 582             switch(value->type)
 583             {
 584                 case OCREP_PROP_NULL:
 585                     err = err | cbor_encode_null(&repMap);
 586                     break;
 587                 case OCREP_PROP_INT:
 588                     err = err | cbor_encode_int(&repMap,
 589                             value->i);
 590                     break;
 591                 case OCREP_PROP_DOUBLE:
 592                     err = err | cbor_encode_double(&repMap,
 593                             value->d);
 594                     break;
 595                 case OCREP_PROP_BOOL:
 596                     err = err | cbor_encode_boolean(&repMap,
 597                             value->b);
 598                     break;
 599                 case OCREP_PROP_STRING:
 600                     err = err | cbor_encode_text_string(&repMap,
 601                             value->str, strlen(value->str));
 602                     break;
 603                 case OCREP_PROP_OBJECT:
 604                     err = err | OCConvertSingleRepPayload(&repMap, value->obj);
 605                     break;
 606                 case OCREP_PROP_ARRAY:
 607                     err = err | OCConvertArray(&repMap, &value->arr);
 608                     break;
 609                 default:
 610                     OC_LOG_V(ERROR, TAG, "Invalid Prop type: %d",
 611                             value->type);
 612                     break;
 613             }
 614             value = value->next;
 615         }
 616
 617         err = err | cbor_encoder_close_container(&map, &repMap);
 618     }
 619
 620     // Close Map
 621     err = err | cbor_encoder_close_container(parent, &map);
 622
 623     return err;
 624 }
 625
 626 static int64_t OCConvertRepPayload(OCRepPayload* payload, uint8_t* outPayload, size_t* size)
 627 {
 628     CborEncoder encoder = {0};
 629     int64_t err = 0;
 630
 631     cbor_encoder_init(&encoder, outPayload, *size, 0);
 632     CborEncoder rootArray;
 633     err = err | cbor_encoder_create_array(&encoder, &rootArray, CborIndefiniteLength);
 634     err = err | cbor_encode_uint(&rootArray, PAYLOAD_TYPE_REPRESENTATION);
 635
 636     while(payload != NULL && (err == 0 || err == CborErrorOutOfMemory))
 637     {
 638         err = err | OCConvertSingleRepPayload(&rootArray, payload);
 639         payload = payload->next;
 640     }
 641
 642     // Close main array
 643     err = err | cbor_encoder_close_container(&encoder, &rootArray);
 644
 645     return checkError(err, &encoder, outPayload, size);
 646 }
 647
 648 static int64_t OCConvertPresencePayload(OCPresencePayload* payload,
 649         uint8_t* outPayload, size_t* size)
 650 {
 651     CborEncoder encoder = {0};
 652     int64_t err = 0;
 653
 654     cbor_encoder_init(&encoder, outPayload, *size, 0);
 655     CborEncoder rootArray;
 656
 657     err = err | cbor_encoder_create_array(&encoder, &rootArray, 2);
 658     err = err | cbor_encode_uint(&rootArray, PAYLOAD_TYPE_PRESENCE);
 659
 660
 661     CborEncoder map;
 662     err = err | cbor_encoder_create_map(&rootArray, &map, CborIndefiniteLength);
 663
 664     // Sequence Number
 665     err = err | cbor_encode_text_string(&map,
 666             OC_RSRVD_NONCE,
 667             sizeof(OC_RSRVD_NONCE) - 1);
 668     err = err | cbor_encode_uint(&map, payload->sequenceNumber);
 669
 670     // Max Age
 671     err = err | cbor_encode_text_string(&map,
 672             OC_RSRVD_TTL,
 673             sizeof(OC_RSRVD_TTL) - 1);
 674     err = err | cbor_encode_uint(&map, payload->maxAge);
 675
 676     // Trigger
 677     const char* triggerStr = convertTriggerEnumToString(payload->trigger);
 678     err = err | AddTextStringToMap(&map, OC_RSRVD_TRIGGER, sizeof(OC_RSRVD_TRIGGER) - 1,
 679             triggerStr);
 680
 681     // Resource type name
 682     if(payload->trigger != OC_PRESENCE_TRIGGER_DELETE)
 683     {
 684         err = err | ConditionalAddTextStringToMap(&map, OC_RSRVD_RESOURCE_TYPE,
 685                 sizeof(OC_RSRVD_RESOURCE_TYPE) - 1, payload->resourceType);
 686     }
 687
 688     // Close Map
 689     err = err | cbor_encoder_close_container(&rootArray, &map);
 690     err = err | cbor_encoder_close_container(&encoder, &rootArray);
 691
 692     return checkError(err, &encoder, outPayload, size);
 693 }
 694
 695 static int64_t AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
 696         const char* value)
 697 {
 698     return cbor_encode_text_string(map, key, keylen) |
 699            cbor_encode_text_string(map, value, strlen(value));
 700 }
 701
 702 static int64_t ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
 703         const char* value)
 704 {
 705     return value ? AddTextStringToMap(map, key, keylen, value) : 0;
 706 }