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 "oic_string.h"
  26 #include "logger.h"
  27 #include "ocpayload.h"
  28 #include "ocrandom.h"
  29 #include "ocresourcehandler.h"
  30 #include "cbor.h"
  31 #include "rdpayload.h"
  32
  33 #define TAG "OCPayloadConvert"
  34 // Arbitrarily chosen size that seems to contain the majority of packages
  35 #define INIT_SIZE (255)
  36
  37 // CBOR Array Length
  38 #define DISCOVERY_CBOR_ARRAY_LEN 1
  39 // CBOR Res Map Length
  40 #define DISCOVERY_CBOR_RES_MAP_LEN 2
  41 // CBOR Links Map Length
  42 #define DISCOVERY_CBOR_LINKS_MAP_LEN 4
  43
  44 // Functions all return either a CborError, or a negative version of the OC_STACK return values
  45 static int64_t OCConvertPayloadHelper(OCPayload* payload, uint8_t* outPayload, size_t* size);
  46 static int64_t OCConvertDiscoveryPayload(OCDiscoveryPayload* payload, uint8_t* outPayload,
  47         size_t* size);
  48 static int64_t OCConvertDevicePayload(OCDevicePayload* payload, uint8_t* outPayload,
  49         size_t* size);
  50 static int64_t OCConvertPlatformPayload(OCPlatformPayload* payload, uint8_t* outPayload,
  51         size_t* size);
  52 static int64_t OCConvertRepPayload(OCRepPayload* payload, uint8_t* outPayload, size_t* size);
  53 static int64_t OCConvertRepMap(CborEncoder *map, const OCRepPayload* payload);
  54 static int64_t OCConvertPresencePayload(OCPresencePayload* payload, uint8_t* outPayload,
  55         size_t* size);
  56 static int64_t OCConvertSecurityPayload(OCSecurityPayload* payload, uint8_t* outPayload,
  57         size_t* size);
  58 static int64_t OCConvertSingleRepPayload(CborEncoder* parent, const OCRepPayload* payload);
  59 static int64_t OCConvertArray(CborEncoder* parent, const OCRepPayloadValueArray* valArray);
  60
  61 static int64_t AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
  62         const char* value);
  63
  64 static int64_t ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
  65         const char* value);
  66
  67 OCStackResult OCConvertPayload(OCPayload* payload, uint8_t** outPayload, size_t* size)
  68 {
  69     // TinyCbor Version 47a78569c0 or better on master is required for the re-allocation
  70     // strategy to work.  If you receive the following assertion error, please do a git-pull
  71     // from the extlibs/tinycbor/tinycbor directory
  72     #define CborNeedsUpdating  (CborErrorOutOfMemory < CborErrorDataTooLarge)
  73     OC_STATIC_ASSERT(!CborNeedsUpdating, "tinycbor needs to be updated to at least 47a78569c0");
  74     #undef CborNeedsUpdating
  75     if (!payload)
  76     {
  77         OC_LOG(ERROR, TAG, "Payload parameter NULL");
  78         return OC_STACK_INVALID_PARAM;
  79     }
  80
  81     if (!outPayload || !size)
  82     {
  83         OC_LOG(ERROR, TAG, "Out parameter/s parameter NULL");
  84         return OC_STACK_INVALID_PARAM;
  85     }
  86
  87     OC_LOG_V(INFO, TAG, "Converting payload of type %d", payload->type);
  88
  89     size_t curSize = INIT_SIZE;
  90     uint8_t* out = (uint8_t*)OICCalloc(1, curSize);
  91     int64_t err = OCConvertPayloadHelper(payload, out, &curSize);
  92
  93     if (err == CborErrorOutOfMemory)
  94     {
  95         // reallocate "out" and try again!
  96         uint8_t* out2 = (uint8_t*)OICRealloc(out, curSize);
  97
  98         if (!out2)
  99         {
 100             OICFree(out);
 101             return OC_STACK_NO_MEMORY;
 102         }
 103
 104         out = out2;
 105         err = OCConvertPayloadHelper(payload, out, &curSize);
 106     }
 107
 108     if (err == 0)
 109     {
 110         if (curSize < INIT_SIZE)
 111         {
 112             uint8_t* out2 = (uint8_t*)OICRealloc(out, curSize);
 113
 114             if (!out2)
 115             {
 116                 OICFree(out);
 117                 return OC_STACK_NO_MEMORY;
 118             }
 119
 120             out = out2;
 121         }
 122
 123         *size = curSize;
 124         *outPayload = out;
 125         return OC_STACK_OK;
 126     }
 127     else if (err < 0)
 128     {
 129         return (OCStackResult)-err;
 130     }
 131     else
 132     {
 133         return OC_STACK_ERROR;
 134     }
 135 }
 136
 137 static int64_t OCConvertPayloadHelper(OCPayload* payload, uint8_t* outPayload, size_t* size)
 138 {
 139     switch(payload->type)
 140     {
 141         case PAYLOAD_TYPE_DISCOVERY:
 142             return OCConvertDiscoveryPayload((OCDiscoveryPayload*)payload, outPayload, size);
 143         case PAYLOAD_TYPE_DEVICE:
 144             return OCConvertDevicePayload((OCDevicePayload*)payload, outPayload, size);
 145         case PAYLOAD_TYPE_PLATFORM:
 146             return OCConvertPlatformPayload((OCPlatformPayload*)payload, outPayload, size);
 147         case PAYLOAD_TYPE_REPRESENTATION:
 148             return OCConvertRepPayload((OCRepPayload*)payload, outPayload, size);
 149         case PAYLOAD_TYPE_PRESENCE:
 150             return OCConvertPresencePayload((OCPresencePayload*)payload, outPayload, size);
 151         case PAYLOAD_TYPE_SECURITY:
 152             return OCConvertSecurityPayload((OCSecurityPayload*)payload, outPayload, size);
 153         case PAYLOAD_TYPE_RD:
 154             return OCRDPayloadToCbor((OCRDPayload*)payload, outPayload, size);
 155         default:
 156             OC_LOG_V(INFO,TAG, "ConvertPayload default %d", payload->type);
 157             return OC_STACK_NOTIMPL;
 158     }
 159 }
 160
 161 static int64_t checkError(int64_t err, CborEncoder* encoder, uint8_t* outPayload, size_t* size)
 162 {
 163     if (err == CborErrorOutOfMemory)
 164     {
 165         *size += encoder->ptr - encoder->end;
 166         return err;
 167     }
 168     else if (err != 0)
 169     {
 170         OC_LOG_V(ERROR, TAG, "Convert Payload failed : %zd", err);
 171         return err;
 172     }
 173     else
 174     {
 175         *size = encoder->ptr - outPayload;
 176         return 0;
 177     }
 178 }
 179
 180 static int64_t OCConvertSecurityPayload(OCSecurityPayload* payload, uint8_t* outPayload,
 181         size_t* size)
 182 {
 183     CborEncoder encoder;
 184     int64_t err = 0;
 185
 186     cbor_encoder_init(&encoder, outPayload, *size, 0);
 187
 188     CborEncoder map;
 189
 190     err = err | cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength);
 191
 192     if(payload->securityData)
 193     {
 194         err = err | cbor_encode_text_string(&map, payload->securityData,
 195                                             strlen(payload->securityData));
 196     }
 197
 198     err = err | cbor_encoder_close_container(&encoder, &map);
 199     return checkError(err, &encoder, outPayload, size);
 200 }
 201
 202 static char* OCStringLLJoin(OCStringLL* val)
 203 {
 204     OCStringLL* temp = val;
 205     size_t size = strlen(temp->value);
 206
 207     while (temp->next)
 208     {
 209         ++size;
 210         temp = temp->next;
 211         size += strlen(temp->value);
 212     }
 213
 214     char* joinedStr = (char*)OICCalloc(sizeof(char), size + 1);
 215
 216     if (!joinedStr)
 217     {
 218         return NULL;
 219     }
 220
 221     OICStrcat(joinedStr, size + 1, val->value);
 222     while (val->next)
 223     {
 224         val = val->next;
 225         OICStrcat(joinedStr, size + 1, " ");
 226         OICStrcat(joinedStr, size + 1, val->value);
 227     }
 228     return joinedStr;
 229 }
 230
 231 static int64_t OCConvertDiscoveryPayload(OCDiscoveryPayload* payload, uint8_t* outPayload,
 232         size_t* size)
 233 {
 234     CborEncoder encoder = {0};
 235     CborEncoder rootArray = {0};
 236     int64_t err = 0;
 237
 238     cbor_encoder_init(&encoder, outPayload, *size, 0);
 239
 240     if (payload->collectionResources)
 241     {
 242         CborError cborEncoderResult;
 243         cborEncoderResult = cbor_encoder_create_array(&encoder, &rootArray, DISCOVERY_CBOR_ARRAY_LEN);
 244         if (CborNoError != cborEncoderResult)
 245         {
 246             OC_LOG(ERROR, TAG, "Failed creating root array.");
 247             goto cbor_error;
 248         }
 249
 250         CborEncoder colArray;
 251         cborEncoderResult = cbor_encoder_create_array(&rootArray, &colArray, CborIndefiniteLength);
 252         if (CborNoError != cborEncoderResult)
 253         {
 254             OC_LOG(ERROR, TAG, "Failed creating collection array.");
 255             goto cbor_error;
 256         }
 257         OCResourceCollectionPayload *colResources = payload->collectionResources;
 258         while (colResources)
 259         {
 260             if (OC_STACK_OK != OCTagsPayloadToCbor(colResources->tags, &colArray))
 261             {
 262                 goto cbor_error;
 263             }
 264             if (OC_STACK_OK != OCLinksPayloadToCbor(colResources->setLinks, &colArray))
 265             {
 266                 goto cbor_error;
 267             }
 268             colResources = colResources->next;
 269         }
 270         cborEncoderResult = cbor_encoder_close_container(&rootArray, &colArray);
 271         if (CborNoError != cborEncoderResult)
 272         {
 273             OC_LOG(ERROR, TAG, "Failed closing collection array.");
 274             goto cbor_error;
 275         }
 276         cborEncoderResult = cbor_encoder_close_container(&encoder, &rootArray);
 277         if (CborNoError != cborEncoderResult)
 278         {
 279             OC_LOG(ERROR, TAG, "Failed closing root array.");
 280             goto cbor_error;
 281         }
 282     }
 283     else if (payload->resources)
 284     {
 285         size_t resourceCount =  OCDiscoveryPayloadGetResourceCount(payload);
 286         err = err | cbor_encoder_create_array(&encoder, &rootArray, resourceCount);
 287
 288         for(size_t i = 0; i < resourceCount; ++i)
 289         {
 290             CborEncoder map;
 291             OCResourcePayload* resource = OCDiscoveryPayloadGetResource(payload, i);
 292             if(!resource)
 293             {
 294                 OICFree(outPayload);
 295                 return OC_STACK_INVALID_PARAM;
 296             }
 297
 298             err = err | cbor_encoder_create_map(&rootArray, &map, DISCOVERY_CBOR_RES_MAP_LEN);
 299
 300             // Device ID
 301             err = err | cbor_encode_text_string(&map, OC_RSRVD_DEVICE_ID,
 302                     sizeof(OC_RSRVD_DEVICE_ID) - 1);
 303             err = err | cbor_encode_byte_string(&map, resource->sid, UUID_SIZE);
 304
 305             {
 306                 CborEncoder linkArray;
 307                 err = err | cbor_encode_text_string(&map, OC_RSRVD_LINKS, sizeof(OC_RSRVD_LINKS) -1);
 308                 err = err | cbor_encoder_create_array(&map, &linkArray, CborIndefiniteLength);
 309
 310                 // Link Map
 311                 {
 312                     CborEncoder linkMap;
 313                     err = err | cbor_encoder_create_map(&linkArray, &linkMap, DISCOVERY_CBOR_LINKS_MAP_LEN);
 314
 315                     // Uri
 316                     err = err | AddTextStringToMap(&linkMap, OC_RSRVD_HREF,
 317                             sizeof(OC_RSRVD_HREF) - 1,
 318                             resource->uri);
 319                     // Resource Type
 320                     if (resource->types)
 321                     {
 322                         char* joinedTypes = OCStringLLJoin(resource->types);
 323                         if (joinedTypes)
 324                         {
 325                             err = err | cbor_encode_text_string(&linkMap, OC_RSRVD_RESOURCE_TYPE,
 326                                     sizeof(OC_RSRVD_RESOURCE_TYPE) - 1);
 327                             err = err | cbor_encode_text_string(&linkMap, joinedTypes,
 328                                     strlen(joinedTypes));
 329                             OICFree(joinedTypes);
 330                         }
 331                         else
 332                         {
 333                             return OC_STACK_NO_MEMORY;
 334                         }
 335                     }
 336                     // Interface Types
 337                     if (resource->interfaces)
 338                     {
 339                         char* joinedInterfaces = OCStringLLJoin(resource->interfaces);
 340                         if (joinedInterfaces)
 341                         {
 342                             err = err | cbor_encode_text_string(&linkMap, OC_RSRVD_INTERFACE,
 343                                     sizeof(OC_RSRVD_INTERFACE) - 1);
 344                             err = err | cbor_encode_text_string(&linkMap, joinedInterfaces,
 345                                     strlen(joinedInterfaces));
 346                             OICFree(joinedInterfaces);
 347                         }
 348                         else
 349                         {
 350                             return OC_STACK_NO_MEMORY;
 351                         }
 352                     }
 353                     // Policy
 354                     {
 355                         CborEncoder policyMap;
 356                         err = err | cbor_encode_text_string(&linkMap, OC_RSRVD_POLICY,
 357                                 sizeof(OC_RSRVD_POLICY) - 1);
 358                         err = err | cbor_encoder_create_map(&linkMap, &policyMap, CborIndefiniteLength);
 359
 360                         // Bitmap
 361                         err = err | cbor_encode_text_string(&policyMap, OC_RSRVD_BITMAP,
 362                                 sizeof(OC_RSRVD_BITMAP) - 1);
 363                         err = err | cbor_encode_uint(&policyMap, resource->bitmap);
 364
 365                         if(resource->secure)
 366                         {
 367                             err = err | cbor_encode_text_string(&policyMap, OC_RSRVD_SECURE,
 368                                     sizeof(OC_RSRVD_SECURE) - 1);
 369                             err = err | cbor_encode_boolean(&policyMap, OC_RESOURCE_SECURE);
 370
 371                             if(resource->port != 0)
 372                             {
 373                                 err = err | cbor_encode_text_string(&policyMap, OC_RSRVD_HOSTING_PORT,
 374                                         sizeof(OC_RSRVD_HOSTING_PORT) - 1);
 375                                 err = err | cbor_encode_uint(&policyMap, resource->port);
 376                             }
 377                         }
 378
 379                         err = err | cbor_encoder_close_container(&linkMap, &policyMap);
 380                     }
 381                     // Close
 382                     err = err | cbor_encoder_close_container(&linkArray, &linkMap);
 383                 }
 384                 err = err | cbor_encoder_close_container(&map, &linkArray);
 385             }
 386             err = err | cbor_encoder_close_container(&rootArray, &map);
 387         }
 388         // Close main array
 389         err = err | cbor_encoder_close_container(&encoder, &rootArray);
 390     }
 391
 392     return checkError(err, &encoder, outPayload, size);
 393 cbor_error:
 394     OICFree(outPayload);
 395     return OC_STACK_ERROR;
 396 }
 397
 398 static int64_t OCConvertDevicePayload(OCDevicePayload* payload, uint8_t* outPayload,
 399         size_t* size)
 400 {
 401     CborEncoder encoder = {0};
 402     int64_t err = 0;
 403
 404     cbor_encoder_init(&encoder, outPayload, *size, 0);
 405     CborEncoder repMap;
 406     err = err | cbor_encoder_create_map(&encoder, &repMap, CborIndefiniteLength);
 407
 408     // Device ID
 409     err = err | cbor_encode_text_string(&repMap, OC_RSRVD_DEVICE_ID,
 410             sizeof(OC_RSRVD_DEVICE_ID) - 1);
 411     err = err | cbor_encode_byte_string(&repMap, payload->sid, UUID_SIZE);
 412
 413     // Device Name
 414     err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_DEVICE_NAME,
 415             sizeof(OC_RSRVD_DEVICE_NAME) - 1,
 416             payload->deviceName);
 417
 418     // Device Spec Version
 419     err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SPEC_VERSION,
 420             sizeof(OC_RSRVD_SPEC_VERSION) - 1,
 421             payload->specVersion);
 422
 423     // Device data Model Version
 424     err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_DATA_MODEL_VERSION,
 425             sizeof(OC_RSRVD_DATA_MODEL_VERSION) - 1,
 426             payload->dataModelVersion);
 427
 428     err = err | cbor_encoder_close_container(&encoder, &repMap);
 429
 430     return checkError(err, &encoder, outPayload, size);
 431 }
 432
 433 static int64_t OCConvertPlatformPayload(OCPlatformPayload* payload, uint8_t* outPayload,
 434         size_t* size)
 435 {
 436     CborEncoder encoder = {0};
 437     int64_t err = 0;
 438
 439     cbor_encoder_init(&encoder, outPayload, *size, 0);
 440     {
 441         CborEncoder repMap;
 442         err = err | cbor_encoder_create_map(&encoder, &repMap, CborIndefiniteLength);
 443
 444         // Platform ID
 445         err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_ID,
 446                 sizeof(OC_RSRVD_PLATFORM_ID) - 1,
 447                 payload->info.platformID);
 448
 449         // MFG Name
 450         err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_NAME,
 451                 sizeof(OC_RSRVD_MFG_NAME) - 1,
 452                 payload->info.manufacturerName);
 453
 454         // MFG Url
 455         err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_URL,
 456                 sizeof(OC_RSRVD_MFG_URL) - 1,
 457                 payload->info.manufacturerUrl);
 458
 459         // Model Num
 460         err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MODEL_NUM,
 461                 sizeof(OC_RSRVD_MODEL_NUM) - 1,
 462                 payload->info.modelNumber);
 463
 464         // Date of Mfg
 465         err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_MFG_DATE,
 466                 sizeof(OC_RSRVD_MFG_DATE) - 1,
 467                 payload->info.dateOfManufacture);
 468
 469         // Platform Version
 470         err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_PLATFORM_VERSION,
 471                 sizeof(OC_RSRVD_PLATFORM_VERSION) - 1,
 472                 payload->info.platformVersion);
 473
 474         // OS Version
 475         err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_OS_VERSION,
 476                 sizeof(OC_RSRVD_OS_VERSION) - 1,
 477                 payload->info.operatingSystemVersion);
 478
 479         // Hardware Version
 480         err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_HARDWARE_VERSION,
 481                 sizeof(OC_RSRVD_HARDWARE_VERSION) - 1,
 482                 payload->info.hardwareVersion);
 483
 484         // Firmware Version
 485         err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_FIRMWARE_VERSION,
 486                 sizeof(OC_RSRVD_FIRMWARE_VERSION) - 1,
 487                 payload->info.firmwareVersion);
 488
 489         // Support URL
 490         err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SUPPORT_URL,
 491                 sizeof(OC_RSRVD_SUPPORT_URL) - 1,
 492                 payload->info.supportUrl);
 493
 494         // System Time
 495         err = err | ConditionalAddTextStringToMap(&repMap, OC_RSRVD_SYSTEM_TIME,
 496                 sizeof(OC_RSRVD_SYSTEM_TIME) - 1,
 497                 payload->info.systemTime);
 498
 499         // Close Map
 500         err = err | cbor_encoder_close_container(&encoder, &repMap);
 501     }
 502
 503     return checkError(err, &encoder, outPayload, size);
 504 }
 505
 506 static int64_t OCConvertArrayItem(CborEncoder* array, const OCRepPayloadValueArray* valArray,
 507         size_t index)
 508 {
 509     int64_t err = 0;
 510     switch (valArray->type)
 511     {
 512         case OCREP_PROP_NULL:
 513             OC_LOG(ERROR, TAG, "ConvertArray Invalid NULL");
 514             err = CborUnknownError;
 515             break;
 516         case OCREP_PROP_INT:
 517             err = err | cbor_encode_int(array, valArray->iArray[index]);
 518             break;
 519         case OCREP_PROP_DOUBLE:
 520             err = err | cbor_encode_double(array, valArray->dArray[index]);
 521             break;
 522         case OCREP_PROP_BOOL:
 523             err = err | cbor_encode_boolean(array, valArray->bArray[index]);
 524             break;
 525         case OCREP_PROP_STRING:
 526             if (!valArray->strArray[index])
 527             {
 528                 err = err | cbor_encode_null(array);
 529             }
 530             else
 531             {
 532                 err = err | cbor_encode_text_string(array, valArray->strArray[index],
 533                         strlen(valArray->strArray[index]));
 534             }
 535             break;
 536         case OCREP_PROP_BYTE_STRING:
 537             if (!valArray->strArray[index])
 538             {
 539                 err = err | cbor_encode_null(array);
 540             }
 541             else
 542             {
 543                 err = err | cbor_encode_byte_string(array, valArray->ocByteStrArray[index].bytes,
 544                         valArray->ocByteStrArray[index].len);
 545             }
 546             break;
 547         case OCREP_PROP_OBJECT:
 548             if (!valArray->objArray[index])
 549             {
 550                 err = err | cbor_encode_null(array);
 551             }
 552             else
 553             {
 554                 err = OCConvertRepMap(array, valArray->objArray[index]);
 555             }
 556             break;
 557         case OCREP_PROP_ARRAY:
 558             OC_LOG(ERROR, TAG, "ConvertArray Invalid child array");
 559             err = CborUnknownError;
 560             break;
 561     }
 562
 563     return err;
 564 }
 565 static int64_t OCConvertArray(CborEncoder* parent, const OCRepPayloadValueArray* valArray)
 566 {
 567     CborEncoder array;
 568     int64_t err = 0;
 569
 570     err = err | cbor_encoder_create_array(parent, &array, valArray->dimensions[0]);
 571
 572     for (size_t i = 0; i < valArray->dimensions[0];++i)
 573     {
 574         if (valArray->dimensions[1] != 0)
 575         {
 576             CborEncoder array2;
 577             err = err | cbor_encoder_create_array(&array, &array2, valArray->dimensions[1]);
 578
 579             for (size_t j = 0; j < valArray->dimensions[1]; ++j)
 580             {
 581                 if (valArray->dimensions[2] != 0)
 582                 {
 583                     CborEncoder array3;
 584                     err = err | cbor_encoder_create_array(&array2, &array3,
 585                             valArray->dimensions[2]);
 586
 587                     for(size_t k = 0; k < valArray->dimensions[2]; ++k)
 588                     {
 589                         OCConvertArrayItem(&array3, valArray,
 590                             j * valArray->dimensions[2] +
 591                             i * valArray->dimensions[2] * valArray->dimensions[1] +
 592                             k);
 593                     }
 594                     err = err | cbor_encoder_close_container(&array2, &array3);
 595                 }
 596                 else
 597                 {
 598                     OCConvertArrayItem(&array2, valArray,
 599                             i * valArray->dimensions[1] + j);
 600                 }
 601             }
 602             err = err | cbor_encoder_close_container(&array, &array2);
 603         }
 604         else
 605         {
 606             OCConvertArrayItem(&array, valArray, i);
 607         }
 608     }
 609     err = err | cbor_encoder_close_container(parent, &array);
 610     return err;
 611 }
 612
 613 static int64_t OCConvertRepMap(CborEncoder *map, const OCRepPayload* payload)
 614 {
 615     int64_t err = 0;
 616     CborEncoder repMap;
 617     err = err | cbor_encoder_create_map(map, &repMap, CborIndefiniteLength);
 618     err = err | OCConvertSingleRepPayload(&repMap, payload);
 619     err = err | cbor_encoder_close_container(map, &repMap);
 620     return err;
 621 }
 622
 623 static int64_t OCConvertSingleRepPayload(CborEncoder* repMap, const OCRepPayload* payload)
 624 {
 625     int64_t err = 0;
 626     OCRepPayloadValue* value = payload->values;
 627     while(value)
 628     {
 629         err = err | cbor_encode_text_string(repMap,
 630                 value->name,
 631                 strlen(value->name));
 632         switch(value->type)
 633         {
 634             case OCREP_PROP_NULL:
 635                 err = err | cbor_encode_null(repMap);
 636                 break;
 637             case OCREP_PROP_INT:
 638                 err = err | cbor_encode_int(repMap,
 639                         value->i);
 640                 break;
 641             case OCREP_PROP_DOUBLE:
 642                 err = err | cbor_encode_double(repMap,
 643                         value->d);
 644                 break;
 645             case OCREP_PROP_BOOL:
 646                 err = err | cbor_encode_boolean(repMap,
 647                         value->b);
 648                 break;
 649             case OCREP_PROP_STRING:
 650                 err = err | cbor_encode_text_string(repMap,
 651                         value->str, strlen(value->str));
 652                 break;
 653             case OCREP_PROP_BYTE_STRING:
 654                 err = err | cbor_encode_byte_string(repMap,
 655                         value->ocByteStr.bytes, value->ocByteStr.len);
 656                 break;
 657             case OCREP_PROP_OBJECT:
 658                 err = err | OCConvertRepMap(repMap, value->obj);
 659                 break;
 660             case OCREP_PROP_ARRAY:
 661                 err = err | OCConvertArray(repMap, &value->arr);
 662                 break;
 663             default:
 664                 OC_LOG_V(ERROR, TAG, "Invalid Prop type: %d",
 665                         value->type);
 666                 break;
 667         }
 668         value = value->next;
 669     }
 670
 671     return err;
 672 }
 673
 674 static int64_t OCConvertRepPayload(OCRepPayload* payload, uint8_t* outPayload, size_t* size)
 675 {
 676     CborEncoder encoder = {0};
 677     int64_t err = 0;
 678
 679     cbor_encoder_init(&encoder, outPayload, *size, 0);
 680     CborEncoder rootMap;
 681     err = err | cbor_encoder_create_map(&encoder, &rootMap, CborIndefiniteLength);
 682
 683     if (payload->types)
 684     {
 685         OC_LOG(INFO, TAG, "Payload has types or interfaces");
 686         char* joinedTypes = OCStringLLJoin(payload->types);
 687         if (joinedTypes)
 688         {
 689             err = err | cbor_encode_text_string(&rootMap, OC_RSRVD_RESOURCE_TYPE,
 690                     sizeof(OC_RSRVD_RESOURCE_TYPE) - 1);
 691             err = err | cbor_encode_text_string(&rootMap, joinedTypes,
 692                     strlen(joinedTypes));
 693             OICFree(joinedTypes);
 694         }
 695         else
 696         {
 697             return OC_STACK_NO_MEMORY;
 698         }
 699     }
 700     if (payload->interfaces)
 701     {
 702         char* joinedInterfaces = OCStringLLJoin(payload->interfaces);
 703         if (joinedInterfaces)
 704         {
 705             err = err | cbor_encode_text_string(&rootMap, OC_RSRVD_INTERFACE,
 706                     sizeof(OC_RSRVD_INTERFACE) - 1);
 707             err = err | cbor_encode_text_string(&rootMap, joinedInterfaces,
 708                     strlen(joinedInterfaces));
 709             OICFree(joinedInterfaces);
 710         }
 711         else
 712         {
 713             return OC_STACK_NO_MEMORY;
 714         }
 715     }
 716
 717     while(payload != NULL && (err == 0 || err == CborErrorOutOfMemory))
 718     {
 719         err = err | OCConvertSingleRepPayload(&rootMap, payload);
 720         payload = payload->next;
 721     }
 722
 723     // Close main array
 724     err = err | cbor_encoder_close_container(&encoder, &rootMap);
 725
 726     return checkError(err, &encoder, outPayload, size);
 727 }
 728
 729 static int64_t OCConvertPresencePayload(OCPresencePayload* payload,
 730         uint8_t* outPayload, size_t* size)
 731 {
 732     CborEncoder encoder = {0};
 733     int64_t err = 0;
 734
 735     cbor_encoder_init(&encoder, outPayload, *size, 0);
 736     CborEncoder map;
 737     err = err | cbor_encoder_create_map(&encoder, &map, CborIndefiniteLength);
 738
 739     // Sequence Number
 740     err = err | cbor_encode_text_string(&map,
 741             OC_RSRVD_NONCE,
 742             sizeof(OC_RSRVD_NONCE) - 1);
 743     err = err | cbor_encode_uint(&map, payload->sequenceNumber);
 744
 745     // Max Age
 746     err = err | cbor_encode_text_string(&map,
 747             OC_RSRVD_TTL,
 748             sizeof(OC_RSRVD_TTL) - 1);
 749     err = err | cbor_encode_uint(&map, payload->maxAge);
 750
 751     // Trigger
 752     const char* triggerStr = convertTriggerEnumToString(payload->trigger);
 753     err = err | AddTextStringToMap(&map, OC_RSRVD_TRIGGER, sizeof(OC_RSRVD_TRIGGER) - 1,
 754             triggerStr);
 755
 756     // Resource type name
 757     if(payload->trigger != OC_PRESENCE_TRIGGER_DELETE)
 758     {
 759         err = err | ConditionalAddTextStringToMap(&map, OC_RSRVD_RESOURCE_TYPE,
 760                 sizeof(OC_RSRVD_RESOURCE_TYPE) - 1, payload->resourceType);
 761     }
 762
 763     // Close Map
 764     err = err | cbor_encoder_close_container(&encoder, &map);
 765
 766     return checkError(err, &encoder, outPayload, size);
 767 }
 768
 769 static int64_t AddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
 770         const char* value)
 771 {
 772     return cbor_encode_text_string(map, key, keylen) |
 773            cbor_encode_text_string(map, value, strlen(value));
 774 }
 775
 776 static int64_t ConditionalAddTextStringToMap(CborEncoder* map, const char* key, size_t keylen,
 777         const char* value)
 778 {
 779     return value ? AddTextStringToMap(map, key, keylen, value) : 0;
 780 }