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