/* shell commands */
int _netif_send(int argc, char **argv)
{
kernel_pid_t dev;
uint8_t addr[MAX_ADDR_LEN];
size_t addr_len;
ng_pktsnip_t *pkt;
ng_netif_hdr_t *nethdr;
uint8_t flags = 0x00;
if (argc < 4) {
printf("usage: %s <if> [<addr>|bcast] <data>\n", argv[0]);
return 1;
}
/* parse interface */
dev = (kernel_pid_t)atoi(argv[1]);
if (!_is_iface(dev)) {
puts("error: invalid interface given");
return 1;
}
/* parse address */
addr_len = ng_netif_addr_from_str(addr, sizeof(addr), argv[2]);
if (addr_len == 0) {
if (strcmp(argv[2], "bcast") == 0) {
flags |= NG_NETIF_HDR_FLAGS_BROADCAST;
}
else {
puts("error: invalid address given");
return 1;
}
}
/* put packet together */
pkt = ng_pktbuf_add(NULL, argv[3], strlen(argv[3]), NG_NETTYPE_UNDEF);
pkt = ng_pktbuf_add(pkt, NULL, sizeof(ng_netif_hdr_t) + addr_len,
NG_NETTYPE_NETIF);
nethdr = (ng_netif_hdr_t *)pkt->data;
ng_netif_hdr_init(nethdr, 0, addr_len);
ng_netif_hdr_set_dst_addr(nethdr, addr, addr_len);
nethdr->flags = flags;
/* and send it */
ng_netapi_send(dev, pkt);
return 0;
}
static ng_pktsnip_t *_build_frag_pkt(ng_pktsnip_t *pkt, size_t payload_len,
size_t size)
{
ng_netif_hdr_t *hdr = pkt->data, *new_hdr;
ng_pktsnip_t *netif, *frag;
netif = ng_netif_hdr_build(ng_netif_hdr_get_src_addr(hdr), hdr->src_l2addr_len,
ng_netif_hdr_get_dst_addr(hdr), hdr->dst_l2addr_len);
if (netif == NULL) {
DEBUG("6lo frag: error allocating new link-layer header\n");
return NULL;
}
new_hdr = netif->data;
new_hdr->if_pid = hdr->if_pid;
new_hdr->flags = hdr->flags;
new_hdr->rssi = hdr->rssi;
new_hdr->lqi = hdr->lqi;
frag = ng_pktbuf_add(NULL, NULL, _min(size, payload_len),
NG_NETTYPE_SIXLOWPAN);
if (frag == NULL) {
DEBUG("6lo frag: error allocating first fragment\n");
ng_pktbuf_release(netif);
return NULL;
}
LL_PREPEND(frag, netif);
return frag;
}
static void test_pktbuf_add__pkt_NOT_NULL__data_NOT_NULL__size_0(void)
{
ng_pktsnip_t *next = ng_pktbuf_add(NULL, TEST_STRING4, sizeof(TEST_STRING4),
NG_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL(next);
TEST_ASSERT_NULL(ng_pktbuf_add(next, TEST_STRING8, 0, NG_NETTYPE_TEST));
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(NG_NETTYPE_TEST, next->type);
TEST_ASSERT(ng_pktbuf_is_sane());
TEST_ASSERT(!ng_pktbuf_is_empty());
}
static void test_pktbuf_hold__success2(void)
{
ng_pktsnip_t *pkt = ng_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16), NG_NETTYPE_TEST);
ng_pktbuf_hold(pkt, TEST_UINT8);
TEST_ASSERT_EQUAL_INT(TEST_UINT8 + 1, pkt->users);
}
static void test_pktbuf_realloc_data__size_0(void)
{
ng_pktsnip_t *pkt = ng_pktbuf_add(NULL, NULL, sizeof(TEST_STRING8), NG_NETTYPE_UNDEF);
TEST_ASSERT_EQUAL_INT(ENOMEM, ng_pktbuf_realloc_data(pkt, 0));
ng_pktbuf_release(pkt);
TEST_ASSERT(ng_pktbuf_is_empty());
}
static void test_pktbuf_realloc_data__memfull(void)
{
ng_pktsnip_t *pkt = ng_pktbuf_add(NULL, NULL, sizeof(TEST_STRING8), NG_NETTYPE_TEST);
TEST_ASSERT_EQUAL_INT(ENOMEM, ng_pktbuf_realloc_data(pkt, NG_PKTBUF_SIZE + 1));
ng_pktbuf_release(pkt);
TEST_ASSERT(ng_pktbuf_is_empty());
}
static void test_pktbuf_mark__success_aligned(void)
{
uint8_t *data = (uint8_t *)(TEST_STRING16);
ng_pktsnip_t *pkt1 = ng_pktbuf_add(NULL, data, sizeof(TEST_STRING16),
NG_NETTYPE_TEST);
ng_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 = ng_pktbuf_mark(pkt1, 8, NG_NETTYPE_UNDEF)));
TEST_ASSERT(ng_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(NG_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(NG_NETTYPE_UNDEF, pkt2->type);
TEST_ASSERT_EQUAL_INT(1, pkt2->users);
/* check if slightly larger packet would override data */
ng_pktbuf_remove_snip(pkt1, pkt2);
pkt2 = ng_pktbuf_add(NULL, TEST_STRING12, 12, NG_NETTYPE_TEST);
TEST_ASSERT(ng_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(NG_NETTYPE_TEST, pkt1->type);
TEST_ASSERT_EQUAL_INT(1, pkt1->users);
/* check if everything can be cleaned up */
ng_pktbuf_release(pkt1);
ng_pktbuf_release(pkt2);
TEST_ASSERT(ng_pktbuf_is_empty());
}
ng_pktsnip_t *ng_ipv6_hdr_build(ng_pktsnip_t *payload,
uint8_t *src, uint8_t src_len,
uint8_t *dst, uint8_t dst_len)
{
ng_pktsnip_t *ipv6;
ng_ipv6_hdr_t *hdr;
if (((src_len != 0) && (src_len != sizeof(ng_ipv6_addr_t))) ||
((dst_len != 0) && (dst_len != sizeof(ng_ipv6_addr_t)))) {
DEBUG("ipv6_hdr: Address length was not 0 or %zu byte.\n",
sizeof(ng_ipv6_addr_t));
return NULL;
}
ipv6 = ng_pktbuf_add(payload, NULL, sizeof(ng_ipv6_hdr_t), HDR_NETTYPE);
if (ipv6 == NULL) {
DEBUG("ipv6_hdr: no space left in packet buffer\n");
return NULL;
}
hdr = (ng_ipv6_hdr_t *)ipv6->data;
if ((src != NULL) && (src_len != 0)) {
#ifdef MODULE_NG_IPV6_ADDR
DEBUG("ipv6_hdr: set packet source to %s\n",
ng_ipv6_addr_to_str(addr_str, (ng_ipv6_addr_t *)src,
sizeof(addr_str)));
#endif
memcpy(&hdr->src, src, src_len);
}
else {
DEBUG("ipv6_hdr: set packet source to ::\n");
ng_ipv6_addr_set_unspecified(&hdr->src);
}
memset(&hdr->dst + dst_len, 0, sizeof(ng_ipv6_addr_t) - dst_len);
if ((dst != NULL) && (dst_len != 0)) {
#ifdef MODULE_NG_IPV6_ADDR
DEBUG("ipv6_hdr: set packet destination to %s\n",
ng_ipv6_addr_to_str(addr_str, (ng_ipv6_addr_t *)dst,
sizeof(addr_str)));
#endif
memcpy(&hdr->dst, dst, dst_len);
}
else {
DEBUG("ipv6_hdr: set packet destination to ::1\n");
ng_ipv6_addr_set_loopback(&hdr->dst);
}
hdr->v_tc_fl = byteorder_htonl(0x60000000); /* set version, tc and fl in one go*/
hdr->nh = PROTNUM_RESERVED;
hdr->hl = 0;
return ipv6;
}
static void test_pktbuf_realloc_data__shrink(void)
{
ng_pktsnip_t *pkt;
void *exp_data;
pkt = ng_pktbuf_add(NULL, NULL, sizeof(TEST_STRING16), NG_NETTYPE_TEST);
exp_data = pkt->data;
TEST_ASSERT_NOT_NULL(pkt);
TEST_ASSERT_NOT_NULL(ng_pktbuf_add(NULL, NULL, 4, NG_NETTYPE_TEST));
TEST_ASSERT_EQUAL_INT(0, ng_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(NG_NETTYPE_TEST, pkt->type);
TEST_ASSERT_EQUAL_INT(1, pkt->users);
}
static void test_pktbuf_add__unaligned_in_aligned_hole(void)
{
ng_pktsnip_t *pkt1 = ng_pktbuf_add(NULL, NULL, 8, NG_NETTYPE_TEST);
ng_pktsnip_t *pkt2 = ng_pktbuf_add(NULL, NULL, 8, NG_NETTYPE_TEST);
ng_pktsnip_t *pkt3 = ng_pktbuf_add(NULL, NULL, 8, NG_NETTYPE_TEST);
ng_pktsnip_t *pkt4;
void *tmp_data2 = pkt2->data;
ng_pktbuf_release(pkt2);
pkt4 = ng_pktbuf_add(NULL, TEST_STRING12, 9, NG_NETTYPE_TEST);
TEST_ASSERT(tmp_data2 != pkt4->data);
ng_pktbuf_release(pkt1);
ng_pktbuf_release(pkt3);
ng_pktbuf_release(pkt4);
TEST_ASSERT(ng_pktbuf_is_empty());
}
static void send(char *addr_str, char *port_str, char *data)
{
uint8_t port[2];
uint16_t tmp;
ng_pktsnip_t *payload, *udp, *ip;
ng_ipv6_addr_t addr;
ng_netreg_entry_t *sendto;
/* parse destination address */
if (ng_ipv6_addr_from_str(&addr, addr_str) == NULL) {
puts("Error: unable to parse destination address");
return;
}
/* parse port */
tmp = (uint16_t)atoi(port_str);
if (tmp == 0) {
puts("Error: unable to parse destination port");
return;
}
port[0] = (uint8_t)tmp;
port[1] = tmp >> 8;
/* allocate payload */
payload = ng_pktbuf_add(NULL, data, strlen(data), NG_NETTYPE_UNDEF);
if (payload == NULL) {
puts("Error: unable to copy data to packet buffer");
return;
}
/* allocate UDP header, set source port := destination port */
udp = ng_udp_hdr_build(payload, port, 2, port, 2);
if (udp == NULL) {
puts("Error: unable to allocate UDP header");
ng_pktbuf_release(payload);
return;
}
/* allocate IPv6 header */
ip = ng_ipv6_hdr_build(udp, NULL, 0, (uint8_t *)&addr, sizeof(addr));
if (ip == NULL) {
puts("Error: unable to allocate IPv6 header");
ng_pktbuf_release(udp);
return;
}
/* send packet */
sendto = ng_netreg_lookup(NG_NETTYPE_UDP, NG_NETREG_DEMUX_CTX_ALL);
if (sendto == NULL) {
puts("Error: unable to locate UDP thread");
ng_pktbuf_release(ip);
return;
}
ng_pktbuf_hold(ip, ng_netreg_num(NG_NETTYPE_UDP,
NG_NETREG_DEMUX_CTX_ALL) - 1);
while (sendto != NULL) {
ng_netapi_send(sendto->pid, ip);
sendto = ng_netreg_getnext(sendto);
}
printf("Success: send %i byte to %s:%u\n", payload->size, addr_str, tmp);
}
void icn_initInterest(uint16_t seq) {
if (WANT_CONTENT) {
uint32_t tmp1;
uint16_t tmp2;
tmp1 = _getSmallestMissing();
LOG_DEBUG("Smallest missing is %lu\n", tmp1);
tmp2 = seq;
if ((tmp1 < NUMBER_OF_CHUNKS) && (tmp1 >= 0)) {
LOG_INFO("Scheduling retransmission for %lu\n", tmp1);
vtimer_remove(&retry_vt);
vtimer_set_msg(&retry_vt, retry_interval, thread_getpid(), ICN_RESEND_INTEREST, &tmp1);
}
if (bf_isset(received_chunks, seq)) {
LOG_INFO("Already received a chunk for %u, not sending again\n", seq);
return;
}
#if FLOW_CONTROL
if (seq > (receive_counter + FLOW_THR)) {
LOG_INFO("Flow control, seq is %u, receive counter is %u\n",
seq, receive_counter);
return;
}
#endif
/* create packet */
ng_pktsnip_t *pkt;
icn_pkt_t icn_pkt;
icn_pkt.type = ICN_INTEREST;
icn_pkt.seq = seq;
memcpy(icn_pkt.payload, interest, strlen(interest) + 1);
pkt = ng_pktbuf_add(NULL, &icn_pkt, sizeof(icn_pkt_t), NG_NETTYPE_UNDEF);
// send interest packet
if (tmp2 < NUMBER_OF_CHUNKS) {
LOG_INFO("Sending Interest for %u to %s\n", seq,
ng_netif_addr_to_str(l2addr_str, sizeof(l2addr_str),
CONTENT_STORE->uint8, ADDR_LEN_64B));
icn_send(CONTENT_STORE, pkt);
}
if (tmp2 < NUMBER_OF_CHUNKS) {
tmp2++;
#if TIMED_SENDING
vtimer_remove(&periodic_vt);
vtimer_set_msg(&periodic_vt, interval, thread_getpid(), ICN_SEND_INTEREST, &tmp2);
#else
icn_initInterest(tmp2);
#endif
}
}
else {
LOG_DEBUG("nothing to do\n");
}
}
static void test_pktbuf_hold__success(void)
{
ng_pktsnip_t *pkt = ng_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16), NG_NETTYPE_TEST);
for (uint8_t i = 0; i < TEST_UINT8; i++) {
uint8_t prev_users = pkt->users;
ng_pktbuf_hold(pkt, 1);
TEST_ASSERT_EQUAL_INT(prev_users + 1, pkt->users);
}
}
static void test_pktbuf_start_write__pkt_users_1(void)
{
ng_pktsnip_t *pkt_copy, *pkt = ng_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16),
NG_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL((pkt_copy = ng_pktbuf_start_write(pkt)));
TEST_ASSERT(pkt == pkt_copy);
ng_pktbuf_release(pkt);
TEST_ASSERT(ng_pktbuf_is_empty());
}
static void test_pktbuf_realloc_data__pkt_users_gt_1(void)
{
ng_pktsnip_t *pkt = ng_pktbuf_add(NULL, NULL, sizeof(TEST_STRING8), NG_NETTYPE_UNDEF);
ng_pktbuf_hold(pkt, 1);
TEST_ASSERT_EQUAL_INT(EINVAL, ng_pktbuf_realloc_data(pkt, sizeof(TEST_STRING8) - 1));
ng_pktbuf_release(pkt);
ng_pktbuf_release(pkt);
TEST_ASSERT(ng_pktbuf_is_empty());
}
static void test_pktbuf_add__in_place(void)
{
ng_pktsnip_t *pkt = ng_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16),
NG_NETTYPE_UNDEF);
ng_pktsnip_t *header;
TEST_ASSERT_NOT_NULL((header = ng_pktbuf_add(pkt, pkt->data, 4, NG_NETTYPE_UNDEF)));
TEST_ASSERT(header == pkt->next);
TEST_ASSERT_EQUAL_STRING(TEST_STRING16, header->data); /* there is no 0 byte */
TEST_ASSERT_EQUAL_INT(4, header->size);
TEST_ASSERT_EQUAL_INT(NG_NETTYPE_UNDEF, header->type);
TEST_ASSERT_EQUAL_INT(1, header->users);
TEST_ASSERT_EQUAL_STRING(TEST_STRING16 + 4, pkt->data);
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING16) - 4, pkt->size);
TEST_ASSERT_EQUAL_INT(NG_NETTYPE_UNDEF, pkt->type);
TEST_ASSERT_EQUAL_INT(1, pkt->users);
ng_pktbuf_release(header);
ng_pktbuf_release(pkt);
TEST_ASSERT(ng_pktbuf_is_empty());
}
static void test_pktbuf_realloc_data__pkt_data_wrong(void)
{
ng_pktsnip_t *pkt = ng_pktbuf_add(NULL, NULL, sizeof(TEST_STRING8), NG_NETTYPE_UNDEF);
void *orig_data = pkt->data;
pkt->data = TEST_STRING8;
TEST_ASSERT_EQUAL_INT(ENOENT, ng_pktbuf_realloc_data(pkt, 0));
pkt->data = orig_data;
ng_pktbuf_release(pkt);
TEST_ASSERT(ng_pktbuf_is_empty());
}
/*
* Event handlers
*/
static void _receive_data(void)
{
packet_t *data;
ng_pktsnip_t *pkt_head;
ng_pktsnip_t *pkt;
ng_netif_hdr_t *hdr;
ng_nettype_t nettype;
/* only read data if we have somewhere to send it to */
if (_netdev->event_cb == NULL) {
return;
}
/* get pointer to RX data buffer */
data = &(_rx_buf[_rx_next ^ 1]);
/* allocate and fill netif header */
pkt_head = ng_pktbuf_add(NULL, NULL, sizeof(ng_netif_hdr_t) + 4,
NG_NETTYPE_UNDEF);
if (pkt_head == NULL) {
DEBUG("nrfmin: Error allocating netif header on RX\n");
return;
}
hdr = (ng_netif_hdr_t *)pkt_head->data;
ng_netif_hdr_init(hdr, 2, 2);
hdr->if_pid = _netdev->mac_pid;
ng_netif_hdr_set_src_addr(hdr, data->src_addr, 2);
ng_netif_hdr_set_dst_addr(hdr, data->dst_addr, 2);
/* allocate and fill payload */
nettype = _nrftype_to_nettype(data->proto);
pkt = ng_pktbuf_add(pkt_head, data->payload, data->length - 6, nettype);
if (pkt == NULL) {
DEBUG("nrfmin: Error allocating packet payload on RX\n");
ng_pktbuf_release(pkt_head);
return;
}
/* pass on the received packet */
_netdev->event_cb(NETDEV_EVENT_RX_COMPLETE, pkt);
}
static void test_pktbuf_add__pkt_NOT_NULL__data_NULL__size_0(void)
{
ng_pktsnip_t *pkt, *next = ng_pktbuf_add(NULL, TEST_STRING4, sizeof(TEST_STRING4),
NG_NETTYPE_UNDEF);
TEST_ASSERT_NOT_NULL(next);
TEST_ASSERT_NOT_NULL((pkt = ng_pktbuf_add(next, NULL, 0, NG_NETTYPE_UNDEF)));
TEST_ASSERT(pkt->next == next);
TEST_ASSERT_NULL(pkt->data);
TEST_ASSERT_EQUAL_INT(0, pkt->size);
TEST_ASSERT_EQUAL_INT(NG_NETTYPE_UNDEF, 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(NG_NETTYPE_UNDEF, pkt->type);
TEST_ASSERT(!ng_pktbuf_is_empty());
}
static void test_pktbuf_add__pkt_NULL__data_NULL__size_0(void)
{
ng_pktsnip_t *pkt;
TEST_ASSERT_NOT_NULL((pkt = ng_pktbuf_add(NULL, NULL, 0, NG_NETTYPE_UNDEF)));
TEST_ASSERT_NULL(pkt->next);
TEST_ASSERT_NULL(pkt->data);
TEST_ASSERT_EQUAL_INT(0, pkt->size);
TEST_ASSERT_EQUAL_INT(NG_NETTYPE_UNDEF, pkt->type);
TEST_ASSERT(!ng_pktbuf_is_empty());
}
void icn_initContent(eui64_t *lastHop, uint16_t seq) {
/* create packet */
ng_pktsnip_t *pkt;
icn_pkt_t icn_pkt;
icn_pkt.type = ICN_CONTENT;
icn_pkt.seq = seq;
memcpy(icn_pkt.payload, content, strlen(content) + 1);
pkt = ng_pktbuf_add(NULL, &icn_pkt, sizeof(icn_pkt_t), NG_NETTYPE_UNDEF);
// send interest packet
icn_send(lastHop, pkt);
}
static void test_pktbuf_realloc_data__nomemenough(void)
{
ng_pktsnip_t *pkt1, *pkt2;
pkt1 = ng_pktbuf_add(NULL, TEST_STRING8, sizeof(TEST_STRING8), NG_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL(pkt1);
pkt2 = ng_pktbuf_add(NULL, NULL, 1, NG_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL(pkt2);
TEST_ASSERT_NOT_NULL(ng_pktbuf_add(NULL, NULL, 4, NG_NETTYPE_TEST));
ng_pktbuf_release(pkt2);
TEST_ASSERT_EQUAL_INT(0, ng_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(NG_NETTYPE_TEST, pkt1->type);
TEST_ASSERT_EQUAL_INT(1, pkt1->users);
}
static void test_pktbuf_realloc_data__memenough(void)
{
ng_pktsnip_t *pkt;
pkt = ng_pktbuf_add(NULL, NULL, sizeof(TEST_STRING16), NG_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL(pkt);
TEST_ASSERT_EQUAL_INT(0, ng_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(NG_NETTYPE_TEST, pkt->type);
TEST_ASSERT_EQUAL_INT(1, pkt->users);
}
static void _receive(ng_pktsnip_t *pkt)
{
ng_pktsnip_t *udp, *ipv6;
ng_udp_hdr_t *hdr;
uint32_t port;
ng_netreg_entry_t *sendto;
/* mark UDP header */
udp = ng_pktbuf_start_write(pkt);
if (udp == NULL) {
DEBUG("udp: unable to get write access to packet\n");
ng_pktbuf_release(pkt);
return;
}
pkt = udp;
udp = ng_pktbuf_add(pkt, pkt->data, sizeof(ng_udp_hdr_t), NG_NETTYPE_UDP);
if (udp == NULL) {
DEBUG("udp: error marking UDP header, dropping packet\n");
ng_pktbuf_release(pkt);
return;
}
/* mark payload as Type: UNDEF */
pkt->type = NG_NETTYPE_UNDEF;
/* get explicit pointer to UDP header */
hdr = (ng_udp_hdr_t *)udp->data;
LL_SEARCH_SCALAR(pkt, ipv6, type, NG_NETTYPE_IPV6);
/* validate checksum */
if (_calc_csum(udp, ipv6, pkt)) {
DEBUG("udp: received packet with invalid checksum, dropping it\n");
ng_pktbuf_release(pkt);
return;
}
/* get port (netreg demux context) */
port = (uint32_t)byteorder_ntohs(hdr->dst_port);
/* send payload to receivers */
sendto = ng_netreg_lookup(NG_NETTYPE_UDP, port);
if (sendto == NULL) {
DEBUG("udp: unable to forward packet as no one is interested in it\n");
ng_pktbuf_release(pkt);
return;
}
ng_pktbuf_hold(pkt, ng_netreg_num(NG_NETTYPE_UDP, port) - 1);
while (sendto != NULL) {
ng_netapi_receive(sendto->pid, pkt);
sendto = ng_netreg_getnext(sendto);
}
}
static void test_pktbuf_get_iovec__3_elem(void)
{
struct iovec *vec;
size_t len;
ng_pktsnip_t *snip = ng_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16),
NG_NETTYPE_UNDEF);
snip = ng_pktbuf_add(snip, TEST_STRING8, sizeof(TEST_STRING8), NG_NETTYPE_UNDEF);
snip = ng_pktbuf_add(snip, TEST_STRING4, sizeof(TEST_STRING4), NG_NETTYPE_UNDEF);
snip = ng_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);
ng_pktbuf_release(snip);
TEST_ASSERT(ng_pktbuf_is_empty());
}
static void test_pktbuf_add__pkt_NULL__data_NULL__size_not_0(void)
{
ng_pktsnip_t *pkt;
TEST_ASSERT_NOT_NULL((pkt = ng_pktbuf_add(NULL, NULL, sizeof(TEST_STRING8),
NG_NETTYPE_UNDEF)));
TEST_ASSERT_NULL(pkt->next);
TEST_ASSERT_NOT_NULL(pkt->data);
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING8), pkt->size);
TEST_ASSERT_EQUAL_INT(NG_NETTYPE_UNDEF, pkt->type);
TEST_ASSERT_EQUAL_INT(1, pkt->users);
TEST_ASSERT(!ng_pktbuf_is_empty());
}
static void test_pktbuf_mark__pkt_NOT_NULL__size_0(void)
{
ng_pktsnip_t *pkt = ng_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16),
NG_NETTYPE_TEST);
TEST_ASSERT_NOT_NULL(pkt);
TEST_ASSERT_NULL(ng_pktbuf_mark(pkt, 0, NG_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(NG_NETTYPE_TEST, pkt->type);
TEST_ASSERT_EQUAL_INT(1, pkt->users);
}
static void test_pktbuf_realloc_data__success2(void)
{
ng_pktsnip_t *pkt;
pkt = ng_pktbuf_add(NULL, TEST_STRING8, sizeof(TEST_STRING8), NG_NETTYPE_UNDEF);
TEST_ASSERT_NOT_NULL(pkt);
TEST_ASSERT_EQUAL_INT(0, ng_pktbuf_realloc_data(pkt, sizeof(TEST_STRING16)));
TEST_ASSERT_NULL(pkt->next);
TEST_ASSERT_EQUAL_STRING(TEST_STRING8, pkt->data);
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING16), pkt->size);
TEST_ASSERT_EQUAL_INT(NG_NETTYPE_UNDEF, pkt->type);
TEST_ASSERT_EQUAL_INT(1, pkt->users);
}
ng_pktsnip_t *ng_ndp_opt_build(uint8_t type, size_t size, ng_pktsnip_t *next)
{
ng_ndp_opt_t *opt;
ng_pktsnip_t *pkt = ng_pktbuf_add(next, NULL, _ceil8(size), NG_NETTYPE_UNDEF);
if (pkt == NULL) {
DEBUG("ndp: no space left in packet buffer\n");
return NULL;
}
opt = pkt->data;
opt->type = type;
opt->len = (uint8_t)(pkt->size / 8);
return pkt;
}
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;
ng_pktsnip_t *pkt = ng_pktbuf_add(NULL, &data, sizeof(test_pktbuf_struct_t), NG_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);
}
