X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=resource%2Fcsdk%2Fconnectivity%2Fsrc%2Fcaprotocolmessage.c;h=0ab1ae7f3db3abb8a8cae05a2e9c48693ce79ab1;hb=03ae7cd73e2e10a8de75da40a0e476cc955b46b2;hp=ec48e71de6fb597ffae2b53e0bca2d04a8bdd18c;hpb=da09afd6d11d40b87cac4c129979d24392f2b2ff;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 ec48e71..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,90 +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" +#define TAG "OIC_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 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 CAGetRequestInfoFromPDU(const coap_pdu_t *pdu, CARequestInfo_t *outReqInfo) +CAResult_t CASetProxyUri(const char *uri) { - OIC_LOG(DEBUG, TAG, "IN"); + VERIFY_NON_NULL(uri, TAG, "uri"); + OICStrcpy(g_chproxyUri, sizeof (g_chproxyUri), uri); + return CA_STATUS_OK; +} +#endif - if (NULL == pdu || NULL == outReqInfo) - { - OIC_LOG(ERROR, TAG, "parameter is null"); - return CA_STATUS_INVALID_PARAM; - } +CAResult_t CAGetRequestInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint, + CARequestInfo_t *outReqInfo) +{ + VERIFY_NON_NULL(pdu, TAG, "pdu"); + VERIFY_NON_NULL(outReqInfo, TAG, "outReqInfo"); uint32_t code = CA_NOT_FOUND; - CAResult_t ret = CAGetInfoFromPDU(pdu, &code, &(outReqInfo->info)); + 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) +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, &code, &(outResInfo->info)); + 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, CAErrorInfo_t *errorInfo) +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, &code, &errorInfo->info); - OIC_LOG(DEBUG, TAG, "OUT"); + CAResult_t ret = CAGetInfoFromPDU(pdu, endpoint, &code, &errorInfo->info); + 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; @@ -132,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, NULL, info, endpoint))) + if (!(pdu = CAGeneratePDUImpl((code_t) code, info, endpoint, NULL, transport))) { OIC_LOG(ERROR, TAG, "pdu NULL"); return NULL; @@ -141,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"); @@ -167,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; } @@ -184,87 +168,147 @@ 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, optlist, info, endpoint); + 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) +coap_pdu_t *CAParsePDU(const char *data, uint32_t length, uint32_t *outCode, + const CAEndpoint_t *endpoint) { - OIC_LOG(DEBUG, TAG, "IN"); + VERIFY_NON_NULL_RET(data, TAG, "data", NULL); + VERIFY_NON_NULL_RET(endpoint, TAG, "endpoint", NULL); - if (NULL == data) + coap_transport_t transport = COAP_UDP; +#ifdef WITH_TCP + if (CAIsSupportedCoAPOverTCP(endpoint->adapter)) { - OIC_LOG(ERROR, TAG, "data is null"); - return NULL; + transport = coap_get_tcp_header_type_from_initbyte(((unsigned char *)data)[0] >> 4); } +#endif - coap_pdu_t *outpdu = coap_new_pdu(); + 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; } - if (0 >= coap_pdu_parse((unsigned char *) data, length, outpdu)) + OIC_LOG_V(DEBUG, TAG, "pdu parse-transport type : %d", 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; } - if (outpdu->hdr->version != COAP_DEFAULT_VERSION) +#ifdef WITH_TCP + if (CAIsSupportedCoAPOverTCP(endpoint->adapter)) { - OIC_LOG_V(ERROR, TAG, "coap version is not available : %d", - outpdu->hdr->version); - coap_delete_pdu(outpdu); - return NULL; + OIC_LOG(INFO, TAG, "there is no version info in coap header"); } - - if (outpdu->hdr->token_length > CA_MAX_TOKEN_LEN) + else +#endif { - OIC_LOG_V(ERROR, TAG, "token length has been exceed : %d", - outpdu->hdr->token_length); - coap_delete_pdu(outpdu); - return NULL; + if (outpdu->transport_hdr->udp.version != COAP_DEFAULT_VERSION) + { + OIC_LOG_V(ERROR, TAG, "coap version is not available : %d", + outpdu->transport_hdr->udp.version); + goto exit; + } + if (outpdu->transport_hdr->udp.token_length > CA_MAX_TOKEN_LEN) + { + OIC_LOG_V(ERROR, TAG, "token length has been exceed : %d", + outpdu->transport_hdr->udp.token_length); + goto exit; + } } if (outCode) { - (*outCode) = (uint32_t) CA_RESPONSE_CODE(outpdu->hdr->code); + (*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, coap_list_t *options, const CAInfo_t *info, - const CAEndpoint_t *endpoint) +coap_pdu_t *CAGeneratePDUImpl(code_t code, const CAInfo_t *info, + 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); + + unsigned int length = COAP_MAX_PDU_SIZE; +#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) + { + 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) + { + msgLength = msgLength + info->payloadSize + PAYLOAD_MARKER; + } + *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; + } - coap_pdu_t *pdu = coap_new_pdu(); + coap_pdu_t *pdu = coap_new_pdu2(*transport, length); if (NULL == pdu) { @@ -272,25 +316,38 @@ coap_pdu_t *CAGeneratePDUImpl(code_t code, coap_list_t *options, const CAInfo_t return NULL; } - OIC_LOG_V(DEBUG, TAG, "msgID is %d", info->messageId); - uint16_t message_id; - if (0 == info->messageId) - { - /* initialize message id */ - prng((uint8_t * ) &message_id, sizeof(message_id)); + OIC_LOG_V(DEBUG, TAG, "transport type: %d, payload size: %zu", + *transport, info->payloadSize); - OIC_LOG_V(DEBUG, TAG, "gen msg id=%d", message_id); +#ifdef WITH_TCP + if (CAIsSupportedCoAPOverTCP(endpoint->adapter)) + { + coap_add_length(pdu, *transport, msgLength); } else +#endif { - /* use saved message id */ - message_id = info->messageId; + OIC_LOG_V(DEBUG, TAG, "msgID is %d", info->messageId); + uint16_t message_id = 0; + if (0 == info->messageId) + { + /* initialize message id */ + prng((uint8_t * ) &message_id, sizeof(message_id)); + + OIC_LOG_V(DEBUG, TAG, "gen msg id=%d", message_id); + } + else + { + /* use saved message id */ + message_id = info->messageId; + } + 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->transport_hdr->udp.type = info->type; } - pdu->hdr->id = message_id; - OIC_LOG_V(DEBUG, TAG, "messageId in pdu is %d, %d", message_id, pdu->hdr->id); - pdu->hdr->type = info->type; - pdu->hdr->code = COAP_RESPONSE_CODE(code); + coap_add_code(pdu, *transport, code); if (info->token && CA_EMPTY != code) { @@ -298,60 +355,54 @@ coap_pdu_t *CAGeneratePDUImpl(code_t code, coap_list_t *options, const CAInfo_t 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); + 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) { OIC_LOG_V(DEBUG, TAG, "[%s] opt will be added.", COAP_OPTION_DATA(*(coap_option *) opt->data)); - 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)); + + OIC_LOG_V(DEBUG, TAG, "[%d] pdu length", pdu->length); + 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); } } - bool enabledPayload = false; -#ifndef WITH_BWT - enabledPayload = true; -#endif + OIC_LOG_V(DEBUG, TAG, "[%d] pdu length after option", pdu->length); - if (enabledPayload || CA_ADAPTER_GATT_BTLE == endpoint->adapter) + 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; @@ -359,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), @@ -393,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)) { @@ -414,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--) { @@ -435,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 @@ -460,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); @@ -486,36 +535,82 @@ 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; } } } - OIC_LOG(DEBUG, TAG, "OUT"); + // insert one extra header with the payload format if applicable. + if (CA_FORMAT_UNDEFINED != info->payloadFormat) + { + coap_list_t* node = NULL; + 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, (unsigned short)COAP_MEDIATYPE_APPLICATION_CBOR), + (char *)buf); + break; + default: + OIC_LOG_V(ERROR, TAG, "format option:[%d] not supported", info->payloadFormat); + } + if (!node) + { + OIC_LOG(ERROR, TAG, "format option not created"); + return CA_STATUS_INVALID_PARAM; + } + int ret = coap_insert(optlist, node, CAOrderOpts); + if (ret <= 0) + { + coap_delete(node); + OIC_LOG(ERROR, TAG, "format option not inserted in header"); + return CA_STATUS_INVALID_PARAM; + } + } + if (CA_FORMAT_UNDEFINED != info->acceptFormat) + { + coap_list_t* node = NULL; + 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, (unsigned short)COAP_MEDIATYPE_APPLICATION_CBOR), + (char *)buf); + break; + default: + OIC_LOG_V(ERROR, TAG, "format option:[%d] not supported", info->acceptFormat); + } + if (!node) + { + OIC_LOG(ERROR, TAG, "format option not created"); + return CA_STATUS_INVALID_PARAM; + } + int ret = coap_insert(optlist, node, CAOrderOpts); + if (ret <= 0) + { + coap_delete(node); + OIC_LOG(ERROR, TAG, "format option not inserted in header"); + return CA_STATUS_INVALID_PARAM; + } + } + 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) @@ -561,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; @@ -578,46 +671,58 @@ 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))) { if (COAP_OPTION_URI_PATH != opt_iter.type && COAP_OPTION_URI_QUERY != opt_iter.type && 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_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_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, uint32_t *outCode, CAInfo_t *outInfo) +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) + 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_t transport; +#ifdef WITH_TCP + if (CAIsSupportedCoAPOverTCP(endpoint->adapter)) { - OIC_LOG(ERROR, TAG, "NULL pointer param"); - return CA_STATUS_INVALID_PARAM; + transport = coap_get_tcp_header_type_from_initbyte(((unsigned char *)pdu->transport_hdr)[0] >> 4); + } + else +#endif + { + transport = COAP_UDP; } coap_opt_iterator_t opt_iter; - coap_option_iterator_init((coap_pdu_t *) pdu, &opt_iter, COAP_OPT_ALL); + coap_option_iterator_init2((coap_pdu_t *) pdu, &opt_iter, COAP_OPT_ALL, transport); if (outCode) { - (*outCode) = (uint32_t) CA_RESPONSE_CODE(pdu->hdr->code); + (*outCode) = (uint32_t) CA_RESPONSE_CODE(coap_get_code(pdu, transport)); } // init HeaderOption list @@ -626,11 +731,26 @@ CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, uint32_t *outCode, CAInfo_t * outInfo->numOptions = count; - // set type - outInfo->type = pdu->hdr->type; +#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->transport_hdr->udp.type; - // set message id - outInfo->messageId = pdu->hdr->id; + // set message id + outInfo->messageId = pdu->transport_hdr->udp.id; + outInfo->payloadFormat = CA_FORMAT_UNDEFINED; + outInfo->acceptFormat = CA_FORMAT_UNDEFINED; + } if (count > 0) { @@ -642,12 +762,15 @@ CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, uint32_t *outCode, CAInfo_t * } } - 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))) { @@ -738,18 +861,57 @@ CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, uint32_t *outCode, CAInfo_t * { OIC_LOG_V(DEBUG, TAG, "option[%d] will be filtering", opt_iter.type); } + else if (COAP_OPTION_CONTENT_FORMAT == opt_iter.type) + { + if (1 == COAP_OPT_LENGTH(option)) + { + outInfo->payloadFormat = CAConvertFormat((uint8_t)buf[0]); + } + else + { + outInfo->payloadFormat = CA_FORMAT_UNSUPPORTED; + OIC_LOG_V(DEBUG, TAG, "option[%d] has an unsupported format [%d]", + opt_iter.type, (uint8_t)buf[0]); + } + } + else if (COAP_OPTION_ACCEPT == opt_iter.type) + { + if (1 == COAP_OPT_LENGTH(option)) + { + outInfo->acceptFormat = CAConvertFormat((uint8_t)buf[0]); + } + else + { + outInfo->acceptFormat = CA_FORMAT_UNSUPPORTED; + } + OIC_LOG_V(DEBUG, TAG, "option[%d] has an unsupported format [%d]", + 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++; } } @@ -757,21 +919,25 @@ CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, uint32_t *outCode, CAInfo_t * } } + unsigned char* token = NULL; + unsigned int token_length = 0; + coap_get_token2(pdu->transport_hdr, transport, &token, &token_length); + // set token data - if (pdu->hdr->token_length > 0) + if (token_length > 0) { - OIC_LOG_V(DEBUG, TAG, "inside token length : %d", pdu->hdr->token_length); - outInfo->token = (char *) OICMalloc(pdu->hdr->token_length); + OIC_LOG_V(DEBUG, TAG, "inside token length : %d", token_length); + outInfo->token = (char *) OICMalloc(token_length); if (NULL == outInfo->token) { OIC_LOG(ERROR, TAG, "Out of memory"); OICFree(outInfo->options); return CA_MEMORY_ALLOC_FAILED; } - memcpy(outInfo->token, pdu->hdr->token, pdu->hdr->token_length); + memcpy(outInfo->token, token, token_length); } - outInfo->tokenLength = pdu->hdr->token_length; + outInfo->tokenLength = token_length; // set payload data size_t dataSize; @@ -793,7 +959,7 @@ CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, uint32_t *outCode, CAInfo_t * 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) { @@ -803,8 +969,24 @@ CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, uint32_t *outCode, CAInfo_t * 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: @@ -813,50 +995,47 @@ 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; - } + VERIFY_NON_NULL(pdu_hdr, TAG, "pdu_hdr"); + VERIFY_NON_NULL(outInfo, TAG, "outInfo"); + VERIFY_NON_NULL(endpoint, TAG, "endpoint"); - if (NULL == outInfo) + coap_transport_t transport = COAP_UDP; +#ifdef WITH_TCP + if (CAIsSupportedCoAPOverTCP(endpoint->adapter)) { - OIC_LOG(ERROR, TAG, "outInfo is null"); - return CA_STATUS_INVALID_PARAM; + transport = coap_get_tcp_header_type_from_initbyte(((unsigned char *)pdu_hdr)[0] >> 4); } +#endif + + unsigned char* token = NULL; + unsigned int token_length = 0; + coap_get_token2(pdu_hdr, transport, &token, &token_length); // set token data - if (pdu_hdr->token_length > 0) + if (token && token_length > 0) { - OIC_LOG_V(DEBUG, TAG, "token len:%d", pdu_hdr->token_length); - outInfo->token = (char *) OICMalloc(pdu_hdr->token_length); + OIC_LOG_V(DEBUG, TAG, "token len:%d", token_length); + outInfo->token = (char *) OICMalloc(token_length); if (NULL == outInfo->token) { - OIC_LOG(ERROR, TAG, "out of memory"); + OIC_LOG(ERROR, TAG, "Out of memory"); return CA_MEMORY_ALLOC_FAILED; } - memcpy(outInfo->token, pdu_hdr->token, pdu_hdr->token_length); + memcpy(outInfo->token, token, token_length); } - outInfo->tokenLength = pdu_hdr->token_length; - - OIC_LOG(DEBUG, TAG, "OUT"); + outInfo->tokenLength = token_length; 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)) { @@ -864,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) @@ -892,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, @@ -948,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"); @@ -961,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'; } @@ -977,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) @@ -997,11 +1117,7 @@ CAMessageType_t CAGetMessageTypeFromPduBinaryData(const void *pdu, uint32_t size 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) @@ -1017,11 +1133,7 @@ uint16_t CAGetMessageIdFromPduBinaryData(const void *pdu, uint32_t size) 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) @@ -1034,3 +1146,54 @@ CAResponseResult_t CAGetCodeFromPduBinaryData(const void *pdu, uint32_t size) return (CAResponseResult_t) CA_RESPONSE_CODE(hdr->code); } + +CAPayloadFormat_t CAConvertFormat(uint8_t format) +{ + switch (format) + { + case COAP_MEDIATYPE_TEXT_PLAIN: + return CA_FORMAT_TEXT_PLAIN; + case COAP_MEDIATYPE_APPLICATION_LINK_FORMAT: + return CA_FORMAT_APPLICATION_LINK_FORMAT; + case COAP_MEDIATYPE_APPLICATION_XML: + return CA_FORMAT_APPLICATION_XML; + case COAP_MEDIATYPE_APPLICATION_OCTET_STREAM: + return CA_FORMAT_APPLICATION_OCTET_STREAM; + case COAP_MEDIATYPE_APPLICATION_RDF_XML: + return CA_FORMAT_APPLICATION_RDF_XML; + case COAP_MEDIATYPE_APPLICATION_EXI: + return CA_FORMAT_APPLICATION_EXI; + case COAP_MEDIATYPE_APPLICATION_JSON: + return CA_FORMAT_APPLICATION_JSON; + case COAP_MEDIATYPE_APPLICATION_CBOR: + return CA_FORMAT_APPLICATION_CBOR; + default: + 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