Cached DHCP packet. More...

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ipxe/dhcppkt.h>
#include <ipxe/init.h>
#include <ipxe/netdevice.h>
#include <ipxe/vlan.h>
#include <ipxe/uaccess.h>
#include <ipxe/uri.h>
#include <ipxe/cachedhcp.h>

Data Structures
struct	cached_dhcp_packet
	A cached DHCP packet. More...

Macros
#define	CACHEDHCP_RETAIN 0x0001
	Cached DHCP packet should be retained.
#define	CACHEDHCP_USED 0x0002
	Cached DHCP packet has been used.
#define	colour &cached_dhcpack
	Colour for debug messages.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static void	cachedhcp_free (struct cached_dhcp_packet *cache)
	Free cached DHCP packet.
static int	cachedhcp_apply (struct cached_dhcp_packet cache, struct net_device netdev)
	Apply cached DHCP packet settings.
static struct uri *	cachedhcp_uri (struct cached_dhcp_packet *cache)
	Get URI from cached DHCP packet.
int	cachedhcp_record (struct cached_dhcp_packet cache, unsigned int vlan, const void data, size_t max_len)
	Record cached DHCP packet.
static void	cachedhcp_startup_early (void)
	Cached DHCP packet early startup function.
static void	cachedhcp_startup_late (void)
	Cache DHCP packet late startup function.
static void	cachedhcp_shutdown (int booting __unused)
	Cached DHCP packet shutdown function.
struct startup_fn cachedhcp_early_fn	__startup_fn (STARTUP_EARLY)
	Cached DHCP packet early startup function.
struct startup_fn cachedhcp_late_fn	__startup_fn (STARTUP_LATE)
	Cached DHCP packet late startup function.
static int	cachedhcp_probe (struct net_device netdev, void priv __unused)
	Apply cached DHCPACK to network device, if applicable.
void	cachedhcp_recycle (struct net_device *netdev)
	Recycle cached DHCPACK.

Variables
struct cached_dhcp_packet	cached_dhcpack
	Cached DHCPACK.
struct cached_dhcp_packet	cached_proxydhcp
	Cached ProxyDHCPOFFER.
struct cached_dhcp_packet	cached_pxebs
	Cached PXEBSACK.
static struct cached_dhcp_packet *	cached_packets []
	List of cached DHCP packets.
struct net_driver cachedhcp_driver	__net_driver
	Cached DHCP packet network device driver.

Detailed Description

Cached DHCP packet.

Definition in file cachedhcp.c.

Macro Definition Documentation

◆ CACHEDHCP_RETAIN

#define CACHEDHCP_RETAIN 0x0001

Cached DHCP packet should be retained.

Definition at line 58 of file cachedhcp.c.

Referenced by cachedhcp_apply(), and cachedhcp_startup_late().

◆ CACHEDHCP_USED

#define CACHEDHCP_USED 0x0002

Cached DHCP packet has been used.

Definition at line 61 of file cachedhcp.c.

Referenced by cachedhcp_apply(), cachedhcp_recycle(), and cachedhcp_startup_late().

◆ colour

#define colour &cached_dhcpack

Colour for debug messages.

Definition at line 87 of file cachedhcp.c.

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )

◆ FILE_SECBOOT()

FILE_SECBOOT ( PERMITTED )

◆ cachedhcp_free()

void cachedhcp_free ( struct cached_dhcp_packet * cache )

static

Free cached DHCP packet.

Parameters

cache Cached DHCP packet

Definition at line 94 of file cachedhcp.c.

                                                                {
 
        dhcppkt_put ( cache->dhcppkt );
        cache->dhcppkt = NULL;
}

References cached_dhcp_packet::dhcppkt, dhcppkt_put(), and NULL.

Referenced by cachedhcp_apply(), cachedhcp_record(), cachedhcp_shutdown(), cachedhcp_startup_early(), and cachedhcp_startup_late().

◆ cachedhcp_apply()

int cachedhcp_apply	(	struct cached_dhcp_packet *	cache,
		struct net_device *	netdev )

static

Apply cached DHCP packet settings.

Parameters

cache	Cached DHCP packet
netdev	Network device, or NULL

Return values

rc	Return status code

