RIOT-OS/RIOT
RIOT-OS/RIOT
1
0
Fork 0
mirror of https://github.com/RIOT-OS/RIOT.git synced 2025-01-17 05:12:57 +01:00
Code Releases Activity

examples,tests: update users of deprecated nanocoap APIs

Browse Source
This commit is contained in:
Marian Buschsieweke 2024-10-15 16:51:02 +02:00
parent 39ae267d96
commit 32575402c7
No known key found for this signature in database
GPG Key ID: 758BD52517F79C41
7 changed files with 51 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
examples/nanocoap_server/coap_handler.c
View File

@ -10,14 +10,17 @@
#include <stdio.h>
#include <string.h>
#include "event/callback.h"
#include "event/timeout.h"
#include "event/thread.h"
#include "fmt.h"
#include "net/nanocoap.h"
#include "net/nanocoap_sock.h"
#include "hashes/sha256.h"
#include "kernel_defines.h"
#if MODULE_EVENT_THREAD
# include "event.h"
# include "event/thread.h"
# include "event/timeout.h"
# include "event/callback.h"
#endif
/* internal value that can be read/written via CoAP */
static uint8_t internal_value = 0;
@ -158,7 +161,7 @@ ssize_t _sha256_handler(coap_pkt_t* pkt, uint8_t *buf, size_t len, coap_request_
return reply_len;
}
uint8_t *pkt_pos = (uint8_t*)pkt->hdr + reply_len;
uint8_t *pkt_pos = pkt->buf + reply_len;
if (blockwise) {
pkt_pos += coap_opt_put_block1_control(pkt_pos, 0, &block1);
}
@ -167,7 +170,7 @@ ssize_t _sha256_handler(coap_pkt_t* pkt, uint8_t *buf, size_t len, coap_request_
pkt_pos += fmt_bytes_hex((char *)pkt_pos, digest, sizeof(digest));
}
return pkt_pos - (uint8_t*)pkt->hdr;
return pkt_pos - pkt->buf;
}
NANOCOAP_RESOURCE(echo) {

15
tests/net/nanocoap_cli/nanocli_client.c
View File

@ -93,8 +93,7 @@ static int _cmd_client(int argc, char **argv)
{
/* Ordered like the RFC method code numbers, but off by 1. GET is code 0. */
const char *method_codes[] = {"get", "post", "put"};
unsigned buflen = 128;
uint8_t buf[buflen];
uint8_t buf[128];
coap_pkt_t pkt;
size_t len;
@ -113,14 +112,14 @@ static int _cmd_client(int argc, char **argv)
goto end;
}
pkt.hdr = (coap_hdr_t *)buf;
pkt.buf = buf;
/* parse options */
if (argc == 5 || argc == 6) {
ssize_t hdrlen = coap_build_hdr(pkt.hdr, COAP_TYPE_CON,
_client_token, _client_token_len,
code_pos+1, 1);
coap_pkt_init(&pkt, &buf[0], buflen, hdrlen);
ssize_t hdrlen = coap_build_udp_hdr(buf, sizeof(buf), COAP_TYPE_CON,
_client_token, _client_token_len,
code_pos + 1, 1);
coap_pkt_init(&pkt, &buf[0], sizeof(buf), hdrlen);
coap_opt_add_string(&pkt, COAP_OPT_URI_PATH, argv[4], '/');
if (argc == 6) {
coap_opt_add_uint(&pkt, COAP_OPT_CONTENT_FORMAT, COAP_FORMAT_TEXT);
@ -137,7 +136,7 @@ static int _cmd_client(int argc, char **argv)
printf("nanocli: sending msg ID %u, %" PRIuSIZE " bytes\n", coap_get_id(&pkt),
len);
ssize_t res = _send(&pkt, buflen, argv[2], argv[3]);
ssize_t res = _send(&pkt, sizeof(buf), argv[2], argv[3]);
if (res < 0) {
printf("nanocli: msg send failed: %" PRIdSIZE "\n", res);
}

2
tests/net/nanocoap_cli/nanocli_server.c
View File

@ -65,7 +65,7 @@ static int _nanocoap_server(sock_udp_ep_t *local, uint8_t *buf, size_t bufsize,
.remote = &remote,
};
if (coap_parse(&pkt, (uint8_t *)buf, res) < 0) {
if (coap_parse_udp(&pkt, (uint8_t *)buf, res) < 0) {
DEBUG("nanocoap: error parsing packet\n");
continue;
}

11
tests/pkg/edhoc_c/initiator.c
View File

@ -20,9 +20,7 @@
#include <stdio.h>
#include "net/gnrc/netif.h"
#include "net/ipv6.h"
#include "net/nanocoap_sock.h"
#include "shell.h"
#include "edhoc/edhoc.h"
#include "edhoc_keys.h"
@ -33,9 +31,6 @@
#include "tinycrypt/sha256.h"
#endif
#define ENABLE_DEBUG 0
#include "debug.h"
#define COAP_BUF_SIZE (256U)
#if IS_ACTIVE(CONFIG_INITIATOR)
@ -114,11 +109,9 @@ static ssize_t _build_coap_pkt(coap_pkt_t *pkt, uint8_t *buf, ssize_t buflen,
uint8_t token[2] = { 0xDA, 0xEC };
ssize_t len = 0;
/* set pkt buffer */
pkt->hdr = (coap_hdr_t *)buf;
/* build header, confirmed message always post */
ssize_t hdrlen = coap_build_hdr(pkt->hdr, COAP_TYPE_CON, token,
sizeof(token), COAP_METHOD_POST, 1);
ssize_t hdrlen = coap_build_udp_hdr(buf, buflen, COAP_TYPE_CON, token,
sizeof(token), COAP_METHOD_POST, 1);
coap_pkt_init(pkt, buf, buflen, hdrlen);
coap_opt_add_string(pkt, COAP_OPT_URI_PATH, "/.well-known/edhoc", '/');

5
tests/riotboot_flashwrite/coap_handler.c
View File

@ -8,7 +8,6 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "net/nanocoap.h"
#include "riotboot/flashwrite.h"
@ -72,10 +71,10 @@ ssize_t _flashwrite_handler(coap_pkt_t* pkt, uint8_t *buf, size_t len, coap_requ
return reply_len;
}
uint8_t *pkt_pos = (uint8_t*)pkt->hdr + reply_len;
uint8_t *pkt_pos = pkt->buf + reply_len;
pkt_pos += coap_put_block1_ok(pkt_pos, &block1, 0);
return pkt_pos - (uint8_t*)pkt->hdr;
return pkt_pos - pkt->buf;
}
NANOCOAP_RESOURCE(flashwrite) {

10
tests/unittests/tests-gcoap/tests-gcoap.c
View File

@ -124,7 +124,7 @@ static void test_gcoap__client_get_resp(void)
};
memcpy(buf, pdu_data, sizeof(pdu_data));
res = coap_parse(&pdu, &buf[0], sizeof(pdu_data));
res = coap_parse_udp(&pdu, &buf[0], sizeof(pdu_data));
TEST_ASSERT_EQUAL_INT(sizeof(pdu_data), res);
TEST_ASSERT_EQUAL_INT(COAP_CLASS_SUCCESS, coap_get_code_class(&pdu));
@ -155,7 +155,7 @@ static void test_gcoap__client_put_req(void)
len = coap_opt_finish(&pdu, COAP_OPT_FINISH_PAYLOAD);
memcpy(pdu.payload, payload, 1);
coap_parse(&pdu, buf, len + 1);
coap_parse_udp(&pdu, buf, len + 1);
TEST_ASSERT_EQUAL_INT(COAP_METHOD_PUT, coap_get_code_decimal(&pdu));
TEST_ASSERT_EQUAL_INT(1, pdu.payload_len);
@ -203,7 +203,7 @@ static void test_gcoap__client_get_path_defer(void)
TEST_ASSERT_EQUAL_INT(len,
sizeof(coap_udp_hdr_t) + CONFIG_GCOAP_TOKENLEN + ETAG_SLACK + optlen);
coap_parse(&pdu, buf, len);
coap_parse_udp(&pdu, buf, len);
char uri[CONFIG_NANOCOAP_URI_MAX] = {0};
coap_get_uri_path(&pdu, (uint8_t *)&uri[0]);
@ -249,7 +249,7 @@ static ssize_t _read_cli_stats_req(coap_pkt_t *pdu, uint8_t *buf)
};
memcpy(buf, pdu_data, sizeof(pdu_data));
return coap_parse(pdu, buf, sizeof(pdu_data));
return coap_parse_udp(pdu, buf, sizeof(pdu_data));
}
/* Server GET request success case. Validate request example. */
@ -321,7 +321,7 @@ static ssize_t _read_cli_stats_req_con(coap_pkt_t *pdu, uint8_t *buf)
};
memcpy(buf, pdu_data, sizeof(pdu_data));
return coap_parse(pdu, buf, sizeof(pdu_data));
return coap_parse_udp(pdu, buf, sizeof(pdu_data));
}
/* Server CON GET request success case. Validate request is confirmable. */

