18#if defined(HAVE_LIMITS_H)
25#ifdef HAVE_ARPA_INET_H
34#define min(a,b) ((a) < (b) ? (a) : (b))
38#define max(a,b) ((a) > (b) ? (a) : (b))
69coap_pdu_from_pbuf(
struct pbuf *pbuf) {
75 LWIP_ASSERT(
"Can only deal with contiguous PBUFs (increase PBUF_POOL_BUFSIZE)",
76 pbuf->tot_len == pbuf->len);
77 LWIP_ASSERT(
"coap_io_do_io needs to receive an exclusive copy of the incoming pbuf",
103 assert(code <= 0xff);
104 assert(mid >= 0 && mid <= 0xffff);
110 if (memp_pools[MEMP_COAP_PDU]->stats->used + 1 >=
111 memp_pools[MEMP_COAP_PDU]->stats->avail) {
112 memp_pools[MEMP_COAP_PDU]->stats->err++;
121#if defined(WITH_CONTIKI) || defined(WITH_LWIP)
122 assert(size <= COAP_DEFAULT_MAX_PDU_RX_SIZE);
123 if (size > COAP_DEFAULT_MAX_PDU_RX_SIZE)
131 pdu->pbuf = pbuf_alloc(PBUF_TRANSPORT, size + pdu->
max_hdr_size, PBUF_RAM);
132 if (pdu->pbuf == NULL) {
163 coap_log_crit(
"coap_new_pdu: cannot allocate memory for new PDU\n");
171 pbuf_free(pdu->pbuf);
173 if (pdu->
token != NULL)
187 const uint8_t *token,
212 if (drop_options == NULL) {
253#if !defined(WITH_LWIP)
261#if !defined(WITH_LWIP)
262 if (pdu->
data != NULL) {
271 if (new_hdr == NULL) {
296 while (size > new_size)
318 coap_log_warn(
"coap_add_token: The token must defined first. Token ignored\n");
329 coap_log_warn(
"coap_add_token: Token size too large. Token ignored\n");
333 coap_log_warn(
"coap_add_token: Insufficient space for token. Token ignored\n");
343 memcpy(pdu->
token, data, len);
347 memcpy(&pdu->
token[1], data, len);
352 memcpy(&pdu->
token[2], data, len);
384 coap_log_warn(
"coap_add_token: Token size too large. Token ignored\n");
415 if (memcmp(pdu->
token, data, len) != 0)
416 memcpy(pdu->
token, data, len);
420 memcpy(&pdu->
token[1], data, len);
425 memcpy(&pdu->
token[2], data, len);
446 if (opt_iter.
number == number) {
464 opt_delta = decode_this.
delta + decode_next.
delta;
465 if (opt_delta < 13) {
467 next_option[0] = (next_option[0] & 0x0f) + (
coap_opt_t)(opt_delta << 4);
468 }
else if (opt_delta < 269 && decode_next.
delta < 13) {
471 next_option[0] = (next_option[1] & 0x0f) + (13 << 4);
472 next_option[1] = (
coap_opt_t)(opt_delta - 13);
473 }
else if (opt_delta < 269) {
475 next_option[1] = (
coap_opt_t)(opt_delta - 13);
476 }
else if (decode_next.
delta < 13) {
478 if (next_option - option < 2) {
486 if (opt_iter.
number == number) {
492 assert(option != NULL);
493 assert(next_option != NULL);
494 memmove(&next_option[1], next_option,
502 next_option[0] = (next_option[2] & 0x0f) + (14 << 4);
503 next_option[1] = (
coap_opt_t)((opt_delta - 269) >> 8);
504 next_option[2] = (opt_delta - 269) & 0xff;
505 }
else if (decode_next.
delta < 269) {
508 next_option[0] = (next_option[1] & 0x0f) + (14 << 4);
509 next_option[1] = (
coap_opt_t)((opt_delta - 269) >> 8);
510 next_option[2] = (opt_delta - 269) & 0xff;
512 next_option[1] = (
coap_opt_t)((opt_delta - 269) >> 8);
513 next_option[2] = (opt_delta - 269) & 0xff;
521 memmove(option, next_option, pdu->
used_size - (next_option - pdu->
token));
524 pdu->
data -= next_option - option;
559 coap_log_info(
"Option number %d is not defined as repeatable - dropped\n",
563 coap_log_info(
"Option number %d is not defined as repeatable\n",
573 const uint8_t *data) {
576 uint16_t prev_number = 0;
588 if (opt_iter.
number > number) {
592 prev_number = opt_iter.
number;
594 assert(option != NULL);
601 opt_delta = opt_iter.
number - number;
602 if (opt_delta == 0) {
615 if (opt_iter.
number > number) {
620 assert(option != NULL);
622 if (decode.
delta < 13) {
624 option[0] = (option[0] & 0x0f) + (
coap_opt_t)(opt_delta << 4);
625 }
else if (decode.
delta < 269 && opt_delta < 13) {
627 option[1] = (option[0] & 0x0f) + (
coap_opt_t)(opt_delta << 4);
629 }
else if (decode.
delta < 269 && opt_delta < 269) {
632 }
else if (opt_delta < 13) {
634 option[2] = (option[0] & 0x0f) + (
coap_opt_t)(opt_delta << 4);
636 }
else if (opt_delta < 269) {
638 option[1] = (option[0] & 0x0f) + 0xd0;
643 option[1] = (
coap_opt_t)((opt_delta - 269) >> 8);
644 option[2] = (opt_delta - 269) & 0xff;
647 memmove(&option[shift], &option[shrink],
650 number - prev_number, data, len))
653 if (shift >= shrink) {
656 pdu->
data += shift - shrink;
660 pdu->
data -= shrink - shift;
667 const uint8_t *data) {
671 size_t new_length = 0;
672 size_t old_length = 0;
683 if (new_length > old_length) {
685 pdu->
used_size + new_length - old_length))
691 if (new_length != old_length)
692 memmove(&option[new_length], &option[old_length],
696 decode.
delta, data, len))
699 if (new_length >= old_length) {
700 pdu->
used_size += new_length - old_length;
702 pdu->
data += new_length - old_length;
704 pdu->
used_size -= old_length - new_length;
706 pdu->
data -= old_length - new_length;
713 const uint8_t *data) {
715 coap_log_warn(
"coap_add_optlist_pdu: PDU already contains data\n");
723 const uint8_t *data) {
750 if (number < pdu->max_opt) {
751 coap_log_debug(
"coap_add_option: options are not in correct order\n");
762 memmove(&pdu->
data[optsize-1], &pdu->
data[-1],
765 pdu->
data += optsize;
772 number - pdu->
max_opt, data, len);
793 memcpy(payload, data, len);
794 return payload != NULL;
827 size_t *offset,
size_t *total) {
840 if (pdu->
data == NULL) {
853#ifndef SHORT_ERROR_RESPONSE
919 assert(optsize <= *length);
926 *max_opt += option.
delta;
936 const uint8_t *data) {
938 size_t header_size = 0;
941 uint8_t len = *data >> 4;
975 const uint8_t *token_start = NULL;
978 uint8_t len = *data >> 4;
979 uint8_t tkl = *data & 0x0f;
983 token_start = &data[2];
984 }
else if (length >= 2) {
987 token_start = &data[3];
988 }
else if (length >= 3) {
991 token_start = &data[4];
992 }
else if (length >= 5) {
993 size = ((size_t)data[1] << 24) + ((size_t)data[2] << 16)
995 token_start = &data[6];
1006 size += ((uint16_t)token_start[0] << 8) + token_start[1] +
1021 uint8_t e_token_length;
1029 pdu->
type = (hdr[0] >> 4) & 0x03;
1031 pdu->
mid = (uint16_t)hdr[2] << 8 | hdr[3];
1047 e_token_length = hdr[0] & 0x0f;
1064 coap_log_debug(
"coap_pdu_parse: PDU header token size broken\n");
1109 if (len < 1 || len > 255)
1150 if (len < 1 || len > 255)
1154 if (len < 1 || len > 8)
1190 if (len < 1 || len > 255)
1218 if (len < 1 || len > 1034)
1222 if (len < 1 || len > 255)
1250 if (*len < prflen +1) {
1254 memcpy(*obp, prf, prflen);
1268 const uint8_t hex[] =
"0123456789abcdef";
1269 (*obp)[0] = hex[(c & 0xf0) >> 4];
1270 (*obp)[1] = hex[c & 0x0f];
1272 (*obp)[0] = isprint(c) ? c :
'.';
1285 if (pdu->
code == 0) {
1298 if (pdu->
code == 0) {
1308#if (COAP_MAX_LOGGING_LEVEL >= _COAP_LOG_WARN)
1312 const uint32_t len =
1315 coap_log_debug(
"coap_pdu_parse: %d.%02d: offset %u malformed option\n",
1324 coap_log_warn(
"coap_pdu_parse: %d.%02d: offset %u option %u has bad length %" PRIu32 "\n",
1338 static char outbuf[COAP_DEBUG_BUF_SIZE];
1345 for (i = 0; i < 2; i++) {
1350 outbuflen =
sizeof(outbuf);
1356 const uint32_t len =
1370 tlen = opt - opt_last;
1372 ok = ok &&
write_char(&obp, &outbuflen, *opt_last, i);
1377 ok = ok &&
write_char(&obp, &outbuflen, *opt, i);
1391 coap_log_debug(
"coap_pdu_parse: message ending in payload start marker\n");
1396 pdu->
data = (uint8_t *)opt;
1406 const uint8_t *data,
1414 if (!hdr_size || hdr_size > length)
1420 if (pdu->
token - hdr_size != data)
1421 memcpy(pdu->
token - hdr_size, data, length);
1429 uint8_t e_token_length;
1438 coap_log_warn(
"coap_add_token: Token size too large. PDU ignored\n");
1444 coap_log_warn(
"coap_pdu_encode_header: not enough space for UDP-style header\n");
1451 pdu->
token[-2] = (uint8_t)(pdu->
mid >> 8);
1452 pdu->
token[-1] = (uint8_t)(pdu->
mid);
1454#if !COAP_DISABLE_TCP
1474 coap_log_warn(
"coap_pdu_encode_header: not enough space for TCP0 header\n");
1477 pdu->
token[-2] = (uint8_t)len << 4
1484 coap_log_warn(
"coap_pdu_encode_header: not enough space for TCP8 header\n");
1487 pdu->
token[-3] = 13 << 4 | e_token_length;
1494 coap_log_warn(
"coap_pdu_encode_header: not enough space for TCP16 header\n");
1497 pdu->
token[-4] = 14 << 4 | e_token_length;
1505 coap_log_warn(
"coap_pdu_encode_header: not enough space for TCP32 header\n");
1508 pdu->
token[-6] = 15 << 4 | e_token_length;
1518 coap_log_warn(
"coap_pdu_encode_header: unsupported protocol\n");
1531 assert(code <= 0xff);
1543 assert(type <= 0x3);
1559#if (UINT_MAX > 65535)
1560 assert(mid >= 0 && mid <= 0xffff);
Pulls together all the internal only header files.
void * coap_realloc_type(coap_memory_tag_t type, void *p, size_t size)
Reallocates a chunk p of bytes created by coap_malloc_type() or coap_realloc_type() and returns a poi...
void * coap_malloc_type(coap_memory_tag_t type, size_t size)
Allocates a chunk of size bytes and returns a pointer to the newly allocated memory.
void coap_free_type(coap_memory_tag_t type, void *p)
Releases the memory that was allocated by coap_malloc_type().
#define coap_lock_check_locked(s)
size_t coap_opt_parse(const coap_opt_t *opt, size_t length, coap_option_t *result)
Parses the option pointed to by opt into result.
uint16_t coap_option_num_t
uint8_t coap_opt_t
Use byte-oriented access methods here because sliding a complex struct coap_opt_t over the data buffe...
static size_t next_option_safe(coap_opt_t **optp, size_t *length, uint16_t *max_opt)
Advances *optp to next option if still in PDU.
static int coap_pdu_parse_opt_csm(coap_pdu_t *pdu, uint16_t len)
error_desc_t coap_error[]
static int write_prefix(char **obp, size_t *len, const char *prf, size_t prflen)
static int coap_pdu_parse_opt_base(coap_pdu_t *pdu, uint16_t len)
static int write_char(char **obp, size_t *len, int c, int printable)
uint16_t coap_new_message_id(coap_session_t *session)
Returns a new message id and updates session->tx_mid accordingly.
#define coap_log_debug(...)
#define coap_log_info(...)
#define coap_log_warn(...)
#define coap_log_crit(...)
coap_opt_t * coap_option_next(coap_opt_iterator_t *oi)
Updates the iterator oi to point to the next option.
size_t coap_opt_encode(coap_opt_t *opt, size_t maxlen, uint16_t delta, const uint8_t *val, size_t length)
Encodes option with given delta into opt.
uint32_t coap_opt_length(const coap_opt_t *opt)
Returns the length of the given option.
coap_opt_iterator_t * coap_option_iterator_init(const coap_pdu_t *pdu, coap_opt_iterator_t *oi, const coap_opt_filter_t *filter)
Initializes the given option iterator oi to point to the beginning of the pdu's option list.
size_t coap_opt_encode_size(uint16_t delta, size_t length)
Compute storage bytes needed for an option with given delta and length.
#define COAP_OPT_ALL
Pre-defined filter that includes all options.
coap_opt_t * coap_check_option(const coap_pdu_t *pdu, coap_option_num_t number, coap_opt_iterator_t *oi)
Retrieves the first option of number number from pdu.
const uint8_t * coap_opt_value(const coap_opt_t *opt)
Returns a pointer to the value of the given option.
int coap_option_filter_get(coap_opt_filter_t *filter, coap_option_num_t option)
Checks if number is contained in filter.
#define COAP_MESSAGE_SIZE_OFFSET_TCP8
#define COAP_TOKEN_EXT_2B_TKL
size_t coap_insert_option(coap_pdu_t *pdu, coap_option_num_t number, size_t len, const uint8_t *data)
Inserts option of given number in the pdu with the appropriate data.
int coap_remove_option(coap_pdu_t *pdu, coap_option_num_t number)
Removes (first) option of given number from the pdu.
int coap_update_token(coap_pdu_t *pdu, size_t len, const uint8_t *data)
Updates token in pdu with length len and data.
#define COAP_TOKEN_EXT_1B_BIAS
#define COAP_PDU_MAX_UDP_HEADER_SIZE
int coap_pdu_parse_header(coap_pdu_t *pdu, coap_proto_t proto)
Decode the protocol specific header for the specified PDU.
size_t coap_pdu_parse_header_size(coap_proto_t proto, const uint8_t *data)
Interprets data to determine the number of bytes in the header.
#define COAP_PDU_MAX_TCP_HEADER_SIZE
#define COAP_MAX_MESSAGE_SIZE_TCP8
#define COAP_PDU_IS_SIGNALING(pdu)
#define COAP_TOKEN_EXT_2B_BIAS
#define COAP_MAX_MESSAGE_SIZE_TCP0
int coap_option_check_repeatable(coap_option_num_t number)
Check whether the option is allowed to be repeated or not.
#define COAP_MESSAGE_SIZE_OFFSET_TCP16
void coap_pdu_clear(coap_pdu_t *pdu, size_t size)
Clears any contents from pdu and resets used_size, and data pointers.
#define COAP_MESSAGE_SIZE_OFFSET_TCP32
int coap_pdu_parse_opt(coap_pdu_t *pdu)
Verify consistency in the given CoAP PDU structure and locate the data.
size_t coap_update_option(coap_pdu_t *pdu, coap_option_num_t number, size_t len, const uint8_t *data)
Updates existing first option of given number in the pdu with the new data.
#define COAP_TOKEN_EXT_1B_TKL
size_t coap_pdu_encode_header(coap_pdu_t *pdu, coap_proto_t proto)
Compose the protocol specific header for the specified PDU.
#define COAP_DEFAULT_VERSION
#define COAP_PAYLOAD_START
int coap_pdu_check_resize(coap_pdu_t *pdu, size_t size)
Dynamically grows the size of pdu to new_size if needed.
size_t coap_pdu_parse_size(coap_proto_t proto, const uint8_t *data, size_t length)
Parses data to extract the message size.
int coap_pdu_resize(coap_pdu_t *pdu, size_t new_size)
Dynamically grows the size of pdu to new_size.
#define COAP_PDU_IS_REQUEST(pdu)
#define COAP_MAX_MESSAGE_SIZE_TCP16
size_t coap_add_option_internal(coap_pdu_t *pdu, coap_option_num_t number, size_t len, const uint8_t *data)
Adds option of given number to pdu that is passed as first parameter.
#define COAP_OPTION_HOP_LIMIT
#define COAP_OPTION_NORESPONSE
#define COAP_OPTION_URI_HOST
#define COAP_OPTION_IF_MATCH
coap_pdu_code_t coap_pdu_get_code(const coap_pdu_t *pdu)
Gets the PDU code associated with pdu.
#define COAP_OPTION_BLOCK2
const char * coap_response_phrase(unsigned char code)
Returns a human-readable response phrase for the specified CoAP response code.
#define COAP_OPTION_CONTENT_FORMAT
#define COAP_SIGNALING_OPTION_ALTERNATIVE_ADDRESS
#define COAP_OPTION_SIZE2
#define COAP_OPTION_BLOCK1
#define COAP_OPTION_PROXY_SCHEME
uint8_t * coap_add_data_after(coap_pdu_t *pdu, size_t len)
Adds given data to the pdu that is passed as first parameter but does not.
#define COAP_OPTION_URI_QUERY
void coap_delete_pdu(coap_pdu_t *pdu)
Dispose of an CoAP PDU and frees associated storage.
void coap_pdu_set_code(coap_pdu_t *pdu, coap_pdu_code_t code)
Sets the PDU code in the pdu.
int coap_mid_t
coap_mid_t is used to store the CoAP Message ID of a CoAP PDU.
#define COAP_OPTION_IF_NONE_MATCH
#define COAP_OPTION_LOCATION_PATH
#define COAP_TOKEN_EXT_MAX
#define COAP_OPTION_URI_PATH
#define COAP_SIGNALING_OPTION_EXTENDED_TOKEN_LENGTH
#define COAP_RESPONSE_CODE(N)
coap_proto_t
CoAP protocol types.
coap_pdu_t * coap_new_pdu(coap_pdu_type_t type, coap_pdu_code_t code, coap_session_t *session)
Creates a new CoAP PDU.
coap_pdu_code_t
Set of codes available for a PDU.
#define COAP_OPTION_OSCORE
#define COAP_OPTION_SIZE1
coap_pdu_type_t
CoAP PDU message type definitions.
#define COAP_SIGNALING_OPTION_BLOCK_WISE_TRANSFER
int coap_add_token(coap_pdu_t *pdu, size_t len, const uint8_t *data)
Adds token of length len to pdu.
#define COAP_OPTION_LOCATION_QUERY
void coap_pdu_set_type(coap_pdu_t *pdu, coap_pdu_type_t type)
Sets the PDU type in the pdu.
size_t coap_add_option(coap_pdu_t *pdu, coap_option_num_t number, size_t len, const uint8_t *data)
Adds option of given number to pdu that is passed as first parameter.
#define COAP_SIGNALING_OPTION_CUSTODY
coap_pdu_signaling_proto_t
coap_pdu_type_t coap_pdu_get_type(const coap_pdu_t *pdu)
Gets the PDU type associated with pdu.
int coap_get_data(const coap_pdu_t *pdu, size_t *len, const uint8_t **data)
Retrieves the length and data pointer of specified PDU.
int coap_pdu_parse(coap_proto_t proto, const uint8_t *data, size_t length, coap_pdu_t *pdu)
Parses data into the CoAP PDU structure given in result.
#define COAP_MAX_OPT
the highest option number we know
void coap_pdu_set_mid(coap_pdu_t *pdu, coap_mid_t mid)
Sets the message id in the pdu.
coap_pdu_t * coap_pdu_duplicate(const coap_pdu_t *old_pdu, coap_session_t *session, size_t token_length, const uint8_t *token, coap_opt_filter_t *drop_options)
Duplicate an existing PDU.
#define COAP_OPTION_URI_PORT
coap_pdu_t * coap_pdu_init(coap_pdu_type_t type, coap_pdu_code_t code, coap_mid_t mid, size_t size)
Creates a new CoAP PDU with at least enough storage space for the given size maximum message size.
#define COAP_OPTION_ACCEPT
int coap_get_data_large(const coap_pdu_t *pdu, size_t *len, const uint8_t **data, size_t *offset, size_t *total)
Retrieves the data from a PDU, with support for large bodies of data that spans multiple PDUs.
coap_mid_t coap_pdu_get_mid(const coap_pdu_t *pdu)
Gets the message id associated with pdu.
#define COAP_OPTION_MAXAGE
#define COAP_OPTION_PROXY_URI
#define COAP_OPTION_OBSERVE
#define COAP_SIGNALING_OPTION_HOLD_OFF
#define COAP_SIGNALING_OPTION_BAD_CSM_OPTION
#define COAP_SIGNALING_OPTION_MAX_MESSAGE_SIZE
int coap_add_data(coap_pdu_t *pdu, size_t len, const uint8_t *data)
Adds given data to the pdu that is passed as first parameter.
coap_bin_const_t coap_pdu_get_token(const coap_pdu_t *pdu)
Gets the token associated with pdu.
size_t coap_session_max_pdu_size(const coap_session_t *session)
Get maximum acceptable PDU size.
#define COAP_PROTO_NOT_RELIABLE(p)
#define COAP_PROTO_RELIABLE(p)
CoAP binary data definition with const data.
size_t length
length of binary data
const uint8_t * s
read-only binary data
Iterator to run through PDU options.
coap_option_num_t number
decoded option number
Representation of CoAP options.
uint8_t max_hdr_size
space reserved for protocol-specific header
uint16_t max_opt
highest option number in PDU
uint8_t * token
first byte of token (or extended length bytes prefix), if any, or options
coap_lg_xmit_t * lg_xmit
Holds ptr to lg_xmit if sending a set of blocks.
size_t body_length
Holds body data length.
size_t max_size
maximum size for token, options and payload, or zero for variable size pdu
const uint8_t * body_data
Holds ptr to re-assembled data or NULL.
size_t body_offset
Holds body data offset.
coap_pdu_code_t code
request method (value 1–31) or response code (value 64-255)
uint8_t hdr_size
actual size used for protocol-specific header (0 until header is encoded)
coap_bin_const_t actual_token
Actual token in pdu.
uint8_t * data
first byte of payload, if any
coap_mid_t mid
message id, if any, in regular host byte order
uint32_t e_token_length
length of Token space (includes leading extended bytes
size_t used_size
used bytes of storage for token, options and payload
uint8_t crit_opt
Set if unknown critical option for proxy.
size_t alloc_size
allocated storage for token, options and payload
coap_session_t * session
Session responsible for PDU or NULL.
size_t body_total
Holds body data total size.
coap_pdu_type_t type
message type
Abstraction of virtual session that can be attached to coap_context_t (client) or coap_endpoint_t (se...
uint8_t doing_first
Set if doing client's first request.
coap_context_t * context
session's context