static inline void ieee802154_acknowledge(struct net_if *iface,
struct ieee802154_mpdu *mpdu)
{
struct net_pkt *pkt;
struct net_buf *frag;
if (!mpdu->mhr.fs->fc.ar) {
return;
}
pkt = net_pkt_get_reserve_tx(IEEE802154_ACK_PKT_LENGTH, K_FOREVER);
if (!pkt) {
return;
}
frag = net_pkt_get_frag(pkt, K_FOREVER);
net_pkt_frag_insert(pkt, frag);
if (ieee802154_create_ack_frame(iface, pkt, mpdu->mhr.fs->sequence)) {
const struct ieee802154_radio_api *radio =
iface->dev->driver_api;
net_buf_add(frag, IEEE802154_ACK_PKT_LENGTH);
radio->tx(iface->dev, pkt, frag);
}
net_pkt_unref(pkt);
return;
}
static inline struct net_pkt *prepare_arp_reply(struct net_if *iface,
struct net_pkt *req,
struct net_eth_addr *addr)
{
struct net_pkt *pkt;
struct net_buf *frag;
struct net_arp_hdr *hdr;
struct net_eth_hdr *eth;
pkt = net_pkt_get_reserve_tx(sizeof(struct net_eth_hdr), K_FOREVER);
if (!pkt) {
goto fail;
}
frag = net_pkt_get_frag(pkt, K_FOREVER);
if (!frag) {
goto fail;
}
net_pkt_frag_add(pkt, frag);
net_pkt_set_iface(pkt, iface);
hdr = NET_ARP_HDR(pkt);
eth = NET_ETH_HDR(pkt);
eth->type = htons(NET_ETH_PTYPE_ARP);
memset(ð->dst.addr, 0xff, sizeof(struct net_eth_addr));
memcpy(ð->src.addr, net_if_get_link_addr(iface)->addr,
sizeof(struct net_eth_addr));
hdr->hwtype = htons(NET_ARP_HTYPE_ETH);
hdr->protocol = htons(NET_ETH_PTYPE_IP);
hdr->hwlen = sizeof(struct net_eth_addr);
hdr->protolen = sizeof(struct in_addr);
hdr->opcode = htons(NET_ARP_REPLY);
memcpy(&hdr->dst_hwaddr.addr, ð->src.addr,
sizeof(struct net_eth_addr));
memcpy(&hdr->src_hwaddr.addr, addr,
sizeof(struct net_eth_addr));
net_ipaddr_copy(&hdr->dst_ipaddr, &NET_ARP_HDR(req)->src_ipaddr);
net_ipaddr_copy(&hdr->src_ipaddr, &NET_ARP_HDR(req)->dst_ipaddr);
net_buf_add(frag, sizeof(struct net_arp_hdr));
return pkt;
fail:
net_pkt_unref(pkt);
return NULL;
}
static bool send_ipv4_udp_msg(struct net_if *iface,
struct in_addr *src,
struct in_addr *dst,
u16_t src_port,
u16_t dst_port,
struct ud *ud,
bool expect_failure)
{
struct net_pkt *pkt;
struct net_buf *frag;
int ret;
pkt = net_pkt_get_reserve_tx(0, K_FOREVER);
frag = net_pkt_get_frag(pkt, K_FOREVER);
net_pkt_frag_add(pkt, frag);
net_pkt_set_iface(pkt, iface);
net_pkt_set_ll_reserve(pkt, net_buf_headroom(frag));
setup_ipv4_udp(pkt, src, dst, src_port, dst_port);
ret = net_recv_data(iface, pkt);
if (ret < 0) {
printk("Cannot recv pkt %p, ret %d\n", pkt, ret);
zassert_true(0, "exiting");
}
if (k_sem_take(&recv_lock, TIMEOUT)) {
/**TESTPOINT: Check for failure*/
zassert_true(expect_failure, "Timeout, packet not received");
return true;
}
/* Check that the returned user data is the same as what was given
* as a parameter.
*/
if (ud != returned_ud && !expect_failure) {
printk("IPv4 wrong user data %p returned, expected %p\n",
returned_ud, ud);
zassert_true(0, "exiting");
}
return !fail;
}
static bool send_iface(struct net_if *iface, int val, bool expect_fail)
{
static u8_t data[] = { 't', 'e', 's', 't', '\0' };
struct net_pkt *pkt;
int ret;
pkt = net_pkt_get_reserve_tx(0, K_FOREVER);
net_pkt_set_iface(pkt, iface);
net_pkt_append_all(pkt, sizeof(data), data, K_FOREVER);
ret = net_send_data(pkt);
if (!expect_fail && ret < 0) {
DBG("Cannot send test packet (%d)\n", ret);
return false;
}
if (!expect_fail && k_sem_take(&wait_data, WAIT_TIME)) {
DBG("Timeout while waiting interface %d data\n", val);
return false;
}
return true;
}
static bool run_tests(void)
{
struct net_pkt *pkt, *pkt2;
struct net_buf *frag;
struct net_if *iface;
struct net_if_addr *ifaddr;
struct net_arp_hdr *arp_hdr;
struct net_ipv4_hdr *ipv4;
struct net_eth_hdr *eth_hdr;
int len;
struct in_addr dst = { { { 192, 168, 0, 2 } } };
struct in_addr dst_far = { { { 10, 11, 12, 13 } } };
struct in_addr dst_far2 = { { { 172, 16, 14, 186 } } };
struct in_addr src = { { { 192, 168, 0, 1 } } };
struct in_addr netmask = { { { 255, 255, 255, 0 } } };
struct in_addr gw = { { { 192, 168, 0, 42 } } };
net_arp_init();
iface = net_if_get_default();
net_if_ipv4_set_gw(iface, &gw);
net_if_ipv4_set_netmask(iface, &netmask);
/* Unicast test */
ifaddr = net_if_ipv4_addr_add(iface,
&src,
NET_ADDR_MANUAL,
0);
ifaddr->addr_state = NET_ADDR_PREFERRED;
/* Application data for testing */
pkt = net_pkt_get_reserve_tx(sizeof(struct net_eth_hdr), K_FOREVER);
if (!pkt) {
printk("Out of mem TX\n");
return false;
}
frag = net_pkt_get_frag(pkt, K_FOREVER);
if (!frag) {
printk("Out of mem DATA\n");
return false;
}
net_pkt_frag_add(pkt, frag);
net_pkt_set_iface(pkt, iface);
setup_eth_header(iface, pkt, &hwaddr, NET_ETH_PTYPE_IP);
len = strlen(app_data);
if (net_pkt_ll_reserve(pkt) != sizeof(struct net_eth_hdr)) {
printk("LL reserve invalid, should be %zd was %d\n",
sizeof(struct net_eth_hdr),
net_pkt_ll_reserve(pkt));
return false;
}
ipv4 = (struct net_ipv4_hdr *)net_buf_add(frag,
sizeof(struct net_ipv4_hdr));
net_ipaddr_copy(&ipv4->src, &src);
net_ipaddr_copy(&ipv4->dst, &dst);
memcpy(net_buf_add(frag, len), app_data, len);
pkt2 = net_arp_prepare(pkt);
/* pkt2 is the ARP packet and pkt is the IPv4 packet and it was
* stored in ARP table.
*/
if (pkt2 == pkt) {
/* The packets cannot be the same as the ARP cache has
* still room for the pkt.
*/
printk("ARP cache should still have free space\n");
return false;
}
if (!pkt2) {
printk("ARP pkt is empty\n");
return false;
}
/* The ARP cache should now have a link to pending net_pkt
* that is to be sent after we have got an ARP reply.
*/
if (!pkt->frags) {
printk("Pending pkt fragment is NULL\n");
return false;
}
pending_pkt = pkt;
/* pkt2 should contain the arp header, verify it */
if (memcmp(net_pkt_ll(pkt2), net_eth_broadcast_addr(),
sizeof(struct net_eth_addr))) {
printk("ARP ETH dest address invalid\n");
net_hexdump("ETH dest wrong ", net_pkt_ll(pkt2),
sizeof(struct net_eth_addr));
net_hexdump("ETH dest correct",
(u8_t *)net_eth_broadcast_addr(),
sizeof(struct net_eth_addr));
return false;
}
if (memcmp(net_pkt_ll(pkt2) + sizeof(struct net_eth_addr),
iface->link_addr.addr,
sizeof(struct net_eth_addr))) {
printk("ARP ETH source address invalid\n");
net_hexdump("ETH src correct",
iface->link_addr.addr,
sizeof(struct net_eth_addr));
net_hexdump("ETH src wrong ",
net_pkt_ll(pkt2) + sizeof(struct net_eth_addr),
sizeof(struct net_eth_addr));
return false;
}
arp_hdr = NET_ARP_HDR(pkt2);
eth_hdr = NET_ETH_HDR(pkt2);
if (eth_hdr->type != htons(NET_ETH_PTYPE_ARP)) {
printk("ETH type 0x%x, should be 0x%x\n",
eth_hdr->type, htons(NET_ETH_PTYPE_ARP));
return false;
}
if (arp_hdr->hwtype != htons(NET_ARP_HTYPE_ETH)) {
printk("ARP hwtype 0x%x, should be 0x%x\n",
arp_hdr->hwtype, htons(NET_ARP_HTYPE_ETH));
return false;
}
if (arp_hdr->protocol != htons(NET_ETH_PTYPE_IP)) {
printk("ARP protocol 0x%x, should be 0x%x\n",
arp_hdr->protocol, htons(NET_ETH_PTYPE_IP));
return false;
}
if (arp_hdr->hwlen != sizeof(struct net_eth_addr)) {
printk("ARP hwlen 0x%x, should be 0x%zx\n",
arp_hdr->hwlen, sizeof(struct net_eth_addr));
return false;
}
if (arp_hdr->protolen != sizeof(struct in_addr)) {
printk("ARP IP addr len 0x%x, should be 0x%zx\n",
arp_hdr->protolen, sizeof(struct in_addr));
return false;
}
if (arp_hdr->opcode != htons(NET_ARP_REQUEST)) {
printk("ARP opcode 0x%x, should be 0x%x\n",
arp_hdr->opcode, htons(NET_ARP_REQUEST));
return false;
}
if (!net_ipv4_addr_cmp(&arp_hdr->dst_ipaddr,
&NET_IPV4_HDR(pkt)->dst)) {
char out[sizeof("xxx.xxx.xxx.xxx")];
snprintk(out, sizeof(out), "%s",
net_sprint_ipv4_addr(&arp_hdr->dst_ipaddr));
printk("ARP IP dest invalid %s, should be %s", out,
net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->dst));
return false;
}
if (!net_ipv4_addr_cmp(&arp_hdr->src_ipaddr,
&NET_IPV4_HDR(pkt)->src)) {
char out[sizeof("xxx.xxx.xxx.xxx")];
snprintk(out, sizeof(out), "%s",
net_sprint_ipv4_addr(&arp_hdr->src_ipaddr));
printk("ARP IP src invalid %s, should be %s", out,
net_sprint_ipv4_addr(&NET_IPV4_HDR(pkt)->src));
return false;
}
/* We could have send the new ARP request but for this test we
* just free it.
*/
net_pkt_unref(pkt2);
if (pkt->ref != 2) {
printk("ARP cache should own the original packet\n");
return false;
}
/* Then a case where target is not in the same subnet */
net_ipaddr_copy(&ipv4->dst, &dst_far);
pkt2 = net_arp_prepare(pkt);
if (pkt2 == pkt) {
printk("ARP cache should not find anything\n");
return false;
}
if (!pkt2) {
printk("ARP pkt2 is empty\n");
return false;
}
arp_hdr = NET_ARP_HDR(pkt2);
if (!net_ipv4_addr_cmp(&arp_hdr->dst_ipaddr, &iface->ipv4.gw)) {
char out[sizeof("xxx.xxx.xxx.xxx")];
snprintk(out, sizeof(out), "%s",
net_sprint_ipv4_addr(&arp_hdr->dst_ipaddr));
printk("ARP IP dst invalid %s, should be %s\n", out,
net_sprint_ipv4_addr(&iface->ipv4.gw));
return false;
}
net_pkt_unref(pkt2);
/* Try to find the same destination again, this should fail as there
* is a pending request in ARP cache.
*/
net_ipaddr_copy(&ipv4->dst, &dst_far);
/* Make sure prepare will not free the pkt because it will be
* needed in the later test case.
*/
net_pkt_ref(pkt);
pkt2 = net_arp_prepare(pkt);
if (!pkt2) {
printk("ARP cache is not sending the request again\n");
return false;
}
net_pkt_unref(pkt2);
/* Try to find the different destination, this should fail too
* as the cache table should be full.
*/
net_ipaddr_copy(&ipv4->dst, &dst_far2);
/* Make sure prepare will not free the pkt because it will be
* needed in the next test case.
*/
net_pkt_ref(pkt);
pkt2 = net_arp_prepare(pkt);
if (!pkt2) {
printk("ARP cache did not send a req\n");
return false;
}
/* Restore the original address so that following test case can
* work properly.
*/
net_ipaddr_copy(&ipv4->dst, &dst);
/* The arp request packet is now verified, create an arp reply.
* The previous value of pkt is stored in arp table and is not lost.
*/
pkt = net_pkt_get_reserve_rx(sizeof(struct net_eth_hdr), K_FOREVER);
if (!pkt) {
printk("Out of mem RX reply\n");
return false;
}
printk("%d pkt %p\n", __LINE__, pkt);
frag = net_pkt_get_frag(pkt, K_FOREVER);
if (!frag) {
printk("Out of mem DATA reply\n");
return false;
}
printk("%d frag %p\n", __LINE__, frag);
net_pkt_frag_add(pkt, frag);
net_pkt_set_iface(pkt, iface);
arp_hdr = NET_ARP_HDR(pkt);
net_buf_add(frag, sizeof(struct net_arp_hdr));
net_ipaddr_copy(&arp_hdr->dst_ipaddr, &dst);
net_ipaddr_copy(&arp_hdr->src_ipaddr, &src);
pkt2 = prepare_arp_reply(iface, pkt, &hwaddr);
if (!pkt2) {
printk("ARP reply generation failed.");
return false;
}
/* The pending packet should now be sent */
switch (net_arp_input(pkt2)) {
case NET_OK:
case NET_CONTINUE:
break;
case NET_DROP:
break;
}
/* Yielding so that network interface TX thread can proceed. */
k_yield();
if (send_status < 0) {
printk("ARP reply was not sent\n");
return false;
}
if (pkt->ref != 1) {
printk("ARP cache should no longer own the original packet\n");
return false;
}
net_pkt_unref(pkt);
/* Then feed in ARP request */
pkt = net_pkt_get_reserve_rx(sizeof(struct net_eth_hdr), K_FOREVER);
if (!pkt) {
printk("Out of mem RX request\n");
return false;
}
frag = net_pkt_get_frag(pkt, K_FOREVER);
if (!frag) {
printk("Out of mem DATA request\n");
return false;
}
net_pkt_frag_add(pkt, frag);
net_pkt_set_iface(pkt, iface);
send_status = -EINVAL;
arp_hdr = NET_ARP_HDR(pkt);
net_buf_add(frag, sizeof(struct net_arp_hdr));
net_ipaddr_copy(&arp_hdr->dst_ipaddr, &src);
net_ipaddr_copy(&arp_hdr->src_ipaddr, &dst);
setup_eth_header(iface, pkt, &hwaddr, NET_ETH_PTYPE_ARP);
pkt2 = prepare_arp_request(iface, pkt, &hwaddr);
if (!pkt2) {
printk("ARP request generation failed.");
return false;
}
req_test = true;
switch (net_arp_input(pkt2)) {
case NET_OK:
case NET_CONTINUE:
break;
case NET_DROP:
break;
}
/* Yielding so that network interface TX thread can proceed. */
k_yield();
if (send_status < 0) {
printk("ARP req was not sent\n");
return false;
}
net_pkt_unref(pkt);
printk("Network ARP checks passed\n");
return true;
}
static void test_fragment_copy(void)
{
struct net_pkt *pkt, *new_pkt;
struct net_buf *frag, *new_frag;
struct ipv6_hdr *ipv6;
struct udp_hdr *udp;
size_t orig_len, reserve;
int pos;
pkt = net_pkt_get_reserve_rx(0, K_FOREVER);
frag = net_pkt_get_reserve_rx_data(LL_RESERVE, K_FOREVER);
/* Place the IP + UDP header in the first fragment */
if (net_buf_tailroom(frag)) {
ipv6 = (struct ipv6_hdr *)(frag->data);
udp = (struct udp_hdr *)((void *)ipv6 + sizeof(*ipv6));
if (net_buf_tailroom(frag) < sizeof(*ipv6)) {
printk("Not enough space for IPv6 header, "
"needed %zd bytes, has %zd bytes\n",
sizeof(ipv6), net_buf_tailroom(frag));
zassert_true(false, "No space for IPv6 header");
}
net_buf_add(frag, sizeof(*ipv6));
if (net_buf_tailroom(frag) < sizeof(*udp)) {
printk("Not enough space for UDP header, "
"needed %zd bytes, has %zd bytes\n",
sizeof(udp), net_buf_tailroom(frag));
zassert_true(false, "No space for UDP header");
}
net_buf_add(frag, sizeof(*udp));
memcpy(net_buf_add(frag, 15), example_data, 15);
net_pkt_set_appdata(pkt, (void *)udp + sizeof(*udp) + 15);
net_pkt_set_appdatalen(pkt, 0);
}
net_pkt_frag_add(pkt, frag);
orig_len = net_pkt_get_len(pkt);
DBG("Total copy data len %zd\n", orig_len);
linearize(pkt, buf_orig, orig_len);
/* Then copy a fragment list to a new fragment list.
* Reserve some space in front of the buffers.
*/
reserve = sizeof(struct ipv6_hdr) + sizeof(struct icmp_hdr);
new_frag = net_pkt_copy_all(pkt, reserve, K_FOREVER);
zassert_not_null(new_frag, "Cannot copy fragment list");
new_pkt = net_pkt_get_reserve_tx(0, K_FOREVER);
new_pkt->frags = net_buf_frag_add(new_pkt->frags, new_frag);
DBG("Total new data len %zd\n", net_pkt_get_len(new_pkt));
if ((net_pkt_get_len(pkt) + reserve) != net_pkt_get_len(new_pkt)) {
int diff;
diff = net_pkt_get_len(new_pkt) - reserve -
net_pkt_get_len(pkt);
printk("Fragment list missing data, %d bytes not copied "
"(%zd vs %zd)\n", diff,
net_pkt_get_len(pkt) + reserve,
net_pkt_get_len(new_pkt));
zassert_true(false, "Frag list missing");
}
if (net_pkt_get_len(new_pkt) != (orig_len + sizeof(struct ipv6_hdr) +
sizeof(struct icmp_hdr))) {
printk("Fragment list missing data, new pkt len %zd "
"should be %zd\n", net_pkt_get_len(new_pkt),
orig_len + sizeof(struct ipv6_hdr) +
sizeof(struct icmp_hdr));
zassert_true(false, "Frag list missing data");
}
linearize(new_pkt, buf_copy, sizeof(buf_copy));
zassert_true(memcmp(buf_orig, buf_copy, sizeof(buf_orig)),
"Buffer copy failed, buffers are same");
pos = memcmp(buf_orig, buf_copy + sizeof(struct ipv6_hdr) +
sizeof(struct icmp_hdr), orig_len);
if (pos) {
printk("Buffer copy failed at pos %d\n", pos);
zassert_true(false, "Buf copy failed");
}
}
struct net_pkt *
ieee802154_create_mac_cmd_frame(struct ieee802154_context *ctx,
enum ieee802154_cfi type,
struct ieee802154_frame_params *params)
{
struct ieee802154_fcf_seq *fs;
struct net_pkt *pkt;
struct net_buf *frag;
u8_t *p_buf;
pkt = net_pkt_get_reserve_tx(0, K_FOREVER);
if (!pkt) {
return NULL;
}
frag = net_pkt_get_frag(pkt, K_FOREVER);
if (!frag) {
goto error;
}
net_pkt_frag_add(pkt, frag);
p_buf = net_pkt_ll(pkt);
fs = generate_fcf_grounds(&p_buf,
type == IEEE802154_CFI_BEACON_REQUEST ?
false : ctx->ack_requested);
fs->fc.frame_type = IEEE802154_FRAME_TYPE_MAC_COMMAND;
fs->sequence = ctx->sequence;
if (!cfi_to_fs_settings(type, fs, params)) {
goto error;
}
p_buf = generate_addressing_fields(ctx, fs, params, p_buf);
/* Let's insert the cfi */
((struct ieee802154_command *)p_buf)->cfi = type;
/* In MAC command, we consider ll header being the mhr.
* Rest will be the MAC command itself. This will proove
* to be easy to handle afterwards to point directly to MAC
* command space, in order to fill-in its content.
*/
net_pkt_set_ll_reserve(pkt, p_buf - net_pkt_ll(pkt));
net_buf_pull(frag, net_pkt_ll_reserve(pkt));
/* Thus setting the right MAC command length
* Now up to the caller to fill-in this space relevantly.
* See ieee802154_mac_command() helper.
*/
frag->len = mac_command_length(type);
dbg_print_fs(fs);
return pkt;
error:
net_pkt_unref(pkt);
return NULL;
}
