resource/csdk/connectivity/src/caprotocolmessage.c

   1 /******************************************************************
   2  *
   3  * Copyright 2014 Samsung Electronics 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 _BSD_SOURCE or _DEFAULT_SOURCE causes header files to expose
  22 // definitions that may otherwise be skipped. Skipping can cause implicit
  23 // declaration warnings and/or bugs and subtle problems in code execution.
  24 // For glibc information on feature test macros,
  25 // Refer http://www.gnu.org/software/libc/manual/html_node/Feature-Test-Macros.html
  26 //
  27 // For details on compatibility and glibc support,
  28 // Refer http://www.gnu.org/software/libc/manual/html_node/BSD-Random.html
  29 #define _DEFAULT_SOURCE
  30
  31 #include "iotivity_config.h"
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <stdbool.h>
  36 #ifdef HAVE_TIME_H
  37 #include <time.h>
  38 #endif
  39
  40 #include "caprotocolmessage.h"
  41 #include "logger.h"
  42 #include "oic_malloc.h"
  43 #include "oic_string.h"
  44 #include "ocrandom.h"
  45 #include "cacommonutil.h"
  46
  47 #define TAG "OIC_CA_PRTCL_MSG"
  48
  49 #define CA_PDU_MIN_SIZE (4)
  50 #define CA_ENCODE_BUFFER_SIZE (4)
  51
  52 static const char COAP_URI_HEADER[] = "coap://[::]/";
  53
  54 static char g_chproxyUri[CA_MAX_URI_LENGTH];
  55
  56 CAResult_t CASetProxyUri(const char *uri)
  57 {
  58     VERIFY_NON_NULL(uri, TAG, "uri");
  59     OICStrcpy(g_chproxyUri, sizeof (g_chproxyUri), uri);
  60     return CA_STATUS_OK;
  61 }
  62
  63 CAResult_t CAGetRequestInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint,
  64                                    CARequestInfo_t *outReqInfo)
  65 {
  66     VERIFY_NON_NULL(pdu, TAG, "pdu");
  67     VERIFY_NON_NULL(outReqInfo, TAG, "outReqInfo");
  68
  69     uint32_t code = CA_NOT_FOUND;
  70     CAResult_t ret = CAGetInfoFromPDU(pdu, endpoint, &code, &(outReqInfo->info));
  71     outReqInfo->method = code;
  72
  73     return ret;
  74 }
  75
  76 CAResult_t CAGetResponseInfoFromPDU(const coap_pdu_t *pdu, CAResponseInfo_t *outResInfo,
  77                                     const CAEndpoint_t *endpoint)
  78 {
  79     VERIFY_NON_NULL(pdu, TAG, "pdu");
  80     VERIFY_NON_NULL(outResInfo, TAG, "outResInfo");
  81
  82     uint32_t code = CA_NOT_FOUND;
  83     CAResult_t ret = CAGetInfoFromPDU(pdu, endpoint, &code, &(outResInfo->info));
  84     outResInfo->result = code;
  85
  86     return ret;
  87 }
  88
  89 CAResult_t CAGetErrorInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint,
  90                                  CAErrorInfo_t *errorInfo)
  91 {
  92     VERIFY_NON_NULL(pdu, TAG, "pdu");
  93
  94     uint32_t code = 0;
  95     CAResult_t ret = CAGetInfoFromPDU(pdu, endpoint, &code, &errorInfo->info);
  96
  97     return ret;
  98 }
  99
 100 coap_pdu_t *CAGeneratePDU(uint32_t code, const CAInfo_t *info, const CAEndpoint_t *endpoint,
 101                           coap_list_t **optlist, coap_transport_t *transport)
 102 {
 103     VERIFY_NON_NULL_RET(info, TAG, "info", NULL);
 104     VERIFY_NON_NULL_RET(endpoint, TAG, "endpoint", NULL);
 105     VERIFY_NON_NULL_RET(optlist, TAG, "optlist", NULL);
 106
 107     OIC_LOG_V(DEBUG, TAG, "generate pdu for [%d]adapter, [%d]flags",
 108               endpoint->adapter, endpoint->flags);
 109
 110     coap_pdu_t *pdu = NULL;
 111
 112     // RESET have to use only 4byte (empty message)
 113     // and ACKNOWLEDGE can use empty message when code is empty.
 114     if (CA_MSG_RESET == info->type || (CA_EMPTY == code && CA_MSG_ACKNOWLEDGE == info->type))
 115     {
 116         if (CA_EMPTY != code)
 117         {
 118             OIC_LOG(ERROR, TAG, "reset is not empty message");
 119             return NULL;
 120         }
 121
 122         if (info->payloadSize > 0 || info->payload || info->token || info->tokenLength > 0)
 123         {
 124             OIC_LOG(ERROR, TAG, "Empty message has unnecessary data after messageID");
 125             return NULL;
 126         }
 127
 128         OIC_LOG(DEBUG, TAG, "code is empty");
 129         if (!(pdu = CAGeneratePDUImpl((code_t) code, info, endpoint, NULL, transport)))
 130         {
 131             OIC_LOG(ERROR, TAG, "pdu NULL");
 132             return NULL;
 133         }
 134     }
 135     else
 136     {
 137         if (info->resourceUri)
 138         {
 139             OIC_LOG_V(DEBUG, TAG, "uri : %s", info->resourceUri);
 140
 141             uint32_t length = strlen(info->resourceUri);
 142             if (CA_MAX_URI_LENGTH < length)
 143             {
 144                 OIC_LOG(ERROR, TAG, "URI len err");
 145                 return NULL;
 146             }
 147
 148             uint32_t uriLength = length + sizeof(COAP_URI_HEADER);
 149             char *coapUri = (char *) OICCalloc(1, uriLength);
 150             if (NULL == coapUri)
 151             {
 152                 OIC_LOG(ERROR, TAG, "out of memory");
 153                 return NULL;
 154             }
 155             OICStrcat(coapUri, uriLength, COAP_URI_HEADER);
 156             OICStrcat(coapUri, uriLength, info->resourceUri);
 157
 158             // parsing options in URI
 159             CAResult_t res = CAParseURI(coapUri, optlist);
 160             if (CA_STATUS_OK != res)
 161             {
 162                 OICFree(coapUri);
 163                 return NULL;
 164             }
 165
 166             OICFree(coapUri);
 167         }
 168         // parsing options in HeadOption
 169         CAResult_t ret = CAParseHeadOption(code, info, optlist);
 170         if (CA_STATUS_OK != ret)
 171         {
 172             return NULL;
 173         }
 174
 175         pdu = CAGeneratePDUImpl((code_t) code, info, endpoint, *optlist, transport);
 176         if (NULL == pdu)
 177         {
 178             OIC_LOG(ERROR, TAG, "pdu NULL");
 179             return NULL;
 180         }
 181     }
 182
 183     // pdu print method : coap_show_pdu(pdu);
 184     return pdu;
 185 }
 186
 187 coap_pdu_t *CAParsePDU(const char *data, size_t length, uint32_t *outCode,
 188                        const CAEndpoint_t *endpoint)
 189 {
 190     VERIFY_NON_NULL_RET(data, TAG, "data", NULL);
 191     VERIFY_NON_NULL_RET(endpoint, TAG, "endpoint", NULL);
 192
 193     coap_transport_t transport = COAP_UDP;
 194 #ifdef WITH_TCP
 195     if (CAIsSupportedCoAPOverTCP(endpoint->adapter))
 196     {
 197         transport = coap_get_tcp_header_type_from_initbyte(((unsigned char *)data)[0] >> 4);
 198     }
 199 #endif
 200
 201     coap_pdu_t *outpdu =
 202         coap_pdu_init2(0, 0, ntohs(COAP_INVALID_TID), length, transport);
 203     if (NULL == outpdu)
 204     {
 205         OIC_LOG(ERROR, TAG, "outpdu is null");
 206         return NULL;
 207     }
 208
 209     OIC_LOG_V(DEBUG, TAG, "pdu parse-transport type : %d", transport);
 210
 211     int ret = coap_pdu_parse2((unsigned char *) data, length, outpdu, transport);
 212     OIC_LOG_V(DEBUG, TAG, "pdu parse ret: %d", ret);
 213     if (0 >= ret)
 214     {
 215         OIC_LOG(ERROR, TAG, "pdu parse failed");
 216         goto exit;
 217     }
 218
 219 #ifdef WITH_TCP
 220     if (CAIsSupportedCoAPOverTCP(endpoint->adapter))
 221     {
 222         OIC_LOG(INFO, TAG, "there is no version info in coap header");
 223     }
 224     else
 225 #endif
 226     {
 227         if (outpdu->transport_hdr->udp.version != COAP_DEFAULT_VERSION)
 228         {
 229             OIC_LOG_V(ERROR, TAG, "coap version is not available : %d",
 230                       outpdu->transport_hdr->udp.version);
 231             goto exit;
 232         }
 233         if (outpdu->transport_hdr->udp.token_length > CA_MAX_TOKEN_LEN)
 234         {
 235             OIC_LOG_V(ERROR, TAG, "token length has been exceed : %d",
 236                       outpdu->transport_hdr->udp.token_length);
 237             goto exit;
 238         }
 239     }
 240
 241     if (outCode)
 242     {
 243         (*outCode) = (uint32_t) CA_RESPONSE_CODE(coap_get_code(outpdu, transport));
 244     }
 245
 246     return outpdu;
 247
 248 exit:
 249     OIC_LOG(DEBUG, TAG, "data :");
 250     OIC_LOG_BUFFER(DEBUG, TAG,  data, length);
 251     coap_delete_pdu(outpdu);
 252     return NULL;
 253 }
 254
 255 coap_pdu_t *CAGeneratePDUImpl(code_t code, const CAInfo_t *info,
 256                               const CAEndpoint_t *endpoint, coap_list_t *options,
 257                               coap_transport_t *transport)
 258 {
 259     VERIFY_NON_NULL_RET(info, TAG, "info", NULL);
 260     VERIFY_NON_NULL_RET(endpoint, TAG, "endpoint", NULL);
 261     VERIFY_NON_NULL_RET(transport, TAG, "transport", NULL);
 262
 263     unsigned int length = COAP_MAX_PDU_SIZE;
 264 #ifdef WITH_TCP
 265     unsigned int msgLength = 0;
 266     if (CAIsSupportedCoAPOverTCP(endpoint->adapter))
 267     {
 268         if (options)
 269         {
 270             unsigned short prevOptNumber = 0;
 271             for (coap_list_t *opt = options; opt; opt = opt->next)
 272             {
 273                 unsigned short curOptNumber = COAP_OPTION_KEY(*(coap_option *) opt->data);
 274                 if (prevOptNumber > curOptNumber)
 275                 {
 276                     OIC_LOG(ERROR, TAG, "option list is wrong");
 277                     return NULL;
 278                 }
 279
 280                 size_t optValueLen = COAP_OPTION_LENGTH(*(coap_option *) opt->data);
 281                 size_t optLength = coap_get_opt_header_length(curOptNumber - prevOptNumber, optValueLen);
 282                 if (0 == optLength)
 283                 {
 284                     OIC_LOG(ERROR, TAG, "Reserved for the Payload marker for the option");
 285                     return NULL;
 286                 }
 287                 msgLength += optLength;
 288                 prevOptNumber = curOptNumber;
 289                 OIC_LOG_V(DEBUG, TAG, "curOptNumber[%d], prevOptNumber[%d], optValueLen[%zu], "
 290                         "optLength[%zu], msgLength[%d]",
 291                           curOptNumber, prevOptNumber, optValueLen, optLength, msgLength);
 292             }
 293         }
 294
 295         if (info->payloadSize > 0)
 296         {
 297             msgLength = msgLength + info->payloadSize + PAYLOAD_MARKER;
 298         }
 299         *transport = coap_get_tcp_header_type_from_size(msgLength);
 300         length = msgLength + coap_get_tcp_header_length_for_transport(*transport)
 301                 + info->tokenLength;
 302     }
 303     else
 304 #endif
 305     {
 306         *transport = COAP_UDP;
 307     }
 308
 309     coap_pdu_t *pdu = coap_new_pdu2(*transport, length);
 310
 311     if (NULL == pdu)
 312     {
 313         OIC_LOG(ERROR, TAG, "malloc failed");
 314         return NULL;
 315     }
 316
 317     OIC_LOG_V(DEBUG, TAG, "transport type: %d, payload size: %zu",
 318               *transport, info->payloadSize);
 319
 320 #ifdef WITH_TCP
 321     if (CAIsSupportedCoAPOverTCP(endpoint->adapter))
 322     {
 323         coap_add_length(pdu, *transport, msgLength);
 324     }
 325     else
 326 #endif
 327     {
 328         OIC_LOG_V(DEBUG, TAG, "msgID is %d", info->messageId);
 329         uint16_t message_id = 0;
 330         if (0 == info->messageId)
 331         {
 332             /* initialize message id */
 333             prng((uint8_t * ) &message_id, sizeof(message_id));
 334
 335             OIC_LOG_V(DEBUG, TAG, "gen msg id=%d", message_id);
 336         }
 337         else
 338         {
 339             /* use saved message id */
 340             message_id = info->messageId;
 341         }
 342         pdu->transport_hdr->udp.id = message_id;
 343         OIC_LOG_V(DEBUG, TAG, "messageId in pdu is %d, %d", message_id, pdu->transport_hdr->udp.id);
 344
 345         pdu->transport_hdr->udp.type = info->type;
 346     }
 347
 348     coap_add_code(pdu, *transport, code);
 349
 350     if (info->token && CA_EMPTY != code)
 351     {
 352         uint32_t tokenLength = info->tokenLength;
 353         OIC_LOG_V(DEBUG, TAG, "token info token length: %d, token :", tokenLength);
 354         OIC_LOG_BUFFER(DEBUG, TAG, (const uint8_t *)info->token, tokenLength);
 355
 356         int32_t ret = coap_add_token2(pdu, tokenLength, (unsigned char *)info->token, *transport);
 357         if (0 == ret)
 358         {
 359             OIC_LOG(ERROR, TAG, "can't add token");
 360         }
 361     }
 362
 363 #ifdef WITH_BWT
 364     if (CA_ADAPTER_GATT_BTLE != endpoint->adapter
 365 #ifdef WITH_TCP
 366             && !CAIsSupportedCoAPOverTCP(endpoint->adapter)
 367 #endif
 368             )
 369     {
 370         // option list will be added in blockwise-transfer
 371         return pdu;
 372     }
 373 #endif
 374
 375     if (options)
 376     {
 377         for (coap_list_t *opt = options; opt; opt = opt->next)
 378         {
 379             OIC_LOG_V(DEBUG, TAG, "[%s] opt will be added.",
 380                       COAP_OPTION_DATA(*(coap_option *) opt->data));
 381
 382             OIC_LOG_V(DEBUG, TAG, "[%d] pdu length", pdu->length);
 383             if (0 == coap_add_option2(pdu, COAP_OPTION_KEY(*(coap_option *) opt->data),
 384                                       COAP_OPTION_LENGTH(*(coap_option *) opt->data),
 385                                       COAP_OPTION_DATA(*(coap_option *) opt->data), *transport))
 386             {
 387                 OIC_LOG(ERROR, TAG, "coap_add_option2 has failed");
 388                 coap_delete_pdu(pdu);
 389                 return NULL;
 390             }
 391         }
 392     }
 393
 394     OIC_LOG_V(DEBUG, TAG, "[%d] pdu length after option", pdu->length);
 395
 396     if (NULL != info->payload && 0 < info->payloadSize)
 397     {
 398         OIC_LOG(DEBUG, TAG, "payload is added");
 399         coap_add_data(pdu, info->payloadSize, (const unsigned char *) info->payload);
 400     }
 401
 402     return pdu;
 403 }
 404
 405 CAResult_t CAParseURI(const char *uriInfo, coap_list_t **optlist)
 406 {
 407     VERIFY_NON_NULL(uriInfo, TAG, "uriInfo");
 408     VERIFY_NON_NULL(optlist, TAG, "optlist");
 409
 410     /* split arg into Uri-* options */
 411     coap_uri_t uri;
 412     coap_split_uri((unsigned char *) uriInfo, strlen(uriInfo), &uri);
 413
 414     if (uri.port != COAP_DEFAULT_PORT)
 415     {
 416         unsigned char portbuf[CA_ENCODE_BUFFER_SIZE] = { 0 };
 417         int ret = coap_insert(optlist,
 418                               CACreateNewOptionNode(COAP_OPTION_URI_PORT,
 419                                                     coap_encode_var_bytes(portbuf, uri.port),
 420                                                     (char *)portbuf),
 421                               CAOrderOpts);
 422         if (ret <= 0)
 423         {
 424             return CA_STATUS_INVALID_PARAM;
 425         }
 426     }
 427
 428     if (uri.path.s && uri.path.length)
 429     {
 430         CAResult_t ret = CAParseUriPartial(uri.path.s, uri.path.length,
 431                                            COAP_OPTION_URI_PATH, optlist);
 432         if (CA_STATUS_OK != ret)
 433         {
 434             OIC_LOG(ERROR, TAG, "CAParseUriPartial failed(uri path)");
 435             return ret;
 436         }
 437     }
 438
 439     if (uri.query.s && uri.query.length)
 440     {
 441         CAResult_t ret = CAParseUriPartial(uri.query.s, uri.query.length, COAP_OPTION_URI_QUERY,
 442                                            optlist);
 443         if (CA_STATUS_OK != ret)
 444         {
 445             OIC_LOG(ERROR, TAG, "CAParseUriPartial failed(uri query)");
 446             return ret;
 447         }
 448     }
 449
 450     return CA_STATUS_OK;
 451 }
 452
 453 CAResult_t CAParseUriPartial(const unsigned char *str, size_t length, int target,
 454                              coap_list_t **optlist)
 455 {
 456     VERIFY_NON_NULL(optlist, TAG, "optlist");
 457
 458     if ((target != COAP_OPTION_URI_PATH) && (target != COAP_OPTION_URI_QUERY))
 459     {
 460         // should never occur. Log just in case.
 461         OIC_LOG(DEBUG, TAG, "Unexpected URI component.");
 462         return CA_NOT_SUPPORTED;
 463     }
 464     else if (str && length)
 465     {
 466         unsigned char uriBuffer[CA_MAX_URI_LENGTH] = { 0 };
 467         unsigned char *pBuf = uriBuffer;
 468         size_t buflen = sizeof(uriBuffer);
 469         int res = (target == COAP_OPTION_URI_PATH) ? coap_split_path(str, length, pBuf, &buflen) :
 470                                                      coap_split_query(str, length, pBuf, &buflen);
 471
 472         if (res > 0)
 473         {
 474             size_t prevIdx = 0;
 475             while (res--)
 476             {
 477                 int ret = coap_insert(optlist,
 478                                       CACreateNewOptionNode(target, COAP_OPT_LENGTH(pBuf),
 479                                                             (char *)COAP_OPT_VALUE(pBuf)),
 480                                       CAOrderOpts);
 481                 if (ret <= 0)
 482                 {
 483                     return CA_STATUS_INVALID_PARAM;
 484                 }
 485
 486                 size_t optSize = COAP_OPT_SIZE(pBuf);
 487                 if ((prevIdx + optSize) < buflen)
 488                 {
 489                     pBuf += optSize;
 490                     prevIdx += optSize;
 491                 }
 492             }
 493         }
 494         else
 495         {
 496             OIC_LOG_V(ERROR, TAG, "Problem parsing URI : %d for %d", res, target);
 497             return CA_STATUS_FAILED;
 498         }
 499     }
 500     else
 501     {
 502         OIC_LOG(ERROR, TAG, "str or length is not available");
 503         return CA_STATUS_FAILED;
 504     }
 505
 506     return CA_STATUS_OK;
 507 }
 508
 509 CAResult_t CAParseHeadOption(uint32_t code, const CAInfo_t *info, coap_list_t **optlist)
 510 {
 511     (void)code;
 512     VERIFY_NON_NULL_RET(info, TAG, "info", CA_STATUS_INVALID_PARAM);
 513
 514     OIC_LOG_V(DEBUG, TAG, "parse Head Opt: %d", info->numOptions);
 515
 516     if (!optlist)
 517     {
 518         OIC_LOG(ERROR, TAG, "optlist is null");
 519         return CA_STATUS_INVALID_PARAM;
 520     }
 521
 522     for (uint32_t i = 0; i < info->numOptions; i++)
 523     {
 524         if(!(info->options + i))
 525         {
 526             OIC_LOG(ERROR, TAG, "options is not available");
 527             return CA_STATUS_FAILED;
 528         }
 529
 530         uint32_t id = (info->options + i)->optionID;
 531         if (COAP_OPTION_URI_PATH == id || COAP_OPTION_URI_QUERY == id)
 532         {
 533             OIC_LOG_V(DEBUG, TAG, "not Header Opt: %d", id);
 534         }
 535         else
 536         {
 537             OIC_LOG_V(DEBUG, TAG, "Head opt ID: %d", id);
 538             OIC_LOG_V(DEBUG, TAG, "Head opt data: %s", (info->options + i)->optionData);
 539             OIC_LOG_V(DEBUG, TAG, "Head opt length: %d", (info->options + i)->optionLength);
 540             int ret = coap_insert(optlist,
 541                                   CACreateNewOptionNode(id, (info->options + i)->optionLength,
 542                                                         (info->options + i)->optionData),
 543                                   CAOrderOpts);
 544             if (ret <= 0)
 545             {
 546                 return CA_STATUS_INVALID_PARAM;
 547             }
 548         }
 549     }
 550
 551     // insert one extra header with the payload format if applicable.
 552     if (CA_FORMAT_UNDEFINED != info->payloadFormat)
 553     {
 554         coap_list_t* node = NULL;
 555         uint8_t buf[CA_ENCODE_BUFFER_SIZE] = {0};
 556         switch (info->payloadFormat)
 557         {
 558             case CA_FORMAT_APPLICATION_CBOR:
 559                 node = CACreateNewOptionNode(
 560                         COAP_OPTION_CONTENT_FORMAT,
 561                         coap_encode_var_bytes(buf, (unsigned short)COAP_MEDIATYPE_APPLICATION_CBOR),
 562                         (char *)buf);
 563                 break;
 564             default:
 565                 OIC_LOG_V(ERROR, TAG, "Content format option:[%d] not supported", info->payloadFormat);
 566         }
 567         if (!node)
 568         {
 569             OIC_LOG(ERROR, TAG, "Content format option not created");
 570             return CA_STATUS_INVALID_PARAM;
 571         }
 572         int ret = coap_insert(optlist, node, CAOrderOpts);
 573         if (ret <= 0)
 574         {
 575             coap_delete(node);
 576             OIC_LOG(ERROR, TAG, "Content format option not inserted in header");
 577             return CA_STATUS_INVALID_PARAM;
 578         }
 579     }
 580     if (CA_FORMAT_UNDEFINED != info->acceptFormat)
 581     {
 582         coap_list_t* node = NULL;
 583         uint8_t buf[CA_ENCODE_BUFFER_SIZE] = {0};
 584         switch (info->acceptFormat)
 585         {
 586             case CA_FORMAT_APPLICATION_CBOR:
 587                 node = CACreateNewOptionNode(
 588                         COAP_OPTION_ACCEPT,
 589                         coap_encode_var_bytes(buf, (unsigned short)COAP_MEDIATYPE_APPLICATION_CBOR),
 590                         (char *)buf);
 591                 break;
 592             default:
 593                 OIC_LOG_V(ERROR, TAG, "Accept format option:[%d] not supported", info->acceptFormat);
 594         }
 595         if (!node)
 596         {
 597             OIC_LOG(ERROR, TAG, "Accept format option not created");
 598             return CA_STATUS_INVALID_PARAM;
 599         }
 600         int ret = coap_insert(optlist, node, CAOrderOpts);
 601         if (ret <= 0)
 602         {
 603             coap_delete(node);
 604             OIC_LOG(ERROR, TAG, "Accept format option not inserted in header");
 605             return CA_STATUS_INVALID_PARAM;
 606         }
 607     }
 608
 609     return CA_STATUS_OK;
 610 }
 611
 612 coap_list_t *CACreateNewOptionNode(uint16_t key, uint32_t length, const char *data)
 613 {
 614     VERIFY_NON_NULL_RET(data, TAG, "data", NULL);
 615
 616     coap_option *option = coap_malloc(sizeof(coap_option) + length + 1);
 617     if (!option)
 618     {
 619         OIC_LOG(ERROR, TAG, "Out of memory");
 620         return NULL;
 621     }
 622     memset(option, 0, sizeof(coap_option) + length + 1);
 623
 624     COAP_OPTION_KEY(*option) = key;
 625
 626     coap_option_def_t* def = coap_opt_def(key);
 627     if (NULL != def && coap_is_var_bytes(def))
 628     {
 629        if (length > def->max)
 630         {
 631             // make sure we shrink the value so it fits the coap option definition
 632             // by truncating the value, disregard the leading bytes.
 633             OIC_LOG_V(DEBUG, TAG, "Option [%d] data size [%d] shrunk to [%d]",
 634                     def->key, length, def->max);
 635             data = &(data[length-def->max]);
 636             length = def->max;
 637         }
 638         // Shrink the encoding length to a minimum size for coap
 639         // options that support variable length encoding.
 640          COAP_OPTION_LENGTH(*option) = coap_encode_var_bytes(
 641                 COAP_OPTION_DATA(*option),
 642                 coap_decode_var_bytes((unsigned char *)data, length));
 643     }
 644     else
 645     {
 646         COAP_OPTION_LENGTH(*option) = length;
 647         memcpy(COAP_OPTION_DATA(*option), data, length);
 648     }
 649
 650     /* we can pass NULL here as delete function since option is released automatically  */
 651     coap_list_t *node = coap_new_listnode(option, NULL);
 652
 653     if (!node)
 654     {
 655         OIC_LOG(ERROR, TAG, "node is NULL");
 656         coap_free(option);
 657         return NULL;
 658     }
 659
 660     return node;
 661 }
 662
 663 int CAOrderOpts(void *a, void *b)
 664 {
 665     if (!a || !b)
 666     {
 667         return a < b ? -1 : 1;
 668     }
 669
 670     if (COAP_OPTION_KEY(*(coap_option *) a) < COAP_OPTION_KEY(*(coap_option * ) b))
 671     {
 672         return -1;
 673     }
 674
 675     return COAP_OPTION_KEY(*(coap_option *) a) == COAP_OPTION_KEY(*(coap_option * ) b);
 676 }
 677
 678 uint32_t CAGetOptionCount(coap_opt_iterator_t opt_iter)
 679 {
 680     uint32_t count = 0;
 681     coap_opt_t *option = NULL;
 682
 683     while ((option = coap_option_next(&opt_iter)))
 684     {
 685         if (COAP_OPTION_URI_PATH != opt_iter.type && COAP_OPTION_URI_QUERY != opt_iter.type
 686             && COAP_OPTION_BLOCK1 != opt_iter.type && COAP_OPTION_BLOCK2 != opt_iter.type
 687             && COAP_OPTION_SIZE1 != opt_iter.type && COAP_OPTION_SIZE2 != opt_iter.type
 688             && COAP_OPTION_CONTENT_FORMAT != opt_iter.type
 689             && COAP_OPTION_ACCEPT != opt_iter.type
 690             && COAP_OPTION_URI_HOST != opt_iter.type && COAP_OPTION_URI_PORT != opt_iter.type
 691             && COAP_OPTION_ETAG != opt_iter.type && COAP_OPTION_MAXAGE != opt_iter.type
 692             && COAP_OPTION_PROXY_SCHEME != opt_iter.type)
 693         {
 694             count++;
 695         }
 696     }
 697
 698     return count;
 699 }
 700
 701 CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint,
 702                             uint32_t *outCode, CAInfo_t *outInfo)
 703 {
 704     VERIFY_NON_NULL(pdu, TAG, "pdu");
 705     VERIFY_NON_NULL(endpoint, TAG, "endpoint");
 706     VERIFY_NON_NULL(outCode, TAG, "outCode");
 707     VERIFY_NON_NULL(outInfo, TAG, "outInfo");
 708
 709     coap_transport_t transport;
 710 #ifdef WITH_TCP
 711     if (CAIsSupportedCoAPOverTCP(endpoint->adapter))
 712     {
 713         transport = coap_get_tcp_header_type_from_initbyte(((unsigned char *)pdu->transport_hdr)[0] >> 4);
 714     }
 715     else
 716 #endif
 717     {
 718         transport = COAP_UDP;
 719     }
 720
 721     coap_opt_iterator_t opt_iter;
 722     coap_option_iterator_init2((coap_pdu_t *) pdu, &opt_iter, COAP_OPT_ALL, transport);
 723
 724     if (outCode)
 725     {
 726         (*outCode) = (uint32_t) CA_RESPONSE_CODE(coap_get_code(pdu, transport));
 727     }
 728
 729     // init HeaderOption list
 730     uint32_t count = CAGetOptionCount(opt_iter);
 731     memset(outInfo, 0, sizeof(*outInfo));
 732
 733     outInfo->numOptions = count;
 734
 735 #ifdef WITH_TCP
 736     if (CAIsSupportedCoAPOverTCP(endpoint->adapter))
 737     {
 738         // set type
 739         outInfo->type = CA_MSG_NONCONFIRM;
 740         outInfo->payloadFormat = CA_FORMAT_UNDEFINED;
 741     }
 742     else
 743 #else
 744     (void) endpoint;
 745 #endif
 746     {
 747         // set type
 748         outInfo->type = pdu->transport_hdr->udp.type;
 749
 750         // set message id
 751         outInfo->messageId = pdu->transport_hdr->udp.id;
 752         outInfo->payloadFormat = CA_FORMAT_UNDEFINED;
 753         outInfo->acceptFormat = CA_FORMAT_UNDEFINED;
 754     }
 755
 756     if (count > 0)
 757     {
 758         outInfo->options = (CAHeaderOption_t *) OICCalloc(count, sizeof(CAHeaderOption_t));
 759         if (NULL == outInfo->options)
 760         {
 761             OIC_LOG(ERROR, TAG, "Out of memory");
 762             return CA_MEMORY_ALLOC_FAILED;
 763         }
 764     }
 765
 766     coap_opt_t *option = NULL;
 767     char optionResult[CA_MAX_URI_LENGTH] = {0};
 768     uint32_t idx = 0;
 769     uint32_t optionLength = 0;
 770     bool isfirstsetflag = false;
 771     bool isQueryBeingProcessed = false;
 772     bool isProxyRequest = false;
 773
 774     while ((option = coap_option_next(&opt_iter)))
 775     {
 776         char buf[COAP_MAX_PDU_SIZE] = {0};
 777         uint32_t bufLength =
 778             CAGetOptionData(opt_iter.type, (uint8_t *)(COAP_OPT_VALUE(option)),
 779                     COAP_OPT_LENGTH(option), (uint8_t *)buf, sizeof(buf));
 780         if (bufLength)
 781         {
 782             OIC_LOG_V(DEBUG, TAG, "COAP URI element : %s", buf);
 783             if (COAP_OPTION_URI_PATH == opt_iter.type || COAP_OPTION_URI_QUERY == opt_iter.type)
 784             {
 785                 if (false == isfirstsetflag)
 786                 {
 787                     isfirstsetflag = true;
 788                     optionResult[optionLength] = '/';
 789                     optionLength++;
 790                     // Make sure there is enough room in the optionResult buffer
 791                     if ((optionLength + bufLength) < sizeof(optionResult))
 792                     {
 793                         memcpy(&optionResult[optionLength], buf, bufLength);
 794                         optionLength += bufLength;
 795                     }
 796                     else
 797                     {
 798                         goto exit;
 799                     }
 800                 }
 801                 else
 802                 {
 803                     if (COAP_OPTION_URI_PATH == opt_iter.type)
 804                     {
 805                         // Make sure there is enough room in the optionResult buffer
 806                         if (optionLength < sizeof(optionResult))
 807                         {
 808                             optionResult[optionLength] = '/';
 809                             optionLength++;
 810                         }
 811                         else
 812                         {
 813                             goto exit;
 814                         }
 815                     }
 816                     else if (COAP_OPTION_URI_QUERY == opt_iter.type)
 817                     {
 818                         if (false == isQueryBeingProcessed)
 819                         {
 820                             // Make sure there is enough room in the optionResult buffer
 821                             if (optionLength < sizeof(optionResult))
 822                             {
 823                                 optionResult[optionLength] = '?';
 824                                 optionLength++;
 825                                 isQueryBeingProcessed = true;
 826                             }
 827                             else
 828                             {
 829                                 goto exit;
 830                             }
 831                         }
 832                         else
 833                         {
 834                             // Make sure there is enough room in the optionResult buffer
 835                             if (optionLength < sizeof(optionResult))
 836                             {
 837                                 optionResult[optionLength] = ';';
 838                                 optionLength++;
 839                             }
 840                             else
 841                             {
 842                                 goto exit;
 843                             }
 844                         }
 845                     }
 846                     // Make sure there is enough room in the optionResult buffer
 847                     if ((optionLength + bufLength) < sizeof(optionResult))
 848                     {
 849                         memcpy(&optionResult[optionLength], buf, bufLength);
 850                         optionLength += bufLength;
 851                     }
 852                     else
 853                     {
 854                         goto exit;
 855                     }
 856                 }
 857             }
 858             else if (COAP_OPTION_BLOCK1 == opt_iter.type || COAP_OPTION_BLOCK2 == opt_iter.type
 859                     || COAP_OPTION_SIZE1 == opt_iter.type || COAP_OPTION_SIZE2 == opt_iter.type)
 860             {
 861                 OIC_LOG_V(DEBUG, TAG, "option[%d] will be filtering", opt_iter.type);
 862             }
 863             else if (COAP_OPTION_CONTENT_FORMAT == opt_iter.type)
 864             {
 865                 if (1 == COAP_OPT_LENGTH(option))
 866                 {
 867                     outInfo->payloadFormat = CAConvertFormat((uint8_t)buf[0]);
 868                 }
 869                 else
 870                 {
 871                     outInfo->payloadFormat = CA_FORMAT_UNSUPPORTED;
 872                     OIC_LOG_V(DEBUG, TAG, "option[%d] has an unsupported format [%d]",
 873                               opt_iter.type, (uint8_t)buf[0]);
 874                 }
 875             }
 876             else if (COAP_OPTION_ACCEPT == opt_iter.type)
 877             {
 878                 if (1 == COAP_OPT_LENGTH(option))
 879                 {
 880                     outInfo->acceptFormat = CAConvertFormat((uint8_t)buf[0]);
 881                 }
 882                 else
 883                 {
 884                     outInfo->acceptFormat = CA_FORMAT_UNSUPPORTED;
 885                 }
 886                 OIC_LOG_V(DEBUG, TAG, "option[%d] has an unsupported format [%d]",
 887                           opt_iter.type, (uint8_t)buf[0]);
 888             }
 889             else if (COAP_OPTION_URI_PORT == opt_iter.type ||
 890                     COAP_OPTION_URI_HOST == opt_iter.type ||
 891                     COAP_OPTION_ETAG == opt_iter.type ||
 892                     COAP_OPTION_MAXAGE == opt_iter.type ||
 893                     COAP_OPTION_PROXY_SCHEME== opt_iter.type)
 894             {
 895                 OIC_LOG_V(INFO, TAG, "option[%d] has an unsupported format [%d]",
 896                           opt_iter.type, (uint8_t)buf[0]);
 897             }
 898             else
 899             {
 900                 if (COAP_OPTION_PROXY_URI == opt_iter.type)
 901                 {
 902                     isProxyRequest = true;
 903                 }
 904                 if (idx < count)
 905                 {
 906                     if (bufLength <= sizeof(outInfo->options[0].optionData))
 907                     {
 908                         outInfo->options[idx].optionID = opt_iter.type;
 909                         outInfo->options[idx].optionLength = bufLength;
 910                         outInfo->options[idx].protocolID = CA_COAP_ID;
 911                         memcpy(outInfo->options[idx].optionData, buf, bufLength);
 912                         idx++;
 913                     }
 914                 }
 915             }
 916         }
 917     }
 918
 919     unsigned char* token = NULL;
 920     unsigned int token_length = 0;
 921     coap_get_token2(pdu->transport_hdr, transport, &token, &token_length);
 922
 923     // set token data
 924     if (token_length > 0)
 925     {
 926         OIC_LOG_V(DEBUG, TAG, "inside token length : %d", token_length);
 927         outInfo->token = (char *) OICMalloc(token_length);
 928         if (NULL == outInfo->token)
 929         {
 930             OIC_LOG(ERROR, TAG, "Out of memory");
 931             OICFree(outInfo->options);
 932             return CA_MEMORY_ALLOC_FAILED;
 933         }
 934         memcpy(outInfo->token, token, token_length);
 935     }
 936
 937     outInfo->tokenLength = token_length;
 938
 939     // set payload data
 940     size_t dataSize;
 941     uint8_t *data;
 942     if (coap_get_data(pdu, &dataSize, &data))
 943     {
 944         OIC_LOG(DEBUG, TAG, "inside pdu->data");
 945         outInfo->payload = (uint8_t *) OICMalloc(dataSize);
 946         if (NULL == outInfo->payload)
 947         {
 948             OIC_LOG(ERROR, TAG, "Out of memory");
 949             OICFree(outInfo->options);
 950             OICFree(outInfo->token);
 951             return CA_MEMORY_ALLOC_FAILED;
 952         }
 953         memcpy(outInfo->payload, pdu->data, dataSize);
 954         outInfo->payloadSize = dataSize;
 955     }
 956
 957     if (optionResult[0] != '\0')
 958     {
 959         OIC_LOG_V(DEBUG, TAG, "URL length:%zu", strlen(optionResult));
 960         outInfo->resourceUri = OICStrdup(optionResult);
 961         if (!outInfo->resourceUri)
 962         {
 963             OIC_LOG(ERROR, TAG, "Out of memory");
 964             OICFree(outInfo->options);
 965             OICFree(outInfo->token);
 966             return CA_MEMORY_ALLOC_FAILED;
 967         }
 968     }
 969     else if(isProxyRequest && g_chproxyUri[0] != '\0')
 970     {
 971        /*
 972         *   A request for Proxy will not have any uri element as per CoAP specs
 973         *   and only COAP_OPTION_PROXY_URI will be present. Use preset proxy uri
 974         *   for such requests.
 975         */
 976         outInfo->resourceUri = OICStrdup(g_chproxyUri);
 977         if (!outInfo->resourceUri)
 978         {
 979             OIC_LOG(ERROR, TAG, "Out of memory");
 980             OICFree(outInfo->options);
 981             OICFree(outInfo->token);
 982             return CA_MEMORY_ALLOC_FAILED;
 983         }
 984     }
 985     return CA_STATUS_OK;
 986
 987 exit:
 988     OIC_LOG(ERROR, TAG, "buffer too small");
 989     OICFree(outInfo->options);
 990     return CA_STATUS_FAILED;
 991 }
 992
 993 CAResult_t CAGetTokenFromPDU(const coap_hdr_transport_t *pdu_hdr,
 994                              CAInfo_t *outInfo,
 995                              const CAEndpoint_t *endpoint)
 996 {
 997     VERIFY_NON_NULL(pdu_hdr, TAG, "pdu_hdr");
 998     VERIFY_NON_NULL(outInfo, TAG, "outInfo");
 999     VERIFY_NON_NULL(endpoint, TAG, "endpoint");
1000
1001     coap_transport_t transport = COAP_UDP;
1002 #ifdef WITH_TCP
1003     if (CAIsSupportedCoAPOverTCP(endpoint->adapter))
1004     {
1005         transport = coap_get_tcp_header_type_from_initbyte(((unsigned char *)pdu_hdr)[0] >> 4);
1006     }
1007 #endif
1008
1009     unsigned char* token = NULL;
1010     unsigned int token_length = 0;
1011     coap_get_token2(pdu_hdr, transport, &token, &token_length);
1012
1013     // set token data
1014     if (token_length > 0)
1015     {
1016         OIC_LOG_V(DEBUG, TAG, "token len:%d", token_length);
1017         outInfo->token = (char *) OICMalloc(token_length);
1018         if (NULL == outInfo->token)
1019         {
1020             OIC_LOG(ERROR, TAG, "Out of memory");
1021             return CA_MEMORY_ALLOC_FAILED;
1022         }
1023         memcpy(outInfo->token, token, token_length);
1024     }
1025
1026     outInfo->tokenLength = token_length;
1027
1028     return CA_STATUS_OK;
1029 }
1030
1031 CAResult_t CAGenerateTokenInternal(CAToken_t *token, uint8_t tokenLength)
1032 {
1033     VERIFY_NON_NULL(token, TAG, "token");
1034
1035     if ((tokenLength > CA_MAX_TOKEN_LEN) || (0 == tokenLength))
1036     {
1037         OIC_LOG(ERROR, TAG, "invalid token length");
1038         return CA_STATUS_INVALID_PARAM;
1039     }
1040
1041     // memory allocation
1042     char *temp = (char *) OICCalloc(tokenLength, sizeof(char));
1043     if (NULL == temp)
1044     {
1045         OIC_LOG(ERROR, TAG, "Out of memory");
1046         return CA_MEMORY_ALLOC_FAILED;
1047     }
1048
1049     if (!OCGetRandomBytes((uint8_t *)temp, tokenLength))
1050     {
1051         OIC_LOG(ERROR, TAG, "Failed to generate random token");
1052         return CA_STATUS_FAILED;
1053     }
1054
1055     // save token
1056     *token = temp;
1057
1058     OIC_LOG_V(DEBUG, TAG, "token len:%d, token:", tokenLength);
1059     OIC_LOG_BUFFER(DEBUG, TAG, (const uint8_t *)(*token), tokenLength);
1060
1061     return CA_STATUS_OK;
1062 }
1063
1064 void CADestroyTokenInternal(CAToken_t token)
1065 {
1066     OICFree(token);
1067 }
1068
1069 uint32_t CAGetOptionData(uint16_t key, const uint8_t *data, uint32_t len,
1070         uint8_t *option, uint32_t buflen)
1071 {
1072     if (0 == buflen)
1073     {
1074         OIC_LOG(ERROR, TAG, "buflen 0");
1075         return 0;
1076     }
1077
1078     if (buflen <= len)
1079     {
1080         OIC_LOG(ERROR, TAG, "option buffer too small");
1081         return 0;
1082     }
1083
1084     coap_option_def_t* def = coap_opt_def(key);
1085     if (NULL != def && coap_is_var_bytes(def) && 0 == len)
1086     {
1087         // A 0 length option is permitted in CoAP but the
1088         // rest or the stack is unaware of variable byte encoding
1089         // should remain that way so a 0 byte of length 1 is inserted.
1090         len = 1;
1091         option[0]=0;
1092     }
1093     else
1094     {
1095         memcpy(option, data, len);
1096         option[len] = '\0';
1097     }
1098
1099     return len;
1100 }
1101
1102 CAMessageType_t CAGetMessageTypeFromPduBinaryData(const void *pdu, uint32_t size)
1103 {
1104     VERIFY_NON_NULL_RET(pdu, TAG, "pdu", CA_MSG_NONCONFIRM);
1105
1106     // pdu minimum size is 4 byte.
1107     if (size < CA_PDU_MIN_SIZE)
1108     {
1109         OIC_LOG(ERROR, TAG, "min size");
1110         return CA_MSG_NONCONFIRM;
1111     }
1112
1113     coap_hdr_t *hdr = (coap_hdr_t *) pdu;
1114
1115     return (CAMessageType_t) hdr->type;
1116 }
1117
1118 uint16_t CAGetMessageIdFromPduBinaryData(const void *pdu, uint32_t size)
1119 {
1120     VERIFY_NON_NULL_RET(pdu, TAG, "pdu", 0);
1121
1122     // pdu minimum size is 4 byte.
1123     if (size < CA_PDU_MIN_SIZE)
1124     {
1125         OIC_LOG(ERROR, TAG, "min size");
1126         return 0;
1127     }
1128
1129     coap_hdr_t *hdr = (coap_hdr_t *) pdu;
1130
1131     return hdr->id;
1132 }
1133
1134 CAResponseResult_t CAGetCodeFromPduBinaryData(const void *pdu, uint32_t size)
1135 {
1136     VERIFY_NON_NULL_RET(pdu, TAG, "pdu", CA_NOT_FOUND);
1137
1138     // pdu minimum size is 4 byte.
1139     if (size < CA_PDU_MIN_SIZE)
1140     {
1141         OIC_LOG(ERROR, TAG, "min size");
1142         return CA_NOT_FOUND;
1143     }
1144
1145     coap_hdr_t *hdr = (coap_hdr_t *) pdu;
1146
1147     return (CAResponseResult_t) CA_RESPONSE_CODE(hdr->code);
1148 }
1149
1150 CAPayloadFormat_t CAConvertFormat(uint8_t format)
1151 {
1152     switch (format)
1153     {
1154         case COAP_MEDIATYPE_TEXT_PLAIN:
1155             return CA_FORMAT_TEXT_PLAIN;
1156         case COAP_MEDIATYPE_APPLICATION_LINK_FORMAT:
1157             return CA_FORMAT_APPLICATION_LINK_FORMAT;
1158         case COAP_MEDIATYPE_APPLICATION_XML:
1159             return CA_FORMAT_APPLICATION_XML;
1160         case COAP_MEDIATYPE_APPLICATION_OCTET_STREAM:
1161             return CA_FORMAT_APPLICATION_OCTET_STREAM;
1162         case COAP_MEDIATYPE_APPLICATION_RDF_XML:
1163             return CA_FORMAT_APPLICATION_RDF_XML;
1164         case COAP_MEDIATYPE_APPLICATION_EXI:
1165             return CA_FORMAT_APPLICATION_EXI;
1166         case COAP_MEDIATYPE_APPLICATION_JSON:
1167             return CA_FORMAT_APPLICATION_JSON;
1168         case COAP_MEDIATYPE_APPLICATION_CBOR:
1169             return CA_FORMAT_APPLICATION_CBOR;
1170         default:
1171             return CA_FORMAT_UNSUPPORTED;
1172     }
1173 }
1174
1175 #ifdef WITH_BWT
1176 bool CAIsSupportedBlockwiseTransfer(CATransportAdapter_t adapter)
1177 {
1178     OIC_LOG_V(INFO, TAG, "adapter value is %d", adapter);
1179     if (CA_ADAPTER_IP & adapter || CA_ADAPTER_NFC & adapter
1180             || CA_DEFAULT_ADAPTER == adapter)
1181     {
1182         return true;
1183     }
1184     return false;
1185 }
1186 #endif
1187
1188 #ifdef WITH_TCP
1189 bool CAIsSupportedCoAPOverTCP(CATransportAdapter_t adapter)
1190 {
1191     OIC_LOG_V(INFO, TAG, "adapter value is %d", adapter);
1192     if (CA_ADAPTER_GATT_BTLE & adapter || CA_ADAPTER_RFCOMM_BTEDR & adapter
1193             || CA_ADAPTER_TCP & adapter || CA_DEFAULT_ADAPTER == adapter)
1194     {
1195         return true;
1196     }
1197     return false;
1198 }
1199 #endif