iPXE
cachedhcp.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2013 Michael Brown <mbrown@fensystems.co.uk>.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17  * 02110-1301, USA.
18  *
19  * You can also choose to distribute this program under the terms of
20  * the Unmodified Binary Distribution Licence (as given in the file
21  * COPYING.UBDL), provided that you have satisfied its requirements.
22  */
23 
24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
25 
26 #include <stdint.h>
27 #include <stdlib.h>
28 #include <errno.h>
29 #include <ipxe/dhcppkt.h>
30 #include <ipxe/init.h>
31 #include <ipxe/netdevice.h>
32 #include <ipxe/cachedhcp.h>
33 
34 /** @file
35  *
36  * Cached DHCP packet
37  *
38  */
39 
40 /** A cached DHCP packet */
42  /** Settings block name */
43  const char *name;
44  /** DHCP packet (if any) */
46 };
47 
48 /** Cached DHCPACK */
51 };
52 
53 /** Cached ProxyDHCPOFFER */
56 };
57 
58 /** Cached PXEBSACK */
61 };
62 
63 /** List of cached DHCP packets */
64 static struct cached_dhcp_packet *cached_packets[] = {
67  &cached_pxebs,
68 };
69 
70 /** Colour for debug messages */
71 #define colour &cached_dhcpack
72 
73 /**
74  * Free cached DHCP packet
75  *
76  * @v cache Cached DHCP packet
77  */
78 static void cachedhcp_free ( struct cached_dhcp_packet *cache ) {
79 
80  dhcppkt_put ( cache->dhcppkt );
81  cache->dhcppkt = NULL;
82 }
83 
84 /**
85  * Apply cached DHCP packet settings
86  *
87  * @v cache Cached DHCP packet
88  * @v netdev Network device, or NULL
89  * @ret rc Return status code
90  */
91 static int cachedhcp_apply ( struct cached_dhcp_packet *cache,
92  struct net_device *netdev ) {
93  struct settings *settings = NULL;
94  struct ll_protocol *ll_protocol;
95  const uint8_t *chaddr;
96  uint8_t *hw_addr;
97  uint8_t *ll_addr;
98  size_t ll_addr_len;
99  int rc;
100 
101  /* Do nothing if cache is empty */
102  if ( ! cache->dhcppkt )
103  return 0;
104  chaddr = cache->dhcppkt->dhcphdr->chaddr;
105 
106  /* Handle association with network device, if specified */
107  if ( netdev ) {
108  hw_addr = netdev->hw_addr;
109  ll_addr = netdev->ll_addr;
112 
113  /* If cached packet's MAC address matches the network
114  * device's permanent MAC address, then assume that
115  * the permanent MAC address ought to be the network
116  * device's current link-layer address.
117  *
118  * This situation can arise when the PXE ROM does not
119  * understand the system-specific mechanism for
120  * overriding the MAC address, and so uses the
121  * permanent MAC address instead. We choose to match
122  * this behaviour in order to minimise surprise.
123  */
124  if ( memcmp ( hw_addr, chaddr, ll_addr_len ) == 0 ) {
125  if ( memcmp ( hw_addr, ll_addr, ll_addr_len ) != 0 ) {
126  DBGC ( colour, "CACHEDHCP %s resetting %s MAC "
127  "%s ", cache->name, netdev->name,
128  ll_protocol->ntoa ( ll_addr ) );
129  DBGC ( colour, "-> %s\n",
130  ll_protocol->ntoa ( hw_addr ) );
131  }
132  memcpy ( ll_addr, hw_addr, ll_addr_len );
133  }
134 
135  /* Do nothing unless cached packet's MAC address
136  * matches this network device.
137  */
138  if ( memcmp ( ll_addr, chaddr, ll_addr_len ) != 0 ) {
139  DBGC ( colour, "CACHEDHCP %s does not match %s\n",
140  cache->name, netdev->name );
141  return 0;
142  }
143  DBGC ( colour, "CACHEDHCP %s is for %s\n",
144  cache->name, netdev->name );
145 
146  /* Use network device's settings block */
148  }
149 
150  /* Register settings */
151  if ( ( rc = register_settings ( &cache->dhcppkt->settings, settings,
152  cache->name ) ) != 0 ) {
153  DBGC ( colour, "CACHEDHCP %s could not register settings: %s\n",
154  cache->name, strerror ( rc ) );
155  return rc;
156  }
157 
158  /* Free cached DHCP packet */
159  cachedhcp_free ( cache );
160 
161  return 0;
162 }
163 
164 /**
165  * Record cached DHCP packet
166  *
167  * @v cache Cached DHCP packet
168  * @v data DHCPACK packet buffer
169  * @v max_len Maximum possible length
170  * @ret rc Return status code
171  */
173  size_t max_len ) {
174  struct dhcp_packet *dhcppkt;
175  struct dhcp_packet *tmp;
176  struct dhcphdr *dhcphdr;
177  unsigned int i;
178  size_t len;
179 
180  /* Free any existing cached packet */
181  cachedhcp_free ( cache );
182 
183  /* Allocate and populate DHCP packet */
184  dhcppkt = zalloc ( sizeof ( *dhcppkt ) + max_len );
185  if ( ! dhcppkt ) {
186  DBGC ( colour, "CACHEDHCP %s could not allocate copy\n",
187  cache->name );
188  return -ENOMEM;
189  }
190  dhcphdr = ( ( ( void * ) dhcppkt ) + sizeof ( *dhcppkt ) );
192  dhcppkt_init ( dhcppkt, dhcphdr, max_len );
193 
194  /* Shrink packet to required length. If reallocation fails,
195  * just continue to use the original packet and waste the
196  * unused space.
197  */
198  len = dhcppkt_len ( dhcppkt );
199  assert ( len <= max_len );
200  tmp = realloc ( dhcppkt, ( sizeof ( *dhcppkt ) + len ) );
201  if ( tmp )
202  dhcppkt = tmp;
203 
204  /* Reinitialise packet at new address */
205  dhcphdr = ( ( ( void * ) dhcppkt ) + sizeof ( *dhcppkt ) );
206  dhcppkt_init ( dhcppkt, dhcphdr, len );
207 
208  /* Discard duplicate packets, since some PXE stacks (including
209  * iPXE itself) will report the DHCPACK packet as the PXEBSACK
210  * if no separate PXEBSACK exists.
211  */
212  for ( i = 0 ; i < ( sizeof ( cached_packets ) /
213  sizeof ( cached_packets[0] ) ) ; i++ ) {
214  tmp = cached_packets[i]->dhcppkt;
215  if ( tmp && ( dhcppkt_len ( tmp ) == len ) &&
216  ( memcmp ( tmp->dhcphdr, dhcppkt->dhcphdr, len ) == 0 ) ) {
217  DBGC ( colour, "CACHEDHCP %s duplicates %s\n",
218  cache->name, cached_packets[i]->name );
219  dhcppkt_put ( dhcppkt );
220  return -EEXIST;
221  }
222  }
223 
224  /* Store as cached packet */
225  DBGC ( colour, "CACHEDHCP %s at %#08lx+%#zx/%#zx\n", cache->name,
226  user_to_phys ( data, 0 ), len, max_len );
227  cache->dhcppkt = dhcppkt;
228 
229  return 0;
230 }
231 
232 /**
233  * Cached DHCPACK startup function
234  *
235  */
236 static void cachedhcp_startup ( void ) {
237 
238  /* Apply cached ProxyDHCPOFFER, if any */
240 
241  /* Apply cached PXEBSACK, if any */
243 
244  /* Free any remaining cached packets */
245  if ( cached_dhcpack.dhcppkt ) {
246  DBGC ( colour, "CACHEDHCP %s unclaimed\n",
248  }
252 }
253 
254 /** Cached DHCPACK startup function */
255 struct startup_fn cachedhcp_startup_fn __startup_fn ( STARTUP_LATE ) = {
256  .name = "cachedhcp",
257  .startup = cachedhcp_startup,
258 };
259 
260 /**
261  * Apply cached DHCPACK to network device, if applicable
262  *
263  * @v netdev Network device
264  * @ret rc Return status code
265  */
266 static int cachedhcp_probe ( struct net_device *netdev ) {
267 
268  /* Apply cached DHCPACK to network device, if applicable */
270 }
271 
272 /** Cached DHCP packet network device driver */
273 struct net_driver cachedhcp_driver __net_driver = {
274  .name = "cachedhcp",
275  .probe = cachedhcp_probe,
276 };
#define colour
Colour for debug messages.
Definition: cachedhcp.c:71
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
A DHCP packet.
Definition: dhcppkt.h:20
uint8_t ll_addr_len
Link-layer address length.
Definition: netdevice.h:198
static void size_t size_t max_len
Definition: entropy.h:153
Error codes.
#define EEXIST
File exists.
Definition: errno.h:388
struct cached_dhcp_packet cached_proxydhcp
Cached ProxyDHCPOFFER.
Definition: cachedhcp.c:54
static __always_inline void copy_from_user(void *dest, userptr_t src, off_t src_off, size_t len)
Copy data from user buffer.
Definition: uaccess.h:337
unsigned long user_to_phys(userptr_t userptr, off_t offset)
Convert user pointer to physical address.
#define DBGC(...)
Definition: compiler.h:505
static void cachedhcp_startup(void)
Cached DHCPACK startup function.
Definition: cachedhcp.c:236
FILE_LICENCE(GPL2_OR_LATER_OR_UBDL)
struct net_driver cachedhcp_driver __net_driver
Cached DHCP packet network device driver.
Definition: cachedhcp.c:273
const char * name
Definition: init.h:42
A network upper-layer driver.
Definition: netdevice.h:473
static struct settings * netdev_settings(struct net_device *netdev)
Get per-netdevice configuration settings block.
Definition: netdevice.h:589
A link-layer protocol.
Definition: netdevice.h:114
#define STARTUP_LATE
Late startup.
Definition: init.h:64
static struct cached_dhcp_packet * cached_packets[]
List of cached DHCP packets.
Definition: cachedhcp.c:64
struct dhcp_packet * dhcppkt
DHCP packet (if any)
Definition: cachedhcp.c:45
static void cachedhcp_free(struct cached_dhcp_packet *cache)
Free cached DHCP packet.
Definition: cachedhcp.c:78
A startup/shutdown function.
Definition: init.h:41
#define ENOMEM
Not enough space.
Definition: errno.h:534
void * memcpy(void *dest, const void *src, size_t len) __nonnull
const char * name
Name.
Definition: netdevice.h:475
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
#define PROXYDHCP_SETTINGS_NAME
Settings block name used for ProxyDHCP responses.
Definition: dhcp.h:689
static int cachedhcp_apply(struct cached_dhcp_packet *cache, struct net_device *netdev)
Apply cached DHCP packet settings.
Definition: cachedhcp.c:91
#define DHCP_SETTINGS_NAME
Settings block name used for DHCP responses.
Definition: dhcp.h:686
Cached DHCP packet.
static struct net_device * netdev
Definition: gdbudp.c:52
A cached DHCP packet.
Definition: cachedhcp.c:41
#define PXEBS_SETTINGS_NAME
Setting block name used for BootServerDHCP responses.
Definition: dhcp.h:692
char * strerror(int errno)
Retrieve string representation of error number.
Definition: strerror.c:78
void * zalloc(size_t size)
Allocate cleared memory.
Definition: malloc.c:624
uint8_t chaddr[16]
Client hardware address.
Definition: dhcp.h:637
uint8_t * tmp
Definition: entropy.h:156
A network device.
Definition: netdevice.h:352
A settings block.
Definition: settings.h:132
unsigned char uint8_t
Definition: stdint.h:10
struct startup_fn cachedhcp_startup_fn __startup_fn(STARTUP_LATE)
Cached DHCPACK startup function.
struct cached_dhcp_packet cached_dhcpack
Cached DHCPACK.
Definition: cachedhcp.c:49
struct settings settings
Settings interface.
Definition: dhcppkt.h:28
A DHCP header.
Definition: dhcp.h:591
Network device management.
static int cachedhcp_probe(struct net_device *netdev)
Apply cached DHCPACK to network device, if applicable.
Definition: cachedhcp.c:266
void dhcppkt_init(struct dhcp_packet *dhcppkt, struct dhcphdr *data, size_t len)
Initialise DHCP packet.
Definition: dhcppkt.c:300
char name[NETDEV_NAME_LEN]
Name of this network device.
Definition: netdevice.h:362
struct dhcphdr * dhcphdr
The DHCP packet contents.
Definition: dhcppkt.h:24
uint32_t len
Length.
Definition: ena.h:14
static void dhcppkt_put(struct dhcp_packet *dhcppkt)
Decrement reference count on DHCP packet.
Definition: dhcppkt.h:49
static size_t dhcppkt_len(struct dhcp_packet *dhcppkt)
Get used length of DHCP packet.
Definition: dhcppkt.h:59
const char * name
Settings block name.
Definition: cachedhcp.c:43
const char *(* ntoa)(const void *ll_addr)
Transcribe link-layer address.
Definition: netdevice.h:163
DHCP packets.
void * realloc(void *old_ptr, size_t new_size)
Reallocate memory.
Definition: malloc.c:521
int register_settings(struct settings *settings, struct settings *parent, const char *name)
Register settings block.
Definition: settings.c:475
struct cached_dhcp_packet cached_pxebs
Cached PXEBSACK.
Definition: cachedhcp.c:59
int cachedhcp_record(struct cached_dhcp_packet *cache, userptr_t data, size_t max_len)
Record cached DHCP packet.
Definition: cachedhcp.c:172
struct arbelprm_port_state_change_st data
Message.
Definition: arbel.h:12
uint8_t ll_addr[MAX_LL_ADDR_LEN]
Link-layer address.
Definition: netdevice.h:387
int memcmp(const void *first, const void *second, size_t len)
Compare memory regions.
Definition: string.c:114
uint8_t hw_addr[MAX_HW_ADDR_LEN]
Hardware address.
Definition: netdevice.h:381
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362
struct ll_protocol * ll_protocol
Link-layer protocol.
Definition: netdevice.h:372
unsigned long userptr_t
A pointer to a user buffer.
Definition: uaccess.h:33