static int nrf5_tx(struct device *dev,
struct net_pkt *pkt,
struct net_buf *frag)
{
struct nrf5_802154_data *nrf5_radio = NRF5_802154_DATA(dev);
u8_t payload_len = net_pkt_ll_reserve(pkt) + frag->len;
u8_t *payload = frag->data - net_pkt_ll_reserve(pkt);
SYS_LOG_DBG("%p (%u)", payload, payload_len);
nrf5_radio->tx_success = false;
nrf5_radio->tx_psdu[0] = payload_len + NRF5_FCS_LENGTH;
memcpy(nrf5_radio->tx_psdu + 1, payload, payload_len);
if (!nrf_drv_radio802154_transmit(nrf5_radio->tx_psdu,
nrf5_radio->channel,
nrf5_radio->txpower)) {
SYS_LOG_ERR("Cannot send frame");
return -EIO;
}
SYS_LOG_DBG("Sending frame (ch:%d, txpower:%d)",
nrf5_radio->channel,
nrf5_radio->txpower);
/* The nRF driver guarantees that either
* nrf_drv_radio802154_transmitted() or
* nrf_drv_radio802154_energy_detected()
* callback is called, thus unlocking the semaphore.
*/
k_sem_take(&nrf5_radio->tx_wait, K_FOREVER);
SYS_LOG_DBG("Result: %d", nrf5_data.tx_success);
return nrf5_radio->tx_success ? 0 : -EBUSY;
}
static void pkt_hexdump(struct net_pkt *pkt, bool each_frag_reserve)
{
u16_t reserve = each_frag_reserve ? net_pkt_ll_reserve(pkt) : 0;
struct net_buf *frag;
printk("IEEE 802.15.4 packet content:\n");
frag = pkt->frags;
while (frag) {
hexdump(each_frag_reserve ?
frag->data - reserve : frag->data,
frag->len + reserve, reserve);
frag = frag->frags;
}
}
static enum net_verdict ieee802154_recv(struct net_if *iface,
struct net_pkt *pkt)
{
struct ieee802154_mpdu mpdu;
if (!ieee802154_validate_frame(net_pkt_ll(pkt),
net_pkt_get_len(pkt), &mpdu)) {
return NET_DROP;
}
if (mpdu.mhr.fs->fc.frame_type == IEEE802154_FRAME_TYPE_BEACON) {
return ieee802154_handle_beacon(iface, &mpdu);
}
if (ieee802154_is_scanning(iface)) {
return NET_DROP;
}
if (mpdu.mhr.fs->fc.frame_type == IEEE802154_FRAME_TYPE_MAC_COMMAND) {
return ieee802154_handle_mac_command(iface, &mpdu);
}
/* At this point the frame has to be a DATA one */
ieee802154_acknowledge(iface, &mpdu);
net_pkt_set_ll_reserve(pkt, mpdu.payload - (void *)net_pkt_ll(pkt));
net_buf_pull(pkt->frags, net_pkt_ll_reserve(pkt));
set_pkt_ll_addr(net_pkt_ll_src(pkt), mpdu.mhr.fs->fc.pan_id_comp,
mpdu.mhr.fs->fc.src_addr_mode, mpdu.mhr.src_addr);
set_pkt_ll_addr(net_pkt_ll_dst(pkt), false,
mpdu.mhr.fs->fc.dst_addr_mode, mpdu.mhr.dst_addr);
if (!ieee802154_decipher_data_frame(iface, pkt, &mpdu)) {
return NET_DROP;
}
pkt_hexdump(pkt, true);
return ieee802154_manage_recv_packet(iface, pkt);
}
bool ieee802154_decipher_data_frame(struct net_if *iface, struct net_pkt *pkt,
struct ieee802154_mpdu *mpdu)
{
struct ieee802154_context *ctx = net_if_l2_data(iface);
u8_t level;
if (!mpdu->mhr.fs->fc.security_enabled) {
return true;
}
/* Section 7.2.3 (i) talks about "security level policy" conformance
* but such policy does not seem to be detailed. So let's assume both
* ends should have same security level.
*/
if (mpdu->mhr.aux_sec->control.security_level != ctx->sec_ctx.level) {
return false;
}
/* ToDo: handle src short address
* This will require to look up in nbr cache with short addr
* in order to get the extended address related to it
*/
if (!ieee802154_decrypt_auth(&ctx->sec_ctx, net_pkt_ll(pkt),
net_pkt_ll_reserve(pkt),
net_pkt_get_len(pkt),
net_pkt_ll_src(pkt)->addr,
sys_le32_to_cpu(
mpdu->mhr.aux_sec->frame_counter))) {
NET_ERR("Could not decipher the frame");
return false;
}
level = ctx->sec_ctx.level;
if (level >= IEEE802154_SECURITY_LEVEL_ENC) {
level -= 4;
}
/* We remove tag size from frag's length, it is now useless */
pkt->frags->len -= level_2_tag_size[level];
return true;
}
static enum net_verdict ieee802154_send(struct net_if *iface,
struct net_pkt *pkt)
{
struct ieee802154_context *ctx = net_if_l2_data(iface);
u8_t reserved_space = net_pkt_ll_reserve(pkt);
struct net_buf *frag;
if (net_pkt_family(pkt) != AF_INET6) {
return NET_DROP;
}
if (!ieee802154_manage_send_packet(iface, pkt)) {
return NET_DROP;
}
frag = pkt->frags;
while (frag) {
if (frag->len > IEEE802154_MTU) {
NET_ERR("Frag %p as too big length %u",
frag, frag->len);
return NET_DROP;
}
if (!ieee802154_create_data_frame(ctx, net_pkt_ll_dst(pkt),
frag, reserved_space)) {
return NET_DROP;
}
frag = frag->frags;
}
pkt_hexdump(pkt, true);
net_if_queue_tx(iface, pkt);
return NET_OK;
}
static int eth_tx(struct net_if *iface, struct net_pkt *pkt)
{
struct device *const dev = net_if_get_device(iface);
const struct eth_sam_dev_cfg *const cfg = DEV_CFG(dev);
struct eth_sam_dev_data *const dev_data = DEV_DATA(dev);
Gmac *gmac = cfg->regs;
struct gmac_queue *queue = &dev_data->queue_list[0];
struct gmac_desc_list *tx_desc_list = &queue->tx_desc_list;
struct gmac_desc *tx_desc;
struct net_buf *frag;
u8_t *frag_data;
u16_t frag_len;
u32_t err_tx_flushed_count_at_entry = queue->err_tx_flushed_count;
unsigned int key;
__ASSERT(pkt, "buf pointer is NULL");
__ASSERT(pkt->frags, "Frame data missing");
SYS_LOG_DBG("ETH tx");
/* First fragment is special - it contains link layer (Ethernet
* in our case) header. Modify the data pointer to account for more data
* in the beginning of the buffer.
*/
net_buf_push(pkt->frags, net_pkt_ll_reserve(pkt));
frag = pkt->frags;
while (frag) {
frag_data = frag->data;
frag_len = frag->len;
/* Assure cache coherency before DMA read operation */
DCACHE_CLEAN(frag_data, frag_len);
k_sem_take(&queue->tx_desc_sem, K_FOREVER);
/* The following section becomes critical and requires IRQ lock
* / unlock protection only due to the possibility of executing
* tx_error_handler() function.
*/
key = irq_lock();
/* Check if tx_error_handler() function was executed */
if (queue->err_tx_flushed_count != err_tx_flushed_count_at_entry) {
irq_unlock(key);
return -EIO;
}
tx_desc = &tx_desc_list->buf[tx_desc_list->head];
/* Update buffer descriptor address word */
tx_desc->w0 = (u32_t)frag_data;
/* Guarantee that address word is written before the status
* word to avoid race condition.
*/
__DMB(); /* data memory barrier */
/* Update buffer descriptor status word (clear used bit) */
tx_desc->w1 =
(frag_len & GMAC_TXW1_LEN)
| (!frag->frags ? GMAC_TXW1_LASTBUFFER : 0)
| (tx_desc_list->head == tx_desc_list->len - 1
? GMAC_TXW1_WRAP : 0);
/* Update descriptor position */
MODULO_INC(tx_desc_list->head, tx_desc_list->len);
__ASSERT(tx_desc_list->head != tx_desc_list->tail,
"tx_desc_list overflow");
irq_unlock(key);
/* Continue with the rest of fragments (only data) */
frag = frag->frags;
}
key = irq_lock();
/* Check if tx_error_handler() function was executed */
if (queue->err_tx_flushed_count != err_tx_flushed_count_at_entry) {
irq_unlock(key);
return -EIO;
}
/* Ensure the descriptor following the last one is marked as used */
tx_desc = &tx_desc_list->buf[tx_desc_list->head];
tx_desc->w1 |= GMAC_TXW1_USED;
/* Account for a sent frame */
ring_buf_put(&queue->tx_frames, POINTER_TO_UINT(pkt));
irq_unlock(key);
/* Start transmission */
gmac->GMAC_NCR |= GMAC_NCR_TSTART;
return 0;
}
static int tester_send(struct net_if *iface, struct net_pkt *pkt)
{
struct net_eth_hdr *hdr;
if (!pkt->frags) {
printk("No data to send!\n");
return -ENODATA;
}
if (net_pkt_ll_reserve(pkt) != sizeof(struct net_eth_hdr)) {
printk("No ethernet header in pkt %p", pkt);
send_status = -EINVAL;
return send_status;
}
hdr = (struct net_eth_hdr *)net_pkt_ll(pkt);
if (ntohs(hdr->type) == NET_ETH_PTYPE_ARP) {
struct net_arp_hdr *arp_hdr = NET_ARP_HDR(pkt);
if (ntohs(arp_hdr->opcode) == NET_ARP_REPLY) {
if (!req_test && pkt != pending_pkt) {
printk("Pending data but to be sent is wrong, "
"expecting %p but got %p\n",
pending_pkt, pkt);
return -EINVAL;
}
if (!req_test && memcmp(&hdr->dst, &hwaddr,
sizeof(struct net_eth_addr))) {
char out[sizeof("xx:xx:xx:xx:xx:xx")];
snprintk(out, sizeof(out), "%s",
net_sprint_ll_addr(
(u8_t *)&hdr->dst,
sizeof(struct net_eth_addr)));
printk("Invalid hwaddr %s, should be %s\n",
out,
net_sprint_ll_addr(
(u8_t *)&hwaddr,
sizeof(struct net_eth_addr)));
send_status = -EINVAL;
return send_status;
}
} else if (ntohs(arp_hdr->opcode) == NET_ARP_REQUEST) {
if (memcmp(&hdr->src, &hwaddr,
sizeof(struct net_eth_addr))) {
char out[sizeof("xx:xx:xx:xx:xx:xx")];
snprintk(out, sizeof(out), "%s",
net_sprint_ll_addr(
(u8_t *)&hdr->src,
sizeof(struct net_eth_addr)));
printk("Invalid hwaddr %s, should be %s\n",
out,
net_sprint_ll_addr(
(u8_t *)&hwaddr,
sizeof(struct net_eth_addr)));
send_status = -EINVAL;
return send_status;
}
}
}
printk("Data was sent successfully\n");
net_pkt_unref(pkt);
send_status = 0;
return 0;
}
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 int slip_send(struct net_if *iface, struct net_pkt *pkt)
{
struct net_buf *frag;
#if defined(CONFIG_SLIP_TAP)
u16_t ll_reserve = net_pkt_ll_reserve(pkt);
bool send_header_once = false;
#endif
u8_t *ptr;
u16_t i;
u8_t c;
if (!pkt->frags) {
/* No data? */
return -ENODATA;
}
slip_writeb(SLIP_END);
for (frag = pkt->frags; frag; frag = frag->frags) {
#if SYS_LOG_LEVEL >= SYS_LOG_LEVEL_DEBUG
int frag_count = 0;
#endif
#if defined(CONFIG_SLIP_TAP)
ptr = frag->data - ll_reserve;
/* This writes ethernet header */
if (!send_header_once && ll_reserve) {
for (i = 0; i < ll_reserve; i++) {
slip_writeb_esc(*ptr++);
}
}
if (net_if_get_mtu(iface) > net_buf_headroom(frag)) {
/* Do not add link layer header if the mtu is bigger
* than fragment size. The first packet needs the
* link layer header always.
*/
send_header_once = true;
ll_reserve = 0;
ptr = frag->data;
}
#else
/* There is no ll header in tun device */
ptr = frag->data;
#endif
for (i = 0; i < frag->len; ++i) {
c = *ptr++;
slip_writeb_esc(c);
}
#if SYS_LOG_LEVEL >= SYS_LOG_LEVEL_DEBUG
SYS_LOG_DBG("sent data %d bytes",
frag->len + net_pkt_ll_reserve(pkt));
if (frag->len + ll_reserve) {
char msg[8 + 1];
snprintf(msg, sizeof(msg), "<slip %2d", frag_count++);
hexdump(msg, net_pkt_ll(pkt),
frag->len + net_pkt_ll_reserve(pkt),
net_pkt_ll_reserve(pkt));
}
#endif
}
net_pkt_unref(pkt);
slip_writeb(SLIP_END);
return 0;
}
static void test_pkt_read_write_insert(void)
{
struct net_buf *read_frag;
struct net_buf *temp_frag;
struct net_pkt *pkt;
struct net_buf *frag;
u8_t read_data[100];
u16_t read_pos;
u16_t len;
u16_t pos;
/* Example of multi fragment read, append and skip APS's */
pkt = net_pkt_get_reserve_rx(0, K_FOREVER);
net_pkt_set_ll_reserve(pkt, LL_RESERVE);
frag = net_pkt_get_reserve_rx_data(net_pkt_ll_reserve(pkt),
K_FOREVER);
net_pkt_frag_add(pkt, frag);
/* 1) Offset is with in input fragment.
* Write app data after IPv6 and UDP header. (If the offset is after
* IPv6 + UDP header size, api will create empty space till offset
* and write data).
*/
frag = net_pkt_write(pkt, frag, NET_IPV6UDPH_LEN, &pos, 10,
(u8_t *)sample_data, K_FOREVER);
zassert_false(!frag || pos != 58, "Usecase 1: Write failed");
read_frag = net_frag_read(frag, NET_IPV6UDPH_LEN, &read_pos, 10,
read_data);
zassert_false(!read_frag && read_pos == 0xffff,
"Usecase 1: Read failed");
zassert_false(memcmp(read_data, sample_data, 10),
"Usecase 1: Read data mismatch");
/* 2) Write IPv6 and UDP header at offset 0. (Empty space is created
* already in Usecase 1, just need to fill the header, at this point
* there shouldn't be any length change).
*/
frag = net_pkt_write(pkt, frag, 0, &pos, NET_IPV6UDPH_LEN,
(u8_t *)sample_data, K_FOREVER);
zassert_false(!frag || pos != 48, "Usecase 2: Write failed");
read_frag = net_frag_read(frag, 0, &read_pos, NET_IPV6UDPH_LEN,
read_data);
zassert_false(!read_frag && read_pos == 0xffff,
"Usecase 2: Read failed");
zassert_false(memcmp(read_data, sample_data, NET_IPV6UDPH_LEN),
"Usecase 2: Read data mismatch");
net_pkt_unref(pkt);
pkt = net_pkt_get_reserve_rx(0, K_FOREVER);
net_pkt_set_ll_reserve(pkt, LL_RESERVE);
/* 3) Offset is in next to next fragment.
* Write app data after 2 fragments. (If the offset far away, api will
* create empty fragments(space) till offset and write data).
*/
frag = net_pkt_write(pkt, pkt->frags, 200, &pos, 10,
(u8_t *)sample_data + 10, K_FOREVER);
zassert_not_null(frag, "Usecase 3: Write failed");
read_frag = net_frag_read(frag, pos - 10, &read_pos, 10,
read_data);
zassert_false(!read_frag && read_pos == 0xffff,
"Usecase 3: Read failed");
zassert_false(memcmp(read_data, sample_data + 10, 10),
"Usecase 3: Read data mismatch");
/* 4) Offset is in next to next fragment (overwrite).
* Write app data after 2 fragments. (Space is already available from
* Usecase 3, this scenatio doesn't create any space, it just overwrites
* the existing data.
*/
frag = net_pkt_write(pkt, pkt->frags, 190, &pos, 10,
(u8_t *)sample_data, K_FOREVER);
zassert_not_null(frag, "Usecase 4: Write failed");
read_frag = net_frag_read(frag, pos - 10, &read_pos, 20,
read_data);
zassert_false(!read_frag && read_pos == 0xffff,
"Usecase 4: Read failed");
zassert_false(memcmp(read_data, sample_data, 20),
"Usecase 4: Read data mismatch");
net_pkt_unref(pkt);
/* 5) Write 20 bytes in fragment which has only 10 bytes space.
* API should overwrite on first 10 bytes and create extra 10 bytes
* and write there.
*/
pkt = net_pkt_get_reserve_rx(0, K_FOREVER);
net_pkt_set_ll_reserve(pkt, LL_RESERVE);
frag = net_pkt_get_reserve_rx_data(net_pkt_ll_reserve(pkt),
K_FOREVER);
net_pkt_frag_add(pkt, frag);
/* Create 10 bytes space. */
net_buf_add(frag, 10);
frag = net_pkt_write(pkt, frag, 0, &pos, 20, (u8_t *)sample_data,
K_FOREVER);
zassert_false(!frag && pos != 20, "Usecase 5: Write failed");
read_frag = net_frag_read(frag, 0, &read_pos, 20, read_data);
zassert_false(!read_frag && read_pos == 0xffff,
"Usecase 5: Read failed");
zassert_false(memcmp(read_data, sample_data, 20),
"USecase 5: Read data mismatch");
net_pkt_unref(pkt);
/* 6) First fragment is full, second fragment has 10 bytes tail room,
* third fragment has 5 bytes.
* Write data (30 bytes) in second fragment where offset is 10 bytes
* before the tailroom.
* So it should overwrite 10 bytes and create space for another 10
* bytes and write data. Third fragment 5 bytes overwritten and space
* for 5 bytes created.
*/
pkt = net_pkt_get_reserve_rx(0, K_FOREVER);
net_pkt_set_ll_reserve(pkt, LL_RESERVE);
/* First fragment make it fully occupied. */
frag = net_pkt_get_reserve_rx_data(net_pkt_ll_reserve(pkt),
K_FOREVER);
net_pkt_frag_add(pkt, frag);
len = net_buf_tailroom(frag);
net_buf_add(frag, len);
/* 2nd fragment last 10 bytes tailroom, rest occupied */
frag = net_pkt_get_reserve_rx_data(net_pkt_ll_reserve(pkt),
K_FOREVER);
net_pkt_frag_add(pkt, frag);
len = net_buf_tailroom(frag);
net_buf_add(frag, len - 10);
read_frag = temp_frag = frag;
read_pos = frag->len - 10;
/* 3rd fragment, only 5 bytes occupied */
frag = net_pkt_get_reserve_rx_data(net_pkt_ll_reserve(pkt),
K_FOREVER);
net_pkt_frag_add(pkt, frag);
net_buf_add(frag, 5);
temp_frag = net_pkt_write(pkt, temp_frag, temp_frag->len - 10, &pos,
30, (u8_t *) sample_data, K_FOREVER);
zassert_not_null(temp_frag, "Use case 6: Write failed");
read_frag = net_frag_read(read_frag, read_pos, &read_pos, 30,
read_data);
zassert_false(!read_frag && read_pos == 0xffff,
"Usecase 6: Read failed");
zassert_false(memcmp(read_data, sample_data, 30),
"Usecase 6: Read data mismatch");
net_pkt_unref(pkt);
/* 7) Offset is with in input fragment.
* Write app data after IPv6 and UDP header. (If the offset is after
* IPv6 + UDP header size, api will create empty space till offset
* and write data). Insert some app data after IPv6 + UDP header
* before first set of app data.
*/
pkt = net_pkt_get_reserve_rx(0, K_FOREVER);
net_pkt_set_ll_reserve(pkt, LL_RESERVE);
/* First fragment make it fully occupied. */
frag = net_pkt_get_reserve_rx_data(net_pkt_ll_reserve(pkt),
K_FOREVER);
net_pkt_frag_add(pkt, frag);
frag = net_pkt_write(pkt, frag, NET_IPV6UDPH_LEN, &pos, 10,
(u8_t *)sample_data + 10, K_FOREVER);
zassert_false(!frag || pos != 58, "Usecase 7: Write failed");
read_frag = net_frag_read(frag, NET_IPV6UDPH_LEN, &read_pos, 10,
read_data);
zassert_false(!read_frag && read_pos == 0xffff,
"Usecase 7: Read failed");
zassert_false(memcmp(read_data, sample_data + 10, 10),
"Usecase 7: Read data mismatch");
zassert_true(net_pkt_insert(pkt, frag, NET_IPV6UDPH_LEN, 10,
(u8_t *)sample_data, K_FOREVER),
"Usecase 7: Insert failed");
read_frag = net_frag_read(frag, NET_IPV6UDPH_LEN, &read_pos, 20,
read_data);
zassert_false(!read_frag && read_pos == 0xffff,
"Usecase 7: Read after failed");
zassert_false(memcmp(read_data, sample_data, 20),
"Usecase 7: Read data mismatch after insertion");
/* Insert data outside input fragment length, error case. */
zassert_false(net_pkt_insert(pkt, frag, 70, 10, (u8_t *)sample_data,
K_FOREVER),
"Usecase 7: False insert failed");
net_pkt_unref(pkt);
/* 8) Offset is with in input fragment.
* Write app data after IPv6 and UDP header. (If the offset is after
* IPv6 + UDP header size, api will create empty space till offset
* and write data). Insert some app data after IPv6 + UDP header
* before first set of app data. Insertion data is long which will
* take two fragments.
*/
pkt = net_pkt_get_reserve_rx(0, K_FOREVER);
net_pkt_set_ll_reserve(pkt, LL_RESERVE);
/* First fragment make it fully occupied. */
frag = net_pkt_get_reserve_rx_data(net_pkt_ll_reserve(pkt),
K_FOREVER);
net_pkt_frag_add(pkt, frag);
frag = net_pkt_write(pkt, frag, NET_IPV6UDPH_LEN, &pos, 10,
(u8_t *)sample_data + 60, K_FOREVER);
zassert_false(!frag || pos != 58, "Usecase 8: Write failed");
read_frag = net_frag_read(frag, NET_IPV6UDPH_LEN, &read_pos, 10,
read_data);
zassert_false(!read_frag && read_pos == 0xffff,
"Usecase 8: Read failed");
zassert_false(memcmp(read_data, sample_data + 60, 10),
"Usecase 8: Read data mismatch");
zassert_true(net_pkt_insert(pkt, frag, NET_IPV6UDPH_LEN, 60,
(u8_t *)sample_data, K_FOREVER),
"Usecase 8: Insert failed");
read_frag = net_frag_read(frag, NET_IPV6UDPH_LEN, &read_pos, 70,
read_data);
zassert_false(!read_frag && read_pos == 0xffff,
"Usecase 8: Read after failed");
zassert_false(memcmp(read_data, sample_data, 70),
"Usecase 8: Read data mismatch after insertion");
net_pkt_unref(pkt);
DBG("test_pkt_read_write_insert passed\n");
}
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;
}
