X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=resource%2Fcsdk%2Fconnectivity%2Fsrc%2Fcaprotocolmessage.c;h=e3fbe3c598a4d2f568a368431f0344d10d48f6ae;hb=966700a71110e415e8d3049cbe59c624929a9dff;hp=07ef6fd3247e0877dccfcfa30da66b8535262ea8;hpb=45676e721e9954db2dafbe78c79c284d83c48f0f;p=platform%2Fupstream%2Fiotivity.git diff --git a/resource/csdk/connectivity/src/caprotocolmessage.c b/resource/csdk/connectivity/src/caprotocolmessage.c index 07ef6fd..e3fbe3c 100644 --- a/resource/csdk/connectivity/src/caprotocolmessage.c +++ b/resource/csdk/connectivity/src/caprotocolmessage.c @@ -18,424 +18,790 @@ * ******************************************************************/ +// Defining _BSD_SOURCE or _DEFAULT_SOURCE causes header files to expose +// definitions that may otherwise be skipped. Skipping can cause implicit +// declaration warnings and/or bugs and subtle problems in code execution. +// 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 #include #include +#include +#ifdef HAVE_TIME_H #include +#endif #include "caprotocolmessage.h" #include "logger.h" #include "oic_malloc.h" +#include "oic_string.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 "CA" +#define CA_BUFSIZE (128) +#define CA_PDU_MIN_SIZE (4) +#define CA_PORT_BUFFER_SIZE (4) -#define CA_BUFSIZE 128 -#define CA_PDU_MIN_SIZE 4 +static const char COAP_URI_HEADER[] = "coap://[::]/"; -static const char COAP_HEADER[] = "coap://[::]/"; -static uint32_t SEED = 0; +static unsigned int SEED = 0; -void CAGetRequestInfoFromPdu(const coap_pdu_t *pdu, CARequestInfo_t *outReqInfo, char *outUri, - uint32_t buflen) +CAResult_t CAGetRequestInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint, + CARequestInfo_t *outReqInfo) { - OIC_LOG(DEBUG, TAG, "CAGetRequestInfoFromPdu IN"); + OIC_LOG(DEBUG, TAG, "IN"); - if (NULL == pdu) + if (NULL == pdu || NULL == outReqInfo) { - return; + OIC_LOG(ERROR, TAG, "parameter is null"); + return CA_STATUS_INVALID_PARAM; } uint32_t code = CA_NOT_FOUND; - CAGetInfoFromPDU(pdu, &code, &(outReqInfo->info), outUri, buflen); + CAResult_t ret = CAGetInfoFromPDU(pdu, endpoint, &code, &(outReqInfo->info)); outReqInfo->method = code; - OIC_LOG(DEBUG, TAG, "CAGetRequestInfoFromPdu OUT"); + + OIC_LOG(DEBUG, TAG, "OUT"); + return ret; } -void CAGetResponseInfoFromPdu(const coap_pdu_t *pdu, CAResponseInfo_t *outResInfo, char *outUri, - uint32_t buflen) +CAResult_t CAGetResponseInfoFromPDU(const coap_pdu_t *pdu, CAResponseInfo_t *outResInfo, + const CAEndpoint_t *endpoint) { - OIC_LOG(DEBUG, TAG, "CAGetResponseInfoFromPdu IN"); - if (NULL == pdu) + OIC_LOG(DEBUG, TAG, "IN"); + + if (NULL == pdu || NULL == outResInfo) { - return; + OIC_LOG(ERROR, TAG, "parameter is null"); + return CA_STATUS_INVALID_PARAM; } uint32_t code = CA_NOT_FOUND; - CAGetInfoFromPDU(pdu, &code, &(outResInfo->info), outUri, buflen); + CAResult_t ret = CAGetInfoFromPDU(pdu, endpoint, &code, &(outResInfo->info)); outResInfo->result = code; - OIC_LOG(DEBUG, TAG, "CAGetResponseInfoFromPdu OUT"); + + OIC_LOG(DEBUG, TAG, "OUT"); + return ret; } -coap_pdu_t *CAGeneratePdu(const char *uri, const uint32_t code, const CAInfo_t info) +CAResult_t CAGetErrorInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint, + CAErrorInfo_t *errorInfo) { - OIC_LOG(DEBUG, TAG, "CAGeneratePdu IN"); + OIC_LOG(DEBUG, TAG, "IN"); - if (NULL == uri) + if (!pdu) { - return NULL; + OIC_LOG(ERROR, TAG, "parameter is null"); + return CA_STATUS_INVALID_PARAM; } - uint32_t length = strlen(uri); - if (CA_MAX_URI_LENGTH < length) - { - OIC_LOG(ERROR, TAG, "check URI length.."); - return NULL; - } + uint32_t code = 0; + CAResult_t ret = CAGetInfoFromPDU(pdu, endpoint, &code, &errorInfo->info); + OIC_LOG(DEBUG, TAG, "OUT"); + return ret; +} - uint32_t uriLength = length + sizeof(COAP_HEADER); - char *coapUri = NULL; - coapUri = (char *) OICCalloc(1, uriLength * sizeof(char)); - if (NULL == coapUri) +coap_pdu_t *CAGeneratePDU(uint32_t code, const CAInfo_t *info, const CAEndpoint_t *endpoint) +{ + OIC_LOG(DEBUG, TAG, "IN"); + + VERIFY_NON_NULL_RET(info, TAG, "info", NULL); + VERIFY_NON_NULL_RET(endpoint, TAG, "endpoint", NULL); + + coap_pdu_t *pdu = NULL; + + // RESET have to use only 4byte (empty message) + // and ACKNOWLEDGE can use empty message when code is empty. + if (CA_MSG_RESET == info->type || (CA_EMPTY == code && CA_MSG_ACKNOWLEDGE == info->type)) { - OIC_LOG(ERROR, TAG, "CAGeneratePdu, Memory allocation failed !"); - return NULL; + OIC_LOG(DEBUG, TAG, "code is empty"); + if (!(pdu = CAGeneratePDUImpl((code_t) code, info, endpoint, NULL))) + { + OIC_LOG(ERROR, TAG, "pdu NULL"); + return NULL; + } } - - coap_list_t *optlist = NULL; - if (NULL != coapUri) + else { - strcat(coapUri, COAP_HEADER); - strcat(coapUri, uri); + coap_list_t *optlist = NULL; - // parsing options in URI - CAParseURI(coapUri, &optlist); - OICFree(coapUri); - coapUri = NULL; + if (CA_MSG_ACKNOWLEDGE != info->type) + { + const char *uri = info->resourceUri; + if (NULL == uri) + { + OIC_LOG(ERROR, TAG, "uri NULL"); + return NULL; + } + uint32_t length = strlen(uri); + if (CA_MAX_URI_LENGTH < length) + { + OIC_LOG(ERROR, TAG, "URI len err"); + return NULL; + } + + uint32_t uriLength = length + sizeof(COAP_URI_HEADER); + char *coapUri = (char *) OICCalloc(1, uriLength); + if (NULL == coapUri) + { + OIC_LOG(ERROR, TAG, "out of memory"); + return NULL; + } + OICStrcat(coapUri, uriLength, COAP_URI_HEADER); + OICStrcat(coapUri, uriLength, uri); + + // parsing options in URI + CAResult_t res = CAParseURI(coapUri, &optlist); + if (CA_STATUS_OK != res) + { + if (optlist) + { + coap_delete_list(optlist); + } + OICFree(coapUri); + return NULL; + } + + OICFree(coapUri); + } // parsing options in HeadOption - CAParseHeadOption(code, info, &optlist); - } + CAResult_t ret = CAParseHeadOption(code, info, &optlist); + if (CA_STATUS_OK != ret) + { + coap_delete_list(optlist); + return NULL; + } - coap_pdu_t *pdu; - if (!(pdu = CAGeneratePduImpl((code_t) code, optlist, info, info.payload))) - { - return NULL; - } + pdu = CAGeneratePDUImpl((code_t) code, info, endpoint, optlist); + if (NULL == pdu) + { + OIC_LOG(ERROR, TAG, "pdu NULL"); + coap_delete_list(optlist); + return NULL; + } - // free option list - coap_delete_list(optlist); + // free option list + coap_delete_list(optlist); + } // pdu print method : coap_show_pdu(pdu); - OIC_LOG(DEBUG, TAG, "CAGeneratePdu OUT"); + 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, "CAParsePDU IN"); - coap_pdu_t *outpdu = coap_new_pdu(); + OIC_LOG(DEBUG, TAG, "IN"); + + if (NULL == data) + { + OIC_LOG(ERROR, TAG, "data is null"); + return NULL; + } - if (0 >= coap_pdu_parse((unsigned char *) data, length, outpdu)) + coap_transport_type transport; +#ifdef TCP_ADAPTER + if (CA_ADAPTER_TCP == endpoint->adapter) + { + transport = coap_get_tcp_header_type_from_initbyte(((unsigned char *)data)[0] >> 4); + } + else +#endif { - OIC_LOG(ERROR, TAG, "coap_pdu_parse failed"); + transport = coap_udp; + } + + coap_pdu_t *outpdu = coap_new_pdu(transport, length); + if (NULL == outpdu) + { + OIC_LOG(ERROR, TAG, "outpdu is null"); + return NULL; + } + + OIC_LOG_V(DEBUG, TAG, "pdu parse-transport type : %d", transport); + + int ret = coap_pdu_parse((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; } +#ifdef TCP_ADAPTER + if (CA_ADAPTER_TCP == 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) + { + OIC_LOG_V(ERROR, TAG, "coap version is not available : %d", + outpdu->hdr->coap_hdr_udp_t.version); + coap_delete_pdu(outpdu); + return NULL; + } + if (outpdu->hdr->coap_hdr_udp_t.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; + } + } + if (outCode) { - (*outCode) = (uint32_t) outpdu->hdr->code; - }OIC_LOG(DEBUG, TAG, "CAParsePDU OUT"); + (*outCode) = (uint32_t) CA_RESPONSE_CODE(coap_get_code(outpdu, transport)); + } + + OIC_LOG(DEBUG, TAG, "OUT"); return outpdu; } -coap_pdu_t *CAGeneratePduImpl(const code_t code, coap_list_t *options, const CAInfo_t info, - const char *payload) +coap_pdu_t *CAGeneratePDUImpl(code_t code, const CAInfo_t *info, + const CAEndpoint_t *endpoint, coap_list_t *options) { - OIC_LOG(DEBUG, TAG, "CAGeneratePduImpl IN"); + OIC_LOG(DEBUG, TAG, "IN"); + VERIFY_NON_NULL_RET(info, TAG, "info", NULL); + VERIFY_NON_NULL_RET(endpoint, TAG, "endpoint", 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) + { + if (options) + { + for (coap_list_t *opt = options; opt; opt = opt->next) + { + headerLength += COAP_OPTION_LENGTH(*(coap_option *) opt->data) + 1; + } + } - coap_pdu_t *pdu = coap_new_pdu(); - if (!pdu) + if (info->payloadSize > 0) + { + headerLength = headerLength + info->payloadSize + 1; + } + transport = coap_get_tcp_header_type_from_size(headerLength); + length = headerLength + coap_get_tcp_header_length_for_transport(transport) + + info->tokenLength; + } + else +#endif { - OIC_LOG(ERROR, TAG, "Out of memory"); + transport = coap_udp; + } + + coap_pdu_t *pdu = coap_new_pdu(transport, length); + + if (NULL == pdu) + { + OIC_LOG(ERROR, TAG, "malloc failed"); return NULL; } - OIC_LOG_V(DEBUG, TAG, "messageId is %d", info.messageId); - if (CA_MSG_ACKNOWLEDGE == info.type || CA_MSG_RESET == info.type) + OIC_LOG_V(DEBUG, TAG, "transport type: %d, payload size: %d", + transport, info->payloadSize); + +#ifdef TCP_ADAPTER + if (CA_ADAPTER_TCP == endpoint->adapter) { - pdu->hdr->id = htons(info.messageId); + coap_add_length(pdu, transport, headerLength); } else +#endif { + OIC_LOG_V(DEBUG, TAG, "msgID is %d", info->messageId); uint16_t message_id; - if (info.messageId == 0) + if (0 == info->messageId) { /* initialize message id */ - prng((uint8_t * ) &message_id, sizeof(uint16_t)); + prng((uint8_t * ) &message_id, sizeof(message_id)); - OIC_LOG_V(DEBUG, TAG, "generate the message id(%d)", message_id); + OIC_LOG_V(DEBUG, TAG, "gen msg id=%d", message_id); } else { /* use saved message id */ - message_id = info.messageId; + message_id = info->messageId; } - pdu->hdr->id = htons(message_id); + 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->hdr->coap_hdr_udp_t.type = info->type; } - pdu->hdr->type = info.type; - pdu->hdr->code = COAP_RESPONSE_CODE(code); - if (info.token) + coap_add_code(pdu, transport, code); + + if (info->token && CA_EMPTY != code) { - uint32_t tokenLength = strlen(info.token); - OIC_LOG_V(DEBUG, TAG, "token info : %s, %d", info.token, tokenLength); + uint32_t tokenLength = info->tokenLength; + 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, (uint8_t *) info.token); + int32_t ret = coap_add_token(pdu, tokenLength, (unsigned char *)info->token, transport); if (0 == ret) { - OIC_LOG(DEBUG, TAG, "cannot add token to request"); + OIC_LOG(ERROR, TAG, "can't add token"); } } if (options) { - coap_list_t *opt; - for (opt = options; opt; opt = opt->next) + 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)); + 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); } } - if (NULL != payload) + 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 + ) { - uint32_t len = strlen(payload); - OIC_LOG_V(DEBUG, TAG, "coap_add_data, payload: %s", payload); - coap_add_data(pdu, len, (const uint8_t *) payload); + 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, "CAGeneratePduImpl OUT"); + OIC_LOG(DEBUG, TAG, "OUT"); return pdu; } -void CAParseURI(const char *uriInfo, coap_list_t **optlist) +CAResult_t CAParseURI(const char *uriInfo, coap_list_t **optlist) { - OIC_LOG(DEBUG, TAG, "CAParseURI IN");OIC_LOG_V(DEBUG, TAG, "url : %s", uriInfo); + 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; + } /* split arg into Uri-* options */ coap_uri_t uri; coap_split_uri((unsigned char *) uriInfo, strlen(uriInfo), &uri); - unsigned char portbuf[2]; if (uri.port != COAP_DEFAULT_PORT) { - coap_insert( - optlist, - CACreateNewOptionNode(COAP_OPTION_URI_PORT, - coap_encode_var_bytes(portbuf, uri.port), portbuf), - CAOrderOpts); + unsigned char portbuf[CA_PORT_BUFFER_SIZE] = { 0 }; + int ret = coap_insert(optlist, + CACreateNewOptionNode(COAP_OPTION_URI_PORT, + coap_encode_var_bytes(portbuf, uri.port), + (char *)portbuf), + CAOrderOpts); + if (ret <= 0) + { + return CA_STATUS_INVALID_PARAM; + } } - unsigned char uriBuffer[CA_BUFSIZE] = - { 0 }; - unsigned char *pBuf = uriBuffer; - uint32_t buflen; - int32_t res; - - if (uri.path.length) + if (uri.path.s && uri.path.length) { - buflen = CA_BUFSIZE; - res = coap_split_path(uri.path.s, uri.path.length, pBuf, &buflen); + CAResult_t ret = CAParseUriPartial(uri.path.s, uri.path.length, + COAP_OPTION_URI_PATH, optlist); + if (CA_STATUS_OK != ret) + { + OIC_LOG(ERROR, TAG, "CAParseUriPartial failed(uri path)"); + return ret; + } + } - if (res > 0) + if (uri.query.s && uri.query.length) + { + CAResult_t ret = CAParseUriPartial(uri.query.s, uri.query.length, COAP_OPTION_URI_QUERY, + optlist); + if (CA_STATUS_OK != ret) { - uint32_t prevIdx = 0; - while (res--) - { - coap_insert( - optlist, - CACreateNewOptionNode(COAP_OPTION_URI_PATH, COAP_OPT_LENGTH(pBuf), - COAP_OPT_VALUE(pBuf)), - CAOrderOpts); - - uint32_t optSize = COAP_OPT_SIZE(pBuf); - uint32_t nextIdx = prevIdx + optSize; - if (nextIdx < buflen) - { - pBuf += optSize; - prevIdx += nextIdx; - } - } + OIC_LOG(ERROR, TAG, "CAParseUriPartial failed(uri query)"); + return ret; } } - if (uri.query.length) + 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; + } + + if ((target != COAP_OPTION_URI_PATH) && (target != COAP_OPTION_URI_QUERY)) + { + // should never occur. Log just in case. + OIC_LOG(DEBUG, TAG, "Unexpected URI component."); + return CA_NOT_SUPPORTED; + } + else if (str && length) { - buflen = CA_BUFSIZE; - pBuf = uriBuffer; - res = coap_split_query(uri.query.s, uri.query.length, pBuf, &buflen); + unsigned char uriBuffer[CA_BUFSIZE] = { 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); if (res > 0) { - uint32_t prevIdx = 0; + size_t prevIdx = 0; while (res--) { - coap_insert( - optlist, - CACreateNewOptionNode(COAP_OPTION_URI_QUERY, COAP_OPT_LENGTH(pBuf), - COAP_OPT_VALUE(pBuf)), - CAOrderOpts); - - uint32_t optSize = COAP_OPT_SIZE(pBuf); - uint32_t nextIdx = prevIdx + optSize; - if (nextIdx < buflen) + int ret = coap_insert(optlist, + CACreateNewOptionNode(target, COAP_OPT_LENGTH(pBuf), + (char *)COAP_OPT_VALUE(pBuf)), + CAOrderOpts); + if (ret <= 0) + { + return CA_STATUS_INVALID_PARAM; + } + + size_t optSize = COAP_OPT_SIZE(pBuf); + if ((prevIdx + optSize) < buflen) { pBuf += optSize; - prevIdx += nextIdx; + prevIdx += optSize; } } } + else + { + OIC_LOG_V(ERROR, TAG, "Problem parsing URI : %d for %d", res, target); + return CA_STATUS_FAILED; + } + } + else + { + OIC_LOG(ERROR, TAG, "str or length is not available"); + return CA_STATUS_FAILED; } - OIC_LOG(DEBUG, TAG, "CAParseURI OUT"); + return CA_STATUS_OK; } -void CAParseHeadOption(const uint32_t code, const CAInfo_t info, coap_list_t **optlist) +CAResult_t CAParseHeadOption(uint32_t code, const CAInfo_t *info, coap_list_t **optlist) { - OIC_LOG(DEBUG, TAG, "CAParseHeadOption IN"); + (void)code; + OIC_LOG(DEBUG, TAG, "IN"); + VERIFY_NON_NULL_RET(info, TAG, "info is NULL", CA_STATUS_INVALID_PARAM); - OIC_LOG_V(DEBUG, TAG, "start parse Head Option : %d", info.numOptions); + OIC_LOG_V(DEBUG, TAG, "parse Head Opt: %d", info->numOptions); - uint32_t i; - for (i = 0; i < info.numOptions; i++) + if (!optlist) { - uint32_t id = info.options[i].optionID; + OIC_LOG(ERROR, TAG, "optlist is null"); + return CA_STATUS_INVALID_PARAM; + } + + for (uint32_t i = 0; i < info->numOptions; i++) + { + if(!(info->options + i)) + { + OIC_LOG(ERROR, TAG, "options is not available"); + return CA_STATUS_FAILED; + } + + uint32_t id = (info->options + i)->optionID; if (COAP_OPTION_URI_PATH == id || COAP_OPTION_URI_QUERY == id) { - OIC_LOG_V(DEBUG, TAG, "it is not Header Option : %d", id); + OIC_LOG_V(DEBUG, TAG, "not Header Opt: %d", id); } else { - OIC_LOG_V(DEBUG, TAG, "Head Option ID: %d", info.options[i].optionID); - - OIC_LOG_V(DEBUG, TAG, "Head Option data: %s", info.options[i].optionData); - - OIC_LOG_V(DEBUG, TAG, "Head Option length: %d", info.options[i].optionLength); + 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; + } + } + } - coap_insert( - optlist, - CACreateNewOptionNode(info.options[i].optionID, info.options[i].optionLength, - info.options[i].optionData), - CAOrderOpts); + // insert one extra header with the payload format if applicable. + if (CA_FORMAT_UNDEFINED != info->payloadFormat) + { + coap_list_t* node = NULL; + uint8_t buf[3] = {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), + (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[3] = {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), + (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; } } - OIC_LOG(DEBUG, TAG, "CAParseHeadOption OUT"); + OIC_LOG(DEBUG, TAG, "OUT"); + return CA_STATUS_OK; } -coap_list_t *CACreateNewOptionNode(const uint16_t key, const uint32_t length, const uint8_t *data) +coap_list_t *CACreateNewOptionNode(uint16_t key, uint32_t length, const char *data) { - OIC_LOG(DEBUG, TAG, "CACreateNewOptionNode IN"); + OIC_LOG(DEBUG, TAG, "IN"); + + if (!data) + { + OIC_LOG(ERROR, TAG, "invalid pointer parameter"); + return NULL; + } + coap_option *option = coap_malloc(sizeof(coap_option) + length + 1); if (!option) { - OIC_LOG(DEBUG, TAG, "Out of memory"); + OIC_LOG(ERROR, TAG, "Out of memory"); return NULL; } memset(option, 0, sizeof(coap_option) + length + 1); COAP_OPTION_KEY(*option) = key; - COAP_OPTION_LENGTH(*option) = length; - memcpy(COAP_OPTION_DATA(*option), data, length); + + coap_option_def_t* def = coap_opt_def(key); + if (NULL != def && coap_is_var_bytes(def)) + { + if (length > def->max) + { + // make sure we shrink the value so it fits the coap option definition + // by truncating the value, disregard the leading bytes. + OIC_LOG_V(DEBUG, TAG, "Option [%d] data size [%d] shrunk to [%d]", + def->key, length, def->max); + data = &(data[length-def->max]); + length = def->max; + } + // Shrink the encoding length to a minimum size for coap + // options that support variable length encoding. + COAP_OPTION_LENGTH(*option) = coap_encode_var_bytes( + COAP_OPTION_DATA(*option), + coap_decode_var_bytes((unsigned char *)data, length)); + } + else + { + COAP_OPTION_LENGTH(*option) = length; + memcpy(COAP_OPTION_DATA(*option), data, length); + } /* we can pass NULL here as delete function since option is released automatically */ coap_list_t *node = coap_new_listnode(option, NULL); if (!node) { - OIC_LOG(DEBUG, TAG, "coap_new_listnode returns NULL"); + OIC_LOG(ERROR, TAG, "node is NULL"); coap_free(option); return NULL; } - //coap_free(option); - OIC_LOG(DEBUG, TAG, "CACreateNewOptionNode OUT"); + + OIC_LOG(DEBUG, TAG, "OUT"); return node; } int CAOrderOpts(void *a, void *b) { - OIC_LOG(DEBUG, TAG, "CAOrderOpts IN"); + OIC_LOG(DEBUG, TAG, "IN"); if (!a || !b) { return a < b ? -1 : 1; } - if (COAP_OPTION_KEY(*(coap_option *)a) < COAP_OPTION_KEY(*(coap_option * )b)) + if (COAP_OPTION_KEY(*(coap_option *) a) < COAP_OPTION_KEY(*(coap_option * ) b)) { return -1; } - OIC_LOG(DEBUG, TAG, "CAOrderOpts OUT"); - return COAP_OPTION_KEY(*(coap_option *)a) == COAP_OPTION_KEY(*(coap_option * )b); + 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, "CAGetOptionCount IN"); + OIC_LOG(DEBUG, TAG, "IN"); uint32_t count = 0; coap_opt_t *option; while ((option = coap_option_next(&opt_iter))) { - if (COAP_OPTION_URI_PATH != opt_iter.type && COAP_OPTION_URI_QUERY != opt_iter.type) + 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_CONTENT_FORMAT != opt_iter.type + && COAP_OPTION_ACCEPT != opt_iter.type) { count++; } } - OIC_LOG(DEBUG, TAG, "CAGetOptionCount OUT"); + OIC_LOG(DEBUG, TAG, "OUT"); return count; } -void CAGetInfoFromPDU(const coap_pdu_t *pdu, uint32_t *outCode, CAInfo_t *outInfo, char *outUri, - uint32_t buflen) +CAResult_t CAGetInfoFromPDU(const coap_pdu_t *pdu, const CAEndpoint_t *endpoint, + uint32_t *outCode, CAInfo_t *outInfo) { - OIC_LOG(DEBUG, TAG, "CAGetInfoFromPDU IN"); + OIC_LOG(DEBUG, TAG, "IN"); + + if (!pdu || !outCode || !outInfo) + { + OIC_LOG(ERROR, TAG, "NULL pointer param"); + return CA_STATUS_INVALID_PARAM; + } + + coap_transport_type transport; +#ifdef TCP_ADAPTER + if (CA_ADAPTER_TCP == endpoint->adapter) + { + transport = coap_get_tcp_header_type_from_initbyte(((unsigned char *)pdu->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_init((coap_pdu_t *) pdu, &opt_iter, COAP_OPT_ALL, transport); - // set code 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 uint32_t count = CAGetOptionCount(opt_iter); + memset(outInfo, 0, sizeof(*outInfo)); - if (!outInfo) + outInfo->numOptions = count; + +#ifdef TCP_ADAPTER + if (CA_ADAPTER_TCP == endpoint->adapter) { - OIC_LOG(ERROR, TAG, "outInfo is null"); - return; + // set type + outInfo->type = CA_MSG_NONCONFIRM; + outInfo->payloadFormat = CA_FORMAT_UNDEFINED; } - memset(outInfo, 0, sizeof(*outInfo)); - outInfo->numOptions = count; - // set type - outInfo->type = pdu->hdr->type; + else +#endif + { + // set type + outInfo->type = pdu->hdr->coap_hdr_udp_t.type; - // set message id - outInfo->messageId = ntohs(pdu->hdr->id); + // set message id + outInfo->messageId = pdu->hdr->coap_hdr_udp_t.id; + outInfo->payloadFormat = CA_FORMAT_UNDEFINED; + outInfo->acceptFormat = CA_FORMAT_UNDEFINED; + } if (count > 0) { outInfo->options = (CAHeaderOption_t *) OICCalloc(count, sizeof(CAHeaderOption_t)); - if (outInfo->options == NULL) + if (NULL == outInfo->options) { - OIC_LOG(DEBUG, TAG, "CAGetInfoFromPDU, Memory allocation failed !"); - return; + OIC_LOG(ERROR, TAG, "Out of memory"); + return CA_MEMORY_ALLOC_FAILED; } } - char buf[COAP_MAX_PDU_SIZE] = - { 0 }; coap_opt_t *option; - char optionResult[CA_MAX_URI_LENGTH] = - { 0 }; + char optionResult[CA_MAX_URI_LENGTH] = {0}; uint32_t idx = 0; uint32_t optionLength = 0; bool isfirstsetflag = false; @@ -443,11 +809,13 @@ void CAGetInfoFromPDU(const coap_pdu_t *pdu, uint32_t *outCode, CAInfo_t *outInf while ((option = coap_option_next(&opt_iter))) { - if (CAGetOptionData((uint8_t *) (COAP_OPT_VALUE(option)), COAP_OPT_LENGTH(option), - (uint8_t *) buf, sizeof(buf))) + char buf[COAP_MAX_PDU_SIZE] = {0}; + uint32_t bufLength = + CAGetOptionData(opt_iter.type, (uint8_t *)(COAP_OPT_VALUE(option)), + COAP_OPT_LENGTH(option), (uint8_t *)buf, sizeof(buf)); + if (bufLength) { OIC_LOG_V(DEBUG, TAG, "COAP URI element : %s", buf); - uint32_t bufLength = strlen(buf); if (COAP_OPTION_URI_PATH == opt_iter.type || COAP_OPTION_URI_QUERY == opt_iter.type) { if (false == isfirstsetflag) @@ -455,46 +823,115 @@ void CAGetInfoFromPDU(const coap_pdu_t *pdu, uint32_t *outCode, CAInfo_t *outInf isfirstsetflag = true; optionResult[optionLength] = '/'; optionLength++; - memcpy(optionResult + optionLength, buf, bufLength); - optionLength += bufLength; + // Make sure there is enough room in the optionResult buffer + if ((optionLength + bufLength) < sizeof(optionResult)) + { + memcpy(&optionResult[optionLength], buf, bufLength); + optionLength += bufLength; + } + else + { + goto exit; + } } else { if (COAP_OPTION_URI_PATH == opt_iter.type) { - optionResult[optionLength] = '/'; - optionLength++; + // Make sure there is enough room in the optionResult buffer + if (optionLength < sizeof(optionResult)) + { + optionResult[optionLength] = '/'; + optionLength++; + } + else + { + goto exit; + } } else if (COAP_OPTION_URI_QUERY == opt_iter.type) { - if(false == isQueryBeingProcessed) + if (false == isQueryBeingProcessed) { - optionResult[optionLength] = '?'; - optionLength++; - isQueryBeingProcessed = true; + // Make sure there is enough room in the optionResult buffer + if (optionLength < sizeof(optionResult)) + { + optionResult[optionLength] = '?'; + optionLength++; + isQueryBeingProcessed = true; + } + else + { + goto exit; + } } else { - optionResult[optionLength] = '&'; - optionLength++; + // Make sure there is enough room in the optionResult buffer + if (optionLength < sizeof(optionResult)) + { + optionResult[optionLength] = ';'; + optionLength++; + } + else + { + goto exit; + } } } - memcpy(optionResult + optionLength, buf, bufLength); - optionLength += bufLength; + // Make sure there is enough room in the optionResult buffer + if ((optionLength + bufLength) < sizeof(optionResult)) + { + memcpy(&optionResult[optionLength], buf, bufLength); + optionLength += bufLength; + } + else + { + goto exit; + } } } + else if (COAP_OPTION_BLOCK1 == opt_iter.type || COAP_OPTION_BLOCK2 == opt_iter.type + || COAP_OPTION_SIZE1 == opt_iter.type || COAP_OPTION_SIZE2 == opt_iter.type) + { + 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 (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++; } } @@ -502,207 +939,320 @@ void CAGetInfoFromPDU(const coap_pdu_t *pdu, uint32_t *outCode, CAInfo_t *outInf } } + unsigned char* token = NULL; + unsigned int token_length = 0; + coap_get_token(pdu->hdr, transport, &token, &token_length); + // set token data - if (pdu->hdr->token_length > 0) + if (token_length > 0) { - OIC_LOG(DEBUG, TAG, "inside pdu->hdr->token_length"); - outInfo->token = (char *) OICMalloc(pdu->hdr->token_length + 1); - if (outInfo->token == NULL) + OIC_LOG_V(DEBUG, TAG, "inside token length : %d", token_length); + outInfo->token = (char *) OICMalloc(token_length); + if (NULL == outInfo->token) { - OIC_LOG(DEBUG, TAG, "CAGetInfoFromPDU, Memory allocation failed !"); + OIC_LOG(ERROR, TAG, "Out of memory"); OICFree(outInfo->options); - return; + return CA_MEMORY_ALLOC_FAILED; } - memcpy(outInfo->token, pdu->hdr->token, pdu->hdr->token_length); - outInfo->token[pdu->hdr->token_length] = '\0'; + memcpy(outInfo->token, token, token_length); } + outInfo->tokenLength = token_length; + // set payload data - if (NULL != pdu->data) + size_t dataSize; + uint8_t *data; + if (coap_get_data(pdu, &dataSize, &data)) { - uint32_t payloadLength = strlen((char*) pdu->data); OIC_LOG(DEBUG, TAG, "inside pdu->data"); - outInfo->payload = (char *) OICMalloc(payloadLength + 1); - if (outInfo->payload == NULL) + outInfo->payload = (uint8_t *) OICMalloc(dataSize); + if (NULL == outInfo->payload) { - OIC_LOG(DEBUG, TAG, "CAGetInfoFromPDU, Memory allocation failed !"); + OIC_LOG(ERROR, TAG, "Out of memory"); OICFree(outInfo->options); OICFree(outInfo->token); - return; + return CA_MEMORY_ALLOC_FAILED; } - memcpy(outInfo->payload, pdu->data, payloadLength); - outInfo->payload[payloadLength] = '\0'; + memcpy(outInfo->payload, pdu->data, dataSize); + outInfo->payloadSize = dataSize; } - uint32_t length = strlen(optionResult); - OIC_LOG_V(DEBUG, TAG, "made URL length: %d, %d, %d...\n", length, buflen, strlen(outUri)); - if (buflen >= length) + if (optionResult[0] != '\0') { - memcpy(outUri, optionResult, length); - outUri[length] = '\0'; - OIC_LOG_V(DEBUG, TAG, "made URL : %s, %s\n", optionResult, outUri); - }OIC_LOG(DEBUG, TAG, "CAGetInfoFromPDU OUT"); + OIC_LOG_V(DEBUG, TAG, "URL length:%d", strlen(optionResult)); + outInfo->resourceUri = OICStrdup(optionResult); + if (!outInfo->resourceUri) + { + OIC_LOG(ERROR, TAG, "Out of memory"); + OICFree(outInfo->options); + OICFree(outInfo->token); + return CA_MEMORY_ALLOC_FAILED; + } + } + + OIC_LOG(DEBUG, TAG, "OUT"); + return CA_STATUS_OK; + +exit: + OIC_LOG(ERROR, TAG, "buffer too small"); + OICFree(outInfo->options); + return CA_STATUS_FAILED; } -CAResult_t CAGenerateTokenInternal(CAToken_t *token) +CAResult_t CAGetTokenFromPDU(const coap_hdr_t *pdu_hdr, CAInfo_t *outInfo, + const CAEndpoint_t *endpoint) { - OIC_LOG(DEBUG, TAG, "CAGenerateTokenInternal IN"); - if (token == NULL) + OIC_LOG(DEBUG, TAG, "IN"); + if (NULL == pdu_hdr) { - return CA_STATUS_FAILED; + OIC_LOG(ERROR, TAG, "pdu_hdr is null"); + return CA_STATUS_INVALID_PARAM; } - // memory allocation - char *temp = (char *) OICCalloc(1, (CA_MAX_TOKEN_LEN + 1) * sizeof(char)); - if (temp == NULL) + if (NULL == outInfo) { - OIC_LOG(DEBUG, TAG, "CAGenerateTokenInternal, Memory allocation failed !"); - return CA_MEMORY_ALLOC_FAILED; + OIC_LOG(ERROR, TAG, "outInfo is null"); + return CA_STATUS_INVALID_PARAM; + } + + coap_transport_type transport; +#ifdef TCP_ADAPTER + if (CA_ADAPTER_TCP == 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); + + // set token data + if (token_length > 0) + { + 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"); + return CA_MEMORY_ALLOC_FAILED; + } + memcpy(outInfo->token, token, token_length); + } + + 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; + } + + if ((tokenLength > CA_MAX_TOKEN_LEN) || (0 == tokenLength)) + { + OIC_LOG(ERROR, TAG, "invalid token length"); + return CA_STATUS_INVALID_PARAM; } if (SEED == 0) { +#ifdef ARDUINO + SEED = now(); +#else SEED = time(NULL); - if (SEED == -1) +#endif + if (SEED == (unsigned int)((time_t)-1)) { - OIC_LOG(DEBUG, TAG, "Failed to Create Seed!"); + OIC_LOG(ERROR, TAG, "seed is not made"); SEED = 0; - OICFree(temp); 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) + { + OIC_LOG(ERROR, TAG, "Out of memory"); + return CA_MEMORY_ALLOC_FAILED; } // set random byte - uint32_t index; - for (index = 0; index < CA_MAX_TOKEN_LEN; index++) + for (uint8_t index = 0; index < tokenLength; index++) { // use valid characters - temp[index] = (random() % 94 + 33) & 0xFF; +#ifdef ARDUINO + temp[index] = rand() & 0x00FF; +#else + temp[index] = random() & 0x00FF; +#endif } - temp[index] = '\0'; // save token *token = temp; - OIC_LOG_V(DEBUG, TAG, "generate the token(%s)!!", *token); + OIC_LOG_V(DEBUG, TAG, "token len:%d, token:", tokenLength); + OIC_LOG_BUFFER(DEBUG, TAG, (const uint8_t *)(*token), tokenLength); - OIC_LOG(DEBUG, TAG, "CAGenerateTokenInternal OUT"); + OIC_LOG(DEBUG, TAG, "OUT"); return CA_STATUS_OK; } void CADestroyTokenInternal(CAToken_t token) { - OIC_LOG(DEBUG, TAG, "CADestroyTokenInternal IN"); - if (token != NULL) - { - OIC_LOG_V(DEBUG, TAG, "destroy the token(%s)!!", token); - - OICFree(token); - token = NULL; - } - - OIC_LOG(DEBUG, TAG, "CADestroyTokenInternal OUT"); + OIC_LOG(DEBUG, TAG, "IN"); + OICFree(token); + OIC_LOG(DEBUG, TAG, "OUT"); } void CADestroyInfo(CAInfo_t *info) { - OIC_LOG(DEBUG, TAG, "CADestroyInfo IN"); + OIC_LOG(DEBUG, TAG, "IN"); if (NULL != info) { - if (NULL != info->options) - { - OIC_LOG(DEBUG, TAG, "free options in CAInfo"); - OICFree(info->options); - } + OIC_LOG(DEBUG, TAG, "free options"); + OICFree(info->options); - if (NULL != info->token) - { - OIC_LOG(DEBUG, TAG, "free token in CAInfo"); - OICFree(info->token); - } + OIC_LOG(DEBUG, TAG, "free token"); + OICFree(info->token); - if (NULL != info->payload) - { - OIC_LOG(DEBUG, TAG, "free payload in CAInfo"); - OICFree(info->payload); - } + OIC_LOG(DEBUG, TAG, "free payload"); + OICFree(info->payload); } OIC_LOG(DEBUG, TAG, "OUT"); } -uint32_t CAGetOptionData(const uint8_t *data, uint32_t len, uint8_t *option, uint32_t buflen) +uint32_t CAGetOptionData(uint16_t key, const uint8_t *data, uint32_t len, + uint8_t *option, uint32_t buflen) { - assert(data || 0 == len); - - if (0 == buflen || 0 == len) + if (0 == buflen) { - OIC_LOG(ERROR, TAG, "buflen or len is not available"); + OIC_LOG(ERROR, TAG, "buflen 0"); return 0; } - if (NULL == data) + if (buflen <= len) { - OIC_LOG(ERROR, TAG, "data not available"); + OIC_LOG(ERROR, TAG, "option buffer too small"); return 0; } - if (NULL == option) - { - OIC_LOG(ERROR, TAG, "option pointer is null"); - return 0; - } - - uint32_t cnt = 0; - while (len) - { - if (cnt == buflen - 1) - { - break; - } - - *option++ = *data; - ++cnt; - ++data; - --len; + coap_option_def_t* def = coap_opt_def(key); + 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 { + memcpy(option, data, len); + option[len] = '\0'; } - *option = '\0'; - return cnt; + return len; } CAMessageType_t CAGetMessageTypeFromPduBinaryData(const void *pdu, uint32_t size) { - // pdu minimum size is 4 byte. - if (size < CA_PDU_MIN_SIZE) + if (NULL == pdu) { + OIC_LOG(ERROR, TAG, "pdu is null"); return CA_MSG_NONCONFIRM; } - coap_hdr_t *hdr = (coap_hdr_t *) pdu; - if (NULL == hdr) + // pdu minimum size is 4 byte. + if (size < CA_PDU_MIN_SIZE) { + OIC_LOG(ERROR, TAG, "min size"); return CA_MSG_NONCONFIRM; } - return (CAMessageType_t) hdr->type; + coap_hdr_t *hdr = (coap_hdr_t *) pdu; + + return (CAMessageType_t) hdr->coap_hdr_udp_t.type; } uint16_t CAGetMessageIdFromPduBinaryData(const void *pdu, uint32_t size) { + if (NULL == pdu) + { + OIC_LOG(ERROR, TAG, "pdu is null"); + return 0; + } + // pdu minimum size is 4 byte. if (size < CA_PDU_MIN_SIZE) { + OIC_LOG(ERROR, TAG, "min size"); return 0; } coap_hdr_t *hdr = (coap_hdr_t *) pdu; - if (NULL == hdr) + + return hdr->coap_hdr_udp_t.id; +} + +CAResponseResult_t CAGetCodeFromPduBinaryData(const void *pdu, uint32_t size) +{ + if (NULL == pdu) { - return 0; + OIC_LOG(ERROR, TAG, "pdu is null"); + return CA_NOT_FOUND; } - return ntohs(hdr->id); + // pdu minimum size is 4 byte. + if (size < CA_PDU_MIN_SIZE) + { + OIC_LOG(ERROR, TAG, "min size"); + return CA_NOT_FOUND; + } + + coap_hdr_t *hdr = (coap_hdr_t *) pdu; + + return (CAResponseResult_t) CA_RESPONSE_CODE(hdr->coap_hdr_udp_t.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; + } }