407 lines
8.5 KiB
C
407 lines
8.5 KiB
C
/** @file
|
|
* @brief Network initialization
|
|
*
|
|
* Initialize the network IP stack. Create one thread for reading data
|
|
* from IP stack and passing that data to applications (Rx thread).
|
|
*/
|
|
|
|
/*
|
|
* Copyright (c) 2016 Intel Corporation
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
#if defined(CONFIG_NET_DEBUG_CORE)
|
|
#define SYS_LOG_DOMAIN "net/core"
|
|
#define NET_LOG_ENABLED 1
|
|
#endif
|
|
|
|
#include <init.h>
|
|
#include <kernel.h>
|
|
#include <toolchain.h>
|
|
#include <linker/sections.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
|
|
#include <net/net_if.h>
|
|
#include <net/net_mgmt.h>
|
|
#include <net/arp.h>
|
|
#include <net/net_pkt.h>
|
|
#include <net/net_core.h>
|
|
#include <net/dns_resolve.h>
|
|
|
|
#include "net_private.h"
|
|
#include "net_shell.h"
|
|
|
|
#include "icmpv6.h"
|
|
#include "ipv6.h"
|
|
|
|
#include "icmpv4.h"
|
|
|
|
#if defined(CONFIG_NET_DHCPV4)
|
|
#include "dhcpv4.h"
|
|
#endif
|
|
|
|
#include "route.h"
|
|
#include "rpl.h"
|
|
|
|
#include "connection.h"
|
|
#include "udp_internal.h"
|
|
#include "tcp.h"
|
|
|
|
#include "net_stats.h"
|
|
|
|
/* Stack for the rx thread.
|
|
*/
|
|
#if !defined(CONFIG_NET_RX_STACK_SIZE)
|
|
#define CONFIG_NET_RX_STACK_SIZE 1024
|
|
#endif
|
|
|
|
NET_STACK_DEFINE(RX, rx_stack, CONFIG_NET_RX_STACK_SIZE,
|
|
CONFIG_NET_RX_STACK_SIZE + CONFIG_NET_RX_STACK_RPL);
|
|
static struct k_thread rx_thread_data;
|
|
static struct k_fifo rx_queue;
|
|
static k_tid_t rx_tid;
|
|
static K_SEM_DEFINE(startup_sync, 0, UINT_MAX);
|
|
|
|
static inline enum net_verdict process_data(struct net_pkt *pkt,
|
|
bool is_loopback)
|
|
{
|
|
int ret;
|
|
bool locally_routed = false;
|
|
|
|
#if defined(CONFIG_NET_IPV6_FRAGMENT)
|
|
/* If the packet is routed back to us when we have reassembled
|
|
* an IPv6 packet, then do not pass it to L2 as the packet does
|
|
* not have link layer headers in it.
|
|
*/
|
|
if (net_pkt_ipv6_fragment_start(pkt)) {
|
|
locally_routed = true;
|
|
}
|
|
#endif
|
|
|
|
/* If there is no data, then drop the packet. */
|
|
if (!pkt->frags) {
|
|
NET_DBG("Corrupted packet (frags %p)", pkt->frags);
|
|
net_stats_update_processing_error();
|
|
|
|
return NET_DROP;
|
|
}
|
|
|
|
if (!is_loopback && !locally_routed) {
|
|
ret = net_if_recv_data(net_pkt_iface(pkt), pkt);
|
|
if (ret != NET_CONTINUE) {
|
|
if (ret == NET_DROP) {
|
|
NET_DBG("Packet %p discarded by L2", pkt);
|
|
net_stats_update_processing_error();
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/* IP version and header length. */
|
|
switch (NET_IPV6_HDR(pkt)->vtc & 0xf0) {
|
|
#if defined(CONFIG_NET_IPV6)
|
|
case 0x60:
|
|
net_stats_update_ipv6_recv();
|
|
net_pkt_set_family(pkt, PF_INET6);
|
|
return net_ipv6_process_pkt(pkt);
|
|
#endif
|
|
#if defined(CONFIG_NET_IPV4)
|
|
case 0x40:
|
|
net_stats_update_ipv4_recv();
|
|
net_pkt_set_family(pkt, PF_INET);
|
|
return net_ipv4_process_pkt(pkt);
|
|
#endif
|
|
}
|
|
|
|
NET_DBG("Unknown IP family packet (0x%x)",
|
|
NET_IPV6_HDR(pkt)->vtc & 0xf0);
|
|
net_stats_update_ip_errors_protoerr();
|
|
net_stats_update_ip_errors_vhlerr();
|
|
|
|
return NET_DROP;
|
|
}
|
|
|
|
static void processing_data(struct net_pkt *pkt, bool is_loopback)
|
|
{
|
|
switch (process_data(pkt, is_loopback)) {
|
|
case NET_OK:
|
|
NET_DBG("Consumed pkt %p", pkt);
|
|
break;
|
|
case NET_DROP:
|
|
default:
|
|
NET_DBG("Dropping pkt %p", pkt);
|
|
net_pkt_unref(pkt);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void net_rx_thread(void)
|
|
{
|
|
struct net_pkt *pkt;
|
|
|
|
NET_DBG("Starting RX thread (stack %zu bytes)",
|
|
K_THREAD_STACK_SIZEOF(rx_stack));
|
|
|
|
/* Starting TX side. The ordering is important here and the TX
|
|
* can only be started when RX side is ready to receive packets.
|
|
* We synchronize the startup of the device so that both RX and TX
|
|
* are only started fully when both are ready to receive or send
|
|
* data.
|
|
*/
|
|
net_if_init(&startup_sync);
|
|
|
|
k_sem_take(&startup_sync, K_FOREVER);
|
|
|
|
/* This will take the interface up and start everything. */
|
|
net_if_post_init();
|
|
|
|
while (1) {
|
|
#if defined(CONFIG_NET_STATISTICS) || defined(CONFIG_NET_DEBUG_CORE)
|
|
size_t pkt_len;
|
|
#endif
|
|
|
|
pkt = k_fifo_get(&rx_queue, K_FOREVER);
|
|
|
|
net_analyze_stack("RX thread", K_THREAD_STACK_BUFFER(rx_stack),
|
|
K_THREAD_STACK_SIZEOF(rx_stack));
|
|
|
|
#if defined(CONFIG_NET_STATISTICS) || defined(CONFIG_NET_DEBUG_CORE)
|
|
pkt_len = net_pkt_get_len(pkt);
|
|
#endif
|
|
NET_DBG("Received pkt %p len %zu", pkt, pkt_len);
|
|
|
|
net_stats_update_bytes_recv(pkt_len);
|
|
|
|
processing_data(pkt, false);
|
|
|
|
net_print_statistics();
|
|
net_pkt_print();
|
|
|
|
k_yield();
|
|
}
|
|
}
|
|
|
|
static void init_rx_queue(void)
|
|
{
|
|
k_fifo_init(&rx_queue);
|
|
|
|
rx_tid = k_thread_create(&rx_thread_data, rx_stack,
|
|
K_THREAD_STACK_SIZEOF(rx_stack),
|
|
(k_thread_entry_t)net_rx_thread,
|
|
NULL, NULL, NULL, K_PRIO_COOP(8),
|
|
K_ESSENTIAL, K_NO_WAIT);
|
|
}
|
|
|
|
#if defined(CONFIG_NET_IP_ADDR_CHECK)
|
|
/* Check if the IPv{4|6} addresses are proper. As this can be expensive,
|
|
* make this optional.
|
|
*/
|
|
static inline int check_ip_addr(struct net_pkt *pkt)
|
|
{
|
|
#if defined(CONFIG_NET_IPV6)
|
|
if (net_pkt_family(pkt) == AF_INET6) {
|
|
if (net_ipv6_addr_cmp(&NET_IPV6_HDR(pkt)->dst,
|
|
net_ipv6_unspecified_address())) {
|
|
NET_DBG("IPv6 dst address missing");
|
|
return -EADDRNOTAVAIL;
|
|
}
|
|
|
|
/* If the destination address is our own, then route it
|
|
* back to us.
|
|
*/
|
|
if (net_is_ipv6_addr_loopback(&NET_IPV6_HDR(pkt)->dst) ||
|
|
net_is_my_ipv6_addr(&NET_IPV6_HDR(pkt)->dst)) {
|
|
struct in6_addr addr;
|
|
|
|
/* Swap the addresses so that in receiving side
|
|
* the packet is accepted.
|
|
*/
|
|
net_ipaddr_copy(&addr, &NET_IPV6_HDR(pkt)->src);
|
|
net_ipaddr_copy(&NET_IPV6_HDR(pkt)->src,
|
|
&NET_IPV6_HDR(pkt)->dst);
|
|
net_ipaddr_copy(&NET_IPV6_HDR(pkt)->dst, &addr);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* The source check must be done after the destination check
|
|
* as having src ::1 is perfectly ok if dst is ::1 too.
|
|
*/
|
|
if (net_is_ipv6_addr_loopback(&NET_IPV6_HDR(pkt)->src)) {
|
|
NET_DBG("IPv6 loopback src address");
|
|
return -EADDRNOTAVAIL;
|
|
}
|
|
} else
|
|
#endif /* CONFIG_NET_IPV6 */
|
|
|
|
#if defined(CONFIG_NET_IPV4)
|
|
if (net_pkt_family(pkt) == AF_INET) {
|
|
if (net_ipv4_addr_cmp(&NET_IPV4_HDR(pkt)->dst,
|
|
net_ipv4_unspecified_address())) {
|
|
return -EADDRNOTAVAIL;
|
|
}
|
|
|
|
/* If the destination address is our own, then route it
|
|
* back to us.
|
|
*/
|
|
if (net_is_ipv4_addr_loopback(&NET_IPV4_HDR(pkt)->dst) ||
|
|
net_is_my_ipv4_addr(&NET_IPV4_HDR(pkt)->dst)) {
|
|
struct in_addr addr;
|
|
|
|
/* Swap the addresses so that in receiving side
|
|
* the packet is accepted.
|
|
*/
|
|
net_ipaddr_copy(&addr, &NET_IPV4_HDR(pkt)->src);
|
|
net_ipaddr_copy(&NET_IPV4_HDR(pkt)->src,
|
|
&NET_IPV4_HDR(pkt)->dst);
|
|
net_ipaddr_copy(&NET_IPV4_HDR(pkt)->dst, &addr);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* The source check must be done after the destination check
|
|
* as having src 127.0.0.0/8 is perfectly ok if dst is in
|
|
* localhost subnet too.
|
|
*/
|
|
if (net_is_ipv4_addr_loopback(&NET_IPV4_HDR(pkt)->src)) {
|
|
NET_DBG("IPv4 loopback src address");
|
|
return -EADDRNOTAVAIL;
|
|
}
|
|
} else
|
|
#endif /* CONFIG_NET_IPV4 */
|
|
|
|
{
|
|
;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#else
|
|
#define check_ip_addr(pkt) 0
|
|
#endif
|
|
|
|
/* Called when data needs to be sent to network */
|
|
int net_send_data(struct net_pkt *pkt)
|
|
{
|
|
int status;
|
|
|
|
if (!pkt || !pkt->frags) {
|
|
return -ENODATA;
|
|
}
|
|
|
|
if (!net_pkt_iface(pkt)) {
|
|
return -EINVAL;
|
|
}
|
|
|
|
#if defined(CONFIG_NET_STATISTICS)
|
|
switch (net_pkt_family(pkt)) {
|
|
case AF_INET:
|
|
net_stats_update_ipv4_sent();
|
|
break;
|
|
case AF_INET6:
|
|
net_stats_update_ipv6_sent();
|
|
break;
|
|
}
|
|
#endif
|
|
|
|
status = check_ip_addr(pkt);
|
|
if (status < 0) {
|
|
return status;
|
|
} else if (status > 0) {
|
|
/* Packet is destined back to us so send it directly
|
|
* to RX processing.
|
|
*/
|
|
NET_DBG("Loopback pkt %p back to us", pkt);
|
|
processing_data(pkt, true);
|
|
return 0;
|
|
}
|
|
|
|
if (net_if_send_data(net_pkt_iface(pkt), pkt) == NET_DROP) {
|
|
return -EIO;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Called by driver when an IP packet has been received */
|
|
int net_recv_data(struct net_if *iface, struct net_pkt *pkt)
|
|
{
|
|
NET_ASSERT(pkt && pkt->frags);
|
|
NET_ASSERT(iface);
|
|
|
|
if (!pkt->frags) {
|
|
return -ENODATA;
|
|
}
|
|
|
|
if (!atomic_test_bit(iface->flags, NET_IF_UP)) {
|
|
return -ENETDOWN;
|
|
}
|
|
|
|
NET_DBG("fifo %p iface %p pkt %p len %zu", &rx_queue, iface, pkt,
|
|
net_pkt_get_len(pkt));
|
|
|
|
net_pkt_set_iface(pkt, iface);
|
|
|
|
k_fifo_put(&rx_queue, pkt);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static inline void l3_init(void)
|
|
{
|
|
net_icmpv4_init();
|
|
net_icmpv6_init();
|
|
net_ipv6_init();
|
|
|
|
#if defined(CONFIG_NET_UDP) || defined(CONFIG_NET_TCP)
|
|
net_conn_init();
|
|
#endif
|
|
net_udp_init();
|
|
net_tcp_init();
|
|
|
|
net_route_init();
|
|
|
|
dns_init_resolver();
|
|
|
|
NET_DBG("Network L3 init done");
|
|
}
|
|
|
|
static inline void l2_init(void)
|
|
{
|
|
net_arp_init();
|
|
|
|
NET_DBG("Network L2 init done");
|
|
}
|
|
|
|
static int net_init(struct device *unused)
|
|
{
|
|
int status = 0;
|
|
|
|
NET_DBG("Priority %d", CONFIG_NET_INIT_PRIO);
|
|
|
|
net_pkt_init();
|
|
|
|
net_context_init();
|
|
|
|
l2_init();
|
|
l3_init();
|
|
|
|
net_mgmt_event_init();
|
|
|
|
init_rx_queue();
|
|
|
|
#if CONFIG_NET_DHCPV4
|
|
status = dhcpv4_init();
|
|
if (status) {
|
|
return status;
|
|
}
|
|
#endif
|
|
|
|
return status;
|
|
}
|
|
|
|
SYS_INIT(net_init, POST_KERNEL, CONFIG_NET_INIT_PRIO);
|