[dhcp] Add generic facility for using cached network settings
authorJoshua Oreman <oremanj@rwcr.net>
Tue, 8 Dec 2009 08:40:50 +0000 (03:40 -0500)
committerMarty Connor <mdc@etherboot.org>
Wed, 20 Jan 2010 22:15:51 +0000 (17:15 -0500)
When a DHCP session is started (using autoboot or a command-line `dhcp
net0'), check whether the new setting use-cached (DHCP option 175.178)
is TRUE; if so, skip DHCP and rely on currently registered
settings. This lets one combine a static IP with autoboot.

Before checking the use-cached setting, call a weak
get_cached_dhcpack() hook that can be implemented by particular builds
of gPXE supporting some fashion of retrieving a cached DHCPACK packet.
If one is available, it is registered as an options source, and then
either that packet's option 175.178 or the user's prior manual
use-cached setting can allow skipping duplicate DHCP.

Using cached packets is not the default because DHCP servers are often
configured to give gPXE different options than they give a vendor PXE
client; in order to break the infinite loop of PXE chaining, one would
need to load a gPXE with an embedded image that does something more
than autoboot.

Signed-off-by: Marty Connor <mdc@etherboot.org>
src/include/gpxe/dhcp.h
src/net/cachedhcp.c [new file with mode: 0644]
src/net/udp/dhcp.c
src/usr/dhcpmgmt.c

index 2d9f885..ebfe8ed 100644 (file)
@@ -16,6 +16,7 @@ FILE_LICENCE ( GPL2_OR_LATER );
 #include <gpxe/tables.h>
 #include <gpxe/uuid.h>
 #include <gpxe/netdevice.h>
+#include <gpxe/uaccess.h>
 
 struct job_interface;
 struct dhcp_options;
@@ -332,6 +333,16 @@ struct dhcp_netdev_desc {
        uint16_t device;
 } __attribute__ (( packed ));
 
+/** Use cached network settings
+ *
+ * Cached network settings may be available from a prior DHCP request
+ * (if running as a PXE NBP), non-volatile storage on the NIC, or
+ * settings set via the command line or an embedded image. If this
+ * flag is not set, it will be assumed that those sources are
+ * insufficient and that DHCP should still be run when autobooting.
+ */
+#define DHCP_EB_USE_CACHED DHCP_ENCAP_OPT ( DHCP_EB_ENCAP, 0xb2 )
+
 /** BIOS drive number
  *
  * This is the drive number for a drive emulated via INT 13.  0x80 is
@@ -615,4 +626,12 @@ extern int start_dhcp ( struct job_interface *job, struct net_device *netdev );
 extern int start_pxebs ( struct job_interface *job, struct net_device *netdev,
                         unsigned int pxe_type );
 
+/* In environments that can provide cached DHCP packets, this function
+ * should look for such a packet and call store_cached_dhcpack() with
+ * it if it exists.
+ */
+__weak_decl ( void, get_cached_dhcpack, ( void ), (), );
+
+extern void store_cached_dhcpack ( userptr_t data, size_t len );
+
 #endif /* _GPXE_DHCP_H */
diff --git a/src/net/cachedhcp.c b/src/net/cachedhcp.c
new file mode 100644 (file)
index 0000000..37f344b
--- /dev/null
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2009 Joshua Oreman <oremanj@rwcr.net>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER );
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <gpxe/dhcp.h>
+#include <gpxe/dhcppkt.h>
+#include <gpxe/netdevice.h>
+#include <gpxe/iobuf.h>
+#include <gpxe/uaccess.h>
+
+/** @file
+ *
+ * Cached DHCP packet handling
+ *
+ */
+
+/**
+ * Store cached DHCPACK packet
+ *
+ * @v data             User pointer to cached DHCP packet data
+ * @v len              Length of cached DHCP packet data
+ * @ret rc             Return status code
+ *
+ * This function should be called by the architecture-specific
+ * get_cached_dhcpack() handler.
+ */
+void store_cached_dhcpack ( userptr_t data, size_t len ) {
+       struct dhcp_packet *dhcppkt;
+       struct dhcphdr *dhcphdr;
+       struct settings *parent;
+       int rc;
+
+       /* Create DHCP packet */
+       dhcppkt = zalloc ( sizeof ( *dhcppkt ) + len );
+       if ( ! dhcppkt )
+               return;
+
+       /* Fill in data for DHCP packet */
+       dhcphdr = ( ( ( void * ) dhcppkt ) + sizeof ( * dhcppkt ) );
+       copy_from_user ( dhcphdr, data, 0, len );
+       dhcppkt_init ( dhcppkt, dhcphdr, len );
+       DBG_HD ( dhcppkt->options.data, dhcppkt->options.len );
+
+       /* Register settings on the last opened network device.
+        * This will have the effect of registering cached settings
+        * with a network device when "dhcp netX" is performed for that
+        * device, which is usually what we want.
+        */
+       parent = netdev_settings ( last_opened_netdev() );
+       if ( ( rc = register_settings ( &dhcppkt->settings, parent ) ) != 0 )
+               DBG ( "DHCP could not register cached settings: %s\n",
+                     strerror ( rc ) );
+
+       dhcppkt_put ( dhcppkt );
+
+       DBG ( "DHCP registered cached settings\n" );
+}
index aba9000..0edd0ad 100644 (file)
@@ -110,6 +110,14 @@ struct setting user_class_setting __setting = {
        .type = &setting_type_string,
 };
 
+/** Use cached network settings */
+struct setting use_cached_setting __setting = {
+       .name = "use-cached",
+       .description = "Use cached network settings",
+       .tag = DHCP_EB_USE_CACHED,
+       .type = &setting_type_uint8,
+};
+
 /**
  * Name a DHCP packet type
  *
@@ -1237,16 +1245,28 @@ static struct sockaddr dhcp_peer = {
  *
  * @v job              Job control interface
  * @v netdev           Network device
- * @ret rc             Return status code
+ * @ret rc             Return status code, or positive if cached
  *
  * Starts DHCP on the specified network device.  If successful, the
  * DHCPACK (and ProxyDHCPACK, if applicable) will be registered as
  * option sources.
+ *
+ * On a return of 0, a background job has been started to perform the
+ * DHCP request. Any nonzero return means the job has not been
+ * started; a positive return value indicates the success condition of
+ * having fetched the appropriate data from cached information.
  */
 int start_dhcp ( struct job_interface *job, struct net_device *netdev ) {
        struct dhcp_session *dhcp;
        int rc;
 
+       /* Check for cached DHCP information */
+       get_cached_dhcpack();
+       if ( fetch_uintz_setting ( NULL, &use_cached_setting ) ) {
+               DBG ( "DHCP using cached network settings\n" );
+               return 1;
+       }
+
        /* Allocate and initialise structure */
        dhcp = zalloc ( sizeof ( *dhcp ) );
        if ( ! dhcp )
index aa96985..f82a3bb 100644 (file)
@@ -55,8 +55,13 @@ int dhcp ( struct net_device *netdev ) {
        printf ( "DHCP (%s ", netdev->name );
        while ( hlen-- )
                printf ( "%02x%c", *(chaddr++), ( hlen ? ':' : ')' ) );
-       if ( ( rc = start_dhcp ( &monojob, netdev ) ) == 0 )
+
+       if ( ( rc = start_dhcp ( &monojob, netdev ) ) == 0 ) {
                rc = monojob_wait ( "" );
+       } else if ( rc > 0 ) {
+               printf ( " using cached\n" );
+               rc = 0;
+       }
 
        return rc;
 }