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 <gpxe/list.h>
#include <gpxe/in.h>
#include <gpxe/arp.h>
#include <gpxe/if_ether.h>
#include <gpxe/iobuf.h>
#include <gpxe/netdevice.h>
#include <gpxe/ip.h>
#include <gpxe/tcpip.h>
#include <gpxe/dhcp.h>
#include <gpxe/settings.h>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER)
static	LIST_HEAD (frag_buffers)
	List of fragment reassembly buffers.
static struct ipv4_miniroute *__malloc	add_ipv4_miniroute (struct net_device *netdev, struct in_addr address, struct in_addr netmask, struct in_addr gateway)
	Add IPv4 minirouting table entry.
static void	del_ipv4_miniroute (struct ipv4_miniroute *miniroute)
	Delete IPv4 minirouting table entry.
static struct ipv4_miniroute *	ipv4_route (struct in_addr *dest)
	Perform IPv4 routing.
static void	ipv4_frag_expired (struct retry_timer *timer __unused, int over)
	Fragment reassembly counter timeout.
static void	free_fragbuf (struct frag_buffer *fragbuf)
	Free fragment buffer.
static struct io_buffer *	ipv4_reassemble (struct io_buffer *iobuf)
	Fragment reassembler.
static uint16_t	ipv4_pshdr_chksum (struct io_buffer *iobuf, uint16_t csum)
	Add IPv4 pseudo-header checksum to existing checksum.
static int	ipv4_ll_addr (struct in_addr dest, struct in_addr src, struct net_device *netdev, uint8_t *ll_dest)
	Determine link-layer address.
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.
static int	ipv4_rx (struct io_buffer *iobuf, struct net_device *netdev __unused, const void *ll_source __unused)
	Process incoming packets.
static int	ipv4_arp_check (struct net_device *netdev, const void *net_addr)
	Check existence of IPv4 address for ARP.
char *	inet_ntoa (struct in_addr in)
	Convert IPv4 address to dotted-quad notation.
static const char *	ipv4_ntoa (const void *net_addr)
	Transcribe IP address.
static int	ipv4_create_routes (void)
	Create IPv4 routing table based on configured settings.
	REQUIRE_OBJECT (icmp)
Variables
static uint16_t	next_ident = 0
struct net_protocol	ipv4_protocol
struct list_head	ipv4_miniroutes = LIST_HEAD_INIT ( ipv4_miniroutes )
	List of IPv4 miniroutes.
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 setting ip_setting	__setting
	IPv4 address setting.
struct settings_applicator ipv4_settings_applicator	__settings_applicator
	IPv4 settings applicator.

---

Detailed Description

IPv4 protocol.

Definition in file ipv4.c.

---

Function Documentation

FILE_LICENCE

(

GPL2_OR_LATER

)

static LIST_HEAD

(

frag_buffers

)

[static]

List of fragment reassembly buffers.

static struct ipv4_miniroute* __malloc add_ipv4_miniroute	(	struct net_device *	netdev,
		struct in_addr	address,
		struct in_addr	netmask,
		struct in_addr	gateway
	)			[static, read]

Add IPv4 minirouting table entry.

Parameters:

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

Return values:

miniroute

Routing table entry, or NULL

Definition at line 47 of file ipv4.c.

References ipv4_miniroute::address, DBG, ipv4_miniroute::gateway, inet_ntoa(), ipv4_miniroute::list, list_add, list_add_tail, malloc(), net_device::name, ipv4_miniroute::netdev, netdev_get(), ipv4_miniroute::netmask, NULL, and in_addr::s_addr.

Referenced by ipv4_create_routes().

                                                                      {
        struct ipv4_miniroute *miniroute;

        DBG ( "IPv4 add %s", inet_ntoa ( address ) );
        DBG ( "/%s ", inet_ntoa ( netmask ) );
        if ( gateway.s_addr )
                DBG ( "gw %s ", inet_ntoa ( gateway ) );
        DBG ( "via %s\n", netdev->name );

        /* Allocate and populate miniroute structure */
        miniroute = malloc ( sizeof ( *miniroute ) );
        if ( ! miniroute ) {
                DBG ( "IPv4 could not add miniroute\n" );
                return NULL;
        }

        /* Record routing information */
        miniroute->netdev = netdev_get ( netdev );
        miniroute->address = address;
        miniroute->netmask = netmask;
        miniroute->gateway = gateway;
                
        /* Add to end of list if we have a gateway, otherwise
         * to start of list.
         */
        if ( gateway.s_addr ) {
                list_add_tail ( &miniroute->list, &ipv4_miniroutes );
        } else {
                list_add ( &miniroute->list, &ipv4_miniroutes );
        }

        return miniroute;
}

