/* 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(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());
}
#ifndef MODULE_GNRC_PKTBUF_MALLOC /* GNRC_PKTBUF_SIZE does not apply for gnrc_pktbuf_malloc */
static void test_pktbuf_realloc_data__memfull(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, GNRC_PKTBUF_SIZE + 1));
gnrc_pktbuf_release(pkt);
TEST_ASSERT(gnrc_pktbuf_is_empty());
}
static void test_pktbuf_mark__success_aligned(void)
{
uint8_t *data = (uint8_t *)(TEST_STRING16);
gnrc_pktsnip_t *pkt1 = gnrc_pktbuf_add(NULL, data, sizeof(TEST_STRING16),
GNRC_NETTYPE_TEST);
gnrc_pktsnip_t *pkt2;
uint8_t exp_data1[sizeof(TEST_STRING16) - 8];
uint8_t exp_data2[8];
memcpy(exp_data1, data + sizeof(exp_data2), sizeof(exp_data1));
memcpy(exp_data2, data, sizeof(exp_data2));
TEST_ASSERT_NOT_NULL(pkt1);
TEST_ASSERT_NOT_NULL((pkt2 = gnrc_pktbuf_mark(pkt1, 8, GNRC_NETTYPE_UNDEF)));
TEST_ASSERT(gnrc_pktbuf_is_sane());
TEST_ASSERT(pkt1->next == pkt2);
TEST_ASSERT_NOT_NULL(pkt1->data);
TEST_ASSERT_EQUAL_INT(0, memcmp(exp_data1, pkt1->data, pkt1->size));
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING16) - 8,
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_NOT_NULL(pkt2->data);
TEST_ASSERT_EQUAL_INT(0, memcmp(exp_data2, pkt2->data, pkt2->size));
TEST_ASSERT_EQUAL_INT(8, pkt2->size);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_UNDEF, pkt2->type);
TEST_ASSERT_EQUAL_INT(1, pkt2->users);
/* check if slightly larger packet would override data */
gnrc_pktbuf_remove_snip(pkt1, pkt2);
pkt2 = gnrc_pktbuf_add(NULL, TEST_STRING12, 12, GNRC_NETTYPE_TEST);
TEST_ASSERT(gnrc_pktbuf_is_sane());
TEST_ASSERT_NOT_NULL(pkt1->data);
TEST_ASSERT_EQUAL_INT(0, memcmp(exp_data1, pkt1->data, pkt1->size));
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING16) - 8,
pkt1->size);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, pkt1->type);
TEST_ASSERT_EQUAL_INT(1, pkt1->users);
/* check if everything can be cleaned up */
gnrc_pktbuf_release(pkt1);
gnrc_pktbuf_release(pkt2);
TEST_ASSERT(gnrc_pktbuf_is_empty());
}
static void test_pktbuf_realloc_data__shrink(void)
{
gnrc_pktsnip_t *pkt;
void *exp_data;
pkt = gnrc_pktbuf_add(NULL, NULL, sizeof(TEST_STRING16), GNRC_NETTYPE_TEST);
exp_data = pkt->data;
TEST_ASSERT_NOT_NULL(pkt);
TEST_ASSERT_NOT_NULL(gnrc_pktbuf_add(NULL, NULL, 4, GNRC_NETTYPE_TEST));
TEST_ASSERT_EQUAL_INT(0, gnrc_pktbuf_realloc_data(pkt, 8));
TEST_ASSERT(exp_data == pkt->data);
TEST_ASSERT_NULL(pkt->next);
TEST_ASSERT_EQUAL_INT(8, pkt->size);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, pkt->type);
TEST_ASSERT_EQUAL_INT(1, pkt->users);
}
static void test_pktbuf_hold__success2(void)
{
gnrc_pktsnip_t *pkt = gnrc_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16),
GNRC_NETTYPE_TEST);
gnrc_pktbuf_hold(pkt, TEST_UINT8);
TEST_ASSERT_EQUAL_INT(TEST_UINT8 + 1, pkt->users);
}
/**
* @{
*
* @file
*/
#include <errno.h>
#include <stdint.h>
#include <sys/uio.h>
#include "embUnit.h"
#include "net/gnrc/nettype.h"
#include "net/gnrc/pkt.h"
#include "net/gnrc/pktbuf.h"
#include "unittests-constants.h"
#include "tests-pktbuf.h"
typedef struct __attribute__((packed)) {
uint8_t u8;
uint16_t u16;
uint32_t u32;
uint64_t u64;
int8_t s8;
int16_t s16;
int32_t s32;
int64_t s64;
}
test_pktbuf_struct_t;
static void set_up(void)
{
gnrc_pktbuf_init();
}
static void test_pktbuf_init(void)
{
TEST_ASSERT(gnrc_pktbuf_is_empty());
TEST_ASSERT_NOT_NULL(gnrc_pktbuf_add(NULL, TEST_STRING4, sizeof(TEST_STRING4),
GNRC_NETTYPE_TEST));
TEST_ASSERT_NOT_NULL(gnrc_pktbuf_add(NULL, TEST_STRING8, sizeof(TEST_STRING8),
GNRC_NETTYPE_TEST));
TEST_ASSERT_NOT_NULL(gnrc_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16),
GNRC_NETTYPE_TEST));
TEST_ASSERT(gnrc_pktbuf_is_sane());
TEST_ASSERT(!gnrc_pktbuf_is_empty());
gnrc_pktbuf_init();
TEST_ASSERT(gnrc_pktbuf_is_empty());
}
static void test_pktbuf_add__pkt_NULL__data_NULL__size_0(void)
{
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_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);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, next->type);
TEST_ASSERT(gnrc_pktbuf_is_sane());
TEST_ASSERT(!gnrc_pktbuf_is_empty());
}
static void test_pktbuf_add__pkt_NULL__data_NOT_NULL__size_0(void)
{
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_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);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, next->type);
TEST_ASSERT(gnrc_pktbuf_is_sane());
TEST_ASSERT(!gnrc_pktbuf_is_empty());
}
static void test_pktbuf_add__pkt_NULL__data_NULL__size_not_0(void)
{
gnrc_pktsnip_t *pkt;
TEST_ASSERT_NOT_NULL((pkt = gnrc_pktbuf_add(NULL, NULL, sizeof(TEST_STRING8),
GNRC_NETTYPE_TEST)));
TEST_ASSERT_NULL(pkt->next);
TEST_ASSERT_NOT_NULL(pkt->data);
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING8), pkt->size);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, pkt->type);
TEST_ASSERT_EQUAL_INT(1, pkt->users);
TEST_ASSERT(gnrc_pktbuf_is_sane());
TEST_ASSERT(!gnrc_pktbuf_is_empty());
}
static void test_pktbuf_add__pkt_NOT_NULL__data_NULL__size_not_0(void)
{
gnrc_pktsnip_t *pkt, *next = gnrc_pktbuf_add(NULL, TEST_STRING4, sizeof(TEST_STRING4),
GNRC_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL(next);
TEST_ASSERT_NOT_NULL((pkt = gnrc_pktbuf_add(next, NULL, sizeof(TEST_STRING8), GNRC_NETTYPE_TEST)));
TEST_ASSERT(pkt->next == next);
TEST_ASSERT_NOT_NULL(pkt->data);
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING8), 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);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, pkt->type);
TEST_ASSERT(!gnrc_pktbuf_is_empty());
}
static void test_pktbuf_add__pkt_NOT_NULL__data_NOT_NULL__size_not_0(void)
{
gnrc_pktsnip_t *pkt, *next = gnrc_pktbuf_add(NULL, TEST_STRING4, sizeof(TEST_STRING4),
GNRC_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL(next);
TEST_ASSERT_NOT_NULL((pkt = gnrc_pktbuf_add(next, TEST_STRING8, sizeof(TEST_STRING8),
GNRC_NETTYPE_TEST)));
TEST_ASSERT(pkt->next == next);
TEST_ASSERT_EQUAL_STRING(TEST_STRING8, pkt->data);
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING8), 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);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, pkt->type);
TEST_ASSERT(gnrc_pktbuf_is_sane());
TEST_ASSERT(!gnrc_pktbuf_is_empty());
}
#ifndef MODULE_GNRC_PKTBUF_MALLOC /* to long for standard malloc on native ;-) */
static void test_pktbuf_add__memfull(void)
{
gnrc_pktsnip_t *pkt = gnrc_pktbuf_add(NULL, NULL, 1, GNRC_NETTYPE_TEST);
while (pkt) {
pkt = gnrc_pktbuf_add(NULL, NULL, 1, GNRC_NETTYPE_TEST);
}
TEST_ASSERT(gnrc_pktbuf_is_sane());
TEST_ASSERT(!gnrc_pktbuf_is_empty());
}
#endif
static void test_pktbuf_add__success(void)
{
gnrc_pktsnip_t *pkt, *pkt_prev = NULL;
for (int i = 0; i < 9; i++) {
pkt = gnrc_pktbuf_add(NULL, NULL, (GNRC_PKTBUF_SIZE / 10) + 4, GNRC_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL(pkt);
TEST_ASSERT_NULL(pkt->next);
TEST_ASSERT_NOT_NULL(pkt->data);
TEST_ASSERT_EQUAL_INT((GNRC_PKTBUF_SIZE / 10) + 4, pkt->size);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, pkt->type);
TEST_ASSERT_EQUAL_INT(1, pkt->users);
if (pkt_prev != NULL) {
TEST_ASSERT(pkt_prev < pkt);
TEST_ASSERT(pkt_prev->data < pkt->data);
}
pkt_prev = pkt;
}
TEST_ASSERT(gnrc_pktbuf_is_sane());
}
static void test_pktbuf_add__packed_struct(void)
{
test_pktbuf_struct_t data = { 0x4d, 0xef43, 0xacdef574, 0x43644305695afde5,
34, -4469, 149699748, -46590430597
};
test_pktbuf_struct_t *data_cpy;
gnrc_pktsnip_t *pkt = gnrc_pktbuf_add(NULL, &data, sizeof(test_pktbuf_struct_t), GNRC_NETTYPE_TEST);
data_cpy = (test_pktbuf_struct_t *)pkt->data;
TEST_ASSERT_EQUAL_INT(data.u8, data_cpy->u8);
TEST_ASSERT_EQUAL_INT(data.u16, data_cpy->u16);
TEST_ASSERT_EQUAL_INT(data.u32, data_cpy->u32);
TEST_ASSERT_EQUAL_INT(data.u64, data_cpy->u64);
TEST_ASSERT_EQUAL_INT(data.s8, data_cpy->s8);
TEST_ASSERT_EQUAL_INT(data.s16, data_cpy->s16);
TEST_ASSERT_EQUAL_INT(data.s32, data_cpy->s32);
TEST_ASSERT_EQUAL_INT(data.s64, data_cpy->s64);
}
#ifndef MODULE_GNRC_PKTBUF_MALLOC /* alignment-handling left to malloc, so no certainty here */
static void test_pktbuf_add__unaligned_in_aligned_hole(void)
{
gnrc_pktsnip_t *pkt1 = gnrc_pktbuf_add(NULL, NULL, 8, GNRC_NETTYPE_TEST);
gnrc_pktsnip_t *pkt2 = gnrc_pktbuf_add(NULL, NULL, 8, GNRC_NETTYPE_TEST);
gnrc_pktsnip_t *pkt3 = gnrc_pktbuf_add(NULL, NULL, 8, GNRC_NETTYPE_TEST);
gnrc_pktsnip_t *pkt4;
void *tmp_data2 = pkt2->data;
gnrc_pktbuf_release(pkt2);
pkt4 = gnrc_pktbuf_add(NULL, TEST_STRING12, 9, GNRC_NETTYPE_TEST);
TEST_ASSERT(tmp_data2 != pkt4->data);
gnrc_pktbuf_release(pkt1);
gnrc_pktbuf_release(pkt3);
gnrc_pktbuf_release(pkt4);
TEST_ASSERT(gnrc_pktbuf_is_empty());
}
static void test_pktbuf_start_write__pkt_users_1(void)
{
gnrc_pktsnip_t *pkt_copy, *pkt = gnrc_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16),
GNRC_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL((pkt_copy = gnrc_pktbuf_start_write(pkt)));
TEST_ASSERT(pkt == pkt_copy);
gnrc_pktbuf_release(pkt);
TEST_ASSERT(gnrc_pktbuf_is_empty());
}
void gnrc_rpl_send_DIO(gnrc_rpl_instance_t *inst, ipv6_addr_t *destination)
{
if (inst == NULL) {
DEBUG("RPL: Error - trying to send DIO without being part of a dodag.\n");
return;
}
gnrc_rpl_dodag_t *dodag = &inst->dodag;
gnrc_pktsnip_t *pkt = NULL, *tmp = NULL;
gnrc_rpl_dio_t *dio;
#ifndef GNRC_RPL_WITHOUT_PIO
if (dodag->req_opts & GNRC_RPL_REQ_OPT_PREFIX_INFO) {
if ((pkt = _dio_prefix_info_build(pkt, dodag)) == NULL) {
return;
}
}
#endif
if (dodag->req_opts & GNRC_RPL_REQ_OPT_DODAG_CONF) {
if ((pkt = _dio_dodag_conf_build(pkt, dodag)) == NULL) {
return;
}
dodag->req_opts &= ~GNRC_RPL_REQ_OPT_DODAG_CONF;
}
if ((tmp = gnrc_pktbuf_add(pkt, NULL, sizeof(gnrc_rpl_dio_t), GNRC_NETTYPE_UNDEF)) == NULL) {
DEBUG("RPL: Send DIO - no space left in packet buffer\n");
gnrc_pktbuf_release(pkt);
return;
}
pkt = tmp;
dio = pkt->data;
dio->instance_id = inst->id;
dio->version_number = dodag->version;
/* a leaf node announces an INFINITE_RANK */
dio->rank = ((dodag->node_status == GNRC_RPL_LEAF_NODE) ?
byteorder_htons(GNRC_RPL_INFINITE_RANK) : byteorder_htons(dodag->my_rank));
dio->g_mop_prf = (dodag->grounded << GNRC_RPL_GROUNDED_SHIFT) |
(inst->mop << GNRC_RPL_MOP_SHIFT) | dodag->prf;
dio->dtsn = dodag->dtsn;
dio->flags = 0;
dio->reserved = 0;
dio->dodag_id = dodag->dodag_id;
if ((tmp = gnrc_icmpv6_build(pkt, ICMPV6_RPL_CTRL, GNRC_RPL_ICMPV6_CODE_DIO,
sizeof(icmpv6_hdr_t))) == NULL) {
DEBUG("RPL: Send DIO - no space left in packet buffer\n");
gnrc_pktbuf_release(pkt);
return;
}
pkt = tmp;
gnrc_rpl_send(pkt, NULL, destination, &dodag->dodag_id);
}
static void test_pktbuf_merge_data__success1(void)
{
gnrc_pktsnip_t *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_merge(pkt));
gnrc_pktbuf_release(pkt);
TEST_ASSERT(gnrc_pktbuf_is_empty());
}
static void test_pktbuf_hold__success(void)
{
gnrc_pktsnip_t *pkt = gnrc_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16),
GNRC_NETTYPE_TEST);
for (uint8_t i = 0; i < TEST_UINT8; i++) {
uint8_t prev_users = pkt->users;
gnrc_pktbuf_hold(pkt, 1);
TEST_ASSERT_EQUAL_INT(prev_users + 1, pkt->users);
}
}
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_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);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, next->type);
TEST_ASSERT(gnrc_pktbuf_is_sane());
TEST_ASSERT(!gnrc_pktbuf_is_empty());
}
static void test_pktbuf_realloc_data__alignment(void)
{
gnrc_pktsnip_t *pkt1, *pkt2, *pkt3;
/* see: https://github.com/RIOT-OS/RIOT/pull/4602 */
pkt1 = gnrc_pktbuf_add(NULL, TEST_STRING8, sizeof(TEST_STRING8), GNRC_NETTYPE_TEST);
pkt2 = gnrc_pktbuf_add(NULL, NULL, 23, GNRC_NETTYPE_TEST);
pkt3 = gnrc_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16), GNRC_NETTYPE_UNDEF);
TEST_ASSERT_NOT_NULL(pkt1);
TEST_ASSERT_NOT_NULL(pkt2);
TEST_ASSERT_NOT_NULL(pkt3);
TEST_ASSERT_EQUAL_INT(0, gnrc_pktbuf_realloc_data(pkt2, 21));
gnrc_pktbuf_release(pkt1);
gnrc_pktbuf_release(pkt2);
gnrc_pktbuf_release(pkt3);
TEST_ASSERT(gnrc_pktbuf_is_empty());
}
static void test_pktbuf_add__pkt_NULL__data_NULL__size_0(void)
{
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_realloc_data__size_0(void)
{
gnrc_pktsnip_t *pkt = gnrc_pktbuf_add(NULL, NULL, sizeof(TEST_STRING8), GNRC_NETTYPE_TEST);
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());
}
static void test_pktbuf_merge_data__success2(void)
{
gnrc_pktsnip_t *pkt = gnrc_pktbuf_add(NULL, TEST_STRING4,
sizeof(TEST_STRING4),
GNRC_NETTYPE_TEST);
pkt = gnrc_pktbuf_add(pkt, TEST_STRING8, sizeof(TEST_STRING8), GNRC_NETTYPE_TEST);
pkt = gnrc_pktbuf_add(pkt, TEST_STRING16, sizeof(TEST_STRING16), GNRC_NETTYPE_TEST);
TEST_ASSERT_EQUAL_INT(0, gnrc_pktbuf_merge(pkt));
TEST_ASSERT_NULL(pkt->next);
TEST_ASSERT_EQUAL_STRING(TEST_STRING16, pkt->data);
TEST_ASSERT_EQUAL_STRING(TEST_STRING8,
(char *) pkt->data + sizeof(TEST_STRING16));
TEST_ASSERT_EQUAL_STRING(TEST_STRING4,
(char *) pkt->data + sizeof(TEST_STRING16) +
sizeof(TEST_STRING8));
gnrc_pktbuf_release(pkt);
TEST_ASSERT(gnrc_pktbuf_is_empty());
TEST_ASSERT(gnrc_pktbuf_is_sane());
}
static void test_pktbuf_reverse_snips__too_full(void)
{
gnrc_pktsnip_t *pkt, *pkt_next, *pkt_huge;
const size_t pkt_huge_size = GNRC_PKTBUF_SIZE - (3 * 8) -
(3 * sizeof(gnrc_pktsnip_t)) - 4;
pkt_next = gnrc_pktbuf_add(NULL, TEST_STRING8, 8, GNRC_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL(pkt_next);
/* hold to enforce duplication */
gnrc_pktbuf_hold(pkt_next, 1);
pkt = gnrc_pktbuf_add(pkt_next, TEST_STRING8, 8, GNRC_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL(pkt);
/* filling up rest of packet buffer */
pkt_huge = gnrc_pktbuf_add(NULL, NULL, pkt_huge_size, GNRC_NETTYPE_UNDEF);
TEST_ASSERT_NOT_NULL(pkt_huge);
TEST_ASSERT_NULL(gnrc_pktbuf_reverse_snips(pkt));
gnrc_pktbuf_release(pkt_huge);
/* release because of hold above */
gnrc_pktbuf_release(pkt_next);
TEST_ASSERT(gnrc_pktbuf_is_empty());
}
static bool _assemble_beacon(gnrc_netif_t *netif, uint8_t total_tdma_slot_num,
uint8_t total_tdma_node_num, uint8_t *slots_list,
gnrc_gomach_l2_id_t *id_list, gnrc_pktsnip_t **pkt,
gnrc_pktsnip_t **gomach_pkt,
gnrc_gomach_frame_beacon_t *gomach_beaocn_hdr)
{
/* If there are slots to allocate, add the slots list and the ID list to
* the beacon! */
netif->mac.rx.vtdma_manag.total_slots_num = total_tdma_slot_num;
/* Add the slots list to the beacon. */
*pkt = gnrc_pktbuf_add(NULL, slots_list, total_tdma_node_num * sizeof(uint8_t),
GNRC_NETTYPE_GOMACH);
if (*pkt == NULL) {
LOG_ERROR("ERROR: [GOMACH]: pktbuf add failed in gnrc_gomach_send_beacon().\n");
return false;
}
*gomach_pkt = *pkt;
/* Add the ID list to the beacon. */
*pkt = gnrc_pktbuf_add(*pkt, id_list, total_tdma_node_num * sizeof(gnrc_gomach_l2_id_t),
GNRC_NETTYPE_GOMACH);
if (*pkt == NULL) {
LOG_ERROR("ERROR: [GOMACH]: pktbuf add failed in gnrc_gomach_send_beacon().\n");
gnrc_pktbuf_release(*gomach_pkt);
return false;
}
*gomach_pkt = *pkt;
/* Add the GoMacH header to the beacon. */
*pkt = gnrc_pktbuf_add(*pkt, gomach_beaocn_hdr, sizeof(gnrc_gomach_frame_beacon_t),
GNRC_NETTYPE_GOMACH);
if (*pkt == NULL) {
LOG_ERROR("ERROR: [GOMACH]: pktbuf add failed in gnrc_gomach_send_beacon().\n");
gnrc_pktbuf_release(*gomach_pkt);
return false;
}
return true;
}
int gnrc_gomach_send_data(gnrc_netif_t *netif, netopt_enable_t csma_enable)
{
assert(netif != NULL);
gnrc_pktsnip_t *pkt = netif->mac.tx.packet;
assert(pkt != NULL);
/* Insert GoMacH header above NETIF header. */
gnrc_gomach_frame_data_t *gomach_data_hdr_pointer;
gnrc_pktsnip_t *gomach_snip = gnrc_pktsnip_search_type(pkt, GNRC_NETTYPE_GOMACH);
if (gomach_snip != NULL) {
gomach_data_hdr_pointer = gomach_snip->data;
}
else {
gomach_data_hdr_pointer = NULL;
}
if (gomach_data_hdr_pointer == NULL) {
/* No GoMacH header yet, build one. */
gnrc_gomach_frame_data_t gomach_data_hdr;
gomach_data_hdr.header.type = GNRC_GOMACH_FRAME_DATA;
/* Set the queue-length indicator according to its current queue situation. */
gomach_data_hdr.queue_indicator =
gnrc_priority_pktqueue_length(&netif->mac.tx.current_neighbor->queue);
/* Save the payload pointer. */
gnrc_pktsnip_t *payload = netif->mac.tx.packet->next;
pkt->next = gnrc_pktbuf_add(pkt->next, &gomach_data_hdr, sizeof(gomach_data_hdr),
GNRC_NETTYPE_GOMACH);
if (pkt->next == NULL) {
LOG_ERROR("ERROR: [GOMACH]: pktbuf add failed in gnrc_gomach_send_data().\n");
/* Make append payload after netif header again. */
netif->mac.tx.packet->next = payload;
return -ENOBUFS;
}
}
else {
/* GoMacH header exists, update the queue-indicator. */
gomach_data_hdr_pointer->queue_indicator =
gnrc_priority_pktqueue_length(&netif->mac.tx.current_neighbor->queue);
}
gnrc_pktbuf_hold(netif->mac.tx.packet, 1);
/* Send the data packet here. */
return gnrc_gomach_send(netif, netif->mac.tx.packet, csma_enable);
}
static void _send(void *data, size_t len, char *dest, size_t *dest_len)
{
gnrc_pktsnip_t *payload = gnrc_pktbuf_add(NULL, data, len, GNRC_NETTYPE_UNDEF);
gnrc_netapi_send(_kiss_pid, payload);
// force an ack using gnrc_netapi_get
gnrc_netapi_get(_kiss_pid, 0, 0, NULL, 0);
// read back from the file
*dest_len = (size_t) ftell(_kiss_file);
fseek(_kiss_file, 0, SEEK_SET);
fread(dest, 1, *dest_len, _kiss_file);
}
static void test_pktbuf_realloc_data__nomemenough(void)
{
gnrc_pktsnip_t *pkt1, *pkt2;
pkt1 = gnrc_pktbuf_add(NULL, TEST_STRING8, sizeof(TEST_STRING8), GNRC_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL(pkt1);
pkt2 = gnrc_pktbuf_add(NULL, NULL, 1, GNRC_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL(pkt2);
TEST_ASSERT_NOT_NULL(gnrc_pktbuf_add(NULL, NULL, 4, GNRC_NETTYPE_TEST));
gnrc_pktbuf_release(pkt2);
TEST_ASSERT_EQUAL_INT(0, gnrc_pktbuf_realloc_data(pkt1, 200));
TEST_ASSERT_NULL(pkt1->next);
TEST_ASSERT_EQUAL_INT(200, pkt1->size);
TEST_ASSERT_EQUAL_STRING(TEST_STRING8, pkt1->data);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, pkt1->type);
TEST_ASSERT_EQUAL_INT(1, pkt1->users);
}
static void test_pktbuf_realloc_data__memenough(void)
{
gnrc_pktsnip_t *pkt;
pkt = gnrc_pktbuf_add(NULL, NULL, sizeof(TEST_STRING16), GNRC_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL(pkt);
TEST_ASSERT_EQUAL_INT(0, gnrc_pktbuf_realloc_data(pkt, sizeof(TEST_STRING8)));
TEST_ASSERT_NULL(pkt->next);
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING8), pkt->size);
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, pkt->type);
TEST_ASSERT_EQUAL_INT(1, pkt->users);
}
static void test_pktbuf_get_iovec__3_elem(void)
{
struct iovec *vec;
size_t len;
gnrc_pktsnip_t *snip = gnrc_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16),
GNRC_NETTYPE_UNDEF);
snip = gnrc_pktbuf_add(snip, TEST_STRING8, sizeof(TEST_STRING8), GNRC_NETTYPE_UNDEF);
snip = gnrc_pktbuf_add(snip, TEST_STRING4, sizeof(TEST_STRING4), GNRC_NETTYPE_UNDEF);
snip = gnrc_pktbuf_get_iovec(snip, &len);
vec = (struct iovec *)snip->data;
TEST_ASSERT_EQUAL_INT((sizeof(struct iovec) * 3), snip->size);
TEST_ASSERT_EQUAL_INT(3, len);
TEST_ASSERT(snip->next->data == vec[0].iov_base);
TEST_ASSERT(snip->next->next->data == vec[1].iov_base);
TEST_ASSERT(snip->next->next->next->data == vec[2].iov_base);
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING4), vec[0].iov_len);
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING8), vec[1].iov_len);
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING16), vec[2].iov_len);
gnrc_pktbuf_release(snip);
TEST_ASSERT(gnrc_pktbuf_is_empty());
}
static void test_pktbuf_release__short_pktsnips(void)
{
gnrc_pktsnip_t *pkt = gnrc_pktbuf_add(NULL, TEST_STRING8, sizeof(TEST_STRING8),
GNRC_NETTYPE_UNDEF);
gnrc_pktsnip_t *hdr = gnrc_pktbuf_mark(pkt, sizeof(TEST_STRING8) - 1, GNRC_NETTYPE_TEST);
TEST_ASSERT(pkt);
TEST_ASSERT(hdr);
TEST_ASSERT(pkt->next == hdr);
TEST_ASSERT(hdr->next == NULL);
TEST_ASSERT_EQUAL_INT(hdr->size, sizeof(TEST_STRING8) - 1);
TEST_ASSERT_EQUAL_INT(pkt->size, 1);
gnrc_pktbuf_release(pkt);
TEST_ASSERT(gnrc_pktbuf_is_empty());
}
static void test_pktbuf_mark__pkt_NOT_NULL__size_0(void)
{
gnrc_pktsnip_t *pkt = gnrc_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16),
GNRC_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL(pkt);
TEST_ASSERT_NULL(gnrc_pktbuf_mark(pkt, 0, GNRC_NETTYPE_TEST));
TEST_ASSERT_NULL(pkt->next);
TEST_ASSERT_NOT_NULL(pkt->data);
TEST_ASSERT_EQUAL_STRING(TEST_STRING16, 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);
}
int conn_ip_sendto(const void *data, size_t len, const void *src, size_t src_len,
void *dst, size_t dst_len, int family, int proto)
{
gnrc_pktsnip_t *pkt, *hdr = NULL;
gnrc_nettype_t l3_type;
pkt = gnrc_pktbuf_add(NULL, (void *)data, len, GNRC_NETTYPE_UNDEF); /* data will only be copied */
switch (family) {
#ifdef MODULE_GNRC_IPV6
case AF_INET6:
if (((src != NULL) && (src_len != sizeof(ipv6_addr_t))) ||
(dst_len != sizeof(ipv6_addr_t)) ||
(((unsigned)proto) > 256U)) {
gnrc_pktbuf_release(pkt);
return -EINVAL;
}
/* addr will only be copied */
hdr = gnrc_ipv6_hdr_build(pkt, (uint8_t *)src, src_len, (uint8_t *)dst, dst_len);
if (hdr == NULL) {
gnrc_pktbuf_release(pkt);
return -ENOMEM;
}
/* set next header to connection's proto */
ipv6_hdr_t *ipv6_hdr = hdr->data;
ipv6_hdr->nh = (uint8_t)proto;
pkt = hdr;
l3_type = GNRC_NETTYPE_IPV6;
break;
#endif /* MODULE_GNRC_IPV6 */
default:
(void)src;
(void)src_len;
(void)dst;
(void)dst_len;
(void)proto;
(void)hdr;
gnrc_pktbuf_release(pkt);
return -EAFNOSUPPORT;
}
gnrc_netapi_dispatch_send(l3_type, GNRC_NETREG_DEMUX_CTX_ALL, pkt);
return len;
}
int conn_udp_sendto(const void *data, size_t len, const void *src, size_t src_len,
const void *dst, size_t dst_len, int family, uint16_t sport,
uint16_t dport)
{
gnrc_pktsnip_t *pkt, *hdr = NULL;
pkt = gnrc_pktbuf_add(NULL, (void *)data, len, GNRC_NETTYPE_UNDEF); /* data will only be copied */
hdr = gnrc_udp_hdr_build(pkt, (uint8_t *)&sport, sizeof(uint16_t), (uint8_t *)&dport,
sizeof(uint16_t));
if (hdr == NULL) {
gnrc_pktbuf_release(pkt);
return -ENOMEM;
}
pkt = hdr;
switch (family) {
#ifdef MODULE_GNRC_IPV6
case AF_INET6:
if (((src != NULL) && (src_len != sizeof(ipv6_addr_t))) ||
(dst_len != sizeof(ipv6_addr_t))) {
gnrc_pktbuf_release(pkt);
return -EINVAL;
}
/* addr will only be copied */
hdr = gnrc_ipv6_hdr_build(pkt, (uint8_t *)src, src_len, (uint8_t *)dst, dst_len);
if (hdr == NULL) {
gnrc_pktbuf_release(pkt);
return -ENOMEM;
}
pkt = hdr;
break;
#endif /* MODULE_GNRC_IPV6 */
default:
(void)hdr;
(void)src;
(void)src_len;
(void)dst;
(void)dst_len;
gnrc_pktbuf_release(pkt);
return -EAFNOSUPPORT;
}
gnrc_netapi_dispatch_send(GNRC_NETTYPE_UDP, GNRC_NETREG_DEMUX_CTX_ALL, pkt);
return len;
}
static inline bool _add_uncompr_disp(gnrc_pktsnip_t *pkt)
{
gnrc_pktsnip_t *sixlowpan;
uint8_t *disp;
DEBUG("6lo: Send uncompressed\n");
sixlowpan = gnrc_pktbuf_add(NULL, NULL, sizeof(uint8_t), GNRC_NETTYPE_SIXLOWPAN);
if (sixlowpan == NULL) {
return false;
}
sixlowpan->next = pkt->next;
pkt->next = sixlowpan;
disp = sixlowpan->data;
disp[0] = SIXLOWPAN_UNCOMP;
return true;
}
static void test_pktbuf_add__packed_struct(void)
{
test_pktbuf_struct_t data = { 0x4d, 0xef43, 0xacdef574, 0x43644305695afde5,
34, -4469, 149699748, -46590430597
};
test_pktbuf_struct_t *data_cpy;
gnrc_pktsnip_t *pkt = gnrc_pktbuf_add(NULL, &data, sizeof(test_pktbuf_struct_t), GNRC_NETTYPE_TEST);
data_cpy = (test_pktbuf_struct_t *)pkt->data;
TEST_ASSERT_EQUAL_INT(data.u8, data_cpy->u8);
TEST_ASSERT_EQUAL_INT(data.u16, data_cpy->u16);
TEST_ASSERT_EQUAL_INT(data.u32, data_cpy->u32);
TEST_ASSERT_EQUAL_INT(data.u64, data_cpy->u64);
TEST_ASSERT_EQUAL_INT(data.s8, data_cpy->s8);
TEST_ASSERT_EQUAL_INT(data.s16, data_cpy->s16);
TEST_ASSERT_EQUAL_INT(data.s32, data_cpy->s32);
TEST_ASSERT_EQUAL_INT(data.s64, data_cpy->s64);
}
static void test_pktbuf_start_write__pkt_users_2(void)
{
gnrc_pktsnip_t *pkt_copy, *pkt = gnrc_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16),
GNRC_NETTYPE_TEST);
gnrc_pktbuf_hold(pkt, 1);
TEST_ASSERT_NOT_NULL((pkt_copy = gnrc_pktbuf_start_write(pkt)));
TEST_ASSERT(pkt != pkt_copy);
TEST_ASSERT(pkt->next == pkt_copy->next);
TEST_ASSERT_EQUAL_STRING(pkt->data, pkt_copy->data);
TEST_ASSERT_EQUAL_INT(pkt->size, pkt_copy->size);
TEST_ASSERT_EQUAL_INT(pkt->type, pkt_copy->type);
TEST_ASSERT_EQUAL_INT(pkt->users, pkt_copy->users);
TEST_ASSERT_EQUAL_INT(1, pkt->users);
gnrc_pktbuf_release(pkt_copy);
gnrc_pktbuf_release(pkt);
TEST_ASSERT(gnrc_pktbuf_is_empty());
}
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_realloc_data__success(void)
{
char exp_data[] = TEST_STRING16;
gnrc_pktsnip_t *pkt;
pkt = gnrc_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16), GNRC_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL(pkt);
TEST_ASSERT_EQUAL_INT(0, gnrc_pktbuf_realloc_data(pkt, sizeof(TEST_STRING8)));
TEST_ASSERT_NULL(pkt->next);
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING8), pkt->size);
for (unsigned int i = 0; i < pkt->size; i++) {
uint8_t *data = pkt->data;
TEST_ASSERT_EQUAL_INT(exp_data[i], data[i]);
}
TEST_ASSERT_EQUAL_INT(GNRC_NETTYPE_TEST, pkt->type);
TEST_ASSERT_EQUAL_INT(1, pkt->users);
}