Definition at line 107 of file cachedhcp.c.

                                                         {
        struct settings *settings = NULL;
        struct ll_protocol *ll_protocol;
        const uint8_t *chaddr;
        uint8_t *hw_addr;
        uint8_t *ll_addr;
        size_t ll_addr_len;
        int rc;
 
        /* Do nothing if cache is empty or already in use */
        if ( ( ! cache->dhcppkt ) || ( cache->flags & CACHEDHCP_USED ) )
                return 0;
        chaddr = cache->dhcppkt->dhcphdr->chaddr;
 
        /* Handle association with network device, if specified */
        if ( netdev ) {
                hw_addr = netdev->hw_addr;
                ll_addr = netdev->ll_addr;
                ll_protocol = netdev->ll_protocol;
                ll_addr_len = ll_protocol->ll_addr_len;
 
                /* If cached packet's MAC address matches the network
                 * device's permanent MAC address, then assume that
                 * the permanent MAC address ought to be the network
                 * device's current link-layer address.
                 *
                 * This situation can arise when the PXE ROM does not
                 * understand the system-specific mechanism for
                 * overriding the MAC address, and so uses the
                 * permanent MAC address instead.  We choose to match
                 * this behaviour in order to minimise surprise.
                 */
                if ( memcmp ( hw_addr, chaddr, ll_addr_len ) == 0 ) {
                        if ( memcmp ( hw_addr, ll_addr, ll_addr_len ) != 0 ) {
                                DBGC ( colour, "CACHEDHCP %s resetting %s MAC "
                                       "%s ", cache->name, netdev->name,
                                       ll_protocol->ntoa ( ll_addr ) );
                                DBGC ( colour, "-> %s\n",
                                       ll_protocol->ntoa ( hw_addr ) );
                        }
                        memcpy ( ll_addr, hw_addr, ll_addr_len );
                }
 
                /* Do nothing unless cached packet's MAC address
                 * matches this network device.
                 */
                if ( memcmp ( ll_addr, chaddr, ll_addr_len ) != 0 ) {
                        DBGC ( colour, "CACHEDHCP %s %s does not match %s\n",
                               cache->name, ll_protocol->ntoa ( chaddr ),
                               netdev->name );
                        return 0;
                }
 
                /* Do nothing unless cached packet's VLAN tag matches
                 * this network device.
                 */
                if ( vlan_tag ( netdev ) != cache->vlan ) {
                        DBGC ( colour, "CACHEDHCP %s VLAN %d does not match "
                               "%s\n", cache->name, cache->vlan,
                               netdev->name );
                        return 0;
                }
 
                /* Use network device's settings block */
                settings = netdev_settings ( netdev );
                DBGC ( colour, "CACHEDHCP %s is for %s\n",
                       cache->name, netdev->name );
 
                /* Mark network device to be opened automatically */
                netdev->state |= NETDEV_AUTO_OPEN;
        }
 
        /* Register settings */
        if ( ( rc = register_settings ( &cache->dhcppkt->settings, settings,
                                        cache->name ) ) != 0 ) {
                DBGC ( colour, "CACHEDHCP %s could not register settings: %s\n",
                       cache->name, strerror ( rc ) );
                return rc;
        }
 
        /* Mark as used */
        cache->flags |= CACHEDHCP_USED;
 
        /* Free cached DHCP packet, if applicable */
        if ( ! ( cache->flags & CACHEDHCP_RETAIN ) )
                cachedhcp_free ( cache );
 
        return 0;
}

References cachedhcp_free(), CACHEDHCP_RETAIN, CACHEDHCP_USED, dhcphdr::chaddr, colour, DBGC, dhcp_packet::dhcphdr, cached_dhcp_packet::dhcppkt, cached_dhcp_packet::flags, ll_protocol::ll_addr_len, memcmp(), memcpy(), cached_dhcp_packet::name, netdev, NETDEV_AUTO_OPEN, netdev_settings(), ll_protocol::ntoa, NULL, rc, register_settings(), dhcp_packet::settings, strerror(), cached_dhcp_packet::vlan, and vlan_tag().

Referenced by cachedhcp_probe(), and cachedhcp_startup_early().

◆ cachedhcp_uri()

struct uri * cachedhcp_uri ( struct cached_dhcp_packet * cache )

static

Get URI from cached DHCP packet.

Parameters

cache Cached DHCP packet

Return values

uri	URI, or NULL if not defined

