ipv4.c File Reference

IPv4 protocol. More...

#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/list.h>
#include <ipxe/in.h>
#include <ipxe/arp.h>
#include <ipxe/if_ether.h>
#include <ipxe/iobuf.h>
#include <ipxe/netdevice.h>
#include <ipxe/ip.h>
#include <ipxe/tcpip.h>
#include <ipxe/dhcp.h>
#include <ipxe/settings.h>
#include <ipxe/fragment.h>
#include <ipxe/ipstat.h>
#include <ipxe/profile.h>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
struct ip_statistics_family ipv4_stats_family	__ip_statistics_family (IP_STATISTICS_IPV4)
	IPv4 statistics family.
static int	ipv4_add_miniroute (struct net_device *netdev, struct in_addr address, struct in_addr network, struct in_addr netmask, struct in_addr gateway)
	Add IPv4 minirouting table entry.
static int	ipv4_add_static (struct net_device *netdev, struct in_addr address, const void *routes, size_t len)
	Add static route minirouting table entries.
static int	ipv4_add_miniroutes (struct net_device *netdev, struct in_addr address)
	Add IPv4 minirouting table entries.
static void	ipv4_del_miniroute (struct ipv4_miniroute *miniroute)
	Delete IPv4 minirouting table entry.
static void	ipv4_del_miniroutes (void)
	Delete IPv4 minirouting table entries.
struct ipv4_miniroute *	ipv4_route (unsigned int scope_id, struct in_addr *dest)
	Perform IPv4 routing.
static struct net_device *	ipv4_netdev (struct sockaddr_tcpip *st_dest)
	Determine transmitting network device.
static int	ipv4_is_fragment (struct fragment *fragment, struct io_buffer *iobuf, size_t hdrlen __unused)
	Check if IPv4 fragment matches fragment reassembly buffer.
static size_t	ipv4_fragment_offset (struct io_buffer *iobuf, size_t hdrlen __unused)
	Get IPv4 fragment offset.
static int	ipv4_more_fragments (struct io_buffer *iobuf, size_t hdrlen __unused)
	Check if more fragments exist.
static uint16_t	ipv4_pshdr_chksum (struct io_buffer *iobuf, uint16_t csum)
	Add IPv4 pseudo-header checksum to existing checksum.
static int	ipv4_tx (struct io_buffer *iobuf, struct tcpip_protocol *tcpip_protocol, struct sockaddr_tcpip *st_src, struct sockaddr_tcpip *st_dest, struct net_device *netdev, uint16_t *trans_csum)
	Transmit IP packet.
int	ipv4_has_any_addr (struct net_device *netdev)
	Check if network device has any IPv4 address.
static int	ipv4_has_addr (struct net_device *netdev, struct in_addr addr)
	Check if network device has a specific IPv4 address.
static int	ipv4_rx (struct io_buffer *iobuf, struct net_device *netdev, const void *ll_dest __unused, const void *ll_source __unused, unsigned int flags)
	Process incoming packets.
static int	ipv4_arp_check (struct net_device *netdev, const void *net_addr)
	Check existence of IPv4 address for ARP.
int	inet_aton (const char *string, struct in_addr *in)
	Parse IPv4 address.
char *	inet_ntoa (struct in_addr in)
	Convert IPv4 address to dotted-quad notation.
static const char *	ipv4_ntoa (const void *net_addr)
	Transcribe IPv4 address.
static const char *	ipv4_sock_ntoa (struct sockaddr *sa)
	Transcribe IPv4 socket address.
static int	ipv4_sock_aton (const char *string, struct sockaddr *sa)
	Parse IPv4 socket address.
int	parse_ipv4_setting (const struct setting_type *type __unused, const char *value, void *buf, size_t len)
	Parse IPv4 address setting value.
int	format_ipv4_setting (const struct setting_type *type __unused, const void *raw, size_t raw_len, char *buf, size_t len)
	Format IPv4 address setting value.
const struct setting ip_setting	__setting (SETTING_IP4, ip)
	IPv4 address setting.
const struct setting netmask_setting	__setting (SETTING_IP4, netmask)
	IPv4 subnet mask setting.
const struct setting gateway_setting	__setting (SETTING_IP4, gateway)
	Default gateway setting.
const struct setting static_route_setting	__setting (SETTING_IP4, static_routes)
	Classless static routes setting.
static int	ipv4_gratuitous_arp (struct net_device *netdev, struct in_addr address)
	Send gratuitous ARP, if applicable.
static int	ipv4_settings (int(*apply)(struct net_device *netdev, struct in_addr address))
	Process IPv4 network device settings.
static int	ipv4_apply_routes (void)
	Create IPv4 routing table based on configured settings.
	REQUIRING_SYMBOL (ipv4_protocol)
	REQUIRE_OBJECT (icmpv4)

Variables
static uint8_t	next_ident_high = 0
struct list_head	ipv4_miniroutes = LIST_HEAD_INIT ( ipv4_miniroutes )
	List of IPv4 miniroutes.
static struct ip_statistics	ipv4_stats
	IPv4 statistics.
static struct profiler ipv4_tx_profiler	__profiler = { .name = "ipv4.tx" }
	Transmit profiler.
static struct fragment_reassembler	ipv4_reassembler
	IPv4 fragment reassembler.
struct net_protocol ipv4_protocol	__net_protocol
	IPv4 protocol.
struct tcpip_net_protocol ipv4_tcpip_protocol	__tcpip_net_protocol
	IPv4 TCPIP net protocol.
struct arp_net_protocol ipv4_arp_protocol	__arp_net_protocol
	IPv4 ARP protocol.
struct sockaddr_converter ipv4_sockaddr_converter	__sockaddr_converter
	IPv4 socket address converter.
struct settings_applicator ipv4_settings_applicator	__settings_applicator
	IPv4 settings applicator.

Detailed Description

IPv4 protocol.

Definition in file ipv4.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

__ip_statistics_family()

struct ip_statistics_family ipv4_stats_family __ip_statistics_family

(

IP_STATISTICS_IPV4

)

IPv4 statistics family.

References __ip_statistics_family, IP_STATISTICS_IPV4, and ipv4_stats.

ipv4_add_miniroute()

int ipv4_add_miniroute ( struct net_device * netdev, struct in_addr address, struct in_addr network, struct in_addr netmask, struct in_addr gateway )

static

Add IPv4 minirouting table entry.

Parameters

netdev	Network device
address	IPv4 address
network	Subnet address
netmask	Subnet mask
gateway	Gateway address (if any)

Return values

rc	Return status code