static void del_ipv4_miniroute

(

struct ipv4_miniroute *

miniroute

)

[static]

Delete IPv4 minirouting table entry.

Parameters:

miniroute

Routing table entry

Definition at line 87 of file ipv4.c.

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

Referenced by ipv4_create_routes().

                                                                    {

        DBG ( "IPv4 del %s", inet_ntoa ( miniroute->address ) );
        DBG ( "/%s ", inet_ntoa ( miniroute->netmask ) );
        if ( miniroute->gateway.s_addr )
                DBG ( "gw %s ", inet_ntoa ( miniroute->gateway ) );
        DBG ( "via %s\n", miniroute->netdev->name );

        netdev_put ( miniroute->netdev );
        list_del ( &miniroute->list );
        free ( miniroute );
}

static struct ipv4_miniroute* ipv4_route

(

struct in_addr *

dest

)

[static, read]

Perform IPv4 routing.

Parameters:

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 110 of file ipv4.c.

References ipv4_miniroute::address, ipv4_miniroute::gateway, INADDR_BROADCAST, ipv4_miniroute::list, list_for_each_entry, ipv4_miniroute::netdev, netdev_is_open(), ipv4_miniroute::netmask, NULL, and in_addr::s_addr.

Referenced by ipv4_tx().

                                                                   {
        struct ipv4_miniroute *miniroute;
        int local;
        int has_gw;

        /* Never attempt to route the broadcast address */
        if ( dest->s_addr == INADDR_BROADCAST )
                return NULL;

        /* Find first usable route in routing table */
        list_for_each_entry ( miniroute, &ipv4_miniroutes, list ) {
                if ( ! netdev_is_open ( miniroute->netdev ) )
                        continue;
                local = ( ( ( dest->s_addr ^ miniroute->address.s_addr )
                            & miniroute->netmask.s_addr ) == 0 );
                has_gw = ( miniroute->gateway.s_addr );
                if ( local || has_gw ) {
                        if ( ! local )
                                *dest = miniroute->gateway;
                        return miniroute;
                }
        }

        return NULL;
}

static void ipv4_frag_expired	(	struct retry_timer *timer	__unused,
		int	over
	)			[static]

Fragment reassembly counter timeout.

Parameters:

	timer	Retry timer
	over	If asserted, the timer is greater than MAX_TIMEOUT

Definition at line 142 of file ipv4.c.

References DBG.

Referenced by ipv4_reassemble().

                                           {
        if ( over ) {
                DBG ( "Fragment reassembly timeout" );
                /* Free the fragment buffer */
        }
}

static void free_fragbuf

(

struct frag_buffer *

fragbuf

)

[static]

Free fragment buffer.

Parameters:

fragbug

Fragment buffer

Definition at line 155 of file ipv4.c.

References free().

Referenced by ipv4_reassemble().

                                                         {
        free ( fragbuf );
}

static struct io_buffer* ipv4_reassemble

(

struct io_buffer *

iobuf

)

[static, read]

Fragment reassembler.

Parameters:

iobuf

I/O buffer, fragment of the datagram

Return values:

frag_iob

Reassembled packet, or NULL

Check if the fragment belongs to any fragment series

Check if the packet is the expected fragment

