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         CAParsePayloadFormatHeadOption(info->payloadFormat, COAP_OPTION_CONTENT_FORMAT, COAP_OPTION_CONTENT_VERSION, info->payloadVersion, optlist);
 555     }
 556
 557     if (CA_FORMAT_UNDEFINED != info->acceptFormat)
 558     {
 559         CAParsePayloadFormatHeadOption(info->acceptFormat, COAP_OPTION_ACCEPT, info->acceptVersion, COAP_OPTION_ACCEPT_VERSION, optlist);
 560     }
 561
 562     return CA_STATUS_OK;
 563 }
 564
 565 CAResult_t CAParsePayloadFormatHeadOption(CAPayloadFormat_t format, uint16_t formatOption,
 566         uint16_t versionOption, uint16_t version, coap_list_t **optlist)
 567 {
 568     coap_list_t* encodeNode = NULL;
 569     coap_list_t* versionNode = NULL;
 570     uint8_t encodeBuf[CA_ENCODE_BUFFER_SIZE] = { 0 };
 571     uint8_t versionBuf[CA_ENCODE_BUFFER_SIZE] = { 0 };
 572
 573     switch (format)
 574     {
 575         case CA_FORMAT_APPLICATION_CBOR:
 576             encodeNode = CACreateNewOptionNode(formatOption,
 577                     coap_encode_var_bytes(encodeBuf,
 578                             (unsigned short) COAP_MEDIATYPE_APPLICATION_CBOR), (char *) encodeBuf);
 579             break;
 580         case CA_FORMAT_APPLICATION_VND_OCF_CBOR:
 581             encodeNode = CACreateNewOptionNode(formatOption,
 582                     coap_encode_var_bytes(encodeBuf,
 583                             (unsigned short) COAP_MEDIATYPE_APPLICATION_VND_OCF_CBOR),
 584                     (char *) encodeBuf);
 585             // Include payload version information for this format.
 586             versionNode = CACreateNewOptionNode(versionOption,
 587                     coap_encode_var_bytes(versionBuf, version), (char *) versionBuf);
 588             break;
 589         default:
 590             OIC_LOG_V(ERROR, TAG, "Format option:[%d] not supported", format);
 591     }
 592     if (!encodeNode)
 593     {
 594         OIC_LOG(ERROR, TAG, "Format option not created");
 595         return CA_STATUS_INVALID_PARAM;
 596     }
 597     int ret = coap_insert(optlist, encodeNode, CAOrderOpts);
 598     if (0 >= ret)
 599     {
 600         coap_delete(encodeNode);
 601         OIC_LOG(ERROR, TAG, "Format option not inserted in header");
 602         if (CA_FORMAT_APPLICATION_VND_OCF_CBOR == format && versionNode)
 603         {
 604             coap_delete(versionNode);
 605         }
 606         return CA_STATUS_INVALID_PARAM;
 607     }
 608
 609     if (CA_FORMAT_APPLICATION_VND_OCF_CBOR == format)
 610     {
 611         if (!versionNode)
 612         {
 613             OIC_LOG(ERROR, TAG, "Version option not created");
 614             coap_delete(encodeNode);
 615             return CA_STATUS_INVALID_PARAM;
 616         }
 617         else
 618         {
 619             ret = coap_insert(optlist, versionNode, CAOrderOpts);
 620             if (0 >= ret)
 621             {
 622                 coap_delete(versionNode);
 623                 coap_delete(encodeNode);
 624                 OIC_LOG(ERROR, TAG, "Content version option not inserted in header");
 625                 return CA_STATUS_INVALID_PARAM;
 626             }
 627         }
 628     }
 629     return CA_STATUS_OK;
 630 }
 631
 632 coap_list_t *CACreateNewOptionNode(uint16_t key, uint32_t length, const char *data)
 633 {
 634     VERIFY_NON_NULL_RET(data, TAG, "data", NULL);
 635
 636     coap_option *option = coap_malloc(sizeof(coap_option) + length + 1);
 637     if (!option)
 638     {
 639         OIC_LOG(ERROR, TAG, "Out of memory");
 640         return NULL;
 641     }
 642     memset(option, 0, sizeof(coap_option) + length + 1);
 643
 644     COAP_OPTION_KEY(*option) = key;
 645
 646     coap_option_def_t* def = coap_opt_def(key);
 647     if (NULL != def && coap_is_var_bytes(def))
 648     {
 649        if (length > def->max)
 650         {
 651             // make sure we shrink the value so it fits the coap option definition
 652             // by truncating the value, disregard the leading bytes.
 653             OIC_LOG_V(DEBUG, TAG, "Option [%d] data size [%d] shrunk to [%d]",
 654                     def->key, length, def->max);
 655             data = &(data[length-def->max]);
 656             length = def->max;
 657         }
 658         // Shrink the encoding length to a minimum size for coap
 659         // options that support variable length encoding.
 660          COAP_OPTION_LENGTH(*option) = coap_encode_var_bytes(
 661                 COAP_OPTION_DATA(*option),
 662                 coap_decode_var_bytes((unsigned char *)data, length));
 663     }
 664     else
 665     {
 666         COAP_OPTION_LENGTH(*option) = length;
 667         memcpy(COAP_OPTION_DATA(*option), data, length);
 668     }
 669
 670     /* we can pass NULL here as delete function since option is released automatically  */
 671     coap_list_t *node = coap_new_listnode(option, NULL);
 672
 673     if (!node)
 674     {
 675         OIC_LOG(ERROR, TAG, "node is NULL");
 676         coap_free(option);
 677         return NULL;
 678     }
 679
 680     return node;
 681 }
 682
 683 int CAOrderOpts(void *a, void *b)
 684 {
 685     if (!a || !b)
 686     {
 687         return a < b ? -1 : 1;
 688     }
 689
 690     if (COAP_OPTION_KEY(*(coap_option *) a) < COAP_OPTION_KEY(*(coap_option * ) b))
 691     {
 692         return -1;
 693     }
 694
 695     return COAP_OPTION_KEY(*(coap_option *) a) == COAP_OPTION_KEY(*(coap_option * ) b);
 696 }
 697
 698 uint32_t CAGetOptionCount(coap_opt_iterator_t opt_iter)
 699 {
 700     uint32_t count = 0;
 701     coap_opt_t *option = NULL;
 702
 703     while ((option = coap_option_next(&opt_iter)))
 704     {
 705         if (COAP_OPTION_URI_PATH != opt_iter.type && COAP_OPTION_URI_QUERY != opt_iter.type
 706             && COAP_OPTION_BLOCK1 != opt_iter.type && COAP_OPTION_BLOCK2 != opt_iter.type
 707             && COAP_OPTION_SIZE1 != opt_iter.type && COAP_OPTION_SIZE2 != opt_iter.type
 708             && COAP_OPTION_CONTENT_FORMAT != opt_iter.type
 709             && COAP_OPTION_ACCEPT != opt_iter.type
 710             && COAP_OPTION_CONTENT_VERSION != opt_iter.type
 711             && COAP_OPTION_ACCEPT_VERSION != opt_iter.type
 712             && COAP_OPTION_URI_HOST != opt_iter.type && COAP_OPTION_URI_PORT != opt_iter.type
 713             && COAP_OPTION_ETAG != opt_iter.type && COAP_OPTION_MAXAGE != opt_iter.type
 714             && COAP_OPTION_PROXY_SCHEME != opt_iter.type)
 715         {
 716             count++;
 717         }
 718     }
 719
 720     return count;
 721 }
 722
 723 CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint,
 724                             uint32_t *outCode, CAInfo_t *outInfo)
 725 {
 726     VERIFY_NON_NULL(pdu, TAG, "pdu");
 727     VERIFY_NON_NULL(endpoint, TAG, "endpoint");
 728     VERIFY_NON_NULL(outCode, TAG, "outCode");
 729     VERIFY_NON_NULL(outInfo, TAG, "outInfo");
 730
 731     coap_transport_t transport;
 732 #ifdef WITH_TCP
 733     if (CAIsSupportedCoAPOverTCP(endpoint->adapter))
 734     {
 735         transport = coap_get_tcp_header_type_from_initbyte(((unsigned char *)pdu->transport_hdr)[0] >> 4);
 736     }
 737     else
 738 #endif
 739     {
 740         transport = COAP_UDP;
 741     }
 742
 743     coap_opt_iterator_t opt_iter;
 744     coap_option_iterator_init2((coap_pdu_t *) pdu, &opt_iter, COAP_OPT_ALL, transport);
 745
 746     if (outCode)
 747     {
 748         (*outCode) = (uint32_t) CA_RESPONSE_CODE(coap_get_code(pdu, transport));
 749     }
 750
 751     // init HeaderOption list
 752     uint32_t count = CAGetOptionCount(opt_iter);
 753     memset(outInfo, 0, sizeof(*outInfo));
 754
 755     outInfo->numOptions = count;
 756
 757 #ifdef WITH_TCP
 758     if (CAIsSupportedCoAPOverTCP(endpoint->adapter))
 759     {
 760         // set type
 761         outInfo->type = CA_MSG_NONCONFIRM;
 762         outInfo->payloadFormat = CA_FORMAT_UNDEFINED;
 763     }
 764     else
 765 #else
 766     (void) endpoint;
 767 #endif
 768     {
 769         // set type
 770         outInfo->type = pdu->transport_hdr->udp.type;
 771
 772         // set message id
 773         outInfo->messageId = pdu->transport_hdr->udp.id;
 774         outInfo->payloadFormat = CA_FORMAT_UNDEFINED;
 775         outInfo->acceptFormat = CA_FORMAT_UNDEFINED;
 776     }
 777
 778     if (count > 0)
 779     {
 780         outInfo->options = (CAHeaderOption_t *) OICCalloc(count, sizeof(CAHeaderOption_t));
 781         if (NULL == outInfo->options)
 782         {
 783             OIC_LOG(ERROR, TAG, "Out of memory");
 784             return CA_MEMORY_ALLOC_FAILED;
 785         }
 786     }
 787
 788     coap_opt_t *option = NULL;
 789     char optionResult[CA_MAX_URI_LENGTH] = {0};
 790     uint32_t idx = 0;
 791     uint32_t optionLength = 0;
 792     bool isfirstsetflag = false;
 793     bool isQueryBeingProcessed = false;
 794     bool isProxyRequest = false;
 795
 796     while ((option = coap_option_next(&opt_iter)))
 797     {
 798         char buf[COAP_MAX_PDU_SIZE] = {0};
 799         uint32_t bufLength =
 800             CAGetOptionData(opt_iter.type, (uint8_t *)(COAP_OPT_VALUE(option)),
 801                     COAP_OPT_LENGTH(option), (uint8_t *)buf, sizeof(buf));
 802         if (bufLength)
 803         {
 804             OIC_LOG_V(DEBUG, TAG, "COAP URI element : %s", buf);
 805             if (COAP_OPTION_URI_PATH == opt_iter.type || COAP_OPTION_URI_QUERY == opt_iter.type)
 806             {
 807                 if (false == isfirstsetflag)
 808                 {
 809                     isfirstsetflag = true;
 810                     optionResult[optionLength] = '/';
 811                     optionLength++;
 812                     // Make sure there is enough room in the optionResult buffer
 813                     if ((optionLength + bufLength) < sizeof(optionResult))
 814                     {
 815                         memcpy(&optionResult[optionLength], buf, bufLength);
 816                         optionLength += bufLength;
 817                     }
 818                     else
 819                     {
 820                         goto exit;
 821                     }
 822                 }
 823                 else
 824                 {
 825                     if (COAP_OPTION_URI_PATH == opt_iter.type)
 826                     {
 827                         // Make sure there is enough room in the optionResult buffer
 828                         if (optionLength < sizeof(optionResult))
 829                         {
 830                             optionResult[optionLength] = '/';
 831                             optionLength++;
 832                         }
 833                         else
 834                         {
 835                             goto exit;
 836                         }
 837                     }
 838                     else if (COAP_OPTION_URI_QUERY == opt_iter.type)
 839                     {
 840                         if (false == isQueryBeingProcessed)
 841                         {
 842                             // Make sure there is enough room in the optionResult buffer
 843                             if (optionLength < sizeof(optionResult))
 844                             {
 845                                 optionResult[optionLength] = '?';
 846                                 optionLength++;
 847                                 isQueryBeingProcessed = true;
 848                             }
 849                             else
 850                             {
 851                                 goto exit;
 852                             }
 853                         }
 854                         else
 855                         {
 856                             // Make sure there is enough room in the optionResult buffer
 857                             if (optionLength < sizeof(optionResult))
 858                             {
 859                                 optionResult[optionLength] = ';';
 860                                 optionLength++;
 861                             }
 862                             else
 863                             {
 864                                 goto exit;
 865                             }
 866                         }
 867                     }
 868                     // Make sure there is enough room in the optionResult buffer
 869                     if ((optionLength + bufLength) < sizeof(optionResult))
 870                     {
 871                         memcpy(&optionResult[optionLength], buf, bufLength);
 872                         optionLength += bufLength;
 873                     }
 874                     else
 875                     {
 876                         goto exit;
 877                     }
 878                 }
 879             }
 880             else if (COAP_OPTION_BLOCK1 == opt_iter.type || COAP_OPTION_BLOCK2 == opt_iter.type
 881                     || COAP_OPTION_SIZE1 == opt_iter.type || COAP_OPTION_SIZE2 == opt_iter.type)
 882             {
 883                 OIC_LOG_V(DEBUG, TAG, "option[%d] will be filtering", opt_iter.type);
 884             }
 885             else if (COAP_OPTION_CONTENT_FORMAT == opt_iter.type)
 886             {
 887                 if (1 == COAP_OPT_LENGTH(option))
 888                 {
 889                     outInfo->payloadFormat = CAConvertFormat((uint8_t)buf[0]);
 890                 }
 891                 else if (2 == COAP_OPT_LENGTH(option))
 892                 {
 893                     outInfo->payloadFormat = CAConvertFormat(
 894                             coap_decode_var_bytes(COAP_OPT_VALUE(option), COAP_OPT_LENGTH(option)));
 895                 }
 896                 else
 897                 {
 898                     outInfo->payloadFormat = CA_FORMAT_UNSUPPORTED;
 899                     OIC_LOG_V(DEBUG, TAG, "option has an unsupported format");
 900                 }
 901             }
 902             else if (COAP_OPTION_CONTENT_VERSION == opt_iter.type)
 903             {
 904                 if (2 == COAP_OPT_LENGTH(option))
 905                 {
 906                     outInfo->payloadVersion =  coap_decode_var_bytes(COAP_OPT_VALUE(option), COAP_OPT_LENGTH(option));
 907                 }
 908                 else
 909                 {
 910                     OIC_LOG_V(DEBUG, TAG, "unsupported content version");
 911                     outInfo->payloadVersion = DEFAULT_CONTENT_VERSION_VALUE;
 912
 913                 }
 914             }
 915             else if (COAP_OPTION_ACCEPT_VERSION == opt_iter.type)
 916             {
 917                 if (2 == COAP_OPT_LENGTH(option))
 918                 {
 919                     outInfo->acceptVersion = coap_decode_var_bytes(COAP_OPT_VALUE(option), COAP_OPT_LENGTH(option));
 920                 }
 921                 else
 922                 {
 923                     OIC_LOG_V(DEBUG, TAG, "unsupported accept version");
 924                     outInfo->acceptVersion = DEFAULT_ACCEPT_VERSION_VALUE;
 925                 }
 926             }
 927             else if (COAP_OPTION_ACCEPT == opt_iter.type)
 928             {
 929                 if (1 == COAP_OPT_LENGTH(option))
 930                 {
 931                     outInfo->acceptFormat = CAConvertFormat((uint8_t)buf[0]);
 932                 }
 933                 else if (2 == COAP_OPT_LENGTH(option))
 934                 {
 935                     outInfo->acceptFormat = CAConvertFormat(
 936                             coap_decode_var_bytes(COAP_OPT_VALUE(option), COAP_OPT_LENGTH(option)));
 937                 }
 938                 else
 939                 {
 940                     outInfo->acceptFormat = CA_FORMAT_UNSUPPORTED;
 941                     OIC_LOG_V(DEBUG, TAG, "option has an unsupported accept format");
 942                 }
 943             }
 944             else if (COAP_OPTION_URI_PORT == opt_iter.type ||
 945                     COAP_OPTION_URI_HOST == opt_iter.type ||
 946                     COAP_OPTION_ETAG == opt_iter.type ||
 947                     COAP_OPTION_MAXAGE == opt_iter.type ||
 948                     COAP_OPTION_PROXY_SCHEME== opt_iter.type)
 949             {
 950                 OIC_LOG_V(INFO, TAG, "option[%d] has an unsupported format [%d]",
 951                           opt_iter.type, (uint8_t)buf[0]);
 952             }
 953             else
 954             {
 955                 if (COAP_OPTION_PROXY_URI == opt_iter.type)
 956                 {
 957                     isProxyRequest = true;
 958                 }
 959                 if (idx < count)
 960                 {
 961                     if (bufLength <= sizeof(outInfo->options[0].optionData))
 962                     {
 963                         outInfo->options[idx].optionID = opt_iter.type;
 964                         outInfo->options[idx].optionLength = bufLength;
 965                         outInfo->options[idx].protocolID = CA_COAP_ID;
 966                         memcpy(outInfo->options[idx].optionData, buf, bufLength);
 967                         idx++;
 968                     }
 969                 }
 970             }
 971         }
 972     }
 973
 974     unsigned char* token = NULL;
 975     unsigned int token_length = 0;
 976     coap_get_token2(pdu->transport_hdr, transport, &token, &token_length);
 977
 978     // set token data
 979     if (token_length > 0)
 980     {
 981         OIC_LOG_V(DEBUG, TAG, "inside token length : %d", token_length);
 982         outInfo->token = (char *) OICMalloc(token_length);
 983         if (NULL == outInfo->token)
 984         {
 985             OIC_LOG(ERROR, TAG, "Out of memory");
 986             OICFree(outInfo->options);
 987             return CA_MEMORY_ALLOC_FAILED;
 988         }
 989         memcpy(outInfo->token, token, token_length);
 990     }
 991
 992     outInfo->tokenLength = token_length;
 993
 994     // set payload data
 995     size_t dataSize;
 996     uint8_t *data;
 997     if (coap_get_data(pdu, &dataSize, &data))
 998     {
 999         OIC_LOG(DEBUG, TAG, "inside pdu->data");
1000         outInfo->payload = (uint8_t *) OICMalloc(dataSize);
1001         if (NULL == outInfo->payload)
1002         {
1003             OIC_LOG(ERROR, TAG, "Out of memory");
1004             OICFree(outInfo->options);
1005             OICFree(outInfo->token);
1006             return CA_MEMORY_ALLOC_FAILED;
1007         }
1008         memcpy(outInfo->payload, pdu->data, dataSize);
1009         outInfo->payloadSize = dataSize;
1010     }
1011
1012     if (optionResult[0] != '\0')
1013     {
1014         OIC_LOG_V(DEBUG, TAG, "URL length:%zu", strlen(optionResult));
1015         outInfo->resourceUri = OICStrdup(optionResult);
1016         if (!outInfo->resourceUri)
1017         {
1018             OIC_LOG(ERROR, TAG, "Out of memory");
1019             OICFree(outInfo->options);
1020             OICFree(outInfo->token);
1021             return CA_MEMORY_ALLOC_FAILED;
1022         }
1023     }
1024     else if(isProxyRequest && g_chproxyUri[0] != '\0')
1025     {
1026        /*
1027         *   A request for Proxy will not have any uri element as per CoAP specs
1028         *   and only COAP_OPTION_PROXY_URI will be present. Use preset proxy uri
1029         *   for such requests.
1030         */
1031         outInfo->resourceUri = OICStrdup(g_chproxyUri);
1032         if (!outInfo->resourceUri)
1033         {
1034             OIC_LOG(ERROR, TAG, "Out of memory");
1035             OICFree(outInfo->options);
1036             OICFree(outInfo->token);
1037             return CA_MEMORY_ALLOC_FAILED;
1038         }
1039     }
1040     return CA_STATUS_OK;
1041
1042 exit:
1043     OIC_LOG(ERROR, TAG, "buffer too small");
1044     OICFree(outInfo->options);
1045     return CA_STATUS_FAILED;
1046 }
1047
1048 CAResult_t CAGetTokenFromPDU(const coap_hdr_transport_t *pdu_hdr,
1049                              CAInfo_t *outInfo,
1050                              const CAEndpoint_t *endpoint)
1051 {
1052     VERIFY_NON_NULL(pdu_hdr, TAG, "pdu_hdr");
1053     VERIFY_NON_NULL(outInfo, TAG, "outInfo");
1054     VERIFY_NON_NULL(endpoint, TAG, "endpoint");
1055
1056     coap_transport_t transport = COAP_UDP;
1057 #ifdef WITH_TCP
1058     if (CAIsSupportedCoAPOverTCP(endpoint->adapter))
1059     {
1060         transport = coap_get_tcp_header_type_from_initbyte(((unsigned char *)pdu_hdr)[0] >> 4);
1061     }
1062 #endif
1063
1064     unsigned char* token = NULL;
1065     unsigned int token_length = 0;
1066     coap_get_token2(pdu_hdr, transport, &token, &token_length);
1067
1068     // set token data
1069     if (token_length > 0)
1070     {
1071         OIC_LOG_V(DEBUG, TAG, "token len:%d", token_length);
1072         outInfo->token = (char *) OICMalloc(token_length);
1073         if (NULL == outInfo->token)
1074         {
1075             OIC_LOG(ERROR, TAG, "Out of memory");
1076             return CA_MEMORY_ALLOC_FAILED;
1077         }
1078         memcpy(outInfo->token, token, token_length);
1079     }
1080
1081     outInfo->tokenLength = token_length;
1082
1083     return CA_STATUS_OK;
1084 }
1085
1086 CAResult_t CAGenerateTokenInternal(CAToken_t *token, uint8_t tokenLength)
1087 {
1088     VERIFY_NON_NULL(token, TAG, "token");
1089
1090     if ((tokenLength > CA_MAX_TOKEN_LEN) || (0 == tokenLength))
1091     {
1092         OIC_LOG(ERROR, TAG, "invalid token length");
1093         return CA_STATUS_INVALID_PARAM;
1094     }
1095
1096     // memory allocation
1097     char *temp = (char *) OICCalloc(tokenLength, sizeof(char));
1098     if (NULL == temp)
1099     {
1100         OIC_LOG(ERROR, TAG, "Out of memory");
1101         return CA_MEMORY_ALLOC_FAILED;
1102     }
1103
1104     if (!OCGetRandomBytes((uint8_t *)temp, tokenLength))
1105     {
1106         OIC_LOG(ERROR, TAG, "Failed to generate random token");
1107         return CA_STATUS_FAILED;
1108     }
1109
1110     // save token
1111     *token = temp;
1112
1113     OIC_LOG_V(DEBUG, TAG, "token len:%d, token:", tokenLength);
1114     OIC_LOG_BUFFER(DEBUG, TAG, (const uint8_t *)(*token), tokenLength);
1115
1116     return CA_STATUS_OK;
1117 }
1118
1119 void CADestroyTokenInternal(CAToken_t token)
1120 {
1121     OICFree(token);
1122 }
1123
1124 uint32_t CAGetOptionData(uint16_t key, const uint8_t *data, uint32_t len,
1125         uint8_t *option, uint32_t buflen)
1126 {
1127     if (0 == buflen)
1128     {
1129         OIC_LOG(ERROR, TAG, "buflen 0");
1130         return 0;
1131     }
1132
1133     if (buflen <= len)
1134     {
1135         OIC_LOG(ERROR, TAG, "option buffer too small");
1136         return 0;
1137     }
1138
1139     coap_option_def_t* def = coap_opt_def(key);
1140     if (NULL != def && coap_is_var_bytes(def) && 0 == len)
1141     {
1142         // A 0 length option is permitted in CoAP but the
1143         // rest or the stack is unaware of variable byte encoding
1144         // should remain that way so a 0 byte of length 1 is inserted.
1145         len = 1;
1146         option[0]=0;
1147     }
1148     else
1149     {
1150         memcpy(option, data, len);
1151         option[len] = '\0';
1152     }
1153
1154     return len;
1155 }
1156
1157 CAMessageType_t CAGetMessageTypeFromPduBinaryData(const void *pdu, uint32_t size)
1158 {
1159     VERIFY_NON_NULL_RET(pdu, TAG, "pdu", CA_MSG_NONCONFIRM);
1160
1161     // pdu minimum size is 4 byte.
1162     if (size < CA_PDU_MIN_SIZE)
1163     {
1164         OIC_LOG(ERROR, TAG, "min size");
1165         return CA_MSG_NONCONFIRM;
1166     }
1167
1168     coap_hdr_t *hdr = (coap_hdr_t *) pdu;
1169
1170     return (CAMessageType_t) hdr->type;
1171 }
1172
1173 uint16_t CAGetMessageIdFromPduBinaryData(const void *pdu, uint32_t size)
1174 {
1175     VERIFY_NON_NULL_RET(pdu, TAG, "pdu", 0);
1176
1177     // pdu minimum size is 4 byte.
1178     if (size < CA_PDU_MIN_SIZE)
1179     {
1180         OIC_LOG(ERROR, TAG, "min size");
1181         return 0;
1182     }
1183
1184     coap_hdr_t *hdr = (coap_hdr_t *) pdu;
1185
1186     return hdr->id;
1187 }
1188
1189 CAResponseResult_t CAGetCodeFromPduBinaryData(const void *pdu, uint32_t size)
1190 {
1191     VERIFY_NON_NULL_RET(pdu, TAG, "pdu", CA_NOT_FOUND);
1192
1193     // pdu minimum size is 4 byte.
1194     if (size < CA_PDU_MIN_SIZE)
1195     {
1196         OIC_LOG(ERROR, TAG, "min size");
1197         return CA_NOT_FOUND;
1198     }
1199
1200     coap_hdr_t *hdr = (coap_hdr_t *) pdu;
1201
1202     return (CAResponseResult_t) CA_RESPONSE_CODE(hdr->code);
1203 }
1204
1205 CAPayloadFormat_t CAConvertFormat(uint16_t format)
1206 {
1207     switch (format)
1208     {
1209         case COAP_MEDIATYPE_TEXT_PLAIN:
1210             return CA_FORMAT_TEXT_PLAIN;
1211         case COAP_MEDIATYPE_APPLICATION_LINK_FORMAT:
1212             return CA_FORMAT_APPLICATION_LINK_FORMAT;
1213         case COAP_MEDIATYPE_APPLICATION_XML:
1214             return CA_FORMAT_APPLICATION_XML;
1215         case COAP_MEDIATYPE_APPLICATION_OCTET_STREAM:
1216             return CA_FORMAT_APPLICATION_OCTET_STREAM;
1217         case COAP_MEDIATYPE_APPLICATION_RDF_XML:
1218             return CA_FORMAT_APPLICATION_RDF_XML;
1219         case COAP_MEDIATYPE_APPLICATION_EXI:
1220             return CA_FORMAT_APPLICATION_EXI;
1221         case COAP_MEDIATYPE_APPLICATION_JSON:
1222             return CA_FORMAT_APPLICATION_JSON;
1223         case COAP_MEDIATYPE_APPLICATION_CBOR:
1224             return CA_FORMAT_APPLICATION_CBOR;
1225         case COAP_MEDIATYPE_APPLICATION_VND_OCF_CBOR:
1226             return CA_FORMAT_APPLICATION_VND_OCF_CBOR;
1227         default:
1228             return CA_FORMAT_UNSUPPORTED;
1229     }
1230 }
1231
1232 #ifdef WITH_BWT
1233 bool CAIsSupportedBlockwiseTransfer(CATransportAdapter_t adapter)
1234 {
1235     OIC_LOG_V(INFO, TAG, "adapter value is %d", adapter);
1236     if (CA_ADAPTER_IP & adapter || CA_ADAPTER_NFC & adapter
1237             || CA_DEFAULT_ADAPTER == adapter)
1238     {
1239         return true;
1240     }
1241     return false;
1242 }
1243 #endif
1244
1245 #ifdef WITH_TCP
1246 bool CAIsSupportedCoAPOverTCP(CATransportAdapter_t adapter)
1247 {
1248     OIC_LOG_V(INFO, TAG, "adapter value is %d", adapter);
1249     if (CA_ADAPTER_GATT_BTLE & adapter || CA_ADAPTER_RFCOMM_BTEDR & adapter
1250             || CA_ADAPTER_TCP & adapter || CA_DEFAULT_ADAPTER == adapter)
1251     {
1252         return true;
1253     }
1254     return false;
1255 }
1256 #endif