Definition at line 86 of file ipv4.c.

                                                         {
        struct ipv4_miniroute *miniroute;
        struct ipv4_miniroute *before;
        struct in_addr hostmask;
        struct in_addr broadcast;
 
        /* Calculate host mask */
        if ( gateway.s_addr || IN_IS_SMALL ( netmask.s_addr ) ) {
                hostmask.s_addr = INADDR_NONE;
        } else {
                hostmask.s_addr = ~netmask.s_addr;
        }
        broadcast.s_addr = ( network.s_addr | hostmask.s_addr );
 
        /* Print debugging information */
        DBGC ( netdev, "IPv4 add %s", inet_ntoa ( address ) );
        DBGC ( netdev, " for %s", inet_ntoa ( network ) );
        DBGC ( netdev, "/%s ", inet_ntoa ( netmask ) );
        DBGC ( netdev, "bc %s ", inet_ntoa ( broadcast ) );
        if ( gateway.s_addr )
                DBGC ( netdev, "gw %s ", inet_ntoa ( gateway ) );
        DBGC ( netdev, "via %s\n", netdev->name );
 
        /* Allocate and populate miniroute structure */
        miniroute = malloc ( sizeof ( *miniroute ) );
        if ( ! miniroute ) {
                DBGC ( netdev, "IPv4 could not add miniroute\n" );
                return -ENOMEM;
        }
 
        /* Record routing information */
        miniroute->netdev = netdev_get ( netdev );
        miniroute->address = address;
        miniroute->network = network;
        miniroute->netmask = netmask;
        miniroute->hostmask = hostmask;
        miniroute->gateway = gateway;
 
        /* Add to routing table ahead of any less specific routes */
        list_for_each_entry ( before, &ipv4_miniroutes, list ) {
                if ( netmask.s_addr & ~before->netmask.s_addr )
                        break;
        }
        list_add_tail ( &miniroute->list, &before->list );
 
        return 0;
}

References address, ipv4_miniroute::address, before, DBGC, ENOMEM, ipv4_miniroute::gateway, ipv4_miniroute::hostmask, IN_IS_SMALL, INADDR_NONE, inet_ntoa(), ipv4_miniroutes, ipv4_miniroute::list, list_add_tail, list_for_each_entry, malloc(), ipv4_miniroute::netdev, netdev, netdev_get(), ipv4_miniroute::netmask, ipv4_miniroute::network, and in_addr::s_addr.

Referenced by ipv4_add_miniroutes(), and ipv4_add_static().

ipv4_add_static()

int ipv4_add_static ( struct net_device * netdev, struct in_addr address, const void * routes, size_t len )

static

Add static route minirouting table entries.

Parameters

netdev	Network device
address	IPv4 address
routes	Static routes
len	Length of static routes

Return values

rc	Return status code

Definition at line 147 of file ipv4.c.

                                                              {
        const struct {
                struct in_addr address;
        } __attribute__ (( packed )) *encoded;
        struct in_addr netmask;
        struct in_addr network;
        struct in_addr gateway;
        unsigned int width;
        unsigned int masklen;
        size_t remaining;
        const void *data;
        int rc;
 
        /* Parse and add static routes */
        for ( data = routes, remaining = len ; remaining ; ) {
 
                /* Extract subnet mask width */
                width = *( ( uint8_t * ) data );
                data++;
                remaining--;
                masklen = ( ( width + 7 ) / 8 );
 
                /* Check remaining length */
                if ( ( masklen + sizeof ( gateway ) ) > remaining ) {
                        DBGC ( netdev, "IPv4 invalid static route:\n" );
                        DBGC_HDA ( netdev, 0, routes, len );
                        return -EINVAL;
                }
 
                /* Calculate subnet mask */
                if ( width ) {
                        netmask.s_addr = htonl ( -1UL << ( 32 - width ) );
                } else {
                        netmask.s_addr = 0;
                }
 
                /* Extract network address */
                encoded = data;
                network.s_addr = ( encoded->address.s_addr & netmask.s_addr );
                data += masklen;
                remaining -= masklen;
 
                /* Extract gateway address */
                encoded = data;
                gateway.s_addr = encoded->address.s_addr;
                data += sizeof ( gateway );
                remaining -= sizeof ( gateway );
 
                /* Add route */
                if ( ( rc = ipv4_add_miniroute ( netdev, address, network,
                                                 netmask, gateway ) ) != 0 )
                        return rc;
        }
 
        return 0;
}

References __attribute__, address, data, DBGC, DBGC_HDA, EINVAL, htonl, ipv4_add_miniroute(), len, netdev, rc, and in_addr::s_addr.

Referenced by ipv4_add_miniroutes().

ipv4_add_miniroutes()

int ipv4_add_miniroutes ( struct net_device * netdev, struct in_addr address )

static

Add IPv4 minirouting table entries.

Parameters

netdev	Network device
address	IPv4 address

Return values

rc	Return status code

Definition at line 212 of file ipv4.c.

                                                          {
        struct settings *settings = netdev_settings ( netdev );
        struct in_addr none = { 0 };
        struct in_addr netmask;
        struct in_addr gateway;
        struct in_addr network;
        void *routes;
        int len;
        int rc;
 
        /* Get subnet mask */
        fetch_ipv4_setting ( settings, &netmask_setting, &netmask );
 
        /* Calculate default netmask, if necessary */
        if ( ! netmask.s_addr ) {
                if ( IN_IS_CLASSA ( address.s_addr ) ) {
                        netmask.s_addr = INADDR_NET_CLASSA;
                } else if ( IN_IS_CLASSB ( address.s_addr ) ) {
                        netmask.s_addr = INADDR_NET_CLASSB;
                } else if ( IN_IS_CLASSC ( address.s_addr ) ) {
                        netmask.s_addr = INADDR_NET_CLASSC;
                }
        }
 
        /* Get default gateway, if present */
        fetch_ipv4_setting ( settings, &gateway_setting, &gateway );
 
        /* Get static routes, if present */
        len = fetch_raw_setting_copy ( settings, &static_route_setting,
                                       &routes );
 
        /* Add local address */
        network.s_addr = ( address.s_addr & netmask.s_addr );
        if ( ( rc = ipv4_add_miniroute ( netdev, address, network, netmask,
                                         none ) ) != 0 )
                goto done;
 
        /* Add static routes or default gateway, as applicable */
        if ( len >= 0 ) {
                if ( ( rc = ipv4_add_static ( netdev, address, routes,
                                              len ) ) != 0 )
                        goto done;
        } else if ( gateway.s_addr ) {
                if ( ( rc = ipv4_add_miniroute ( netdev, address, none, none,
                                                 gateway ) ) != 0 )
                        goto done;
        }
 
 done:
        free ( routes );
        return rc;
}