The offset of the new packet must be equal to the length of the data accumulated so far (the length of the reassembled I/O buffer

Append the contents of the fragment to the reassembled I/O buffer

Check if the fragment series is over

Check if the fragment is the first in the fragment series

Create a new fragment buffer

Definition at line 165 of file ipv4.c.

References alloc_iob(), io_buffer::data, retry_timer::expired, frag_buffer::frag_iob, frag_buffer::frag_timer, iphdr::frags, free_fragbuf(), free_iob(), iphdr::ident, frag_buffer::ident, iob_len(), iob_pull, iob_put, IP_FRAG_IOB_SIZE, IP_FRAG_TIMEOUT, IP_MASK_MOREFRAGS, IP_MASK_OFFSET, ipv4_frag_expired(), frag_buffer::list, list_add, list_for_each_entry, malloc(), memcpy, NULL, in_addr::s_addr, iphdr::src, frag_buffer::src, start_timer(), and retry_timer::timeout.

Referenced by ipv4_rx().

                                                                       {
        struct iphdr *iphdr = iobuf->data;
        struct frag_buffer *fragbuf;
        
        /**
         * Check if the fragment belongs to any fragment series
         */
        list_for_each_entry ( fragbuf, &frag_buffers, list ) {
                if ( fragbuf->ident == iphdr->ident &&
                     fragbuf->src.s_addr == iphdr->src.s_addr ) {
                        /**
                         * Check if the packet is the expected fragment
                         * 
                         * The offset of the new packet must be equal to the
                         * length of the data accumulated so far (the length of
                         * the reassembled I/O buffer
                         */
                        if ( iob_len ( fragbuf->frag_iob ) == 
                              ( iphdr->frags & IP_MASK_OFFSET ) ) {
                                /**
                                 * Append the contents of the fragment to the
                                 * reassembled I/O buffer
                                 */
                                iob_pull ( iobuf, sizeof ( *iphdr ) );
                                memcpy ( iob_put ( fragbuf->frag_iob,
                                                        iob_len ( iobuf ) ),
                                         iobuf->data, iob_len ( iobuf ) );
                                free_iob ( iobuf );

                                /** Check if the fragment series is over */
                                if ( ! ( iphdr->frags & IP_MASK_MOREFRAGS ) ) {
                                        iobuf = fragbuf->frag_iob;
                                        free_fragbuf ( fragbuf );
                                        return iobuf;
                                }

                        } else {
                                /* Discard the fragment series */
                                free_fragbuf ( fragbuf );
                                free_iob ( iobuf );
                        }
                        return NULL;
                }
        }
        
        /** Check if the fragment is the first in the fragment series */
        if ( iphdr->frags & IP_MASK_MOREFRAGS &&
                        ( ( iphdr->frags & IP_MASK_OFFSET ) == 0 ) ) {
        
                /** Create a new fragment buffer */
                fragbuf = ( struct frag_buffer* ) malloc ( sizeof( *fragbuf ) );
                fragbuf->ident = iphdr->ident;
                fragbuf->src = iphdr->src;

                /* Set up the reassembly I/O buffer */
                fragbuf->frag_iob = alloc_iob ( IP_FRAG_IOB_SIZE );
                iob_pull ( iobuf, sizeof ( *iphdr ) );
                memcpy ( iob_put ( fragbuf->frag_iob, iob_len ( iobuf ) ),
                         iobuf->data, iob_len ( iobuf ) );
                free_iob ( iobuf );

                /* Set the reassembly timer */
                fragbuf->frag_timer.timeout = IP_FRAG_TIMEOUT;
                fragbuf->frag_timer.expired = ipv4_frag_expired;
                start_timer ( &fragbuf->frag_timer );

                /* Add the fragment buffer to the list of fragment buffers */
                list_add ( &fragbuf->list, &frag_buffers );
        }
        
        return NULL;
}

static 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 245 of file ipv4.c.

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().

                                                                             {
        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 ) );
}

static int ipv4_ll_addr	(	struct in_addr	dest,
		struct in_addr	src,
		struct net_device *	netdev,
		uint8_t *	ll_dest
	)			[static]

Determine link-layer address.

Parameters:

	dest	IPv4 destination address
	src	IPv4 source address
	netdev	Network device
	ll_dest	Link-layer destination address buffer

Return values:

rc

Return status code

Definition at line 270 of file ipv4.c.

References AF_INET, arp_resolve(), IN_MULTICAST, INADDR_BROADCAST, ipv4_protocol, ll_protocol::ll_addr_len, net_device::ll_broadcast, net_device::ll_protocol, ll_protocol::mc_hash, memcpy, ntohl, and in_addr::s_addr.

