/* * Copyright (C) 2006 Michael Brown . * * 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. */ #include #include #include #include #include #include #include /** @file * * DHCP options * */ /** List of registered DHCP option blocks */ static LIST_HEAD ( option_blocks ); /** * Obtain value of a numerical DHCP option * * @v option DHCP option, or NULL * @ret value Numerical value of the option, or 0 * * Parses the numerical value from a DHCP option, if present. It is * permitted to call dhcp_num_option() with @c option set to NULL; in * this case 0 will be returned. * * The caller does not specify the size of the DHCP option data; this * is implied by the length field stored within the DHCP option * itself. */ unsigned long dhcp_num_option ( struct dhcp_option *option ) { unsigned long value = 0; uint8_t *data; if ( option ) { /* This is actually smaller code than using htons() * etc., and will also cope well with malformed * options (such as zero-length options). */ for ( data = option->data.bytes ; data < ( option->data.bytes + option->len ) ; data++ ) value = ( ( value << 8 ) | *data ); } return value; } /** * Calculate length of a DHCP option * * @v option DHCP option * @ret len Length (including tag and length field) */ static inline unsigned int dhcp_option_len ( struct dhcp_option *option ) { if ( ( option->tag == DHCP_END ) || ( option->tag == DHCP_PAD ) ) { return 1; } else { return ( option->len + 2 ); } } /** * Find DHCP option within DHCP options block, and its encapsulator (if any) * * @v tag DHCP option tag to search for * @v options DHCP options block * @ret encapsulator Encapsulating option (if applicable, may be NULL) * @ret option DHCP option, or NULL if not found * * Searches for the DHCP option matching the specified tag within the * block of data. Encapsulated options may be searched for by using * DHCP_ENCAP_OPT() to construct the tag value. If the option is an * encapsulated option, and @c encapsulator is non-NULL, it will be * filled in with a pointer to the encapsulating option, if present. * Note that the encapsulating option may be present even if the * encapsulated option is absent, in which case @c encapsulator will * be set but the function will return NULL. * * This routine is designed to be paranoid. It does not assume that * the option data is well-formatted, and so must guard against flaws * such as options missing a @c DHCP_END terminator, or options whose * length would take them beyond the end of the data block. */ static struct dhcp_option * find_dhcp_option_encap ( unsigned int tag, struct dhcp_option_block *options, struct dhcp_option **encapsulator ) { struct dhcp_option *option = options->data; ssize_t remaining = options->len; unsigned int option_len; while ( remaining ) { /* Calculate length of this option. Abort processing * if the length is malformed (i.e. takes us beyond * the end of the data block). */ option_len = dhcp_option_len ( option ); remaining -= option_len; if ( remaining < 0 ) break; /* Check for matching tag */ if ( option->tag == tag ) return option; /* Check for explicit end marker */ if ( option->tag == DHCP_END ) break; /* Check for start of matching encapsulation block */ if ( DHCP_ENCAPSULATOR ( tag ) && ( option->tag == DHCP_ENCAPSULATOR ( tag ) ) ) { /* Continue search within encapsulated option block */ if ( encapsulator ) *encapsulator = option; remaining = option->len; option = ( void * ) &option->data; continue; } option = ( ( ( void * ) option ) + option_len ); } return NULL; } /** * Find DHCP option within DHCP options block * * @v tag DHCP option tag to search for * @v options DHCP options block * @ret option DHCP option, or NULL if not found * * Searches for the DHCP option matching the specified tag within the * block of data. Encapsulated options may be searched for by using * DHCP_ENCAP_OPT() to construct the tag value. */ struct dhcp_option * find_dhcp_option ( unsigned int tag, struct dhcp_option_block *options ) { return find_dhcp_option_encap ( tag, options, NULL ); } /** * Find length of used portion of DHCP options block * * @v options DHCP options block * @ret len Length of used portion of data block * * This searches for the @c DHCP_END marker within the options block. * If found, the length of the used portion of the block (i.e. the * portion containing everything @b before the @c DHCP_END marker, but * excluding the @c DHCP_END marker itself) is returned. * * If no @c DHCP_END marker is present, the length of the whole * options block is returned. */ size_t dhcp_option_block_len ( struct dhcp_option_block *options ) { void *dhcpend; if ( ( dhcpend = find_dhcp_option ( DHCP_END, options ) ) ) { return ( dhcpend - options->data ); } else { return options->len; } } /** * Find DHCP option within all registered DHCP options blocks * * @v tag DHCP option tag to search for * @ret option DHCP option, or NULL if not found * * Searches within all registered DHCP option blocks for the specified * tag. Encapsulated options may be searched for by using * DHCP_ENCAP_OPT() to construct the tag value. * * Where multiple option blocks contain the same DHCP option, the * option from the highest-priority block will be returned. (Priority * of an options block is determined by the value of the @c * DHCP_EB_PRIORITY option within the block, if present; the default * priority is zero). */ struct dhcp_option * find_global_dhcp_option ( unsigned int tag ) { struct dhcp_option_block *options; struct dhcp_option *option; list_for_each_entry ( options, &option_blocks, list ) { if ( ( option = find_dhcp_option ( tag, options ) ) ) return option; } return NULL; } /** * Register DHCP option block * * @v options DHCP option block * * Register a block of DHCP options. */ void register_dhcp_options ( struct dhcp_option_block *options ) { struct dhcp_option_block *existing_options; signed int existing_priority; signed int priority; /* Determine priority of new block */ priority = find_dhcp_num_option ( DHCP_EB_PRIORITY, options ); /* Insert after any existing blocks which have a higher priority */ list_for_each_entry ( existing_options, &option_blocks, list ) { existing_priority = find_dhcp_num_option ( DHCP_EB_PRIORITY, existing_options ); if ( priority > existing_priority ) break; } list_add_tail ( &options->list, &existing_options->list ); } /** * Unregister DHCP option block * * @v options DHCP option block */ void unregister_dhcp_options ( struct dhcp_option_block *options ) { list_del ( &options->list ); } /** * Allocate space for a block of DHCP options * * @v len Maximum length of option block * @ret options Option block, or NULL * * Creates a new DHCP option block and populates it with an empty * options list. This call does not register the options block. */ struct dhcp_option_block * alloc_dhcp_options ( size_t len ) { struct dhcp_option_block *options; struct dhcp_option *option; options = malloc ( sizeof ( *options ) + len ); if ( options ) { options->data = ( ( void * ) options + sizeof ( *options ) ); options->len = len; if ( len ) { option = options->data; option->tag = DHCP_END; } } return options; } /** * Free DHCP options block * * @v options Option block */ void free_dhcp_options ( struct dhcp_option_block *options ) { free ( options ); }