19#define min(a,b) ((a) < (b) ? (a) : (b))
22#define STATE_TOKEN_BASE(t) ((t) & 0xffffffffffffULL)
23#define STATE_TOKEN_RETRY(t) ((uint64_t)(t) >> 48)
24#define STATE_TOKEN_FULL(t,r) (STATE_TOKEN_BASE(t) + ((uint64_t)(r) << 48))
26#if COAP_Q_BLOCK_SUPPORT
72 if (block->
szx == 7) {
84 if (block->
m && (length % 1024) != 0) {
85 coap_log_debug(
"block: Oversized packet - reduced to %zu from %zu\n",
86 length - (length % 1024), length);
87 length -= length % 1024;
120 block->
m = block_b.
m;
130 unsigned int blk_size,
size_t total) {
132 size_t avail = pdu->
max_size - token_options;
133 unsigned int start = num << (blk_size + 4);
134 unsigned int can_use_bert = block->
defined == 0 || block->
bert;
136 assert(start <= total);
137 memset(block, 0,
sizeof(*block));
139 block->
szx = block->
aszx = blk_size;
140 if (can_use_bert && blk_size == 6 && avail >= 1024 && session != NULL &&
145 block->
chunk_size = (uint32_t)((avail / 1024) * 1024);
147 block->
chunk_size = (size_t)1 << (blk_size + 4);
148 if (avail < block->chunk_size && (total - start) >= avail) {
154 coap_log_debug(
"not enough space, even the smallest block does not fit (1)\n");
157 new_blk_size =
coap_flsll((
long long)avail) - 5;
158 coap_log_debug(
"decrease block size for %zu to %d\n", avail, new_blk_size);
160 block->
szx = new_blk_size;
161 block->
num <<= szx - block->
szx;
162 block->
chunk_size = (size_t)1 << (new_blk_size + 4);
173 unsigned char buf[4];
178 start = block->
num << (block->
szx + 4);
179 if (block->
num != 0 && data_length <= start) {
189 block->
szx, data_length))
194 ((block_b.
num << 4) |
207 unsigned char buf[4];
211 start = block->
num << (block->
szx + 4);
212 if (block->
num != 0 && data_length <= start) {
220 block->
szx, data_length))
235 unsigned int block_num,
unsigned char block_szx) {
237 start = block_num << (block_szx + 4);
243 min(len - start, ((
size_t)1 << (block_szx + 4))),
250 unsigned int start = block->
num << (block->
szx + 4);
258 max_size = ((pdu->
max_size - token_options) / 1024) * 1024;
260 max_size = (size_t)1 << (block->
szx + 4);
265 min(len - start, max_size),
281 unsigned char buf[4];
283 int block2_requested = 0;
285 memset(&block2, 0,
sizeof(block2));
292 block2_requested = 1;
293 if (block2.
num != 0 && length <= (block2.
num << (block2.
szx + 4))) {
296 length >> (block2.
szx + 4));
305 memset(etag, 0,
sizeof(etag));
320 if (block2_requested) {
380 uint32_t block_mode) {
388 uint32_t block_mode) {
394#if ! COAP_Q_BLOCK_SUPPORT
402 size_t max_block_size) {
413 switch (max_block_size) {
424 coap_log_info(
"coap_context_set_max_block_size: Invalid max block size (%zu)\n",
429 max_block_size = (
coap_fls((uint32_t)max_block_size >> 4) - 1) & 0x07;
430 context->
block_mode &= ~COAP_BLOCK_MAX_SIZE_MASK;
437 const uint8_t *b,
size_t blen) {
438 return alen == blen && (alen == 0 || memcmp(a, b, alen) == 0);
441#if COAP_CLIENT_SUPPORT
465 coap_log_debug(
"** %s: coap_cancel_observe: COAP_BLOCK_USE_LIBCOAP not enabled\n",
470 LL_FOREACH_SAFE(session->
lg_crcv, lg_crcv, q) {
478#if COAP_Q_BLOCK_SUPPORT
520#if COAP_Q_BLOCK_SUPPORT
522 if (using_q_block1) {
523 mid = coap_send_q_block1(session, block, pdu, COAP_SEND_INC_PDU);
539#if COAP_OSCORE_SUPPORT
545 uint64_t token_match =
556 LL_FOREACH(session->
lg_crcv, lg_crcv) {
595#if COAP_SERVER_SUPPORT
612 LL_FOREACH(session->
lg_xmit, lg_xmit) {
619 lg_xmit->b.b2.query ?
620 lg_xmit->b.b2.query : &empty)) {
629 memcmp(lg_xmit->
b.
b2.
rtag, rtag, rtag_length) != 0)
654#if COAP_Q_BLOCK_SUPPORT
660 int have_block_defined = 0;
662 uint8_t max_blk_size;
664 size_t token_options;
667#if COAP_Q_BLOCK_SUPPORT
673 coap_log_warn(
"coap_add_data_large: PDU already contains data\n");
675 release_func(session, app_ptr);
680 coap_log_debug(
"** %s: coap_add_data_large: COAP_BLOCK_USE_LIBCOAP not enabled\n",
694#define MAX_BLK_LEN (((1UL << 20) - 1) * (1 << (6 + 4)))
696#if UINT_MAX > MAX_BLK_LEN
707#if COAP_Q_BLOCK_SUPPORT
723 LL_FOREACH_SAFE(session->
lg_xmit, lg_xmit, q) {
726 LL_DELETE(session->
lg_xmit, lg_xmit);
736#if COAP_Q_BLOCK_SUPPORT
737 if (session->
block_mode & COAP_BLOCK_HAS_Q_BLOCK) {
750#if COAP_SERVER_SUPPORT
758 LL_DELETE(session->
lg_xmit, lg_xmit);
765#if COAP_OSCORE_SUPPORT
766 if (session->oscore_encryption) {
774 avail = pdu->
max_size - token_options;
777#if COAP_OSCORE_SUPPORT
782 blk_size =
coap_flsll((
long long)avail) - 4 - 1;
787 if (max_blk_size && blk_size > max_blk_size)
788 blk_size = max_blk_size;
792 if (block.
szx < blk_size)
793 blk_size = block.
szx;
794 have_block_defined = 1;
796#if COAP_Q_BLOCK_SUPPORT
799 if (have_block_defined) {
801 coap_log_warn(
"Both BlockX and Q-BlockX cannot be set at the same time\n");
805 if (block.
szx < blk_size)
806 blk_size = block.
szx;
807 have_block_defined = 1;
813 if (avail < 16 && ((ssize_t)length > avail || have_block_defined)) {
815 coap_log_debug(
"not enough space, even the smallest block does not fit (2)\n");
819 chunk = (size_t)1 << (blk_size + 4);
820 if ((have_block_defined && block.
num != 0) || single_request ||
825 if (length >= block.
num * chunk) {
827#if COAP_SERVER_SUPPORT
832 (
unsigned int)length),
844 memcpy(&etag, digest.
key,
sizeof(etag));
862 (block.
num << 4) | (block.
m << 3) | block.
aszx),
867 if (chunk > length - block.
num * chunk)
868 rem = length - block.
num * chunk;
873 release_func(session, app_ptr);
874 }
else if ((have_block_defined && length > chunk) || (ssize_t)length > avail) {
894 lg_xmit->blk_size = blk_size;
895 lg_xmit->option = option;
896 lg_xmit->data = data;
897 lg_xmit->length = length;
898#if COAP_Q_BLOCK_SUPPORT
899 lg_xmit->non_timeout_random_ticks =
902 lg_xmit->release_func = release_func;
903 lg_xmit->app_ptr = app_ptr;
910 if (!lg_xmit->b.b1.app_token)
918 lg_xmit->b.b1.count = 1;
920 lg_xmit->b.b1.count);
928 (
unsigned int)length),
941 lg_xmit->b.b2.resource = resource;
944 if (lg_xmit->b.b2.query) {
945 memcpy(lg_xmit->b.b2.query->s, query->
s, query->
length);
948 lg_xmit->b.b2.query = NULL;
953 sizeof(lg_xmit->b.b2.rtag));
955 lg_xmit->b.b2.rtag_set = 1;
957 lg_xmit->b.b2.rtag_set = 0;
959 lg_xmit->b.b2.etag = etag;
960 lg_xmit->b.b2.request_method = request_method;
967 lg_xmit->b.b2.maxage_expire = 0;
972 (
unsigned int)length),
986 blk_size, lg_xmit->length))
993 (block.
num << 4) | (block.
m << 3) | block.
aszx),
997 memcpy(&lg_xmit->pdu, pdu,
sizeof(lg_xmit->pdu));
999 lg_xmit->pdu.used_size + lg_xmit->pdu.max_hdr_size);
1000 if (!lg_xmit->pdu.token)
1003 lg_xmit->pdu.alloc_size = lg_xmit->pdu.used_size;
1004 lg_xmit->pdu.token += lg_xmit->pdu.max_hdr_size;
1005 memcpy(lg_xmit->pdu.token, pdu->
token, lg_xmit->pdu.used_size);
1007 lg_xmit->pdu.data = lg_xmit->pdu.token + (pdu->
data - pdu->
token);
1008 lg_xmit->pdu.actual_token.s = lg_xmit->pdu.token + pdu->
e_token_length -
1014 avail = pdu->
max_size - token_options;
1019#if COAP_OSCORE_SUPPORT
1022 if (avail < (ssize_t)chunk) {
1025 coap_log_warn(
"not enough space, even the smallest block does not fit (3)\n");
1028 blk_size =
coap_flsll((
long long)avail) - 4 - 1;
1029 block.
num = block.
num << (lg_xmit->blk_size - blk_size);
1030 lg_xmit->blk_size = blk_size;
1031 chunk = (size_t)1 << (lg_xmit->blk_size + 4);
1037 (block.
num << 4) | (block.
m << 3) | lg_xmit->blk_size),
1042 if (rem > lg_xmit->length - block.
num * chunk)
1043 rem = lg_xmit->length - block.
num * chunk;
1048 lg_xmit->b.b1.bert_size = rem;
1050 lg_xmit->last_block = -1;
1053 LL_PREPEND(session->
lg_xmit,lg_xmit);
1062 if (have_block_defined) {
1066 (0 << 4) | (0 << 3) | blk_size), buf);
1073 release_func(session, app_ptr);
1080 }
else if (release_func) {
1081 release_func(session, app_ptr);
1086#if COAP_CLIENT_SUPPORT
1091 const uint8_t *data,
1099 release_func, app_ptr);
1108 const uint8_t *data,
1117 release_func(session, app_ptr);
1121 length, data, release_func, app_ptr, 0, 0);
1125#if COAP_SERVER_SUPPORT
1132 uint16_t media_type,
1136 const uint8_t *data,
1144 response, query, media_type, maxage, etag,
1145 length, data, release_func, app_ptr);
1156 uint16_t media_type,
1160 const uint8_t *data,
1164 unsigned char buf[4];
1166 int block_requested = 0;
1167 int single_request = 0;
1168#if COAP_Q_BLOCK_SUPPORT
1169 uint32_t block_opt = (session->
block_mode & COAP_BLOCK_HAS_Q_BLOCK) ?
1175 memset(&block, 0,
sizeof(block));
1182 block_requested = 1;
1183 if (block.
num != 0 && length <= (block.
num << (block.
szx + 4))) {
1186 length >> (block.
szx + 4));
1191#if COAP_Q_BLOCK_SUPPORT
1193 block_requested = 1;
1194 if (block.
num != 0 && length <= (block.
num << (block.
szx + 4))) {
1197 length >> (block.
szx + 4));
1201 if (!(session->
block_mode & COAP_BLOCK_HAS_Q_BLOCK)) {
1222 if (block_requested) {
1246 query, maxage, etag, length, data,
1247 release_func, app_ptr, single_request,
1250 goto error_released;
1257 release_func(session, app_ptr);
1259#if COAP_ERROR_PHRASE_LENGTH > 0
1277#if COAP_Q_BLOCK_SUPPORT
1287 LL_FOREACH_SAFE(session->
lg_xmit, p, q) {
1291 LL_DELETE(session->
lg_xmit, p);
1301 if (p->
last_sent + partial_timeout <= now) {
1303 LL_DELETE(session->
lg_xmit, p);
1308 if (*tim_rem > p->
last_sent + partial_timeout - now) {
1309 *tim_rem = p->
last_sent + partial_timeout - now;
1318#if COAP_CLIENT_SUPPORT
1319#if COAP_Q_BLOCK_SUPPORT
1347 int block_payload_set = -1;
1363 block_size = (size_t)1 << (lg_crcv->
szx + 4);
1364 sofar = block * block_size;
1365 if (sofar < lg_crcv->total_len) {
1368 pdu = coap_build_missing_pdu(session, lg_crcv);
1374 (block << 4) | (1 << 3) | lg_crcv->
szx),
1387 pdu = coap_build_missing_pdu(session, lg_crcv);
1392 if (block_payload_set == -1)
1398 (block << 4) | (0 << 3) | lg_crcv->
szx),
1406 block_size = (size_t)1 << (lg_crcv->
szx + 4);
1407 sofar = (block + 1) * block_size;
1408 if (sofar < lg_crcv->total_len) {
1411 pdu = coap_build_missing_pdu(session, lg_crcv);
1415 sofar = (lg_crcv->
total_len + block_size - 1)/block_size;
1417 if (block_payload_set == -1)
1419 for (; block < (ssize_t)sofar &&
1423 (block << 4) | (0 << 3) | lg_crcv->
szx),
1431 if (block_payload_set != -1)
1432 lg_crcv->
rec_blocks.processing_payload_set = block_payload_set;
1447#if COAP_Q_BLOCK_SUPPORT
1453#if COAP_Q_BLOCK_SUPPORT
1455 session->
block_mode & COAP_BLOCK_HAS_Q_BLOCK)
1461 LL_FOREACH_SAFE(session->
lg_crcv, p, q) {
1465#if COAP_Q_BLOCK_SUPPORT
1467 size_t scaled_timeout = receive_timeout *
1480 coap_request_missing_q_block2(session, p);
1492 p->
last_used + partial_timeout <= now) {
1493#if COAP_Q_BLOCK_SUPPORT
1497 LL_DELETE(session->
lg_crcv, p);
1501 if (*tim_rem > p->
last_used + partial_timeout - now) {
1502 *tim_rem = p->
last_used + partial_timeout - now;
1511#if COAP_SERVER_SUPPORT
1512#if COAP_Q_BLOCK_SUPPORT
1540 assert(block >= 0 && block < (1 << 20));
1542 if (block < 0 || block >= (1 << 20)) {
1544 }
else if (block < 24) {
1547 }
else if (block < 0x100) {
1551 }
else if (block < 0x10000) {
1554 val[1] = block >> 8;
1555 val[2] = block & 0xff;
1559 val[1] = block >> 16;
1560 val[2] = (block >> 8) & 0xff;
1561 val[3] = block & 0xff;
1577 for (i = 0; i < rec_blocks->
used; i++) {
1578 if (block_num < rec_blocks->range[i].begin)
1580 if (block_num <= rec_blocks->range[i].end)
1586#if COAP_SERVER_SUPPORT
1588check_if_next_block(
coap_rblock_t *rec_blocks, uint32_t block_num) {
1589 if (rec_blocks->
used == 0) {
1590 return block_num == 0 ? 1 : 0;
1592 if (rec_blocks->
range[rec_blocks->
used-1].
end + 1 == block_num)
1604 for (i = 0; i < rec_blocks->
used; i++) {
1605 if (block < rec_blocks->range[i].begin)
1607 if (block < rec_blocks->range[i].end)
1611 if (block + 1 < total_blocks)
1617#if COAP_CLIENT_SUPPORT
1618#if COAP_Q_BLOCK_SUPPORT
1622 if (rec_blocks->
used &&
1624 rec_blocks->processing_payload_set)
1632 if (rec_blocks->
used > 1 &&
1634 rec_blocks->processing_payload_set)
1641#if COAP_SERVER_SUPPORT
1652#if COAP_Q_BLOCK_SUPPORT
1658#if COAP_Q_BLOCK_SUPPORT
1660 session->
block_mode & COAP_BLOCK_HAS_Q_BLOCK)
1666 LL_FOREACH_SAFE(session->
lg_srcv, p, q) {
1670#if COAP_Q_BLOCK_SUPPORT
1672 size_t scaled_timeout = receive_timeout *
1682 size_t block_size = (size_t)1 << (p->
szx + 4);
1683 size_t final_block = (p->
total_len + block_size - 1)/block_size - 1;
1685 size_t last_payload_block;
1687 size_t no_blocks = 0;
1700 if (no_blocks == 0 && block == (
int)final_block)
1706 if (final_block > last_payload_block) {
1707 final_block = last_payload_block;
1709 no_blocks += final_block - block;
1710 if (no_blocks == 0) {
1712 final_block = (p->
total_len + block_size - 1)/block_size - 1;
1714 if (final_block > last_payload_block) {
1715 final_block = last_payload_block;
1725 pdu = pdu_408_build(session, p);
1731 if (!add_408_block(pdu, block)) {
1741 for (; block <= (int)final_block; block++) {
1743 pdu = pdu_408_build(session, p);
1747 if (!add_408_block(pdu, block)) {
1767#if COAP_Q_BLOCK_SUPPORT
1787 (
const uint8_t *)
"Missing interim block");
1791 LL_DELETE(session->
lg_srcv, p);
1795 if (*tim_rem > p->
last_used + partial_timeout - now) {
1796 *tim_rem = p->
last_used + partial_timeout - now;
1805#if COAP_Q_BLOCK_SUPPORT
1814 coap_send_pdu_t send_pdu) {
1819 const uint8_t *ptoken;
1821 size_t ltoken_length;
1822 uint32_t delayqueue_cnt = 0;
1825 if (send_pdu == COAP_SEND_INC_PDU)
1834 (send_pdu == COAP_SEND_INC_PDU ? 1 : 0);
1835 LL_FOREACH(session->
delayqueue, delayqueue) {
1863 ptoken, &drop_options);
1869 if (send_pdu == COAP_SEND_INC_PDU &&
1879 size_t chunk = ((size_t)1 << (lg_xmit->
blk_size + 4));
1905 ltoken_length, ptoken, &drop_options);
1910 ((block.
num) << 4) |
1949#if COAP_CLIENT_SUPPORT
1957 LL_FOREACH_SAFE(session->
lg_xmit, lg_xmit, q) {
1958 coap_tick_t non_timeout = lg_xmit->non_timeout_random_ticks;
1960 if (now < non_timeout)
1961 return non_timeout - now;
1962 timed_out = now - non_timeout;
1968 size_t chunk = (size_t)1 << (lg_xmit->
blk_size + 4);
1970 memset(&block, 0,
sizeof(block));
1971 block.
num = (uint32_t)(lg_xmit->
offset / chunk);
1974 coap_send_q_blocks(session, lg_xmit, block, &lg_xmit->
pdu, COAP_SEND_SKIP_PDU);
1975 if (tim_rem > non_timeout)
1976 tim_rem = non_timeout;
1986 LL_DELETE(session->
lg_xmit, lg_xmit);
1990 if (tim_rem > lg_xmit->
last_all_sent + 4 * non_timeout - now)
1999#if COAP_SERVER_SUPPORT
2007 LL_FOREACH_SAFE(session->
lg_xmit, lg_xmit, q) {
2008 coap_tick_t non_timeout = lg_xmit->non_timeout_random_ticks;
2010 if (now < non_timeout)
2011 return non_timeout - now;
2012 timed_out = now - non_timeout;
2018 size_t chunk = (size_t)1 << (lg_xmit->
blk_size + 4);
2020 memset(&block, 0,
sizeof(block));
2021 block.
num = (uint32_t)(lg_xmit->
offset / chunk);
2025 coap_send_q_blocks(session, lg_xmit, block, &lg_xmit->
pdu, COAP_SEND_SKIP_PDU);
2026 if (tim_rem > non_timeout)
2027 tim_rem = non_timeout;
2037 LL_DELETE(session->
lg_xmit, lg_xmit);
2041 if (tim_rem > lg_xmit->
last_all_sent + 4 * non_timeout - now)
2051#if COAP_CLIENT_SUPPORT
2065 if (opt && lg_crcv) {
2066 int observe_action = -1;
2077 (block_num + 1) *
sizeof(lg_crcv->
obs_token[0]));
2090 if (lg_crcv->
obs_token[block_num] == NULL)
2094 if (block_num < lg_crcv->obs_token_cnt) {
2102#if COAP_Q_BLOCK_SUPPORT
2107 coap_send_pdu_t send_request) {
2110 uint64_t token_match =
2114 LL_FOREACH(session->
lg_xmit, lg_xmit) {
2123 return coap_send_q_blocks(session, lg_xmit, block, request, send_request);
2128#if COAP_SERVER_SUPPORT
2129#if COAP_Q_BLOCK_SUPPORT
2140 coap_send_pdu_t send_response) {
2145 LL_FOREACH(session->
lg_xmit, lg_xmit) {
2150 lg_xmit->b.b2.query ? lg_xmit->b.b2.query : &empty))
2153 return coap_send_q_blocks(session, lg_xmit, block, response, send_response);
2158#if COAP_CLIENT_SUPPORT
2159#if COAP_Q_BLOCK_SUPPORT
2191 11, (
const u_char *)
".well-known");
2193 4, (
const u_char *)
"core");
2206 (0 << 4) | (0 << 3) | 0),
2223 size_t token_options = pdu->
data ? (size_t)(pdu->
data - pdu->
token) :
2225 size_t data_len = lg_xmit ? lg_xmit->
length :
2231 if (lg_crcv == NULL)
2234 coap_log_debug(
"** %s: lg_crcv %p initialized - stateless token xxxx%012llx\n",
2238 lg_crcv->initial = 1;
2241 memcpy(&lg_crcv->pdu, pdu,
sizeof(lg_crcv->pdu));
2243 lg_crcv->pdu.max_size = token_options + data_len + 9;
2244 lg_crcv->pdu.used_size = token_options + data_len;
2246 token_options + data_len + lg_crcv->pdu.max_hdr_size);
2247 if (!lg_crcv->pdu.token) {
2251 lg_crcv->pdu.token += lg_crcv->pdu.max_hdr_size;
2252 memcpy(lg_crcv->pdu.token, pdu->
token, token_options);
2253 if (lg_crcv->pdu.data) {
2254 lg_crcv->pdu.data = lg_crcv->pdu.token + token_options;
2256 memcpy(lg_crcv->pdu.data, lg_xmit ? lg_xmit->
data : pdu->data, data_len);
2261 if (!lg_crcv->app_token) {
2268 lg_crcv->retry_counter = 1;
2269 lg_crcv->state_token = state_token;
2275 new_token = track_fetch_observe(pdu, lg_crcv, 0, &pdu->
actual_token);
2283 lg_crcv->o_blk_size = block.
aszx;
2295#if (COAP_MAX_LOGGING_LEVEL < _COAP_LOG_DEBUG)
2298 if (lg_crcv == NULL)
2315#if COAP_SERVER_SUPPORT
2319#if (COAP_MAX_LOGGING_LEVEL < _COAP_LOG_DEBUG)
2322 if (lg_srcv == NULL)
2337 if (lg_xmit == NULL)
2356#if COAP_SERVER_SUPPORT
2363add_block_send(uint32_t num,
int is_continue, send_track *out_blocks,
2364 uint32_t *count, uint32_t max_count) {
2367 for (i = 0; i < *count && *count < max_count; i++) {
2368 if (num == out_blocks[i].num)
2370 else if (num < out_blocks[i].num) {
2372 memmove(&out_blocks[i], &out_blocks[i+1], *count - i -1);
2373 out_blocks[i].num = num;
2374 out_blocks[i].is_continue = is_continue;
2379 if (*count < max_count) {
2380 out_blocks[i].num = num;
2381 out_blocks[i].is_continue = is_continue;
2414 uint16_t block_opt = 0;
2415 send_track *out_blocks = NULL;
2416 const char *error_phrase;
2421 uint32_t request_cnt, i;
2424#if COAP_Q_BLOCK_SUPPORT
2429 if (!(session->
block_mode & COAP_BLOCK_HAS_Q_BLOCK))
2436 coap_log_warn(
"Block2 and Q-Block2 cannot be in the same request\n");
2437 coap_add_data(response,
sizeof(
"Both Block2 and Q-Block2 invalid")-1,
2438 (
const uint8_t *)
"Both Block2 and Q-Block2 invalid");
2440 goto skip_app_handler;
2447 if (block.
num == 0) {
2455#if COAP_Q_BLOCK_SUPPORT
2461 goto internal_issue;
2476 goto skip_app_handler;
2483 chunk = (size_t)1 << (p->
blk_size + 4);
2486 coap_log_debug(
"found Block option, block is BERT, block nr. %u, M %d\n",
2487 block.
num, block.
m);
2489 coap_log_debug(
"found Block option, block size is %u, block nr. %u, M %d\n",
2490 1 << (block.
szx + 4), block.
num, block.
m);
2493 if (block.
num == 0) {
2494 if ((p->
offset + chunk) % ((
size_t)1 << (block.
szx + 4)) == 0) {
2499 block.
num = (uint32_t)(((p->
offset + chunk) >> (block.
szx + 4)) - 1);
2501 chunk = (size_t)1 << (p->
blk_size + 4);
2503 coap_log_debug(
"new Block size is %u, block number %u completed\n",
2504 1 << (block.
szx + 4), block.
num);
2507 "next block is not aligned on requested block size "
2508 "boundary. (%zu x %u mod %u = %zu (which is not 0)\n",
2510 (1 << (block.
szx + 4)),
2511 (p->
offset + chunk) % ((
size_t)1 << (block.
szx + 4)));
2514 coap_log_debug(
"ignoring request to change Block size from %u to %u\n",
2515 (1 << (p->
blk_size + 4)), (1 << (block.
szx + 4)));
2527#if COAP_Q_BLOCK_SUPPORT
2528 max_block = (p->
length + chunk - 1)/chunk;
2540 sizeof(
"Changing blocksize during request invalid")-1,
2541 (
const uint8_t *)
"Changing blocksize during request invalid");
2543 goto skip_app_handler;
2545#if COAP_Q_BLOCK_SUPPORT
2550 goto call_app_handler;
2554 num + i < max_block; i++) {
2555 add_block_send(num + i, 1, out_blocks, &request_cnt,
2563 num + i < max_block; i++) {
2564 add_block_send(num + i, 0, out_blocks, &request_cnt,
2569 add_block_send(num, 0, out_blocks, &request_cnt,
2572 add_block_send(num, 0, out_blocks, &request_cnt, 1);
2576 if (request_cnt == 0) {
2580 out_blocks[0].num = 0;
2581 out_blocks[0].is_continue = 0;
2585 for (i = 0; i < request_cnt; i++) {
2588 block.
num = out_blocks[i].num;
2591 if (i + 1 < request_cnt) {
2598 if (out_blocks[i].is_continue) {
2606 goto internal_issue;
2609 if (out_blocks[i].is_continue)
2624 goto internal_issue;
2634 ((out_pdu->
max_size - token_options) /1024) * 1024;
2645 goto internal_issue;
2647 if (!(p->
offset + chunk < p->length)) {
2655 if (!(p->
offset + chunk < p->length)) {
2673 goto internal_issue;
2681 goto internal_issue;
2683 if (i + 1 < request_cnt) {
2689 goto skip_app_handler;
2690#if COAP_Q_BLOCK_SUPPORT
2700 (
const uint8_t *)error_phrase);
2716 rec_blocks->
retry = 0;
2718 for (i = 0; i < rec_blocks->
used; i++) {
2719 if (block_num >= rec_blocks->
range[i].
begin &&
2720 block_num <= rec_blocks->range[i].end)
2723 if (block_num < rec_blocks->range[i].begin) {
2724 if (block_num + 1 == rec_blocks->
range[i].
begin) {
2731 memmove(&rec_blocks->
range[i+1], &rec_blocks->
range[i],
2732 (rec_blocks->
used - i) *
sizeof(rec_blocks->
range[0]));
2738 if (block_num == rec_blocks->
range[i].
end + 1) {
2739 rec_blocks->
range[i].
end = block_num;
2740 if (i + 1 < rec_blocks->
used) {
2741 if (rec_blocks->
range[i+1].
begin == block_num + 1) {
2744 if (i+2 < rec_blocks->
used) {
2745 memmove(&rec_blocks->
range[i+1], &rec_blocks->
range[i+2],
2746 (rec_blocks->
used - (i+2)) *
sizeof(rec_blocks->
range[0]));
2754 if (i == rec_blocks->
used) {
2765#if COAP_SERVER_SUPPORT
2785 const uint8_t *data = NULL;
2790 uint16_t block_option = 0;
2797 const uint8_t *rtag;
2798 uint32_t max_block_szx;
2801 unsigned int saved_num;
2802 size_t saved_offset;
2805 *pfree_lg_srcv = NULL;
2812#if COAP_Q_BLOCK_SUPPORT
2815 coap_add_data(response,
sizeof(
"Block1 + Q-Block1 together")-1,
2816 (
const uint8_t *)
"Block1 + Q-Block1 together");
2818 goto skip_app_handler;
2822#if COAP_Q_BLOCK_SUPPORT
2828 if (!block_option ||
2831 goto call_app_handler;
2857 goto skip_app_handler;
2861 offset = block.
num << (block.
szx + 4);
2864#
if COAP_Q_BLOCK_SUPPORT
2883 if (total < (length + offset + (block.
m ? 1 : 0)))
2884 total = length + offset + (block.m ? 1 : 0);
2886 *added_block = block.
m;
2888 goto call_app_handler;
2894 LL_FOREACH(session->
lg_srcv, p) {
2895 if (rtag_opt || p->
rtag_set == 1) {
2896 if (!(rtag_opt && p->
rtag_set == 1))
2899 memcmp(p->
rtag, rtag, rtag_length) != 0)
2913 (
const uint8_t *)
"Missing block 0");
2915 goto skip_app_handler;
2923 (
const uint8_t *)
"Memory issue");
2925 goto skip_app_handler;
2938 if (!block.
bert && block.
num == 0 && max_block_szx != 0 &&
2939 max_block_szx < block.
szx) {
2940 p->
szx = max_block_szx;
2956 LL_PREPEND(session->
lg_srcv, p);
2963 (
const uint8_t *)
"Missing interim block");
2965 goto skip_app_handler;
2969 coap_add_data(response,
sizeof(
"Content-Format mismatch")-1,
2970 (
const uint8_t *)
"Content-Format mismatch");
2975#if COAP_Q_BLOCK_SUPPORT
2979 (
const uint8_t *)
"Size1 mismatch");
2992 chunk = (size_t)1 << (block.
szx + 4);
2994 saved_num = block.
num;
2995 saved_offset = offset;
2997 while (offset < saved_offset + length) {
3002 coap_add_data(response,
sizeof(
"Too many missing blocks")-1,
3003 (
const uint8_t *)
"Too many missing blocks");
3010 offset = block.
num << (block.
szx + 4);
3016#if COAP_Q_BLOCK_SUPPORT
3020 if (p->
total_len < saved_offset + length) {
3027 (
const uint8_t *)
"Memory issue");
3029 goto skip_app_handler;
3035 (uint32_t)(p->
total_len + chunk -1)/chunk)) {
3040#if COAP_Q_BLOCK_SUPPORT
3043 (uint32_t)(p->
total_len + chunk -1)/chunk)) {
3054 goto skip_app_handler;
3058 goto skip_app_handler;
3064 if (!block.
bert && saved_num == 0 && max_block_szx != 0 &&
3065 max_block_szx < block.
aszx) {
3066 block.
aszx = max_block_szx;
3076 (uint32_t)(p->
total_len + chunk -1)/chunk)) {
3103#if COAP_Q_BLOCK_SUPPORT
3122#if COAP_Q_BLOCK_SUPPORT
3126 goto skip_app_handler;
3153 LL_DELETE(session->
lg_srcv, p);
3161#if COAP_CLIENT_SUPPORT
3162#if COAP_Q_BLOCK_SUPPORT
3164derive_cbor_value(
const uint8_t **bp,
size_t rem_len) {
3165 uint32_t value = **bp & 0x1f;
3169 }
else if (value == 24) {
3171 return (uint32_t)-1;
3175 }
else if (value == 25) {
3177 return (uint32_t)-1;
3185 return (uint32_t)-1;
3188 value |= **bp << 16;
3206 if (sent || lg_xmit || lg_crcv) {
3210 const uint8_t *data;
3220 }
else if (lg_xmit) {
3221 sent = &lg_xmit->
pdu;
3223 size_t blk_size = (size_t)1 << (lg_xmit->
blk_size + 4);
3224 size_t offset = (lg_xmit->
last_block + 1) * blk_size;
3226 data = &lg_xmit->
data[offset];
3227 data_len = (lg_xmit->
length - offset) > blk_size ? blk_size :
3228 lg_xmit->length - offset;
3231 sent = &lg_crcv->
pdu;
3253 track_fetch_observe(echo_pdu, lg_crcv, 0, &echo_pdu->
actual_token);
3254#if COAP_OSCORE_SUPPORT
3255 if (session->oscore_encryption &&
3312 uint64_t token_match =
3317 LL_FOREACH_SAFE(session->
lg_xmit, p, q) {
3327 size_t chunk = (size_t)1 << (p->
blk_size + 4);
3334 coap_log_debug(
"found Block option, block is BERT, block nr. %u (%zu)\n",
3337 coap_log_debug(
"found Block option, block size is %u, block nr. %u\n",
3338 1 << (block.
szx + 4), block.
num);
3345 }
else if ((p->
offset + chunk) % ((
size_t)1 << (block.
szx + 4)) == 0) {
3350 block.
num = (uint32_t)(((p->
offset + chunk) >> (block.
szx + 4)) - 1);
3352 chunk = (size_t)1 << (p->
blk_size + 4);
3354 coap_log_debug(
"new Block size is %u, block number %u completed\n",
3355 1 << (block.
szx + 4), block.
num);
3360 "next block is not aligned on requested block size boundary. "
3361 "(%zu x %u mod %u = %zu != 0)\n",
3363 (1 << (block.
szx + 4)),
3364 (p->
offset + chunk) % ((
size_t)1 << (block.
szx + 4)));
3367 track_echo(session, rcvd);
3395 LL_FOREACH(session->
lg_crcv, lg_crcv) {
3401 new_token = track_fetch_observe(&p->
pdu, lg_crcv, block.
num + 1,
3404 assert(len <=
sizeof(buf));
3406 memcpy(buf, new_token->
s, len);
3418 size_t token_options = pdu->
data ? (size_t)(pdu->
data - pdu->
token) :
3421 ((pdu->
max_size - token_options) /1024) * 1024;
3439#if COAP_Q_BLOCK_SUPPORT
3442 if (coap_send_q_block1(session, block, pdu,
3462 int observe_action = -1;
3465 goto lg_xmit_finished;
3475 goto lg_xmit_finished;
3483 goto lg_xmit_finished;
3485 if (check_freshness(session, rcvd, sent, p, NULL))
3487#if COAP_Q_BLOCK_SUPPORT
3496 const uint8_t *data;
3501 uint16_t fmt = fmt_opt ?
3511 coap_log_debug(
"Unexpected 4.08 - protocol violation - ignore\n");
3517 const uint8_t *bp = data;
3523 size_t ltoken_length;
3525 for (i = 0; (bp < data + length) &&
3527 if ((*bp & 0xc0) != 0x00)
3529 block.
num = derive_cbor_value(&bp, data + length - bp);
3531 if (block.
num > (1 << 20) -1)
3533 block.
m = (block.
num + 1) * chunk < p->length;
3563 coap_log_info(
"Invalid application/missing-blocks+cbor-seq\n");
3566 goto lg_xmit_finished;
3576 LL_FOREACH(session->
lg_crcv, lg_crcv) {
3605 LL_DELETE(session->
lg_xmit, p);
3616 const uint8_t *data,
size_t offset,
size_t total) {
3619 if (body_data == NULL && total) {
3622 if (body_data == NULL)
3626 if (offset + length <= total && body_data->length >= total) {
3627 memcpy(&body_data->
s[offset], data, length);
3643 memcpy(&body_data->
s[offset], data, length);
3652#if COAP_CLIENT_SUPPORT
3672#if COAP_Q_BLOCK_SUPPORT
3676 uint16_t block_opt = 0;
3678 int ack_rst_sent = 0;
3679 uint64_t token_match =
3683 memset(&block, 0,
sizeof(block));
3684#if COAP_Q_BLOCK_SUPPORT
3685 memset(&qblock, 0,
sizeof(qblock));
3687 LL_FOREACH(session->
lg_crcv, p) {
3702 const uint8_t *data;
3705 size_t size2 = size_opt ?
3717#if COAP_Q_BLOCK_SUPPORT
3720 coap_log_warn(
"Both Block1 and Q-Block1 not supported in a response\n");
3726 if (!(session->
block_mode & COAP_BLOCK_HAS_Q_BLOCK)) {
3731 track_echo(session, rcvd);
3732 if (have_block && (block.
m || length)) {
3736 uint16_t fmt = fmt_opt ?
3743 size_t saved_offset;
3756 goto expire_lg_crcv;
3759 chunk = (size_t)1 << (block.
szx + 4);
3760 offset = block.
num * chunk;
3761 if (size2 < (offset + length)) {
3763 size2 = offset + length + 1;
3765 size2 = offset + length;
3767 saved_offset = offset;
3770#if COAP_Q_BLOCK_SUPPORT
3791#if COAP_Q_BLOCK_SUPPORT
3809#if COAP_Q_BLOCK_SUPPORT
3814 coap_log_warn(
"Data body updated during receipt - new request started\n");
3831 (0 << 4) | (0 << 3) | block.
aszx),
3837 goto skip_app_handler;
3849#if COAP_Q_BLOCK_SUPPORT
3855 if (block.
num == 0) {
3868 while (offset < saved_offset + length) {
3870#if COAP_Q_BLOCK_SUPPORT
3874 coap_log_debug(
"found Block option, block size is %u, block nr. %u\n",
3875 1 << (block.
szx + 4), block.
num);
3876#if COAP_Q_BLOCK_SUPPORT
3878 this_payload_set > p->
rec_blocks.processing_payload_set &&
3879 this_payload_set != p->
rec_blocks.latest_payload_set) {
3880 coap_request_missing_q_block2(session, p);
3882 p->
rec_blocks.latest_payload_set = this_payload_set;
3892 offset = block.
num << (block.
szx + 4);
3898 if (updated_block) {
3900 if (size2 < saved_offset + length) {
3901 size2 = saved_offset + length;
3904 saved_offset, size2);
3910 (size2 + chunk -1) / chunk)) {
3917#if COAP_Q_BLOCK_SUPPORT
3921 (size2 + chunk -1) / chunk)) {
3924 if (check_all_blocks_in_for_payload_set(session,
3930 if (check_any_blocks_next_payload_set(session,
3933 coap_request_missing_q_block2(session, p);
3934 goto skip_app_handler;
3939 goto skip_app_handler;
3943 goto skip_app_handler;
3964 ((block.
num + 1) << 4) |
3965 (block.
m << 3) | block.
aszx),
3970 coap_add_data_large_internal(session, NULL, pdu, NULL, NULL, -1, 0, length, data, NULL, NULL, 0, 0);
3976 goto skip_app_handler;
3981#if COAP_Q_BLOCK_SUPPORT
3997 goto call_app_handler;
3999#if COAP_Q_BLOCK_SUPPORT
4010#if COAP_Q_BLOCK_SUPPORT
4020#if COAP_Q_BLOCK_SUPPORT
4059 LL_DELETE(session->
lg_crcv, p);
4061 goto skip_app_handler;
4071 goto skip_app_handler;
4089 goto expire_lg_crcv;
4094#if COAP_OSCORE_SUPPORT
4095 if (check_freshness(session, rcvd,
4096 (session->oscore_encryption == 0) ? sent : NULL,
4099 if (check_freshness(session, rcvd, sent, NULL, p))
4101 goto skip_app_handler;
4102 goto expire_lg_crcv;
4105 goto expire_lg_crcv;
4127#
if COAP_Q_BLOCK_SUPPORT
4134 goto skip_app_handler;
4138#if COAP_Q_BLOCK_SUPPORT
4139 if (session->
block_mode & COAP_BLOCK_PROBE_Q_BLOCK) {
4145 if (block.
num != 0) {
4148 const uint8_t *data;
4149 size_t chunk = (size_t)1 << (block.
szx + 4);
4154 goto call_app_handler;
4157#if COAP_Q_BLOCK_SUPPORT
4161 if (!(session->
block_mode & COAP_BLOCK_HAS_Q_BLOCK)) {
4170 LL_PREPEND(session->
lg_crcv, lg_crcv);
4175 track_echo(session, rcvd);
4180 LL_PREPEND(session->
lg_crcv, lg_crcv);
4204 LL_DELETE(session->
lg_crcv, p);
4217#if COAP_SERVER_SUPPORT
4226 if (response->
code == 0)
4229 if (lg_xmit && lg_xmit->
pdu.
code == 0) {
4236#if COAP_CLIENT_SUPPORT
4239 uint64_t token_match =
4246 LL_FOREACH(session->
lg_crcv, lg_crcv) {
4259 LL_FOREACH(session->
lg_xmit, lg_xmit) {
COAP_STATIC_INLINE int full_match(const uint8_t *a, size_t alen, const uint8_t *b, size_t blen)
static int coap_add_data_large_internal(coap_session_t *session, const coap_pdu_t *request, coap_pdu_t *pdu, coap_resource_t *resource, const coap_string_t *query, int maxage, uint64_t etag, size_t length, const uint8_t *data, coap_release_large_data_t release_func, void *app_ptr, int single_request, coap_pdu_code_t request_method)
#define STATE_TOKEN_FULL(t, r)
static int check_all_blocks_in(coap_rblock_t *rec_blocks, size_t total_blocks)
#define STATE_TOKEN_BASE(t)
static int update_received_blocks(coap_rblock_t *rec_blocks, uint32_t block_num)
static int setup_block_b(coap_session_t *session, coap_pdu_t *pdu, coap_block_b_t *block, unsigned int num, unsigned int blk_size, size_t total)
static int check_if_received_block(coap_rblock_t *rec_blocks, uint32_t block_num)
int coap_flsll(long long j)
int coap_fls(unsigned int i)
unsigned char coap_key_t[4]
#define coap_hash(String, Length, Result)
@ COAP_NACK_TOO_MANY_RETRIES
Library specific build wrapper for coap_internal.h.
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().
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...
#define coap_lock_callback_ret_release(r, c, func, failed)
#define coap_lock_unlock(c)
#define coap_lock_lock(c, failed)
#define coap_lock_callback(c, func)
#define coap_lock_check_locked(c)
coap_mid_t coap_send_rst_lkd(coap_session_t *session, const coap_pdu_t *request)
Sends an RST message with code 0 for the specified request to dst.
coap_mid_t coap_send_ack_lkd(coap_session_t *session, const coap_pdu_t *request)
Sends an ACK message with code 0 for the specified request to dst.
int coap_add_data_large_response_lkd(coap_resource_t *resource, coap_session_t *session, const coap_pdu_t *request, coap_pdu_t *response, const coap_string_t *query, uint16_t media_type, int maxage, uint64_t etag, size_t length, const uint8_t *data, coap_release_large_data_t release_func, void *app_ptr)
Associates given data with the response pdu that is passed as fourth parameter.
int coap_context_set_max_block_size_lkd(coap_context_t *context, size_t max_block_size)
Set the context level maximum block size that the server supports when sending or receiving packets w...
void coap_block_delete_lg_srcv(coap_session_t *session, coap_lg_srcv_t *lg_srcv)
void coap_context_set_block_mode_lkd(coap_context_t *context, uint32_t block_mode)
Set the context level CoAP block handling bits for handling RFC7959.
int coap_block_check_lg_crcv_timeouts(coap_session_t *session, coap_tick_t now, coap_tick_t *tim_rem)
int coap_block_check_lg_srcv_timeouts(coap_session_t *session, coap_tick_t now, coap_tick_t *tim_rem)
#define COAP_BLOCK_MAX_SIZE_SET(a)
void coap_block_delete_lg_crcv(coap_session_t *session, coap_lg_crcv_t *lg_crcv)
int coap_handle_response_get_block(coap_context_t *context, coap_session_t *session, coap_pdu_t *sent, coap_pdu_t *rcvd, coap_recurse_t recursive)
void coap_check_code_lg_xmit(const coap_session_t *session, const coap_pdu_t *request, coap_pdu_t *response, const coap_resource_t *resource, const coap_string_t *query)
The function checks that the code in a newly formed lg_xmit created by coap_add_data_large_response_l...
int coap_handle_response_send_block(coap_session_t *session, coap_pdu_t *sent, coap_pdu_t *rcvd)
coap_mid_t coap_retransmit_oscore_pdu(coap_session_t *session, coap_pdu_t *pdu, coap_opt_t *echo)
int coap_add_data_large_request_lkd(coap_session_t *session, coap_pdu_t *pdu, size_t length, const uint8_t *data, coap_release_large_data_t release_func, void *app_ptr)
Associates given data with the pdu that is passed as second parameter.
void coap_check_update_token(coap_session_t *session, coap_pdu_t *pdu)
The function checks if the token needs to be updated before PDU is presented to the application (only...
void coap_block_delete_lg_xmit(coap_session_t *session, coap_lg_xmit_t *lg_xmit)
#define COAP_SINGLE_BLOCK_OR_Q
int coap_handle_request_put_block(coap_context_t *context, coap_session_t *session, coap_pdu_t *pdu, coap_pdu_t *response, coap_resource_t *resource, coap_string_t *uri_path, coap_opt_t *observe, int *added_block, coap_lg_srcv_t **free_lg_srcv)
#define COAP_BLOCK_SET_MASK
coap_lg_xmit_t * coap_find_lg_xmit_response(const coap_session_t *session, const coap_pdu_t *request, const coap_resource_t *resource, const coap_string_t *query)
coap_lg_crcv_t * coap_block_new_lg_crcv(coap_session_t *session, coap_pdu_t *pdu, coap_lg_xmit_t *lg_xmit)
int coap_handle_request_send_block(coap_session_t *session, coap_pdu_t *pdu, coap_pdu_t *response, coap_resource_t *resource, coap_string_t *query)
#define COAP_BLOCK_MAX_SIZE_GET(a)
int coap_block_check_lg_xmit_timeouts(coap_session_t *session, coap_tick_t now, coap_tick_t *tim_rem)
COAP_API void coap_context_set_block_mode(coap_context_t *context, uint32_t block_mode)
Set the context level CoAP block handling bits for handling RFC7959.
COAP_API int coap_add_data_large_response(coap_resource_t *resource, coap_session_t *session, const coap_pdu_t *request, coap_pdu_t *response, const coap_string_t *query, uint16_t media_type, int maxage, uint64_t etag, size_t length, const uint8_t *data, coap_release_large_data_t release_func, void *app_ptr)
Associates given data with the response pdu that is passed as fourth parameter.
#define COAP_BLOCK_USE_M_Q_BLOCK
#define COAP_OPT_BLOCK_SZX(opt)
Returns the value of the SZX-field of a Block option opt.
#define COAP_BLOCK_STLESS_BLOCK2
COAP_API int coap_add_data_large_request(coap_session_t *session, coap_pdu_t *pdu, size_t length, const uint8_t *data, coap_release_large_data_t release_func, void *app_ptr)
Associates given data with the pdu that is passed as second parameter.
#define COAP_BLOCK_TRY_Q_BLOCK
#define COAP_BLOCK_STLESS_FETCH
COAP_API int coap_context_set_max_block_size(coap_context_t *context, size_t max_block_size)
Set the context level maximum block size that the server supports when sending or receiving packets w...
int coap_add_block_b_data(coap_pdu_t *pdu, size_t len, const uint8_t *data, coap_block_b_t *block)
Adds the appropriate payload data of the body to the pdu.
#define COAP_BLOCK_SINGLE_BODY
int coap_write_block_b_opt(coap_session_t *session, coap_block_b_t *block, coap_option_num_t number, coap_pdu_t *pdu, size_t data_length)
Writes a block option of type number to message pdu.
int coap_add_block(coap_pdu_t *pdu, size_t len, const uint8_t *data, unsigned int block_num, unsigned char block_szx)
Adds the block_num block of size 1 << (block_szx + 4) from source data to pdu.
void(* coap_release_large_data_t)(coap_session_t *session, void *app_ptr)
Callback handler for de-allocating the data based on app_ptr provided to coap_add_data_large_*() func...
void coap_add_data_blocked_response(const coap_pdu_t *request, coap_pdu_t *response, uint16_t media_type, int maxage, size_t length, const uint8_t *data)
Adds the appropriate part of data to the response pdu.
int coap_get_block_b(const coap_session_t *session, const coap_pdu_t *pdu, coap_option_num_t number, coap_block_b_t *block)
Initializes block from pdu.
#define COAP_OPT_BLOCK_MORE(opt)
Returns the value of the More-bit of a Block option opt.
unsigned int coap_opt_block_num(const coap_opt_t *block_opt)
Returns the value of field num in the given block option block_opt.
int coap_get_block(const coap_pdu_t *pdu, coap_option_num_t number, coap_block_t *block)
Initializes block from pdu.
#define COAP_BLOCK_NOT_RANDOM_BLOCK1
#define COAP_OPT_BLOCK_END_BYTE(opt)
Returns the value of the last byte of opt.
int coap_q_block_is_supported(void)
Returns 1 if libcoap was built with option Q-BlockX support, 0 otherwise.
int coap_write_block_opt(coap_block_t *block, coap_option_num_t number, coap_pdu_t *pdu, size_t data_length)
Writes a block option of type number to message pdu.
coap_binary_t * coap_block_build_body(coap_binary_t *body_data, size_t length, const uint8_t *data, size_t offset, size_t total)
Re-assemble payloads into a body.
#define COAP_BLOCK_USE_LIBCOAP
int coap_digest_final(coap_digest_ctx_t *digest_ctx, coap_digest_t *digest_buffer)
Finalize the coap_digest information into the provided digest_buffer.
int coap_digest_update(coap_digest_ctx_t *digest_ctx, const uint8_t *data, size_t data_len)
Update the coap_digest information with the next chunk of data.
coap_digest_ctx_t * coap_digest_setup(void)
Initialize a coap_digest.
time_t coap_time_t
CoAP time in seconds since epoch.
uint64_t coap_tick_t
This data type represents internal timer ticks with COAP_TICKS_PER_SECOND resolution.
coap_time_t coap_ticks_to_rt(coap_tick_t t)
Helper function that converts coap ticks to wallclock time.
#define COAP_TICKS_PER_SECOND
Use ms resolution on POSIX systems.
int coap_handle_event_lkd(coap_context_t *context, coap_event_t event, coap_session_t *session)
Invokes the event handler of context for the given event and data.
uint16_t coap_new_message_id_lkd(coap_session_t *session)
Returns a new message id and updates session->tx_mid accordingly.
int coap_client_delay_first(coap_session_t *session)
Delay the sending of the first client request until some other negotiation has completed.
coap_mid_t coap_send_internal(coap_session_t *session, coap_pdu_t *pdu)
Sends a CoAP message to given peer.
void coap_ticks(coap_tick_t *)
Returns the current value of an internal tick counter.
@ COAP_RESPONSE_FAIL
Response not liked - send CoAP RST packet.
unsigned int coap_encode_var_safe(uint8_t *buf, size_t length, unsigned int val)
Encodes multiple-length byte sequences.
unsigned int coap_decode_var_bytes(const uint8_t *buf, size_t len)
Decodes multiple-length byte sequences.
uint64_t coap_decode_var_bytes8(const uint8_t *buf, size_t len)
Decodes multiple-length byte sequences.
unsigned int coap_encode_var_safe8(uint8_t *buf, size_t length, uint64_t val)
Encodes multiple-length byte sequences.
@ COAP_EVENT_PARTIAL_BLOCK
Triggered when not all of a large body has been received.
@ COAP_EVENT_XMIT_BLOCK_FAIL
Triggered when not all of a large body has been transmitted.
#define coap_log_debug(...)
void coap_show_pdu(coap_log_t level, const coap_pdu_t *pdu)
Display the contents of the specified pdu.
const char * coap_session_str(const coap_session_t *session)
Get session description.
#define coap_log_info(...)
#define coap_log_warn(...)
#define COAP_OBSERVE_CANCEL
The value COAP_OBSERVE_CANCEL in a GET/FETCH request option COAP_OPTION_OBSERVE indicates that the ob...
#define COAP_OBSERVE_ESTABLISH
The value COAP_OBSERVE_ESTABLISH in a GET/FETCH request option COAP_OPTION_OBSERVE indicates a new ob...
COAP_API int coap_cancel_observe(coap_session_t *session, coap_binary_t *token, coap_pdu_type_t message_type)
Cancel an observe that is being tracked by the client large receive logic.
coap_opt_t * coap_option_next(coap_opt_iterator_t *oi)
Updates the iterator oi to point to the next option.
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_set(coap_opt_filter_t *filter, coap_option_num_t option)
Sets the corresponding entry for number in filter.
int coap_rebuild_pdu_for_proxy(coap_pdu_t *pdu)
Convert PDU to use Proxy-Scheme option if Proxy-Uri option is present.
size_t coap_oscore_overhead(coap_session_t *session, coap_pdu_t *pdu)
Determine the additional data size requirements for adding in OSCORE.
#define COAP_PDU_IS_RESPONSE(pdu)
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.
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.
coap_pdu_t * coap_pdu_duplicate_lkd(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_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.
#define COAP_PDU_IS_REQUEST(pdu)
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_BLOCK2
const char * coap_response_phrase(unsigned char code)
Returns a human-readable response phrase for the specified CoAP response code.
#define COAP_MEDIATYPE_APPLICATION_MB_CBOR_SEQ
#define COAP_OPTION_CONTENT_FORMAT
#define COAP_OPTION_SIZE2
#define COAP_OPTION_BLOCK1
#define COAP_OPTION_Q_BLOCK1
void coap_delete_pdu(coap_pdu_t *pdu)
Dispose of an CoAP PDU and frees associated storage.
int coap_mid_t
coap_mid_t is used to store the CoAP Message ID of a CoAP PDU.
#define COAP_OPTION_URI_PATH
#define COAP_RESPONSE_CODE(N)
#define COAP_RESPONSE_CLASS(C)
coap_pdu_code_t
Set of codes available for a PDU.
#define COAP_OPTION_SIZE1
coap_pdu_type_t
CoAP PDU message type definitions.
#define COAP_MEDIATYPE_TEXT_PLAIN
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_CONTENT_TYPE
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_OPTION_Q_BLOCK2
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.
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.
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.
#define COAP_INVALID_MID
Indicates an invalid message id.
#define COAP_OPTION_MAXAGE
#define COAP_OPTION_OBSERVE
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_REQUEST_CODE_FETCH
#define COAP_NON_RECEIVE_TIMEOUT_TICKS(s)
The NON_RECEIVE_TIMEOUT definition for the session (s).
#define COAP_NON_TIMEOUT_TICKS(s)
#define COAP_MAX_TRANSMIT_WAIT_TICKS(s)
#define COAP_NON_PARTIAL_TIMEOUT_TICKS(s)
The NON_PARTIAL_TIMEOUT definition for the session (s).
coap_tick_t coap_get_non_timeout_random_ticks(coap_session_t *session)
#define COAP_MAX_PAYLOADS(s)
size_t coap_session_max_pdu_size_lkd(const coap_session_t *session)
Get maximum acceptable PDU size.
#define COAP_NON_MAX_RETRANSMIT(s)
#define COAP_PROTO_NOT_RELIABLE(p)
#define COAP_PROTO_RELIABLE(p)
void coap_session_new_token(coap_session_t *session, size_t *len, uint8_t *data)
Creates a new token for use.
@ COAP_SESSION_TYPE_CLIENT
client-side
void coap_delete_bin_const(coap_bin_const_t *s)
Deletes the given const binary data and releases any memory allocated.
void coap_delete_str_const(coap_str_const_t *s)
Deletes the given const string and releases any memory allocated.
coap_binary_t * coap_new_binary(size_t size)
Returns a new binary object with at least size bytes storage allocated.
coap_bin_const_t * coap_new_bin_const(const uint8_t *data, size_t size)
Take the specified byte array (text) and create a coap_bin_const_t * Returns a new const binary objec...
coap_binary_t * coap_resize_binary(coap_binary_t *s, size_t size)
Resizes the given coap_binary_t object.
void coap_delete_binary(coap_binary_t *s)
Deletes the given coap_binary_t object and releases any memory allocated.
#define coap_binary_equal(binary1, binary2)
Compares the two binary data for equality.
#define coap_string_equal(string1, string2)
Compares the two strings for equality.
coap_string_t * coap_new_string(size_t size)
Returns a new string object with at least size+1 bytes storage allocated.
coap_str_const_t * coap_new_str_const(const uint8_t *data, size_t size)
Returns a new const string object with at least size+1 bytes storage allocated, and the provided data...
void coap_delete_string(coap_string_t *s)
Deletes the given string and releases any memory allocated.
int coap_cancel_observe_lkd(coap_session_t *session, coap_binary_t *token, coap_pdu_type_t message_type)
Cancel an observe that is being tracked by the client large receive logic.
#define COAP_STATIC_INLINE
CoAP binary data definition with const data.
size_t length
length of binary data
const uint8_t * s
read-only binary data
CoAP binary data definition.
size_t length
length of binary data
Structure of Block options with BERT support.
unsigned int num
block number
uint32_t chunk_size
1024 if BERT
unsigned int bert
Operating as BERT.
unsigned int aszx
block size (0-7 including BERT
unsigned int defined
Set if block found.
unsigned int m
1 if more blocks follow, 0 otherwise
unsigned int szx
block size (0-6)
Structure of Block options.
unsigned int num
block number
unsigned int szx
block size
unsigned int m
1 if more blocks follow, 0 otherwise
The CoAP stack's global state is stored in a coap_context_t object.
uint64_t etag
Next ETag to use.
coap_nack_handler_t nack_handler
Called when a response issue has occurred.
coap_response_handler_t response_handler
Called when a response is received.
uint32_t block_mode
Zero or more COAP_BLOCK_ or'd options.
coap_resource_t * proxy_uri_resource
can be used for handling proxy URI resources
coap_resource_t * unknown_resource
can be used for handling unknown resources
uint64_t state_token
state token
size_t bert_size
size of last BERT block
uint32_t count
the number of packets sent for payload
coap_binary_t * app_token
original PDU token
coap_pdu_code_t request_method
Method used to request this data.
uint8_t rtag_length
RTag length.
coap_string_t * query
Associated query for the resource.
coap_resource_t * resource
associated resource
coap_time_t maxage_expire
When this entry expires.
uint8_t rtag_set
Set if RTag is in receive PDU.
uint8_t rtag[8]
RTag for block checking.
Structure to hold large body (many blocks) client receive information.
uint16_t block_option
Block option in use.
uint8_t etag[8]
ETag for block checking.
uint8_t etag_length
ETag length.
uint8_t last_type
Last request type (CON/NON)
uint8_t observe_length
Length of observe data.
uint8_t observe[3]
Observe data (if observe_set) (only 24 bits)
uint8_t etag_set
Set if ETag is in receive PDU.
uint8_t initial
If set, has not been used yet.
uint8_t szx
size of individual blocks
uint16_t o_block_option
Block CoAP option used when initiating Observe.
uint16_t content_format
Content format for the set of blocks.
coap_pdu_t pdu
skeletal PDU
uint8_t o_blk_size
Block size used when initiating Observe.
coap_tick_t last_used
< list of received blocks
coap_bin_const_t ** obs_token
Tokens used in setting up Observe (to handle large FETCH)
uint64_t state_token
state token
coap_binary_t * app_token
app requesting PDU token
uint16_t retry_counter
Retry counter (part of state token)
coap_binary_t * body_data
Used for re-assembling entire body.
size_t obs_token_cnt
number of tokens used to set up Observe
uint8_t observe_set
Set if this is an observe receive PDU.
size_t total_len
Length as indicated by SIZE2 option.
Structure to hold large body (many blocks) server receive information.
uint8_t rtag[8]
RTag for block checking.
coap_mid_t last_mid
Last received mid for this set of packets.
uint8_t rtag_set
Set if RTag is in receive PDU.
uint16_t block_option
Block option in use.
size_t total_len
Length as indicated by SIZE1 option.
uint8_t observe_length
Length of observe data.
coap_rblock_t rec_blocks
set to uri_path if unknown resource
uint8_t no_more_seen
Set if block with more not set seen.
coap_binary_t * body_data
Used for re-assembling entire body.
coap_resource_t * resource
associated resource
uint8_t observe_set
Set if this is an observe receive PDU.
uint8_t rtag_length
RTag length.
uint8_t last_type
Last request type (CON/NON)
uint8_t szx
size of individual blocks
coap_tick_t last_used
Last time data sent or 0.
uint8_t observe[3]
Observe data (if set) (only 24 bits)
uint16_t content_format
Content format for the set of blocks.
coap_bin_const_t * last_token
< list of received blocks
coap_str_const_t * uri_path
Structure to hold large body (many blocks) transmission information.
coap_tick_t last_all_sent
Last time all data sent or 0.
coap_release_large_data_t release_func
large data de-alloc function
uint8_t blk_size
large block transmission size
coap_tick_t last_sent
Last time any data sent.
union coap_lg_xmit_t::@1 b
const uint8_t * data
large data ptr
int last_block
last acknowledged block number Block1 last transmitted Q-Block2
coap_tick_t last_payload
Last time MAX_PAYLOAD was sent or 0.
size_t offset
large data next offset to transmit
coap_pdu_t pdu
skeletal PDU
size_t length
large data length
uint16_t option
large block transmisson CoAP option
void * app_ptr
applicaton provided ptr for de-alloc function
coap_tick_t last_obs
Last time used (Observe tracking) or 0.
Iterator to run through PDU options.
coap_option_num_t number
decoded option number
uint8_t max_hdr_size
space reserved for protocol-specific header
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)
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
size_t body_total
Holds body data total size.
coap_pdu_type_t type
message type
Structure to keep track of received blocks.
struct coap_lg_range range[COAP_RBLOCK_CNT]
Abstraction of resource that can be attached to coap_context_t.
Abstraction of virtual session that can be attached to coap_context_t (client) or coap_endpoint_t (se...
coap_lg_xmit_t * lg_xmit
list of large transmissions
uint32_t block_mode
Zero or more COAP_BLOCK_ or'd options.
uint8_t csm_bert_rem_support
CSM TCP BERT blocks supported (remote)
uint64_t tx_token
Next token number to use.
coap_mid_t remote_test_mid
mid used for checking remote support
uint8_t csm_bert_loc_support
CSM TCP BERT blocks supported (local)
coap_proto_t proto
protocol used
uint8_t con_active
Active CON request sent.
coap_queue_t * delayqueue
list of delayed messages waiting to be sent
uint32_t tx_rtag
Next Request-Tag number to use.
coap_lg_srcv_t * lg_srcv
Server list of expected large receives.
coap_lg_crcv_t * lg_crcv
Client list of expected large receives.
coap_session_type_t type
client or server side socket
coap_context_t * context
session's context
coap_bin_const_t * echo
last token used to make a request
CoAP string data definition.
size_t length
length of string