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