References address, done, fetch_ipv4_setting(), fetch_raw_setting_copy(), free, gateway_setting, IN_IS_CLASSA, IN_IS_CLASSB, IN_IS_CLASSC, INADDR_NET_CLASSA, INADDR_NET_CLASSB, INADDR_NET_CLASSC, ipv4_add_miniroute(), ipv4_add_static(), len, netdev, netdev_settings(), netmask_setting, none, rc, and in_addr::s_addr.

Referenced by ipv4_apply_routes().

ipv4_del_miniroute()

void ipv4_del_miniroute ( struct ipv4_miniroute * miniroute )

static

Delete IPv4 minirouting table entry.

Parameters

miniroute

Routing table entry

Definition at line 271 of file ipv4.c.

                                                                    {
        struct net_device *netdev = miniroute->netdev;
 
        DBGC ( netdev, "IPv4 del %s", inet_ntoa ( miniroute->address ) );
        DBGC ( netdev, " for %s", inet_ntoa ( miniroute->network ) );
        DBGC ( netdev, "/%s ", inet_ntoa ( miniroute->netmask ) );
        if ( miniroute->gateway.s_addr )
                DBGC ( netdev, "gw %s ", inet_ntoa ( miniroute->gateway ) );
        DBGC ( netdev, "via %s\n", miniroute->netdev->name );
 
        netdev_put ( miniroute->netdev );
        list_del ( &miniroute->list );
        free ( miniroute );
}

References ipv4_miniroute::address, DBGC, free, ipv4_miniroute::gateway, inet_ntoa(), ipv4_miniroute::list, list_del, net_device::name, ipv4_miniroute::netdev, netdev, netdev_put(), ipv4_miniroute::netmask, ipv4_miniroute::network, and in_addr::s_addr.

Referenced by ipv4_del_miniroutes().

ipv4_del_miniroutes()

void ipv4_del_miniroutes ( void )

static

Delete IPv4 minirouting table entries.

Definition at line 290 of file ipv4.c.

                                         {
        struct ipv4_miniroute *miniroute;
        struct ipv4_miniroute *tmp;
 
        /* Delete all existing routes */
        list_for_each_entry_safe ( miniroute, tmp, &ipv4_miniroutes, list )
                ipv4_del_miniroute ( miniroute );
}

References ipv4_del_miniroute(), ipv4_miniroutes, ipv4_miniroute::list, list_for_each_entry_safe, and tmp.

Referenced by ipv4_apply_routes().

ipv4_route()

struct ipv4_miniroute * ipv4_route	(	unsigned int	scope_id,
		struct in_addr *	dest )

Perform IPv4 routing.

Parameters

scope_id	Destination address scope ID
dest	Final destination address

Return values

dest	Next hop destination address
miniroute	Routing table entry to use, or NULL if no route

If the route requires use of a gateway, the next hop destination address will be overwritten with the gateway address.

Definition at line 310 of file ipv4.c.

                                                            {
        struct ipv4_miniroute *miniroute;
 
        /* Find first usable route in routing table */
        list_for_each_entry ( miniroute, &ipv4_miniroutes, list ) {
 
                /* Skip closed network devices */
                if ( ! netdev_is_open ( miniroute->netdev ) )
                        continue;
 
                if ( IN_IS_MULTICAST ( dest->s_addr ) ) {
 
                        /* If destination is non-global, and the scope
                         * ID matches this network device, then use
                         * the first matching route.
                         */
                        if ( miniroute->netdev->scope_id == scope_id )
                                return miniroute;
 
                } else {
 
                        /* If destination is global, then use the
                         * first matching route (via its gateway if
                         * specified).
                         */
                        if ( ( ( dest->s_addr ^ miniroute->network.s_addr )
                               & miniroute->netmask.s_addr ) == 0 ) {
                                if ( miniroute->gateway.s_addr )
                                        *dest = miniroute->gateway;
                                return miniroute;
                        }
                }
        }
 
        return NULL;
}

References dest, ipv4_miniroute::gateway, IN_IS_MULTICAST, ipv4_miniroutes, ipv4_miniroute::list, list_for_each_entry, ipv4_miniroute::netdev, netdev_is_open(), ipv4_miniroute::netmask, ipv4_miniroute::network, NULL, in_addr::s_addr, and net_device::scope_id.

Referenced by ipv4_netdev(), ipv4_route_okx(), and ipv4_tx().

ipv4_netdev()

struct net_device * ipv4_netdev ( struct sockaddr_tcpip * st_dest )

static

Determine transmitting network device.

Parameters

st_dest

Destination network-layer address

Return values

netdev

Transmitting network device, or NULL

Definition at line 354 of file ipv4.c.

                                                                          {
        struct sockaddr_in *sin_dest = ( ( struct sockaddr_in * ) st_dest );
        struct in_addr dest = sin_dest->sin_addr;
        struct ipv4_miniroute *miniroute;
 
        /* Find routing table entry */
        miniroute = ipv4_route ( sin_dest->sin_scope_id, &dest );
        if ( ! miniroute )
                return NULL;
 
        return miniroute->netdev;
}

References dest, ipv4_route(), ipv4_miniroute::netdev, NULL, sockaddr_in::sin_addr, and sockaddr_in::sin_scope_id.

ipv4_is_fragment()

int ipv4_is_fragment ( struct fragment * fragment, struct io_buffer * iobuf, size_t hdrlen __unused )

static

Check if IPv4 fragment matches fragment reassembly buffer.

Parameters

fragment	Fragment reassembly buffer
iobuf	I/O buffer
hdrlen	Length of non-fragmentable potion of I/O buffer

Return values

is_fragment

Fragment matches this reassembly buffer

Definition at line 375 of file ipv4.c.

                                                       {
        struct iphdr *frag_iphdr = fragment->iobuf->data;
        struct iphdr *iphdr = iobuf->data;
 
        return ( ( iphdr->src.s_addr == frag_iphdr->src.s_addr ) &&
                 ( iphdr->ident == frag_iphdr->ident ) );
}

References __unused, io_buffer::data, iphdr::ident, fragment::iobuf, in_addr::s_addr, and iphdr::src.

ipv4_fragment_offset()

size_t ipv4_fragment_offset ( struct io_buffer * iobuf, size_t hdrlen __unused )

static

Get IPv4 fragment offset.

Parameters

iobuf	I/O buffer
hdrlen	Length of non-fragmentable potion of I/O buffer

Return values

offset

Offset

