Cached DHCP packet. More...

#include <stddef.h>
#include <ipxe/uaccess.h>

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)

int	cachedhcp_record (struct cached_dhcp_packet *cache, unsigned int vlan, userptr_t data, size_t max_len)
	Record cached DHCP packet. More...

void	cachedhcp_recycle (struct net_device *netdev)
	Recycle cached DHCPACK. More...

Variables
struct cached_dhcp_packet	cached_dhcpack
	Cached DHCPACK. More...

struct cached_dhcp_packet	cached_proxydhcp
	Cached ProxyDHCPOFFER. More...

struct cached_dhcp_packet	cached_pxebs
	Cached PXEBSACK. More...

Detailed Description

Cached DHCP packet.

Definition in file cachedhcp.h.

Function Documentation

◆ FILE_LICENCE()

FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )

◆ cachedhcp_record()

int cachedhcp_record	(	struct cached_dhcp_packet *	cache,
		unsigned int	vlan,
		userptr_t	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 200 of file cachedhcp.c.

                                                         {
         struct dhcp_packet *dhcppkt;
         struct dhcp_packet *tmp;
         struct dhcphdr *dhcphdr;
         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 ) );
         copy_from_user ( dhcphdr, data, 0, 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,
                user_to_phys ( data, 0 ), len, max_len );
         cache->dhcppkt = dhcppkt;
         cache->vlan = vlan;
 
         return 0;
 }

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

Referenced by cachedhcp_init(), and efi_cachedhcp_record().

◆ cachedhcp_recycle()

void cachedhcp_recycle ( struct net_device * netdev )

Recycle cached DHCPACK.

Parameters

netdev	Network device
priv	Private data

Definition at line 352 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;
         }
 }