Definition at line 204 of file cachedhcp.c.

                                                                       {
        struct dhcp_packet *dhcppkt = cache->dhcppkt;
        struct settings *settings = &dhcppkt->settings;
        struct uri *uri = NULL;
        union {
                struct sockaddr sa;
                struct sockaddr_in sin;
        } next_server;
        char *filename;
 
        /* Fetch next-server address */
        memset ( &next_server, 0, sizeof ( next_server ) );
        next_server.sin.sin_family = AF_INET;
        fetch_ipv4_setting ( settings, &next_server_setting,
                             &next_server.sin.sin_addr );
        if ( next_server.sin.sin_addr.s_addr ) {
                DBGC ( colour, "CACHEDHCP %s has next-server %s\n",
                       cache->name, inet_ntoa ( next_server.sin.sin_addr ) );
        }
 
        /* Fetch filename */
        fetch_string_setting_copy ( settings, &filename_setting, &filename );
        if ( ! filename )
                goto err_filename;
        DBGC ( colour, "CACHEDHCP %s has filename %s\n",
               cache->name, filename );
 
        /* Construct URI */
        uri = pxe_uri ( &next_server.sa, filename );
        if ( ! uri )
                goto err_uri;
 
 err_uri:
        free ( filename );
 err_filename:
        return uri;
}

References AF_INET, colour, DBGC, cached_dhcp_packet::dhcppkt, fetch_ipv4_setting(), fetch_string_setting_copy(), free, inet_ntoa(), memset(), cached_dhcp_packet::name, NULL, pxe_uri(), sa, dhcp_packet::settings, and sin.

Referenced by cachedhcp_record().

◆ cachedhcp_record()

int cachedhcp_record	(	struct cached_dhcp_packet *	cache,
		unsigned int	vlan,
		const void *	data,
		size_t	max_len )

Record cached DHCP packet.

Parameters

cache	Cached DHCP packet
vlan	VLAN tag, if any
data	DHCPACK packet buffer
max_len	Maximum possible length

Return values

rc	Return status code

Definition at line 251 of file cachedhcp.c.

                                                          {
        struct dhcp_packet *dhcppkt;
        struct dhcp_packet *tmp;
        struct dhcphdr *dhcphdr;
        struct uri *uri;
        unsigned int i;
        size_t len;
 
        /* Free any existing cached packet */
        cachedhcp_free ( cache );
 
        /* Allocate and populate DHCP packet */
        dhcppkt = zalloc ( sizeof ( *dhcppkt ) + max_len );
        if ( ! dhcppkt ) {
                DBGC ( colour, "CACHEDHCP %s could not allocate copy\n",
                       cache->name );
                return -ENOMEM;
        }
        dhcphdr = ( ( ( void * ) dhcppkt ) + sizeof ( *dhcppkt ) );
        memcpy ( dhcphdr, data, max_len );
        dhcppkt_init ( dhcppkt, dhcphdr, max_len );
 
        /* Shrink packet to required length.  If reallocation fails,
         * just continue to use the original packet and waste the
         * unused space.
         */
        len = dhcppkt_len ( dhcppkt );
        assert ( len <= max_len );
        tmp = realloc ( dhcppkt, ( sizeof ( *dhcppkt ) + len ) );
        if ( tmp )
                dhcppkt = tmp;
 
        /* Reinitialise packet at new address */
        dhcphdr = ( ( ( void * ) dhcppkt ) + sizeof ( *dhcppkt ) );
        dhcppkt_init ( dhcppkt, dhcphdr, len );
 
        /* Discard duplicate packets, since some PXE stacks (including
         * iPXE itself) will report the DHCPACK packet as the PXEBSACK
         * if no separate PXEBSACK exists.
         */
        for ( i = 0 ; i < ( sizeof ( cached_packets ) /
                            sizeof ( cached_packets[0] ) ) ; i++ ) {
                tmp = cached_packets[i]->dhcppkt;
                if ( tmp && ( dhcppkt_len ( tmp ) == len ) &&
                     ( memcmp ( tmp->dhcphdr, dhcppkt->dhcphdr, len ) == 0 ) ) {
                        DBGC ( colour, "CACHEDHCP %s duplicates %s\n",
                               cache->name, cached_packets[i]->name );
                        dhcppkt_put ( dhcppkt );
                        return -EEXIST;
                }
        }
 
        /* Store as cached packet */
        DBGC ( colour, "CACHEDHCP %s at %#08lx+%#zx/%#zx\n", cache->name,
               virt_to_phys ( data ), len, max_len );
        cache->dhcppkt = dhcppkt;
        cache->vlan = vlan;
 
        /* Set current working URI, if defined in this packet */
        uri = cachedhcp_uri ( cache );
        if ( uri )
                churi ( uri );
        uri_put ( uri );
 
        return 0;
}

