X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=resource%2Fcsdk%2Fconnectivity%2Fsrc%2Fcaprotocolmessage.c;h=0ab1ae7f3db3abb8a8cae05a2e9c48693ce79ab1;hb=03ae7cd73e2e10a8de75da40a0e476cc955b46b2;hp=04b80a0554aac977a32082004126f11b02a083cf;hpb=86f70cfd6278136a0a3d86c1f2a393c1286006c4;p=platform%2Fupstream%2Fiotivity.git diff --git a/resource/csdk/connectivity/src/caprotocolmessage.c b/resource/csdk/connectivity/src/caprotocolmessage.c old mode 100644 new mode 100755 index 04b80a0..0ab1ae7 --- a/resource/csdk/connectivity/src/caprotocolmessage.c +++ b/resource/csdk/connectivity/src/caprotocolmessage.c @@ -24,11 +24,11 @@ // For glibc information on feature test macros, // Refer http://www.gnu.org/software/libc/manual/html_node/Feature-Test-Macros.html // -// This file requires #define use due to random() and srandom() // For details on compatibility and glibc support, // Refer http://www.gnu.org/software/libc/manual/html_node/BSD-Random.html #define _DEFAULT_SOURCE +#include "iotivity_config.h" #include #include #include @@ -41,93 +41,73 @@ #include "logger.h" #include "oic_malloc.h" #include "oic_string.h" +#include "ocrandom.h" +#include "cacommonutil.h" -// ARM GCC compiler doesnt define srandom function. -#if defined(ARDUINO) && !defined(ARDUINO_ARCH_SAM) -#define HAVE_SRANDOM 1 -#endif - -#define TAG "CA_PRTCL_MSG" - -/** - * @def VERIFY_NON_NULL_RET - * @brief Macro to verify the validity of input argument - */ -#define VERIFY_NON_NULL_RET(arg, log_tag, log_message,ret) \ - if (NULL == arg ){ \ - OIC_LOG_V(ERROR, log_tag, "Invalid input:%s", log_message); \ - return ret; \ - } +#define TAG "OIC_CA_PRTCL_MSG" -#define CA_BUFSIZE (128) #define CA_PDU_MIN_SIZE (4) -#define CA_PORT_BUFFER_SIZE (4) +#define CA_ENCODE_BUFFER_SIZE (4) static const char COAP_URI_HEADER[] = "coap://[::]/"; -static unsigned int SEED = 0; +#ifdef WITH_CHPROXY +static char g_chproxyUri[CA_MAX_URI_LENGTH]; + +CAResult_t CASetProxyUri(const char *uri) +{ + VERIFY_NON_NULL(uri, TAG, "uri"); + OICStrcpy(g_chproxyUri, sizeof (g_chproxyUri), uri); + return CA_STATUS_OK; +} +#endif CAResult_t CAGetRequestInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint, CARequestInfo_t *outReqInfo) { - OIC_LOG(DEBUG, TAG, "IN"); - - if (NULL == pdu || NULL == outReqInfo) - { - OIC_LOG(ERROR, TAG, "parameter is null"); - return CA_STATUS_INVALID_PARAM; - } + VERIFY_NON_NULL(pdu, TAG, "pdu"); + VERIFY_NON_NULL(outReqInfo, TAG, "outReqInfo"); uint32_t code = CA_NOT_FOUND; CAResult_t ret = CAGetInfoFromPDU(pdu, endpoint, &code, &(outReqInfo->info)); outReqInfo->method = code; - OIC_LOG(DEBUG, TAG, "OUT"); return ret; } CAResult_t CAGetResponseInfoFromPDU(const coap_pdu_t *pdu, CAResponseInfo_t *outResInfo, const CAEndpoint_t *endpoint) { - OIC_LOG(DEBUG, TAG, "IN"); - - if (NULL == pdu || NULL == outResInfo) - { - OIC_LOG(ERROR, TAG, "parameter is null"); - return CA_STATUS_INVALID_PARAM; - } + VERIFY_NON_NULL(pdu, TAG, "pdu"); + VERIFY_NON_NULL(outResInfo, TAG, "outResInfo"); uint32_t code = CA_NOT_FOUND; CAResult_t ret = CAGetInfoFromPDU(pdu, endpoint, &code, &(outResInfo->info)); outResInfo->result = code; - OIC_LOG(DEBUG, TAG, "OUT"); return ret; } CAResult_t CAGetErrorInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint, CAErrorInfo_t *errorInfo) { - OIC_LOG(DEBUG, TAG, "IN"); - - if (!pdu) - { - OIC_LOG(ERROR, TAG, "parameter is null"); - return CA_STATUS_INVALID_PARAM; - } + VERIFY_NON_NULL(pdu, TAG, "pdu"); uint32_t code = 0; CAResult_t ret = CAGetInfoFromPDU(pdu, endpoint, &code, &errorInfo->info); - OIC_LOG(DEBUG, TAG, "OUT"); + return ret; } -coap_pdu_t *CAGeneratePDU(uint32_t code, const CAInfo_t *info, const CAEndpoint_t *endpoint) +coap_pdu_t *CAGeneratePDU(uint32_t code, const CAInfo_t *info, const CAEndpoint_t *endpoint, + coap_list_t **optlist, coap_transport_t *transport) { - OIC_LOG(DEBUG, TAG, "IN"); - VERIFY_NON_NULL_RET(info, TAG, "info", NULL); VERIFY_NON_NULL_RET(endpoint, TAG, "endpoint", NULL); + VERIFY_NON_NULL_RET(optlist, TAG, "optlist", NULL); + + OIC_LOG_V(DEBUG, TAG, "generate pdu for [%d]adapter, [%d]flags", + endpoint->adapter, endpoint->flags); coap_pdu_t *pdu = NULL; @@ -135,8 +115,20 @@ coap_pdu_t *CAGeneratePDU(uint32_t code, const CAInfo_t *info, const CAEndpoint_ // and ACKNOWLEDGE can use empty message when code is empty. if (CA_MSG_RESET == info->type || (CA_EMPTY == code && CA_MSG_ACKNOWLEDGE == info->type)) { + if (CA_EMPTY != code) + { + OIC_LOG(ERROR, TAG, "reset is not empty message"); + return NULL; + } + + if (info->payloadSize > 0 || info->payload || info->token || info->tokenLength > 0) + { + OIC_LOG(ERROR, TAG, "Empty message has unnecessary data after messageID"); + return NULL; + } + OIC_LOG(DEBUG, TAG, "code is empty"); - if (!(pdu = CAGeneratePDUImpl((code_t) code, info, endpoint, NULL))) + if (!(pdu = CAGeneratePDUImpl((code_t) code, info, endpoint, NULL, transport))) { OIC_LOG(ERROR, TAG, "pdu NULL"); return NULL; @@ -144,18 +136,11 @@ coap_pdu_t *CAGeneratePDU(uint32_t code, const CAInfo_t *info, const CAEndpoint_ } else { - coap_list_t *optlist = NULL; - - if (CA_MSG_ACKNOWLEDGE != info->type) + if (info->resourceUri) { - const char *uri = info->resourceUri; - if (NULL == uri) - { - OIC_LOG(ERROR, TAG, "uri NULL"); - return NULL; - } + OIC_LOG_V(DEBUG, TAG, "uri : %s", info->resourceUri); - uint32_t length = strlen(uri); + uint32_t length = strlen(info->resourceUri); if (CA_MAX_URI_LENGTH < length) { OIC_LOG(ERROR, TAG, "URI len err"); @@ -170,16 +155,12 @@ coap_pdu_t *CAGeneratePDU(uint32_t code, const CAInfo_t *info, const CAEndpoint_ return NULL; } OICStrcat(coapUri, uriLength, COAP_URI_HEADER); - OICStrcat(coapUri, uriLength, uri); + OICStrcat(coapUri, uriLength, info->resourceUri); // parsing options in URI - CAResult_t res = CAParseURI(coapUri, &optlist); + CAResult_t res = CAParseURI(coapUri, optlist); if (CA_STATUS_OK != res) { - if (optlist) - { - coap_delete_list(optlist); - } OICFree(coapUri); return NULL; } @@ -187,92 +168,75 @@ coap_pdu_t *CAGeneratePDU(uint32_t code, const CAInfo_t *info, const CAEndpoint_ OICFree(coapUri); } // parsing options in HeadOption - CAResult_t ret = CAParseHeadOption(code, info, &optlist); + CAResult_t ret = CAParseHeadOption(code, info, optlist); if (CA_STATUS_OK != ret) { - coap_delete_list(optlist); return NULL; } - pdu = CAGeneratePDUImpl((code_t) code, info, endpoint, optlist); + pdu = CAGeneratePDUImpl((code_t) code, info, endpoint, *optlist, transport); if (NULL == pdu) { OIC_LOG(ERROR, TAG, "pdu NULL"); - coap_delete_list(optlist); return NULL; } - - // free option list - coap_delete_list(optlist); } // pdu print method : coap_show_pdu(pdu); - OIC_LOG(DEBUG, TAG, "OUT"); return pdu; } coap_pdu_t *CAParsePDU(const char *data, uint32_t length, uint32_t *outCode, const CAEndpoint_t *endpoint) { - OIC_LOG(DEBUG, TAG, "IN"); - - if (NULL == data) - { - OIC_LOG(ERROR, TAG, "data is null"); - return NULL; - } + VERIFY_NON_NULL_RET(data, TAG, "data", NULL); + VERIFY_NON_NULL_RET(endpoint, TAG, "endpoint", NULL); - coap_transport_type transport; -#ifdef TCP_ADAPTER - if (CA_ADAPTER_TCP == endpoint->adapter) + coap_transport_t transport = COAP_UDP; +#ifdef WITH_TCP + if (CAIsSupportedCoAPOverTCP(endpoint->adapter)) { transport = coap_get_tcp_header_type_from_initbyte(((unsigned char *)data)[0] >> 4); } - else #endif - { - transport = coap_udp; - } - coap_pdu_t *outpdu = coap_new_pdu(transport, length); + coap_pdu_t *outpdu = coap_new_pdu2(transport, length); if (NULL == outpdu) { OIC_LOG(ERROR, TAG, "outpdu is null"); + OIC_LOG_V(ERROR, TAG, "data length: %u", length); return NULL; } OIC_LOG_V(DEBUG, TAG, "pdu parse-transport type : %d", transport); - int ret = coap_pdu_parse((unsigned char *) data, length, outpdu, transport); + int ret = coap_pdu_parse2((unsigned char *) data, length, outpdu, transport); OIC_LOG_V(DEBUG, TAG, "pdu parse ret: %d", ret); if (0 >= ret) { OIC_LOG(ERROR, TAG, "pdu parse failed"); - coap_delete_pdu(outpdu); - return NULL; + goto exit; } -#ifdef TCP_ADAPTER - if (CA_ADAPTER_TCP == endpoint->adapter) +#ifdef WITH_TCP + if (CAIsSupportedCoAPOverTCP(endpoint->adapter)) { OIC_LOG(INFO, TAG, "there is no version info in coap header"); } else #endif { - if (outpdu->hdr->coap_hdr_udp_t.version != COAP_DEFAULT_VERSION) + if (outpdu->transport_hdr->udp.version != COAP_DEFAULT_VERSION) { OIC_LOG_V(ERROR, TAG, "coap version is not available : %d", - outpdu->hdr->coap_hdr_udp_t.version); - coap_delete_pdu(outpdu); - return NULL; + outpdu->transport_hdr->udp.version); + goto exit; } - if (outpdu->hdr->coap_hdr_udp_t.token_length > CA_MAX_TOKEN_LEN) + if (outpdu->transport_hdr->udp.token_length > CA_MAX_TOKEN_LEN) { OIC_LOG_V(ERROR, TAG, "token length has been exceed : %d", - outpdu->hdr->coap_hdr_udp_t.token_length); - coap_delete_pdu(outpdu); - return NULL; + outpdu->transport_hdr->udp.token_length); + goto exit; } } @@ -281,46 +245,70 @@ coap_pdu_t *CAParsePDU(const char *data, uint32_t length, uint32_t *outCode, (*outCode) = (uint32_t) CA_RESPONSE_CODE(coap_get_code(outpdu, transport)); } - OIC_LOG(DEBUG, TAG, "OUT"); return outpdu; + +exit: + OIC_LOG(DEBUG, TAG, "data :"); + OIC_LOG_BUFFER(DEBUG, TAG, (const uint8_t*) data, length); + coap_delete_pdu(outpdu); + return NULL; } coap_pdu_t *CAGeneratePDUImpl(code_t code, const CAInfo_t *info, - const CAEndpoint_t *endpoint, coap_list_t *options) + const CAEndpoint_t *endpoint, coap_list_t *options, + coap_transport_t *transport) { - OIC_LOG(DEBUG, TAG, "IN"); VERIFY_NON_NULL_RET(info, TAG, "info", NULL); VERIFY_NON_NULL_RET(endpoint, TAG, "endpoint", NULL); + VERIFY_NON_NULL_RET(transport, TAG, "transport", NULL); - coap_transport_type transport; unsigned int length = COAP_MAX_PDU_SIZE; -#ifdef TCP_ADAPTER - unsigned int headerLength = 0; - if (CA_ADAPTER_TCP == endpoint->adapter) +#ifdef WITH_TCP + unsigned int msgLength = 0; + if (CAIsSupportedCoAPOverTCP(endpoint->adapter)) { if (options) { + unsigned short prevOptNumber = 0; for (coap_list_t *opt = options; opt; opt = opt->next) { - headerLength += COAP_OPTION_LENGTH(*(coap_option *) opt->data) + 1; + unsigned short curOptNumber = COAP_OPTION_KEY(*(coap_option *) opt->data); + if (prevOptNumber > curOptNumber) + { + OIC_LOG(ERROR, TAG, "option list is wrong"); + return NULL; + } + + size_t optValueLen = COAP_OPTION_LENGTH(*(coap_option *) opt->data); + size_t optLength = coap_get_opt_header_length(curOptNumber - prevOptNumber, optValueLen); + if (0 == optLength) + { + OIC_LOG(ERROR, TAG, "Reserved for the Payload marker for the option"); + return NULL; + } + msgLength += optLength; + prevOptNumber = curOptNumber; + OIC_LOG_V(DEBUG, TAG, "curOptNumber[%d], prevOptNumber[%d], optValueLen[%zu], " + "optLength[%zu], msgLength[%d]", + curOptNumber, prevOptNumber, optValueLen, optLength, msgLength); } } if (info->payloadSize > 0) { - headerLength = headerLength + info->payloadSize + 1; + msgLength = msgLength + info->payloadSize + PAYLOAD_MARKER; } - transport = coap_get_tcp_header_type_from_size(headerLength); - length = headerLength + coap_get_tcp_header_length_for_transport(transport) + *transport = coap_get_tcp_header_type_from_size(msgLength); + length = msgLength + coap_get_tcp_header_length_for_transport(*transport) + info->tokenLength; } else #endif { - transport = coap_udp; + *transport = COAP_UDP; } - coap_pdu_t *pdu = coap_new_pdu(transport, length); + coap_pdu_t *pdu = coap_new_pdu2(*transport, length); if (NULL == pdu) { @@ -328,19 +316,19 @@ coap_pdu_t *CAGeneratePDUImpl(code_t code, const CAInfo_t *info, return NULL; } - OIC_LOG_V(DEBUG, TAG, "transport type: %d, payload size: %d", - transport, info->payloadSize); + OIC_LOG_V(DEBUG, TAG, "transport type: %d, payload size: %zu", + *transport, info->payloadSize); -#ifdef TCP_ADAPTER - if (CA_ADAPTER_TCP == endpoint->adapter) +#ifdef WITH_TCP + if (CAIsSupportedCoAPOverTCP(endpoint->adapter)) { - coap_add_length(pdu, transport, headerLength); + coap_add_length(pdu, *transport, msgLength); } else #endif { OIC_LOG_V(DEBUG, TAG, "msgID is %d", info->messageId); - uint16_t message_id; + uint16_t message_id = 0; if (0 == info->messageId) { /* initialize message id */ @@ -353,13 +341,13 @@ coap_pdu_t *CAGeneratePDUImpl(code_t code, const CAInfo_t *info, /* use saved message id */ message_id = info->messageId; } - pdu->hdr->coap_hdr_udp_t.id = message_id; - OIC_LOG_V(DEBUG, TAG, "messageId in pdu is %d, %d", message_id, pdu->hdr->coap_hdr_udp_t.id); + pdu->transport_hdr->udp.id = message_id; + OIC_LOG_V(DEBUG, TAG, "messageId in pdu is %d, %d", message_id, pdu->transport_hdr->udp.id); - pdu->hdr->coap_hdr_udp_t.type = info->type; + pdu->transport_hdr->udp.type = info->type; } - coap_add_code(pdu, transport, code); + coap_add_code(pdu, *transport, code); if (info->token && CA_EMPTY != code) { @@ -367,13 +355,25 @@ coap_pdu_t *CAGeneratePDUImpl(code_t code, const CAInfo_t *info, OIC_LOG_V(DEBUG, TAG, "token info token length: %d, token :", tokenLength); OIC_LOG_BUFFER(DEBUG, TAG, (const uint8_t *)info->token, tokenLength); - int32_t ret = coap_add_token(pdu, tokenLength, (unsigned char *)info->token, transport); + int32_t ret = coap_add_token2(pdu, tokenLength, (unsigned char *)info->token, *transport); if (0 == ret) { OIC_LOG(ERROR, TAG, "can't add token"); } } +#ifdef WITH_BWT + if (CA_ADAPTER_GATT_BTLE != endpoint->adapter +#ifdef WITH_TCP + && !CAIsSupportedCoAPOverTCP(endpoint->adapter) +#endif + ) + { + // option list will be added in blockwise-transfer + return pdu; + } +#endif + if (options) { for (coap_list_t *opt = options; opt; opt = opt->next) @@ -382,53 +382,27 @@ coap_pdu_t *CAGeneratePDUImpl(code_t code, const CAInfo_t *info, COAP_OPTION_DATA(*(coap_option *) opt->data)); OIC_LOG_V(DEBUG, TAG, "[%d] pdu length", pdu->length); - coap_add_option(pdu, COAP_OPTION_KEY(*(coap_option *) opt->data), - COAP_OPTION_LENGTH(*(coap_option *) opt->data), - COAP_OPTION_DATA(*(coap_option *) opt->data), transport); + coap_add_option2(pdu, COAP_OPTION_KEY(*(coap_option *) opt->data), + COAP_OPTION_LENGTH(*(coap_option *) opt->data), + COAP_OPTION_DATA(*(coap_option *) opt->data), *transport); } } OIC_LOG_V(DEBUG, TAG, "[%d] pdu length after option", pdu->length); - bool enabledPayload = false; -#ifndef WITH_BWT - enabledPayload = true; -#endif - - if (enabledPayload || CA_ADAPTER_GATT_BTLE == endpoint->adapter -#ifdef TCP_ADAPTER - || CA_ADAPTER_TCP == endpoint->adapter -#endif - ) + if (NULL != info->payload && 0 < info->payloadSize) { - if (NULL != info->payload && 0 < info->payloadSize) - { - OIC_LOG(DEBUG, TAG, "payload is added"); - coap_add_data(pdu, info->payloadSize, (const unsigned char *) info->payload); - } + OIC_LOG(DEBUG, TAG, "payload is added"); + coap_add_data(pdu, info->payloadSize, (const unsigned char *) info->payload); } - OIC_LOG(DEBUG, TAG, "OUT"); return pdu; } CAResult_t CAParseURI(const char *uriInfo, coap_list_t **optlist) { - OIC_LOG(DEBUG, TAG, "IN"); - - if (NULL == uriInfo) - { - OIC_LOG(ERROR, TAG, "uriInfo is null"); - return CA_STATUS_INVALID_PARAM; - } - - OIC_LOG_V(DEBUG, TAG, "url : %s", uriInfo); - - if (NULL == optlist) - { - OIC_LOG(ERROR, TAG, "optlist is null"); - return CA_STATUS_INVALID_PARAM; - } + VERIFY_NON_NULL(uriInfo, TAG, "uriInfo"); + VERIFY_NON_NULL(optlist, TAG, "optlist"); /* split arg into Uri-* options */ coap_uri_t uri; @@ -436,7 +410,7 @@ CAResult_t CAParseURI(const char *uriInfo, coap_list_t **optlist) if (uri.port != COAP_DEFAULT_PORT) { - unsigned char portbuf[CA_PORT_BUFFER_SIZE] = { 0 }; + unsigned char portbuf[CA_ENCODE_BUFFER_SIZE] = { 0 }; int ret = coap_insert(optlist, CACreateNewOptionNode(COAP_OPTION_URI_PORT, coap_encode_var_bytes(portbuf, uri.port), @@ -470,18 +444,13 @@ CAResult_t CAParseURI(const char *uriInfo, coap_list_t **optlist) } } - OIC_LOG(DEBUG, TAG, "OUT"); return CA_STATUS_OK; } CAResult_t CAParseUriPartial(const unsigned char *str, size_t length, int target, coap_list_t **optlist) { - if (!optlist) - { - OIC_LOG(ERROR, TAG, "optlist is null"); - return CA_STATUS_INVALID_PARAM; - } + VERIFY_NON_NULL(optlist, TAG, "optlist"); if ((target != COAP_OPTION_URI_PATH) && (target != COAP_OPTION_URI_QUERY)) { @@ -491,14 +460,16 @@ CAResult_t CAParseUriPartial(const unsigned char *str, size_t length, int target } else if (str && length) { - unsigned char uriBuffer[CA_BUFSIZE] = { 0 }; + unsigned char uriBuffer[CA_MAX_URI_LENGTH] = { 0 }; unsigned char *pBuf = uriBuffer; - size_t buflen = sizeof(uriBuffer); - int res = (target == COAP_OPTION_URI_PATH) ? coap_split_path(str, length, pBuf, &buflen) : - coap_split_query(str, length, pBuf, &buflen); + size_t unusedBufferSize = sizeof(uriBuffer); + int res = (target == COAP_OPTION_URI_PATH) ? coap_split_path(str, length, pBuf, &unusedBufferSize) : + coap_split_query(str, length, pBuf, &unusedBufferSize); if (res > 0) { + assert(unusedBufferSize < sizeof(uriBuffer)); + size_t usedBufferSize = sizeof(uriBuffer) - unusedBufferSize; size_t prevIdx = 0; while (res--) { @@ -512,11 +483,13 @@ CAResult_t CAParseUriPartial(const unsigned char *str, size_t length, int target } size_t optSize = COAP_OPT_SIZE(pBuf); - if ((prevIdx + optSize) < buflen) + if (prevIdx + optSize > usedBufferSize) { - pBuf += optSize; - prevIdx += optSize; + assert(false); + return CA_STATUS_INVALID_PARAM; } + pBuf += optSize; + prevIdx += optSize; } } else @@ -537,8 +510,7 @@ CAResult_t CAParseUriPartial(const unsigned char *str, size_t length, int target CAResult_t CAParseHeadOption(uint32_t code, const CAInfo_t *info, coap_list_t **optlist) { (void)code; - OIC_LOG(DEBUG, TAG, "IN"); - VERIFY_NON_NULL_RET(info, TAG, "info is NULL", CA_STATUS_INVALID_PARAM); + VERIFY_NON_NULL_RET(info, TAG, "info", CA_STATUS_INVALID_PARAM); OIC_LOG_V(DEBUG, TAG, "parse Head Opt: %d", info->numOptions); @@ -563,19 +535,14 @@ CAResult_t CAParseHeadOption(uint32_t code, const CAInfo_t *info, coap_list_t ** } else { - if ((info->options + i)->optionData && (info->options + i)->optionLength > 0) + OIC_LOG_V(DEBUG, TAG, "Head opt ID[%d], length[%d]", id, (info->options + i)->optionLength); + int ret = coap_insert(optlist, + CACreateNewOptionNode(id, (info->options + i)->optionLength, + (info->options + i)->optionData), + CAOrderOpts); + if (ret <= 0) { - OIC_LOG_V(DEBUG, TAG, "Head opt ID: %d", id); - OIC_LOG_V(DEBUG, TAG, "Head opt data: %s", (info->options + i)->optionData); - OIC_LOG_V(DEBUG, TAG, "Head opt length: %d", (info->options + i)->optionLength); - int ret = coap_insert(optlist, - CACreateNewOptionNode(id, (info->options + i)->optionLength, - (info->options + i)->optionData), - CAOrderOpts); - if (ret <= 0) - { - return CA_STATUS_INVALID_PARAM; - } + return CA_STATUS_INVALID_PARAM; } } } @@ -584,12 +551,13 @@ CAResult_t CAParseHeadOption(uint32_t code, const CAInfo_t *info, coap_list_t ** if (CA_FORMAT_UNDEFINED != info->payloadFormat) { coap_list_t* node = NULL; - uint8_t buf[3] = {0}; - switch (info->payloadFormat) { + uint8_t buf[CA_ENCODE_BUFFER_SIZE] = {0}; + switch (info->payloadFormat) + { case CA_FORMAT_APPLICATION_CBOR: node = CACreateNewOptionNode( COAP_OPTION_CONTENT_FORMAT, - coap_encode_var_bytes(buf, (uint16_t)COAP_MEDIATYPE_APPLICATION_CBOR), + coap_encode_var_bytes(buf, (unsigned short)COAP_MEDIATYPE_APPLICATION_CBOR), (char *)buf); break; default: @@ -611,12 +579,13 @@ CAResult_t CAParseHeadOption(uint32_t code, const CAInfo_t *info, coap_list_t ** if (CA_FORMAT_UNDEFINED != info->acceptFormat) { coap_list_t* node = NULL; - uint8_t buf[3] = {0}; - switch (info->acceptFormat) { + uint8_t buf[CA_ENCODE_BUFFER_SIZE] = {0}; + switch (info->acceptFormat) + { case CA_FORMAT_APPLICATION_CBOR: node = CACreateNewOptionNode( COAP_OPTION_ACCEPT, - coap_encode_var_bytes(buf, (uint16_t)COAP_MEDIATYPE_APPLICATION_CBOR), + coap_encode_var_bytes(buf, (unsigned short)COAP_MEDIATYPE_APPLICATION_CBOR), (char *)buf); break; default: @@ -636,19 +605,12 @@ CAResult_t CAParseHeadOption(uint32_t code, const CAInfo_t *info, coap_list_t ** } } - OIC_LOG(DEBUG, TAG, "OUT"); return CA_STATUS_OK; } coap_list_t *CACreateNewOptionNode(uint16_t key, uint32_t length, const char *data) { - OIC_LOG(DEBUG, TAG, "IN"); - - if (!data) - { - OIC_LOG(ERROR, TAG, "invalid pointer parameter"); - return NULL; - } + VERIFY_NON_NULL_RET(data, TAG, "data", NULL); coap_option *option = coap_malloc(sizeof(coap_option) + length + 1); if (!option) @@ -694,13 +656,11 @@ coap_list_t *CACreateNewOptionNode(uint16_t key, uint32_t length, const char *da return NULL; } - OIC_LOG(DEBUG, TAG, "OUT"); return node; } int CAOrderOpts(void *a, void *b) { - OIC_LOG(DEBUG, TAG, "IN"); if (!a || !b) { return a < b ? -1 : 1; @@ -711,15 +671,13 @@ int CAOrderOpts(void *a, void *b) return -1; } - OIC_LOG(DEBUG, TAG, "OUT"); return COAP_OPTION_KEY(*(coap_option *) a) == COAP_OPTION_KEY(*(coap_option * ) b); } uint32_t CAGetOptionCount(coap_opt_iterator_t opt_iter) { - OIC_LOG(DEBUG, TAG, "IN"); uint32_t count = 0; - coap_opt_t *option; + coap_opt_t *option = NULL; while ((option = coap_option_next(&opt_iter))) { @@ -727,41 +685,40 @@ uint32_t CAGetOptionCount(coap_opt_iterator_t opt_iter) && COAP_OPTION_BLOCK1 != opt_iter.type && COAP_OPTION_BLOCK2 != opt_iter.type && COAP_OPTION_SIZE1 != opt_iter.type && COAP_OPTION_SIZE2 != opt_iter.type && COAP_OPTION_CONTENT_FORMAT != opt_iter.type - && COAP_OPTION_ACCEPT != opt_iter.type) + && COAP_OPTION_ACCEPT != opt_iter.type + && COAP_OPTION_URI_HOST != opt_iter.type && COAP_OPTION_URI_PORT != opt_iter.type + && COAP_OPTION_ETAG != opt_iter.type && COAP_OPTION_MAXAGE != opt_iter.type + && COAP_OPTION_PROXY_SCHEME != opt_iter.type) { count++; } } - OIC_LOG(DEBUG, TAG, "OUT"); return count; } CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint, uint32_t *outCode, CAInfo_t *outInfo) { - OIC_LOG(DEBUG, TAG, "IN"); - - if (!pdu || !outCode || !outInfo) - { - OIC_LOG(ERROR, TAG, "NULL pointer param"); - return CA_STATUS_INVALID_PARAM; - } + VERIFY_NON_NULL(pdu, TAG, "pdu"); + VERIFY_NON_NULL(endpoint, TAG, "endpoint"); + VERIFY_NON_NULL(outCode, TAG, "outCode"); + VERIFY_NON_NULL(outInfo, TAG, "outInfo"); - coap_transport_type transport; -#ifdef TCP_ADAPTER - if (CA_ADAPTER_TCP == endpoint->adapter) + coap_transport_t transport; +#ifdef WITH_TCP + if (CAIsSupportedCoAPOverTCP(endpoint->adapter)) { - transport = coap_get_tcp_header_type_from_initbyte(((unsigned char *)pdu->hdr)[0] >> 4); + transport = coap_get_tcp_header_type_from_initbyte(((unsigned char *)pdu->transport_hdr)[0] >> 4); } else #endif { - transport = coap_udp; + transport = COAP_UDP; } coap_opt_iterator_t opt_iter; - coap_option_iterator_init((coap_pdu_t *) pdu, &opt_iter, COAP_OPT_ALL, transport); + coap_option_iterator_init2((coap_pdu_t *) pdu, &opt_iter, COAP_OPT_ALL, transport); if (outCode) { @@ -774,21 +731,23 @@ CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint, outInfo->numOptions = count; -#ifdef TCP_ADAPTER - if (CA_ADAPTER_TCP == endpoint->adapter) +#ifdef WITH_TCP + if (CAIsSupportedCoAPOverTCP(endpoint->adapter)) { // set type outInfo->type = CA_MSG_NONCONFIRM; outInfo->payloadFormat = CA_FORMAT_UNDEFINED; } else +#else + (void) endpoint; #endif { // set type - outInfo->type = pdu->hdr->coap_hdr_udp_t.type; + outInfo->type = pdu->transport_hdr->udp.type; // set message id - outInfo->messageId = pdu->hdr->coap_hdr_udp_t.id; + outInfo->messageId = pdu->transport_hdr->udp.id; outInfo->payloadFormat = CA_FORMAT_UNDEFINED; outInfo->acceptFormat = CA_FORMAT_UNDEFINED; } @@ -803,12 +762,15 @@ CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint, } } - coap_opt_t *option; + coap_opt_t *option = NULL; char optionResult[CA_MAX_URI_LENGTH] = {0}; uint32_t idx = 0; uint32_t optionLength = 0; bool isfirstsetflag = false; bool isQueryBeingProcessed = false; +#ifdef WITH_CHPROXY + bool isProxyRequest = false; +#endif while ((option = coap_option_next(&opt_iter))) { @@ -909,7 +871,7 @@ CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint, { outInfo->payloadFormat = CA_FORMAT_UNSUPPORTED; OIC_LOG_V(DEBUG, TAG, "option[%d] has an unsupported format [%d]", - opt_iter.type, (uint8_t)buf[0]); + opt_iter.type, (uint8_t)buf[0]); } } else if (COAP_OPTION_ACCEPT == opt_iter.type) @@ -923,20 +885,33 @@ CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint, outInfo->acceptFormat = CA_FORMAT_UNSUPPORTED; } OIC_LOG_V(DEBUG, TAG, "option[%d] has an unsupported format [%d]", - opt_iter.type, (uint8_t)buf[0]); + opt_iter.type, (uint8_t)buf[0]); + } + else if (COAP_OPTION_URI_PORT == opt_iter.type || + COAP_OPTION_URI_HOST == opt_iter.type || + COAP_OPTION_ETAG == opt_iter.type || + COAP_OPTION_MAXAGE == opt_iter.type || + COAP_OPTION_PROXY_SCHEME== opt_iter.type) + { + OIC_LOG_V(INFO, TAG, "option[%d] has an unsupported format [%d]", + opt_iter.type, (uint8_t)buf[0]); } else { +#ifdef WITH_CHPROXY + if (COAP_OPTION_PROXY_URI == opt_iter.type) + { + isProxyRequest = true; + } +#endif if (idx < count) { - uint32_t length = bufLength; - - if (length <= CA_MAX_HEADER_OPTION_DATA_LENGTH) + if (bufLength <= sizeof(outInfo->options[0].optionData)) { outInfo->options[idx].optionID = opt_iter.type; - outInfo->options[idx].optionLength = length; + outInfo->options[idx].optionLength = bufLength; outInfo->options[idx].protocolID = CA_COAP_ID; - memcpy(outInfo->options[idx].optionData, buf, length); + memcpy(outInfo->options[idx].optionData, buf, bufLength); idx++; } } @@ -946,7 +921,7 @@ CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint, unsigned char* token = NULL; unsigned int token_length = 0; - coap_get_token(pdu->hdr, transport, &token, &token_length); + coap_get_token2(pdu->transport_hdr, transport, &token, &token_length); // set token data if (token_length > 0) @@ -984,7 +959,7 @@ CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint, if (optionResult[0] != '\0') { - OIC_LOG_V(DEBUG, TAG, "URL length:%d", strlen(optionResult)); + OIC_LOG_V(DEBUG, TAG, "URL length:%zu", strlen(optionResult)); outInfo->resourceUri = OICStrdup(optionResult); if (!outInfo->resourceUri) { @@ -994,8 +969,24 @@ CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint, return CA_MEMORY_ALLOC_FAILED; } } - - OIC_LOG(DEBUG, TAG, "OUT"); +#ifdef WITH_CHPROXY + else if(isProxyRequest && g_chproxyUri[0] != '\0') + { + /* + * A request for CoAP-HTTP Proxy will not have any uri element as per CoAP specs + * and only COAP_OPTION_PROXY_URI will be present. Use preset proxy uri + * for such requests. + */ + outInfo->resourceUri = OICStrdup(g_chproxyUri); + if (!outInfo->resourceUri) + { + OIC_LOG(ERROR, TAG, "Out of memory"); + OICFree(outInfo->options); + OICFree(outInfo->token); + return CA_MEMORY_ALLOC_FAILED; + } + } +#endif return CA_STATUS_OK; exit: @@ -1004,40 +995,28 @@ exit: return CA_STATUS_FAILED; } -CAResult_t CAGetTokenFromPDU(const coap_hdr_t *pdu_hdr, CAInfo_t *outInfo, +CAResult_t CAGetTokenFromPDU(const coap_hdr_transport_t *pdu_hdr, + CAInfo_t *outInfo, const CAEndpoint_t *endpoint) { - OIC_LOG(DEBUG, TAG, "IN"); - if (NULL == pdu_hdr) - { - OIC_LOG(ERROR, TAG, "pdu_hdr is null"); - return CA_STATUS_INVALID_PARAM; - } - - if (NULL == outInfo) - { - OIC_LOG(ERROR, TAG, "outInfo is null"); - return CA_STATUS_INVALID_PARAM; - } + VERIFY_NON_NULL(pdu_hdr, TAG, "pdu_hdr"); + VERIFY_NON_NULL(outInfo, TAG, "outInfo"); + VERIFY_NON_NULL(endpoint, TAG, "endpoint"); - coap_transport_type transport; -#ifdef TCP_ADAPTER - if (CA_ADAPTER_TCP == endpoint->adapter) + coap_transport_t transport = COAP_UDP; +#ifdef WITH_TCP + if (CAIsSupportedCoAPOverTCP(endpoint->adapter)) { transport = coap_get_tcp_header_type_from_initbyte(((unsigned char *)pdu_hdr)[0] >> 4); } - else #endif - { - transport = coap_udp; - } unsigned char* token = NULL; unsigned int token_length = 0; - coap_get_token(pdu_hdr, transport, &token, &token_length); + coap_get_token2(pdu_hdr, transport, &token, &token_length); // set token data - if (token_length > 0) + if (token && token_length > 0) { OIC_LOG_V(DEBUG, TAG, "token len:%d", token_length); outInfo->token = (char *) OICMalloc(token_length); @@ -1051,20 +1030,12 @@ CAResult_t CAGetTokenFromPDU(const coap_hdr_t *pdu_hdr, CAInfo_t *outInfo, outInfo->tokenLength = token_length; - OIC_LOG(DEBUG, TAG, "OUT"); - return CA_STATUS_OK; } CAResult_t CAGenerateTokenInternal(CAToken_t *token, uint8_t tokenLength) { - OIC_LOG(DEBUG, TAG, "IN"); - - if (!token) - { - OIC_LOG(ERROR, TAG, "invalid token pointer"); - return CA_STATUS_INVALID_PARAM; - } + VERIFY_NON_NULL(token, TAG, "token"); if ((tokenLength > CA_MAX_TOKEN_LEN) || (0 == tokenLength)) { @@ -1072,26 +1043,6 @@ CAResult_t CAGenerateTokenInternal(CAToken_t *token, uint8_t tokenLength) return CA_STATUS_INVALID_PARAM; } - if (SEED == 0) - { -#ifdef ARDUINO - SEED = now(); -#else - SEED = time(NULL); -#endif - if (SEED == (unsigned int)((time_t)-1)) - { - OIC_LOG(ERROR, TAG, "seed is not made"); - SEED = 0; - return CA_STATUS_FAILED; - } -#if HAVE_SRANDOM - srandom(SEED); -#else - srand(SEED); -#endif - } - // memory allocation char *temp = (char *) OICCalloc(tokenLength, sizeof(char)); if (NULL == temp) @@ -1100,51 +1051,19 @@ CAResult_t CAGenerateTokenInternal(CAToken_t *token, uint8_t tokenLength) return CA_MEMORY_ALLOC_FAILED; } - // set random byte - for (uint8_t index = 0; index < tokenLength; index++) - { - // use valid characters -#ifdef ARDUINO - temp[index] = rand() & 0x00FF; -#else - temp[index] = random() & 0x00FF; -#endif - } + OCFillRandomMem((uint8_t *)temp, tokenLength); // save token *token = temp; OIC_LOG_V(DEBUG, TAG, "token len:%d, token:", tokenLength); OIC_LOG_BUFFER(DEBUG, TAG, (const uint8_t *)(*token), tokenLength); - - OIC_LOG(DEBUG, TAG, "OUT"); return CA_STATUS_OK; } void CADestroyTokenInternal(CAToken_t token) { - OIC_LOG(DEBUG, TAG, "IN"); OICFree(token); - OIC_LOG(DEBUG, TAG, "OUT"); -} - -void CADestroyInfo(CAInfo_t *info) -{ - OIC_LOG(DEBUG, TAG, "IN"); - - if (NULL != info) - { - OIC_LOG(DEBUG, TAG, "free options"); - OICFree(info->options); - - OIC_LOG(DEBUG, TAG, "free token"); - OICFree(info->token); - - OIC_LOG(DEBUG, TAG, "free payload"); - OICFree(info->payload); - } - - OIC_LOG(DEBUG, TAG, "OUT"); } uint32_t CAGetOptionData(uint16_t key, const uint8_t *data, uint32_t len, @@ -1156,12 +1075,6 @@ uint32_t CAGetOptionData(uint16_t key, const uint8_t *data, uint32_t len, return 0; } - if (NULL == data || NULL == option) - { - OIC_LOG(ERROR, TAG, "data/option NULL"); - return 0; - } - if (buflen <= len) { OIC_LOG(ERROR, TAG, "option buffer too small"); @@ -1169,13 +1082,16 @@ uint32_t CAGetOptionData(uint16_t key, const uint8_t *data, uint32_t len, } coap_option_def_t* def = coap_opt_def(key); - if(NULL != def && coap_is_var_bytes(def) && 0 == len) { + if (NULL != def && coap_is_var_bytes(def) && 0 == len) + { // A 0 length option is permitted in CoAP but the // rest or the stack is unaware of variable byte encoding // should remain that way so a 0 byte of length 1 is inserted. len = 1; option[0]=0; - } else { + } + else + { memcpy(option, data, len); option[len] = '\0'; } @@ -1185,11 +1101,7 @@ uint32_t CAGetOptionData(uint16_t key, const uint8_t *data, uint32_t len, CAMessageType_t CAGetMessageTypeFromPduBinaryData(const void *pdu, uint32_t size) { - if (NULL == pdu) - { - OIC_LOG(ERROR, TAG, "pdu is null"); - return CA_MSG_NONCONFIRM; - } + VERIFY_NON_NULL_RET(pdu, TAG, "pdu", CA_MSG_NONCONFIRM); // pdu minimum size is 4 byte. if (size < CA_PDU_MIN_SIZE) @@ -1200,16 +1112,12 @@ CAMessageType_t CAGetMessageTypeFromPduBinaryData(const void *pdu, uint32_t size coap_hdr_t *hdr = (coap_hdr_t *) pdu; - return (CAMessageType_t) hdr->coap_hdr_udp_t.type; + return (CAMessageType_t) hdr->type; } uint16_t CAGetMessageIdFromPduBinaryData(const void *pdu, uint32_t size) { - if (NULL == pdu) - { - OIC_LOG(ERROR, TAG, "pdu is null"); - return 0; - } + VERIFY_NON_NULL_RET(pdu, TAG, "pdu", 0); // pdu minimum size is 4 byte. if (size < CA_PDU_MIN_SIZE) @@ -1220,16 +1128,12 @@ uint16_t CAGetMessageIdFromPduBinaryData(const void *pdu, uint32_t size) coap_hdr_t *hdr = (coap_hdr_t *) pdu; - return hdr->coap_hdr_udp_t.id; + return hdr->id; } CAResponseResult_t CAGetCodeFromPduBinaryData(const void *pdu, uint32_t size) { - if (NULL == pdu) - { - OIC_LOG(ERROR, TAG, "pdu is null"); - return CA_NOT_FOUND; - } + VERIFY_NON_NULL_RET(pdu, TAG, "pdu", CA_NOT_FOUND); // pdu minimum size is 4 byte. if (size < CA_PDU_MIN_SIZE) @@ -1240,7 +1144,7 @@ CAResponseResult_t CAGetCodeFromPduBinaryData(const void *pdu, uint32_t size) coap_hdr_t *hdr = (coap_hdr_t *) pdu; - return (CAResponseResult_t) CA_RESPONSE_CODE(hdr->coap_hdr_udp_t.code); + return (CAResponseResult_t) CA_RESPONSE_CODE(hdr->code); } CAPayloadFormat_t CAConvertFormat(uint8_t format) @@ -1267,3 +1171,29 @@ CAPayloadFormat_t CAConvertFormat(uint8_t format) return CA_FORMAT_UNSUPPORTED; } } + +#ifdef WITH_BWT +bool CAIsSupportedBlockwiseTransfer(CATransportAdapter_t adapter) +{ + if (CA_ADAPTER_IP & adapter || CA_ADAPTER_NFC & adapter + || CA_DEFAULT_ADAPTER == adapter) + { + return true; + } + OIC_LOG_V(DEBUG, TAG, "adapter value of BWT is %d", adapter); + return false; +} +#endif + +#ifdef WITH_TCP +bool CAIsSupportedCoAPOverTCP(CATransportAdapter_t adapter) +{ + if (CA_ADAPTER_GATT_BTLE & adapter || CA_ADAPTER_RFCOMM_BTEDR & adapter + || CA_ADAPTER_TCP & adapter || CA_DEFAULT_ADAPTER == adapter) + { + return true; + } + OIC_LOG_V(DEBUG, TAG, "adapter value of CoAP/TCP is %d", adapter); + return false; +} +#endif