Definition at line 392 of file ipv4.c.

                                                              {
        struct iphdr *iphdr = iobuf->data;
 
        return ( ( ntohs ( iphdr->frags ) & IP_MASK_OFFSET ) << 3 );
}

References __unused, io_buffer::data, iphdr::frags, IP_MASK_OFFSET, and ntohs.

ipv4_more_fragments()

int ipv4_more_fragments ( struct io_buffer * iobuf, size_t hdrlen __unused )

static

Check if more fragments exist.

Parameters

iobuf	I/O buffer
hdrlen	Length of non-fragmentable potion of I/O buffer

Return values

more_frags

More fragments exist

Definition at line 406 of file ipv4.c.

                                                          {
        struct iphdr *iphdr = iobuf->data;
 
        return ( iphdr->frags & htons ( IP_MASK_MOREFRAGS ) );
}

References __unused, io_buffer::data, iphdr::frags, htons, and IP_MASK_MOREFRAGS.

ipv4_pshdr_chksum()

uint16_t ipv4_pshdr_chksum ( struct io_buffer * iobuf, uint16_t csum )

static

Add IPv4 pseudo-header checksum to existing checksum.

Parameters

iobuf	I/O buffer
csum	Existing checksum

Return values

csum	Updated checksum

Definition at line 429 of file ipv4.c.

                                                                             {
        struct ipv4_pseudo_header pshdr;
        struct iphdr *iphdr = iobuf->data;
        size_t hdrlen = ( ( iphdr->verhdrlen & IP_MASK_HLEN ) * 4 );
 
        /* Build pseudo-header */
        pshdr.src = iphdr->src;
        pshdr.dest = iphdr->dest;
        pshdr.zero_padding = 0x00;
        pshdr.protocol = iphdr->protocol;
        pshdr.len = htons ( iob_len ( iobuf ) - hdrlen );
 
        /* Update the checksum value */
        return tcpip_continue_chksum ( csum, &pshdr, sizeof ( pshdr ) );
}

References io_buffer::data, iphdr::dest, ipv4_pseudo_header::dest, htons, iob_len(), IP_MASK_HLEN, ipv4_pseudo_header::len, iphdr::protocol, ipv4_pseudo_header::protocol, iphdr::src, ipv4_pseudo_header::src, tcpip_continue_chksum(), iphdr::verhdrlen, and ipv4_pseudo_header::zero_padding.

Referenced by ipv4_rx(), and ipv4_tx().

ipv4_tx()

int ipv4_tx ( struct io_buffer * iobuf, struct tcpip_protocol * tcpip_protocol, struct sockaddr_tcpip * st_src, struct sockaddr_tcpip * st_dest, struct net_device * netdev, uint16_t * trans_csum )

static

Transmit IP packet.

Parameters

iobuf	I/O buffer
tcpip	Transport-layer protocol
st_src	Source network-layer address
st_dest	Destination network-layer address
netdev	Network device to use if no route found, or NULL
trans_csum	Transport-layer checksum to complete, or NULL

Return values

rc

Status

This function expects a transport-layer segment and prepends the IP header

Definition at line 458 of file ipv4.c.

                                            {
        struct iphdr *iphdr = iob_push ( iobuf, sizeof ( *iphdr ) );
        struct sockaddr_in *sin_src = ( ( struct sockaddr_in * ) st_src );
        struct sockaddr_in *sin_dest = ( ( struct sockaddr_in * ) st_dest );
        struct ipv4_miniroute *miniroute;
        struct in_addr next_hop;
        struct in_addr hostmask = { .s_addr = INADDR_NONE };
        uint8_t ll_dest_buf[MAX_LL_ADDR_LEN];
        const void *ll_dest;
        int rc;
 
        /* Start profiling */
        profile_start ( &ipv4_tx_profiler );
 
        /* Update statistics */
        ipv4_stats.out_requests++;
 
        /* Fill up the IP header, except source address */
        memset ( iphdr, 0, sizeof ( *iphdr ) );
        iphdr->verhdrlen = ( IP_VER | ( sizeof ( *iphdr ) / 4 ) );
        iphdr->service = IP_TOS;
        iphdr->len = htons ( iob_len ( iobuf ) );   
        iphdr->ttl = IP_TTL;
        iphdr->protocol = tcpip_protocol->tcpip_proto;
        iphdr->dest = sin_dest->sin_addr;
 
        /* Use routing table to identify next hop and transmitting netdev */
        next_hop = iphdr->dest;
        if ( sin_src )
                iphdr->src = sin_src->sin_addr;
        if ( ( next_hop.s_addr != INADDR_BROADCAST ) &&
             ( ( miniroute = ipv4_route ( sin_dest->sin_scope_id,
                                          &next_hop ) ) != NULL ) ) {
                iphdr->src = miniroute->address;
                hostmask = miniroute->hostmask;
                netdev = miniroute->netdev;
        }
        if ( ! netdev ) {
                DBGC ( sin_dest->sin_addr, "IPv4 has no route to %s\n",
                       inet_ntoa ( iphdr->dest ) );
                ipv4_stats.out_no_routes++;
                rc = -ENETUNREACH;
                goto err;
        }
 
        /* (Ab)use the "ident" field to convey metadata about the
         * network device statistics into packet traces.  Useful for
         * extracting debug information from non-debug builds.
         */
        iphdr->ident = htons ( ( (++next_ident_high) << 8 ) |
                               ( ( netdev->rx_stats.bad & 0xf ) << 4 ) |
                               ( ( netdev->rx_stats.good & 0xf ) << 0 ) );
 
        /* Fix up checksums */
        if ( trans_csum ) {
                *trans_csum = ipv4_pshdr_chksum ( iobuf, *trans_csum );
                if ( ! *trans_csum )
                        *trans_csum = tcpip_protocol->zero_csum;
        }
        iphdr->chksum = tcpip_chksum ( iphdr, sizeof ( *iphdr ) );
 
        /* Print IP4 header for debugging */
        DBGC2 ( sin_dest->sin_addr, "IPv4 TX %s->", inet_ntoa ( iphdr->src ) );
        DBGC2 ( sin_dest->sin_addr, "%s len %d proto %d id %04x csum %04x\n",
                inet_ntoa ( iphdr->dest ), ntohs ( iphdr->len ),
                iphdr->protocol, ntohs ( iphdr->ident ),
                ntohs ( iphdr->chksum ) );
 
        /* Calculate link-layer destination address, if possible */
        if ( ( ( ~next_hop.s_addr ) & hostmask.s_addr ) == 0 ) {
                /* Broadcast address */
                ipv4_stats.out_bcast_pkts++;
                ll_dest = netdev->ll_broadcast;
        } else if ( IN_IS_MULTICAST ( next_hop.s_addr ) ) {
                /* Multicast address */
                ipv4_stats.out_mcast_pkts++;
                if ( ( rc = netdev->ll_protocol->mc_hash ( AF_INET, &next_hop,
                                                           ll_dest_buf ) ) !=0){
                        DBGC ( sin_dest->sin_addr, "IPv4 could not hash "
                               "multicast %s: %s\n",
                               inet_ntoa ( next_hop ), strerror ( rc ) );
                        goto err;
                }
                ll_dest = ll_dest_buf;
        } else {
                /* Unicast address */
                ll_dest = NULL;
        }
 
        /* Update statistics */
        ipv4_stats.out_transmits++;
        ipv4_stats.out_octets += iob_len ( iobuf );
 
        /* Hand off to link layer (via ARP if applicable) */
        if ( ll_dest ) {
                if ( ( rc = net_tx ( iobuf, netdev, &ipv4_protocol, ll_dest,
                                     netdev->ll_addr ) ) != 0 ) {
                        DBGC ( sin_dest->sin_addr, "IPv4 could not transmit "
                               "packet via %s: %s\n",
                               netdev->name, strerror ( rc ) );
                        return rc;
                }
        } else {
                if ( ( rc = arp_tx ( iobuf, netdev, &ipv4_protocol, &next_hop,
                                     &iphdr->src ) ) != 0 ) {
                        DBGC ( sin_dest->sin_addr, "IPv4 could not transmit "
                               "packet via %s: %s\n",
                               netdev->name, strerror ( rc ) );
                        return rc;
                }
        }
 
        profile_stop ( &ipv4_tx_profiler );
        return 0;
 
 err:
        free_iob ( iobuf );
        return rc;
}

