riot-ci/RIOT
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #5694 from miri64/gnrc/enh/0-length-payload

Browse Source 
gnrc_pktbuf: allow for 0-sized payload snips
This commit is contained in:
Martine Lenders 2016-09-28 07:09:23 +02:00 committed by GitHub
commit 6f0018f66a
5 changed files with 160 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
sys/include/net/gnrc/pktbuf.h
View File

@ -71,16 +71,19 @@ void gnrc_pktbuf_init(void);
* function externally. This will most likely create memory leaks or
* not allowed memory access.
*
* @pre size < GNRC_PKTBUF_SIZE
*
* @param[in] next Next gnrc_pktsnip_t in the packet. Leave NULL if you
* want to create a new packet.
* @param[in] data Data of the new gnrc_pktsnip_t. If @p data is NULL no data
* will be inserted into `result`.
* @param[in] size Length of @p data. May not be 0.
* @param[in] size Length of @p data. If this value is 0 the
* gnrc_pktsnip::data field of the newly created snip will
* be NULL.
* @param[in] type Protocol type of the gnrc_pktsnip_t.
*
* @return Pointer to the packet part that represents the new gnrc_pktsnip_t.
* @return NULL, if no space is left in the packet buffer.
* @return NULL, if @p size == 0.
*/
gnrc_pktsnip_t *gnrc_pktbuf_add(gnrc_pktsnip_t *next, void *data, size_t size,
gnrc_nettype_t type);
@ -89,8 +92,9 @@ gnrc_pktsnip_t *gnrc_pktbuf_add(gnrc_pktsnip_t *next, void *data, size_t size,
* @brief Marks the first @p size bytes in a received packet with a new
* packet snip that is appended to the packet.
*
* Graphically this can be represented as follows:
* @code
* Graphically this can be represented as follows:
*
* ~~~~~~~~~~~~~~~~~~~
* Before After
* ====== =====
* (next)
@ -99,7 +103,10 @@ gnrc_pktsnip_t *gnrc_pktbuf_add(gnrc_pktsnip_t *next, void *data, size_t size,
* +--------------------------------+ +----------------+---------------+
* +--------------------------------+ +----------------+---------------+
* \__________pkt->size___________/ \_result->size_/ \__pkt->size__/
* @endcode
* ~~~~~~~~~~~~~~~~~~~
*
* If `size == pkt->size` then the resulting snip will point to NULL in its
* gnrc_pktsnip_t::data field and its gnrc_pktsnip_t::size field will be 0.
*
* @pre @p pkt != NULL && @p size != 0
*
@ -117,7 +124,9 @@ gnrc_pktsnip_t *gnrc_pktbuf_mark(gnrc_pktsnip_t *pkt, size_t size, gnrc_nettype_
* @brief Reallocates gnrc_pktsnip_t::data of @p pkt in the packet buffer, without
* changing the content.
*
* @pre gnrc_pktsnip_t::data of @p pkt is in the packet buffer.
* @pre `pkt != NULL`
* @pre `(pkt->size > 0) <=> (pkt->data != NULL)`
* @pre gnrc_pktsnip_t::data of @p pkt is in the packet buffer if it is not NULL.
*
* @details If enough memory is available behind it or @p size is smaller than
* the original size of the packet then gnrc_pktsnip_t::data of @p pkt will
@ -128,7 +137,7 @@ gnrc_pktsnip_t *gnrc_pktbuf_mark(gnrc_pktsnip_t *pkt, size_t size, gnrc_nettype_
* @param[in] size The size for @p pkt.
*
* @return 0, on success
* @return ENOMEM, if no space is left in the packet buffer or size was 0.
* @return ENOMEM, if no space is left in the packet buffer.
*/
int gnrc_pktbuf_realloc_data(gnrc_pktsnip_t *pkt, size_t size);

66
sys/net/gnrc/pktbuf_static/gnrc_pktbuf_static.c
View File

@ -94,8 +94,8 @@ gnrc_pktsnip_t *gnrc_pktbuf_add(gnrc_pktsnip_t *next, void *data, size_t size,
{
gnrc_pktsnip_t *pkt;
if ((size == 0) || (size > GNRC_PKTBUF_SIZE)) {
DEBUG("pktbuf: size (%u) == 0 || size == GNRC_PKTBUF_SIZE (%u)\n",
if (size > GNRC_PKTBUF_SIZE) {
DEBUG("pktbuf: size (%u) > GNRC_PKTBUF_SIZE (%u)\n",
(unsigned)size, GNRC_PKTBUF_SIZE);
return NULL;
}
@ -122,19 +122,17 @@ gnrc_pktsnip_t *gnrc_pktbuf_mark(gnrc_pktsnip_t *pkt, size_t size, gnrc_nettype_
mutex_unlock(&_mutex);
return NULL;
}
else if (size == pkt->size) {
pkt->type = type;
mutex_unlock(&_mutex);
return pkt;
}
/* create new snip descriptor for marked data */
marked_snip = _pktbuf_alloc(sizeof(gnrc_pktsnip_t));
if (marked_snip == NULL) {
DEBUG("pktbuf: could not reallocate marked section.\n");
mutex_unlock(&_mutex);
return NULL;
}
/* would not fit unused marker => move data around */
if ((size < required_new_size) || ((pkt->size - size) < sizeof(_unused_t))) {
/* marked data would not fit _unused_t marker => move data around to allow
* for proper free */
if ((pkt->size != size) &&
((size < required_new_size) || ((pkt->size - size) < sizeof(_unused_t)))) {
void *new_data_rest;
new_data_marked = _pktbuf_alloc(size);
if (new_data_marked == NULL) {
@ -159,7 +157,9 @@ gnrc_pktsnip_t *gnrc_pktbuf_mark(gnrc_pktsnip_t *pkt, size_t size, gnrc_nettype_
}
else {
new_data_marked = pkt->data;
pkt->data = ((uint8_t *)pkt->data) + size;
/* if (pkt->size - size) != 0 take remainder of data, otherwise set NULL */
pkt->data = (pkt->size != size) ? (((uint8_t *)pkt->data) + size) :
NULL;
}
pkt->size -= size;
_set_pktsnip(marked_snip, pkt->next, new_data_marked, size, type);
@ -174,17 +174,23 @@ int gnrc_pktbuf_realloc_data(gnrc_pktsnip_t *pkt, size_t size)
_align(sizeof(_unused_t)) : _align(size);
mutex_lock(&_mutex);
assert((pkt != NULL) && (pkt->data != NULL) && _pktbuf_contains(pkt->data));
if (size == 0) {
DEBUG("pktbuf: size == 0\n");
mutex_unlock(&_mutex);
return ENOMEM;
}
assert(pkt != NULL);
assert(((pkt->size == 0) && (pkt->data == NULL)) ||
((pkt->size > 0) && (pkt->data != NULL) && _pktbuf_contains(pkt->data)));
/* new size and old size are equal */
if (size == pkt->size) {
/* nothing to do */
mutex_unlock(&_mutex);
return 0;
}
if ((size > pkt->size) || /* new size does not fit */
/* new size is 0 and data pointer isn't already NULL */
if ((size == 0) && (pkt->data != NULL)) {
/* set data pointer to NULL */
_pktbuf_free(pkt->data, pkt->size);
pkt->data = NULL;
}
/* if new size is bigger than old size */
else if ((size > pkt->size) || /* new size does not fit */
((pkt->size - aligned_size) < sizeof(_unused_t))) { /* resulting hole would not fit marker */
void *new_data = _pktbuf_alloc(size);
if (new_data == NULL) {
@ -192,15 +198,15 @@ int gnrc_pktbuf_realloc_data(gnrc_pktsnip_t *pkt, size_t size)
mutex_unlock(&_mutex);
return ENOMEM;
}
memcpy(new_data, pkt->data, (pkt->size < size) ? pkt->size : size);
if (pkt->data != NULL) { /* if old data exist */
memcpy(new_data, pkt->data, (pkt->size < size) ? pkt->size : size);
}
_pktbuf_free(pkt->data, pkt->size);
pkt->data = new_data;
}
else {
if (_align(pkt->size) > aligned_size) {
_pktbuf_free(((uint8_t *)pkt->data) + aligned_size,
pkt->size - aligned_size);
}
else if (_align(pkt->size) > aligned_size) {
_pktbuf_free(((uint8_t *)pkt->data) + aligned_size,
pkt->size - aligned_size);
}
pkt->size = size;
mutex_unlock(&_mutex);
@ -397,17 +403,19 @@ static gnrc_pktsnip_t *_create_snip(gnrc_pktsnip_t *next, void *data, size_t siz
gnrc_nettype_t type)
{
gnrc_pktsnip_t *pkt = _pktbuf_alloc(sizeof(gnrc_pktsnip_t));
void *_data;
void *_data = NULL;
if (pkt == NULL) {
DEBUG("pktbuf: error allocating new packet snip\n");
return NULL;
}
_data = _pktbuf_alloc(size);
if (_data == NULL) {
DEBUG("pktbuf: error allocating data for new packet snip\n");
_pktbuf_free(pkt, sizeof(gnrc_pktsnip_t));
return NULL;
if (size > 0) {
_data = _pktbuf_alloc(size);
if (_data == NULL) {
DEBUG("pktbuf: error allocating data for new packet snip\n");
_pktbuf_free(pkt, sizeof(gnrc_pktsnip_t));
return NULL;
}
}
_set_pktsnip(pkt, next, _data, size, type);
if (data != NULL) {

4
sys/od/od.c
View File

@ -333,6 +333,10 @@ void od(const void *data, size_t data_len, uint8_t width, uint16_t flags)
uint8_t date_length = _length(flags);
char bytes_format[_log10(date_length) + 7];
if (data_len == 0) {
return;
}
_address_format(address_format, flags);
_bytes_format(bytes_format, flags);

16
sys/shell/commands/sc_netif.c
View File

@ -1041,7 +1041,7 @@ int _netif_send(int argc, char **argv)
{
kernel_pid_t dev;
uint8_t addr[MAX_ADDR_LEN];
size_t addr_len, data_len;
size_t addr_len;
gnrc_pktsnip_t *pkt, *hdr;
gnrc_netif_hdr_t *nethdr;
uint8_t flags = 0x00;
@ -1073,16 +1073,10 @@ int _netif_send(int argc, char **argv)
}
/* put packet together */
data_len = strlen(argv[3]);
if (data_len == 0) {
pkt = NULL;
}
else {
pkt = gnrc_pktbuf_add(NULL, argv[3], data_len, GNRC_NETTYPE_UNDEF);
if (pkt == NULL) {
puts("error: packet buffer full");
return 1;
}
pkt = gnrc_pktbuf_add(NULL, argv[3], strlen(argv[3]), GNRC_NETTYPE_UNDEF);
if (pkt == NULL) {
puts("error: packet buffer full");
return 1;
}
hdr = gnrc_netif_hdr_build(NULL, 0, addr, addr_len);
if (hdr == NULL) {

105
tests/unittests/tests-pktbuf/tests-pktbuf.c
View File

@ -59,18 +59,30 @@ static void test_pktbuf_init(void)
static void test_pktbuf_add__pkt_NULL__data_NULL__size_0(void)
{
TEST_ASSERT_NULL(gnrc_pktbuf_add(NULL, NULL, 0, GNRC_NETTYPE_TEST));
TEST_ASSERT(gnrc_pktbuf_is_empty());
gnrc_pktsnip_t *pkt;
TEST_ASSERT_NOT_NULL((pkt = gnrc_pktbuf_add(NULL, NULL, 0, GNRC_NETTYPE_TEST)));
TEST_ASSERT_NULL(pkt->next);
TEST_ASSERT_NULL(pkt->data);
TEST_ASSERT_EQUAL_INT(0, pkt->size);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, pkt->type);
TEST_ASSERT(gnrc_pktbuf_is_sane());
TEST_ASSERT(!gnrc_pktbuf_is_empty());
}
static void test_pktbuf_add__pkt_NOT_NULL__data_NULL__size_0(void)
{
gnrc_pktsnip_t *pkt;
gnrc_pktsnip_t *next = gnrc_pktbuf_add(NULL, TEST_STRING4, sizeof(TEST_STRING4),
GNRC_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL(next);
TEST_ASSERT_NULL(gnrc_pktbuf_add(next, NULL, 0, GNRC_NETTYPE_TEST));
TEST_ASSERT_NOT_NULL((pkt = gnrc_pktbuf_add(next, NULL, 0, GNRC_NETTYPE_TEST)));
TEST_ASSERT(pkt->next = next);
TEST_ASSERT_NULL(pkt->data);
TEST_ASSERT_EQUAL_INT(0, pkt->size);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, pkt->type);
TEST_ASSERT_NULL(next->next);
TEST_ASSERT_EQUAL_STRING(TEST_STRING4, next->data);
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING4), next->size);
@ -81,19 +93,31 @@ static void test_pktbuf_add__pkt_NOT_NULL__data_NULL__size_0(void)
static void test_pktbuf_add__pkt_NULL__data_NOT_NULL__size_0(void)
{
TEST_ASSERT_NULL(gnrc_pktbuf_add(NULL, TEST_STRING8, 0, GNRC_NETTYPE_TEST));
TEST_ASSERT(gnrc_pktbuf_is_empty());
gnrc_pktsnip_t *pkt;
TEST_ASSERT_NOT_NULL((pkt = gnrc_pktbuf_add(NULL, TEST_STRING8, 0, GNRC_NETTYPE_TEST)));
TEST_ASSERT_NULL(pkt->next);
TEST_ASSERT_NULL(pkt->data);
TEST_ASSERT_EQUAL_INT(0, pkt->size);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, pkt->type);
TEST_ASSERT(gnrc_pktbuf_is_sane());
TEST_ASSERT(!gnrc_pktbuf_is_empty());
}
static void test_pktbuf_add__pkt_NOT_NULL__data_NOT_NULL__size_0(void)
{
gnrc_pktsnip_t *pkt;
gnrc_pktsnip_t *next = gnrc_pktbuf_add(NULL, TEST_STRING4, sizeof(TEST_STRING4),
GNRC_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL(next);
TEST_ASSERT_NULL(gnrc_pktbuf_add(next, TEST_STRING8, 0, GNRC_NETTYPE_TEST));
TEST_ASSERT_NOT_NULL((pkt = gnrc_pktbuf_add(next, TEST_STRING8, 0, GNRC_NETTYPE_TEST)));
TEST_ASSERT(pkt->next = next);
TEST_ASSERT_NULL(pkt->data);
TEST_ASSERT_EQUAL_INT(0, pkt->size);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, pkt->type);
TEST_ASSERT_NULL(next->next);
TEST_ASSERT_EQUAL_STRING(TEST_STRING4, next->data);
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING4), next->size);
@ -238,6 +262,18 @@ static void test_pktbuf_add__unaligned_in_aligned_hole(void)
TEST_ASSERT(gnrc_pktbuf_is_empty());
}
static void test_pktbuf_add__0_sized_release(void)
{
gnrc_pktsnip_t *pkt1 = gnrc_pktbuf_add(NULL, NULL, 0, GNRC_NETTYPE_TEST);
gnrc_pktsnip_t *pkt2 = gnrc_pktbuf_add(NULL, NULL, 8, GNRC_NETTYPE_TEST);
gnrc_pktbuf_release(pkt1);
TEST_ASSERT(gnrc_pktbuf_is_sane());
TEST_ASSERT(!gnrc_pktbuf_is_empty());
gnrc_pktbuf_release(pkt2);
TEST_ASSERT(gnrc_pktbuf_is_empty());
}
static void test_pktbuf_mark__pkt_NULL__size_0(void)
{
TEST_ASSERT_NULL(gnrc_pktbuf_mark(NULL, 0, GNRC_NETTYPE_TEST));
@ -428,11 +464,43 @@ static void test_pktbuf_mark__success_small(void)
TEST_ASSERT(gnrc_pktbuf_is_empty());
}
static void test_pktbuf_mark__success_equally_sized(void)
{
gnrc_pktsnip_t *pkt1 = gnrc_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16),
GNRC_NETTYPE_TEST);
gnrc_pktsnip_t *pkt2;
TEST_ASSERT_NOT_NULL(pkt1);
TEST_ASSERT_NOT_NULL((pkt2 = gnrc_pktbuf_mark(pkt1, sizeof(TEST_STRING16),
GNRC_NETTYPE_UNDEF)));
TEST_ASSERT(gnrc_pktbuf_is_sane());
TEST_ASSERT(pkt1->next == pkt2);
TEST_ASSERT_NULL(pkt1->data);
TEST_ASSERT_EQUAL_INT(0, pkt1->size);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, pkt1->type);
TEST_ASSERT_EQUAL_INT(1, pkt1->users);
TEST_ASSERT_NULL(pkt2->next);
TEST_ASSERT_EQUAL_INT(0, memcmp(TEST_STRING16, pkt2->data, pkt2->size));
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING16), pkt2->size);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_UNDEF, pkt2->type);
TEST_ASSERT_EQUAL_INT(1, pkt2->users);
TEST_ASSERT(gnrc_pktbuf_is_sane());
/* check if everything can be cleaned up */
gnrc_pktbuf_release(pkt1);
TEST_ASSERT(gnrc_pktbuf_is_sane());
TEST_ASSERT(gnrc_pktbuf_is_empty());
}
static void test_pktbuf_realloc_data__size_0(void)
{
gnrc_pktsnip_t *pkt = gnrc_pktbuf_add(NULL, NULL, sizeof(TEST_STRING8), GNRC_NETTYPE_TEST);
TEST_ASSERT_EQUAL_INT(ENOMEM, gnrc_pktbuf_realloc_data(pkt, 0));
TEST_ASSERT_EQUAL_INT(0, gnrc_pktbuf_realloc_data(pkt, 0));
TEST_ASSERT(gnrc_pktbuf_is_sane());
TEST_ASSERT_NULL(pkt->data);
TEST_ASSERT_EQUAL_INT(0, pkt->size);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, pkt->type);
gnrc_pktbuf_release(pkt);
TEST_ASSERT(gnrc_pktbuf_is_empty());
}
@ -559,6 +627,26 @@ static void test_pktbuf_realloc_data__success2(void)
TEST_ASSERT_EQUAL_INT(1, pkt->users);
}
static void test_pktbuf_realloc_data__success3(void)
{
gnrc_pktsnip_t *pkt;
pkt = gnrc_pktbuf_add(NULL, NULL, 0, GNRC_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL(pkt);
TEST_ASSERT_NULL(pkt->data);
TEST_ASSERT_EQUAL_INT(0, gnrc_pktbuf_realloc_data(pkt, sizeof(TEST_STRING16)));
TEST_ASSERT_NULL(pkt->next);
TEST_ASSERT_NOT_NULL(pkt->data);
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING16), pkt->size);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, pkt->type);
TEST_ASSERT_EQUAL_INT(1, pkt->users);
TEST_ASSERT(gnrc_pktbuf_is_sane());
gnrc_pktbuf_release(pkt);
TEST_ASSERT(gnrc_pktbuf_is_empty());
}
static void test_pktbuf_hold__pkt_null(void)
{
gnrc_pktbuf_hold(NULL, 1);
@ -739,6 +827,7 @@ Test *tests_pktbuf_tests(void)
new_TestFixture(test_pktbuf_add__success),
new_TestFixture(test_pktbuf_add__packed_struct),
new_TestFixture(test_pktbuf_add__unaligned_in_aligned_hole),
new_TestFixture(test_pktbuf_add__0_sized_release),
new_TestFixture(test_pktbuf_mark__pkt_NULL__size_0),
new_TestFixture(test_pktbuf_mark__pkt_NULL__size_not_0),
new_TestFixture(test_pktbuf_mark__pkt_NOT_NULL__size_0),
@ -747,6 +836,7 @@ Test *tests_pktbuf_tests(void)
new_TestFixture(test_pktbuf_mark__success_large),
new_TestFixture(test_pktbuf_mark__success_aligned),
new_TestFixture(test_pktbuf_mark__success_small),
new_TestFixture(test_pktbuf_mark__success_equally_sized),
new_TestFixture(test_pktbuf_realloc_data__size_0),
new_TestFixture(test_pktbuf_realloc_data__memfull),
new_TestFixture(test_pktbuf_realloc_data__nomemenough),
@ -755,6 +845,7 @@ Test *tests_pktbuf_tests(void)
new_TestFixture(test_pktbuf_realloc_data__alignment),
new_TestFixture(test_pktbuf_realloc_data__success),
new_TestFixture(test_pktbuf_realloc_data__success2),
new_TestFixture(test_pktbuf_realloc_data__success3),
new_TestFixture(test_pktbuf_hold__pkt_null),
new_TestFixture(test_pktbuf_hold__pkt_external),
new_TestFixture(test_pktbuf_hold__success),