/* 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); }