References ipv4_miniroute::address, AF_INET, arp_tx(), iphdr::chksum, DBGC, DBGC2, iphdr::dest, ENETUNREACH, free_iob(), ipv4_miniroute::hostmask, htons, iphdr::ident, IN_IS_MULTICAST, INADDR_BROADCAST, INADDR_NONE, inet_ntoa(), iob_len(), iob_push, IP_TOS, IP_TTL, IP_VER, ipv4_pshdr_chksum(), ipv4_route(), ipv4_stats, iphdr::len, MAX_LL_ADDR_LEN, memset(), net_tx(), ipv4_miniroute::netdev, netdev, next_ident_high, ntohs, NULL, profile_start(), profile_stop(), iphdr::protocol, rc, in_addr::s_addr, iphdr::service, sockaddr_in::sin_addr, sockaddr_in::sin_scope_id, iphdr::src, strerror(), tcpip_chksum(), tcpip_protocol::tcpip_proto, iphdr::ttl, iphdr::verhdrlen, and tcpip_protocol::zero_csum.

ipv4_has_any_addr()

int ipv4_has_any_addr

(

struct net_device *

netdev

)

Check if network device has any IPv4 address.

Parameters

netdev

Network device

Return values

has_any_addr

Network device has any IPv4 address

Definition at line 589 of file ipv4.c.

                                                    {
        struct ipv4_miniroute *miniroute;
 
        list_for_each_entry ( miniroute, &ipv4_miniroutes, list ) {
                if ( miniroute->netdev == netdev )
                        return 1;
        }
        return 0;
}

References ipv4_miniroutes, ipv4_miniroute::list, list_for_each_entry, ipv4_miniroute::netdev, and netdev.

Referenced by dhcp_create_packet(), and ipv4_rx().

ipv4_has_addr()

int ipv4_has_addr ( struct net_device * netdev, struct in_addr addr )

static

Check if network device has a specific IPv4 address.

Parameters

netdev	Network device
addr	IPv4 address

Return values

has_addr

Network device has this IPv4 address

Definition at line 606 of file ipv4.c.

                                                                            {
        struct ipv4_miniroute *miniroute;
 
        list_for_each_entry ( miniroute, &ipv4_miniroutes, list ) {
                if ( ( miniroute->netdev == netdev ) &&
                     ( miniroute->address.s_addr == addr.s_addr ) ) {
                        /* Found matching address */
                        return 1;
                }
        }
        return 0;
}

References addr, ipv4_miniroute::address, ipv4_miniroutes, ipv4_miniroute::list, list_for_each_entry, ipv4_miniroute::netdev, netdev, and in_addr::s_addr.

Referenced by ipv4_arp_check(), ipv4_gratuitous_arp(), and ipv4_rx().

ipv4_rx()

int ipv4_rx ( struct io_buffer * iobuf, struct net_device * netdev, const void *ll_dest __unused, const void *ll_source __unused, unsigned int flags )

static

Process incoming packets.

Parameters

iobuf	I/O buffer
netdev	Network device
ll_dest	Link-layer destination address
ll_source	Link-layer destination source
flags	Packet flags

Return values

rc	Return status code

This function expects an IP4 network datagram. It processes the headers and sends it to the transport layer.

