/*
* Copyright (C) 2013 Michael Brown <mbrown@fensystems.co.uk>.
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*
* You can also choose to distribute this program under the terms of
* the Unmodified Binary Distribution Licence (as given in the file
* COPYING.UBDL), provided that you have satisfied its requirements.
*/
FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/interface.h>
#include <ipxe/xfer.h>
#include <ipxe/iobuf.h>
#include <ipxe/open.h>
#include <ipxe/netdevice.h>
#include <ipxe/settings.h>
#include <ipxe/retry.h>
#include <ipxe/timer.h>
#include <ipxe/in.h>
#include <ipxe/crc32.h>
#include <ipxe/errortab.h>
#include <ipxe/ipv6.h>
#include <ipxe/dhcparch.h>
#include <ipxe/dhcpv6.h>
/** @file
*
* Dynamic Host Configuration Protocol for IPv6
*
*/
/* Disambiguate the various error causes */
#define EPROTO_UNSPECFAIL __einfo_error ( EINFO_EPROTO_UNSPECFAIL )
#define EINFO_EPROTO_UNSPECFAIL \
__einfo_uniqify ( EINFO_EPROTO, 1, "Unspecified server failure" )
#define EPROTO_NOADDRSAVAIL __einfo_error ( EINFO_EPROTO_NOADDRSAVAIL )
#define EINFO_EPROTO_NOADDRSAVAIL \
__einfo_uniqify ( EINFO_EPROTO, 2, "No addresses available" )
#define EPROTO_NOBINDING __einfo_error ( EINFO_EPROTO_NOBINDING )
#define EINFO_EPROTO_NOBINDING \
__einfo_uniqify ( EINFO_EPROTO, 3, "Client record unavailable" )
#define EPROTO_NOTONLINK __einfo_error ( EINFO_EPROTO_NOTONLINK )
#define EINFO_EPROTO_NOTONLINK \
__einfo_uniqify ( EINFO_EPROTO, 4, "Prefix not on link" )
#define EPROTO_USEMULTICAST __einfo_error ( EINFO_EPROTO_USEMULTICAST )
#define EINFO_EPROTO_USEMULTICAST \
__einfo_uniqify ( EINFO_EPROTO, 5, "Use multicast address" )
#define EPROTO_STATUS( status ) \
EUNIQ ( EINFO_EPROTO, ( (status) & 0x0f ), EPROTO_UNSPECFAIL, \
EPROTO_NOADDRSAVAIL, EPROTO_NOBINDING, \
EPROTO_NOTONLINK, EPROTO_USEMULTICAST )
/** Human-readable error messages */
struct errortab dhcpv6_errors[] __errortab = {
__einfo_errortab ( EINFO_EPROTO_NOADDRSAVAIL ),
};
/****************************************************************************
*
* DHCPv6 option lists
*
*/
/** A DHCPv6 option list */
struct dhcpv6_option_list {
/** Data buffer */
const void *data;
/** Length of data buffer */
size_t len;
};
/**
* Find DHCPv6 option
*
* @v options DHCPv6 option list
* @v code Option code
* @ret option DHCPv6 option, or NULL if not found
*/
static const union dhcpv6_any_option *
dhcpv6_option ( struct dhcpv6_option_list *options, unsigned int code ) {
const union dhcpv6_any_option *option = options->data;
size_t remaining = options->len;
size_t data_len;
/* Scan through list of options */
while ( remaining >= sizeof ( option->header ) ) {
/* Calculate and validate option length */
remaining -= sizeof ( option->header );
data_len = ntohs ( option->header.len );
if ( data_len > remaining ) {
/* Malformed option list */
return NULL;
}
/* Return if we have found the specified option */
if ( option->header.code == htons ( code ) )
return option;
/* Otherwise, move to the next option */
option = ( ( ( void * ) option->header.data ) + data_len );
remaining -= data_len;
}
return NULL;
}
/**
* Check DHCPv6 client or server identifier
*
* @v options DHCPv6 option list
* @v code Option code
* @v expected Expected value
* @v len Length of expected value
* @ret rc Return status code
*/
static int dhcpv6_check_duid ( struct dhcpv6_option_list *options,
unsigned int code, const void *expected,
size_t len ) {
const union dhcpv6_any_option *option;
const struct dhcpv6_duid_option *duid;
/* Find option */
option = dhcpv6_option ( options, code );
if ( ! option )
return -ENOENT;
duid = &option->duid;
/* Check option length */
if ( ntohs ( duid->header.len ) != len )
return -EINVAL;
/* Compare option value */
if ( memcmp ( duid->duid, expected, len ) != 0 )
return -EINVAL;
return 0;
}
/**
* Get DHCPv6 status code
*
* @v options DHCPv6 option list
* @ret rc Return status code
*/
static int dhcpv6_status_code ( struct dhcpv6_option_list *options ) {
const union dhcpv6_any_option *option;
const struct dhcpv6_status_code_option *status_code;
unsigned int status;
/* Find status code option, if present */
option = dhcpv6_option ( options, DHCPV6_STATUS_CODE );
if ( ! option ) {
/* Omitted status code should be treated as "success" */
return 0;
}
status_code = &option->status_code;
/* Sanity check */
if ( ntohs ( status_code->header.len ) <
( sizeof ( *status_code ) - sizeof ( status_code->header ) ) ) {
return -EINVAL;
}
/* Calculate iPXE error code from DHCPv6 status code */
status = ntohs ( status_code->status );
return ( status ? -EPROTO_STATUS ( status ) : 0 );
}
/**
* Get DHCPv6 identity association address
*
* @v options DHCPv6 option list
* @v iaid Identity association ID
* @v address IPv6 address to fill in
* @ret rc Return status code
*/
static int dhcpv6_iaaddr ( struct dhcpv6_option_list *options, uint32_t iaid,
struct in6_addr *address ) {
const union dhcpv6_any_option *option;
const struct dhcpv6_ia_na_option *ia_na;
const struct dhcpv6_iaaddr_option *iaaddr;
struct dhcpv6_option_list suboptions;
size_t len;
int rc;
/* Find identity association option, if present */
option = dhcpv6_option ( options, DHCPV6_IA_NA );
if ( ! option )
return -ENOENT;
ia_na = &option->ia_na;
/* Sanity check */
len = ntohs ( ia_na->header.len );
if ( len < ( sizeof ( *ia_na ) - sizeof ( ia_na->header ) ) )
return -EINVAL;
/* Check identity association ID */
if ( ia_na->iaid != htonl ( iaid ) )
return -EINVAL;
/* Construct IA_NA sub-options list */
suboptions.data = ia_na->options;
suboptions.len = ( len + sizeof ( ia_na->header ) -
offsetof ( typeof ( *ia_na ), options ) );
/* Check IA_NA status code */
if ( ( rc = dhcpv6_status_code ( &suboptions ) ) != 0 )
return rc;
/* Find identity association address, if present */
option = dhcpv6_option ( &suboptions, DHCPV6_IAADDR );
if ( ! option )
return -ENOENT;
iaaddr = &option->iaaddr;
/* Sanity check */
len = ntohs ( iaaddr->header.len );
if ( len < ( sizeof ( *iaaddr ) - sizeof ( iaaddr->header ) ) )
return -EINVAL;
/* Construct IAADDR sub-options list */
suboptions.data = iaaddr->options;
suboptions.len = ( len + sizeof ( iaaddr->header ) -
offsetof ( typeof ( *iaaddr ), options ) );
/* Check IAADDR status code */
if ( ( rc = dhcpv6_status_code ( &suboptions ) ) != 0 )
return rc;
/* Extract IPv6 address */
memcpy ( address, &iaaddr->address, sizeof ( *address ) );
return 0;
}
/****************************************************************************
*
* DHCPv6 settings blocks
*
*/
/** A DHCPv6 settings block */
struct dhcpv6_settings {
/** Reference count */
struct refcnt refcnt;
/** Settings block */
struct settings settings;
/** Leased address */
struct in6_addr lease;
/** Option list */
struct dhcpv6_option_list options;
};
/**
* Check applicability of DHCPv6 setting
*
* @v settings Settings block
* @v setting Setting
* @ret applies Setting applies within this settings block
*/
static int dhcpv6_applies ( struct settings *settings __unused,
const struct setting *setting ) {
return ( ( setting->scope == &dhcpv6_scope ) ||
( setting_cmp ( setting, &ip6_setting ) == 0 ) );
}
/**
* Fetch value of DHCPv6 leased address
*
* @v dhcpset DHCPv6 settings
* @v data Buffer to fill with setting data
* @v len Length of buffer
* @ret len Length of setting data, or negative error
*/
static int dhcpv6_fetch_lease ( struct dhcpv6_settings *dhcpv6set,
void *data, size_t len ) {
struct in6_addr *lease = &dhcpv6set->lease;
/* Do nothing unless a leased address exists */
if ( IN6_IS_ADDR_UNSPECIFIED ( lease ) )
return -ENOENT;
/* Copy leased address */
if ( len > sizeof ( *lease ) )
len = sizeof ( *lease );
memcpy ( data, lease, len );
return sizeof ( *lease );
}
/**
* Fetch value of DHCPv6 setting
*
* @v settings Settings block
* @v setting Setting to fetch
* @v data Buffer to fill with setting data
* @v len Length of buffer
* @ret len Length of setting data, or negative error
*/
static int dhcpv6_fetch ( struct settings *settings,
struct setting *setting,
void *data, size_t len ) {
struct dhcpv6_settings *dhcpv6set =
container_of ( settings, struct dhcpv6_settings, settings );
const union dhcpv6_any_option *option;
size_t option_len;
/* Handle leased address */
if ( setting_cmp ( setting, &ip6_setting ) == 0 )
return dhcpv6_fetch_lease ( dhcpv6set, data, len );
/* Find option */
option = dhcpv6_option ( &dhcpv6set->options, setting->tag );
if ( ! option )
return -ENOENT;
/* Copy option to data buffer */
option_len = ntohs ( option->header.len );
if ( len > option_len )
len = option_len;
memcpy ( data, option->header.data, len );
return option_len;
}
/** DHCPv6 settings operations */
static struct settings_operations dhcpv6_settings_operations = {
.applies = dhcpv6_applies,
.fetch = dhcpv6_fetch,
};
/**
* Register DHCPv6 options as network device settings
*
* @v lease DHCPv6 leased address
* @v options DHCPv6 option list
* @v parent Parent settings block
* @ret rc Return status code
*/
static int dhcpv6_register ( struct in6_addr *lease,
struct dhcpv6_option_list *options,
struct settings *parent ) {
struct dhcpv6_settings *dhcpv6set;
void *data;
size_t len;
int rc;
/* Allocate and initialise structure */
dhcpv6set = zalloc ( sizeof ( *dhcpv6set ) + options->len );
if ( ! dhcpv6set ) {
rc = -ENOMEM;
goto err_alloc;
}
ref_init ( &dhcpv6set->refcnt, NULL );
settings_init ( &dhcpv6set->settings, &dhcpv6_settings_operations,
&dhcpv6set->refcnt, &dhcpv6_scope );
dhcpv6set->settings.order = IPV6_ORDER_DHCPV6;
data = ( ( ( void * ) dhcpv6set ) + sizeof ( *dhcpv6set ) );
len = options->len;
memcpy ( data, options->data, len );
dhcpv6set->options.data = data;
dhcpv6set->options.len = len;
memcpy ( &dhcpv6set->lease, lease, sizeof ( dhcpv6set->lease ) );
/* Register settings */
if ( ( rc = register_settings ( &dhcpv6set->settings, parent,
DHCPV6_SETTINGS_NAME ) ) != 0 )
goto err_register;
err_register:
ref_put ( &dhcpv6set->refcnt );
err_alloc:
return rc;
}
/****************************************************************************
*
* DHCPv6 protocol
*
*/
/** Raw option data for options common to all DHCPv6 requests */
static uint8_t dhcpv6_request_options_data[] = {
DHCPV6_CODE ( DHCPV6_OPTION_REQUEST ),
DHCPV6_OPTION ( DHCPV6_CODE ( DHCPV6_DNS_SERVERS ),
DHCPV6_CODE ( DHCPV6_DOMAIN_LIST ),
DHCPV6_CODE ( DHCPV6_BOOTFILE_URL ),
DHCPV6_CODE ( DHCPV6_BOOTFILE_PARAM ) ),
DHCPV6_CODE ( DHCPV6_VENDOR_CLASS ),
DHCPV6_OPTION ( DHCPV6_DWORD_VALUE ( DHCPV6_VENDOR_CLASS_PXE ),
DHCPV6_STRING (
DHCP_VENDOR_PXECLIENT ( DHCP_ARCH_CLIENT_ARCHITECTURE,
DHCP_ARCH_CLIENT_NDI ) ) ),
DHCPV6_CODE ( DHCPV6_CLIENT_ARCHITECTURE ),
DHCPV6_WORD ( DHCP_ARCH_CLIENT_ARCHITECTURE ),
DHCPV6_CODE ( DHCPV6_CLIENT_NDI ),
DHCPV6_OPTION ( DHCP_ARCH_CLIENT_NDI )
};
/**
* Name a DHCPv6 packet type
*
* @v type DHCPv6 packet type
* @ret name DHCPv6 packet type name
*/
static __attribute__ (( unused )) const char *
dhcpv6_type_name ( unsigned int type ) {
static char buf[ 12 /* "UNKNOWN-xxx" + NUL */ ];
switch ( type ) {
case DHCPV6_SOLICIT: return "SOLICIT";
case DHCPV6_ADVERTISE: return "ADVERTISE";
case DHCPV6_REQUEST: return "REQUEST";
case DHCPV6_REPLY: return "REPLY";
case DHCPV6_INFORMATION_REQUEST: return "INFORMATION-REQUEST";
default:
snprintf ( buf, sizeof ( buf ), "UNKNOWN-%d", type );
return buf;
}
}
/** A DHCPv6 session state */
struct dhcpv6_session_state {
/** Current transmitted packet type */
uint8_t tx_type;
/** Current expected received packet type */
uint8_t rx_type;
/** Flags */
uint8_t flags;
/** Next state (or NULL to terminate) */
struct dhcpv6_session_state *next;
};
/** DHCPv6 session state flags */
enum dhcpv6_session_state_flags {
/** Include identity association within request */
DHCPV6_TX_IA_NA = 0x01,
/** Include leased IPv6 address within request */
DHCPV6_TX_IAADDR = 0x02,
/** Record received server ID */
DHCPV6_RX_RECORD_SERVER_ID = 0x04,
/** Record received IPv6 address */
DHCPV6_RX_RECORD_IAADDR = 0x08,
};
/** DHCPv6 request state */
static struct dhcpv6_session_state dhcpv6_request = {
.tx_type = DHCPV6_REQUEST,
.rx_type = DHCPV6_REPLY,
.flags = ( DHCPV6_TX_IA_NA | DHCPV6_TX_IAADDR |
DHCPV6_RX_RECORD_IAADDR ),
.next = NULL,
};
/** DHCPv6 solicitation state */
static struct dhcpv6_session_state dhcpv6_solicit = {
.tx_type = DHCPV6_SOLICIT,
.rx_type = DHCPV6_ADVERTISE,
.flags = ( DHCPV6_TX_IA_NA | DHCPV6_RX_RECORD_SERVER_ID |
DHCPV6_RX_RECORD_IAADDR ),
.next = &dhcpv6_request,
};
/** DHCPv6 information request state */
static struct dhcpv6_session_state dhcpv6_information_request = {
.tx_type = DHCPV6_INFORMATION_REQUEST,
.rx_type = DHCPV6_REPLY,
.flags = 0,
.next = NULL,
};
/** A DHCPv6 session */
struct dhcpv6_session {
/** Reference counter */
struct refcnt refcnt;
/** Job control interface */
struct interface job;
/** Data transfer interface */
struct interface xfer;
/** Network device being configured */
struct net_device *netdev;
/** Transaction ID */
uint8_t xid[3];
/** Identity association ID */
uint32_t iaid;
/** Start time (in ticks) */
unsigned long start;
/** Client DUID */
struct dhcpv6_duid_uuid client_duid;
/** Server DUID, if known */
void *server_duid;
/** Server DUID length */
size_t server_duid_len;
/** Leased IPv6 address */
struct in6_addr lease;
/** Retransmission timer */
struct retry_timer timer;
/** Current session state */
struct dhcpv6_session_state *state;
/** Current timeout status code */
int rc;
};
/**
* Free DHCPv6 session
*
* @v refcnt Reference count
*/
static void dhcpv6_free ( struct refcnt *refcnt ) {
struct dhcpv6_session *dhcpv6 =
container_of ( refcnt, struct dhcpv6_session, refcnt );
netdev_put ( dhcpv6->netdev );
free ( dhcpv6->server_duid );
free ( dhcpv6 );
}
/**
* Terminate DHCPv6 session
*
* @v dhcpv6 DHCPv6 session
* @v rc Reason for close
*/
static void dhcpv6_finished ( struct dhcpv6_session *dhcpv6, int rc ) {
/* Stop timer */
stop_timer ( &dhcpv6->timer );
/* Shut down interfaces */
intf_shutdown ( &dhcpv6->xfer, rc );
intf_shutdown ( &dhcpv6->job, rc );
}
/**
* Transition to new DHCPv6 session state
*
* @v dhcpv6 DHCPv6 session
* @v state New session state
*/
static void dhcpv6_set_state ( struct dhcpv6_session *dhcpv6,
struct dhcpv6_session_state *state ) {
DBGC ( dhcpv6, "DHCPv6 %s entering %s state\n", dhcpv6->netdev->name,
dhcpv6_type_name ( state->tx_type ) );
/* Record state */
dhcpv6->state = state;
/* Default to -ETIMEDOUT if no more specific error is recorded */
dhcpv6->rc = -ETIMEDOUT;
/* Start timer to trigger transmission */
start_timer_nodelay ( &dhcpv6->timer );
}
/**
* Get DHCPv6 user class
*
* @v data Data buffer
* @v len Length of data buffer
* @ret len Length of user class
*/
static size_t dhcpv6_user_class ( void *data, size_t len ) {
static const char default_user_class[4] = { 'i', 'P', 'X', 'E' };
int actual_len;
/* Fetch user-class setting, if defined */
actual_len = fetch_raw_setting ( NULL, &user_class_setting, data, len );
if ( actual_len >= 0 )
return actual_len;
/* Otherwise, use the default user class ("iPXE") */
if ( len > sizeof ( default_user_class ) )
len = sizeof ( default_user_class );
memcpy ( data, default_user_class, len );
return sizeof ( default_user_class );
}
/**
* Transmit current request
*
* @v dhcpv6 DHCPv6 session
* @ret rc Return status code
*/
static int dhcpv6_tx ( struct dhcpv6_session *dhcpv6 ) {
struct dhcpv6_duid_option *client_id;
struct dhcpv6_duid_option *server_id;
struct dhcpv6_ia_na_option *ia_na;
struct dhcpv6_iaaddr_option *iaaddr;
struct dhcpv6_user_class_option *user_class;
struct dhcpv6_elapsed_time_option *elapsed;
struct dhcpv6_header *dhcphdr;
struct io_buffer *iobuf;
void *options;
size_t client_id_len;
size_t server_id_len;
size_t ia_na_len;
size_t user_class_string_len;
size_t user_class_len;
size_t elapsed_len;
size_t total_len;
int rc;
/* Calculate lengths */
client_id_len = ( sizeof ( *client_id ) +
sizeof ( dhcpv6->client_duid ) );
server_id_len = ( dhcpv6->server_duid ? ( sizeof ( *server_id ) +
dhcpv6->server_duid_len ) :0);
if ( dhcpv6->state->flags & DHCPV6_TX_IA_NA ) {
ia_na_len = sizeof ( *ia_na );
if ( dhcpv6->state->flags & DHCPV6_TX_IAADDR )
ia_na_len += sizeof ( *iaaddr );
} else {
ia_na_len = 0;
}
user_class_string_len = dhcpv6_user_class ( NULL, 0 );
user_class_len = ( sizeof ( *user_class ) +
sizeof ( user_class->user_class[0] ) +
user_class_string_len );
elapsed_len = sizeof ( *elapsed );
total_len = ( sizeof ( *dhcphdr ) + client_id_len + server_id_len +
ia_na_len + sizeof ( dhcpv6_request_options_data ) +
user_class_len + elapsed_len );
/* Allocate packet */
iobuf = xfer_alloc_iob ( &dhcpv6->xfer, total_len );
if ( ! iobuf )
return -ENOMEM;
/* Construct header */
dhcphdr = iob_put ( iobuf, sizeof ( *dhcphdr ) );
dhcphdr->type = dhcpv6->state->tx_type;
memcpy ( dhcphdr->xid, dhcpv6->xid, sizeof ( dhcphdr->xid ) );
/* Construct client identifier */
client_id = iob_put ( iobuf, client_id_len );
client_id->header.code = htons ( DHCPV6_CLIENT_ID );
client_id->header.len = htons ( client_id_len -
sizeof ( client_id->header ) );
memcpy ( client_id->duid, &dhcpv6->client_duid,
sizeof ( dhcpv6->client_duid ) );
/* Construct server identifier, if applicable */
if ( server_id_len ) {
server_id = iob_put ( iobuf, server_id_len );
server_id->header.code = htons ( DHCPV6_SERVER_ID );
server_id->header.len = htons ( server_id_len -
sizeof ( server_id->header ) );
memcpy ( server_id->duid, dhcpv6->server_duid,
dhcpv6->server_duid_len );
}
/* Construct identity association, if applicable */
if ( ia_na_len ) {
ia_na = iob_put ( iobuf, ia_na_len );
ia_na->header.code = htons ( DHCPV6_IA_NA );
ia_na->header.len = htons ( ia_na_len -
sizeof ( ia_na->header ) );
ia_na->iaid = htonl ( dhcpv6->iaid );
ia_na->renew = htonl ( 0 );
ia_na->rebind = htonl ( 0 );
if ( dhcpv6->state->flags & DHCPV6_TX_IAADDR ) {
iaaddr = ( ( void * ) ia_na->options );
iaaddr->header.code = htons ( DHCPV6_IAADDR );
iaaddr->header.len = htons ( sizeof ( *iaaddr ) -
sizeof ( iaaddr->header ));
memcpy ( &iaaddr->address, &dhcpv6->lease,
sizeof ( iaaddr->address ) );
iaaddr->preferred = htonl ( 0 );
iaaddr->valid = htonl ( 0 );
}
}
/* Construct fixed request options */
options = iob_put ( iobuf, sizeof ( dhcpv6_request_options_data ) );
memcpy ( options, dhcpv6_request_options_data,
sizeof ( dhcpv6_request_options_data ) );
/* Construct user class */
user_class = iob_put ( iobuf, user_class_len );
user_class->header.code = htons ( DHCPV6_USER_CLASS );
user_class->header.len = htons ( user_class_len -
sizeof ( user_class->header ) );
user_class->user_class[0].len = htons ( user_class_string_len );
dhcpv6_user_class ( user_class->user_class[0].string,
user_class_string_len );
/* Construct elapsed time */
elapsed = iob_put ( iobuf, elapsed_len );
elapsed->header.code = htons ( DHCPV6_ELAPSED_TIME );
elapsed->header.len = htons ( elapsed_len -
sizeof ( elapsed->header ) );
elapsed->elapsed = htons ( ( ( currticks() - dhcpv6->start ) * 100 ) /
TICKS_PER_SEC );
/* Sanity check */
assert ( iob_len ( iobuf ) == total_len );
/* Transmit packet */
if ( ( rc = xfer_deliver_iob ( &dhcpv6->xfer, iobuf ) ) != 0 ) {
DBGC ( dhcpv6, "DHCPv6 %s could not transmit: %s\n",
dhcpv6->netdev->name, strerror ( rc ) );
return rc;
}
return 0;
}
/**
* Handle timer expiry
*
* @v timer Retransmission timer
* @v fail Failure indicator
*/
static void dhcpv6_timer_expired ( struct retry_timer *timer, int fail ) {
struct dhcpv6_session *dhcpv6 =
container_of ( timer, struct dhcpv6_session, timer );
/* If we have failed, terminate DHCPv6 */
if ( fail ) {
dhcpv6_finished ( dhcpv6, dhcpv6->rc );
return;
}
/* Restart timer */
start_timer ( &dhcpv6->timer );
/* (Re)transmit current request */
dhcpv6_tx ( dhcpv6 );
}
/**
* Receive new data
*
* @v dhcpv6 DHCPv6 session
* @v iobuf I/O buffer
* @v meta Data transfer metadata
* @ret rc Return status code
*/
static int dhcpv6_rx ( struct dhcpv6_session *dhcpv6,
struct io_buffer *iobuf,
struct xfer_metadata *meta ) {
struct settings *parent = netdev_settings ( dhcpv6->netdev );
struct sockaddr_in6 *src = ( ( struct sockaddr_in6 * ) meta->src );
struct dhcpv6_header *dhcphdr = iobuf->data;
struct dhcpv6_option_list options;
const union dhcpv6_any_option *option;
int rc;
/* Sanity checks */
if ( iob_len ( iobuf ) < sizeof ( *dhcphdr ) ) {
DBGC ( dhcpv6, "DHCPv6 %s received packet too short (%zd "
"bytes, min %zd bytes)\n", dhcpv6->netdev->name,
iob_len ( iobuf ), sizeof ( *dhcphdr ) );
rc = -EINVAL;
goto done;
}
assert ( src != NULL );
assert ( src->sin6_family == AF_INET6 );
DBGC ( dhcpv6, "DHCPv6 %s received %s from %s\n",
dhcpv6->netdev->name, dhcpv6_type_name ( dhcphdr->type ),
inet6_ntoa ( &src->sin6_addr ) );
/* Construct option list */
options.data = dhcphdr->options;
options.len = ( iob_len ( iobuf ) -
offsetof ( typeof ( *dhcphdr ), options ) );
/* Verify client identifier */
if ( ( rc = dhcpv6_check_duid ( &options, DHCPV6_CLIENT_ID,
&dhcpv6->client_duid,
sizeof ( dhcpv6->client_duid ) ) ) !=0){
DBGC ( dhcpv6, "DHCPv6 %s received %s without correct client "
"ID: %s\n", dhcpv6->netdev->name,
dhcpv6_type_name ( dhcphdr->type ), strerror ( rc ) );
goto done;
}
/* Verify server identifier, if applicable */
if ( dhcpv6->server_duid &&
( ( rc = dhcpv6_check_duid ( &options, DHCPV6_SERVER_ID,
dhcpv6->server_duid,
dhcpv6->server_duid_len ) ) != 0 ) ) {
DBGC ( dhcpv6, "DHCPv6 %s received %s without correct server "
"ID: %s\n", dhcpv6->netdev->name,
dhcpv6_type_name ( dhcphdr->type ), strerror ( rc ) );
goto done;
}
/* Check message type */
if ( dhcphdr->type != dhcpv6->state->rx_type ) {
DBGC ( dhcpv6, "DHCPv6 %s received %s while expecting %s\n",
dhcpv6->netdev->name, dhcpv6_type_name ( dhcphdr->type ),
dhcpv6_type_name ( dhcpv6->state->rx_type ) );
rc = -ENOTTY;
goto done;
}
/* Fetch status code, if present */
if ( ( rc = dhcpv6_status_code ( &options ) ) != 0 ) {
DBGC ( dhcpv6, "DHCPv6 %s received %s with error status: %s\n",
dhcpv6->netdev->name, dhcpv6_type_name ( dhcphdr->type ),
strerror ( rc ) );
/* This is plausibly the error we want to return */
dhcpv6->rc = rc;
goto done;
}
/* Record identity association address, if applicable */
if ( dhcpv6->state->flags & DHCPV6_RX_RECORD_IAADDR ) {
if ( ( rc = dhcpv6_iaaddr ( &options, dhcpv6->iaid,
&dhcpv6->lease ) ) != 0 ) {
DBGC ( dhcpv6, "DHCPv6 %s received %s with unusable "
"IAADDR: %s\n", dhcpv6->netdev->name,
dhcpv6_type_name ( dhcphdr->type ),
strerror ( rc ) );
/* This is plausibly the error we want to return */
dhcpv6->rc = rc;
goto done;
}
DBGC ( dhcpv6, "DHCPv6 %s received %s is for %s\n",
dhcpv6->netdev->name, dhcpv6_type_name ( dhcphdr->type ),
inet6_ntoa ( &dhcpv6->lease ) );
}
/* Record server ID, if applicable */
if ( dhcpv6->state->flags & DHCPV6_RX_RECORD_SERVER_ID ) {
assert ( dhcpv6->server_duid == NULL );
option = dhcpv6_option ( &options, DHCPV6_SERVER_ID );
if ( ! option ) {
DBGC ( dhcpv6, "DHCPv6 %s received %s missing server "
"ID\n", dhcpv6->netdev->name,
dhcpv6_type_name ( dhcphdr->type ) );
rc = -EINVAL;
goto done;
}
dhcpv6->server_duid_len = ntohs ( option->duid.header.len );
dhcpv6->server_duid = malloc ( dhcpv6->server_duid_len );
if ( ! dhcpv6->server_duid ) {
rc = -ENOMEM;
goto done;
}
memcpy ( dhcpv6->server_duid, option->duid.duid,
dhcpv6->server_duid_len );
}
/* Transition to next state, if applicable */
if ( dhcpv6->state->next ) {
dhcpv6_set_state ( dhcpv6, dhcpv6->state->next );
rc = 0;
goto done;
}
/* Register settings */
if ( ( rc = dhcpv6_register ( &dhcpv6->lease, &options,
parent ) ) != 0 ) {
DBGC ( dhcpv6, "DHCPv6 %s could not register settings: %s\n",
dhcpv6->netdev->name, strerror ( rc ) );
goto done;
}
/* Mark as complete */
dhcpv6_finished ( dhcpv6, 0 );
DBGC ( dhcpv6, "DHCPv6 %s complete\n", dhcpv6->netdev->name );
done:
free_iob ( iobuf );
return rc;
}
/** DHCPv6 job control interface operations */
static struct interface_operation dhcpv6_job_op[] = {
INTF_OP ( intf_close, struct dhcpv6_session *, dhcpv6_finished ),
};
/** DHCPv6 job control interface descriptor */
static struct interface_descriptor dhcpv6_job_desc =
INTF_DESC ( struct dhcpv6_session, job, dhcpv6_job_op );
/** DHCPv6 data transfer interface operations */
static struct interface_operation dhcpv6_xfer_op[] = {
INTF_OP ( xfer_deliver, struct dhcpv6_session *, dhcpv6_rx ),
};
/** DHCPv6 data transfer interface descriptor */
static struct interface_descriptor dhcpv6_xfer_desc =
INTF_DESC ( struct dhcpv6_session, xfer, dhcpv6_xfer_op );
/**
* Start DHCPv6
*
* @v job Job control interface
* @v netdev Network device
* @v stateful Perform stateful address autoconfiguration
* @ret rc Return status code
*/
int start_dhcpv6 ( struct interface *job, struct net_device *netdev,
int stateful ) {
struct ll_protocol *ll_protocol = netdev->ll_protocol;
struct dhcpv6_session *dhcpv6;
struct {
union {
struct sockaddr_in6 sin6;
struct sockaddr sa;
} client;
union {
struct sockaddr_in6 sin6;
struct sockaddr sa;
} server;
} addresses;
uint32_t xid;
int len;
int rc;
/* Allocate and initialise structure */
dhcpv6 = zalloc ( sizeof ( *dhcpv6 ) );
if ( ! dhcpv6 )
return -ENOMEM;
ref_init ( &dhcpv6->refcnt, dhcpv6_free );
intf_init ( &dhcpv6->job, &dhcpv6_job_desc, &dhcpv6->refcnt );
intf_init ( &dhcpv6->xfer, &dhcpv6_xfer_desc, &dhcpv6->refcnt );
dhcpv6->netdev = netdev_get ( netdev );
xid = random();
memcpy ( dhcpv6->xid, &xid, sizeof ( dhcpv6->xid ) );
dhcpv6->start = currticks();
timer_init ( &dhcpv6->timer, dhcpv6_timer_expired, &dhcpv6->refcnt );
/* Construct client and server addresses */
memset ( &addresses, 0, sizeof ( addresses ) );
addresses.client.sin6.sin6_family = AF_INET6;
addresses.client.sin6.sin6_port = htons ( DHCPV6_CLIENT_PORT );
addresses.server.sin6.sin6_family = AF_INET6;
ipv6_all_dhcp_relay_and_servers ( &addresses.server.sin6.sin6_addr );
addresses.server.sin6.sin6_scope_id = netdev->scope_id;
addresses.server.sin6.sin6_port = htons ( DHCPV6_SERVER_PORT );
/* Construct client DUID from system UUID */
dhcpv6->client_duid.type = htons ( DHCPV6_DUID_UUID );
if ( ( len = fetch_uuid_setting ( NULL, &uuid_setting,
&dhcpv6->client_duid.uuid ) ) < 0 ) {
rc = len;
DBGC ( dhcpv6, "DHCPv6 %s could not create DUID-UUID: %s\n",
dhcpv6->netdev->name, strerror ( rc ) );
goto err_client_duid;
}
/* Construct IAID from link-layer address */
dhcpv6->iaid = crc32_le ( 0, netdev->ll_addr, ll_protocol->ll_addr_len);
DBGC ( dhcpv6, "DHCPv6 %s has XID %02x%02x%02x\n", dhcpv6->netdev->name,
dhcpv6->xid[0], dhcpv6->xid[1], dhcpv6->xid[2] );
/* Enter initial state */
dhcpv6_set_state ( dhcpv6, ( stateful ? &dhcpv6_solicit :
&dhcpv6_information_request ) );
/* Open socket */
if ( ( rc = xfer_open_socket ( &dhcpv6->xfer, SOCK_DGRAM,
&addresses.server.sa,
&addresses.client.sa ) ) != 0 ) {
DBGC ( dhcpv6, "DHCPv6 %s could not open socket: %s\n",
dhcpv6->netdev->name, strerror ( rc ) );
goto err_open_socket;
}
/* Attach parent interface, mortalise self, and return */
intf_plug_plug ( &dhcpv6->job, job );
ref_put ( &dhcpv6->refcnt );
return 0;
err_open_socket:
dhcpv6_finished ( dhcpv6, rc );
err_client_duid:
ref_put ( &dhcpv6->refcnt );
return rc;
}
/** Boot filename setting */
const struct setting filename6_setting __setting ( SETTING_BOOT, filename ) = {
.name = "filename",
.description = "Boot filename",
.tag = DHCPV6_BOOTFILE_URL,
.type = &setting_type_string,
.scope = &dhcpv6_scope,
};
/** DNS search list setting */
const struct setting dnssl6_setting __setting ( SETTING_IP_EXTRA, dnssl ) = {
.name = "dnssl",
.description = "DNS search list",
.tag = DHCPV6_DOMAIN_LIST,
.type = &setting_type_dnssl,
.scope = &dhcpv6_scope,
};