Referenced by ipv4_tx().

                                                                        {
        struct ll_protocol *ll_protocol = netdev->ll_protocol;

        if ( dest.s_addr == INADDR_BROADCAST ) {
                /* Broadcast address */
                memcpy ( ll_dest, netdev->ll_broadcast,
                         ll_protocol->ll_addr_len );
                return 0;
        } else if ( IN_MULTICAST ( ntohl ( dest.s_addr ) ) ) {
                return ll_protocol->mc_hash ( AF_INET, &dest, ll_dest );
        } else {
                /* Unicast address: resolve via ARP */
                return arp_resolve ( netdev, &ipv4_protocol, &dest,
                                     &src, ll_dest );
        }
}

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
	)			[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 301 of file ipv4.c.

References ipv4_miniroute::address, iphdr::chksum, DBG, iphdr::dest, ENETUNREACH, free_iob(), htons, iphdr::ident, IN_MULTICAST, INADDR_BROADCAST, inet_ntoa(), iob_len(), iob_push, IP_TOS, IP_TTL, IP_VER, ipv4_ll_addr(), ipv4_protocol, ipv4_pshdr_chksum(), ipv4_route(), iphdr::len, MAX_LL_ADDR_LEN, memset(), net_device::name, net_tx(), ipv4_miniroute::netdev, next_ident, ntohl, ntohs, NULL, iphdr::protocol, in_addr::s_addr, iphdr::service, sockaddr_in::sin_addr, iphdr::src, strerror(), tcpip_chksum(), tcpip_protocol::tcpip_proto, iphdr::ttl, and iphdr::verhdrlen.

                                            {
        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;
        uint8_t ll_dest[MAX_LL_ADDR_LEN];
        int rc;

        /* 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->ident = htons ( ++next_ident );
        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 ) &&
             ( ! IN_MULTICAST ( ntohl ( next_hop.s_addr ) ) ) &&
             ( ( miniroute = ipv4_route ( &next_hop ) ) != NULL ) ) {
                iphdr->src = miniroute->address;
                netdev = miniroute->netdev;
        }
        if ( ! netdev ) {
                DBG ( "IPv4 has no route to %s\n", inet_ntoa ( iphdr->dest ) );
                rc = -ENETUNREACH;
                goto err;
        }

        /* Determine link-layer destination address */
        if ( ( rc = ipv4_ll_addr ( next_hop, iphdr->src, netdev,
                                   ll_dest ) ) != 0 ) {
                DBG ( "IPv4 has no link-layer address for %s: %s\n",
                      inet_ntoa ( next_hop ), strerror ( rc ) );
                goto err;
        }

        /* Fix up checksums */
        if ( trans_csum )
                *trans_csum = ipv4_pshdr_chksum ( iobuf, *trans_csum );
        iphdr->chksum = tcpip_chksum ( iphdr, sizeof ( *iphdr ) );

        /* Print IP4 header for debugging */
        DBG ( "IPv4 TX %s->", inet_ntoa ( iphdr->src ) );
        DBG ( "%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 ) );

        /* Hand off to link layer */
        if ( ( rc = net_tx ( iobuf, netdev, &ipv4_protocol, ll_dest ) ) != 0 ) {
                DBG ( "IPv4 could not transmit packet via %s: %s\n",
                      netdev->name, strerror ( rc ) );
                return rc;
        }

        return 0;

 err:
        free_iob ( iobuf );
        return rc;
}

static int ipv4_rx	(	struct io_buffer *	iobuf,
		struct net_device *netdev	__unused,
		const void *ll_source	__unused
	)			[static]

Process incoming packets.

Parameters:

	iobuf	I/O buffer
	netdev	Network device
	ll_source	Link-layer destination source

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

Definition at line 384 of file ipv4.c.

References AF_INET, iphdr::chksum, io_buffer::data, DBG, iphdr::dest, dest, EINVAL, iphdr::frags, free_iob(), htons, iphdr::ident, inet_ntoa(), iob_len(), iob_pull, iob_unput, IP_MASK_HLEN, IP_MASK_MOREFRAGS, IP_MASK_OFFSET, IP_MASK_VER, IP_VER, ipv4_pshdr_chksum(), ipv4_reassemble(), iphdr::len, memset(), ntohs, iphdr::protocol, iphdr::src, src, strerror(), tcpip_chksum(), TCPIP_EMPTY_CSUM, tcpip_rx(), and iphdr::verhdrlen.

                                                      {
        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;

        /* Sanity check the IPv4 header */
        if ( iob_len ( iobuf ) < sizeof ( *iphdr ) ) {
                DBG ( "IPv4 packet too short at %zd bytes (min %zd bytes)\n",
                      iob_len ( iobuf ), sizeof ( *iphdr ) );
                goto err;
        }
        if ( ( iphdr->verhdrlen & IP_MASK_VER ) != IP_VER ) {
                DBG ( "IPv4 version %#02x not supported\n", iphdr->verhdrlen );
                goto err;
        }
        hdrlen = ( ( iphdr->verhdrlen & IP_MASK_HLEN ) * 4 );
        if ( hdrlen < sizeof ( *iphdr ) ) {
                DBG ( "IPv4 header too short at %zd bytes (min %zd bytes)\n",
                      hdrlen, sizeof ( *iphdr ) );
                goto err;
        }
        if ( hdrlen > iob_len ( iobuf ) ) {
                DBG ( "IPv4 header too long at %zd bytes "
                      "(packet is %zd bytes)\n", hdrlen, iob_len ( iobuf ) );
                goto err;
        }
        if ( ( csum = tcpip_chksum ( iphdr, hdrlen ) ) != 0 ) {
                DBG ( "IPv4 checksum incorrect (is %04x including checksum "
                      "field, should be 0000)\n", csum );
                goto err;
        }
        len = ntohs ( iphdr->len );
        if ( len < hdrlen ) {
                DBG ( "IPv4 length too short at %zd bytes "
                      "(header is %zd bytes)\n", len, hdrlen );
                goto err;
        }
        if ( len > iob_len ( iobuf ) ) {
                DBG ( "IPv4 length too long at %zd bytes "
                      "(packet is %zd bytes)\n", len, iob_len ( iobuf ) );
                goto err;
        }

        /* Print IPv4 header for debugging */
        DBG ( "IPv4 RX %s<-", inet_ntoa ( iphdr->dest ) );
        DBG ( "%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 ) );

        /* Truncate packet to correct length, calculate pseudo-header
         * checksum and then strip off the IPv4 header.
         */
        iob_unput ( iobuf, ( iob_len ( iobuf ) - len ) );
        pshdr_csum = ipv4_pshdr_chksum ( iobuf, TCPIP_EMPTY_CSUM );
        iob_pull ( iobuf, hdrlen );

        /* Fragment reassembly */
        if ( ( iphdr->frags & htons ( IP_MASK_MOREFRAGS ) ) || 
             ( ( iphdr->frags & htons ( IP_MASK_OFFSET ) ) != 0 ) ) {
                /* Pass the fragment to ipv4_reassemble() which either
                 * returns a fully reassembled I/O buffer or NULL.
                 */
                iobuf = ipv4_reassemble ( iobuf );
                if ( ! iobuf )
                        return 0;
        }

        /* Construct socket addresses 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;
        if ( ( rc = tcpip_rx ( iobuf, iphdr->protocol, &src.st,
                               &dest.st, pshdr_csum ) ) != 0 ) {
                DBG ( "IPv4 received packet rejected by stack: %s\n",
                      strerror ( rc ) );
                return rc;
        }

        return 0;

 err:
        free_iob ( iobuf );
        return -EINVAL;
}

static 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 487 of file ipv4.c.

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

                                                                              {
        const struct in_addr *address = net_addr;
        struct ipv4_miniroute *miniroute;

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

char* inet_ntoa

(

struct in_addr

in

)

Convert IPv4 address to dotted-quad notation.

Parameters:

in

IP address

Return values:

string

IP address in dotted-quad notation

Definition at line 507 of file ipv4.c.

References sprintf.

Referenced by add_ipv4_miniroute(), apply_dns_settings(), boot_next_server_and_filename(), del_ipv4_miniroute(), dhcp_deliver_iob(), dhcp_proxy_rx(), dhcp_proxy_tx(), dhcp_pxebs_accept(), dhcp_pxebs_rx(), dhcp_pxebs_tx(), dhcp_request_rx(), dhcp_request_tx(), dhcp_rx_offer(), dns_xfer_deliver_raw(), efi_snp_mcast_ip_to_mac(), fetchf_ipv4(), ibft_ipaddr(), ipv4_ntoa(), ipv4_rx(), ipv4_tx(), pxe_tftp_open(), pxenv_udp_open(), pxenv_udp_read(), pxenv_udp_write(), pxenv_undi_get_mcast_address(), route(), start_pxebs(), tftp_apply_settings(), and tftp_process_multicast().

                                       {
        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;
}

static const char* ipv4_ntoa

(

const void *

net_addr

)

[static]

Transcribe IP address.

Parameters:

net_addr

IP address

Return values:

string

IP address in dotted-quad notation

Definition at line 522 of file ipv4.c.

References inet_ntoa().

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

static int ipv4_create_routes

(

void

)

[static]

Create IPv4 routing table based on configured settings.

Return values:

rc

Return status code

Definition at line 584 of file ipv4.c.

References add_ipv4_miniroute(), del_ipv4_miniroute(), ENOMEM, fetch_ipv4_setting(), for_each_netdev, htonl, IN_CLASSA, IN_CLASSA_NET, IN_CLASSB, IN_CLASSB_NET, IN_CLASSC, IN_CLASSC_NET, list_for_each_entry_safe, netdev, netdev_settings(), ntohl, and in_addr::s_addr.

                                       {
        struct ipv4_miniroute *miniroute;
        struct ipv4_miniroute *tmp;
        struct net_device *netdev;
        struct settings *settings;
        struct in_addr address = { 0 };
        struct in_addr netmask = { 0 };
        struct in_addr gateway = { 0 };

        /* Delete all existing routes */
        list_for_each_entry_safe ( miniroute, tmp, &ipv4_miniroutes, list )
                del_ipv4_miniroute ( miniroute );

        /* Create a route for each configured network device */
        for_each_netdev ( netdev ) {
                settings = netdev_settings ( netdev );
                /* Get IPv4 address */
                address.s_addr = 0;
                fetch_ipv4_setting ( settings, &ip_setting, &address );
                if ( ! address.s_addr )
                        continue;
                /* Get subnet mask */
                fetch_ipv4_setting ( settings, &netmask_setting, &netmask );
                /* Calculate default netmask, if necessary */
                if ( ! netmask.s_addr ) {
                        if ( IN_CLASSA ( ntohl ( address.s_addr ) ) ) {
                                netmask.s_addr = htonl ( IN_CLASSA_NET );
                        } else if ( IN_CLASSB ( ntohl ( address.s_addr ) ) ) {
                                netmask.s_addr = htonl ( IN_CLASSB_NET );
                        } else if ( IN_CLASSC ( ntohl ( address.s_addr ) ) ) {
                                netmask.s_addr = htonl ( IN_CLASSC_NET );
                        }
                }
                /* Get default gateway, if present */
                fetch_ipv4_setting ( settings, &gateway_setting, &gateway );
                /* Configure route */
                miniroute = add_ipv4_miniroute ( netdev, address,
                                                 netmask, gateway );
                if ( ! miniroute )
                        return -ENOMEM;
        }

        return 0;
}

REQUIRE_OBJECT

(

icmp

)

---

Variable Documentation

uint16_t next_ident = 0 [static]

Definition at line 27 of file ipv4.c.

Referenced by ipv4_tx().

struct net_protocol ipv4_protocol

Definition at line 29 of file ipv4.c.

Referenced by ipv4_ll_addr(), ipv4_tx(), pxenv_undi_isr(), and pxenv_undi_transmit().

struct list_head ipv4_miniroutes = LIST_HEAD_INIT ( ipv4_miniroutes )

List of IPv4 miniroutes.

Definition at line 32 of file ipv4.c.

Referenced by route().

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 527 of file ipv4.c.

struct tcpip_net_protocol ipv4_tcpip_protocol __tcpip_net_protocol

Initial value:

 {
        .name = "IPv4",
        .sa_family = AF_INET,
        .tx = ipv4_tx,
}

IPv4 TCPIP net protocol.

Definition at line 536 of file ipv4.c.

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 543 of file ipv4.c.

struct settings_applicator ipv4_settings_applicator __settings_applicator

Initial value:

 {
        .apply = ipv4_create_routes,
}

IPv4 settings applicator.

Definition at line 630 of file ipv4.c.