Definition at line 632 of file ipv4.c.

                                          {
        struct iphdr *iphdr = iobuf->data;
        size_t hdrlen;
        size_t len;
        union {
                struct sockaddr_in sin;
                struct sockaddr_tcpip st;
        } src, dest;
        uint16_t csum;
        uint16_t pshdr_csum;
        int rc;
 
        /* Start profiling */
        profile_start ( &ipv4_rx_profiler );
 
        /* Update statistics */
        ipv4_stats.in_receives++;
        ipv4_stats.in_octets += iob_len ( iobuf );
        if ( flags & LL_BROADCAST ) {
                ipv4_stats.in_bcast_pkts++;
        } else if ( flags & LL_MULTICAST ) {
                ipv4_stats.in_mcast_pkts++;
        }
 
        /* Sanity check the IPv4 header */
        if ( iob_len ( iobuf ) < sizeof ( *iphdr ) ) {
                DBGC ( iphdr->src, "IPv4 packet too short at %zd bytes (min "
                       "%zd bytes)\n", iob_len ( iobuf ), sizeof ( *iphdr ) );
                goto err_header;
        }
        if ( ( iphdr->verhdrlen & IP_MASK_VER ) != IP_VER ) {
                DBGC ( iphdr->src, "IPv4 version %#02x not supported\n",
                       iphdr->verhdrlen );
                goto err_header;
        }
        hdrlen = ( ( iphdr->verhdrlen & IP_MASK_HLEN ) * 4 );
        if ( hdrlen < sizeof ( *iphdr ) ) {
                DBGC ( iphdr->src, "IPv4 header too short at %zd bytes (min "
                       "%zd bytes)\n", hdrlen, sizeof ( *iphdr ) );
                goto err_header;
        }
        if ( hdrlen > iob_len ( iobuf ) ) {
                DBGC ( iphdr->src, "IPv4 header too long at %zd bytes "
                       "(packet is %zd bytes)\n", hdrlen, iob_len ( iobuf ) );
                goto err_header;
        }
        if ( ( csum = tcpip_chksum ( iphdr, hdrlen ) ) != 0 ) {
                DBGC ( iphdr->src, "IPv4 checksum incorrect (is %04x "
                       "including checksum field, should be 0000)\n", csum );
                goto err_header;
        }
        len = ntohs ( iphdr->len );
        if ( len < hdrlen ) {
                DBGC ( iphdr->src, "IPv4 length too short at %zd bytes "
                       "(header is %zd bytes)\n", len, hdrlen );
                goto err_header;
        }
        if ( len > iob_len ( iobuf ) ) {
                DBGC ( iphdr->src, "IPv4 length too long at %zd bytes "
                       "(packet is %zd bytes)\n", len, iob_len ( iobuf ) );
                ipv4_stats.in_truncated_pkts++;
                goto err_other;
        }
 
        /* Truncate packet to correct length */
        iob_unput ( iobuf, ( iob_len ( iobuf ) - len ) );
 
        /* Print IPv4 header for debugging */
        DBGC2 ( iphdr->src, "IPv4 RX %s<-", inet_ntoa ( iphdr->dest ) );
        DBGC2 ( iphdr->src, "%s len %d proto %d id %04x csum %04x\n",
                inet_ntoa ( iphdr->src ), ntohs ( iphdr->len ), iphdr->protocol,
                ntohs ( iphdr->ident ), ntohs ( iphdr->chksum ) );
 
        /* Discard unicast packets not destined for us */
        if ( ( ! ( flags & LL_MULTICAST ) ) &&
             ( iphdr->dest.s_addr != INADDR_BROADCAST ) &&
             ipv4_has_any_addr ( netdev ) &&
             ( ! ipv4_has_addr ( netdev, iphdr->dest ) ) ) {
                DBGC ( iphdr->src, "IPv4 discarding non-local unicast packet "
                       "for %s\n", inet_ntoa ( iphdr->dest ) );
                ipv4_stats.in_addr_errors++;
                goto err_other;
        }
 
        /* Perform fragment reassembly if applicable */
        if ( iphdr->frags & htons ( IP_MASK_OFFSET | IP_MASK_MOREFRAGS ) ) {
                /* Pass the fragment to fragment_reassemble() which returns
                 * either a fully reassembled I/O buffer or NULL.
                 */
                iobuf = fragment_reassemble ( &ipv4_reassembler, iobuf,
                                              &hdrlen );
                if ( ! iobuf )
                        return 0;
                iphdr = iobuf->data;
        }
 
        /* Construct socket addresses, calculate pseudo-header
         * checksum, and hand off to transport layer
         */
        memset ( &src, 0, sizeof ( src ) );
        src.sin.sin_family = AF_INET;
        src.sin.sin_addr = iphdr->src;
        memset ( &dest, 0, sizeof ( dest ) );
        dest.sin.sin_family = AF_INET;
        dest.sin.sin_addr = iphdr->dest;
        pshdr_csum = ipv4_pshdr_chksum ( iobuf, TCPIP_EMPTY_CSUM );
        iob_pull ( iobuf, hdrlen );
        if ( ( rc = tcpip_rx ( iobuf, netdev, iphdr->protocol, &src.st,
                               &dest.st, pshdr_csum, &ipv4_stats ) ) != 0 ) {
                DBGC ( src.sin.sin_addr, "IPv4 received packet rejected by "
                       "stack: %s\n", strerror ( rc ) );
                return rc;
        }
 
        profile_stop ( &ipv4_rx_profiler );
        return 0;
 
 err_header:
        ipv4_stats.in_hdr_errors++;
 err_other:
        free_iob ( iobuf );
        return -EINVAL;
}

References __unused, AF_INET, iphdr::chksum, io_buffer::data, DBGC, DBGC2, dest, iphdr::dest, EINVAL, flags, fragment_reassemble(), iphdr::frags, free_iob(), htons, iphdr::ident, INADDR_BROADCAST, inet_ntoa(), iob_len(), iob_pull, iob_unput, IP_MASK_HLEN, IP_MASK_MOREFRAGS, IP_MASK_OFFSET, IP_MASK_VER, IP_VER, ipv4_has_addr(), ipv4_has_any_addr(), ipv4_pshdr_chksum(), ipv4_reassembler, ipv4_stats, iphdr::len, len, LL_BROADCAST, LL_MULTICAST, memset(), netdev, ntohs, profile_start(), profile_stop(), iphdr::protocol, rc, in_addr::s_addr, sin, iphdr::src, src, st, strerror(), tcpip_chksum(), TCPIP_EMPTY_CSUM, tcpip_rx(), and iphdr::verhdrlen.

ipv4_arp_check()

int ipv4_arp_check ( struct net_device * netdev, const void * net_addr )

static

Check existence of IPv4 address for ARP.

Parameters

netdev	Network device
net_addr	Network-layer address

Return values

rc	Return status code

Definition at line 767 of file ipv4.c.

                                                                              {
        const struct in_addr *address = net_addr;
 
        if ( ipv4_has_addr ( netdev, *address ) )
                return 0;
 
        return -ENOENT;
}

References address, ENOENT, ipv4_has_addr(), and netdev.

inet_aton()

int inet_aton	(	const char *	string,
		struct in_addr *	in )

Parse IPv4 address.

Parameters

string

IPv4 address string

Return values

in	IPv4 address to fill in
ok	IPv4 address is valid

Note that this function returns nonzero iff the address is valid, to match the standard BSD API function of the same name. Unlike most other iPXE functions, a zero therefore indicates failure.

Definition at line 787 of file ipv4.c.

                                                         {
        const char *separator = "...";
        uint8_t *byte = ( ( uint8_t * ) in );
        char *endp;
        unsigned long value;
 
        while ( 1 ) {
                value = strtoul ( string, &endp, 0 );
                if ( string == endp )
                        return 0;
                if ( value > 0xff )
                        return 0;
                *(byte++) = value;
                if ( *endp != *separator )
                        return 0;
                if ( ! *(separator++) )
                        return 1;
                string = ( endp + 1 );
        }
}

References in, strtoul(), and value.

Referenced by inet_aton_fail_okx(), inet_aton_okx(), ipv4_route_okx(), ipv4_sock_aton(), parse_ipv4_setting(), and tftp_process_multicast().

