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