References assert, cached_packets, cachedhcp_free(), cachedhcp_uri(), churi(), colour, data, DBGC, dhcp_packet::dhcphdr, cached_dhcp_packet::dhcppkt, dhcppkt_init(), dhcppkt_len(), dhcppkt_put(), EEXIST, ENOMEM, len, memcmp(), memcpy(), cached_dhcp_packet::name, realloc(), tmp, uri_put(), cached_dhcp_packet::vlan, and zalloc().

Referenced by cachedhcp_init(), and efi_cachedhcp_record().

◆ cachedhcp_startup_early()

void cachedhcp_startup_early ( void )

static

Cached DHCP packet early startup function.

Definition at line 323 of file cachedhcp.c.

                                             {
 
        /* Apply cached ProxyDHCPOFFER, if any */
        cachedhcp_apply ( &cached_proxydhcp, NULL );
        cachedhcp_free ( &cached_proxydhcp );
 
        /* Apply cached PXEBSACK, if any */
        cachedhcp_apply ( &cached_pxebs, NULL );
        cachedhcp_free ( &cached_pxebs );
}

References cached_proxydhcp, cached_pxebs, cachedhcp_apply(), cachedhcp_free(), and NULL.

Referenced by __startup_fn().

◆ cachedhcp_startup_late()

void cachedhcp_startup_late ( void )

static

Cache DHCP packet late startup function.

Definition at line 338 of file cachedhcp.c.

                                            {
 
        /* Clear retention flag */
        cached_dhcpack.flags &= ~CACHEDHCP_RETAIN;
 
        /* Free cached DHCPACK, if used by a network device */
        if ( cached_dhcpack.flags & CACHEDHCP_USED )
                cachedhcp_free ( &cached_dhcpack );
 
        /* Report unclaimed DHCPACK, if any.  Do not free yet, since
         * it may still be claimed by a dynamically created device
         * such as a VLAN device.
         */
        if ( cached_dhcpack.dhcppkt ) {
                DBGC ( colour, "CACHEDHCP %s unclaimed\n",
                       cached_dhcpack.name );
        }
}

References cached_dhcpack, cachedhcp_free(), CACHEDHCP_RETAIN, CACHEDHCP_USED, colour, and DBGC.

Referenced by __startup_fn().

◆ cachedhcp_shutdown()

void cachedhcp_shutdown ( int booting __unused )

static

Cached DHCP packet shutdown function.

Parameters

booting System is shutting down for OS boot

Definition at line 362 of file cachedhcp.c.

                                                        {
 
        /* Free cached DHCPACK, if any */
        if ( cached_dhcpack.dhcppkt ) {
                DBGC ( colour, "CACHEDHCP %s never claimed\n",
                       cached_dhcpack.name );
        }
        cachedhcp_free ( &cached_dhcpack );
}

References __unused, cached_dhcpack, cachedhcp_free(), colour, and DBGC.

Referenced by __startup_fn().

◆ __startup_fn() [1/2]

struct startup_fn cachedhcp_early_fn __startup_fn ( STARTUP_EARLY )

Cached DHCP packet early startup function.

References __startup_fn, cachedhcp_startup_early(), and STARTUP_EARLY.

◆ __startup_fn() [2/2]

struct startup_fn cachedhcp_late_fn __startup_fn ( STARTUP_LATE )

Cached DHCP packet late startup function.

References __startup_fn, cachedhcp_shutdown(), cachedhcp_startup_late(), and STARTUP_LATE.

◆ cachedhcp_probe()

int cachedhcp_probe	(	struct net_device *	netdev,
		void *priv	__unused )

static

Apply cached DHCPACK to network device, if applicable.

Parameters

netdev	Network device
priv	Private data

Return values

rc	Return status code

Definition at line 392 of file cachedhcp.c.

                                                                              {
 
        /* Apply cached DHCPACK to network device, if applicable */
        return cachedhcp_apply ( &cached_dhcpack, netdev );
}