inet_ntoa()

char * inet_ntoa

(

struct in_addr

in

)

Convert IPv4 address to dotted-quad notation.

Parameters

in	IPv4 address

Return values

string

IPv4 address in dotted-quad notation

Definition at line 814 of file ipv4.c.

                                       {
        static char buf[16]; /* "xxx.xxx.xxx.xxx" */
        uint8_t *bytes = ( uint8_t * ) ∈
        
        sprintf ( buf, "%d.%d.%d.%d", bytes[0], bytes[1], bytes[2], bytes[3] );
        return buf;
}

References bytes, in, and sprintf.

Referenced by dhcp_deliver(), dhcp_discovery_rx(), dhcp_proxy_rx(), dhcp_proxy_tx(), dhcp_pxebs_accept(), dhcp_pxebs_rx(), dhcp_pxebs_tx(), dhcp_request_rx(), dhcp_request_tx(), efi_snp_mcast_ip_to_mac(), fetch_next_server_and_filename(), format_ipv4_setting(), gve_describe(), ibft_ipaddr(), inet_aton_okx(), inet_ntoa_okx(), ipoib_transmit(), ipv4_add_miniroute(), ipv4_del_miniroute(), ipv4_gratuitous_arp(), ipv4_ntoa(), ipv4_route_okx(), ipv4_rx(), ipv4_sock_ntoa(), ipv4_tx(), pxenv_udp_open(), pxenv_udp_read(), pxenv_udp_write(), pxenv_undi_get_mcast_address(), route_ipv4_print(), start_pxebs(), tftp_apply_settings(), and tftp_process_multicast().

ipv4_ntoa()

const char * ipv4_ntoa ( const void * net_addr )

static

Transcribe IPv4 address.

Parameters

net_addr

IPv4 address

Return values

string

IPv4 address in dotted-quad notation

Definition at line 829 of file ipv4.c.

                                                       {
        return inet_ntoa ( * ( ( struct in_addr * ) net_addr ) );
}

References inet_ntoa().

ipv4_sock_ntoa()

const char * ipv4_sock_ntoa ( struct sockaddr * sa )

static

Transcribe IPv4 socket address.

Parameters

sa	Socket address

Return values

string

Socket address in standard notation

Definition at line 839 of file ipv4.c.

                                                           {
        struct sockaddr_in *sin = ( ( struct sockaddr_in * ) sa );
 
        return inet_ntoa ( sin->sin_addr );
}

References inet_ntoa(), sa, and sin.

ipv4_sock_aton()

int ipv4_sock_aton ( const char * string, struct sockaddr * sa )

static

Parse IPv4 socket address.

Parameters

string	Socket address string
sa	Socket address to fill in

Return values

rc	Return status code

Definition at line 852 of file ipv4.c.

                                                                      {
        struct sockaddr_in *sin = ( ( struct sockaddr_in * ) sa );
        struct in_addr in;
 
        if ( inet_aton ( string, &in ) ) {
                sin->sin_addr = in;
                return 0;
        }
        return -EINVAL;
}

References EINVAL, in, inet_aton(), sa, and sin.

parse_ipv4_setting()

int parse_ipv4_setting	(	const struct setting_type *type	__unused,
		const char *	value,
		void *	buf,
		size_t	len )

Parse IPv4 address setting value.

Parameters

type	Setting type
value	Formatted setting value
buf	Buffer to contain raw value
len	Length of buffer

Return values

len	Length of raw value, or negative error

Definition at line 911 of file ipv4.c.

                                                                    {
        struct in_addr ipv4;
 
        /* Parse IPv4 address */
        if ( inet_aton ( value, &ipv4 ) == 0 )
                return -EINVAL;
 
        /* Copy to buffer */
        if ( len > sizeof ( ipv4 ) )
                len = sizeof ( ipv4 );
        memcpy ( buf, &ipv4, len );
 
        return ( sizeof ( ipv4 ) );
}

References __unused, EINVAL, inet_aton(), len, memcpy(), type, and value.

format_ipv4_setting()

int format_ipv4_setting	(	const struct setting_type *type	__unused,
		const void *	raw,
		size_t	raw_len,
		char *	buf,
		size_t	len )

Format IPv4 address setting value.

Parameters

type	Setting type
raw	Raw setting value
raw_len	Length of raw setting value
buf	Buffer to contain formatted value
len	Length of buffer

Return values

len	Length of formatted value, or negative error

Definition at line 937 of file ipv4.c.

                                       {
        const struct in_addr *ipv4 = raw;
 
        if ( raw_len < sizeof ( *ipv4 ) )
                return -EINVAL;
        return snprintf ( buf, len, "%s", inet_ntoa ( *ipv4 ) );
}

References __unused, EINVAL, inet_ntoa(), len, raw, raw_len, snprintf(), and type.

__setting() [1/4]

const struct setting ip_setting __setting	(	SETTING_IP4	,
		ip	)

IPv4 address setting.

References __setting, DHCP_EB_YIADDR, ip, ip_setting, and SETTING_IP4.

__setting() [2/4]

const struct setting netmask_setting __setting	(	SETTING_IP4	,
		netmask	)

IPv4 subnet mask setting.

References __setting, DHCP_SUBNET_MASK, netmask_setting, and SETTING_IP4.

__setting() [3/4]

const struct setting gateway_setting __setting	(	SETTING_IP4	,
		gateway	)

Default gateway setting.

References __setting, DHCP_ROUTERS, gateway_setting, and SETTING_IP4.

__setting() [4/4]

const struct setting static_route_setting __setting	(	SETTING_IP4	,
		static_routes	)

Classless static routes setting.

References __setting, DHCP_STATIC_ROUTES, and SETTING_IP4.

ipv4_gratuitous_arp()

int ipv4_gratuitous_arp ( struct net_device * netdev, struct in_addr address )

static

Send gratuitous ARP, if applicable.

Parameters

netdev	Network device
address	IPv4 address

Return values

rc	Return status code

Definition at line 987 of file ipv4.c.

                                                          {
        int rc;
 
        /* Do nothing if network device already has this IPv4 address */
        if ( ipv4_has_addr ( netdev, address ) )
                return 0;
 
        /* Transmit gratuitous ARP */
        DBGC ( netdev, "IPv4 sending gratuitous ARP for %s via %s\n",
               inet_ntoa ( address ), netdev->name );
        if ( ( rc = arp_tx_request ( netdev, &ipv4_protocol, &address,
                                     &address ) ) != 0 ) {
                DBGC ( netdev, "IPv4 could not transmit gratuitous ARP: %s\n",
                       strerror ( rc ) );
                /* Treat failures as non-fatal */
        }
 
        return 0;
}

