static void test_pktbuf_realloc_data__further_down_the_line(void)
{
ng_pktsnip_t *pkt1, *pkt2, *header;
void *exp_data;
pkt1 = ng_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16), NG_NETTYPE_UNDEF);
exp_data = pkt1->data;
TEST_ASSERT_NOT_NULL(pkt1);
header = ng_pktbuf_add(pkt1, pkt1->data, 4, NG_NETTYPE_UNDEF);
pkt2 = ng_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16), NG_NETTYPE_UNDEF);
TEST_ASSERT_NOT_NULL(header);
TEST_ASSERT(header == pkt1->next);
TEST_ASSERT_EQUAL_INT(4, header->size);
TEST_ASSERT(((uint8_t *)pkt1->data) == (((uint8_t *)header->data) + 4));
TEST_ASSERT_EQUAL_INT(sizeof(TEST_STRING16) - 4, pkt1->size);
TEST_ASSERT_EQUAL_INT(0, ng_pktbuf_realloc_data(header, 40));
TEST_ASSERT(exp_data != header->data);
TEST_ASSERT_NULL(header->next);
TEST_ASSERT_EQUAL_STRING(TEST_STRING16, header->data);
TEST_ASSERT_EQUAL_INT(40, header->size);
TEST_ASSERT_EQUAL_INT(NG_NETTYPE_UNDEF, header->type);
TEST_ASSERT_EQUAL_INT(1, header->users);
ng_pktbuf_release(pkt1);
ng_pktbuf_release(pkt2);
TEST_ASSERT(ng_pktbuf_is_empty());
}
static void _send(ng_pktsnip_t *pkt)
{
ng_udp_hdr_t *hdr;
ng_pktsnip_t *udp_snip;
ng_netreg_entry_t *sendto;
/* get udp snip and hdr */
LL_SEARCH_SCALAR(pkt, udp_snip, type, NG_NETTYPE_UDP);
udp_snip = ng_pktbuf_start_write(udp_snip);
if (udp_snip == NULL) {
DEBUG("udp: cannot send packet: unable to allocate packet\n");
ng_pktbuf_release(pkt);
return;
}
hdr = (ng_udp_hdr_t *)udp_snip->data;
/* fill in size field */
hdr->length = byteorder_htons(ng_pkt_len(udp_snip));
/* and forward packet to the network layer */
sendto = ng_netreg_lookup(pkt->type, NG_NETREG_DEMUX_CTX_ALL);
/* throw away packet if no one is interested */
if (sendto == NULL) {
DEBUG("udp: cannot send packet: network layer not found\n");
ng_pktbuf_release(pkt);
return;
}
/* send packet to network layer */
ng_pktbuf_hold(pkt, ng_netreg_num(pkt->type, NG_NETREG_DEMUX_CTX_ALL) - 1);
while (sendto != NULL) {
ng_netapi_send(sendto->pid, pkt);
sendto = ng_netreg_getnext(sendto);
}
}
void ng_sixlowpan_frag_handle_pkt(ng_pktsnip_t *pkt)
{
ng_netif_hdr_t *hdr = pkt->next->data;
ng_sixlowpan_frag_t *frag = pkt->data;
uint16_t offset = 0;
size_t frag_size;
switch (frag->disp_size.u8[0] & NG_SIXLOWPAN_FRAG_DISP_MASK) {
case NG_SIXLOWPAN_FRAG_1_DISP:
frag_size = (pkt->size - sizeof(ng_sixlowpan_frag_t));
break;
case NG_SIXLOWPAN_FRAG_N_DISP:
offset = (((ng_sixlowpan_frag_n_t *)frag)->offset * 8);
frag_size = (pkt->size - sizeof(ng_sixlowpan_frag_n_t));
break;
default:
DEBUG("6lo rbuf: Not a fragment header.\n");
ng_pktbuf_release(pkt);
return;
}
rbuf_add(hdr, frag, frag_size, offset);
ng_pktbuf_release(pkt);
}
static void _rx_event(ng_netdev_eth_t *netdev)
{
dev_eth_t *dev = netdev->ethdev;
int nread = dev->driver->recv(dev, (char*)recv_buffer, ETHERNET_MAX_LEN);
DEBUG("ng_netdev_eth: read %d bytes\n", nread);
if (nread > 0) {
ethernet_hdr_t *hdr = (ethernet_hdr_t *)recv_buffer;
ng_pktsnip_t *netif_hdr, *pkt;
ng_nettype_t receive_type = NG_NETTYPE_UNDEF;
size_t data_len = (nread - sizeof(ethernet_hdr_t));
/* TODO: implement multicast groups? */
netif_hdr = ng_pktbuf_add(NULL, NULL,
sizeof(ng_netif_hdr_t) + (2 * ETHERNET_ADDR_LEN),
NG_NETTYPE_NETIF);
if (netif_hdr == NULL) {
DEBUG("ng_netdev_eth: no space left in packet buffer\n");
return;
}
ng_netif_hdr_init(netif_hdr->data, ETHERNET_ADDR_LEN, ETHERNET_ADDR_LEN);
ng_netif_hdr_set_src_addr(netif_hdr->data, hdr->src, ETHERNET_ADDR_LEN);
ng_netif_hdr_set_dst_addr(netif_hdr->data, hdr->dst, ETHERNET_ADDR_LEN);
((ng_netif_hdr_t *)netif_hdr->data)->if_pid = thread_getpid();
receive_type = ng_nettype_from_ethertype(byteorder_ntohs(hdr->type));
DEBUG("ng_netdev_eth: received packet from %02x:%02x:%02x:%02x:%02x:%02x "
"of length %zu\n",
hdr->src[0], hdr->src[1], hdr->src[2], hdr->src[3], hdr->src[4],
hdr->src[5], data_len);
#if defined(MODULE_OD) && ENABLE_DEBUG
od_hex_dump(hdr, nread, OD_WIDTH_DEFAULT);
#endif
/* Mark netif header and payload for next layer */
if ((pkt = ng_pktbuf_add(netif_hdr, recv_buffer + sizeof(ethernet_hdr_t),
data_len, receive_type)) == NULL) {
ng_pktbuf_release(netif_hdr);
DEBUG("ng_netdev_eth: no space left in packet buffer\n");
return;
}
if (netdev->event_cb != NULL) {
netdev->event_cb(NETDEV_EVENT_RX_COMPLETE, pkt);
}
else {
ng_pktbuf_release(pkt); /* netif_hdr is released automatically too */
}
}
else {
DEBUG("ng_netdev_eth: spurious _rx_event: %d\n", nread);
}
}
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);
}
static void _send(ng_pktsnip_t *pkt, bool prep_hdr)
{
kernel_pid_t iface = KERNEL_PID_UNDEF;
ng_pktsnip_t *ipv6, *payload;
ng_ipv6_hdr_t *hdr;
/* seize payload as temporary variable */
payload = ng_pktbuf_start_write(pkt);
if (payload == NULL) {
DEBUG("ipv6: unable to get write access to packet, dropping packet\n");
ng_pktbuf_release(pkt);
return;
}
pkt = payload; /* Reset pkt from temporary variable */
/* get IPv6 snip and (if present) generic interface header */
if (pkt->type == NG_NETTYPE_NETIF) {
/* If there is already a netif header (routing protocols and
* neighbor discovery might add them to preset sending interface) */
iface = ((ng_netif_hdr_t *)pkt->data)->if_pid;
ipv6 = pkt->next;
}
else {
ipv6 = pkt;
}
hdr = ipv6->data;
payload = ipv6->next; /* TODO: parse extension headers */
if (ng_ipv6_addr_is_multicast(&hdr->dst)) {
_send_multicast(iface, pkt, ipv6, payload, prep_hdr);
}
else {
uint8_t l2addr_len = NG_IPV6_NC_L2_ADDR_MAX;
uint8_t l2addr[l2addr_len];
iface = ng_ndp_next_hop_l2addr(l2addr, &l2addr_len, iface, &hdr->dst,
pkt);
if (iface == KERNEL_PID_UNDEF) {
DEBUG("ipv6: error determining next hop's link layer address\n");
ng_pktbuf_release(pkt);
return;
}
if (prep_hdr) {
if (_fill_ipv6_hdr(iface, ipv6, payload) < 0) {
/* error on filling up header */
ng_pktbuf_release(pkt);
return;
}
}
_send_unicast(iface, l2addr, l2addr_len, pkt);
}
}
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());
}
/* SLIP receive handler */
static void _slip_receive(ng_slip_dev_t *dev, size_t bytes)
{
ng_netif_hdr_t *hdr;
ng_netreg_entry_t *sendto;
ng_pktsnip_t *pkt, *netif_hdr;
pkt = ng_pktbuf_add(NULL, NULL, bytes, NG_NETTYPE_UNDEF);
if (pkt == NULL) {
DEBUG("slip: no space left in packet buffer\n");
return;
}
netif_hdr = ng_pktbuf_add(pkt, NULL, sizeof(ng_netif_hdr_t),
NG_NETTYPE_NETIF);
if (netif_hdr == NULL) {
DEBUG("slip: no space left in packet buffer\n");
ng_pktbuf_release(pkt);
return;
}
hdr = netif_hdr->data;
ng_netif_hdr_init(hdr, 0, 0);
hdr->if_pid = thread_getpid();
if (ringbuffer_get(dev->in_buf, pkt->data, bytes) != bytes) {
DEBUG("slip: could not read %zu bytes from ringbuffer\n", bytes);
ng_pktbuf_release(pkt);
return;
}
#ifdef MODULE_NG_IPV6
if ((pkt->size >= sizeof(ipv6_hdr_t)) && ipv6_hdr_is(pkt->data)) {
pkt->type = NG_NETTYPE_IPV6;
}
#endif
sendto = ng_netreg_lookup(pkt->type, NG_NETREG_DEMUX_CTX_ALL);
if (sendto == NULL) {
DEBUG("slip: unable to forward packet of type %i\n", pkt->type);
ng_pktbuf_release(pkt);
}
ng_pktbuf_hold(pkt, ng_netreg_num(pkt->type, NG_NETREG_DEMUX_CTX_ALL) - 1);
while (sendto != NULL) {
DEBUG("slip: sending pkt %p to PID %u\n", pkt, sendto->pid);
ng_netapi_receive(sendto->pid, pkt);
sendto = ng_netreg_getnext(sendto);
}
}
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);
}
}
void ng_ipv6_demux(kernel_pid_t iface, ng_pktsnip_t *pkt, uint8_t nh)
{
int receiver_num;
pkt->type = ng_nettype_from_protnum(nh);
switch (nh) {
case NG_PROTNUM_ICMPV6:
DEBUG("ipv6: handle ICMPv6 packet (nh = %" PRIu8 ")\n", nh);
ng_icmpv6_demux(iface, pkt);
break;
#ifdef MODULE_NG_IPV6_EXT
case NG_PROTNUM_IPV6_EXT_HOPOPT:
case NG_PROTNUM_IPV6_EXT_DST:
case NG_PROTNUM_IPV6_EXT_RH:
case NG_PROTNUM_IPV6_EXT_FRAG:
case NG_PROTNUM_IPV6_EXT_AH:
case NG_PROTNUM_IPV6_EXT_ESP:
case NG_PROTNUM_IPV6_EXT_MOB:
DEBUG("ipv6: handle extension header (nh = %" PRIu8 ")\n", nh);
if (!ng_ipv6_ext_demux(iface, pkt, nh)) {
DEBUG("ipv6: unable to parse extension headers.\n");
ng_pktbuf_release(pkt);
return;
}
#endif
case NG_PROTNUM_IPV6:
DEBUG("ipv6: handle encapsulated IPv6 packet (nh = %" PRIu8 ")\n", nh);
_decapsulate(pkt);
break;
default:
break;
}
DEBUG("ipv6: forward nh = %" PRIu8 " to other threads\n", nh);
receiver_num = ng_netreg_num(pkt->type, NG_NETREG_DEMUX_CTX_ALL) +
ng_netreg_num(NG_NETTYPE_IPV6, nh);
if (receiver_num == 0) {
DEBUG("ipv6: unable to forward packet as no one is interested in it\n");
ng_pktbuf_release(pkt);
return;
}
ng_pktbuf_hold(pkt, receiver_num - 1);
/* IPv6 is not interested anymore so `- 1` */
_dispatch_rcv_pkt(pkt->type, NG_NETREG_DEMUX_CTX_ALL, pkt);
_dispatch_rcv_pkt(NG_NETTYPE_IPV6, nh, pkt);
}
/**
* @brief Function called by the device driver on device events
*
* @param[in] event type of event
* @param[in] data optional parameter
*/
static void _event_cb(ng_netdev_event_t event, void *data)
{
DEBUG("nomac: event triggered -> %i\n", event);
/* NOMAC only understands the RX_COMPLETE event... */
if (event == NETDEV_EVENT_RX_COMPLETE) {
ng_pktsnip_t *pkt;
ng_netreg_entry_t *sendto;
/* get pointer to the received packet */
pkt = (ng_pktsnip_t *)data;
/* find out, who to send the packet to */
sendto = ng_netreg_lookup(pkt->type, NG_NETREG_DEMUX_CTX_ALL);
/* throw away packet if no one is interested */
if (sendto == NULL) {
DEBUG("nomac: unable to forward packet of type %i\n", pkt->type);
ng_pktbuf_release(pkt);
return;
}
/* send the packet to everyone interested in it's type */
ng_pktbuf_hold(pkt, ng_netreg_num(pkt->type, NG_NETREG_DEMUX_CTX_ALL) - 1);
while (sendto != NULL) {
DEBUG("nomac: sending pkt %p to PID %u\n", (void*)pkt, sendto->pid);
ng_netapi_receive(sendto->pid, pkt);
sendto = ng_netreg_getnext(sendto);
}
}
}
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;
}
/* functions for sending */
static void _send_unicast(kernel_pid_t iface, uint8_t *dst_l2addr,
uint16_t dst_l2addr_len, ng_pktsnip_t *pkt)
{
ng_pktsnip_t *netif;
if (pkt->type == NG_NETTYPE_NETIF) {
/* great: someone already added a netif_hdr_t we assume it's wrong
* to keep it simple
* XXX: alternative would be to check if ng_netif_hdr_t::dst_l2addr_len
* is long enough and only then to throw away the header. This causes
* to much overhead IMHO */
DEBUG("ipv6: removed old interface header\n");
pkt = ng_pktbuf_remove_snip(pkt, pkt);
}
DEBUG("ipv6: add to interface header to packet\n");
netif = ng_netif_hdr_build(NULL, 0, dst_l2addr, dst_l2addr_len);
if (netif == NULL) {
DEBUG("ipv6: error on interface header allocation, dropping packet\n");
ng_pktbuf_release(pkt);
return;
}
/* add netif to front of the pkt list */
LL_PREPEND(pkt, netif);
DEBUG("ipv6: send unicast over interface %" PRIkernel_pid "\n", iface);
/* and send to interface */
_send_to_iface(iface, pkt);
}
void ng_ipv6_demux(kernel_pid_t iface, ng_pktsnip_t *pkt, uint8_t nh)
{
int receiver_num;
pkt->type = ng_nettype_from_protnum(nh);
switch (nh) {
case NG_PROTNUM_ICMPV6:
ng_icmpv6_demux(iface, pkt);
break;
/* TODO: add extension header handling */
default:
break;
}
receiver_num = ng_netreg_num(pkt->type, NG_NETREG_DEMUX_CTX_ALL) +
ng_netreg_num(NG_NETTYPE_IPV6, nh);
if (receiver_num == 0) {
DEBUG("ipv6: unable to forward packet as no one is interested in it\n");
ng_pktbuf_release(pkt);
return;
}
ng_pktbuf_hold(pkt, receiver_num - 1);
/* IPv6 is not interested anymore so `- 1` */
_dispatch_rcv_pkt(pkt->type, NG_NETREG_DEMUX_CTX_ALL, pkt);
_dispatch_rcv_pkt(NG_NETTYPE_IPV6, nh, pkt);
}
static void test_pktbuf_release__pkt_external(void)
{
ng_pktsnip_t pkt = { 1, NULL, TEST_STRING8, sizeof(TEST_STRING8), NG_NETTYPE_UNDEF };
ng_pktbuf_release(&pkt);
TEST_ASSERT(ng_pktbuf_is_empty());
}
static void test_pktbuf_realloc_data__nomemenough(void)
{
ng_pktsnip_t *pkt1, *pkt2;
void *exp_data;
pkt1 = ng_pktbuf_add(NULL, TEST_STRING8, sizeof(TEST_STRING8), NG_NETTYPE_UNDEF);
exp_data = pkt1->data;
TEST_ASSERT_NOT_NULL(pkt1);
pkt2 = ng_pktbuf_add(NULL, NULL, 1, NG_NETTYPE_UNDEF);
TEST_ASSERT_NOT_NULL(pkt2);
TEST_ASSERT_NOT_NULL(ng_pktbuf_add(NULL, NULL, 4, NG_NETTYPE_UNDEF));
ng_pktbuf_release(pkt2);
TEST_ASSERT_EQUAL_INT(0, ng_pktbuf_realloc_data(pkt1, 200));
TEST_ASSERT(exp_data != pkt1->data);
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_UNDEF, pkt1->type);
TEST_ASSERT_EQUAL_INT(1, pkt1->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());
}
static void test_pktbuf_realloc_data__pkt_next_neq_NULL(void)
{
ng_pktsnip_t *pkt = ng_pktbuf_add(NULL, NULL, sizeof(TEST_STRING8), NG_NETTYPE_UNDEF);
TEST_ASSERT_NOT_NULL(ng_pktbuf_add(pkt, pkt->data, sizeof(TEST_STRING4), NG_NETTYPE_UNDEF));
TEST_ASSERT_EQUAL_INT(EINVAL, ng_pktbuf_realloc_data(pkt, sizeof(TEST_STRING8) - 1));
ng_pktbuf_release(pkt);
TEST_ASSERT(ng_pktbuf_is_empty());
}
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 udp_send(const char *str)
{
uint8_t data[20];
ng_pktsnip_t *payload, *udp, *ip;
ng_netreg_entry_t *sendto;
memcpy(data, str, strlen(str));
/* allocate payload */
payload = ng_pktbuf_add(NULL, data, strlen(str), 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("Send %s\n", str);
}
static void test_pktbuf_start_write__pkt_users_2(void)
{
ng_pktsnip_t *pkt_copy, *pkt = ng_pktbuf_add(NULL, TEST_STRING16, sizeof(TEST_STRING16),
NG_NETTYPE_TEST);
ng_pktbuf_hold(pkt, 1);
TEST_ASSERT_NOT_NULL((pkt_copy = ng_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);
ng_pktbuf_release(pkt_copy);
ng_pktbuf_release(pkt);
TEST_ASSERT(ng_pktbuf_is_empty());
}
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_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());
}
static int _send_data(ng_netdev_t *netdev, ng_pktsnip_t *pkt)
{
int nsent, to_send;
ng_netdev_eth_t *dev = (ng_netdev_eth_t *)netdev;
DEBUG("ng_netdev_eth: send data ");
if (pkt == NULL) {
return -EFAULT;
}
if ((dev == NULL) || (netdev->driver != &ng_netdev_eth_driver)) {
DEBUG("[wrong device descriptor]\n");
ng_pktbuf_release(pkt);
return -ENODEV;
}
DEBUG("\n");
to_send = _marshall_ethernet(dev, send_buffer, pkt);
ng_pktbuf_release(pkt);
if (to_send < 0) {
errno = -to_send;
DEBUG("marshall\n");
return to_send;
}
DEBUG("ng_netdev_eth: send %d bytes\n", to_send);
#if defined(MODULE_OD) && ENABLE_DEBUG
od_hex_dump(send_buffer, to_send, OD_WIDTH_DEFAULT);
#endif
dev_eth_t *ethdev = dev->ethdev;
if ((nsent = ethdev->driver->send(ethdev, (char*)send_buffer, to_send)) < 0) {
DEBUG("write\n");
return -EIO;
}
return nsent;
}
void ng_sixlowpan_frag_send(kernel_pid_t pid, ng_pktsnip_t *pkt,
size_t payload_len, size_t datagram_size)
{
ng_sixlowpan_netif_t *iface = ng_sixlowpan_netif_get(pid);
uint16_t offset = 0, res;
#if defined(DEVELHELP) && defined(ENABLE_DEBUG)
if (iface == NULL) {
DEBUG("6lo frag: iface == NULL, expect segmentation fault.\n");
ng_pktbuf_release(pkt);
return;
}
#endif
if ((res = _send_1st_fragment(iface, pkt, payload_len, datagram_size)) == 0) {
/* error sending first fragment */
DEBUG("6lo frag: error sending 1st fragment\n");
ng_pktbuf_release(pkt);
return;
}
offset += res;
while (offset < datagram_size) {
if ((res = _send_nth_fragment(iface, pkt, payload_len, datagram_size,
offset)) == 0) {
/* error sending subsequent fragment */
DEBUG("6lo frag: error sending subsequent fragment (offset = %" PRIu16
")\n", offset);
ng_pktbuf_release(pkt);
return;
}
offset += res;
}
/* remove original packet from packet buffer */
ng_pktbuf_release(pkt);
_tag++;
}
static void test_pktbuf_release__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);
}
TEST_ASSERT(!ng_pktbuf_is_empty());
for (uint8_t i = 0; i < TEST_UINT8; i++) {
uint8_t prev_users = pkt->users;
ng_pktbuf_release(pkt);
TEST_ASSERT_EQUAL_INT(prev_users - 1, pkt->users);
}
TEST_ASSERT(!ng_pktbuf_is_empty());
ng_pktbuf_release(pkt);
TEST_ASSERT(ng_pktbuf_is_empty());
}
static ng_nettest_res_t _pkt_test(uint16_t cmd_type, kernel_pid_t pid, ng_pktsnip_t *in,
unsigned int exp_pkts, kernel_pid_t exp_senders[],
ng_pktsnip_t *exp_out[])
{
msg_t msg;
timex_t t = { 0, NG_NETTEST_TIMEOUT };
ng_nettest_res_t res = NG_NETTEST_SUCCESS;
msg.type = cmd_type;
msg.content.ptr = (char *)in;
msg_send(&msg, pid);
for (unsigned int i = 0; i < exp_pkts; i++) {
ng_pktsnip_t *out;
if ((vtimer_msg_receive_timeout(&msg, t) < 0) && res == NG_NETTEST_SUCCESS) {
res = NG_NETTEST_TIMED_OUT;
}
if (msg.type != NG_NETAPI_MSG_TYPE_SND && (res == NG_NETTEST_SUCCESS)) {
res = NG_NETTEST_WRONG_MSG;
}
if (msg.sender_pid != exp_senders[i] && (res == NG_NETTEST_SUCCESS)) {
res = NG_NETTEST_WRONG_SENDER;
}
out = (ng_pktsnip_t *)msg.content.ptr;
if ((out == NULL) && (res == NG_NETTEST_SUCCESS)) {
res = NG_NETTEST_FAIL;
}
while (out) {
if ((res == NG_NETTEST_SUCCESS) &&
((out->users != exp_out[i]->users) ||
(out->size != exp_out[i]->size) ||
(out->type != exp_out[i]->type) ||
(memcmp(out->data, exp_out[i]->data, out->size) != 0))) {
res = NG_NETTEST_FAIL;
}
out = out->next;
}
ng_pktbuf_release((ng_pktsnip_t *)msg.content.ptr);
}
return res;
}