50
tests/unittests/tests-nanocoap/tests-nanocoap.c
View File

@ -43,7 +43,7 @@ static void test_nanocoap__hdr(void)
pktpos += coap_opt_put_uri_path(pktpos, COAP_OPT_LOCATION_PATH, path);
coap_pkt_t pkt;
coap_parse(&pkt, &buf[0], pktpos - &buf[0]);
coap_parse_udp(&pkt, &buf[0], pktpos - &buf[0]);
TEST_ASSERT_EQUAL_INT(msgid, coap_get_id(&pkt));
@ -74,7 +74,7 @@ static void test_nanocoap__hdr_2(void)
pktpos += coap_opt_put_uri_pathquery(pktpos, &lastonum, path);
coap_pkt_t pkt;
coap_parse(&pkt, &buf[0], pktpos - &buf[0]);
coap_parse_udp(&pkt, &buf[0], pktpos - &buf[0]);
TEST_ASSERT_EQUAL_INT(msgid, coap_get_id(&pkt));
@ -692,7 +692,7 @@ static ssize_t _read_riot_value_req(coap_pkt_t *pkt, uint8_t *buf)
};
memcpy(buf, pkt_data, sizeof(pkt_data));
return coap_parse(pkt, buf, sizeof(pkt_data));
return coap_parse_udp(pkt, buf, sizeof(pkt_data));
}
/* Server GET request success case. */
@ -750,7 +750,7 @@ static ssize_t _read_riot_value_req_con(coap_pkt_t *pkt, uint8_t *buf)
};
memcpy(buf, pkt_data, sizeof(pkt_data));
return coap_parse(pkt, buf, sizeof(pkt_data));
return coap_parse_udp(pkt, buf, sizeof(pkt_data));
}
/* Builds on test_nanocoap__server_get_req to test confirmable request. */
@ -785,9 +785,9 @@ static void test_nanocoap__server_option_count_overflow_check(void)
{
/* this test passes a forged CoAP packet containing 42 options (provided by
* @nmeum in #10753, 42 is a random number which just needs to be higher
* than CONFIG_NANOCOAP_NOPTS_MAX) to coap_parse(). The used coap_pkt_t is part
* than CONFIG_NANOCOAP_NOPTS_MAX) to coap_parse_udp(). The used coap_pkt_t is part
* of a struct, followed by an array of 42 coap_option_t. The array is
* cleared before the call to coap_parse(). If the overflow protection is
* cleared before the call to coap_parse_udp(). If the overflow protection is
* working, the array must still be clear after parsing the packet, and the
* proper error code (-ENOMEM) is returned. Otherwise, the parsing wrote
* past scratch.pkt, thus the array is not zeroed anymore.
@ -813,7 +813,7 @@ static void test_nanocoap__server_option_count_overflow_check(void)
memset(&scratch, 0, sizeof(scratch));
ssize_t res = coap_parse(&scratch.pkt, pkt_data, sizeof(pkt_data));
ssize_t res = coap_parse_udp(&scratch.pkt, pkt_data, sizeof(pkt_data));
/* check if any byte of the guard_data array is non-zero */
int dirty = 0;
@ -830,7 +830,7 @@ static void test_nanocoap__server_option_count_overflow_check(void)
}
/*
* Verifies that coap_parse() recognizes inclusion of too many options.
* Verifies that coap_parse_udp() recognizes inclusion of too many options.
*/
static void test_nanocoap__server_option_count_overflow(void)
{
@ -855,13 +855,13 @@ static void test_nanocoap__server_option_count_overflow(void)
}
/* don't read final two bytes, where overflow option will be added later */
ssize_t res = coap_parse(&pkt, buf, sizeof(buf) - 2);
ssize_t res = coap_parse_udp(&pkt, buf, sizeof(buf) - 2);
TEST_ASSERT_EQUAL_INT(sizeof(buf) - 2, res);
/* add option to overflow */
memcpy(&buf[base_len+i], fill_opt, 2);
res = coap_parse(&pkt, buf, sizeof(buf));
res = coap_parse_udp(&pkt, buf, sizeof(buf));
TEST_ASSERT(res < 0);
}
@ -891,7 +891,7 @@ static ssize_t _read_rd_post_req(coap_pkt_t *pkt, bool omit_payload)
};
size_t len = omit_payload ? 59 : sizeof(pkt_data);
return coap_parse(pkt, pkt_data, len);
return coap_parse_udp(pkt, pkt_data, len);
}
/*
@ -976,7 +976,7 @@ static void test_nanocoap__empty(void)
uint16_t msgid = 0xABCD;
coap_pkt_t pkt;
ssize_t res = coap_parse(&pkt, pkt_data, 4);
ssize_t res = coap_parse_udp(&pkt, pkt_data, 4);
TEST_ASSERT(res > 0);
TEST_ASSERT_EQUAL_INT(0, coap_get_code_raw(&pkt));
@ -986,12 +986,12 @@ static void test_nanocoap__empty(void)
/* too short */
memset(&pkt, 0, sizeof(coap_pkt_t));
res = coap_parse(&pkt, pkt_data, 3);
res = coap_parse_udp(&pkt, pkt_data, 3);
TEST_ASSERT_EQUAL_INT(-EBADMSG, res);
/* too long */
memset(&pkt, 0, sizeof(coap_pkt_t));
res = coap_parse(&pkt, pkt_data, 5);
res = coap_parse_udp(&pkt, pkt_data, 5);
TEST_ASSERT_EQUAL_INT(-EBADMSG, res);
}
@ -1055,7 +1055,7 @@ static void test_nanocoap__add_get_proxy_uri(void)
}
/*
* Verifies that coap_parse() recognizes token length bigger than allowed.
* Verifies that coap_parse_udp() recognizes token length bigger than allowed.
*/
static void test_nanocoap__token_length_over_limit(void)
{
@ -1075,7 +1075,7 @@ static void test_nanocoap__token_length_over_limit(void)
coap_pkt_t pkt;
/* Valid packet (TKL = 8) */
ssize_t res = coap_parse(&pkt, buf_valid, sizeof(buf_valid));
ssize_t res = coap_parse_udp(&pkt, buf_valid, sizeof(buf_valid));
TEST_ASSERT_EQUAL_INT(sizeof(buf_valid), res);
TEST_ASSERT_EQUAL_INT(1, coap_get_code_raw(&pkt));
@ -1084,12 +1084,12 @@ static void test_nanocoap__token_length_over_limit(void)
TEST_ASSERT_EQUAL_INT(0, pkt.payload_len);
/* Invalid packet (TKL = 15) */
res = coap_parse(&pkt, buf_invalid, sizeof(buf_invalid));
res = coap_parse_udp(&pkt, buf_invalid, sizeof(buf_invalid));
TEST_ASSERT_EQUAL_INT(-EBADMSG, res);
}
/*
* Verifies that coap_parse() recognizes 8 bit extended token length
* Verifies that coap_parse_udp() recognizes 8 bit extended token length
*/
static void test_nanocoap__token_length_ext_16(void)
{
@ -1106,7 +1106,7 @@ static void test_nanocoap__token_length_ext_16(void)
/* parse the packet build, and verify it parses back as expected */
coap_pkt_t pkt;
ssize_t res = coap_parse(&pkt, buf, 21);
ssize_t res = coap_parse_udp(&pkt, buf, 21);
TEST_ASSERT_EQUAL_INT(21, res);
TEST_ASSERT_EQUAL_INT(21, coap_get_total_hdr_len(&pkt));
@ -1123,7 +1123,7 @@ static void test_nanocoap__token_length_ext_16(void)
ssize_t len = coap_build_reply_header(&pkt, COAP_CODE_DELETED, rbuf,
sizeof(rbuf), 0, NULL, NULL);
TEST_ASSERT_EQUAL_INT(21, len);
res = coap_parse(&pkt, rbuf, 21);
res = coap_parse_udp(&pkt, rbuf, 21);
TEST_ASSERT_EQUAL_INT(21, res);
TEST_ASSERT_EQUAL_INT(21, coap_get_total_hdr_len(&pkt));
TEST_ASSERT_EQUAL_INT(COAP_CODE_DELETED, coap_get_code_raw(&pkt));
@ -1135,7 +1135,7 @@ static void test_nanocoap__token_length_ext_16(void)
}
/*
* Verifies that coap_parse() recognizes 16 bit extended token length
* Verifies that coap_parse_udp() recognizes 16 bit extended token length
*/
static void test_nanocoap__token_length_ext_269(void)
{
@ -1155,7 +1155,7 @@ static void test_nanocoap__token_length_ext_269(void)
/* parse the packet build, and verify it parses back as expected */
coap_pkt_t pkt;
ssize_t res = coap_parse(&pkt, buf, 275);
ssize_t res = coap_parse_udp(&pkt, buf, 275);
TEST_ASSERT_EQUAL_INT(275, res);
TEST_ASSERT_EQUAL_INT(275, coap_get_total_hdr_len(&pkt));
@ -1173,7 +1173,7 @@ static void test_nanocoap__token_length_ext_269(void)
sizeof(rbuf), 0, NULL, NULL);
TEST_ASSERT_EQUAL_INT(275, len);
res = coap_parse(&pkt, rbuf, 275);
res = coap_parse_udp(&pkt, rbuf, 275);
TEST_ASSERT_EQUAL_INT(275, res);
TEST_ASSERT_EQUAL_INT(275, coap_get_total_hdr_len(&pkt));
TEST_ASSERT_EQUAL_INT(COAP_CODE_DELETED, coap_get_code_raw(&pkt));
@ -1207,7 +1207,7 @@ static void test_nanocoap___rst_message(void)
/* now check that parsing it back works */
coap_pkt_t pkt;
TEST_ASSERT_EQUAL_INT(0, coap_parse(&pkt, buf, sizeof(rst_expected)));
TEST_ASSERT_EQUAL_INT(sizeof(rst_expected), coap_parse(&pkt, buf, sizeof(rst_expected)));
TEST_ASSERT_EQUAL_INT(COAP_TYPE_RST, coap_get_type(&pkt));
TEST_ASSERT_EQUAL_INT(0, coap_get_code_raw(&pkt));
TEST_ASSERT_EQUAL_INT(0, coap_get_token_len(&pkt));
@ -1220,7 +1220,7 @@ static void test_nanocoap___rst_message(void)
0xde, 0xed, 0xbe, 0xef, /* Token = 0xdeadbeef */
};
memset(buf, 0x55, sizeof(buf));
TEST_ASSERT_EQUAL_INT(0, coap_parse(&pkt, con_request, sizeof(con_request)));
TEST_ASSERT_EQUAL_INT(sizeof(con_request), coap_parse(&pkt, con_request, sizeof(con_request)));
TEST_ASSERT_EQUAL_INT(sizeof(rst_expected), coap_build_reply(&pkt, 0, buf, sizeof(buf), 0));
TEST_ASSERT(0 == memcmp(rst_expected, buf, sizeof(rst_expected)));
TEST_ASSERT_EQUAL_INT(0x55, buf[sizeof(rst_expected)]);