References address, arp_tx_request(), DBGC, inet_ntoa(), ipv4_has_addr(), netdev, rc, and strerror().

Referenced by ipv4_apply_routes().

ipv4_settings()

int ipv4_settings ( int(* apply )(struct net_device *netdev, struct in_addr address) )

static

Process IPv4 network device settings.

Parameters

apply

Application method

Return values

rc	Return status code

Definition at line 1014 of file ipv4.c.

                                                                        {
        struct net_device *netdev;
        struct settings *settings;
        struct in_addr address;
        int rc;
 
        /* Process settings for each network device */
        for_each_netdev ( netdev ) {
 
                /* Get network device settings */
                settings = netdev_settings ( netdev );
 
                /* Get IPv4 address */
                fetch_ipv4_setting ( settings, &ip_setting, &address );
                if ( ! address.s_addr )
                        continue;
 
                /* Apply settings */
                if ( ( rc = apply ( netdev, address ) ) != 0 )
                        return rc;
        }
 
        return 0;
}

References address, fetch_ipv4_setting(), for_each_netdev, ip_setting, netdev, netdev_settings(), and rc.

Referenced by ipv4_apply_routes().

ipv4_apply_routes()

int ipv4_apply_routes ( void )

static

Create IPv4 routing table based on configured settings.

Return values

rc	Return status code

Definition at line 1045 of file ipv4.c.

                                      {
        int rc;
 
        /* Send gratuitous ARPs for any new IPv4 addresses */
        ipv4_settings ( ipv4_gratuitous_arp );
 
        /* Delete all existing routes */
        ipv4_del_miniroutes();
 
        /* Create routes for each configured network device */
        if ( ( rc = ipv4_settings ( ipv4_add_miniroutes ) ) != 0 )
                return rc;
 
        return 0;
}

References ipv4_add_miniroutes(), ipv4_del_miniroutes(), ipv4_gratuitous_arp(), ipv4_settings(), and rc.

REQUIRING_SYMBOL()

REQUIRING_SYMBOL

(

ipv4_protocol

)

REQUIRE_OBJECT()

REQUIRE_OBJECT

(

icmpv4

)

Variable Documentation

next_ident_high

uint8_t next_ident_high = 0

static

Definition at line 55 of file ipv4.c.

Referenced by ipv4_tx().

ipv4_miniroutes

struct list_head ipv4_miniroutes = LIST_HEAD_INIT ( ipv4_miniroutes )

List of IPv4 miniroutes.

Definition at line 58 of file ipv4.c.

Referenced by ipv4_add_miniroute(), ipv4_del_miniroutes(), ipv4_has_addr(), ipv4_has_any_addr(), ipv4_route(), and route_ipv4_print().

ipv4_stats

struct ip_statistics ipv4_stats

static

IPv4 statistics.

Definition at line 61 of file ipv4.c.

Referenced by __ip_statistics_family(), ipv4_rx(), and ipv4_tx().

__profiler

struct profiler ipv4_rx_profiler __profiler = { .name = "ipv4.tx" }

static

Transmit profiler.

Receive profiler.

Definition at line 71 of file ipv4.c.

{ .name = "ipv4.tx" };

ipv4_reassembler

struct fragment_reassembler ipv4_reassembler

static

Initial value:

= {
        .list = LIST_HEAD_INIT ( ipv4_reassembler.list ),
        .is_fragment = ipv4_is_fragment,
        .fragment_offset = ipv4_fragment_offset,
        .more_fragments = ipv4_more_fragments,
        .stats = &ipv4_stats,
}

IPv4 fragment reassembler.

Definition at line 414 of file ipv4.c.

                                                      {
        .list = LIST_HEAD_INIT ( ipv4_reassembler.list ),
        .is_fragment = ipv4_is_fragment,
        .fragment_offset = ipv4_fragment_offset,
        .more_fragments = ipv4_more_fragments,
        .stats = &ipv4_stats,
};

Referenced by ipv4_rx().

__net_protocol

struct net_protocol ipv4_protocol __net_protocol

Initial value:

= {
        .name = "IP",
        .net_proto = htons ( ETH_P_IP ),
        .net_addr_len = sizeof ( struct in_addr ),
        .rx = ipv4_rx,
        .ntoa = ipv4_ntoa,
}

IPv4 protocol.

AoE protocol.

Definition at line 864 of file ipv4.c.

                                                   {
        .name = "IP",
        .net_proto = htons ( ETH_P_IP ),
        .net_addr_len = sizeof ( struct in_addr ),
        .rx = ipv4_rx,
        .ntoa = ipv4_ntoa,
};

__tcpip_net_protocol

struct tcpip_net_protocol ipv4_tcpip_protocol __tcpip_net_protocol

Initial value:

= {
        .name = "IPv4",
        .sa_family = AF_INET,
        .header_len = sizeof ( struct iphdr ),
        .net_protocol = &ipv4_protocol,
        .tx = ipv4_tx,
        .netdev = ipv4_netdev,
}

IPv4 TCPIP net protocol.

Definition at line 873 of file ipv4.c.

                                                                     {
        .name = "IPv4",
        .sa_family = AF_INET,
        .header_len = sizeof ( struct iphdr ),
        .net_protocol = &ipv4_protocol,
        .tx = ipv4_tx,
        .netdev = ipv4_netdev,
};

__arp_net_protocol

struct arp_net_protocol ipv4_arp_protocol __arp_net_protocol

Initial value:

= {
        .net_protocol = &ipv4_protocol,
        .check = ipv4_arp_check,
}

IPv4 ARP protocol.

Definition at line 883 of file ipv4.c.

                                                               {
        .net_protocol = &ipv4_protocol,
        .check = ipv4_arp_check,
};

__sockaddr_converter

struct sockaddr_converter ipv4_sockaddr_converter __sockaddr_converter

Initial value:

= {
        .family = AF_INET,
        .ntoa = ipv4_sock_ntoa,
        .aton = ipv4_sock_aton,
}

IPv4 socket address converter.

Definition at line 889 of file ipv4.c.

                                                                         {
        .family = AF_INET,
        .ntoa = ipv4_sock_ntoa,
        .aton = ipv4_sock_aton,
};

__settings_applicator

struct settings_applicator ipv4_settings_applicator __settings_applicator

Initial value:

= {
        .apply = ipv4_apply_routes,
}

IPv4 settings applicator.

Definition at line 1062 of file ipv4.c.

                                                                            {
        .apply = ipv4_apply_routes,
};