References __unused, cached_dhcpack, cachedhcp_apply(), netdev, and priv.

◆ cachedhcp_recycle()

void cachedhcp_recycle ( struct net_device * netdev )

Recycle cached DHCPACK.

Parameters

netdev	Network device
priv	Private data

Definition at line 410 of file cachedhcp.c.

                                                     {
        struct cached_dhcp_packet *cache = &cached_dhcpack;
        struct settings *settings;
 
        /* Return DHCPACK to cache, if applicable */
        settings = find_child_settings ( netdev_settings ( netdev ),
                                         cache->name );
        if ( cache->dhcppkt && ( settings == &cache->dhcppkt->settings ) ) {
                DBGC ( colour, "CACHEDHCP %s recycled from %s\n",
                       cache->name, netdev->name );
                assert ( cache->flags & CACHEDHCP_USED );
                unregister_settings ( settings );
                cache->flags &= ~CACHEDHCP_USED;
        }
}

References assert, cached_dhcpack, CACHEDHCP_USED, colour, DBGC, cached_dhcp_packet::dhcppkt, find_child_settings(), cached_dhcp_packet::flags, cached_dhcp_packet::name, netdev, netdev_settings(), dhcp_packet::settings, and unregister_settings().

Referenced by mnptemp_destroy().

Variable Documentation

◆ cached_dhcpack

struct cached_dhcp_packet cached_dhcpack

Initial value:

= {
        .name = DHCP_SETTINGS_NAME,
        .flags = CACHEDHCP_RETAIN,
}

Cached DHCPACK.

Definition at line 64 of file cachedhcp.c.

                                           {
        .name = DHCP_SETTINGS_NAME,
        .flags = CACHEDHCP_RETAIN,
};

Referenced by cachedhcp_init(), cachedhcp_probe(), cachedhcp_recycle(), cachedhcp_shutdown(), cachedhcp_startup_late(), efi_cachedhcp_record(), and FILE_SECBOOT().

◆ cached_proxydhcp

struct cached_dhcp_packet cached_proxydhcp

Initial value:

= {
        .name = PROXYDHCP_SETTINGS_NAME,
}

Cached ProxyDHCPOFFER.

Definition at line 70 of file cachedhcp.c.

                                             {
        .name = PROXYDHCP_SETTINGS_NAME,
};

Referenced by cachedhcp_startup_early(), efi_cachedhcp_record(), and FILE_SECBOOT().

◆ cached_pxebs

struct cached_dhcp_packet cached_pxebs

Initial value:

= {
        .name = PXEBS_SETTINGS_NAME,
}

Cached PXEBSACK.

Definition at line 75 of file cachedhcp.c.

                                         {
        .name = PXEBS_SETTINGS_NAME,
};

Referenced by cachedhcp_startup_early(), efi_cachedhcp_record(), and FILE_SECBOOT().

◆ cached_packets

struct cached_dhcp_packet* cached_packets[]

static

Initial value:

= {
        &cached_dhcpack,
        &cached_proxydhcp,
        &cached_pxebs,
}

List of cached DHCP packets.

Definition at line 80 of file cachedhcp.c.

                                                     {
        &cached_dhcpack,
        &cached_proxydhcp,
        &cached_pxebs,
};

Referenced by cachedhcp_record().

◆ __net_driver

struct net_driver cachedhcp_driver __net_driver

Initial value:

= {
        .name = "cachedhcp",
        .probe = cachedhcp_probe,
}

Cached DHCP packet network device driver.

Definition at line 399 of file cachedhcp.c.

                                                  {
        .name = "cachedhcp",
        .probe = cachedhcp_probe,
};

Data Structures

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ CACHEDHCP_RETAIN

◆ CACHEDHCP_USED

◆ colour

Function Documentation

◆ FILE_LICENCE()

◆ FILE_SECBOOT()

◆ cachedhcp_free()

◆ cachedhcp_apply()

◆ cachedhcp_uri()

◆ cachedhcp_record()

◆ cachedhcp_startup_early()

◆ cachedhcp_startup_late()

◆ cachedhcp_shutdown()

◆ __startup_fn() [1/2]

◆ __startup_fn() [2/2]

◆ cachedhcp_probe()

◆ cachedhcp_recycle()

Variable Documentation

◆ cached_dhcpack

◆ cached_proxydhcp

◆ cached_pxebs

◆ cached_packets

◆ __net_driver