static int lo_txpoll(FAR struct net_driver_s *dev)
{
FAR struct lo_driver_s *priv = (FAR struct lo_driver_s *)dev->d_private;
/* Loop while there is data "sent", i.e., while d_len > 0. That should be
* the case upon entry here and while the processing of the IPv4/6 packet
* generates a new packet to be sent. Sending, of course, just means
* relaying back through the network for this driver.
*/
while (priv->lo_dev.d_len > 0)
{
NETDEV_TXPACKETS(&priv->lo_dev);
NETDEV_RXPACKETS(&priv->lo_dev);
#ifdef CONFIG_NET_PKT
/* When packet sockets are enabled, feed the frame into the packet tap */
pkt_input(&priv->lo_dev);
#endif
/* We only accept IP packets of the configured type and ARP packets */
#ifdef CONFIG_NET_IPv4
if ((IPv4BUF->vhl & IP_VERSION_MASK) == IPv4_VERSION)
{
nllvdbg("IPv4 frame\n");
NETDEV_RXIPV4(&priv->lo_dev);
ipv4_input(&priv->lo_dev);
}
else
#endif
#ifdef CONFIG_NET_IPv6
if ((IPv6BUF->vtc & IP_VERSION_MASK) == IPv6_VERSION)
{
nllvdbg("Iv6 frame\n");
NETDEV_RXIPV6(&priv->lo_dev);
ipv6_input(&priv->lo_dev);
}
else
#endif
{
ndbg("WARNING: Unrecognized packet type dropped: %02x\n", IPv4BUF->vhl);
NETDEV_RXDROPPED(&priv->lo_dev);
priv->lo_dev.d_len = 0;
}
priv->lo_txdone = true;
NETDEV_TXDONE(&priv->lo_dev);
}
return 0;
}
static void emac_receive(FAR struct emac_driver_s *priv)
{
do
{
/* Check for errors and update statistics */
/* Check if the packet is a valid size for the network buffer configuration */
/* Copy the data data from the hardware to priv->d_dev.d_buf. Set
* amount of data in priv->d_dev.d_len
*/
#ifdef CONFIG_NET_PKT
/* When packet sockets are enabled, feed the frame into the packet tap */
pkt_input(&priv->d_dev);
#endif
/* We only accept IP packets of the configured type and ARP packets */
#ifdef CONFIG_NET_IPv4
if (BUF->type == HTONS(ETHTYPE_IP))
{
nllvdbg("IPv4 frame\n");
/* Handle ARP on input then give the IPv4 packet to the network
* layer
*/
arp_ipin(&priv->d_dev);
ipv4_input(&priv->d_dev);
/* If the above function invocation resulted in data that should be
* sent out on the network, the field d_len will set to a value > 0.
*/
if (priv->d_dev.d_len > 0)
{
/* Update the Ethernet header with the correct MAC address */
#ifdef CONFIG_NET_IPv6
if (IFF_IS_IPv4(priv->d_dev.d_flags))
#endif
{
arp_out(&priv->d_dev);
}
#ifdef CONFIG_NET_IPv6
else
{
neighbor_out(&priv->d_dev);
}
#endif
/* And send the packet */
emac_transmit(priv);
}
}
else
#endif
#ifdef CONFIG_NET_IPv6
if (BUF->type == HTONS(ETHTYPE_IP6))
{
nllvdbg("Iv6 frame\n");
/* Give the IPv6 packet to the network layer */
ipv6_input(&priv->d_dev);
/* If the above function invocation resulted in data that should be
* sent out on the network, the field d_len will set to a value > 0.
*/
if (priv->d_dev.d_len > 0)
{
/* Update the Ethernet header with the correct MAC address */
#ifdef CONFIG_NET_IPv4
if (IFF_IS_IPv4(priv->d_dev.d_flags))
{
arp_out(&priv->d_dev);
}
else
#endif
#ifdef CONFIG_NET_IPv6
{
neighbor_out(&priv->d_dev);
}
#endif
/* And send the packet */
emac_transmit(priv);
}
}
else
#endif
#ifdef CONFIG_NET_ARP
if (BUF->type == htons(ETHTYPE_ARP))
{
arp_arpin(&priv->d_dev);
/* If the above function invocation resulted in data that should be
* sent out on the network, the field d_len will set to a value > 0.
*/
if (priv->d_dev.d_len > 0)
{
emac_transmit(priv);
}
}
#endif
}
while (true); /* While there are more packets to be processed */
}
static void e1000_receive(struct e1000_dev *e1000)
{
int head = e1000->rx_ring.head;
unsigned char *cp = (unsigned char *)
(e1000->rx_ring.buf + head * CONFIG_E1000_BUFF_SIZE);
int cnt;
while (e1000->rx_ring.desc[head].desc_status)
{
/* Check for errors and update statistics */
/* Here we do not handle packets that exceed packet-buffer size */
if ((e1000->rx_ring.desc[head].desc_status & 3) == 1)
{
cprintf("NIC READ: Oversized packet\n");
goto next;
}
/* Check if the packet is a valid size for the uIP buffer configuration */
/* get the number of actual data-bytes in this packet */
cnt = e1000->rx_ring.desc[head].packet_length;
if (cnt > CONFIG_NET_ETH_MTU || cnt < 14)
{
cprintf("NIC READ: invalid package size\n");
goto next;
}
/* Copy the data data from the hardware to e1000->netdev.d_buf. Set
* amount of data in e1000->netdev.d_len
*/
/* now we try to copy these data-bytes to the UIP buffer */
memcpy(e1000->netdev.d_buf, cp, cnt);
e1000->netdev.d_len = cnt;
#ifdef CONFIG_NET_PKT
/* When packet sockets are enabled, feed the frame into the packet tap */
pkt_input(&e1000->netdev);
#endif
/* We only accept IP packets of the configured type and ARP packets */
#ifdef CONFIG_NET_IPv4
if (BUF->type == HTONS(ETHTYPE_IP))
{
nllvdbg("IPv4 frame\n");
/* Handle ARP on input then give the IPv4 packet to the network
* layer
*/
arp_ipin(&e1000->netdev);
ipv4_input(&e1000->netdev);
/* If the above function invocation resulted in data that should be
* sent out on the network, the field d_len will set to a value > 0.
*/
if (e1000->netdev.d_len > 0)
{
/* Update the Ethernet header with the correct MAC address */
#ifdef CONFIG_NET_IPv6
if (IFF_IS_IPv4(e1000->netdev.d_flags))
#endif
{
arp_out(&e1000->netdev);
}
#ifdef CONFIG_NET_IPv6
else
{
neighbor_out(&e1000->netdev);
}
#endif
/* And send the packet */
e1000_transmit(e1000);
}
}
else
#endif
#ifdef CONFIG_NET_IPv6
if (BUF->type == HTONS(ETHTYPE_IP6))
{
nllvdbg("Iv6 frame\n");
/* Give the IPv6 packet to the network layer */
ipv6_input(&e1000->netdev);
/* If the above function invocation resulted in data that should be
* sent out on the network, the field d_len will set to a value > 0.
*/
if (e1000->netdev.d_len > 0)
{
/* Update the Ethernet header with the correct MAC address */
#ifdef CONFIG_NET_IPv4
if (IFF_IS_IPv4(e1000->netdev.d_flags))
{
arp_out(&e1000->netdev);
}
else
#endif
#ifdef CONFIG_NET_IPv6
{
neighbor_out(&e1000->netdev);
}
#endif
/* And send the packet */
e1000_transmit(e1000);
}
}
else
#endif
#ifdef CONFIG_NET_ARP
if (BUF->type == htons(ETHTYPE_ARP))
{
arp_arpin(&e1000->netdev);
/* If the above function invocation resulted in data that should be
* sent out on the network, the field d_len will set to a value > 0.
*/
if (e1000->netdev.d_len > 0)
{
e1000_transmit(e1000);
}
#endif
}
next:
e1000->rx_ring.desc[head].desc_status = 0;
e1000->rx_ring.head = (head + 1) % CONFIG_E1000_N_RX_DESC;
e1000->rx_ring.free++;
head = e1000->rx_ring.head;
cp = (unsigned char *)(e1000->rx_ring.buf + head * CONFIG_E1000_BUFF_SIZE);
}
}
static void bcmf_receive(FAR struct bcmf_dev_s *priv)
{
struct bcmf_frame_s *frame;
// wlinfo("Entry\n");
do
{
/* Request frame buffer from bus interface */
frame = bcmf_bdc_rx_frame(priv);
if (frame == NULL)
{
/* No more frame to process */
break;
}
if (!priv->bc_bifup)
{
/* Interface down, drop frame */
priv->bus->free_frame(priv, frame);
continue;
}
priv->bc_dev.d_buf = frame->data;
priv->bc_dev.d_len = frame->len - (uint32_t)(frame->data - frame->base);
wlinfo("Got frame %p %d\n", frame, priv->bc_dev.d_len);
#ifdef CONFIG_NET_PKT
/* When packet sockets are enabled, feed the frame into the packet tap */
pkt_input(&priv->bc_dev);
#endif
/* We only accept IP packets of the configured type and ARP packets */
#ifdef CONFIG_NET_IPv4
if (BUF->type == HTONS(ETHTYPE_IP))
{
ninfo("IPv4 frame\n");
NETDEV_RXIPV4(&priv->bc_dev);
/* Handle ARP on input then give the IPv4 packet to the network
* layer
*/
arp_ipin(&priv->bc_dev);
ipv4_input(&priv->bc_dev);
/* If the above function invocation resulted in data that should be
* sent out on the network, the field d_len will set to a value > 0.
*/
if (priv->bc_dev.d_len > 0)
{
/* Update the Ethernet header with the correct MAC address */
#ifdef CONFIG_NET_IPv6
if (IFF_IS_IPv4(priv->bc_dev.d_flags))
#endif
{
arp_out(&priv->bc_dev);
}
#ifdef CONFIG_NET_IPv6
else
{
neighbor_out(&kel->bc_dev);
}
#endif
/* And send the packet */
bcmf_transmit(priv, frame);
}
else
{
/* Release RX frame buffer */
priv->bus->free_frame(priv, frame);
}
}
else
#endif
#ifdef CONFIG_NET_IPv6
if (BUF->type == HTONS(ETHTYPE_IP6))
{
ninfo("Iv6 frame\n");
NETDEV_RXIPV6(&priv->bc_dev);
/* Give the IPv6 packet to the network layer */
ipv6_input(&priv->bc_dev);
/* If the above function invocation resulted in data that should be
* sent out on the network, the field d_len will set to a value > 0.
*/
if (priv->bc_dev.d_len > 0)
{
/* Update the Ethernet header with the correct MAC address */
#ifdef CONFIG_NET_IPv4
if (IFF_IS_IPv4(priv->bc_dev.d_flags))
{
arp_out(&priv->bc_dev);
}
else
#endif
#ifdef CONFIG_NET_IPv6
{
neighbor_out(&priv->bc_dev);
}
#endif
/* And send the packet */
bcmf_transmit(priv, frame);
}
else
{
/* Release RX frame buffer */
priv->bus->free_frame(priv, frame);
}
}
else
#endif
#ifdef CONFIG_NET_ARP
if (BUF->type == htons(ETHTYPE_ARP))
{
arp_arpin(&priv->bc_dev);
NETDEV_RXARP(&priv->bc_dev);
/* If the above function invocation resulted in data that should be
* sent out on the network, the field d_len will set to a value > 0.
*/
if (priv->bc_dev.d_len > 0)
{
bcmf_transmit(priv, frame);
}
else
{
/* Release RX frame buffer */
priv->bus->free_frame(priv, frame);
}
}
else
#endif
{
wlerr("ERROR: RX dropped\n");
NETDEV_RXDROPPED(&priv->bc_dev);
priv->bus->free_frame(priv, frame);
}
}
while (1); /* While there are more packets to be processed */
}
void netdriver_loop(void)
{
FAR struct eth_hdr_s *eth;
/* Check for new frames. If so, then poll the network for new XMIT data */
net_lock();
(void)devif_poll(&g_sim_dev, sim_txpoll);
net_unlock();
/* netdev_read will return 0 on a timeout event and >0 on a data received event */
g_sim_dev.d_len = netdev_read((FAR unsigned char *)g_sim_dev.d_buf,
CONFIG_NET_ETH_MTU);
/* Disable preemption through to the following so that it behaves a little more
* like an interrupt (otherwise, the following logic gets pre-empted an behaves
* oddly.
*/
sched_lock();
if (g_sim_dev.d_len > 0)
{
/* Data received event. Check for valid Ethernet header with destination == our
* MAC address
*/
eth = BUF;
if (g_sim_dev.d_len > ETH_HDRLEN)
{
int is_ours;
/* Figure out if this ethernet frame is addressed to us. This affects
* what we're willing to receive. Note that in promiscuous mode, the
* up_comparemac will always return 0.
*/
is_ours = (up_comparemac(eth->dest, &g_sim_dev.d_mac.ether) == 0);
#ifdef CONFIG_NET_PKT
/* When packet sockets are enabled, feed the frame into the packet
* tap.
*/
if (is_ours)
{
pkt_input(&g_sim_dev);
}
#endif /* CONFIG_NET_PKT */
/* We only accept IP packets of the configured type and ARP packets */
#ifdef CONFIG_NET_IPv4
if (eth->type == HTONS(ETHTYPE_IP) && is_ours)
{
ninfo("IPv4 frame\n");
/* Handle ARP on input then give the IPv4 packet to the network
* layer
*/
arp_ipin(&g_sim_dev);
ipv4_input(&g_sim_dev);
/* If the above function invocation resulted in data that
* should be sent out on the network, the global variable
* d_len is set to a value > 0.
*/
if (g_sim_dev.d_len > 0)
{
/* Update the Ethernet header with the correct MAC address */
#ifdef CONFIG_NET_IPv6
if (IFF_IS_IPv4(g_sim_dev.d_flags))
#endif
{
arp_out(&g_sim_dev);
}
#ifdef CONFIG_NET_IPv6
else
{
neighbor_out(&g_sim_dev);
}
#endif
/* And send the packet */
netdev_send(g_sim_dev.d_buf, g_sim_dev.d_len);
}
}
else
#endif /* CONFIG_NET_IPv4 */
#ifdef CONFIG_NET_IPv6
if (eth->type == HTONS(ETHTYPE_IP6) && is_ours)
{
ninfo("Iv6 frame\n");
/* Give the IPv6 packet to the network layer */
ipv6_input(&g_sim_dev);
/* If the above function invocation resulted in data that
* should be sent out on the network, the global variable
* d_len is set to a value > 0.
*/
if (g_sim_dev.d_len > 0)
{
/* Update the Ethernet header with the correct MAC address */
#ifdef CONFIG_NET_IPv4
if (IFF_IS_IPv4(g_sim_dev.d_flags))
{
arp_out(&g_sim_dev);
}
else
#endif
#ifdef CONFIG_NET_IPv6
{
neighbor_out(&g_sim_dev);
}
#endif /* CONFIG_NET_IPv6 */
/* And send the packet */
netdev_send(g_sim_dev.d_buf, g_sim_dev.d_len);
}
}
else
#endif/* CONFIG_NET_IPv6 */
#ifdef CONFIG_NET_ARP
if (eth->type == htons(ETHTYPE_ARP))
{
arp_arpin(&g_sim_dev);
/* If the above function invocation resulted in data that
* should be sent out on the network, the global variable
* d_len is set to a value > 0.
*/
if (g_sim_dev.d_len > 0)
{
netdev_send(g_sim_dev.d_buf, g_sim_dev.d_len);
}
}
else
#endif
{
nwarn("WARNING: Unsupported Ethernet type %u\n", eth->type);
}
}
}
/* Otherwise, it must be a timeout event */
else if (timer_expired(&g_periodic_timer))
{
timer_reset(&g_periodic_timer);
devif_timer(&g_sim_dev, sim_txpoll);
}
sched_unlock();
}
static void misoc_net_receive(FAR struct misoc_net_driver_s *priv)
{
uint8_t rxslot;
uint32_t rxlen;
do
{
/* Check for errors and update statistics */
/* Check if the packet is a valid size for the network buffer
* configuration.
*/
/* Find rx slot */
rxslot = ethmac_sram_writer_slot_read();
/* Get rx len */
rxlen = ethmac_sram_writer_length_read();
/* Copy the data data from the hardware to priv->misoc_net_dev.d_buf. Set
* amount of data in priv->misoc_net_dev.d_len
*
* NOTE: These memcpy's could be avoided by simply setting the d_buf
* pointer to the rx*_buf containing the received data. Some additional
* buffer management logic would also be required.
*/
misoc_flush_dcache();
if (rxslot)
{
memcpy(priv->misoc_net_dev.d_buf, priv->rx1_buf, rxlen);
}
else
{
memcpy(priv->misoc_net_dev.d_buf, priv->rx0_buf, rxlen);
}
/* Clear event pending */
ethmac_sram_writer_ev_pending_write(1);
priv->misoc_net_dev.d_len = rxlen;
#ifdef CONFIG_NET_PKT
/* When packet sockets are enabled, feed the frame into the packet tap */
pkt_input(&priv->misoc_net_dev);
#endif
/* We only accept IP packets of the configured type and ARP packets */
#ifdef CONFIG_NET_IPv4
if (BUF->type == HTONS(ETHTYPE_IP))
{
ninfo("IPv4 frame\n");
NETDEV_RXIPV4(&priv->misoc_net_dev);
/* Handle ARP on input then give the IPv4 packet to the network
* layer
*/
arp_ipin(&priv->misoc_net_dev);
ipv4_input(&priv->misoc_net_dev);
/* If the above function invocation resulted in data that should be
* sent out on the network, the field d_len will set to a value > 0.
*/
if (priv->misoc_net_dev.d_len > 0)
{
/* Update the Ethernet header with the correct MAC address */
#ifdef CONFIG_NET_IPv6
if (IFF_IS_IPv4(priv->misoc_net_dev.d_flags))
#endif
{
arp_out(&priv->misoc_net_dev);
}
#ifdef CONFIG_NET_IPv6
else
{
neighbor_out(&kel->misoc_net_dev);
}
#endif
/* And send the packet */
misoc_net_transmit(priv);
}
}
else
#endif
#ifdef CONFIG_NET_IPv6
if (BUF->type == HTONS(ETHTYPE_IP6))
{
ninfo("Iv6 frame\n");
NETDEV_RXIPV6(&priv->misoc_net_dev);
/* Give the IPv6 packet to the network layer */
ipv6_input(&priv->misoc_net_dev);
/* If the above function invocation resulted in data that should be
* sent out on the network, the field d_len will set to a value > 0.
*/
if (priv->misoc_net_dev.d_len > 0)
{
/* Update the Ethernet header with the correct MAC address */
#ifdef CONFIG_NET_IPv4
if (IFF_IS_IPv4(priv->misoc_net_dev.d_flags))
{
arp_out(&priv->misoc_net_dev);
}
else
#endif
#ifdef CONFIG_NET_IPv6
{
neighbor_out(&priv->misoc_net_dev);
}
#endif
/* And send the packet */
misoc_net_transmit(priv);
}
}
else
#endif
#ifdef CONFIG_NET_ARP
if (BUF->type == htons(ETHTYPE_ARP))
{
arp_arpin(&priv->misoc_net_dev);
NETDEV_RXARP(&priv->misoc_net_dev);
/* If the above function invocation resulted in data that should be
* sent out on the network, the field d_len will set to a value > 0.
*/
if (priv->misoc_net_dev.d_len > 0)
{
misoc_net_transmit(priv);
}
}
#endif
else
{
NETDEV_RXDROPPED(&priv->misoc_net_dev);
}
}
while (ethmac_sram_writer_ev_pending_read() & ETHMAC_EV_SRAM_WRITER);
}
void rtos_vnet_recv(struct rgmp_vnet *rgmp_vnet, char *data, int len)
{
struct vnet_driver_s *vnet = rgmp_vnet->priv;
do
{
/* Check if the packet is a valid size for the network buffer
* configuration.
*/
if (len > CONFIG_NET_ETH_MTU || len < 14)
{
#ifdef CONFIG_DEBUG
cprintf("VNET: receive invalid packet of size %d\n", len);
#endif
return;
}
/* Copy the data data from the hardware to vnet->sk_dev.d_buf. Set
* amount of data in vnet->sk_dev.d_len
*/
memcpy(vnet->sk_dev.d_buf, data, len);
vnet->sk_dev.d_len = len;
#ifdef CONFIG_NET_PKT
/* When packet sockets are enabled, feed the frame into the packet tap */
pkt_input(&vnet->sk_dev);
#endif
/* We only accept IP packets of the configured type and ARP packets */
#ifdef CONFIG_NET_IPv4
if (BUF->type == HTONS(ETHTYPE_IP))
{
nllvdbg("IPv4 frame\n");
/* Handle ARP on input then give the IPv4 packet to the network
* layer
*/
arp_ipin(&vnet->sk_dev);
ipv4_input(&vnet->sk_dev);
/* If the above function invocation resulted in data that should be
* sent out on the network, the field d_len will set to a value > 0.
*/
if (vnet->sk_dev.d_len > 0)
{
/* Update the Ethernet header with the correct MAC address */
#ifdef CONFIG_NET_IPv6
if (IFF_IS_IPv4(vnet->sk_dev.d_flags))
#endif
{
arp_out(&vnet->sk_dev);
}
#ifdef CONFIG_NET_IPv6
else
{
neighbor_out(&vnet->sk_dev);
}
#endif
/* And send the packet */
vnet_transmit(vnet);
}
}
else
#endif
#ifdef CONFIG_NET_IPv6
if (BUF->type == HTONS(ETHTYPE_IP6))
{
nllvdbg("Iv6 frame\n");
/* Give the IPv6 packet to the network layer */
ipv6_input(&vnet->sk_dev);
/* If the above function invocation resulted in data that should be
* sent out on the network, the field d_len will set to a value > 0.
*/
if (vnet->sk_dev.d_len > 0)
{
/* Update the Ethernet header with the correct MAC address */
#ifdef CONFIG_NET_IPv4
if (IFF_IS_IPv4(vnet->sk_dev.d_flags))
{
arp_out(&vnet->sk_dev);
}
else
#endif
#ifdef CONFIG_NET_IPv6
{
neighbor_out(&vnet->sk_dev);
}
#endif
/* And send the packet */
vnet_transmit(vnet);
}
}
else
#endif
#ifdef CONFIG_NET_ARP
if (BUF->type == htons(ETHTYPE_ARP))
{
arp_arpin(&vnet->sk_dev);
/* If the above function invocation resulted in data that should
* be sent out on the network, the field d_len will set to a
* value > 0.
*/
if (vnet->sk_dev.d_len > 0)
{
vnet_transmit(vnet);
}
}
#endif
}
while (0); /* While there are more packets to be processed */
}
/**@brief Function for receiving 6LoWPAN module events.
*
* @param[in] p_6lo_interface Pointer to 6LoWPAN interface.
* @param[in] p_6lo_event Pointer to 6LoWPAN related event.
*
* @return None.
*/
static void ble_6lowpan_evt_handler(iot_interface_t * p_interface,
ble_6lowpan_event_t * p_6lo_event)
{
bool rx_failure = false;
uint32_t err_code;
uint32_t interface_id;
iot_pbuffer_t * p_pbuffer;
iot_pbuffer_alloc_param_t pbuff_param;
IPV6_MUTEX_LOCK();
IPV6_ENTRY();
IPV6_TRC("In 6LoWPAN Handler:");
interface_id = interface_get_by_6lo(p_interface);
switch (p_6lo_event->event_id)
{
case BLE_6LO_EVT_ERROR:
{
IPV6_ERR("Got error, with result %08lx", p_6lo_event->event_result);
break;
}
case BLE_6LO_EVT_INTERFACE_ADD:
{
IPV6_TRC("New interface established!");
// Add interface to internal table.
err_code = interface_add(p_interface, &interface_id);
if (NRF_SUCCESS == err_code)
{
IPV6_TRC("Added new network interface to internal table.");
err_code = iot_context_manager_table_alloc(p_interface);
if (err_code == NRF_SUCCESS)
{
IPV6_TRC("Successfully allocated context table!");
}
else
{
IPV6_ERR("Failed to allocate context table!");
}
// Increase number of up interfaces.
m_interfaces_count++;
// Notify application.
app_notify_interface_add(p_interface);
}
else
{
IPV6_ERR("Cannot add new interface. Table is full.");
}
break;
}
case BLE_6LO_EVT_INTERFACE_DELETE:
{
IPV6_TRC("Interface disconnected!");
if (interface_id < IPV6_MAX_INTERFACE)
{
IPV6_TRC("Removed network interface.");
// Notify application.
app_notify_interface_delete(p_interface);
err_code = iot_context_manager_table_free(p_interface);
if (err_code == NRF_SUCCESS)
{
IPV6_TRC("Successfully freed context table!");
}
// Decrease number of up interfaces.
m_interfaces_count--;
// Remove interface from internal table.
interface_delete(interface_id);
}
break;
}
case BLE_6LO_EVT_INTERFACE_DATA_RX:
{
IPV6_TRC("Got data with size = %d!",
p_6lo_event->event_param.rx_event_param.packet_len);
IPV6_TRC("Data: ");
IPV6_DUMP(p_6lo_event->event_param.rx_event_param.p_packet,
p_6lo_event->event_param.rx_event_param.packet_len);
if (interface_id < IPV6_MAX_INTERFACE)
{
if (p_6lo_event->event_result == NRF_ERROR_NOT_FOUND)
{
IPV6_ERR("Cannot restore IPv6 addresses!");
IPV6_ERR("Source CID = 0x%x, Destination CID = 0x%x",
p_6lo_event->event_param.rx_event_param.rx_contexts.src_cntxt_id,
p_6lo_event->event_param.rx_event_param.rx_contexts.dest_cntxt_id);
// Indicates failure.
rx_failure = true;
break;
}
// Check if packet is for us.
ipv6_addr_t * p_addr =
(ipv6_addr_t *)&p_6lo_event->event_param.rx_event_param.p_packet[DEST_ADDR_OFFSET];
err_code = addr_check(interface_id, p_addr, true);
// If no address found - drop message.
if (err_code != NRF_SUCCESS)
{
IPV6_ERR("Packet received on unknown address!");
rx_failure = true;
break;
}
// Try to allocate pbuffer, with no memory.
pbuff_param.flags = PBUFFER_FLAG_NO_MEM_ALLOCATION;
pbuff_param.type = RAW_PACKET_TYPE;
pbuff_param.length = p_6lo_event->event_param.rx_event_param.packet_len;
// Try to allocate pbuffer for receiving data.
err_code = iot_pbuffer_allocate(&pbuff_param, &p_pbuffer);
if (err_code == NRF_SUCCESS)
{
p_pbuffer->p_memory = p_6lo_event->event_param.rx_event_param.p_packet;
p_pbuffer->p_payload = p_pbuffer->p_memory + IPV6_IP_HEADER_SIZE;
p_pbuffer->length -= IPV6_IP_HEADER_SIZE;
// Execute multiplexer.
err_code = ipv6_input(p_interface, p_pbuffer);
if (err_code != NRF_SUCCESS)
{
IPV6_ERR("Failed while processing packet, error = 0x%08lX!", err_code);
}
}
else
{
IPV6_ERR("Failed to allocate packet buffer!");
rx_failure = true;
}
}
else
{
IPV6_ERR("[6LOWPAN]: Got data to unknown interface!");
rx_failure = true;
}
break;
}
default:
break;
}
if (rx_failure == true)
{
UNUSED_VARIABLE(nrf_free(p_6lo_event->event_param.rx_event_param.p_packet));
}
IPV6_EXIT();
IPV6_MUTEX_UNLOCK();
}
