resource/csdk/stack/src/ocpayloadparse.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 // Defining _POSIX_C_SOURCE macro with 200112L (or greater) as value
  22 // causes header files to expose definitions
  23 // corresponding to the POSIX.1-2001 base
  24 // specification (excluding the XSI extension).
  25 // For POSIX.1-2001 base specification,
  26 // Refer http://pubs.opengroup.org/onlinepubs/009695399/
  27 // Required for strok_r
  28 #define _POSIX_C_SOURCE 200112L
  29
  30 #include <string.h>
  31 #include <stdlib.h>
  32 #include "ocpayload.h"
  33 #include "oic_string.h"
  34 #include "oic_malloc.h"
  35 #include "ocpayloadcbor.h"
  36 #include "ocstackinternal.h"
  37 #include "payload_logging.h"
  38 #include "platform_features.h"
  39 #include "ocendpoint.h"
  40
  41 #define TAG "OIC_RI_PAYLOADPARSE"
  42
  43 /*
  44  * The length of UINT64_MAX as a decimal string.
  45  */
  46 #define UINT64_MAX_STRLEN 20
  47
  48 static OCStackResult OCParseDiscoveryPayload(OCPayload **outPayload, CborValue *arrayVal);
  49 static CborError OCParseSingleRepPayload(OCRepPayload **outPayload, CborValue *repParent, bool isRoot);
  50 static OCStackResult OCParseRepPayload(OCPayload **outPayload, CborValue *arrayVal);
  51 static OCStackResult OCParsePresencePayload(OCPayload **outPayload, CborValue *arrayVal);
  52 static OCStackResult OCParseSecurityPayload(OCPayload **outPayload, const uint8_t *payload, size_t size);
  53
  54 OCStackResult OCParsePayload(OCPayload **outPayload, OCPayloadType payloadType,
  55         const uint8_t *payload, size_t payloadSize)
  56 {
  57     OCStackResult result = OC_STACK_MALFORMED_RESPONSE;
  58     CborError err;
  59
  60     VERIFY_PARAM_NON_NULL(TAG, outPayload, "Conversion of outPayload failed");
  61     VERIFY_PARAM_NON_NULL(TAG, payload, "Invalid cbor payload value");
  62
  63     OIC_LOG_V(INFO, TAG, "CBOR Parsing size: %zu of Payload Type: %d, Payload:",
  64             payloadSize, payloadType);
  65
  66     CborParser parser;
  67     CborValue rootValue;
  68
  69     err = cbor_parser_init(payload, payloadSize, 0, &parser, &rootValue);
  70     VERIFY_CBOR_SUCCESS(TAG, err, "Failed initializing init value")
  71
  72     switch(payloadType)
  73     {
  74         case PAYLOAD_TYPE_DISCOVERY:
  75             result = OCParseDiscoveryPayload(outPayload, &rootValue);
  76             break;
  77         case PAYLOAD_TYPE_REPRESENTATION:
  78             result = OCParseRepPayload(outPayload, &rootValue);
  79             break;
  80         case PAYLOAD_TYPE_PRESENCE:
  81             result = OCParsePresencePayload(outPayload, &rootValue);
  82             break;
  83         case PAYLOAD_TYPE_SECURITY:
  84             result = OCParseSecurityPayload(outPayload, payload, payloadSize);
  85             break;
  86         default:
  87             OIC_LOG_V(ERROR, TAG, "ParsePayload Type default: %d", payloadType);
  88             result = OC_STACK_INVALID_PARAM;
  89             break;
  90     }
  91
  92     OIC_LOG_V(INFO, TAG, "Finished parse payload, result is %d", result);
  93
  94 exit:
  95     return result;
  96 }
  97
  98 static OCStackResult OCParseSecurityPayload(OCPayload** outPayload, const uint8_t *payload,
  99         size_t size)
 100 {
 101     if (size > 0)
 102     {
 103         *outPayload = (OCPayload *)OCSecurityPayloadCreate(payload, size);
 104     }
 105     else
 106     {
 107         *outPayload = NULL;
 108     }
 109     return OC_STACK_OK;
 110 }
 111
 112 static char* InPlaceStringTrim(char* str)
 113 {
 114     while (str[0] == ' ')
 115     {
 116         ++str;
 117     }
 118
 119     size_t lastchar = strlen(str);
 120
 121     while (str[lastchar] == ' ')
 122     {
 123         str[lastchar] = '\0';
 124         --lastchar;
 125     }
 126
 127     return str;
 128 }
 129
 130 static CborError OCParseStringLL(CborValue *map, char *type, OCStringLL **resource)
 131 {
 132     CborValue val;
 133     CborError err = cbor_value_map_find_value(map, type, &val);
 134     VERIFY_CBOR_SUCCESS(TAG, err, "to find StringLL TAG");
 135
 136     if (cbor_value_is_array(&val))
 137     {
 138         CborValue txtStr;
 139         err = cbor_value_enter_container(&val, &txtStr);
 140         VERIFY_CBOR_SUCCESS(TAG, err, "to enter container");
 141         while (cbor_value_is_text_string(&txtStr))
 142         {
 143             size_t len = 0;
 144             char *input = NULL;
 145             err = cbor_value_dup_text_string(&txtStr, &input, &len, NULL);
 146             VERIFY_CBOR_SUCCESS(TAG, err, "to find StringLL value.");
 147             if (input)
 148             {
 149                 char *savePtr = NULL;
 150                 char *curPtr = strtok_r(input, " ", &savePtr);
 151                 while (curPtr)
 152                 {
 153                     char *trimmed = InPlaceStringTrim(curPtr);
 154                     if (trimmed && strlen(trimmed) > 0)
 155                     {
 156                         if (!OCResourcePayloadAddStringLL(resource, trimmed))
 157                         {
 158                             return CborErrorOutOfMemory;
 159                         }
 160                     }
 161                     curPtr = strtok_r(NULL, " ", &savePtr);
 162                 }
 163                 free(input);  // Free *TinyCBOR allocated* string.
 164             }
 165             if (cbor_value_is_text_string(&txtStr))
 166             {
 167                 err = cbor_value_advance(&txtStr);
 168                 VERIFY_CBOR_SUCCESS(TAG, err, "to advance string value");
 169             }
 170         }
 171     }
 172 exit:
 173     return err;
 174 }
 175
 176 static OCStackResult OCParseDiscoveryPayload(OCPayload **outPayload, CborValue *rootValue)
 177 {
 178     OCStackResult ret = OC_STACK_INVALID_PARAM;
 179     OCResourcePayload *resource = NULL;
 180     OCDiscoveryPayload *temp = NULL;
 181     OCDiscoveryPayload *rootPayload = NULL;
 182     OCDiscoveryPayload *curPayload = NULL;
 183     OCEndpointPayload *endpoint = NULL;
 184     size_t len = 0;
 185     CborError err = CborNoError;
 186     *outPayload = NULL;
 187
 188     VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload");
 189     VERIFY_PARAM_NON_NULL(TAG, rootValue, "Invalid Parameter rootValue");
 190     if (cbor_value_is_array(rootValue))
 191     {
 192         // Root value is already inside the main root array
 193         CborValue rootMap;
 194
 195         // Enter the main root map
 196         ret = OC_STACK_MALFORMED_RESPONSE;
 197         err = cbor_value_enter_container(rootValue, &rootMap);
 198         VERIFY_CBOR_SUCCESS(TAG, err, "to enter root map container");
 199         while (cbor_value_is_map(&rootMap))
 200         {
 201             ret = OC_STACK_NO_MEMORY;
 202             temp = OCDiscoveryPayloadCreate();
 203             VERIFY_PARAM_NON_NULL(TAG, temp, "Failed error initializing discovery payload");
 204
 205             // Look for DI
 206             CborValue curVal;
 207             err = cbor_value_map_find_value(&rootMap, OC_RSRVD_DEVICE_ID, &curVal);
 208             VERIFY_CBOR_SUCCESS(TAG, err, "to find device id tag");
 209             if (cbor_value_is_valid(&curVal))
 210             {
 211                 if (cbor_value_is_byte_string(&curVal))
 212                 {
 213                     err = cbor_value_dup_byte_string(&curVal, (uint8_t **)&(temp->sid), &len, NULL);
 214                     VERIFY_CBOR_SUCCESS(TAG, err, "to copy device id value");
 215                 }
 216                 else if (cbor_value_is_text_string(&curVal))
 217                 {
 218                     err = cbor_value_dup_text_string(&curVal, &(temp->sid), &len, NULL);
 219                     VERIFY_CBOR_SUCCESS(TAG, err, "to copy device id value");
 220                 }
 221             }
 222
 223             // BaseURI - Not a mandatory field
 224             err = cbor_value_map_find_value(&rootMap, OC_RSRVD_BASE_URI, &curVal);
 225             VERIFY_CBOR_SUCCESS(TAG, err, "to find uri tag");
 226             if (cbor_value_is_text_string(&curVal))
 227             {
 228                 err = cbor_value_dup_text_string(&curVal, &(temp->baseURI), &len, NULL);
 229                 VERIFY_CBOR_SUCCESS(TAG, err, "to find base uri value");
 230             }
 231
 232             // RT - Not a mandatory field
 233             err = cbor_value_map_find_value(&rootMap, OC_RSRVD_RESOURCE_TYPE, &curVal);
 234             if (cbor_value_is_valid(&curVal))
 235             {
 236                 err = OCParseStringLL(&rootMap, OC_RSRVD_RESOURCE_TYPE, &temp->type);
 237                 VERIFY_CBOR_SUCCESS(TAG, err, "to find resource type");
 238             }
 239
 240             // IF - Not a mandatory field
 241             err = cbor_value_map_find_value(&rootMap, OC_RSRVD_INTERFACE, &curVal);
 242             if (cbor_value_is_valid(&curVal))
 243             {
 244                 err =  OCParseStringLL(&rootMap, OC_RSRVD_INTERFACE, &temp->iface);
 245                 VERIFY_CBOR_SUCCESS(TAG, err, "to find interface");
 246             }
 247
 248             // Name - Not a mandatory field
 249             err = cbor_value_map_find_value(&rootMap, OC_RSRVD_DEVICE_NAME, &curVal);
 250             if (cbor_value_is_text_string(&curVal))
 251             {
 252                 err = cbor_value_dup_text_string(&curVal, &temp->name, &len, NULL);
 253                 VERIFY_CBOR_SUCCESS(TAG, err, "to find device name");
 254             }
 255
 256             // Look for Links which will have an array as the value
 257             CborValue linkMap;
 258             err = cbor_value_map_find_value(&rootMap, OC_RSRVD_LINKS, &linkMap);
 259             VERIFY_CBOR_SUCCESS(TAG, err, "to find links tag");
 260
 261             // Enter the links array and start iterating through the array processing
 262             // each resource which shows up as a map.
 263             CborValue resourceMap;
 264             err = cbor_value_enter_container(&linkMap, &resourceMap);
 265             VERIFY_CBOR_SUCCESS(TAG, err, "to enter link map");
 266
 267             while (cbor_value_is_map(&resourceMap))
 268             {
 269                 int bitmap;
 270
 271                 resource = (OCResourcePayload *)OICCalloc(1, sizeof(OCResourcePayload));
 272                 VERIFY_PARAM_NON_NULL(TAG, resource, "Failed allocating resource payload");
 273
 274                 // Uri
 275                 err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_HREF, &curVal);
 276                 VERIFY_CBOR_SUCCESS(TAG, err, "to find href tag");
 277                 err = cbor_value_dup_text_string(&curVal, &(resource->uri), &len, NULL);
 278                 VERIFY_CBOR_SUCCESS(TAG, err, "to find href value");
 279
 280                 // Rel - Not a mandatory field
 281                 err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_REL, &curVal);
 282                 VERIFY_CBOR_SUCCESS(TAG, err, "to find rel tag");
 283                 if (cbor_value_is_valid(&curVal))
 284                 {
 285                     err = cbor_value_dup_text_string(&curVal, &(resource->rel), &len, NULL);
 286                     VERIFY_CBOR_SUCCESS(TAG, err, "to find rel value");
 287                 }
 288
 289                 // ResourceTypes
 290                 err =  OCParseStringLL(&resourceMap, OC_RSRVD_RESOURCE_TYPE, &resource->types);
 291                 VERIFY_CBOR_SUCCESS(TAG, err, "to find resource type tag/value");
 292
 293                 // Interface Types
 294                 err =  OCParseStringLL(&resourceMap, OC_RSRVD_INTERFACE, &resource->interfaces);
 295                 if (CborNoError != err)
 296                 {
 297                     if (!OCResourcePayloadAddStringLL(&resource->interfaces, OC_RSRVD_INTERFACE_LL))
 298                     {
 299                         OIC_LOG(ERROR, TAG, "Failed to add string to StringLL");
 300                         goto exit;
 301                     }
 302                 }
 303
 304                 // Policy
 305                 CborValue policyMap;
 306                 err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_POLICY, &policyMap);
 307                 VERIFY_CBOR_SUCCESS(TAG, err, "to find policy tag");
 308
 309                 // Bitmap
 310                 err = cbor_value_map_find_value(&policyMap, OC_RSRVD_BITMAP, &curVal);
 311                 VERIFY_CBOR_SUCCESS(TAG, err, "to find bitmap tag");
 312                 err = cbor_value_get_int(&curVal, &bitmap);
 313                 VERIFY_CBOR_SUCCESS(TAG, err, "to find bitmap value");
 314                 resource->bitmap = (uint8_t)bitmap;
 315
 316                 // Secure Flag
 317                 err = cbor_value_map_find_value(&policyMap, OC_RSRVD_SECURE, &curVal);
 318                 VERIFY_CBOR_SUCCESS(TAG, err, "to find secure tag");
 319                 if (cbor_value_is_boolean(&curVal))
 320                 {
 321                     err = cbor_value_get_boolean(&curVal, &(resource->secure));
 322                     VERIFY_CBOR_SUCCESS(TAG, err, "to find secure value");
 323                 }
 324
 325                 // Port
 326                 err = cbor_value_map_find_value(&policyMap, OC_RSRVD_HOSTING_PORT, &curVal);
 327                 VERIFY_CBOR_SUCCESS(TAG, err, "to find port tag");
 328                 if (cbor_value_is_integer(&curVal))
 329                 {
 330                     int port;
 331
 332                     err = cbor_value_get_int(&curVal, &port);
 333                     VERIFY_CBOR_SUCCESS(TAG, err, "to find port value");
 334                     resource->port = (uint16_t)port;
 335                 }
 336
 337 #ifdef TCP_ADAPTER
 338                 // TCP Port
 339                 err = cbor_value_map_find_value(&policyMap, OC_RSRVD_TCP_PORT, &curVal);
 340                 if (cbor_value_is_integer(&curVal))
 341                 {
 342                     int tcpPort;
 343
 344                     err = cbor_value_get_int(&curVal, &tcpPort);
 345                     VERIFY_CBOR_SUCCESS(TAG, err, "to find tcp port value");
 346                     resource->tcpPort = (uint16_t)tcpPort;
 347                 }
 348
 349 #ifdef __WITH_TLS__
 350                 // TLS Port
 351                 err = cbor_value_map_find_value(&policyMap, OC_RSRVD_TLS_PORT, &curVal);
 352                 if (cbor_value_is_integer(&curVal))
 353                 {
 354                     int tlsPort;
 355
 356                     err = cbor_value_get_int(&curVal, &tlsPort);
 357                     VERIFY_CBOR_SUCCESS(TAG, err, "to find tcp tls port value");
 358                     resource->tcpPort = (uint16_t)tlsPort;
 359                 }
 360 #endif
 361 #endif
 362                 // Endpoints
 363                 CborValue epsMap;
 364                 err = cbor_value_map_find_value(&resourceMap, OC_RSRVD_ENDPOINTS, &epsMap);
 365                 VERIFY_CBOR_SUCCESS(TAG, err, "to find eps tag");
 366
 367                 if (cbor_value_is_array(&epsMap))
 368                 {
 369                     CborValue epMap;
 370                     err = cbor_value_enter_container(&epsMap, &epMap);
 371                     VERIFY_CBOR_SUCCESS(TAG, err, "to enter endpoint map");
 372
 373                     while (cbor_value_is_map(&epMap))
 374                     {
 375                         endpoint = NULL;
 376                         int pri = 0;
 377                         char *endpointStr = NULL;
 378                         OCStackResult ret = OC_STACK_ERROR;
 379                         endpoint = (OCEndpointPayload *)OICCalloc(1, sizeof(OCEndpointPayload));
 380                         VERIFY_PARAM_NON_NULL(TAG, endpoint, "Failed allocating endpoint payload");
 381
 382                         // ep
 383                         err = cbor_value_map_find_value(&epMap, OC_RSRVD_ENDPOINT, &curVal);
 384                         VERIFY_CBOR_SUCCESS(TAG, err, "to find endpoint tag");
 385                         err = cbor_value_dup_text_string(&curVal, &endpointStr, &len, NULL);
 386                         VERIFY_CBOR_SUCCESS(TAG, err, "to find endpoint value");
 387
 388                         ret = OCParseEndpointString(endpointStr, endpoint);
 389                         OICFree(endpointStr);
 390
 391                         if (OC_STACK_OK == ret)
 392                         {
 393                             // pri
 394                             err = cbor_value_map_find_value(&epMap, OC_RSRVD_PRIORITY, &curVal);
 395                             VERIFY_CBOR_SUCCESS(TAG, err, "to find priority tag");
 396                             err = cbor_value_get_int(&curVal, &pri);
 397                             VERIFY_CBOR_SUCCESS(TAG, err, "to find priority value");
 398                             endpoint->pri = (uint16_t)pri;
 399                             OCResourcePayloadAddNewEndpoint(resource, endpoint);
 400                             endpoint = NULL;
 401                         }
 402                         else
 403                         {
 404                             if (OC_STACK_ADAPTER_NOT_ENABLED == ret)
 405                             {
 406                                 OIC_LOG(ERROR, TAG, "Ignore unrecognized endpoint info");
 407                             }
 408                             // destroy endpoint
 409                             OCDiscoveryEndpointDestroy(endpoint);
 410                             endpoint = NULL;
 411                         }
 412
 413                         err = cbor_value_advance(&epMap);
 414                         VERIFY_CBOR_SUCCESS(TAG, err, "to advance endpoint map");
 415                     }
 416
 417                     err = cbor_value_leave_container(&epsMap, &epMap);
 418                     VERIFY_CBOR_SUCCESS(TAG, err, "to leave eps map");
 419                 }
 420
 421                 err = cbor_value_advance(&resourceMap);
 422                 VERIFY_CBOR_SUCCESS(TAG, err, "to advance resource map");
 423
 424                 OCDiscoveryPayloadAddNewResource(temp, resource);
 425             }
 426
 427             err = cbor_value_leave_container(&linkMap, &resourceMap);
 428             VERIFY_CBOR_SUCCESS(TAG, err, "to leave resource map");
 429
 430             err = cbor_value_advance(&rootMap);
 431             VERIFY_CBOR_SUCCESS(TAG, err, "to advance root map");
 432
 433             if(rootPayload == NULL)
 434             {
 435                 rootPayload = temp;
 436                 curPayload = temp;
 437             }
 438             else
 439             {
 440                 curPayload->next = temp;
 441                 curPayload = curPayload->next;
 442             }
 443         }
 444
 445         err = cbor_value_leave_container(rootValue, &rootMap);
 446         VERIFY_CBOR_SUCCESS(TAG, err, "to leave root map");
 447
 448     }
 449     else
 450     {
 451         OIC_LOG(ERROR, TAG, "Malformed packet ");
 452         goto exit;
 453     }
 454
 455     *outPayload = (OCPayload *)rootPayload;
 456     OIC_LOG_PAYLOAD(DEBUG, *outPayload);
 457
 458     return OC_STACK_OK;
 459
 460 exit:
 461     OCDiscoveryEndpointDestroy(endpoint);
 462     OCDiscoveryResourceDestroy(resource);
 463     OCDiscoveryPayloadDestroy(rootPayload);
 464     return ret;
 465 }
 466
 467 static OCRepPayloadPropType DecodeCborType(CborType type)
 468 {
 469     switch (type)
 470     {
 471         case CborNullType:
 472             return OCREP_PROP_NULL;
 473         case CborIntegerType:
 474             return OCREP_PROP_INT;
 475         case CborDoubleType:
 476         case CborFloatType:
 477             return OCREP_PROP_DOUBLE;
 478         case CborBooleanType:
 479             return OCREP_PROP_BOOL;
 480         case CborTextStringType:
 481             return OCREP_PROP_STRING;
 482         case CborByteStringType:
 483             return OCREP_PROP_BYTE_STRING;
 484         case CborMapType:
 485             return OCREP_PROP_OBJECT;
 486         case CborArrayType:
 487             return OCREP_PROP_ARRAY;
 488         default:
 489             return OCREP_PROP_NULL;
 490     }
 491 }
 492
 493 static CborError OCParseArrayFindDimensionsAndType(const CborValue *parent,
 494         size_t dimensions[MAX_REP_ARRAY_DEPTH], OCRepPayloadPropType *type)
 495 {
 496     CborValue insideArray;
 497     *type = OCREP_PROP_NULL;
 498     dimensions[0] = dimensions[1] = dimensions[2] = 0;
 499
 500     CborError err = cbor_value_enter_container(parent, &insideArray);
 501     VERIFY_CBOR_SUCCESS(TAG, err, "Failed to enter container");
 502
 503     while (cbor_value_is_valid(&insideArray))
 504     {
 505         OCRepPayloadPropType tempType = DecodeCborType(cbor_value_get_type(&insideArray));
 506
 507         if (tempType == OCREP_PROP_ARRAY)
 508         {
 509             size_t subdim[MAX_REP_ARRAY_DEPTH];
 510             tempType = OCREP_PROP_NULL;
 511             err = OCParseArrayFindDimensionsAndType(&insideArray, subdim, &tempType);
 512             VERIFY_CBOR_SUCCESS(TAG, err, "Failed to parse array");
 513
 514             if (subdim[2] != 0)
 515             {
 516                 OIC_LOG(ERROR, TAG, "Parse array helper, sub-array too deep");
 517             }
 518
 519             dimensions[1] = dimensions[1] >= subdim[0] ? dimensions[1] : subdim[0];
 520             dimensions[2] = dimensions[2] >= subdim[1] ? dimensions[2] : subdim[1];
 521
 522             if (*type != OCREP_PROP_NULL && tempType != OCREP_PROP_NULL && *type != tempType)
 523             {
 524                 OIC_LOG(ERROR, TAG, "Array parse failed, mixed arrays not allowed (subtype)");
 525                 return CborUnknownError;
 526             }
 527             else if (*type == OCREP_PROP_NULL)
 528             {
 529                 // We don't know the type of this array yet, so the assignment is OK
 530                 *type = tempType;
 531             }
 532         }
 533         else if (*type == OCREP_PROP_NULL)
 534         {
 535             // We don't know the type of this array yet, so the assignment is OK
 536             *type = tempType;
 537         }
 538         // tempType is allowed to be NULL, since it might now know the answer yet
 539         else if (tempType != OCREP_PROP_NULL && *type != tempType)
 540         {
 541             // this is an invalid situation!
 542             OIC_LOG(ERROR, TAG, "Array parse failed, mixed arrays not allowed");
 543             return CborUnknownError;
 544         }
 545
 546         ++dimensions[0];
 547         err = cbor_value_advance(&insideArray);
 548         VERIFY_CBOR_SUCCESS(TAG, err, "Failed to advance array");
 549     }
 550
 551 exit:
 552     return err;
 553 }
 554
 555 static size_t getAllocSize(OCRepPayloadPropType type)
 556 {
 557     switch (type)
 558     {
 559         case OCREP_PROP_INT:
 560             return sizeof (int64_t);
 561         case OCREP_PROP_DOUBLE:
 562             return sizeof (double);
 563         case OCREP_PROP_BOOL:
 564             return sizeof (bool);
 565         case OCREP_PROP_STRING:
 566             return sizeof (char*);
 567         case OCREP_PROP_BYTE_STRING:
 568             return sizeof (OCByteString);
 569         case OCREP_PROP_OBJECT:
 570             return sizeof (OCRepPayload*);
 571         default:
 572             return 0;
 573     }
 574 }
 575
 576 static size_t arrayStep(size_t dimensions[MAX_REP_ARRAY_DEPTH], size_t elementNum)
 577 {
 578     return
 579         (dimensions[1] == 0 ? 1 : dimensions[1]) *
 580         (dimensions[2] == 0 ? 1 : dimensions[2]) *
 581         elementNum;
 582 }
 583
 584 static CborError OCParseArrayFillArray(const CborValue *parent,
 585         size_t dimensions[MAX_REP_ARRAY_DEPTH], OCRepPayloadPropType type, void *targetArray)
 586 {
 587     CborValue insideArray;
 588
 589     size_t i = 0;
 590     char *tempStr = NULL;
 591     OCByteString ocByteStr = { .bytes = NULL, .len = 0};
 592     size_t tempLen = 0;
 593     OCRepPayload *tempPl = NULL;
 594
 595     size_t newdim[MAX_REP_ARRAY_DEPTH];
 596     newdim[0] = dimensions[1];
 597     newdim[1] = dimensions[2];
 598     newdim[2] = 0;
 599
 600     CborError err = cbor_value_enter_container(parent, &insideArray);
 601     VERIFY_CBOR_SUCCESS(TAG, err, "Failed to enter container");
 602
 603     while (!err && i < dimensions[0] && cbor_value_is_valid(&insideArray))
 604     {
 605         bool noAdvance = false;
 606         if (cbor_value_get_type(&insideArray) != CborNullType)
 607         {
 608             switch (type)
 609             {
 610                 case OCREP_PROP_INT:
 611                     if (dimensions[1] == 0)
 612                     {
 613                         err = cbor_value_get_int64(&insideArray, &(((int64_t*)targetArray)[i]));
 614                     }
 615                     else
 616                     {
 617                         err = OCParseArrayFillArray(&insideArray, newdim, type,
 618                             &(((int64_t*)targetArray)[arrayStep(dimensions, i)]));
 619                     }
 620                     break;
 621                 case OCREP_PROP_DOUBLE:
 622                     if (dimensions[1] == 0)
 623                     {
 624                         double *d = &(((double*)targetArray)[i]);
 625                         if (cbor_value_get_type(&insideArray) == CborDoubleType)
 626                         {
 627                             err = cbor_value_get_double(&insideArray, d);
 628                         }
 629                         else
 630                         {
 631                             /* must be float */
 632                             float f;
 633                             err = cbor_value_get_float(&insideArray, &f);
 634                             if (!err)
 635                                 *d = f;
 636                         }
 637                     }
 638                     else
 639                     {
 640                         err = OCParseArrayFillArray(&insideArray, newdim, type,
 641                             &(((double*)targetArray)[arrayStep(dimensions, i)]));
 642                     }
 643                     break;
 644                 case OCREP_PROP_BOOL:
 645                     if (dimensions[1] == 0)
 646                     {
 647                         err = cbor_value_get_boolean(&insideArray, &(((bool*)targetArray)[i]));
 648                     }
 649                     else
 650                     {
 651                         err = OCParseArrayFillArray(&insideArray, newdim, type,
 652                             &(((bool*)targetArray)[arrayStep(dimensions, i)]));
 653                     }
 654                     break;
 655                 case OCREP_PROP_STRING:
 656                     if (dimensions[1] == 0)
 657                     {
 658                         err = cbor_value_dup_text_string(&insideArray, &tempStr, &tempLen, NULL);
 659                         ((char**)targetArray)[i] = tempStr;
 660                         tempStr = NULL;
 661                     }
 662                     else
 663                     {
 664                         err = OCParseArrayFillArray(&insideArray, newdim, type,
 665                             &(((char**)targetArray)[arrayStep(dimensions, i)]));
 666                     }
 667                     break;
 668                 case OCREP_PROP_BYTE_STRING:
 669                     if (dimensions[1] == 0)
 670                     {
 671                         err = cbor_value_dup_byte_string(&insideArray, &(ocByteStr.bytes),
 672                                 &(ocByteStr.len), NULL);
 673                         ((OCByteString*)targetArray)[i] = ocByteStr;
 674                     }
 675                     else
 676                     {
 677                         err = OCParseArrayFillArray(&insideArray, newdim, type,
 678                                 &(((OCByteString*)targetArray)[arrayStep(dimensions, i)]));
 679                     }
 680                     break;
 681                 case OCREP_PROP_OBJECT:
 682                     if (dimensions[1] == 0)
 683                     {
 684                         err = OCParseSingleRepPayload(&tempPl, &insideArray, false);
 685                         ((OCRepPayload**)targetArray)[i] = tempPl;
 686                         tempPl = NULL;
 687                         noAdvance = true;
 688                     }
 689                     else
 690                     {
 691                         err = OCParseArrayFillArray(&insideArray, newdim, type,
 692                             &(((OCRepPayload**)targetArray)[arrayStep(dimensions, i)]));
 693                     }
 694                     break;
 695                 default:
 696                     OIC_LOG(ERROR, TAG, "Invalid Array type in Parse Array");
 697                     err = CborErrorUnknownType;
 698                     break;
 699             }
 700             VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting repPayload");
 701         }
 702         ++i;
 703         if (!noAdvance && cbor_value_is_valid(&insideArray))
 704         {
 705             err = cbor_value_advance(&insideArray);
 706             VERIFY_CBOR_SUCCESS(TAG, err, "Failed advnce insideArray");
 707         }
 708     }
 709
 710 exit:
 711     return err;
 712 }
 713
 714 static CborError OCParseArray(OCRepPayload *out, const char *name, CborValue *container)
 715 {
 716     void *arr = NULL;
 717
 718     OCRepPayloadPropType type = OCREP_PROP_NULL;
 719     size_t dimensions[MAX_REP_ARRAY_DEPTH] = { 0 };
 720
 721     size_t dimTotal = 0;
 722     size_t allocSize = 0;
 723     bool res = true;
 724     CborError err = OCParseArrayFindDimensionsAndType(container, dimensions, &type);
 725     VERIFY_CBOR_SUCCESS(TAG, err, "Array details weren't clear");
 726
 727     if (type == OCREP_PROP_NULL)
 728     {
 729         res = OCRepPayloadSetNull(out, name);
 730         err = (CborError) !res;
 731         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting value");
 732         return err;
 733     }
 734
 735     dimTotal = calcDimTotal(dimensions);
 736     allocSize = getAllocSize(type);
 737     arr = OICCalloc(dimTotal, allocSize);
 738     VERIFY_PARAM_NON_NULL(TAG, arr, "Array Parse allocation failed");
 739
 740     res = OCParseArrayFillArray(container, dimensions, type, arr);
 741     VERIFY_CBOR_SUCCESS(TAG, err, "Failed parse array");
 742
 743     switch (type)
 744     {
 745         case OCREP_PROP_INT:
 746             res = OCRepPayloadSetIntArrayAsOwner(out, name, (int64_t *)arr, dimensions);
 747             break;
 748         case OCREP_PROP_DOUBLE:
 749             res = OCRepPayloadSetDoubleArrayAsOwner(out, name, (double *)arr, dimensions);
 750             break;
 751         case OCREP_PROP_BOOL:
 752             res = OCRepPayloadSetBoolArrayAsOwner(out, name, (bool *)arr, dimensions);
 753             break;
 754         case OCREP_PROP_STRING:
 755             res = OCRepPayloadSetStringArrayAsOwner(out, name, (char **)arr, dimensions);
 756             break;
 757         case OCREP_PROP_BYTE_STRING:
 758             res = OCRepPayloadSetByteStringArrayAsOwner(out, name, (OCByteString *)arr, dimensions);
 759             break;
 760         case OCREP_PROP_OBJECT:
 761             res = OCRepPayloadSetPropObjectArrayAsOwner(out, name, (OCRepPayload**)arr, dimensions);
 762             break;
 763         default:
 764             OIC_LOG(ERROR, TAG, "Invalid Array type in Parse Array");
 765             break;
 766     }
 767     err = (CborError) !res;
 768     VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting array parameter");
 769     return CborNoError;
 770 exit:
 771     if (type == OCREP_PROP_STRING)
 772     {
 773         for(size_t i = 0; i < dimTotal; ++i)
 774         {
 775             OICFree(((char**)arr)[i]);
 776         }
 777     }
 778     if (type == OCREP_PROP_BYTE_STRING)
 779     {
 780         for(size_t i = 0; i < dimTotal; ++i)
 781         {
 782             OICFree(((OCByteString*)arr)[i].bytes);
 783         }
 784     }
 785     if (type == OCREP_PROP_OBJECT)
 786     {
 787         for(size_t i = 0; i < dimTotal; ++i)
 788         {
 789             OCRepPayloadDestroy(((OCRepPayload**)arr)[i]);
 790         }
 791     }
 792     OICFree(arr);
 793     return err;
 794 }
 795
 796 static CborError OCParseSingleRepPayload(OCRepPayload **outPayload, CborValue *objMap, bool isRoot)
 797 {
 798     CborError err = CborUnknownError;
 799     char *name = NULL;
 800     bool res = false;
 801     VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload");
 802     VERIFY_PARAM_NON_NULL(TAG, objMap, "Invalid Parameter objMap");
 803
 804     if (cbor_value_is_map(objMap) || cbor_value_is_array(objMap))
 805     {
 806         if (!*outPayload)
 807         {
 808             *outPayload = OCRepPayloadCreate();
 809             if (!*outPayload)
 810             {
 811                 return CborErrorOutOfMemory;
 812             }
 813         }
 814
 815         OCRepPayload *curPayload = *outPayload;
 816
 817         uint64_t arrayIndex = 0;
 818         size_t len = 0;
 819         CborValue repMap;
 820         err = cbor_value_enter_container(objMap, &repMap);
 821         VERIFY_CBOR_SUCCESS(TAG, err, "Failed entering repMap");
 822
 823         while (!err && cbor_value_is_valid(&repMap))
 824         {
 825             if (cbor_value_is_map(objMap) && cbor_value_is_text_string(&repMap))
 826             {
 827                 err = cbor_value_dup_text_string(&repMap, &name, &len, NULL);
 828                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding tag name in the map");
 829                 err = cbor_value_advance(&repMap);
 830                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed advancing rootMap");
 831                 if (name &&
 832                     isRoot &&
 833                     ((0 == strcmp(OC_RSRVD_HREF, name)) ||
 834                      (0 == strcmp(OC_RSRVD_RESOURCE_TYPE, name)) ||
 835                     (0 == strcmp(OC_RSRVD_INTERFACE, name))))
 836                 {
 837                     err = cbor_value_advance(&repMap);
 838                     free(name);  // Free *TinyCBOR allocated* string.
 839                     name = NULL;
 840                     continue;
 841                 }
 842             }
 843             else if (cbor_value_is_array(objMap))
 844             {
 845                 name = (char*)OICCalloc(UINT64_MAX_STRLEN + 1, sizeof(char));
 846                 VERIFY_PARAM_NON_NULL(TAG, name, "Failed allocating tag name in the map");
 847 #ifdef PRIu64
 848                 snprintf(name, UINT64_MAX_STRLEN + 1, "%" PRIu64, arrayIndex);
 849 #else
 850                 /*
 851                  * Some libc implementations do not support the PRIu64 format
 852                  * specifier.  Since we don't expect huge heterogeneous arrays,
 853                  * we should never hit the error path below in practice.
 854                  */
 855                 if (arrayIndex <= UINT32_MAX)
 856                 {
 857                     snprintf(name, UINT64_MAX_STRLEN + 1, "%" PRIu32, (uint32_t)arrayIndex);
 858                 }
 859                 else
 860                 {
 861                     err = CborErrorDataTooLarge;
 862                     OICFree(name);
 863                     continue;
 864                 }
 865 #endif
 866             }
 867             CborType type = cbor_value_get_type(&repMap);
 868             switch (type)
 869             {
 870                 case CborNullType:
 871                     res = OCRepPayloadSetNull(curPayload, name);
 872                     break;
 873                 case CborIntegerType:
 874                     {
 875                         int64_t intval = 0;
 876                         err = cbor_value_get_int64(&repMap, &intval);
 877                         VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting int value");
 878                         res = OCRepPayloadSetPropInt(curPayload, name, intval);
 879                     }
 880                     break;
 881                 case CborDoubleType:
 882                     {
 883                         double doubleval = 0;
 884                         err = cbor_value_get_double(&repMap, &doubleval);
 885                         VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting double value");
 886                         res = OCRepPayloadSetPropDouble(curPayload, name, doubleval);
 887                     }
 888                     break;
 889                 case CborBooleanType:
 890                     {
 891                         bool boolval = false;
 892                         err = cbor_value_get_boolean(&repMap, &boolval);
 893                         VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting boolean value");
 894                         res = OCRepPayloadSetPropBool(curPayload, name, boolval);
 895                     }
 896                     break;
 897                 case CborTextStringType:
 898                     {
 899                         char *strval = NULL;
 900                         err = cbor_value_dup_text_string(&repMap, &strval, &len, NULL);
 901                         VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting string value");
 902                         res = OCRepPayloadSetPropStringAsOwner(curPayload, name, strval);
 903                     }
 904                     break;
 905                 case CborByteStringType:
 906                     {
 907                         uint8_t* bytestrval = NULL;
 908                         err = cbor_value_dup_byte_string(&repMap, &bytestrval, &len, NULL);
 909                         VERIFY_CBOR_SUCCESS(TAG, err, "Failed getting byte string value");
 910                         OCByteString tmp = {.bytes = bytestrval, .len = len};
 911                         res = OCRepPayloadSetPropByteStringAsOwner(curPayload, name, &tmp);
 912                     }
 913                     break;
 914                 case CborMapType:
 915                     {
 916                         OCRepPayload *pl = NULL;
 917                         err = OCParseSingleRepPayload(&pl, &repMap, false);
 918                         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting parse single rep");
 919                         res = OCRepPayloadSetPropObjectAsOwner(curPayload, name, pl);
 920                     }
 921                     break;
 922                 case CborArrayType:
 923                     err = OCParseArray(curPayload, name, &repMap);
 924                     if (err != CborNoError)
 925                     {
 926                         // OCParseArray will fail if the array contains mixed types, try
 927                         // to parse as payload with non-negative integer value names
 928                         OCRepPayload *pl = NULL;
 929                         err = OCParseSingleRepPayload(&pl, &repMap, false);
 930                         VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting parse single rep");
 931                         res = OCRepPayloadSetPropObjectAsOwner(curPayload, name, pl);
 932                     }
 933                     break;
 934                 default:
 935                     OIC_LOG_V(ERROR, TAG, "Parsing rep property, unknown type %d", repMap.type);
 936                     res = false;
 937             }
 938             if (type != CborArrayType)
 939             {
 940                 err = (CborError) !res;
 941             }
 942             VERIFY_CBOR_SUCCESS(TAG, err, "Failed setting value");
 943
 944             if (type != CborMapType && cbor_value_is_valid(&repMap))
 945             {
 946                 err = cbor_value_advance(&repMap);
 947                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed advance repMap");
 948             }
 949             OICFree(name);
 950             name = NULL;
 951             ++arrayIndex;
 952         }
 953         if (cbor_value_is_container(objMap))
 954         {
 955             err = cbor_value_leave_container(objMap, &repMap);
 956             VERIFY_CBOR_SUCCESS(TAG, err, "Failed to leave container");
 957         }
 958         return err;
 959     }
 960
 961 exit:
 962     OICFree(name);
 963     OCRepPayloadDestroy(*outPayload);
 964     *outPayload = NULL;
 965     return err;
 966 }
 967
 968 static OCStackResult OCParseRepPayload(OCPayload **outPayload, CborValue *root)
 969 {
 970     OCStackResult ret = OC_STACK_INVALID_PARAM;
 971     CborError err;
 972     OCRepPayload *temp = NULL;
 973     OCRepPayload *rootPayload = NULL;
 974     OCRepPayload *curPayload = NULL;
 975     CborValue rootMap = *root;
 976     VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload");
 977     VERIFY_PARAM_NON_NULL(TAG, root, "Invalid Parameter root");
 978
 979     *outPayload = NULL;
 980     if (cbor_value_is_array(root))
 981     {
 982         err = cbor_value_enter_container(root, &rootMap);
 983         VERIFY_CBOR_SUCCESS(TAG, err, "Failed entering repMap");
 984     }
 985     while (cbor_value_is_valid(&rootMap))
 986     {
 987         temp = OCRepPayloadCreate();
 988         ret = OC_STACK_NO_MEMORY;
 989         VERIFY_PARAM_NON_NULL(TAG, temp, "Failed allocating memory");
 990
 991         CborValue curVal;
 992         ret = OC_STACK_MALFORMED_RESPONSE;
 993
 994         // temporary fix to check for malformed cbor payload
 995         if (!cbor_value_is_map(&rootMap) && !cbor_value_is_array(&rootMap)){
 996             goto exit;
 997         }
 998
 999         if (cbor_value_is_map(&rootMap))
1000         {
1001             err = cbor_value_map_find_value(&rootMap, OC_RSRVD_HREF, &curVal);
1002             VERIFY_CBOR_SUCCESS(TAG, err, "to find href tag");
1003             if (cbor_value_is_text_string(&curVal))
1004             {
1005                 size_t len = 0;
1006                 err = cbor_value_dup_text_string(&curVal, &temp->uri, &len, NULL);
1007                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find uri");
1008             }
1009         }
1010
1011         // Resource types
1012         if (cbor_value_is_map(&rootMap))
1013         {
1014             if (CborNoError == cbor_value_map_find_value(&rootMap, OC_RSRVD_RESOURCE_TYPE, &curVal))
1015             {
1016                 err =  OCParseStringLL(&rootMap, OC_RSRVD_RESOURCE_TYPE, &temp->types);
1017                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find rt type tag/value");
1018             }
1019         }
1020
1021         // Interface Types
1022         if (cbor_value_is_map(&rootMap))
1023         {
1024             if (CborNoError == cbor_value_map_find_value(&rootMap, OC_RSRVD_INTERFACE, &curVal))
1025             {
1026                 err =  OCParseStringLL(&rootMap, OC_RSRVD_INTERFACE, &temp->interfaces);
1027                 VERIFY_CBOR_SUCCESS(TAG, err, "Failed to find interfaces tag/value");
1028             }
1029         }
1030
1031         if (cbor_value_is_map(&rootMap))
1032         {
1033             err = OCParseSingleRepPayload(&temp, &rootMap, true);
1034             VERIFY_CBOR_SUCCESS(TAG, err, "Failed to parse single rep payload");
1035         }
1036
1037         if(rootPayload == NULL)
1038         {
1039             rootPayload = temp;
1040             curPayload = temp;
1041         }
1042         else
1043         {
1044             curPayload->next = temp;
1045             curPayload = curPayload->next;
1046         }
1047
1048         if (cbor_value_is_array(&rootMap))
1049         {
1050             err = cbor_value_advance(&rootMap);
1051             VERIFY_CBOR_SUCCESS(TAG, err, "Failed to advance single rep payload");
1052         }
1053     }
1054     *outPayload = (OCPayload *)rootPayload;
1055     return OC_STACK_OK;
1056
1057 exit:
1058     OCRepPayloadDestroy(temp);
1059     OCRepPayloadDestroy(rootPayload);
1060     OIC_LOG(ERROR, TAG, "CBOR error in ParseRepPayload");
1061     return ret;
1062 }
1063
1064 static OCStackResult OCParsePresencePayload(OCPayload **outPayload, CborValue *rootValue)
1065 {
1066     OCStackResult ret = OC_STACK_INVALID_PARAM;
1067     OCPresencePayload *payload = NULL;
1068     VERIFY_PARAM_NON_NULL(TAG, outPayload, "Invalid Parameter outPayload");
1069
1070     *outPayload = NULL;
1071
1072     payload = (OCPresencePayload *)OICCalloc(1, sizeof(OCPresencePayload));
1073     ret = OC_STACK_NO_MEMORY;
1074     VERIFY_PARAM_NON_NULL(TAG, payload, "Failed allocating presence payload");
1075     payload->base.type = PAYLOAD_TYPE_PRESENCE;
1076     ret = OC_STACK_MALFORMED_RESPONSE;
1077
1078     if (cbor_value_is_map(rootValue))
1079     {
1080         CborValue curVal;
1081         uint64_t temp = 0;
1082         uint8_t trigger;
1083
1084         // Sequence Number
1085         CborError err = cbor_value_map_find_value(rootValue, OC_RSRVD_NONCE, &curVal);
1086         VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding nonce tag");
1087         err = cbor_value_get_uint64(&curVal, &temp);
1088         payload->sequenceNumber = (uint32_t)temp;
1089         VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding nonce value");
1090
1091         // Max Age
1092         err = cbor_value_map_find_value(rootValue, OC_RSRVD_TTL, &curVal);
1093         VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding ttl tag");
1094         temp = 0;
1095         err = cbor_value_get_uint64(&curVal, &temp);
1096         payload->maxAge = (uint32_t)temp;
1097         VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding ttl value");
1098
1099         // Trigger
1100         err = cbor_value_map_find_value(rootValue, OC_RSRVD_TRIGGER, &curVal);
1101         VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding trigger tag");
1102         err = cbor_value_get_simple_type(&curVal, &trigger);
1103         VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding trigger value");
1104         payload->trigger = (OCPresenceTrigger)trigger;
1105
1106         // Resource type name
1107         err = cbor_value_map_find_value(rootValue, OC_RSRVD_RESOURCE_TYPE, &curVal);
1108         VERIFY_CBOR_SUCCESS(TAG, err, "to find res type tag");
1109         if (cbor_value_is_text_string(&curVal))
1110         {
1111             size_t len = 0;
1112             err = cbor_value_dup_text_string(&curVal, &payload->resourceType, &len, NULL);
1113             VERIFY_CBOR_SUCCESS(TAG, err, "Failed finding resource type value");
1114         }
1115
1116         err = cbor_value_advance(rootValue);
1117         VERIFY_CBOR_SUCCESS(TAG, err, "Failed advancing root value");
1118
1119         *outPayload = (OCPayload *)payload;
1120         return OC_STACK_OK;
1121     }
1122 exit:
1123     OIC_LOG(ERROR, TAG, "CBOR error Parse Presence Payload");
1124     OCPresencePayloadDestroy(payload);
1125     return ret;
1126 }