Merge pull request #5001 from anttiylitokola/master

0xc0170 · web-flow · commit 0fec52de94ad · 2017-09-04T16:47:10.000+01:00
Update mbed-coap to version 4.0.10
diff --git a/features/FEATURE_COMMON_PAL/mbed-coap/CHANGELOG.md b/features/FEATURE_COMMON_PAL/mbed-coap/CHANGELOG.md
@@ -1,5 +1,12 @@
 # Change Log
 
+## [v4.0.10](https://github.com/ARMmbed/mbed-coap/releases/tag/v4.0.10) 
+
+-[Full Changelog](https://github.com/ARMmbed/mbed-coap/compare/v4.0.9...v4.0.10)
+
+ **Closed issues:**
+  -  IOTMAC-615 Node mDS registration failure during OTA transfer
+
 ## [v4.0.9](https://github.com/ARMmbed/mbed-coap/releases/tag/v4.0.9) 
 
 -[Full Changelog](https://github.com/ARMmbed/mbed-coap/compare/v4.0.8...v4.0.9)
diff --git a/features/FEATURE_COMMON_PAL/mbed-coap/module.json b/features/FEATURE_COMMON_PAL/mbed-coap/module.json
@@ -1,6 +1,6 @@
 {
   "name": "mbed-coap",
-  "version": "4.0.9",
+  "version": "4.0.10",
   "description": "COAP library",
   "keywords": [
     "coap",
diff --git a/features/FEATURE_COMMON_PAL/mbed-coap/source/sn_coap_builder.c b/features/FEATURE_COMMON_PAL/mbed-coap/source/sn_coap_builder.c
@@ -59,6 +59,7 @@ sn_coap_hdr_s *sn_coap_build_response(struct coap_s *handle, sn_coap_hdr_s *coap
 
     coap_res_ptr = sn_coap_parser_alloc_message(handle);
     if (!coap_res_ptr) {
+        tr_error("sn_coap_build_response - failed to allocate message!");
         return NULL;
     }
 
@@ -83,6 +84,7 @@ sn_coap_hdr_s *sn_coap_build_response(struct coap_s *handle, sn_coap_hdr_s *coap
         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);
         if (!coap_res_ptr->token_ptr) {
+            tr_error("sn_coap_build_response - failed to allocate token!");
             handle->sn_coap_protocol_free(coap_res_ptr);
             return NULL;
         }
@@ -98,7 +100,6 @@ int16_t sn_coap_builder(uint8_t *dst_packet_data_ptr, sn_coap_hdr_s *src_coap_ms
 
 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)
 {
-    tr_debug("sn_coap_builder_2");
     uint8_t *base_packet_data_ptr = NULL;
 
     /* * * * Check given pointers  * * * */
@@ -108,8 +109,8 @@ int16_t sn_coap_builder_2(uint8_t *dst_packet_data_ptr, sn_coap_hdr_s *src_coap_
 
     /* Initialize given Packet data memory area with zero values */
     uint16_t dst_byte_count_to_be_built = sn_coap_builder_calc_needed_packet_data_size_2(src_coap_msg_ptr, blockwise_payload_size);
-    tr_debug("sn_coap_builder_2 - message len: [%d]", dst_byte_count_to_be_built);
     if (!dst_byte_count_to_be_built) {
+        tr_error("sn_coap_builder_2 - failed to allocate message!");
         return -1;
     }
 
@@ -123,6 +124,7 @@ int16_t sn_coap_builder_2(uint8_t *dst_packet_data_ptr, sn_coap_hdr_s *src_coap_
     /* * * * * * * * * * * * * * * * * * */
     if (sn_coap_builder_header_build(&dst_packet_data_ptr, src_coap_msg_ptr) != 0) {
         /* Header building failed */
+        tr_error("sn_coap_builder_2 - header building failed!");
         return -1;
     }
 
@@ -149,7 +151,6 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size(sn_coap_hdr_s *src_coap_ms
 uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_msg_ptr, uint16_t blockwise_payload_size)
 {
     (void)blockwise_payload_size;
-    tr_debug("sn_coap_builder_calc_needed_packet_data_size_2");
     uint16_t returned_byte_count = 0;
 
     if (!src_coap_msg_ptr) {
@@ -168,6 +169,7 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
         /* TOKEN - Length is 1-8 bytes */
         if (src_coap_msg_ptr->token_ptr != NULL) {
             if (src_coap_msg_ptr->token_len > 8 || src_coap_msg_ptr->token_len < 1) { /* Check that option is not longer than defined */
+                tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - token too large!");
                 return 0;
             }
 
@@ -180,6 +182,7 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
             if (repeatable_option_size) {
                 returned_byte_count += repeatable_option_size;
             } else {
+                tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - uri path size failed!");
                 return 0;
             }
         }
@@ -188,6 +191,7 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
         /* CONTENT FORMAT - An integer option, up to 2 bytes */
         if (src_coap_msg_ptr->content_format != COAP_CT_NONE) {
             if ((uint32_t) src_coap_msg_ptr->content_format > 0xffff) {
+                tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - content format too large!");
                 return 0;
             }
 
@@ -198,6 +202,7 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
             /* ACCEPT - An integer option, up to 2 bytes */
             if (src_coap_msg_ptr->options_list_ptr->accept != COAP_CT_NONE) {
                 if ((uint32_t) src_coap_msg_ptr->options_list_ptr->accept > 0xffff) {
+                    tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - accept too large!");
                     return 0;
                 }
 
@@ -222,6 +227,7 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
                 }
 
                 else {
+                    tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - proxy uri too large!");
                     return 0;
                 }
 
@@ -235,6 +241,7 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
                 if (repeatable_option_size) {
                     returned_byte_count += repeatable_option_size;
                 } else {
+                    tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - etag too large!");
                     return 0;
                 }
             }
@@ -249,6 +256,7 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
                 }
 
                 else {
+                    tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - uri host too large!");
                     return 0;
                 }
 
@@ -261,12 +269,14 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
                 if (repeatable_option_size) {
                     returned_byte_count += repeatable_option_size;
                 } else {
+                    tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - location path too large!");
                     return 0;
                 }
             }
             /* 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 ((uint32_t) src_coap_msg_ptr->options_list_ptr->uri_port > 0xffff) {
+                    tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - uri port too large!");
                     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);
@@ -278,6 +288,7 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
                 if (repeatable_option_size) {
                     returned_byte_count += repeatable_option_size;
                 } else {
+                    tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - location query too large!");
                     return 0;
                 }
             }
@@ -295,13 +306,15 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
                 if (repeatable_option_size) {
                     returned_byte_count += repeatable_option_size;
                 } else {
+                    tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - observe too large!");
                     return 0;
                 }
             }
 
             /* BLOCK 1 - An integer option, up to 3 bytes */
             if (src_coap_msg_ptr->options_list_ptr->block1 != COAP_OPTION_BLOCK_NONE) {
                 if ((uint32_t) src_coap_msg_ptr->options_list_ptr->block1 > 0xffffff) {
+                    tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - block1 too large!");
                     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);
@@ -313,6 +326,7 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_
             /* BLOCK 2 - An integer option, up to 3 bytes */
             if (src_coap_msg_ptr->options_list_ptr->block2 != COAP_OPTION_BLOCK_NONE) {
                 if ((uint32_t) src_coap_msg_ptr->options_list_ptr->block2 > 0xffffff) {
+                    tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - block2 too large!");
                     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);
@@ -483,6 +497,7 @@ static int8_t sn_coap_builder_header_build(uint8_t **dst_packet_data_pptr, sn_co
 {
     /* * * * Check validity of Header values * * * */
     if (sn_coap_header_validity_check(src_coap_msg_ptr, COAP_VERSION) != 0) {
+        tr_error("sn_coap_builder_header_build - header build failed!");
         return -1;
     }
 
@@ -526,6 +541,7 @@ static int8_t sn_coap_builder_options_build(uint8_t **dst_packet_data_pptr, sn_c
     /* * * * Check if Options are used at all  * * * */
     if (src_coap_msg_ptr->uri_path_ptr == NULL && src_coap_msg_ptr->token_ptr == NULL &&
             src_coap_msg_ptr->content_format == COAP_CT_NONE && src_coap_msg_ptr->options_list_ptr == NULL) {
+        tr_error("sn_coap_builder_options_build - options not used!");
         return 0;
     }
 
diff --git a/features/FEATURE_COMMON_PAL/mbed-coap/source/sn_coap_header_check.c b/features/FEATURE_COMMON_PAL/mbed-coap/source/sn_coap_header_check.c
@@ -29,6 +29,9 @@
 #include "mbed-coap/sn_coap_protocol.h"
 #include "sn_coap_header_internal.h"
 #include "sn_coap_protocol_internal.h"
+#include "mbed-trace/mbed_trace.h"
+
+#define TRACE_GROUP "coap"
 
 /**
  * \fn int8_t sn_coap_header_validity_check(sn_coap_hdr_s *src_coap_msg_ptr, coap_version_e coap_version)
@@ -56,6 +59,7 @@ int8_t sn_coap_header_validity_check(sn_coap_hdr_s *src_coap_msg_ptr, coap_versi
         case COAP_MSG_TYPE_RESET:
             break;      /* Ok cases */
         default:
+            tr_error("sn_coap_header_validity_check - unknown message type!");
             return -1;      /* Failed case */
     }
 
@@ -91,6 +95,7 @@ int8_t sn_coap_header_validity_check(sn_coap_hdr_s *src_coap_msg_ptr, coap_versi
         case COAP_MSG_CODE_RESPONSE_CONTINUE:
             break;      /* Ok cases */
         default:
+            tr_error("sn_coap_header_validity_check - unknown message code!");
             return -1;      /* Failed case */
     }
 
diff --git a/features/FEATURE_COMMON_PAL/mbed-coap/source/sn_coap_parser.c b/features/FEATURE_COMMON_PAL/mbed-coap/source/sn_coap_parser.c
diff --git a/features/FEATURE_COMMON_PAL/mbed-coap/source/sn_coap_protocol.c b/features/FEATURE_COMMON_PAL/mbed-coap/source/sn_coap_protocol.c

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "mbed-coap",`
`3`		`- "version": "4.0.9",`
	`3`	`+ "version": "4.0.10",`
`4`	`4`	`"description": "COAP library",`
`5`	`5`	`"keywords": [`
`6`	`6`	`"coap",`
Original file line number	Diff line number	Diff line change
`@@ -59,6 +59,7 @@ sn_coap_hdr_s sn_coap_build_response(struct coap_s handle, sn_coap_hdr_s *coap`
`59`	`59`
`60`	`60`	`coap_res_ptr = sn_coap_parser_alloc_message(handle);`
`61`	`61`	`if (!coap_res_ptr) {`
	`62`	`+ tr_error("sn_coap_build_response - failed to allocate message!");`
`62`	`63`	`return NULL;`
`63`	`64`	`}`
`64`	`65`
`@@ -83,6 +84,7 @@ sn_coap_hdr_s sn_coap_build_response(struct coap_s handle, sn_coap_hdr_s *coap`
`83`	`84`	`coap_res_ptr->token_len = coap_packet_ptr->token_len;`
`84`	`85`	`coap_res_ptr->token_ptr = handle->sn_coap_protocol_malloc(coap_res_ptr->token_len);`
`85`	`86`	`if (!coap_res_ptr->token_ptr) {`
	`87`	`+ tr_error("sn_coap_build_response - failed to allocate token!");`
`86`	`88`	`handle->sn_coap_protocol_free(coap_res_ptr);`
`87`	`89`	`return NULL;`
`88`	`90`	`}`
`@@ -98,7 +100,6 @@ int16_t sn_coap_builder(uint8_t dst_packet_data_ptr, sn_coap_hdr_s src_coap_ms`
`98`	`100`
`99`	`101`	`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)`
`100`	`102`	`{`
`101`		`- tr_debug("sn_coap_builder_2");`
`102`	`103`	`uint8_t *base_packet_data_ptr = NULL;`
`103`	`104`
`104`	`105`	`/* * * * Check given pointers * * * */`
`@@ -108,8 +109,8 @@ int16_t sn_coap_builder_2(uint8_t dst_packet_data_ptr, sn_coap_hdr_s src_coap_`
`108`	`109`
`109`	`110`	`/* Initialize given Packet data memory area with zero values */`
`110`	`111`	`uint16_t dst_byte_count_to_be_built = sn_coap_builder_calc_needed_packet_data_size_2(src_coap_msg_ptr, blockwise_payload_size);`
`111`		`- tr_debug("sn_coap_builder_2 - message len: [%d]", dst_byte_count_to_be_built);`
`112`	`112`	`if (!dst_byte_count_to_be_built) {`
	`113`	`+ tr_error("sn_coap_builder_2 - failed to allocate message!");`
`113`	`114`	`return -1;`
`114`	`115`	`}`
`115`	`116`
`@@ -123,6 +124,7 @@ int16_t sn_coap_builder_2(uint8_t dst_packet_data_ptr, sn_coap_hdr_s src_coap_`
`123`	`124`	`/* * * * * * * * * * * * * * * * * * */`
`124`	`125`	`if (sn_coap_builder_header_build(&dst_packet_data_ptr, src_coap_msg_ptr) != 0) {`
`125`	`126`	`/* Header building failed */`
	`127`	`+ tr_error("sn_coap_builder_2 - header building failed!");`
`126`	`128`	`return -1;`
`127`	`129`	`}`
`128`	`130`
`@@ -149,7 +151,6 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size(sn_coap_hdr_s *src_coap_ms`
`149`	`151`	`uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_msg_ptr, uint16_t blockwise_payload_size)`
`150`	`152`	`{`
`151`	`153`	`(void)blockwise_payload_size;`
`152`		`- tr_debug("sn_coap_builder_calc_needed_packet_data_size_2");`
`153`	`154`	`uint16_t returned_byte_count = 0;`
`154`	`155`
`155`	`156`	`if (!src_coap_msg_ptr) {`
`@@ -168,6 +169,7 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_`
`168`	`169`	`/* TOKEN - Length is 1-8 bytes */`
`169`	`170`	`if (src_coap_msg_ptr->token_ptr != NULL) {`
`170`	`171`	`if (src_coap_msg_ptr->token_len > 8 \|\| src_coap_msg_ptr->token_len < 1) { /* Check that option is not longer than defined */`
	`172`	`+ tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - token too large!");`
`171`	`173`	`return 0;`
`172`	`174`	`}`
`173`	`175`
`@@ -180,6 +182,7 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_`
`180`	`182`	`if (repeatable_option_size) {`
`181`	`183`	`returned_byte_count += repeatable_option_size;`
`182`	`184`	`} else {`
	`185`	`+ tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - uri path size failed!");`
`183`	`186`	`return 0;`
`184`	`187`	`}`
`185`	`188`	`}`
`@@ -188,6 +191,7 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_`
`188`	`191`	`/* CONTENT FORMAT - An integer option, up to 2 bytes */`
`189`	`192`	`if (src_coap_msg_ptr->content_format != COAP_CT_NONE) {`
`190`	`193`	`if ((uint32_t) src_coap_msg_ptr->content_format > 0xffff) {`
	`194`	`+ tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - content format too large!");`
`191`	`195`	`return 0;`
`192`	`196`	`}`
`193`	`197`
`@@ -198,6 +202,7 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_`
`198`	`202`	`/* ACCEPT - An integer option, up to 2 bytes */`
`199`	`203`	`if (src_coap_msg_ptr->options_list_ptr->accept != COAP_CT_NONE) {`
`200`	`204`	`if ((uint32_t) src_coap_msg_ptr->options_list_ptr->accept > 0xffff) {`
	`205`	`+ tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - accept too large!");`
`201`	`206`	`return 0;`
`202`	`207`	`}`
`203`	`208`
`@@ -222,6 +227,7 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_`
`222`	`227`	`}`
`223`	`228`
`224`	`229`	`else {`
	`230`	`+ tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - proxy uri too large!");`
`225`	`231`	`return 0;`
`226`	`232`	`}`
`227`	`233`
`@@ -235,6 +241,7 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_`
`235`	`241`	`if (repeatable_option_size) {`
`236`	`242`	`returned_byte_count += repeatable_option_size;`
`237`	`243`	`} else {`
	`244`	`+ tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - etag too large!");`
`238`	`245`	`return 0;`
`239`	`246`	`}`
`240`	`247`	`}`
`@@ -249,6 +256,7 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_`
`249`	`256`	`}`
`250`	`257`
`251`	`258`	`else {`
	`259`	`+ tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - uri host too large!");`
`252`	`260`	`return 0;`
`253`	`261`	`}`
`254`	`262`
`@@ -261,12 +269,14 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_`
`261`	`269`	`if (repeatable_option_size) {`
`262`	`270`	`returned_byte_count += repeatable_option_size;`
`263`	`271`	`} else {`
	`272`	`+ tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - location path too large!");`
`264`	`273`	`return 0;`
`265`	`274`	`}`
`266`	`275`	`}`
`267`	`276`	`/* URI PORT - An integer option, up to 2 bytes */`
`268`	`277`	`if (src_coap_msg_ptr->options_list_ptr->uri_port != COAP_OPTION_URI_PORT_NONE) {`
`269`	`278`	`if ((uint32_t) src_coap_msg_ptr->options_list_ptr->uri_port > 0xffff) {`
	`279`	`+ tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - uri port too large!");`
`270`	`280`	`return 0;`
`271`	`281`	`}`
`272`	`282`	`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);`
`@@ -278,6 +288,7 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_`
`278`	`288`	`if (repeatable_option_size) {`
`279`	`289`	`returned_byte_count += repeatable_option_size;`
`280`	`290`	`} else {`
	`291`	`+ tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - location query too large!");`
`281`	`292`	`return 0;`
`282`	`293`	`}`
`283`	`294`	`}`
`@@ -295,13 +306,15 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_`
`295`	`306`	`if (repeatable_option_size) {`
`296`	`307`	`returned_byte_count += repeatable_option_size;`
`297`	`308`	`} else {`
	`309`	`+ tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - observe too large!");`
`298`	`310`	`return 0;`
`299`	`311`	`}`
`300`	`312`	`}`
`301`	`313`
`302`	`314`	`/* BLOCK 1 - An integer option, up to 3 bytes */`
`303`	`315`	`if (src_coap_msg_ptr->options_list_ptr->block1 != COAP_OPTION_BLOCK_NONE) {`
`304`	`316`	`if ((uint32_t) src_coap_msg_ptr->options_list_ptr->block1 > 0xffffff) {`
	`317`	`+ tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - block1 too large!");`
`305`	`318`	`return 0;`
`306`	`319`	`}`
`307`	`320`	`returned_byte_count += sn_coap_builder_options_build_add_uint_option(NULL, src_coap_msg_ptr->options_list_ptr->block1, COAP_OPTION_BLOCK1, &tempInt);`
`@@ -313,6 +326,7 @@ uint16_t sn_coap_builder_calc_needed_packet_data_size_2(sn_coap_hdr_s *src_coap_`
`313`	`326`	`/* BLOCK 2 - An integer option, up to 3 bytes */`
`314`	`327`	`if (src_coap_msg_ptr->options_list_ptr->block2 != COAP_OPTION_BLOCK_NONE) {`
`315`	`328`	`if ((uint32_t) src_coap_msg_ptr->options_list_ptr->block2 > 0xffffff) {`
	`329`	`+ tr_error("sn_coap_builder_calc_needed_packet_data_size_2 - block2 too large!");`
`316`	`330`	`return 0;`
`317`	`331`	`}`
`318`	`332`	`returned_byte_count += sn_coap_builder_options_build_add_uint_option(NULL, src_coap_msg_ptr->options_list_ptr->block2, COAP_OPTION_BLOCK2, &tempInt);`
`@@ -483,6 +497,7 @@ static int8_t sn_coap_builder_header_build(uint8_t **dst_packet_data_pptr, sn_co`
`483`	`497`	`{`
`484`	`498`	`/* * * * Check validity of Header values * * * */`
`485`	`499`	`if (sn_coap_header_validity_check(src_coap_msg_ptr, COAP_VERSION) != 0) {`
	`500`	`+ tr_error("sn_coap_builder_header_build - header build failed!");`
`486`	`501`	`return -1;`
`487`	`502`	`}`
`488`	`503`
`@@ -526,6 +541,7 @@ static int8_t sn_coap_builder_options_build(uint8_t **dst_packet_data_pptr, sn_c`
`526`	`541`	`/* * * * Check if Options are used at all * * * */`
`527`	`542`	`if (src_coap_msg_ptr->uri_path_ptr == NULL && src_coap_msg_ptr->token_ptr == NULL &&`
`528`	`543`	`src_coap_msg_ptr->content_format == COAP_CT_NONE && src_coap_msg_ptr->options_list_ptr == NULL) {`
	`544`	`+ tr_error("sn_coap_builder_options_build - options not used!");`
`529`	`545`	`return 0;`
`530`	`546`	`}`
`531`	`547`