ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge pull request #11270 from anttiylitokola/update-mbed-coap-to-4.8.1 

Update mbed-coap to version 4.8.1
pull/11289/head
Martin Kojtal 2019-08-22 10:49:12 +02:00 committed by GitHub
parent edcde1ce8c 7ba7f7e8d2
commit 6812869ad5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
11 changed files with 717 additions and 836 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
features/frameworks/mbed-coap/CHANGELOG.md
View File

@ -1,5 +1,14 @@
# Change Log # Change Log
## [v4.8.1(https://github.com/ARMmbed/mbed-coap/releases/tag/v4.8.1)
- Store ACK's also into duplicate info list.
- ROM size optimization. Flash size has gone down ~1100 bytes.
**Closed issues:**
- IOTCLT-3592 - Client does not handle Duplicate ACK messages during blockwise registration correctly
-[Full Changelog](https://github.com/ARMmbed/mbed-coap/compare/v4.8.0...v4.8.1)
## [v4.8.0](https://github.com/ARMmbed/mbed-coap/releases/tag/v4.8.0) ## [v4.8.0](https://github.com/ARMmbed/mbed-coap/releases/tag/v4.8.0)
- Make `sn_coap_protocol_linked_list_duplication_info_remove` API to public. User might want to delete some messages from the duplicate list. - Make `sn_coap_protocol_linked_list_duplication_info_remove` API to public. User might want to delete some messages from the duplicate list.
- Enable support for unified client configuration. - Enable support for unified client configuration.

2
features/frameworks/mbed-coap/Makefile.test
View File

@ -49,7 +49,7 @@ test: $(TESTDIRS)
@rm -f lcov/index.xml @rm -f lcov/index.xml
@find ./ -name '*.gcno' | xargs cp --backup=numbered -t ./coverage/ @find ./ -name '*.gcno' | xargs cp --backup=numbered -t ./coverage/
@find ./ -name '*.gcda' | xargs cp --backup=numbered -t ./coverage/ @find ./ -name '*.gcda' | xargs cp --backup=numbered -t ./coverage/
@gcovr --object-directory ./coverage --exclude-unreachable-branches -e '.*/builds/.*' -e '.*/test/.*' -e '.*/stubs/.*' -e '.*/mbed-coap/.*' -x -o ./lcov/gcovr.xml @gcovr --object-directory ./coverage --exclude-unreachable-branches -e '.*/builds/.*' -e '.*/CppUTest/.*' -e '.*/mbed-client-libservice/.*' -e '.*/test/.*' -e '.*/stubs/.*' -e '.*/mbed-coap/.*' -x -o ./lcov/gcovr.xml
@lcov -d test/. -c -o $(COVERAGEFILE) @lcov -d test/. -c -o $(COVERAGEFILE)
@lcov -q -r $(COVERAGEFILE) "/usr*" -o $(COVERAGEFILE) @lcov -q -r $(COVERAGEFILE) "/usr*" -o $(COVERAGEFILE)
@lcov -q -r $(COVERAGEFILE) "/test*" -o $(COVERAGEFILE) @lcov -q -r $(COVERAGEFILE) "/test*" -o $(COVERAGEFILE)

12
features/frameworks/mbed-coap/mbed-coap/sn_coap_header.h
View File

@ -338,7 +338,7 @@ extern void sn_coap_parser_release_allocated_coap_msg_mem(struct coap_s *handle,
* -1 = Failure in given CoAP header structure\n * -1 = Failure in given CoAP header structure\n
* -2 = Failure in given pointer (= NULL) * -2 = Failure in given pointer (= NULL)
*/ */
extern int16_t sn_coap_builder(uint8_t *dst_packet_data_ptr, sn_coap_hdr_s *src_coap_msg_ptr); extern int16_t sn_coap_builder(uint8_t *dst_packet_data_ptr, const sn_coap_hdr_s *src_coap_msg_ptr);
/** /**
* \fn uint16_t sn_coap_builder_calc_needed_packet_data_size(sn_coap_hdr_s *src_coap_msg_ptr) * \fn uint16_t sn_coap_builder_calc_needed_packet_data_size(sn_coap_hdr_s *src_coap_msg_ptr)
@ -351,7 +351,7 @@ extern int16_t sn_coap_builder(uint8_t *dst_packet_data_ptr, sn_coap_hdr_s *src_
* \return Return value is count of needed memory as bytes for build Packet data * \return Return value is count of needed memory as bytes for build Packet data
* Null if failed * Null if failed
*/ */
extern uint16_t sn_coap_builder_calc_needed_packet_data_size(sn_coap_hdr_s *src_coap_msg_ptr); extern uint16_t sn_coap_builder_calc_needed_packet_data_size(const sn_coap_hdr_s *src_coap_msg_ptr);
/** /**
* \fn int16_t sn_coap_builder_2(uint8_t *dst_packet_data_ptr, sn_coap_hdr_s *src_coap_msg_ptr, uint16_t blockwise_size) * \fn int16_t sn_coap_builder_2(uint8_t *dst_packet_data_ptr, sn_coap_hdr_s *src_coap_msg_ptr, uint16_t blockwise_size)
@ -368,7 +368,7 @@ extern uint16_t sn_coap_builder_calc_needed_packet_data_size(sn_coap_hdr_s *src_
* -1 = Failure in given CoAP header structure\n * -1 = Failure in given CoAP header structure\n
* -2 = Failure in given pointer (= NULL) * -2 = Failure in given pointer (= NULL)
*/ */
extern int16_t sn_coap_builder_2(uint8_t *dst_packet_data_ptr, sn_coap_hdr_s *src_coap_msg_ptr, uint16_t blockwise_payload_size); extern int16_t sn_coap_builder_2(uint8_t *dst_packet_data_ptr, const sn_coap_hdr_s *src_coap_msg_ptr, uint16_t blockwise_payload_size);
/** /**
* \fn uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_msg_ptr, uint16_t blockwise_payload_size) * \fn uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_msg_ptr, uint16_t blockwise_payload_size)
@ -382,7 +382,7 @@ extern int16_t sn_coap_builder_2(uint8_t *dst_packet_data_ptr, sn_coap_hdr_s *sr
* \return Return value is count of needed memory as bytes for build Packet data * \return Return value is count of needed memory as bytes for build Packet data
* Null if failed * Null if failed
*/ */
extern uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_msg_ptr, uint16_t blockwise_payload_size); extern uint16_t sn_coap_builder_calc_needed_packet_data_size_2(const sn_coap_hdr_s *src_coap_msg_ptr, uint16_t blockwise_payload_size);
/** /**
* \fn sn_coap_hdr_s *sn_coap_build_response(struct coap_s *handle, sn_coap_hdr_s *coap_packet_ptr, uint8_t msg_code) * \fn sn_coap_hdr_s *sn_coap_build_response(struct coap_s *handle, sn_coap_hdr_s *coap_packet_ptr, uint8_t msg_code)
@ -397,7 +397,7 @@ extern uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *sr
* NULL Error in parsing the request * NULL Error in parsing the request
* *
*/ */
extern sn_coap_hdr_s *sn_coap_build_response(struct coap_s *handle, sn_coap_hdr_s *coap_packet_ptr, uint8_t msg_code); extern sn_coap_hdr_s *sn_coap_build_response(struct coap_s *handle, const sn_coap_hdr_s *coap_packet_ptr, uint8_t msg_code);
/** /**
* \brief Initialise a message structure to empty * \brief Initialise a message structure to empty
@ -436,6 +436,8 @@ extern sn_coap_hdr_s *sn_coap_parser_alloc_message(struct coap_s *handle);
*/ */
extern sn_coap_options_list_s *sn_coap_parser_alloc_options(struct coap_s *handle, sn_coap_hdr_s *coap_msg_ptr); extern sn_coap_options_list_s *sn_coap_parser_alloc_options(struct coap_s *handle, sn_coap_hdr_s *coap_msg_ptr);
extern sn_coap_hdr_s *sn_coap_parser_alloc_message_with_options(struct coap_s *handle);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

5
features/frameworks/mbed-coap/mbed-coap/sn_coap_protocol.h
View File

@ -38,7 +38,8 @@ extern "C" {
* *
* \param *used_malloc_func_ptr is function pointer for used memory allocation function. * \param *used_malloc_func_ptr is function pointer for used memory allocation function.
* *
* \param *used_free_func_ptr is function pointer for used memory free function. * \param *used_free_func_ptr is function pointer for used memory free function. Note: the implementation
* must handle NULL parameter and ignore it just as typical libc's free() does.
* *
* \param *used_tx_callback_ptr function callback pointer to tx function for sending coap messages * \param *used_tx_callback_ptr function callback pointer to tx function for sending coap messages
* *
@ -234,7 +235,7 @@ extern int8_t sn_coap_protocol_delete_retransmission(struct coap_s *handle, uint
* *
* \brief If re-transmissions are enabled, this function removes message from retransmission buffer. * \brief If re-transmissions are enabled, this function removes message from retransmission buffer.
*/ */
extern int8_t sn_coap_protocol_delete_retransmission_by_token(struct coap_s *handle, uint8_t *token, uint8_t token_len); extern int8_t sn_coap_protocol_delete_retransmission_by_token(struct coap_s *handle, const uint8_t *token, uint8_t token_len);
/** /**
* \fn int8_t sn_coap_convert_block_size(uint16_t block_size) * \fn int8_t sn_coap_convert_block_size(uint16_t block_size)

10
features/frameworks/mbed-coap/mbed-coap/sn_config.h
View File

@ -250,4 +250,14 @@
#define SN_COAP_MAX_INCOMING_BLOCK_MESSAGE_SIZE UINT16_MAX #define SN_COAP_MAX_INCOMING_BLOCK_MESSAGE_SIZE UINT16_MAX
#endif #endif
/**
* \def SN_COAP_BLOCKWISE_INTERNAL_BLOCK_2_HANDLING_ENABLED
* \brief A size optimization switch, which removes the blockwise Block2 response if set to 0.
* handling code which is typically overridden by a call of "sn_coap_protocol_handle_block2_response_internally(coap, false);".
* By default the code is there, so the override can be reversed by "sn_coap_protocol_handle_block2_response_internally(coap, true)".
*/
#ifndef SN_COAP_BLOCKWISE_INTERNAL_BLOCK_2_HANDLING_ENABLED
#define SN_COAP_BLOCKWISE_INTERNAL_BLOCK_2_HANDLING_ENABLED 1
#endif
#endif // SN_CONFIG_H #endif // SN_CONFIG_H

4
features/frameworks/mbed-coap/source/include/sn_coap_header_internal.h
View File

@ -58,7 +58,7 @@ extern "C" {
* \brief This structure is returned by sn_coap_exec() for sending * \brief This structure is returned by sn_coap_exec() for sending
*/ */
typedef struct sn_nsdl_transmit_ { typedef struct sn_nsdl_transmit_ {
sn_nsdl_addr_s *dst_addr_ptr; sn_nsdl_addr_s dst_addr_ptr;
sn_nsdl_capab_e protocol; sn_nsdl_capab_e protocol;
@ -69,7 +69,7 @@ typedef struct sn_nsdl_transmit_ {
/* * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * */
/* * * * EXTERNAL FUNCTION PROTOTYPES * * * */ /* * * * EXTERNAL FUNCTION PROTOTYPES * * * */
/* * * * * * * * * * * * * * * * * * * * * * */ /* * * * * * * * * * * * * * * * * * * * * * */
extern int8_t sn_coap_header_validity_check(sn_coap_hdr_s *src_coap_msg_ptr, coap_version_e coap_version); extern int8_t sn_coap_header_validity_check(const sn_coap_hdr_s *src_coap_msg_ptr, coap_version_e coap_version);
#endif /* SN_COAP_HEADER_INTERNAL_H_ */ #endif /* SN_COAP_HEADER_INTERNAL_H_ */

12
features/frameworks/mbed-coap/source/include/sn_coap_protocol_internal.h
View File

@ -48,9 +48,8 @@ typedef struct coap_send_msg_ {
uint8_t resending_counter; /* Tells how many times message is still tried to resend */ uint8_t resending_counter; /* Tells how many times message is still tried to resend */
uint32_t resending_time; /* Tells next resending time */ uint32_t resending_time; /* Tells next resending time */
sn_nsdl_transmit_s *send_msg_ptr; sn_nsdl_transmit_s send_msg_ptr;
struct coap_s *coap; /* CoAP library handle */
void *param; /* Extra parameter that will be passed to TX/RX callback functions */ void *param; /* Extra parameter that will be passed to TX/RX callback functions */
ns_list_link_t link; ns_list_link_t link;
@ -64,7 +63,6 @@ typedef struct coap_duplication_info_ {
uint16_t msg_id; uint16_t msg_id;
uint16_t packet_len; uint16_t packet_len;
uint8_t *packet_ptr; uint8_t *packet_ptr;
struct coap_s *coap; /* CoAP library handle */
sn_nsdl_addr_s *address; sn_nsdl_addr_s *address;
void *param; void *param;
ns_list_link_t link; ns_list_link_t link;
@ -77,7 +75,6 @@ typedef struct coap_blockwise_msg_ {
uint32_t timestamp; /* Tells when Blockwise message is stored to Linked list */ uint32_t timestamp; /* Tells when Blockwise message is stored to Linked list */
sn_coap_hdr_s *coap_msg_ptr; sn_coap_hdr_s *coap_msg_ptr;
struct coap_s *coap; /* CoAP library handle */
void *param; void *param;
uint16_t msg_id; uint16_t msg_id;
@ -100,7 +97,6 @@ typedef struct coap_blockwise_payload_ {
uint16_t payload_len; uint16_t payload_len;
uint8_t *payload_ptr; uint8_t *payload_ptr;
struct coap_s *coap; /* CoAP library handle */
ns_list_link_t link; ns_list_link_t link;
} coap_blockwise_payload_s; } coap_blockwise_payload_s;
@ -139,6 +135,12 @@ struct coap_s {
uint8_t sn_coap_internal_block2_resp_handling; /* If this is set then coap itself sends a next GET request automatically */ uint8_t sn_coap_internal_block2_resp_handling; /* If this is set then coap itself sends a next GET request automatically */
}; };
/* Utility function which performs a call to sn_coap_protocol_malloc() and memset's the result to zero. */
void *sn_coap_protocol_calloc(struct coap_s *handle, uint16_t length);
/* Utility function which performs a call to sn_coap_protocol_malloc() and memcopy's the source to result buffer. */
void *sn_coap_protocol_malloc_copy(struct coap_s *handle, const void *source, uint16_t length);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

349
features/frameworks/mbed-coap/source/sn_coap_builder.c
View File

@ -37,19 +37,19 @@
#define TRACE_GROUP "coap" #define TRACE_GROUP "coap"
/* * * * LOCAL FUNCTION PROTOTYPES * * * */ /* * * * LOCAL FUNCTION PROTOTYPES * * * */
static int8_t sn_coap_builder_header_build(uint8_t **dst_packet_data_pptr, sn_coap_hdr_s *src_coap_msg_ptr); static int8_t sn_coap_builder_header_build(uint8_t **dst_packet_data_pptr, const sn_coap_hdr_s *src_coap_msg_ptr);
static int8_t sn_coap_builder_options_build(uint8_t **dst_packet_data_pptr, sn_coap_hdr_s *src_coap_msg_ptr); static int8_t sn_coap_builder_options_build(uint8_t **dst_packet_data_pptr, const sn_coap_hdr_s *src_coap_msg_ptr);
static uint16_t sn_coap_builder_options_calc_option_size(uint16_t query_len, uint8_t *query_ptr, sn_coap_option_numbers_e option); static uint16_t sn_coap_builder_options_calc_option_size(uint16_t query_len, const uint8_t *query_ptr, sn_coap_option_numbers_e option);
static int16_t sn_coap_builder_options_build_add_one_option(uint8_t **dst_packet_data_pptr, uint16_t option_len, uint8_t *option_ptr, sn_coap_option_numbers_e option_number, uint16_t *previous_option_number); static int16_t sn_coap_builder_options_build_add_one_option(uint8_t **dst_packet_data_pptr, uint16_t option_len, const uint8_t *option_ptr, sn_coap_option_numbers_e option_number, uint16_t *previous_option_number);
static int16_t sn_coap_builder_options_build_add_multiple_option(uint8_t **dst_packet_data_pptr, uint8_t **src_pptr, uint16_t *src_len_ptr, sn_coap_option_numbers_e option, uint16_t *previous_option_number); static void sn_coap_builder_options_build_add_multiple_option(uint8_t **dst_packet_data_pptr, const uint8_t *src_pptr, uint16_t src_len_ptr, sn_coap_option_numbers_e option, uint16_t *previous_option_number);
static uint8_t sn_coap_builder_options_build_add_uint_option(uint8_t **dst_packet_data_pptr, uint32_t value, sn_coap_option_numbers_e option_number, uint16_t *previous_option_number); static uint8_t sn_coap_builder_options_build_add_uint_option(uint8_t **dst_packet_data_pptr, uint32_t value, sn_coap_option_numbers_e option_number, uint16_t *previous_option_number);
static uint8_t sn_coap_builder_options_get_option_part_count(uint16_t query_len, uint8_t *query_ptr, sn_coap_option_numbers_e option); static uint8_t sn_coap_builder_options_get_option_part_count(uint16_t query_len, const uint8_t *query_ptr, sn_coap_option_numbers_e option);
static uint16_t sn_coap_builder_options_get_option_part_length_from_whole_option_string(uint16_t query_len, uint8_t *query_ptr, uint8_t query_index, sn_coap_option_numbers_e option); static uint16_t sn_coap_builder_options_get_option_part_length_from_whole_option_string(uint16_t query_len, const uint8_t *query_ptr, uint8_t query_index, sn_coap_option_numbers_e option);
static int16_t sn_coap_builder_options_get_option_part_position(uint16_t query_len, uint8_t *query_ptr, uint8_t query_index, sn_coap_option_numbers_e option); static int16_t sn_coap_builder_options_get_option_part_position(uint16_t query_len, const uint8_t *query_ptr, uint8_t query_index, sn_coap_option_numbers_e option);
static void sn_coap_builder_payload_build(uint8_t **dst_packet_data_pptr, sn_coap_hdr_s *src_coap_msg_ptr); static void sn_coap_builder_payload_build(uint8_t **dst_packet_data_pptr, const sn_coap_hdr_s *src_coap_msg_ptr);
static uint8_t sn_coap_builder_options_calculate_jump_need(sn_coap_hdr_s *src_coap_msg_ptr/*, uint8_t block_option*/); static uint8_t sn_coap_builder_options_calculate_jump_need(const sn_coap_hdr_s *src_coap_msg_ptr);
sn_coap_hdr_s *sn_coap_build_response(struct coap_s *handle, sn_coap_hdr_s *coap_packet_ptr, uint8_t msg_code) sn_coap_hdr_s *sn_coap_build_response(struct coap_s *handle, const sn_coap_hdr_s *coap_packet_ptr, uint8_t msg_code)
{ {
sn_coap_hdr_s *coap_res_ptr; sn_coap_hdr_s *coap_res_ptr;
@ -86,25 +86,24 @@ sn_coap_hdr_s *sn_coap_build_response(struct coap_s *handle, sn_coap_hdr_s *coap
if (coap_packet_ptr->token_ptr) { if (coap_packet_ptr->token_ptr) {
coap_res_ptr->token_len = coap_packet_ptr->token_len; coap_res_ptr->token_len = coap_packet_ptr->token_len;
coap_res_ptr->token_ptr = handle->sn_coap_protocol_malloc(coap_res_ptr->token_len); coap_res_ptr->token_ptr = sn_coap_protocol_malloc_copy(handle, coap_packet_ptr->token_ptr, coap_res_ptr->token_len);
if (!coap_res_ptr->token_ptr) { if (!coap_res_ptr->token_ptr) {
tr_error("sn_coap_build_response - failed to allocate token!"); tr_error("sn_coap_build_response - failed to allocate token!");
handle->sn_coap_protocol_free(coap_res_ptr); handle->sn_coap_protocol_free(coap_res_ptr);
return NULL; return NULL;
} }
memcpy(coap_res_ptr->token_ptr, coap_packet_ptr->token_ptr, coap_res_ptr->token_len);
} }
return coap_res_ptr; return coap_res_ptr;
} }
int16_t sn_coap_builder(uint8_t *dst_packet_data_ptr, sn_coap_hdr_s *src_coap_msg_ptr) int16_t sn_coap_builder(uint8_t *dst_packet_data_ptr, const sn_coap_hdr_s *src_coap_msg_ptr)
{ {
return sn_coap_builder_2(dst_packet_data_ptr, src_coap_msg_ptr, SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE); return sn_coap_builder_2(dst_packet_data_ptr, src_coap_msg_ptr, SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE);
} }
int16_t sn_coap_builder_2(uint8_t *dst_packet_data_ptr, sn_coap_hdr_s *src_coap_msg_ptr, uint16_t blockwise_payload_size) int16_t sn_coap_builder_2(uint8_t *dst_packet_data_ptr, const sn_coap_hdr_s *src_coap_msg_ptr, uint16_t blockwise_payload_size)
{ {
uint8_t *base_packet_data_ptr = NULL; uint8_t *base_packet_data_ptr;
/* * * * Check given pointers * * * */ /* * * * Check given pointers * * * */
if (dst_packet_data_ptr == NULL || src_coap_msg_ptr == NULL) { if (dst_packet_data_ptr == NULL || src_coap_msg_ptr == NULL) {
@ -118,6 +117,7 @@ int16_t sn_coap_builder_2(uint8_t *dst_packet_data_ptr, sn_coap_hdr_s *src_coap_
return -1; return -1;
} }
// XXX: this should not be needed anymore but I have no courage to remove it yet.
memset(dst_packet_data_ptr, 0, dst_byte_count_to_be_built); memset(dst_packet_data_ptr, 0, dst_byte_count_to_be_built);
/* * * * Store base (= original) destination Packet data pointer for later usage * * * */ /* * * * Store base (= original) destination Packet data pointer for later usage * * * */
@ -147,12 +147,12 @@ int16_t sn_coap_builder_2(uint8_t *dst_packet_data_ptr, sn_coap_hdr_s *src_coap_
/* * * * Return built Packet data length * * * */ /* * * * Return built Packet data length * * * */
return (dst_packet_data_ptr - base_packet_data_ptr); return (dst_packet_data_ptr - base_packet_data_ptr);
} }
uint16_t sn_coap_builder_calc_needed_packet_data_size(sn_coap_hdr_s *src_coap_msg_ptr) uint16_t sn_coap_builder_calc_needed_packet_data_size(const sn_coap_hdr_s *src_coap_msg_ptr)
{ {
return sn_coap_builder_calc_needed_packet_data_size_2(src_coap_msg_ptr, SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE); return sn_coap_builder_calc_needed_packet_data_size_2(src_coap_msg_ptr, SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE);
} }
uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_msg_ptr, uint16_t blockwise_payload_size) uint16_t sn_coap_builder_calc_needed_packet_data_size_2(const sn_coap_hdr_s *src_coap_msg_ptr, uint16_t blockwise_payload_size)
{ {
(void)blockwise_payload_size; (void)blockwise_payload_size;
uint16_t returned_byte_count = 0; uint16_t returned_byte_count = 0;
@ -203,30 +203,33 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
} }
/* If options list pointer exists */ /* If options list pointer exists */
if (src_coap_msg_ptr->options_list_ptr != NULL) { if (src_coap_msg_ptr->options_list_ptr != NULL) {
const sn_coap_options_list_s *src_options_list_ptr = src_coap_msg_ptr->options_list_ptr;
/* ACCEPT - An integer option, up to 2 bytes */ /* ACCEPT - An integer option, up to 2 bytes */
if (src_coap_msg_ptr->options_list_ptr->accept != COAP_CT_NONE) { if (src_options_list_ptr->accept != COAP_CT_NONE) {
if ((uint32_t) src_coap_msg_ptr->options_list_ptr->accept > 0xffff) { if ((uint32_t) src_options_list_ptr->accept > 0xffff) {
tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - accept too large!"); tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - accept too large!");
return 0; return 0;
} }
returned_byte_count += sn_coap_builder_options_build_add_uint_option(NULL, src_coap_msg_ptr->options_list_ptr->accept, COAP_OPTION_ACCEPT, &tempInt); returned_byte_count += sn_coap_builder_options_build_add_uint_option(NULL, src_options_list_ptr->accept, COAP_OPTION_ACCEPT, &tempInt);
} }
/* MAX AGE - An integer option, omitted for default. Up to 4 bytes */ /* MAX AGE - An integer option, omitted for default. Up to 4 bytes */
if (src_coap_msg_ptr->options_list_ptr->max_age != COAP_OPTION_MAX_AGE_DEFAULT) { if (src_options_list_ptr->max_age != COAP_OPTION_MAX_AGE_DEFAULT) {
returned_byte_count += sn_coap_builder_options_build_add_uint_option(NULL, src_coap_msg_ptr->options_list_ptr->max_age, COAP_OPTION_MAX_AGE, &tempInt); returned_byte_count += sn_coap_builder_options_build_add_uint_option(NULL, src_options_list_ptr->max_age, COAP_OPTION_MAX_AGE, &tempInt);
} }
/* PROXY URI - Length of this option is 1-1034 bytes */ /* PROXY URI - Length of this option is 1-1034 bytes */
if (src_coap_msg_ptr->options_list_ptr->proxy_uri_ptr != NULL) { if (src_options_list_ptr->proxy_uri_ptr != NULL) {
if (src_coap_msg_ptr->options_list_ptr->proxy_uri_len >= 1 && src_coap_msg_ptr->options_list_ptr->proxy_uri_len <= 12) { /* Add option header byte(s) - depending of option length */ if (src_options_list_ptr->proxy_uri_len >= 1 && src_options_list_ptr->proxy_uri_len <= 12) { /* Add option header byte(s) - depending of option length */
returned_byte_count++; returned_byte_count++;
} }
else if (src_coap_msg_ptr->options_list_ptr->proxy_uri_len >= 13 && src_coap_msg_ptr->options_list_ptr->proxy_uri_len <= 269) { else if (src_options_list_ptr->proxy_uri_len >= 13 && src_options_list_ptr->proxy_uri_len <= 269) {
returned_byte_count += 2; returned_byte_count += 2;
} }
else if (src_coap_msg_ptr->options_list_ptr->proxy_uri_len >= 270 && src_coap_msg_ptr->options_list_ptr->proxy_uri_len <= 1034) { else if (src_options_list_ptr->proxy_uri_len >= 270 && src_options_list_ptr->proxy_uri_len <= 1034) {
returned_byte_count += 3; returned_byte_count += 3;
} }
@ -236,12 +239,12 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
} }
/* Add needed memory for Option value */ /* Add needed memory for Option value */
returned_byte_count += src_coap_msg_ptr->options_list_ptr->proxy_uri_len; returned_byte_count += src_options_list_ptr->proxy_uri_len;
} }
/* ETAG - Repeatable option. Length of this option is 1-8 bytes*/ /* ETAG - Repeatable option. Length of this option is 1-8 bytes*/
if (src_coap_msg_ptr->options_list_ptr->etag_ptr != NULL) { if (src_options_list_ptr->etag_ptr != NULL) {
repeatable_option_size = sn_coap_builder_options_calc_option_size(src_coap_msg_ptr->options_list_ptr->etag_len, repeatable_option_size = sn_coap_builder_options_calc_option_size(src_options_list_ptr->etag_len,
src_coap_msg_ptr->options_list_ptr->etag_ptr, COAP_OPTION_ETAG); src_options_list_ptr->etag_ptr, COAP_OPTION_ETAG);
if (repeatable_option_size) { if (repeatable_option_size) {
returned_byte_count += repeatable_option_size; returned_byte_count += repeatable_option_size;
} else { } else {
@ -250,12 +253,12 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
} }
} }
/* URI HOST - Length of this option is 1-255 bytes */ /* URI HOST - Length of this option is 1-255 bytes */
if (src_coap_msg_ptr->options_list_ptr->uri_host_ptr != NULL) { if (src_options_list_ptr->uri_host_ptr != NULL) {
if (src_coap_msg_ptr->options_list_ptr->uri_host_len > 0 && src_coap_msg_ptr->options_list_ptr->uri_host_len <= 12) { if (src_options_list_ptr->uri_host_len > 0 && src_options_list_ptr->uri_host_len <= 12) {
returned_byte_count++; returned_byte_count++;
} }
else if (src_coap_msg_ptr->options_list_ptr->uri_host_len >= 13 && src_coap_msg_ptr->options_list_ptr->uri_host_len <= 255) { else if (src_options_list_ptr->uri_host_len >= 13 && src_options_list_ptr->uri_host_len <= 255) {
returned_byte_count += 2; returned_byte_count += 2;
} }
@ -264,12 +267,12 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
return 0; return 0;
} }
returned_byte_count += src_coap_msg_ptr->options_list_ptr->uri_host_len; returned_byte_count += src_options_list_ptr->uri_host_len;
} }
/* LOCATION PATH - Repeatable option. Length of this option is 0-255 bytes*/ /* LOCATION PATH - Repeatable option. Length of this option is 0-255 bytes*/
if (src_coap_msg_ptr->options_list_ptr->location_path_ptr != NULL) { if (src_options_list_ptr->location_path_ptr != NULL) {
repeatable_option_size = sn_coap_builder_options_calc_option_size(src_coap_msg_ptr->options_list_ptr->location_path_len, repeatable_option_size = sn_coap_builder_options_calc_option_size(src_options_list_ptr->location_path_len,
src_coap_msg_ptr->options_list_ptr->location_path_ptr, COAP_OPTION_LOCATION_PATH); src_options_list_ptr->location_path_ptr, COAP_OPTION_LOCATION_PATH);
if (repeatable_option_size) { if (repeatable_option_size) {
returned_byte_count += repeatable_option_size; returned_byte_count += repeatable_option_size;
} else { } else {
@ -278,17 +281,17 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
} }
} }
/* URI PORT - An integer option, up to 2 bytes */ /* URI PORT - An integer option, up to 2 bytes */
if (src_coap_msg_ptr->options_list_ptr->uri_port != COAP_OPTION_URI_PORT_NONE) { if (src_options_list_ptr->uri_port != COAP_OPTION_URI_PORT_NONE) {
if ((uint32_t) src_coap_msg_ptr->options_list_ptr->uri_port > 0xffff) { if ((uint32_t) src_options_list_ptr->uri_port > 0xffff) {
tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - uri port too large!"); tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - uri port too large!");
return 0; return 0;
} }
returned_byte_count += sn_coap_builder_options_build_add_uint_option(NULL, src_coap_msg_ptr->options_list_ptr->uri_port, COAP_OPTION_URI_PORT, &tempInt); returned_byte_count += sn_coap_builder_options_build_add_uint_option(NULL, src_options_list_ptr->uri_port, COAP_OPTION_URI_PORT, &tempInt);
} }
/* lOCATION QUERY - Repeatable option. Length of this option is 0-255 bytes */ /* lOCATION QUERY - Repeatable option. Length of this option is 0-255 bytes */
if (src_coap_msg_ptr->options_list_ptr->location_query_ptr != NULL) { if (src_options_list_ptr->location_query_ptr != NULL) {
repeatable_option_size = sn_coap_builder_options_calc_option_size(src_coap_msg_ptr->options_list_ptr->location_query_len, repeatable_option_size = sn_coap_builder_options_calc_option_size(src_options_list_ptr->location_query_len,
src_coap_msg_ptr->options_list_ptr->location_query_ptr, COAP_OPTION_LOCATION_QUERY); src_options_list_ptr->location_query_ptr, COAP_OPTION_LOCATION_QUERY);
if (repeatable_option_size) { if (repeatable_option_size) {
returned_byte_count += repeatable_option_size; returned_byte_count += repeatable_option_size;
} else { } else {
@ -297,16 +300,16 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
} }
} }
/* OBSERVE - An integer option, up to 3 bytes */ /* OBSERVE - An integer option, up to 3 bytes */
if (src_coap_msg_ptr->options_list_ptr->observe != COAP_OBSERVE_NONE) { if (src_options_list_ptr->observe != COAP_OBSERVE_NONE) {
if ((uint32_t) src_coap_msg_ptr->options_list_ptr->observe > 0xffffff) { if ((uint32_t) src_options_list_ptr->observe > 0xffffff) {
return 0; return 0;
} }
returned_byte_count += sn_coap_builder_options_build_add_uint_option(NULL, src_coap_msg_ptr->options_list_ptr->observe, COAP_OPTION_OBSERVE, &tempInt); returned_byte_count += sn_coap_builder_options_build_add_uint_option(NULL, src_options_list_ptr->observe, COAP_OPTION_OBSERVE, &tempInt);
} }
/* URI QUERY - Repeatable option. Length of this option is 1-255 */ /* URI QUERY - Repeatable option. Length of this option is 1-255 */
if (src_coap_msg_ptr->options_list_ptr->uri_query_ptr != NULL) { if (src_options_list_ptr->uri_query_ptr != NULL) {
repeatable_option_size = sn_coap_builder_options_calc_option_size(src_coap_msg_ptr->options_list_ptr->uri_query_len, repeatable_option_size = sn_coap_builder_options_calc_option_size(src_options_list_ptr->uri_query_len,
src_coap_msg_ptr->options_list_ptr->uri_query_ptr, COAP_OPTION_URI_QUERY); src_options_list_ptr->uri_query_ptr, COAP_OPTION_URI_QUERY);
if (repeatable_option_size) { if (repeatable_option_size) {
returned_byte_count += repeatable_option_size; returned_byte_count += repeatable_option_size;
} else { } else {
@ -316,28 +319,28 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
} }
/* BLOCK 1 - An integer option, up to 3 bytes */ /* BLOCK 1 - An integer option, up to 3 bytes */
if (src_coap_msg_ptr->options_list_ptr->block1 != COAP_OPTION_BLOCK_NONE) { if (src_options_list_ptr->block1 != COAP_OPTION_BLOCK_NONE) {
if ((uint32_t) src_coap_msg_ptr->options_list_ptr->block1 > 0xffffff) { if ((uint32_t) src_options_list_ptr->block1 > 0xffffff) {
tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - block1 too large!"); tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - block1 too large!");
return 0; return 0;
} }
returned_byte_count += sn_coap_builder_options_build_add_uint_option(NULL, src_coap_msg_ptr->options_list_ptr->block1, COAP_OPTION_BLOCK1, &tempInt); returned_byte_count += sn_coap_builder_options_build_add_uint_option(NULL, src_options_list_ptr->block1, COAP_OPTION_BLOCK1, &tempInt);
} }
/* SIZE1 - Length of this option is 0-4 bytes */ /* SIZE1 - Length of this option is 0-4 bytes */
if (src_coap_msg_ptr->options_list_ptr->use_size1) { if (src_options_list_ptr->use_size1) {
returned_byte_count += sn_coap_builder_options_build_add_uint_option(NULL, src_coap_msg_ptr->options_list_ptr->size1, COAP_OPTION_SIZE1, &tempInt); returned_byte_count += sn_coap_builder_options_build_add_uint_option(NULL, src_options_list_ptr->size1, COAP_OPTION_SIZE1, &tempInt);
} }
/* BLOCK 2 - An integer option, up to 3 bytes */ /* BLOCK 2 - An integer option, up to 3 bytes */
if (src_coap_msg_ptr->options_list_ptr->block2 != COAP_OPTION_BLOCK_NONE) { if (src_options_list_ptr->block2 != COAP_OPTION_BLOCK_NONE) {
if ((uint32_t) src_coap_msg_ptr->options_list_ptr->block2 > 0xffffff) { if ((uint32_t) src_options_list_ptr->block2 > 0xffffff) {
tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - block2 too large!"); tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - block2 too large!");
return 0; return 0;
} }
returned_byte_count += sn_coap_builder_options_build_add_uint_option(NULL, src_coap_msg_ptr->options_list_ptr->block2, COAP_OPTION_BLOCK2, &tempInt); returned_byte_count += sn_coap_builder_options_build_add_uint_option(NULL, src_options_list_ptr->block2, COAP_OPTION_BLOCK2, &tempInt);
} }
/* SIZE2 - Length of this option is 0-4 bytes */ /* SIZE2 - Length of this option is 0-4 bytes */
if (src_coap_msg_ptr->options_list_ptr->use_size2) { if (src_coap_msg_ptr->options_list_ptr->use_size2) {
returned_byte_count += sn_coap_builder_options_build_add_uint_option(NULL, src_coap_msg_ptr->options_list_ptr->size2, COAP_OPTION_SIZE2, &tempInt); returned_byte_count += sn_coap_builder_options_build_add_uint_option(NULL, src_options_list_ptr->size2, COAP_OPTION_SIZE2, &tempInt);
} }
} }
#if SN_COAP_BLOCKWISE_ENABLED || SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE #if SN_COAP_BLOCKWISE_ENABLED || SN_COAP_MAX_BLOCKWISE_PAYLOAD_SIZE
@ -354,12 +357,12 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
if (src_coap_msg_ptr->payload_len) { if (src_coap_msg_ptr->payload_len) {
returned_byte_count ++; /* For payload marker */ returned_byte_count ++; /* For payload marker */
} }
returned_byte_count += sn_coap_builder_options_calculate_jump_need(src_coap_msg_ptr/*, 0*/); returned_byte_count += sn_coap_builder_options_calculate_jump_need(src_coap_msg_ptr);
} }
return returned_byte_count; return returned_byte_count;
} }
/** /**
* \fn static uint8_t sn_coap_builder_options_calculate_jump_need(sn_coap_hdr_s *src_coap_msg_ptr, uint8_t block_option) * \fn static uint8_t sn_coap_builder_options_calculate_jump_need(sn_coap_hdr_s *src_coap_msg_ptr)
* *
* \brief Checks if there is need for option jump * \brief Checks if there is need for option jump
* *
@ -370,43 +373,47 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
* \return Returns bytes needed for jumping * \return Returns bytes needed for jumping
*/ */
static uint8_t sn_coap_builder_options_calculate_jump_need(sn_coap_hdr_s *src_coap_msg_ptr/*, uint8_t block_option*/) static uint8_t sn_coap_builder_options_calculate_jump_need(const sn_coap_hdr_s *src_coap_msg_ptr)
{ {
uint8_t previous_option_number = 0; uint8_t previous_option_number = 0;
uint8_t needed_space = 0; uint8_t needed_space = 0;
if (src_coap_msg_ptr->options_list_ptr != NULL) { const sn_coap_options_list_s* options_list_ptr = src_coap_msg_ptr->options_list_ptr;
if (options_list_ptr != NULL) {
/* If option numbers greater than 12 is not used, then jumping is not needed */ /* If option numbers greater than 12 is not used, then jumping is not needed */
//TODO: Check if this is really needed! Does it enhance perf? If not -> remove //TODO: Check if this is really needed! Does it enhance perf? If not -> remove
if (!src_coap_msg_ptr->options_list_ptr->uri_query_ptr && if (!options_list_ptr->uri_query_ptr &&
src_coap_msg_ptr->options_list_ptr->accept == COAP_CT_NONE && options_list_ptr->accept == COAP_CT_NONE &&
!src_coap_msg_ptr->options_list_ptr->location_query_ptr && !options_list_ptr->location_query_ptr &&
src_coap_msg_ptr->options_list_ptr->block2 == COAP_OPTION_BLOCK_NONE && options_list_ptr->block2 == COAP_OPTION_BLOCK_NONE &&
src_coap_msg_ptr->options_list_ptr->block1 == COAP_OPTION_BLOCK_NONE && options_list_ptr->block1 == COAP_OPTION_BLOCK_NONE &&
!src_coap_msg_ptr->options_list_ptr->proxy_uri_ptr && !options_list_ptr->proxy_uri_ptr &&
src_coap_msg_ptr->options_list_ptr->max_age == COAP_OPTION_MAX_AGE_DEFAULT && options_list_ptr->max_age == COAP_OPTION_MAX_AGE_DEFAULT &&
!src_coap_msg_ptr->options_list_ptr->use_size1 && !options_list_ptr->use_size1 &&
!src_coap_msg_ptr->options_list_ptr->use_size2) { !options_list_ptr->use_size2) {
return 0; return 0;
} }
if (src_coap_msg_ptr->options_list_ptr->uri_host_ptr != NULL) { if (options_list_ptr->uri_host_ptr != NULL) {
previous_option_number = (COAP_OPTION_URI_HOST); previous_option_number = (COAP_OPTION_URI_HOST);
} }
if (src_coap_msg_ptr->options_list_ptr->etag_ptr != NULL) { if (options_list_ptr->etag_ptr != NULL) {
previous_option_number = (COAP_OPTION_ETAG); previous_option_number = (COAP_OPTION_ETAG);
} }
if (src_coap_msg_ptr->options_list_ptr->observe != COAP_OBSERVE_NONE) { if (options_list_ptr->observe != COAP_OBSERVE_NONE) {
previous_option_number = (COAP_OPTION_OBSERVE); previous_option_number = (COAP_OPTION_OBSERVE);
} }
if (src_coap_msg_ptr->options_list_ptr->uri_port != COAP_OPTION_URI_PORT_NONE) { if (options_list_ptr->uri_port != COAP_OPTION_URI_PORT_NONE) {
previous_option_number = (COAP_OPTION_URI_PORT); previous_option_number = (COAP_OPTION_URI_PORT);
} }
if (src_coap_msg_ptr->options_list_ptr->location_path_ptr != NULL) { if (options_list_ptr->location_path_ptr != NULL) {
previous_option_number = (COAP_OPTION_LOCATION_PATH); previous_option_number = (COAP_OPTION_LOCATION_PATH);
} }
@ -416,50 +423,51 @@ static uint8_t sn_coap_builder_options_calculate_jump_need(sn_coap_hdr_s *src_co
if (src_coap_msg_ptr->content_format != COAP_CT_NONE) { if (src_coap_msg_ptr->content_format != COAP_CT_NONE) {
previous_option_number = (COAP_OPTION_CONTENT_FORMAT); previous_option_number = (COAP_OPTION_CONTENT_FORMAT);
} }
if (src_coap_msg_ptr->options_list_ptr->max_age != COAP_OPTION_MAX_AGE_DEFAULT) {
if (options_list_ptr->max_age != COAP_OPTION_MAX_AGE_DEFAULT) {
if ((COAP_OPTION_MAX_AGE - previous_option_number) > 12) { if ((COAP_OPTION_MAX_AGE - previous_option_number) > 12) {
needed_space += 1; needed_space += 1;
} }
previous_option_number = (COAP_OPTION_MAX_AGE); previous_option_number = (COAP_OPTION_MAX_AGE);
} }
if (src_coap_msg_ptr->options_list_ptr->uri_query_ptr != NULL) { if (options_list_ptr->uri_query_ptr != NULL) {
if ((COAP_OPTION_URI_QUERY - previous_option_number) > 12) { if ((COAP_OPTION_URI_QUERY - previous_option_number) > 12) {
needed_space += 1; needed_space += 1;
} }
previous_option_number = (COAP_OPTION_URI_QUERY); previous_option_number = (COAP_OPTION_URI_QUERY);
} }
if (src_coap_msg_ptr->options_list_ptr->accept != COAP_CT_NONE) { if (options_list_ptr->accept != COAP_CT_NONE) {
if ((COAP_OPTION_ACCEPT - previous_option_number) > 12) { if ((COAP_OPTION_ACCEPT - previous_option_number) > 12) {
needed_space += 1; needed_space += 1;
} }
previous_option_number = (COAP_OPTION_ACCEPT); previous_option_number = (COAP_OPTION_ACCEPT);
} }
if (src_coap_msg_ptr->options_list_ptr->location_query_ptr != NULL) { if (options_list_ptr->location_query_ptr != NULL) {
if ((COAP_OPTION_LOCATION_QUERY - previous_option_number) > 12) { if ((COAP_OPTION_LOCATION_QUERY - previous_option_number) > 12) {
needed_space += 1; needed_space += 1;
} }
previous_option_number = (COAP_OPTION_LOCATION_QUERY); previous_option_number = (COAP_OPTION_LOCATION_QUERY);
} }
if (src_coap_msg_ptr->options_list_ptr->block2 != COAP_OPTION_BLOCK_NONE) { if (options_list_ptr->block2 != COAP_OPTION_BLOCK_NONE) {
if ((COAP_OPTION_BLOCK2 - previous_option_number) > 12 ){ if ((COAP_OPTION_BLOCK2 - previous_option_number) > 12 ){
needed_space += 1; needed_space += 1;
} }
previous_option_number = (COAP_OPTION_BLOCK2); previous_option_number = (COAP_OPTION_BLOCK2);
} }
if (src_coap_msg_ptr->options_list_ptr->block1 != COAP_OPTION_BLOCK_NONE) { if (options_list_ptr->block1 != COAP_OPTION_BLOCK_NONE) {
if ((COAP_OPTION_BLOCK1 - previous_option_number) > 12 ){ if ((COAP_OPTION_BLOCK1 - previous_option_number) > 12 ){
needed_space += 1; needed_space += 1;
} }
previous_option_number = (COAP_OPTION_BLOCK1); previous_option_number = (COAP_OPTION_BLOCK1);
} }
if (src_coap_msg_ptr->options_list_ptr->use_size2) { if (options_list_ptr->use_size2) {
if ((COAP_OPTION_SIZE2 - previous_option_number) > 12) { if ((COAP_OPTION_SIZE2 - previous_option_number) > 12) {
needed_space += 1; needed_space += 1;
} }
previous_option_number = (COAP_OPTION_SIZE2); previous_option_number = (COAP_OPTION_SIZE2);
} }
if (src_coap_msg_ptr->options_list_ptr->proxy_uri_ptr != NULL) { if (options_list_ptr->proxy_uri_ptr != NULL) {
if ((COAP_OPTION_PROXY_URI - previous_option_number) > 12) { if ((COAP_OPTION_PROXY_URI - previous_option_number) > 12) {
needed_space += 1; needed_space += 1;
} }
@ -468,7 +476,7 @@ static uint8_t sn_coap_builder_options_calculate_jump_need(sn_coap_hdr_s *src_co
} }
previous_option_number = (COAP_OPTION_PROXY_URI); previous_option_number = (COAP_OPTION_PROXY_URI);
} }
if (src_coap_msg_ptr->options_list_ptr->use_size1 ) { if (options_list_ptr->use_size1) {
if ((COAP_OPTION_SIZE1 - previous_option_number) > 12) { if ((COAP_OPTION_SIZE1 - previous_option_number) > 12) {
needed_space += 1; needed_space += 1;
} }
@ -499,7 +507,7 @@ static uint8_t sn_coap_builder_options_calculate_jump_need(sn_coap_hdr_s *src_co
* *
* \return Return value is 0 in ok case and -1 in failure case * \return Return value is 0 in ok case and -1 in failure case
**************************************************************************** */ **************************************************************************** */
static int8_t sn_coap_builder_header_build(uint8_t **dst_packet_data_pptr, sn_coap_hdr_s *src_coap_msg_ptr) static int8_t sn_coap_builder_header_build(uint8_t **dst_packet_data_pptr, const sn_coap_hdr_s *src_coap_msg_ptr)
{ {
/* * * * Check validity of Header values * * * */ /* * * * Check validity of Header values * * * */
if (sn_coap_header_validity_check(src_coap_msg_ptr, COAP_VERSION) != 0) { if (sn_coap_header_validity_check(src_coap_msg_ptr, COAP_VERSION) != 0) {
@ -507,25 +515,19 @@ static int8_t sn_coap_builder_header_build(uint8_t **dst_packet_data_pptr, sn_co
return -1; return -1;
} }
/* * * Add CoAP Version * * */ uint8_t* dest_packet = *dst_packet_data_pptr;
**dst_packet_data_pptr += COAP_VERSION;
/* * * Add Message type * * */ /* Set CoAP Version, Message type and Token length */
**dst_packet_data_pptr += src_coap_msg_ptr->msg_type; dest_packet[0] = COAP_VERSION | src_coap_msg_ptr->msg_type | src_coap_msg_ptr->token_len;
/* * * Add Token length * * */
**dst_packet_data_pptr += (src_coap_msg_ptr->token_len);
(*dst_packet_data_pptr) ++;
/* * * Add Message code * * */ /* * * Add Message code * * */
**dst_packet_data_pptr = src_coap_msg_ptr->msg_code; dest_packet[1] = src_coap_msg_ptr->msg_code;
(*dst_packet_data_pptr) ++;
/* * * Add Message ID * * */ /* * * Add Message ID * * */
**dst_packet_data_pptr = (uint8_t)(src_coap_msg_ptr->msg_id >> COAP_HEADER_MSG_ID_MSB_SHIFT); /* MSB part */ dest_packet[2] = (uint8_t)(src_coap_msg_ptr->msg_id >> COAP_HEADER_MSG_ID_MSB_SHIFT); /* MSB part */
(*dst_packet_data_pptr) ++; dest_packet[3] = (uint8_t)src_coap_msg_ptr->msg_id; /* LSB part */
**dst_packet_data_pptr = (uint8_t)src_coap_msg_ptr->msg_id; /* LSB part */
(*dst_packet_data_pptr) ++; *dst_packet_data_pptr = dest_packet + 4;
/* Success */ /* Success */
return 0; return 0;
@ -542,7 +544,7 @@ static int8_t sn_coap_builder_header_build(uint8_t **dst_packet_data_pptr, sn_co
* *
* \return Return value is 0 in every case * \return Return value is 0 in every case
*/ */
static int8_t sn_coap_builder_options_build(uint8_t **dst_packet_data_pptr, sn_coap_hdr_s *src_coap_msg_ptr) static int8_t sn_coap_builder_options_build(uint8_t **dst_packet_data_pptr, const sn_coap_hdr_s *src_coap_msg_ptr)
{ {
/* * * * Check if Options are used at all * * * */ /* * * * Check if Options are used at all * * * */
if (src_coap_msg_ptr->uri_path_ptr == NULL && src_coap_msg_ptr->token_ptr == NULL && if (src_coap_msg_ptr->uri_path_ptr == NULL && src_coap_msg_ptr->token_ptr == NULL &&
@ -567,35 +569,37 @@ static int8_t sn_coap_builder_options_build(uint8_t **dst_packet_data_pptr, sn_c
//missing: COAP_OPTION_IF_MATCH, COAP_OPTION_IF_NONE_MATCH, COAP_OPTION_SIZE //missing: COAP_OPTION_IF_MATCH, COAP_OPTION_IF_NONE_MATCH, COAP_OPTION_SIZE
const sn_coap_options_list_s *src_options_list_ptr = src_coap_msg_ptr->options_list_ptr;
/* Check if less used options are used at all */ /* Check if less used options are used at all */
if (src_coap_msg_ptr->options_list_ptr != NULL) { if (src_options_list_ptr != NULL) {
/* * * * Build Uri-Host option * * * */ /* * * * Build Uri-Host option * * * */
sn_coap_builder_options_build_add_one_option(dst_packet_data_pptr, src_coap_msg_ptr->options_list_ptr->uri_host_len, sn_coap_builder_options_build_add_one_option(dst_packet_data_pptr, src_options_list_ptr->uri_host_len,
src_coap_msg_ptr->options_list_ptr->uri_host_ptr, COAP_OPTION_URI_HOST, &previous_option_number); src_options_list_ptr->uri_host_ptr, COAP_OPTION_URI_HOST, &previous_option_number);
/* * * * Build ETag option * * * */ /* * * * Build ETag option * * * */
sn_coap_builder_options_build_add_multiple_option(dst_packet_data_pptr, &src_coap_msg_ptr->options_list_ptr->etag_ptr, sn_coap_builder_options_build_add_multiple_option(dst_packet_data_pptr, src_options_list_ptr->etag_ptr,
(uint16_t *)&src_coap_msg_ptr->options_list_ptr->etag_len, COAP_OPTION_ETAG, &previous_option_number); src_options_list_ptr->etag_len, COAP_OPTION_ETAG, &previous_option_number);
/* * * * Build Observe option * * * * */ /* * * * Build Observe option * * * * */
if (src_coap_msg_ptr->options_list_ptr->observe != COAP_OBSERVE_NONE) { if (src_options_list_ptr->observe != COAP_OBSERVE_NONE) {
sn_coap_builder_options_build_add_uint_option(dst_packet_data_pptr, src_coap_msg_ptr->options_list_ptr->observe, sn_coap_builder_options_build_add_uint_option(dst_packet_data_pptr, src_options_list_ptr->observe,
COAP_OPTION_OBSERVE, &previous_option_number); COAP_OPTION_OBSERVE, &previous_option_number);
} }
/* * * * Build Uri-Port option * * * */ /* * * * Build Uri-Port option * * * */
if (src_coap_msg_ptr->options_list_ptr->uri_port != COAP_OPTION_URI_PORT_NONE) { if (src_options_list_ptr->uri_port != COAP_OPTION_URI_PORT_NONE) {
sn_coap_builder_options_build_add_uint_option(dst_packet_data_pptr, src_coap_msg_ptr->options_list_ptr->uri_port, sn_coap_builder_options_build_add_uint_option(dst_packet_data_pptr, src_options_list_ptr->uri_port,
COAP_OPTION_URI_PORT, &previous_option_number); COAP_OPTION_URI_PORT, &previous_option_number);
} }
/* * * * Build Location-Path option * * * */ /* * * * Build Location-Path option * * * */
sn_coap_builder_options_build_add_multiple_option(dst_packet_data_pptr, &src_coap_msg_ptr->options_list_ptr->location_path_ptr, sn_coap_builder_options_build_add_multiple_option(dst_packet_data_pptr, src_options_list_ptr->location_path_ptr,
&src_coap_msg_ptr->options_list_ptr->location_path_len, COAP_OPTION_LOCATION_PATH, &previous_option_number); src_options_list_ptr->location_path_len, COAP_OPTION_LOCATION_PATH, &previous_option_number);
} }
/* * * * Build Uri-Path option * * * */ /* * * * Build Uri-Path option * * * */
sn_coap_builder_options_build_add_multiple_option(dst_packet_data_pptr, &src_coap_msg_ptr->uri_path_ptr, sn_coap_builder_options_build_add_multiple_option(dst_packet_data_pptr, src_coap_msg_ptr->uri_path_ptr,
&src_coap_msg_ptr->uri_path_len, COAP_OPTION_URI_PATH, &previous_option_number); src_coap_msg_ptr->uri_path_len, COAP_OPTION_URI_PATH, &previous_option_number);
/* * * * Build Content-Type option * * * */ /* * * * Build Content-Type option * * * */
if (src_coap_msg_ptr->content_format != COAP_CT_NONE) { if (src_coap_msg_ptr->content_format != COAP_CT_NONE) {
@ -603,55 +607,53 @@ static int8_t sn_coap_builder_options_build(uint8_t **dst_packet_data_pptr, sn_c
COAP_OPTION_CONTENT_FORMAT, &previous_option_number); COAP_OPTION_CONTENT_FORMAT, &previous_option_number);
} }
if (src_coap_msg_ptr->options_list_ptr != NULL) { if (src_options_list_ptr != NULL) {
/* * * * Build Max-Age option * * * */ /* * * * Build Max-Age option * * * */
if (src_coap_msg_ptr->options_list_ptr->max_age != COAP_OPTION_MAX_AGE_DEFAULT) { if (src_options_list_ptr->max_age != COAP_OPTION_MAX_AGE_DEFAULT) {
sn_coap_builder_options_build_add_uint_option(dst_packet_data_pptr, src_coap_msg_ptr->options_list_ptr->max_age, sn_coap_builder_options_build_add_uint_option(dst_packet_data_pptr, src_options_list_ptr->max_age,
COAP_OPTION_MAX_AGE, &previous_option_number); COAP_OPTION_MAX_AGE, &previous_option_number);
} }
/* * * * Build Uri-Query option * * * * */ /* * * * Build Uri-Query option * * * * */
sn_coap_builder_options_build_add_multiple_option(dst_packet_data_pptr, &src_coap_msg_ptr->options_list_ptr->uri_query_ptr, sn_coap_builder_options_build_add_multiple_option(dst_packet_data_pptr, src_options_list_ptr->uri_query_ptr,
&src_coap_msg_ptr->options_list_ptr->uri_query_len, COAP_OPTION_URI_QUERY, &previous_option_number); src_options_list_ptr->uri_query_len, COAP_OPTION_URI_QUERY, &previous_option_number);
/* * * * Build Accept option * * * * */ /* * * * Build Accept option * * * * */
if (src_coap_msg_ptr->options_list_ptr->accept != COAP_CT_NONE) { if (src_coap_msg_ptr->options_list_ptr->accept != COAP_CT_NONE) {
sn_coap_builder_options_build_add_uint_option(dst_packet_data_pptr, src_coap_msg_ptr->options_list_ptr->accept, sn_coap_builder_options_build_add_uint_option(dst_packet_data_pptr, src_options_list_ptr->accept,
COAP_OPTION_ACCEPT, &previous_option_number); COAP_OPTION_ACCEPT, &previous_option_number);
} }
}
if (src_coap_msg_ptr->options_list_ptr != NULL) {
/* * * * Build Location-Query option * * * */ /* * * * Build Location-Query option * * * */
sn_coap_builder_options_build_add_multiple_option(dst_packet_data_pptr, &src_coap_msg_ptr->options_list_ptr->location_query_ptr, sn_coap_builder_options_build_add_multiple_option(dst_packet_data_pptr, src_options_list_ptr->location_query_ptr,
&src_coap_msg_ptr->options_list_ptr->location_query_len, COAP_OPTION_LOCATION_QUERY, &previous_option_number); src_options_list_ptr->location_query_len, COAP_OPTION_LOCATION_QUERY, &previous_option_number);
/* * * * Build Block2 option * * * * */ /* * * * Build Block2 option * * * * */
if (src_coap_msg_ptr->options_list_ptr->block2 != COAP_OPTION_BLOCK_NONE) { if (src_coap_msg_ptr->options_list_ptr->block2 != COAP_OPTION_BLOCK_NONE) {
sn_coap_builder_options_build_add_uint_option(dst_packet_data_pptr, src_coap_msg_ptr->options_list_ptr->block2, sn_coap_builder_options_build_add_uint_option(dst_packet_data_pptr, src_options_list_ptr->block2,
COAP_OPTION_BLOCK2, &previous_option_number); COAP_OPTION_BLOCK2, &previous_option_number);
} }
/* * * * Build Block1 option * * * * */ /* * * * Build Block1 option * * * * */
if (src_coap_msg_ptr->options_list_ptr->block1 != COAP_OPTION_BLOCK_NONE) { if (src_coap_msg_ptr->options_list_ptr->block1 != COAP_OPTION_BLOCK_NONE) {
sn_coap_builder_options_build_add_uint_option(dst_packet_data_pptr, src_coap_msg_ptr->options_list_ptr->block1, sn_coap_builder_options_build_add_uint_option(dst_packet_data_pptr, src_options_list_ptr->block1,
COAP_OPTION_BLOCK1, &previous_option_number); COAP_OPTION_BLOCK1, &previous_option_number);
} }
/* * * * Build Size2 option * * * */ /* * * * Build Size2 option * * * */
if (src_coap_msg_ptr->options_list_ptr->use_size2) { if (src_coap_msg_ptr->options_list_ptr->use_size2) {
sn_coap_builder_options_build_add_uint_option(dst_packet_data_pptr, src_coap_msg_ptr->options_list_ptr->size2, sn_coap_builder_options_build_add_uint_option(dst_packet_data_pptr, src_options_list_ptr->size2,
COAP_OPTION_SIZE2, &previous_option_number); COAP_OPTION_SIZE2, &previous_option_number);
} }
/* * * * Build Proxy-Uri option * * * */ /* * * * Build Proxy-Uri option * * * */
sn_coap_builder_options_build_add_one_option(dst_packet_data_pptr, src_coap_msg_ptr->options_list_ptr->proxy_uri_len, sn_coap_builder_options_build_add_one_option(dst_packet_data_pptr, src_options_list_ptr->proxy_uri_len,
src_coap_msg_ptr->options_list_ptr->proxy_uri_ptr, COAP_OPTION_PROXY_URI, &previous_option_number); src_options_list_ptr->proxy_uri_ptr, COAP_OPTION_PROXY_URI, &previous_option_number);
/* * * * Build Size1 option * * * */ /* * * * Build Size1 option * * * */
if (src_coap_msg_ptr->options_list_ptr->use_size1) { if (src_options_list_ptr->use_size1) {
sn_coap_builder_options_build_add_uint_option(dst_packet_data_pptr, src_coap_msg_ptr->options_list_ptr->size1, sn_coap_builder_options_build_add_uint_option(dst_packet_data_pptr, src_options_list_ptr->size1,
COAP_OPTION_SIZE1, &previous_option_number); COAP_OPTION_SIZE1, &previous_option_number);
} }
} }
@ -676,7 +678,7 @@ static int8_t sn_coap_builder_options_build(uint8_t **dst_packet_data_pptr, sn_c
* \return Return value is 0 if option was not added, 1 if added * \return Return value is 0 if option was not added, 1 if added
*/ */
static int16_t sn_coap_builder_options_build_add_one_option(uint8_t **dst_packet_data_pptr, uint16_t option_len, static int16_t sn_coap_builder_options_build_add_one_option(uint8_t **dst_packet_data_pptr, uint16_t option_len,
uint8_t *option_ptr, sn_coap_option_numbers_e option_number, uint16_t *previous_option_number) const uint8_t *option_ptr, sn_coap_option_numbers_e option_number, uint16_t *previous_option_number)
{ {
/* Check if there is option at all */ /* Check if there is option at all */
if (option_ptr != NULL) { if (option_ptr != NULL) {
@ -686,61 +688,67 @@ static int16_t sn_coap_builder_options_build_add_one_option(uint8_t **dst_packet
/* * * Build option header * * */ /* * * Build option header * * */
uint8_t first_byte;
/* First option length without extended part */ /* First option length without extended part */
if (option_len <= 12) { if (option_len <= 12) {
**dst_packet_data_pptr = option_len; first_byte = option_len;
} }
else if (option_len > 12 && option_len < 269) { else if (option_len > 12 && option_len < 269) {
**dst_packet_data_pptr = 0x0D; first_byte = 0x0D;
} }
else if (option_len >= 269) { else /*if (option_len >= 269)*/ {
**dst_packet_data_pptr = 0x0E; first_byte = 0x0E;
} }
uint8_t *dest_packet = *dst_packet_data_pptr;
/* Then option delta with extensions, and move pointer */ /* Then option delta with extensions, and move pointer */
if (option_delta <= 12) { if (option_delta <= 12) {
**dst_packet_data_pptr += (option_delta << 4); dest_packet[0] = first_byte + (option_delta << 4);
*dst_packet_data_pptr += 1; dest_packet += 1;
} }
else if (option_delta > 12 && option_delta < 269) { else if (option_delta > 12 && option_delta < 269) {
**dst_packet_data_pptr += 0xD0; dest_packet[0] = first_byte + 0xD0;
option_delta -= 13; option_delta -= 13;
*(*dst_packet_data_pptr + 1) = (uint8_t)option_delta; dest_packet[1] = (uint8_t)option_delta;
*dst_packet_data_pptr += 2; dest_packet += 2;
} }
//This is currently dead code (but possibly needed in future) //This is currently dead code (but possibly needed in future)
else if (option_delta >= 269) { else /*if (option_delta >= 269)*/ {
**dst_packet_data_pptr += 0xE0; dest_packet[0] = first_byte + 0xE0;
option_delta -= 269; option_delta -= 269;
*(*dst_packet_data_pptr + 2) = (uint8_t)option_delta; dest_packet[1] = (option_delta >> 8);
*(*dst_packet_data_pptr + 1) = (option_delta >> 8); dest_packet[2] = (uint8_t)option_delta;
*dst_packet_data_pptr += 3; dest_packet += 3;
} }
/* Now option length extensions, if needed */ /* Now option length extensions, if needed */
if (option_len > 12 && option_len < 269) { if (option_len > 12 && option_len < 269) {
**dst_packet_data_pptr = (uint8_t)(option_len - 13); dest_packet[0] = (uint8_t)(option_len - 13);
*dst_packet_data_pptr += 1; dest_packet += 1;
} }
else if (option_len >= 269) { else if (option_len >= 269) {
*(*dst_packet_data_pptr + 1) = (uint8_t)(option_len - 269); dest_packet[0] = ((option_len - 269) >> 8);
**dst_packet_data_pptr = ((option_len - 269) >> 8); dest_packet[1] = (uint8_t)(option_len - 269);
*dst_packet_data_pptr += 2; dest_packet += 2;
} }
*previous_option_number = option_number; *previous_option_number = option_number;
/* Write Option value */ /* Write Option value */
memcpy(*dst_packet_data_pptr, option_ptr, option_len); memcpy(dest_packet, option_ptr, option_len);
/* Increase destination Packet data pointer */ /* Increase destination Packet data pointer */
(*dst_packet_data_pptr) += option_len; dest_packet += option_len;
*dst_packet_data_pptr = dest_packet;
return 1; return 1;
} }
@ -775,11 +783,9 @@ static uint8_t sn_coap_builder_options_build_add_uint_option(uint8_t **dst_packe
/* If output pointer isn't NULL, write it out */ /* If output pointer isn't NULL, write it out */
if (dst_packet_data_pptr) { if (dst_packet_data_pptr) {
int16_t ret = sn_coap_builder_options_build_add_one_option(dst_packet_data_pptr, len, payload, option_number, previous_option_number); // No need to check & handle return value, as the function returns failure only if the option pointer is zero
/* Allow for failure returns when writing (why even permit failure returns?) */ // and it is pointing to a local variable here.
if (ret < 0) { sn_coap_builder_options_build_add_one_option(dst_packet_data_pptr, len, payload, option_number, previous_option_number);
return ret;
}
} }
/* Return the total option size */ /* Return the total option size */
@ -793,21 +799,21 @@ static uint8_t sn_coap_builder_options_build_add_uint_option(uint8_t **dst_packe
* *
* \param **dst_packet_data_pptr is destination for built Packet data * \param **dst_packet_data_pptr is destination for built Packet data
* *
* \param uint8_t **src_pptr * \param uint8_t **src_ptr
* *
* \param uint16_t *src_len_ptr * \param uint16_t src_len
* *
* \paramsn_coap_option_numbers_e option option to be added * \paramsn_coap_option_numbers_e option option to be added
* *
* \return Return value is 0 always * \return Return value is 0 always
*/ */
static int16_t sn_coap_builder_options_build_add_multiple_option(uint8_t **dst_packet_data_pptr, uint8_t **src_pptr, uint16_t *src_len_ptr, sn_coap_option_numbers_e option, uint16_t *previous_option_number) static void sn_coap_builder_options_build_add_multiple_option(uint8_t **dst_packet_data_pptr, const uint8_t *src_pptr, uint16_t src_len, sn_coap_option_numbers_e option, uint16_t *previous_option_number)
{ {
/* Check if there is option at all */ /* Check if there is option at all */
if (*src_pptr != NULL) { if (src_pptr != NULL) {
uint8_t *query_ptr = *src_pptr; const uint8_t *query_ptr = src_pptr;
uint8_t query_part_count = 0; uint8_t query_part_count = 0;
uint16_t query_len = *src_len_ptr; uint16_t query_len = src_len;
uint8_t i = 0; uint8_t i = 0;
uint16_t query_part_offset = 0; uint16_t query_part_offset = 0;
@ -823,11 +829,10 @@ static int16_t sn_coap_builder_options_build_add_multiple_option(uint8_t **dst_p
query_part_offset = sn_coap_builder_options_get_option_part_position(query_len, query_ptr, i, option); query_part_offset = sn_coap_builder_options_get_option_part_position(query_len, query_ptr, i, option);
/* Add Uri-query's one part to Options */ /* Add Uri-query's one part to Options */
sn_coap_builder_options_build_add_one_option(dst_packet_data_pptr, one_query_part_len, *src_pptr + query_part_offset, option, previous_option_number); sn_coap_builder_options_build_add_one_option(dst_packet_data_pptr, one_query_part_len, src_pptr + query_part_offset, option, previous_option_number);
} }
} }
/* Success */ /* Success */
return 0;
} }
@ -842,7 +847,7 @@ static int16_t sn_coap_builder_options_build_add_multiple_option(uint8_t **dst_p
* *
* \return Return value is count of needed memory as bytes for Uri-query option * \return Return value is count of needed memory as bytes for Uri-query option
*/ */
static uint16_t sn_coap_builder_options_calc_option_size(uint16_t query_len, uint8_t *query_ptr, sn_coap_option_numbers_e option) static uint16_t sn_coap_builder_options_calc_option_size(uint16_t query_len, const uint8_t *query_ptr, sn_coap_option_numbers_e option)
{ {
uint8_t query_part_count = sn_coap_builder_options_get_option_part_count(query_len, query_ptr, option); uint8_t query_part_count = sn_coap_builder_options_get_option_part_count(query_len, query_ptr, option);
uint8_t i = 0; uint8_t i = 0;
@ -923,7 +928,7 @@ static uint16_t sn_coap_builder_options_calc_option_size(uint16_t query_len, uin
* *
* \return Return value is count of query parts * \return Return value is count of query parts
*/ */
static uint8_t sn_coap_builder_options_get_option_part_count(uint16_t query_len, uint8_t *query_ptr, sn_coap_option_numbers_e option) static uint8_t sn_coap_builder_options_get_option_part_count(uint16_t query_len, const uint8_t *query_ptr, sn_coap_option_numbers_e option)
{ {
uint8_t returned_query_count = 0; uint8_t returned_query_count = 0;
uint16_t query_len_index = 0; uint16_t query_len_index = 0;
@ -963,7 +968,7 @@ static uint8_t sn_coap_builder_options_get_option_part_count(uint16_t query_len,
* *
* \return Return value is length of query part * \return Return value is length of query part
*/ */
static uint16_t sn_coap_builder_options_get_option_part_length_from_whole_option_string(uint16_t query_len, uint8_t *query_ptr, static uint16_t sn_coap_builder_options_get_option_part_length_from_whole_option_string(uint16_t query_len, const uint8_t *query_ptr,
uint8_t query_index, sn_coap_option_numbers_e option) uint8_t query_index, sn_coap_option_numbers_e option)
{ {
uint16_t returned_query_part_len = 0; uint16_t returned_query_part_len = 0;
@ -1021,7 +1026,7 @@ static uint16_t sn_coap_builder_options_get_option_part_length_from_whole_option
* \return Return value is position (= offset) of query part in whole query. In * \return Return value is position (= offset) of query part in whole query. In
* fail cases -1 is returned. * fail cases -1 is returned.
*/ */
static int16_t sn_coap_builder_options_get_option_part_position(uint16_t query_len, uint8_t *query_ptr, static int16_t sn_coap_builder_options_get_option_part_position(uint16_t query_len, const uint8_t *query_ptr,
uint8_t query_index, sn_coap_option_numbers_e option) uint8_t query_index, sn_coap_option_numbers_e option)
{ {
uint16_t returned_query_part_offset = 0; uint16_t returned_query_part_offset = 0;
@ -1076,7 +1081,7 @@ static int16_t sn_coap_builder_options_get_option_part_position(uint16_t query_l
* *
* \param *src_coap_msg_ptr is source for building Packet data * \param *src_coap_msg_ptr is source for building Packet data
*/ */
static void sn_coap_builder_payload_build(uint8_t **dst_packet_data_pptr, sn_coap_hdr_s *src_coap_msg_ptr) static void sn_coap_builder_payload_build(uint8_t **dst_packet_data_pptr, const sn_coap_hdr_s *src_coap_msg_ptr)
{ {
/* Check if Payload is used at all */ /* Check if Payload is used at all */
if (src_coap_msg_ptr->payload_len && src_coap_msg_ptr->payload_ptr != NULL) { if (src_coap_msg_ptr->payload_len && src_coap_msg_ptr->payload_ptr != NULL) {

2
features/frameworks/mbed-coap/source/sn_coap_header_check.c
View File

@ -44,7 +44,7 @@
* \return Return value is status of validity check. In ok cases 0 and in * \return Return value is status of validity check. In ok cases 0 and in
* failure cases -1 * failure cases -1
*/ */
int8_t sn_coap_header_validity_check(sn_coap_hdr_s *src_coap_msg_ptr, coap_version_e coap_version) int8_t sn_coap_header_validity_check(const sn_coap_hdr_s *src_coap_msg_ptr, coap_version_e coap_version)
{ {
/* * Check validity of CoAP Version * */ /* * Check validity of CoAP Version * */
if (coap_version != COAP_VERSION_1) { if (coap_version != COAP_VERSION_1) {

125
features/frameworks/mbed-coap/source/sn_coap_parser.c
View File

@ -45,7 +45,7 @@
static void sn_coap_parser_header_parse(uint8_t **packet_data_pptr, sn_coap_hdr_s *dst_coap_msg_ptr, coap_version_e *coap_version_ptr); static void sn_coap_parser_header_parse(uint8_t **packet_data_pptr, sn_coap_hdr_s *dst_coap_msg_ptr, coap_version_e *coap_version_ptr);
static int8_t sn_coap_parser_options_parse(struct coap_s *handle, uint8_t **packet_data_pptr, sn_coap_hdr_s *dst_coap_msg_ptr, uint8_t *packet_data_start_ptr, uint16_t packet_len); static int8_t sn_coap_parser_options_parse(struct coap_s *handle, uint8_t **packet_data_pptr, sn_coap_hdr_s *dst_coap_msg_ptr, uint8_t *packet_data_start_ptr, uint16_t packet_len);
static int8_t sn_coap_parser_options_parse_multiple_options(struct coap_s *handle, uint8_t **packet_data_pptr, uint16_t packet_left_len, uint8_t **dst_pptr, uint16_t *dst_len_ptr, sn_coap_option_numbers_e option, uint16_t option_number_len); static int8_t sn_coap_parser_options_parse_multiple_options(struct coap_s *handle, uint8_t **packet_data_pptr, uint16_t packet_left_len, uint8_t **dst_pptr, uint16_t *dst_len_ptr, sn_coap_option_numbers_e option, uint16_t option_number_len);
static int16_t sn_coap_parser_options_count_needed_memory_multiple_option(uint8_t *packet_data_ptr, uint16_t packet_left_len, sn_coap_option_numbers_e option, uint16_t option_number_len); static int16_t sn_coap_parser_options_count_needed_memory_multiple_option(const uint8_t *packet_data_ptr, uint16_t packet_left_len, sn_coap_option_numbers_e option, uint16_t option_number_len);
static int8_t sn_coap_parser_payload_parse(uint16_t packet_data_len, uint8_t *packet_data_start_ptr, uint8_t **packet_data_pptr, sn_coap_hdr_s *dst_coap_msg_ptr); static int8_t sn_coap_parser_payload_parse(uint16_t packet_data_len, uint8_t *packet_data_start_ptr, uint8_t **packet_data_pptr, sn_coap_hdr_s *dst_coap_msg_ptr);
sn_coap_hdr_s *sn_coap_parser_init_message(sn_coap_hdr_s *coap_msg_ptr) sn_coap_hdr_s *sn_coap_parser_init_message(sn_coap_hdr_s *coap_msg_ptr)
@ -64,6 +64,29 @@ sn_coap_hdr_s *sn_coap_parser_init_message(sn_coap_hdr_s *coap_msg_ptr)
return coap_msg_ptr; return coap_msg_ptr;
} }
sn_coap_hdr_s *sn_coap_parser_alloc_message_with_options(struct coap_s *handle)
{
// check the handle just as in any other place
if (handle == NULL) {
return NULL;
}
sn_coap_hdr_s *coap_msg_ptr = sn_coap_parser_alloc_message(handle);
sn_coap_options_list_s *options_list_ptr = sn_coap_parser_alloc_options(handle, coap_msg_ptr);
if ((coap_msg_ptr == NULL) || (options_list_ptr == NULL)) {
// oops, out of memory free if got already any
handle->sn_coap_protocol_free(coap_msg_ptr);
handle->sn_coap_protocol_free(options_list_ptr);
coap_msg_ptr = NULL;
}
return coap_msg_ptr;
}
sn_coap_hdr_s *sn_coap_parser_alloc_message(struct coap_s *handle) sn_coap_hdr_s *sn_coap_parser_alloc_message(struct coap_s *handle)
{ {
sn_coap_hdr_s *returned_coap_msg_ptr; sn_coap_hdr_s *returned_coap_msg_ptr;
@ -81,6 +104,8 @@ sn_coap_hdr_s *sn_coap_parser_alloc_message(struct coap_s *handle)
sn_coap_options_list_s *sn_coap_parser_alloc_options(struct coap_s *handle, sn_coap_hdr_s *coap_msg_ptr) sn_coap_options_list_s *sn_coap_parser_alloc_options(struct coap_s *handle, sn_coap_hdr_s *coap_msg_ptr)
{ {
sn_coap_options_list_s *options_list_ptr;
/* * * * Check given pointers * * * */ /* * * * Check given pointers * * * */
if (handle == NULL || coap_msg_ptr == NULL) { if (handle == NULL || coap_msg_ptr == NULL) {
return NULL; return NULL;
@ -92,24 +117,23 @@ sn_coap_options_list_s *sn_coap_parser_alloc_options(struct coap_s *handle, sn_c
} }
/* * * * Allocate memory for options and initialize allocated memory with with default values * * * */ /* * * * Allocate memory for options and initialize allocated memory with with default values * * * */
coap_msg_ptr->options_list_ptr = handle->sn_coap_protocol_malloc(sizeof(sn_coap_options_list_s)); /* XXX not technically legal to memset pointers to 0 */
options_list_ptr = sn_coap_protocol_calloc(handle, sizeof(sn_coap_options_list_s));
if (coap_msg_ptr->options_list_ptr == NULL) { if (options_list_ptr == NULL) {
tr_error("sn_coap_parser_alloc_options - failed to allocate options list!"); tr_error("sn_coap_parser_alloc_options - failed to allocate options list!");
return NULL; return NULL;
} }
/* XXX not technically legal to memset pointers to 0 */ coap_msg_ptr->options_list_ptr = options_list_ptr;
memset(coap_msg_ptr->options_list_ptr, 0x00, sizeof(sn_coap_options_list_s));
coap_msg_ptr->options_list_ptr->max_age = 0; options_list_ptr->uri_port = COAP_OPTION_URI_PORT_NONE;
coap_msg_ptr->options_list_ptr->uri_port = COAP_OPTION_URI_PORT_NONE; options_list_ptr->observe = COAP_OBSERVE_NONE;
coap_msg_ptr->options_list_ptr->observe = COAP_OBSERVE_NONE; options_list_ptr->accept = COAP_CT_NONE;
coap_msg_ptr->options_list_ptr->accept = COAP_CT_NONE; options_list_ptr->block2 = COAP_OPTION_BLOCK_NONE;
coap_msg_ptr->options_list_ptr->block2 = COAP_OPTION_BLOCK_NONE; options_list_ptr->block1 = COAP_OPTION_BLOCK_NONE;
coap_msg_ptr->options_list_ptr->block1 = COAP_OPTION_BLOCK_NONE;
return coap_msg_ptr->options_list_ptr; return options_list_ptr;
} }
sn_coap_hdr_s *sn_coap_parser(struct coap_s *handle, uint16_t packet_data_len, uint8_t *packet_data_ptr, coap_version_e *coap_version_ptr) sn_coap_hdr_s *sn_coap_parser(struct coap_s *handle, uint16_t packet_data_len, uint8_t *packet_data_ptr, coap_version_e *coap_version_ptr)
@ -156,43 +180,35 @@ void sn_coap_parser_release_allocated_coap_msg_mem(struct coap_s *handle, sn_coa
} }
if (freed_coap_msg_ptr != NULL) { if (freed_coap_msg_ptr != NULL) {
if (freed_coap_msg_ptr->uri_path_ptr != NULL) {
handle->sn_coap_protocol_free(freed_coap_msg_ptr->uri_path_ptr); // As there are multiple sequential calls to the protocol_free, caching pointer to it
// saves one instruction per call.
void (*local_free)(void *) = handle->sn_coap_protocol_free;
local_free(freed_coap_msg_ptr->uri_path_ptr);
local_free(freed_coap_msg_ptr->token_ptr);
// same here, caching the struct start saves a bit.
sn_coap_options_list_s *options_list_ptr = freed_coap_msg_ptr->options_list_ptr;
if (options_list_ptr != NULL) {
local_free(options_list_ptr->proxy_uri_ptr);
local_free(options_list_ptr->etag_ptr);
local_free(options_list_ptr->uri_host_ptr);
local_free(options_list_ptr->location_path_ptr);
local_free(options_list_ptr->location_query_ptr);
local_free(options_list_ptr->uri_query_ptr);
local_free(options_list_ptr);
} }
if (freed_coap_msg_ptr->token_ptr != NULL) { local_free(freed_coap_msg_ptr);
handle->sn_coap_protocol_free(freed_coap_msg_ptr->token_ptr);
}
if (freed_coap_msg_ptr->options_list_ptr != NULL) {
if (freed_coap_msg_ptr->options_list_ptr->proxy_uri_ptr != NULL) {
handle->sn_coap_protocol_free(freed_coap_msg_ptr->options_list_ptr->proxy_uri_ptr);
}
if (freed_coap_msg_ptr->options_list_ptr->etag_ptr != NULL) {
handle->sn_coap_protocol_free(freed_coap_msg_ptr->options_list_ptr->etag_ptr);
}
if (freed_coap_msg_ptr->options_list_ptr->uri_host_ptr != NULL) {
handle->sn_coap_protocol_free(freed_coap_msg_ptr->options_list_ptr->uri_host_ptr);
}
if (freed_coap_msg_ptr->options_list_ptr->location_path_ptr != NULL) {
handle->sn_coap_protocol_free(freed_coap_msg_ptr->options_list_ptr->location_path_ptr);
}
if (freed_coap_msg_ptr->options_list_ptr->location_query_ptr != NULL) {
handle->sn_coap_protocol_free(freed_coap_msg_ptr->options_list_ptr->location_query_ptr);
}
if (freed_coap_msg_ptr->options_list_ptr->uri_query_ptr != NULL) {
handle->sn_coap_protocol_free(freed_coap_msg_ptr->options_list_ptr->uri_query_ptr);
}
handle->sn_coap_protocol_free(freed_coap_msg_ptr->options_list_ptr);
}
handle->sn_coap_protocol_free(freed_coap_msg_ptr);
} }
} }
@ -269,14 +285,13 @@ static int8_t sn_coap_parser_options_parse(struct coap_s *handle, uint8_t **pack
return -1; return -1;
} }
dst_coap_msg_ptr->token_ptr = handle->sn_coap_protocol_malloc(dst_coap_msg_ptr->token_len); dst_coap_msg_ptr->token_ptr = sn_coap_protocol_malloc_copy(handle, *packet_data_pptr, dst_coap_msg_ptr->token_len);
if (dst_coap_msg_ptr->token_ptr == NULL) { if (dst_coap_msg_ptr->token_ptr == NULL) {
tr_error("sn_coap_parser_options_parse - failed to allocate token!"); tr_error("sn_coap_parser_options_parse - failed to allocate token!");
return -1; return -1;
} }
memcpy(dst_coap_msg_ptr->token_ptr, *packet_data_pptr, dst_coap_msg_ptr->token_len);
(*packet_data_pptr) += dst_coap_msg_ptr->token_len; (*packet_data_pptr) += dst_coap_msg_ptr->token_len;
} }
@ -379,14 +394,13 @@ static int8_t sn_coap_parser_options_parse(struct coap_s *handle, uint8_t **pack
dst_coap_msg_ptr->options_list_ptr->proxy_uri_len = option_len; dst_coap_msg_ptr->options_list_ptr->proxy_uri_len = option_len;
(*packet_data_pptr)++; (*packet_data_pptr)++;
dst_coap_msg_ptr->options_list_ptr->proxy_uri_ptr = handle->sn_coap_protocol_malloc(option_len); dst_coap_msg_ptr->options_list_ptr->proxy_uri_ptr = sn_coap_protocol_malloc_copy(handle, *packet_data_pptr, option_len);
if (dst_coap_msg_ptr->options_list_ptr->proxy_uri_ptr == NULL) { if (dst_coap_msg_ptr->options_list_ptr->proxy_uri_ptr == NULL) {
tr_error("sn_coap_parser_options_parse - COAP_OPTION_PROXY_URI allocation failed!"); tr_error("sn_coap_parser_options_parse - COAP_OPTION_PROXY_URI allocation failed!");
return -1; return -1;
} }
memcpy(dst_coap_msg_ptr->options_list_ptr->proxy_uri_ptr, *packet_data_pptr, option_len);
(*packet_data_pptr) += option_len; (*packet_data_pptr) += option_len;
break; break;
@ -415,13 +429,12 @@ static int8_t sn_coap_parser_options_parse(struct coap_s *handle, uint8_t **pack
dst_coap_msg_ptr->options_list_ptr->uri_host_len = option_len; dst_coap_msg_ptr->options_list_ptr->uri_host_len = option_len;
(*packet_data_pptr)++; (*packet_data_pptr)++;
dst_coap_msg_ptr->options_list_ptr->uri_host_ptr = handle->sn_coap_protocol_malloc(option_len); dst_coap_msg_ptr->options_list_ptr->uri_host_ptr = sn_coap_protocol_malloc_copy(handle, *packet_data_pptr, option_len);
if (dst_coap_msg_ptr->options_list_ptr->uri_host_ptr == NULL) { if (dst_coap_msg_ptr->options_list_ptr->uri_host_ptr == NULL) {
tr_error("sn_coap_parser_options_parse - COAP_OPTION_URI_HOST allocation failed!"); tr_error("sn_coap_parser_options_parse - COAP_OPTION_URI_HOST allocation failed!");
return -1; return -1;
} }
memcpy(dst_coap_msg_ptr->options_list_ptr->uri_host_ptr, *packet_data_pptr, option_len);
(*packet_data_pptr) += option_len; (*packet_data_pptr) += option_len;
break; break;
@ -623,9 +636,9 @@ static int8_t sn_coap_parser_options_parse_multiple_options(struct coap_s *handl
/* Uri-Query is modified to following format: temp1'\0'temp2'\0'temp3 i.e. */ /* Uri-Query is modified to following format: temp1'\0'temp2'\0'temp3 i.e. */
/* Uri-Path is modified to following format: temp1\temp2\temp3 i.e. */ /* Uri-Path is modified to following format: temp1\temp2\temp3 i.e. */
if (option == COAP_OPTION_URI_QUERY || option == COAP_OPTION_LOCATION_QUERY || option == COAP_OPTION_ETAG || option == COAP_OPTION_ACCEPT) { if (option == COAP_OPTION_URI_QUERY || option == COAP_OPTION_LOCATION_QUERY || option == COAP_OPTION_ETAG || option == COAP_OPTION_ACCEPT) {
memset(temp_parsed_uri_query_ptr, '&', 1); *temp_parsed_uri_query_ptr = '&';
} else if (option == COAP_OPTION_URI_PATH || option == COAP_OPTION_LOCATION_PATH) { } else if (option == COAP_OPTION_URI_PATH || option == COAP_OPTION_LOCATION_PATH) {
memset(temp_parsed_uri_query_ptr, '/', 1); *temp_parsed_uri_query_ptr = '/';
} }
temp_parsed_uri_query_ptr++; temp_parsed_uri_query_ptr++;
@ -680,7 +693,7 @@ static int8_t sn_coap_parser_options_parse_multiple_options(struct coap_s *handl
* *
* \param uint16_t option_number_len length of the first option part * \param uint16_t option_number_len length of the first option part
*/ */
static int16_t sn_coap_parser_options_count_needed_memory_multiple_option(uint8_t *packet_data_ptr, uint16_t packet_left_len, sn_coap_option_numbers_e option, uint16_t option_number_len) static int16_t sn_coap_parser_options_count_needed_memory_multiple_option(const uint8_t *packet_data_ptr, uint16_t packet_left_len, sn_coap_option_numbers_e option, uint16_t option_number_len)
{ {
uint16_t ret_value = 0; uint16_t ret_value = 0;
uint16_t i = 1; uint16_t i = 1;

1023
features/frameworks/mbed-coap/source/sn_coap_protocol.c
View File

File diff suppressed because it is too large Load Diff