dhcpd.h File Reference

#include <winsock2.h>
#include <iphlpapi.h>
#include "stdint.h"
#include <pshpack1.h>
#include <poppack.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <ctype.h>
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "dhcp.h"
#include "tree.h"

Include dependency graph for dhcpd.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	ether_header
struct	ip
struct	udphdr
struct	option_data
struct	string_list
struct	iaddr
struct	iaddrlist
struct	packet
struct	hardware
struct	client_lease
struct	client_config
struct	client_state
struct	interface_info
struct	timeout
struct	protocol
struct	hash_bucket
struct	hash_table

Macros
#define	IFNAMSIZ   MAX_INTERFACE_NAME_LEN
#define	ETH_ALEN   6
#define	ETHER_ADDR_LEN   ETH_ALEN
#define	IP_RF   0x8000 /* reserved fragment flag */
#define	IP_DF   0x4000 /* dont fragment flag */
#define	IP_MF   0x2000 /* more fragments flag */
#define	IP_OFFMASK   0x1fff /* mask for fragmenting bits */
#define	ETHERTYPE_IP   0x0800
#define	IPTOS_LOWDELAY   0x10
#define	ARPHRD_ETHER   1
#define	SIZE_T_MAX   1600
#define	USE_SOCKET_RECEIVE
#define	USE_SOCKET_SEND
#define	LOCAL_PORT   68
#define	REMOTE_PORT   67
#define	DEFAULT_HASH_SIZE   97
#define	_PATH_DHCLIENT_CONF   "/etc/dhclient.conf"
#define	_PATH_DHCLIENT_DB   "/var/db/dhclient.leases"
#define	DHCPD_LOG_FACILITY   LOG_DAEMON
#define	MAX_TIME   0x7fffffff
#define	MIN_TIME   0

Enumerations
enum	dhcp_state {   S_REBOOTING , S_INIT , S_SELECTING , S_REQUESTING ,   S_BOUND , S_RENEWING , S_REBINDING , S_STATIC ,   S_RELEASED }

Functions
int	cons_options (struct packet *, struct dhcp_packet *, int, struct tree_cache **)
char *	pretty_print_option (unsigned int, unsigned char *, int, int, int)
void	do_packet (struct interface_info *, struct dhcp_packet *, int, unsigned int, struct iaddr, struct hardware *)
void	error (char *,...) __attribute__((__format__(__printf__
void int	warning (char *,...) __attribute__((__format__(__printf__
void int int	note (char *,...) __attribute__((__format__(__printf__
void int int int	debug (char *,...) __attribute__((__format__(__printf__
void int int int int	parse_warn (char *,...) __attribute__((__format__(__printf__
void	new_parse (char *)
int	next_token (char **, FILE *)
int	peek_token (char **, FILE *)
void	skip_to_semi (FILE *)
int	parse_semi (FILE *)
char *	parse_string (FILE *)
int	parse_ip_addr (FILE *, struct iaddr *)
void	parse_hardware_param (FILE *, struct hardware *)
void	parse_lease_time (FILE *, time_t *)
unsigned char *	parse_numeric_aggregate (FILE *, unsigned char *, int *, int, int, int)
void	convert_num (unsigned char *, char *, int, int)
time_t	parse_date (FILE *)
pair	cons (caddr_t, pair)
struct string_list *	new_string_list (size_t size)
struct hash_table *	new_hash_table (int)
struct hash_bucket *	new_hash_bucket (void)
void	dfree (void *, char *)
void	free_hash_bucket (struct hash_bucket *, char *)
int	if_register_bpf (struct interface_info *)
void	if_register_send (struct interface_info *)
void	if_register_receive (struct interface_info *)
ssize_t	send_packet (struct interface_info *, struct dhcp_packet *, size_t, struct in_addr, struct sockaddr_in *, struct hardware *)
ssize_t	receive_packet (struct interface_info *, unsigned char *, size_t, struct sockaddr_in *, struct hardware *)
void	discover_interfaces (struct interface_info *)
void	reinitialize_interfaces (void)
void	dispatch (HANDLE hStopEvent)
void	got_one (struct protocol *)
void	add_timeout (time_t, void(*)(void *), void *)
void	cancel_timeout (void(*)(void *), void *)
void	add_protocol (char *, int, void(*)(struct protocol *), void *)
void	remove_protocol (struct protocol *)
struct protocol *	find_protocol_by_adapter (struct interface_info *)
int	interface_link_status (char *)
struct hash_table *	new_hash (void)
void	add_hash (struct hash_table *, unsigned char *, int, unsigned char *)
unsigned char *	hash_lookup (struct hash_table *, unsigned char *, int)
void	initialize_universes (void)
u_int32_t	getULong (unsigned char *)
int32_t	getLong (unsigned char *)
u_int16_t	getUShort (unsigned char *)
int16_t	getShort (unsigned char *)
void	putULong (unsigned char *, u_int32_t)
void	putLong (unsigned char *, int32_t)
void	putUShort (unsigned char *, unsigned int)
void	putShort (unsigned char *, int)
struct iaddr	subnet_number (struct iaddr, struct iaddr)
struct iaddr	broadcast_addr (struct iaddr, struct iaddr)
int	addr_eq (struct iaddr, struct iaddr)
char *	piaddr (struct iaddr)
void	dhcpoffer (struct packet *)
void	dhcpack (struct packet *)
void	dhcpnak (struct packet *)
void	send_discover (void *)
void	send_request (void *)
void	send_decline (void *)
void	send_release (void *)
void	state_reboot (void *)
void	state_init (void *)
void	state_release (void *)
void	state_selecting (void *)
void	state_requesting (void *)
void	state_bound (void *)
void	state_panic (void *)
void	bind_lease (struct interface_info *)
void	unbind_lease (struct interface_info *)
void	make_discover (struct interface_info *, struct client_lease *)
void	make_request (struct interface_info *, struct client_lease *)
void	make_decline (struct interface_info *, struct client_lease *)
void	make_release (struct interface_info *, struct client_lease *)
void	free_client_lease (struct client_lease *)
void	rewrite_client_leases (struct interface_info *)
void	write_client_lease (struct interface_info *, struct client_lease *, int)
void	priv_script_init (struct interface_info *, char *, char *)
void	priv_script_write_params (struct interface_info *, char *, struct client_lease *)
int	priv_script_go (void)
void	script_init (char *, struct string_list *)
void	script_write_params (char *, struct client_lease *)
int	script_go (void)
void	client_envadd (struct client_state *, const char *, const char *, const char *,...)
void	script_set_env (struct client_state *, const char *, const char *, const char *)
void	script_flush_env (struct client_state *)
int	dhcp_option_ev_name (char *, size_t, struct dhcp_option *)
struct client_lease *	packet_to_lease (struct packet *)
void	go_daemon (void)
void	client_location_changed (void)
void	bootp (struct packet *)
void	dhcp (struct packet *)
void	assemble_hw_header (struct interface_info *, unsigned char *, int *, struct hardware *)
void	assemble_udp_ip_header (unsigned char *, int *, u_int32_t, u_int32_t, unsigned int, unsigned char *, int)
ssize_t	decode_hw_header (unsigned char *, int, struct hardware *)
ssize_t	decode_udp_ip_header (unsigned char *, int, struct sockaddr_in *, unsigned char *, int)
void	assemble_ethernet_header (struct interface_info *, unsigned char *, int *, struct hardware *)
ssize_t	decode_ethernet_header (struct interface_info *, unsigned char *, int, struct hardware *)
int	read_client_conf (struct interface_info *)
void	read_client_leases (void)
void	parse_client_statement (FILE *, struct interface_info *, struct client_config *)
int	parse_X (FILE *, u_int8_t *, int)
int	parse_option_list (FILE *, u_int8_t *)
void	parse_interface_declaration (FILE *, struct client_config *)
struct interface_info *	interface_or_dummy (char *)
void	make_client_state (struct interface_info *)
void	make_client_config (struct interface_info *, struct client_config *)
void	parse_client_lease_statement (FILE *, int)
void	parse_client_lease_declaration (FILE *, struct client_lease *, struct interface_info **)
struct dhcp_option *	parse_option_decl (FILE *, struct option_data *)
void	parse_string_list (FILE *, struct string_list **, int)
void	parse_reject_statement (FILE *, struct client_config *)
struct buf *	buf_open (size_t)
int	buf_add (struct buf *, void *, size_t)
int	buf_close (int, struct buf *)
ssize_t	buf_read (int, void *, size_t)
void	dispatch_imsg (int)

Variables
int	warnings_occurred
void int int int int int	lexline
void int int int int int	lexchar
char *	token_line
char *	tlname
char	comments [4096]
int	comment_index
int	eol_token
void(*	bootp_packet_handler )(struct interface_info *, struct dhcp_packet *, int, unsigned int, struct iaddr, struct hardware *)
struct dhcp_option	dhcp_options [256]
unsigned char	dhcp_option_default_priority_list []
int	sizeof_dhcp_option_default_priority_list
struct hash_table	universe_hash
struct universe	dhcp_universe
char *	path_dhclient_conf
char *	path_dhclient_db
time_t	cur_time
int	log_priority
int	log_perror
struct client_config	top_level_config

Macro Definition Documentation

_PATH_DHCLIENT_CONF

#define _PATH_DHCLIENT_CONF   "/etc/dhclient.conf"

Definition at line 277 of file dhcpd.h.

_PATH_DHCLIENT_DB

#define _PATH_DHCLIENT_DB   "/var/db/dhclient.leases"

Definition at line 278 of file dhcpd.h.

ARPHRD_ETHER

#define ARPHRD_ETHER   1

Definition at line 88 of file dhcpd.h.

DEFAULT_HASH_SIZE

#define DEFAULT_HASH_SIZE   97

Definition at line 262 of file dhcpd.h.

DHCPD_LOG_FACILITY

#define DHCPD_LOG_FACILITY   LOG_DAEMON

Definition at line 279 of file dhcpd.h.

ETH_ALEN

#define ETH_ALEN   6

Definition at line 50 of file dhcpd.h.

ETHER_ADDR_LEN

#define ETHER_ADDR_LEN   ETH_ALEN

Definition at line 51 of file dhcpd.h.

ETHERTYPE_IP

#define ETHERTYPE_IP   0x0800

Definition at line 86 of file dhcpd.h.

IFNAMSIZ

#define IFNAMSIZ   MAX_INTERFACE_NAME_LEN

Definition at line 48 of file dhcpd.h.

IP_DF

#define IP_DF   0x4000 /* dont fragment flag */

Definition at line 70 of file dhcpd.h.

IP_MF

#define IP_MF   0x2000 /* more fragments flag */

Definition at line 71 of file dhcpd.h.

IP_OFFMASK

#define IP_OFFMASK   0x1fff /* mask for fragmenting bits */

Definition at line 72 of file dhcpd.h.

IP_RF

#define IP_RF   0x8000 /* reserved fragment flag */

Definition at line 69 of file dhcpd.h.

IPTOS_LOWDELAY

#define IPTOS_LOWDELAY   0x10

Definition at line 87 of file dhcpd.h.

LOCAL_PORT

#define LOCAL_PORT   68

Definition at line 112 of file dhcpd.h.

MAX_TIME

#define MAX_TIME   0x7fffffff

Definition at line 281 of file dhcpd.h.

MIN_TIME

#define MIN_TIME   0

Definition at line 282 of file dhcpd.h.

REMOTE_PORT

#define REMOTE_PORT   67

Definition at line 113 of file dhcpd.h.

SIZE_T_MAX

#define SIZE_T_MAX   1600

Definition at line 91 of file dhcpd.h.

USE_SOCKET_RECEIVE

#define USE_SOCKET_RECEIVE

Definition at line 93 of file dhcpd.h.

USE_SOCKET_SEND

#define USE_SOCKET_SEND

Definition at line 94 of file dhcpd.h.

Enumeration Type Documentation

dhcp_state

enum dhcp_state

Enumerator
S_REBOOTING
S_INIT
S_SELECTING
S_REQUESTING
S_BOUND
S_RENEWING
S_REBINDING
S_STATIC
S_RELEASED

Definition at line 171 of file dhcpd.h.

                {
    S_REBOOTING,
    S_INIT,
    S_SELECTING,
    S_REQUESTING,
    S_BOUND,
    S_RENEWING,
    S_REBINDING,
    S_STATIC,
    S_RELEASED
};

Function Documentation

add_hash()

void add_hash	(	struct hash_table *	table,
		unsigned char *	name,
		int	len,
		unsigned char *	pointer
	)

Definition at line 82 of file hash.c.

{
    int hashno;
    struct hash_bucket *bp;
 
    if (!table)
        return;
    if (!len)
        len = strlen ((char *)name);
 
    hashno = do_hash (name, len, table -> hash_count);
    bp = new_hash_bucket ();
 
    if (!bp) {
        warn ("Can't add %s to hash table.", name);
        return;
    }
    bp -> name = name;
    bp -> value = pointer;
    bp -> next = table -> buckets [hashno];
    bp -> len = len;
    table -> buckets [hashno] = bp;
}

Referenced by assign_file_addresses(), assign_inodes(), compute_linkcount(), and initialize_universes().

add_protocol()

void add_protocol	(	char *	name,
		int	fd,
		void(*)(struct protocol *)	handler,
		void *	local
	)

Definition at line 342 of file dispatch.c.

{
    struct protocol *p;
 
    p = malloc(sizeof(*p));
    if (!p)
        error("can't allocate protocol struct for %s", name);
 
    p->fd = fd;
    p->handler = handler;
    p->local = local;
    p->next = protocols;
    protocols = p;
}

Referenced by AdapterDiscoveryThread(), Server_AcquireParameters(), and Server_EnableDhcp().

add_timeout()

void add_timeout	(	time_t	when,
		void(*)(void *)	where,
		void *	what
	)

Definition at line 253 of file dispatch.c.

{
    struct timeout *t, *q;
 
    DH_DbgPrint(MID_TRACE,("Adding timeout %x %p %x\n", when, where, what));
    /* See if this timeout supersedes an existing timeout. */
    t = NULL;
    for (q = timeouts; q; q = q->next) {
        if (q->func == where && q->what == what) {
            if (t)
                t->next = q->next;
            else
                timeouts = q->next;
            break;
        }
        t = q;
    }
 
    /* If we didn't supersede a timeout, allocate a timeout
       structure now. */
    if (!q) {
        if (free_timeouts) {
            q = free_timeouts;
            free_timeouts = q->next;
            q->func = where;
            q->what = what;
        } else {
            q = malloc(sizeof(struct timeout));
            if (!q) {
                error("Can't allocate timeout structure!");
                return;
            }
            q->func = where;
            q->what = what;
        }
    }
 
    q->when = when;
 
    /* Now sort this timeout into the timeout list. */
 
    /* Beginning of list? */
    if (!timeouts || timeouts->when > q->when) {
        q->next = timeouts;
        timeouts = q;
        return;
    }
 
    /* Middle of list? */
    for (t = timeouts; t->next; t = t->next) {
        if (t->next->when > q->when) {
            q->next = t->next;
            t->next = q;
            return;
        }
    }
 
    /* End of list. */
    t->next = q;
    q->next = NULL;
}

Referenced by bind_lease(), dhcpoffer(), send_discover(), and send_request().

addr_eq()

int addr_eq	(	struct iaddr	a,
		struct iaddr	b
	)

Definition at line 100 of file util.c.

                                              {
    return a.len == b.len && !memcmp( a.iabuf, b.iabuf, a.len );
}

Referenced by bootp(), and dhcp().

assemble_ethernet_header()

void assemble_ethernet_header	(	struct interface_info *	,
		unsigned char *	,
		int *	,
		struct hardware *
	)

assemble_hw_header()

void assemble_hw_header	(	struct interface_info *	,
		unsigned char *	,
		int *	,
		struct hardware *
	)

assemble_udp_ip_header()

void assemble_udp_ip_header	(	unsigned char *	,
		int *	,
		u_int32_t	,
		u_int32_t	,
		unsigned int	,
		unsigned char *	,
		int
	)

bind_lease()

void bind_lease

(

struct interface_info *

ip

)

Definition at line 700 of file dhclient.c.

{
    PDHCP_ADAPTER Adapter;
    struct client_lease *new_lease = ip->client->new;
    time_t cur_time;
 
    time(&cur_time);
 
    /* Remember the medium. */
    ip->client->new->medium = ip->client->medium;
 
    /* Replace the old active lease with the new one. */
    if (ip->client->active)
        free_client_lease(ip->client->active);
    ip->client->active = ip->client->new;
    ip->client->new = NULL;
 
    /* Set up a timeout to start the renewal process. */
    /* Timeout of zero means no timeout (some implementations seem to use
     * one day).
     */
    if( ip->client->active->renewal - cur_time )
        add_timeout(ip->client->active->renewal, state_bound, ip);
 
    note("bound to %s -- renewal in %ld seconds.",
         piaddr(ip->client->active->address),
         (long int)(ip->client->active->renewal - cur_time));
 
    ip->client->state = S_BOUND;
 
    Adapter = AdapterFindInfo( ip );
 
    if( Adapter )  setup_adapter( Adapter, new_lease );
    else {
        warning("Could not find adapter for info %p\n", ip);
        return;
    }
    set_name_servers( Adapter, new_lease );
    set_domain( Adapter, new_lease );
}

Referenced by dhcpack(), and state_selecting().

bootp()

void bootp

(

struct packet *

packet

)

Definition at line 796 of file dhclient.c.

{
    struct iaddrlist *ap;
 
    if (packet->raw->op != BOOTREPLY)
        return;
 
    /* If there's a reject list, make sure this packet's sender isn't
       on it. */
    for (ap = packet->interface->client->config->reject_list;
        ap; ap = ap->next) {
        if (addr_eq(packet->client_addr, ap->addr)) {
            note("BOOTREPLY from %s rejected.", piaddr(ap->addr));
            return;
        }
    }
    dhcpoffer(packet);
}

Referenced by do_packet().

broadcast_addr()

struct iaddr broadcast_addr	(	struct iaddr	addr,
		struct iaddr	mask
	)

Definition at line 178 of file util.c.

                                                                    {
    struct iaddr bcast = { 0 };
    return bcast;
}

Referenced by priv_script_write_params().

buf_add()

int buf_add	(	struct buf *	,
		void *	,
		size_t
	)

buf_close()

int buf_close	(	int	,
		struct buf *
	)

buf_open()

struct buf * buf_open

(

size_t

)

buf_read()

ssize_t buf_read	(	int	,
		void *	,
		size_t
	)

Referenced by LoadCentralDirectoryRecord().

cancel_timeout()

void cancel_timeout	(	void(*)(void *)	where,
		void *	what
	)

Definition at line 316 of file dispatch.c.

{
    struct timeout *t, *q;
 
    /* Look for this timeout on the list, and unlink it if we find it. */
    t = NULL;
    for (q = timeouts; q; q = q->next) {
        if (q->func == where && q->what == what) {
            if (t)
                t->next = q->next;
            else
                timeouts = q->next;
            break;
        }
        t = q;
    }
 
    /* If we found the timeout, put it on the free list. */
    if (q) {
        q->next = free_timeouts;
        free_timeouts = q;
    }
}

Referenced by dhcpack(), dhcpnak(), dhcpoffer(), send_request(), and state_selecting().

client_envadd()

void client_envadd	(	struct client_state *	,
		const char *	,
		const char *	,
		const char *	,
			...
	)

client_location_changed()

void client_location_changed

(

void

)

cons()

pair cons	(	caddr_t	car,
		pair	cdr
	)

Definition at line 57 of file tree.c.

{
    pair foo = (pair)dmalloc (sizeof *foo, "cons");
    if (!foo)
        error ("no memory for cons.");
    foo -> car = car;
    foo -> cdr = cdr;
    return foo;
}

cons_options()

int cons_options	(	struct packet *	inpacket,
		struct dhcp_packet *	outpacket,
		int	mms,
		struct tree_cache **	options
	)

Definition at line 199 of file options.c.

{
    unsigned char priority_list[300], buffer[4096];
    int priority_len, main_buffer_size, mainbufix;
    int option_size, length;
 
    /*
     * If the client has provided a maximum DHCP message size, use
     * that; otherwise, if it's BOOTP, only 64 bytes; otherwise use
     * up to the minimum IP MTU size (576 bytes).
     *
     * XXX if a BOOTP client specifies a max message size, we will
     * honor it.
     */
    if (!mms &&
        inpacket &&
        inpacket->options[DHO_DHCP_MAX_MESSAGE_SIZE].data &&
        (inpacket->options[DHO_DHCP_MAX_MESSAGE_SIZE].len >=
        sizeof(u_int16_t)))
        mms = getUShort(
            inpacket->options[DHO_DHCP_MAX_MESSAGE_SIZE].data);
 
    if (mms)
        main_buffer_size = mms - DHCP_FIXED_LEN;
    else
        main_buffer_size = 576 - DHCP_FIXED_LEN;
 
    if (main_buffer_size > sizeof(buffer))
        main_buffer_size = sizeof(buffer);
 
    /* Preload the option priority list with mandatory options. */
    priority_len = 0;
    priority_list[priority_len++] = DHO_DHCP_MESSAGE_TYPE;
    priority_list[priority_len++] = DHO_DHCP_SERVER_IDENTIFIER;
    priority_list[priority_len++] = DHO_DHCP_LEASE_TIME;
    priority_list[priority_len++] = DHO_DHCP_MESSAGE;
 
    /*
     * If the client has provided a list of options that it wishes
     * returned, use it to prioritize.  Otherwise, prioritize based
     * on the default priority list.
     */
    if (inpacket &&
        inpacket->options[DHO_DHCP_PARAMETER_REQUEST_LIST].data) {
        int prlen =
            inpacket->options[DHO_DHCP_PARAMETER_REQUEST_LIST].len;
        if (prlen + priority_len > sizeof(priority_list))
            prlen = sizeof(priority_list) - priority_len;
 
        memcpy(&priority_list[priority_len],
            inpacket->options[DHO_DHCP_PARAMETER_REQUEST_LIST].data,
            prlen);
        priority_len += prlen;
    } else {
        memcpy(&priority_list[priority_len],
            dhcp_option_default_priority_list,
            sizeof_dhcp_option_default_priority_list);
        priority_len += sizeof_dhcp_option_default_priority_list;
    }
 
    /* Copy the options into the big buffer... */
    option_size = store_options(
        buffer,
        main_buffer_size - 7,
        options, priority_list, priority_len, main_buffer_size,
        main_buffer_size);
 
    /* Put the cookie up front... */
    memcpy(outpacket->options, DHCP_OPTIONS_COOKIE, 4);
    mainbufix = 4;
 
    /*
     * If we're going to have to overload, store the overload option
     * at the beginning.  If we can, though, just store the whole
     * thing in the packet's option buffer and leave it at that.
     */
    if (option_size <= main_buffer_size - mainbufix) {
        memcpy(&outpacket->options[mainbufix],
            buffer, option_size);
        mainbufix += option_size;
        if (mainbufix < main_buffer_size)
            outpacket->options[mainbufix++] = DHO_END;
        length = DHCP_FIXED_NON_UDP + mainbufix;
    } else {
        outpacket->options[mainbufix++] = DHO_DHCP_OPTION_OVERLOAD;
        outpacket->options[mainbufix++] = 1;
        if (option_size >
            main_buffer_size - mainbufix + DHCP_FILE_LEN)
            outpacket->options[mainbufix++] = 3;
        else
            outpacket->options[mainbufix++] = 1;
 
        memcpy(&outpacket->options[mainbufix],
            buffer, main_buffer_size - mainbufix);
        length = DHCP_FIXED_NON_UDP + mainbufix;
    }
    return (length);
}

Referenced by make_decline(), make_discover(), make_release(), and make_request().

convert_num()

void convert_num	(	unsigned char *	,
		char *	,
		int	,
		int
	)

debug()

void int int int debug	(	char *	,
			...
	)

decode_ethernet_header()

ssize_t decode_ethernet_header	(	struct interface_info *	,
		unsigned char *	,
		int	,
		struct hardware *
	)

decode_hw_header()

ssize_t decode_hw_header	(	unsigned char *	,
		int	,
		struct hardware *
	)

decode_udp_ip_header()

ssize_t decode_udp_ip_header	(	unsigned char *	,
		int	,
		struct sockaddr_in *	,
		unsigned char *	,
		int
	)

dfree()

void dfree	(	void *	ptr,
		char *	name
	)

Definition at line 79 of file alloc.c.

{
    if (!ptr) {
        warning("dfree %s: free on null pointer.", name);
        return;
    }
    free(ptr);
}

Referenced by do_host_lookup(), free_hash_bucket(), tree_concat(), and tree_evaluate().

dhcp()

void dhcp

(

struct packet *

packet

)

Definition at line 816 of file dhclient.c.

{
    struct iaddrlist *ap;
    void (*handler)(struct packet *);
    char *type;
 
    switch (packet->packet_type) {
    case DHCPOFFER:
        handler = dhcpoffer;
        type = "DHCPOFFER";
        break;
    case DHCPNAK:
        handler = dhcpnak;
        type = "DHCPNACK";
        break;
    case DHCPACK:
        handler = dhcpack;
        type = "DHCPACK";
        break;
    default:
        return;
    }
 
    /* If there's a reject list, make sure this packet's sender isn't
       on it. */
    for (ap = packet->interface->client->config->reject_list;
        ap; ap = ap->next) {
        if (addr_eq(packet->client_addr, ap->addr)) {
            note("%s from %s rejected.", type, piaddr(ap->addr));
            return;
        }
    }
    (*handler)(packet);
}

Referenced by do_packet(), and START_TEST().

dhcp_option_ev_name()

int dhcp_option_ev_name	(	char *	buf,
		size_t	buflen,
		struct dhcp_option *	option
	)

Definition at line 2145 of file dhclient.c.

{
    int i;
 
    for (i = 0; option->name[i]; i++) {
        if (i + 1 == buflen)
            return 0;
        if (option->name[i] == '-')
            buf[i] = '_';
        else
            buf[i] = option->name[i];
    }
 
    buf[i] = 0;
    return 1;
}

Referenced by priv_script_write_params().

dhcpack()

void dhcpack

(

struct packet *

packet

)

Definition at line 338 of file dhclient.c.

{
    struct interface_info *ip = packet->interface;
    struct client_lease *lease;
        time_t cur_time;
 
        time(&cur_time);
 
    /* If we're not receptive to an offer right now, or if the offer
       has an unrecognizable transaction id, then just drop it. */
    if (packet->interface->client->xid != packet->raw->xid ||
        (packet->interface->hw_address.hlen != packet->raw->hlen) ||
        (memcmp(packet->interface->hw_address.haddr,
        packet->raw->chaddr, packet->raw->hlen)))
        return;
 
    if (ip->client->state != S_REBOOTING &&
        ip->client->state != S_REQUESTING &&
        ip->client->state != S_RENEWING &&
        ip->client->state != S_REBINDING)
        return;
 
    note("DHCPACK from %s", piaddr(packet->client_addr));
 
    lease = packet_to_lease(packet);
    if (!lease) {
        note("packet_to_lease failed.");
        return;
    }
 
    ip->client->new = lease;
 
    /* Stop resending DHCPREQUEST. */
    cancel_timeout(send_request, ip);
 
    /* Figure out the lease time. */
    if (ip->client->new->options[DHO_DHCP_LEASE_TIME].data)
        ip->client->new->expiry = getULong(
            ip->client->new->options[DHO_DHCP_LEASE_TIME].data);
    else
        ip->client->new->expiry = DHCP_DEFAULT_LEASE_TIME;
    /* A number that looks negative here is really just very large,
       because the lease expiry offset is unsigned. */
    if (ip->client->new->expiry < 0)
        ip->client->new->expiry = TIME_MAX;
    /* XXX should be fixed by resetting the client state */
    if (ip->client->new->expiry < 60)
        ip->client->new->expiry = 60;
 
    /* Take the server-provided renewal time if there is one;
       otherwise figure it out according to the spec. */
    if (ip->client->new->options[DHO_DHCP_RENEWAL_TIME].len)
        ip->client->new->renewal = getULong(
            ip->client->new->options[DHO_DHCP_RENEWAL_TIME].data);
    else
        ip->client->new->renewal = ip->client->new->expiry / 2;
 
    /* Same deal with the rebind time. */
    if (ip->client->new->options[DHO_DHCP_REBINDING_TIME].len)
        ip->client->new->rebind = getULong(
            ip->client->new->options[DHO_DHCP_REBINDING_TIME].data);
    else
        ip->client->new->rebind = ip->client->new->renewal +
            ip->client->new->renewal / 2 + ip->client->new->renewal / 4;
 
#ifdef __REACTOS__
    ip->client->new->lease = ip->client->new->expiry;
    ip->client->new->obtained = cur_time;
#endif
    ip->client->new->expiry += cur_time;
    /* Lease lengths can never be negative. */
    if (ip->client->new->expiry < cur_time)
        ip->client->new->expiry = TIME_MAX;
    ip->client->new->renewal += cur_time;
    if (ip->client->new->renewal < cur_time)
        ip->client->new->renewal = TIME_MAX;
    ip->client->new->rebind += cur_time;
    if (ip->client->new->rebind < cur_time)
        ip->client->new->rebind = TIME_MAX;
 
    bind_lease(ip);
}

Referenced by dhcp().

dhcpnak()

void dhcpnak

(

struct packet *

packet

)

Definition at line 1066 of file dhclient.c.

{
    struct interface_info *ip = packet->interface;
 
    /* If we're not receptive to an offer right now, or if the offer
       has an unrecognizable transaction id, then just drop it. */
    if (packet->interface->client->xid != packet->raw->xid ||
        (packet->interface->hw_address.hlen != packet->raw->hlen) ||
        (memcmp(packet->interface->hw_address.haddr,
        packet->raw->chaddr, packet->raw->hlen)))
        return;
 
    if (ip->client->state != S_REBOOTING &&
        ip->client->state != S_REQUESTING &&
        ip->client->state != S_RENEWING &&
        ip->client->state != S_REBINDING)
        return;
 
    note("DHCPNAK from %s", piaddr(packet->client_addr));
 
    if (!ip->client->active) {
        note("DHCPNAK with no active lease.\n");
        return;
    }
 
    free_client_lease(ip->client->active);
    ip->client->active = NULL;
 
    /* Stop sending DHCPREQUEST packets... */
    cancel_timeout(send_request, ip);
 
    ip->client->state = S_INIT;
    state_init(ip);
}

Referenced by dhcp().

dhcpoffer()

void dhcpoffer

(

struct packet *

packet

)

Definition at line 852 of file dhclient.c.

{
    struct interface_info *ip = packet->interface;
    struct client_lease *lease, *lp;
    int i;
    int arp_timeout_needed = 0;
    time_t stop_selecting;
    char *name = packet->options[DHO_DHCP_MESSAGE_TYPE].len ?
        "DHCPOFFER" : "BOOTREPLY";
        time_t cur_time;
 
        time(&cur_time);
 
    /* If we're not receptive to an offer right now, or if the offer
       has an unrecognizable transaction id, then just drop it. */
    if (ip->client->state != S_SELECTING ||
            packet->interface->client->xid != packet->raw->xid ||
            (packet->interface->hw_address.hlen != packet->raw->hlen) ||
        (memcmp(packet->interface->hw_address.haddr,
        packet->raw->chaddr, packet->raw->hlen)))
        return;
 
    note("%s from %s", name, piaddr(packet->client_addr));
 
 
    /* If this lease doesn't supply the minimum required parameters,
       blow it off. */
    for (i = 0; ip->client->config->required_options[i]; i++) {
        if (!packet->options[ip->client->config->
            required_options[i]].len) {
            note("%s isn't satisfactory.", name);
            return;
        }
    }
 
    /* If we've already seen this lease, don't record it again. */
    for (lease = ip->client->offered_leases;
        lease; lease = lease->next) {
        if (lease->address.len == sizeof(packet->raw->yiaddr) &&
            !memcmp(lease->address.iabuf,
            &packet->raw->yiaddr, lease->address.len)) {
            debug("%s already seen.", name);
            return;
        }
    }
 
    lease = packet_to_lease(packet);
    if (!lease) {
        note("packet_to_lease failed.");
        return;
    }
 
    /* If this lease was acquired through a BOOTREPLY, record that
       fact. */
    if (!packet->options[DHO_DHCP_MESSAGE_TYPE].len)
        lease->is_bootp = 1;
 
    /* Record the medium under which this lease was offered. */
    lease->medium = ip->client->medium;
 
    /* Send out an ARP Request for the offered IP address. */
        if( !check_arp( ip, lease ) ) {
            note("Arp check failed\n");
            return;
        }
 
    /* Figure out when we're supposed to stop selecting. */
    stop_selecting =
        ip->client->first_sending + ip->client->config->select_interval;
 
    /* If this is the lease we asked for, put it at the head of the
       list, and don't mess with the arp request timeout. */
    if (lease->address.len == ip->client->requested_address.len &&
        !memcmp(lease->address.iabuf,
        ip->client->requested_address.iabuf,
        ip->client->requested_address.len)) {
        lease->next = ip->client->offered_leases;
        ip->client->offered_leases = lease;
    } else {
        /* If we already have an offer, and arping for this
           offer would take us past the selection timeout,
           then don't extend the timeout - just hope for the
           best. */
        if (ip->client->offered_leases &&
            (cur_time + arp_timeout_needed) > stop_selecting)
            arp_timeout_needed = 0;
 
        /* Put the lease at the end of the list. */
        lease->next = NULL;
        if (!ip->client->offered_leases)
            ip->client->offered_leases = lease;
        else {
            for (lp = ip->client->offered_leases; lp->next;
                lp = lp->next)
                ;   /* nothing */
            lp->next = lease;
        }
    }
 
    /* If we're supposed to stop selecting before we've had time
       to wait for the ARPREPLY, add some delay to wait for
       the ARPREPLY. */
    if (stop_selecting - cur_time < arp_timeout_needed)
        stop_selecting = cur_time + arp_timeout_needed;
 
    /* If the selecting interval has expired, go immediately to
       state_selecting().  Otherwise, time out into
       state_selecting at the select interval. */
    if (stop_selecting <= 0)
        state_selecting(ip);
    else {
        add_timeout(stop_selecting, state_selecting, ip);
        cancel_timeout(send_discover, ip);
    }
}

Referenced by bootp(), and dhcp().

discover_interfaces()

void discover_interfaces

(

struct interface_info *

)

dispatch()

void dispatch

(

HANDLE

hStopEvent

)

Definition at line 70 of file dispatch.c.

{
    int count, to_msec;
    struct protocol *l;
    time_t howlong, cur_time;
    HANDLE Events[3];
    int EventCount = 2;
 
    Events[0] = hAdapterStateChangedEvent;
    Events[1] = hStopEvent;
    Events[2] = WSA_INVALID_EVENT;
 
    ApiLock();
 
    do {
        /*
         * Call any expired timeouts, and then if there's still
         * a timeout registered, time out the select call then.
         */
        time(&cur_time);
 
        if (timeouts)
        {
            struct timeout *t;
 
            if (timeouts->when <= cur_time) {
                t = timeouts;
                timeouts = timeouts->next;
                (*(t->func))(t->what);
                t->next = free_timeouts;
                free_timeouts = t;
                continue;
            }
 
            /*
             * Figure timeout in milliseconds, and check for
             * potential overflow, so we can cram into an
             * int for poll, while not polling with a
             * negative timeout and blocking indefinitely.
             */
            howlong = timeouts->when - cur_time;
            if (howlong > INT_MAX / 1000)
                howlong = INT_MAX / 1000;
            to_msec = howlong * 1000;
        }
        else
        {
            to_msec = INFINITE;
        }
 
        if (Events[2] == WSA_INVALID_EVENT && DhcpSocket != INVALID_SOCKET)
        {
            Events[2] = WSACreateEvent();
            if (Events[2] != WSA_INVALID_EVENT)
            {
                count = WSAEventSelect(DhcpSocket, Events[2], FD_READ | FD_CLOSE);
                if (count != NO_ERROR)
                {
                    WSACloseEvent(Events[2]);
                    Events[2] = WSA_INVALID_EVENT;
                }
                else
                {
                    EventCount = 3;
                }
            }
        }
        else if (Events[2] != WSA_INVALID_EVENT && DhcpSocket == INVALID_SOCKET)
        {
            WSACloseEvent(Events[2]);
            Events[2] = WSA_INVALID_EVENT;
 
            EventCount = 2;
        }
 
        ApiUnlock();
        count = WaitForMultipleObjects(EventCount,
                                       Events,
                                       FALSE,
                                       to_msec);
        ApiLock();
        if (count == WAIT_OBJECT_0)
        {
            /* Adapter state change */
            continue;
        }
        else if (count == WAIT_OBJECT_0 + 1)
        {
            /* Stop event signalled */
            DPRINT("Dispatch thread stop event!\n");
            break;
        }
        else if (count == WAIT_OBJECT_0 + 2)
        {
            /* Packet received */
 
            /* WSA events are manual reset events */
            WSAResetEvent(Events[2]);
        }
        else
        {
            /* Timeout */
            continue;
        }
 
        for (l = protocols; l; l = l->next) {
            struct interface_info *ip;
            ip = l->local;
            if (ip && (l->handler != got_one ||
                        !ip->dead)) {
                DH_DbgPrint(MID_TRACE,("Handling %x\n", l));
                (*(l->handler))(l);
            }
        }
    } while (1);
 
    WSACloseEvent(Events[2]);
 
    ApiUnlock();
 
    DPRINT("Dispatch thread stopped!\n");
}

Referenced by __CxxFrameHandler(), create_database(), create_list(), create_view(), cxx_frame_handler(), cxx_local_unwind(), CxxHandleV8Frame(), database_invoke(), dispinterface_create_stub(), find_catch_block(), ICreateTypeInfo2_fnSetTypeFlags(), init_test_dispatch(), InstallerImpl_OpenDatabase(), InstallerImpl_OpenPackage(), InstallerImpl_Products(), InstallerImpl_RelatedProducts(), InstallerImpl_SummaryInformation(), main(), run_script(), ServiceMain(), session_invoke(), svc_create(), svc_reg(), svc_tp_create(), test_CreateTypeLib(), test_IConnectionPoint(), test_IWinHttpRequest_Invoke(), test_ParseDisplayName(), test_recinfo(), test_VarCat(), and test_VarUI1FromDisp().

dispatch_imsg()

void dispatch_imsg

(

int

)

do_packet()

void do_packet	(	struct interface_info *	interface,
		struct dhcp_packet *	packet,
		int	len,
		unsigned int	from_port,
		struct iaddr	from,
		struct hardware *	hfrom
	)

Definition at line 635 of file options.c.

{
    struct packet tp;
    int i;
 
    if (packet->hlen > sizeof(packet->chaddr)) {
        note("Discarding packet with invalid hlen.");
        return;
    }
 
    memset(&tp, 0, sizeof(tp));
    tp.raw = packet;
    tp.packet_length = len;
    tp.client_port = from_port;
    tp.client_addr = from;
    tp.interface = interface;
    tp.haddr = hfrom;
 
    parse_options(&tp);
    if (tp.options_valid &&
        tp.options[DHO_DHCP_MESSAGE_TYPE].data)
        tp.packet_type = tp.options[DHO_DHCP_MESSAGE_TYPE].data[0];
    if (tp.packet_type)
        dhcp(&tp);
    else
        bootp(&tp);
 
    /* Free the data associated with the options. */
    for (i = 0; i < 256; i++)
        if (tp.options[i].len && tp.options[i].data)
            free(tp.options[i].data);
}

Referenced by init_client().

error()

void error	(	char *	format,
			...
	)

Definition at line 128 of file uimain.c.

{
  va_list ap;
  char text[512];
  char text1[512];
 
  sprintf(text1, "ERROR: ");
  va_start(ap, format);
  vsprintf(text, format, ap);
  va_end(ap);
  strcat(text1, text);
  mi_error(text1);
}

find_protocol_by_adapter()

struct protocol * find_protocol_by_adapter

(

struct interface_info *

info

)

Definition at line 412 of file dispatch.c.

{
    struct protocol *p;
 
    for( p = protocols; p; p = p->next ) {
        if( p->local == (void *)info ) return p;
    }
 
    return NULL;
}

Referenced by AdapterDiscoveryThread(), IsReconnectHackNeeded(), Server_AcquireParameters(), Server_EnableDhcp(), Server_ReleaseParameters(), and Server_StaticRefreshParams().

free_client_lease()

void free_client_lease

(

struct client_lease *

lease

)

Definition at line 1893 of file dhclient.c.

{
    int i;
 
    if (lease->server_name)
        free(lease->server_name);
    if (lease->filename)
        free(lease->filename);
    for (i = 0; i < 256; i++) {
        if (lease->options[i].len)
            free(lease->options[i].data);
    }
    free(lease);
}

Referenced by bind_lease(), dhcpnak(), packet_to_lease(), state_selecting(), and unbind_lease().

free_hash_bucket()

void free_hash_bucket	(	struct hash_bucket *	ptr,
		char *	name
	)

Definition at line 89 of file alloc.c.

{
    dfree(ptr, name);
}

Referenced by delete_hash_entry().

getLong()

int32_t getLong

(

unsigned char *

data

)

Definition at line 92 of file util.c.

                                       {
       return (int32_t) ntohl(*(u_int32_t*) data);
}

Referenced by pretty_print_option().

getShort()

int16_t getShort

(

unsigned char *

data

)

Definition at line 84 of file util.c.

                                        {
    return (int16_t) ntohs(*(int16_t*) data);
}

Referenced by pretty_print_option().

getULong()

u_int32_t getULong

(

unsigned char *

data

)

Definition at line 96 of file util.c.

                                          {
       return ntohl(*(u_int32_t*)data);
}

Referenced by dhcpack(), and pretty_print_option().

getUShort()

u_int16_t getUShort

(

unsigned char *

data

)

Definition at line 88 of file util.c.

                                           {
    return (u_int16_t) ntohs(*(u_int16_t*) data);
}

Referenced by cons_options(), and pretty_print_option().

go_daemon()

void go_daemon

(

void

)

got_one()

void got_one

(

struct protocol *

l

)

Definition at line 194 of file dispatch.c.

{
    struct sockaddr_in from;
    struct hardware hfrom;
    struct iaddr ifrom;
    ssize_t result;
    union {
        /*
         * Packet input buffer.  Must be as large as largest
         * possible MTU.
         */
        unsigned char packbuf[4095];
        struct dhcp_packet packet;
    } u;
    struct interface_info *ip = l->local;
    PDHCP_ADAPTER adapter;
 
    if ((result = receive_packet(ip, u.packbuf, sizeof(u), &from,
                                 &hfrom)) == -1) {
        warning("receive_packet failed on %s: %d", ip->name,
                WSAGetLastError());
        ip->errors++;
        if (ip->errors > 20) {
            /* our interface has gone away. */
            warning("Interface %s no longer appears valid.",
                    ip->name);
            ip->dead = 1;
            closesocket(l->fd);
            remove_protocol(l);
            adapter = AdapterFindInfo(ip);
            if (adapter) {
                RemoveEntryList(&adapter->ListEntry);
                free(adapter);
            }
        }
        return;
    }
    if (result == 0)
        return;
 
    if (bootp_packet_handler) {
        ifrom.len = 4;
        memcpy(ifrom.iabuf, &from.sin_addr, ifrom.len);
 
        
        adapter = AdapterFindByHardwareAddress(u.packet.chaddr,
                                               u.packet.hlen);
 
        if (!adapter) {
            warning("Discarding packet with a non-matching target physical address\n");
            return;
        }
 
        (*bootp_packet_handler)(&adapter->DhclientInfo, &u.packet, result,
                                from.sin_port, ifrom, &hfrom);
    }
}

Referenced by AdapterDiscoveryThread(), dispatch(), Server_AcquireParameters(), Server_EnableDhcp(), and slurpstring().

hash_lookup()

unsigned char * hash_lookup	(	struct hash_table *	table,
		unsigned char *	name,
		int	len
	)

Definition at line 144 of file hash.c.

{
    int hashno;
    struct hash_bucket *bp;
 
    if (!table)
        return (unsigned char *)0;
 
    if (!len)
        len = strlen ((char *)name);
 
    hashno = do_hash (name, len, table -> hash_count);
 
    for (bp = table -> buckets [hashno]; bp; bp = bp -> next) {
        if (len == bp -> len && !memcmp (bp -> name, name, len))
            return bp -> value;
    }
    return (unsigned char *)0;
}

if_register_bpf()

int if_register_bpf

(

struct interface_info *

)

if_register_receive()

void if_register_receive

(

struct interface_info *

ip

)

Definition at line 687 of file adapter.c.

                                                    {
}

if_register_send()

void if_register_send

(

struct interface_info *

ip

)

Definition at line 683 of file adapter.c.

                                                 {
 
}

initialize_universes()

void initialize_universes

(

void

)

Definition at line 674 of file tables.c.

{
    int i;
 
    dhcp_universe.name = "dhcp";
    dhcp_universe.hash = new_hash ();
    if (!dhcp_universe.hash)
        error ("Can't allocate dhcp option hash table.");
    for (i = 0; i < 256; i++) {
        dhcp_universe.options [i] = &dhcp_options [i];
        add_hash (dhcp_universe.hash,
              (unsigned char *)dhcp_options [i].name, 0,
              (unsigned char *)&dhcp_options [i]);
    }
    universe_hash.hash_count = DEFAULT_HASH_SIZE;
    add_hash (&universe_hash,
          (unsigned char *)dhcp_universe.name, 0,
          (unsigned char *)&dhcp_universe);
}

interface_link_status()

int interface_link_status

(

char *

ifname

)

Definition at line 424 of file dispatch.c.

{
    return (1);
}

interface_or_dummy()

struct interface_info * interface_or_dummy

(

char *

)

make_client_config()

void make_client_config	(	struct interface_info *	,
		struct client_config *
	)

make_client_state()

void make_client_state

(

struct interface_info *

)

make_decline()

void make_decline	(	struct interface_info *	ip,
		struct client_lease *	lease
	)

Definition at line 1755 of file dhclient.c.

{
    struct tree_cache *options[256], message_type_tree;
    struct tree_cache requested_address_tree;
    struct tree_cache server_id_tree, client_id_tree;
    unsigned char decline = DHCPDECLINE;
    int i;
 
    memset(options, 0, sizeof(options));
    memset(&ip->client->packet, 0, sizeof(ip->client->packet));
 
    /* Set DHCP_MESSAGE_TYPE to DHCPDECLINE */
    i = DHO_DHCP_MESSAGE_TYPE;
    options[i] = &message_type_tree;
    options[i]->value = &decline;
    options[i]->len = sizeof(decline);
    options[i]->buf_size = sizeof(decline);
    options[i]->timeout = 0xFFFFFFFF;
 
    /* Send back the server identifier... */
    i = DHO_DHCP_SERVER_IDENTIFIER;
    options[i] = &server_id_tree;
    options[i]->value = lease->options[i].data;
    options[i]->len = lease->options[i].len;
    options[i]->buf_size = lease->options[i].len;
    options[i]->timeout = 0xFFFFFFFF;
 
    /* Send back the address we're declining. */
    i = DHO_DHCP_REQUESTED_ADDRESS;
    options[i] = &requested_address_tree;
    options[i]->value = lease->address.iabuf;
    options[i]->len = lease->address.len;
    options[i]->buf_size = lease->address.len;
    options[i]->timeout = 0xFFFFFFFF;
 
    /* Send the uid if the user supplied one. */
    i = DHO_DHCP_CLIENT_IDENTIFIER;
    if (ip->client->config->send_options[i].len) {
        options[i] = &client_id_tree;
        options[i]->value = ip->client->config->send_options[i].data;
        options[i]->len = ip->client->config->send_options[i].len;
        options[i]->buf_size = ip->client->config->send_options[i].len;
        options[i]->timeout = 0xFFFFFFFF;
    }
 
 
    /* Set up the option buffer... */
    ip->client->packet_length = cons_options(NULL, &ip->client->packet, 0,
        options);
    if (ip->client->packet_length < BOOTP_MIN_LEN)
        ip->client->packet_length = BOOTP_MIN_LEN;
 
    ip->client->packet.op = BOOTREQUEST;
    ip->client->packet.htype = ip->hw_address.htype;
    ip->client->packet.hlen = ip->hw_address.hlen;
    ip->client->packet.hops = 0;
    ip->client->packet.xid = ip->client->xid;
    ip->client->packet.secs = 0; /* Filled in by send_request. */
    ip->client->packet.flags = 0;
 
    /* ciaddr must always be zero. */
    memset(&ip->client->packet.ciaddr, 0,
        sizeof(ip->client->packet.ciaddr));
    memset(&ip->client->packet.yiaddr, 0,
        sizeof(ip->client->packet.yiaddr));
    memset(&ip->client->packet.siaddr, 0,
        sizeof(ip->client->packet.siaddr));
    memset(&ip->client->packet.giaddr, 0,
        sizeof(ip->client->packet.giaddr));
    memcpy(ip->client->packet.chaddr,
        ip->hw_address.haddr, ip->hw_address.hlen);
}

make_discover()

void make_discover	(	struct interface_info *	ip,
		struct client_lease *	lease
	)

Definition at line 1570 of file dhclient.c.

{
    unsigned char discover = DHCPDISCOVER;
    struct tree_cache *options[256];
    struct tree_cache option_elements[256];
    int i;
    ULONG foo = (ULONG) GetTickCount();
 
    memset(option_elements, 0, sizeof(option_elements));
    memset(options, 0, sizeof(options));
    memset(&ip->client->packet, 0, sizeof(ip->client->packet));
 
    /* Set DHCP_MESSAGE_TYPE to DHCPDISCOVER */
    i = DHO_DHCP_MESSAGE_TYPE;
    options[i] = &option_elements[i];
    options[i]->value = &discover;
    options[i]->len = sizeof(discover);
    options[i]->buf_size = sizeof(discover);
    options[i]->timeout = 0xFFFFFFFF;
 
    /* Request the options we want */
    i  = DHO_DHCP_PARAMETER_REQUEST_LIST;
    options[i] = &option_elements[i];
    options[i]->value = ip->client->config->requested_options;
    options[i]->len = ip->client->config->requested_option_count;
    options[i]->buf_size =
        ip->client->config->requested_option_count;
    options[i]->timeout = 0xFFFFFFFF;
 
    /* If we had an address, try to get it again. */
    if (lease) {
        ip->client->requested_address = lease->address;
        i = DHO_DHCP_REQUESTED_ADDRESS;
        options[i] = &option_elements[i];
        options[i]->value = lease->address.iabuf;
        options[i]->len = lease->address.len;
        options[i]->buf_size = lease->address.len;
        options[i]->timeout = 0xFFFFFFFF;
    } else
        ip->client->requested_address.len = 0;
 
    /* Send any options requested in the config file. */
    for (i = 0; i < 256; i++)
        if (!options[i] &&
            ip->client->config->send_options[i].data) {
            options[i] = &option_elements[i];
            options[i]->value =
                ip->client->config->send_options[i].data;
            options[i]->len =
                ip->client->config->send_options[i].len;
            options[i]->buf_size =
                ip->client->config->send_options[i].len;
            options[i]->timeout = 0xFFFFFFFF;
        }
 
    /* Set up the option buffer... */
    ip->client->packet_length = cons_options(NULL, &ip->client->packet, 0,
        options);
    if (ip->client->packet_length < BOOTP_MIN_LEN)
        ip->client->packet_length = BOOTP_MIN_LEN;
 
    ip->client->packet.op = BOOTREQUEST;
    ip->client->packet.htype = ip->hw_address.htype;
    ip->client->packet.hlen = ip->hw_address.hlen;
    ip->client->packet.hops = 0;
    ip->client->packet.xid = RtlRandom(&foo);
    ip->client->packet.secs = 0; /* filled in by send_discover. */
    ip->client->packet.flags = 0;
 
    memset(&(ip->client->packet.ciaddr),
        0, sizeof(ip->client->packet.ciaddr));
    memset(&(ip->client->packet.yiaddr),
        0, sizeof(ip->client->packet.yiaddr));
    memset(&(ip->client->packet.siaddr),
        0, sizeof(ip->client->packet.siaddr));
    memset(&(ip->client->packet.giaddr),
        0, sizeof(ip->client->packet.giaddr));
    memcpy(ip->client->packet.chaddr,
        ip->hw_address.haddr, ip->hw_address.hlen);
}

Referenced by state_init().

make_release()

void make_release	(	struct interface_info *	ip,
		struct client_lease *	lease
	)

Definition at line 1829 of file dhclient.c.

{
    struct tree_cache *options[256], message_type_tree;
    struct tree_cache server_id_tree, client_id_tree;
    unsigned char release = DHCPRELEASE;
    int i;
 
    memset(options, 0, sizeof(options));
    memset(&ip->client->packet, 0, sizeof(ip->client->packet));
 
    /* Set DHCP_MESSAGE_TYPE to DHCPRELEASE */
    i = DHO_DHCP_MESSAGE_TYPE;
    options[i] = &message_type_tree;
    options[i]->value = &release;
    options[i]->len = sizeof(release);
    options[i]->buf_size = sizeof(release);
    options[i]->timeout = 0xFFFFFFFF;
 
    /* Send back the server identifier... */
    i = DHO_DHCP_SERVER_IDENTIFIER;
    options[i] = &server_id_tree;
    options[i]->value = lease->options[i].data;
    options[i]->len = lease->options[i].len;
    options[i]->buf_size = lease->options[i].len;
    options[i]->timeout = 0xFFFFFFFF;
 
    /* Send the uid if the user supplied one. */
    i = DHO_DHCP_CLIENT_IDENTIFIER;
    if (ip->client->config->send_options[i].len)
    {
        options[i] = &client_id_tree;
        options[i]->value = ip->client->config->send_options[i].data;
        options[i]->len = ip->client->config->send_options[i].len;
        options[i]->buf_size = ip->client->config->send_options[i].len;
        options[i]->timeout = 0xFFFFFFFF;
    }
 
    /* Set up the option buffer... */
    ip->client->packet_length = cons_options(NULL, &ip->client->packet, 0, options);
    if (ip->client->packet_length < BOOTP_MIN_LEN)
        ip->client->packet_length = BOOTP_MIN_LEN;
 
    ip->client->packet.op = BOOTREQUEST;
    ip->client->packet.htype = ip->hw_address.htype;
    ip->client->packet.hlen = ip->hw_address.hlen;
    ip->client->packet.hops = 0;
    ip->client->packet.xid = 0;
    ip->client->packet.secs = 0;
    ip->client->packet.flags = 0;
 
    /* ciaddr is the address to be released */
    memcpy(&ip->client->packet.ciaddr,
        lease->address.iabuf, lease->address.len);
    memset(&ip->client->packet.yiaddr, 0,
        sizeof(ip->client->packet.yiaddr));
    memset(&ip->client->packet.siaddr, 0,
        sizeof(ip->client->packet.siaddr));
    memset(&ip->client->packet.giaddr, 0,
        sizeof(ip->client->packet.giaddr));
    memcpy(ip->client->packet.chaddr,
        ip->hw_address.haddr, ip->hw_address.hlen);
}

Referenced by state_release().

make_request()

void make_request	(	struct interface_info *	ip,
		struct client_lease *	lease
	)

Definition at line 1653 of file dhclient.c.

{
    unsigned char request = DHCPREQUEST;
    struct tree_cache *options[256];
    struct tree_cache option_elements[256];
    int i;
 
    memset(options, 0, sizeof(options));
    memset(&ip->client->packet, 0, sizeof(ip->client->packet));
 
    /* Set DHCP_MESSAGE_TYPE to DHCPREQUEST */
    i = DHO_DHCP_MESSAGE_TYPE;
    options[i] = &option_elements[i];
    options[i]->value = &request;
    options[i]->len = sizeof(request);
    options[i]->buf_size = sizeof(request);
    options[i]->timeout = 0xFFFFFFFF;
 
    /* Request the options we want */
    i = DHO_DHCP_PARAMETER_REQUEST_LIST;
    options[i] = &option_elements[i];
    options[i]->value = ip->client->config->requested_options;
    options[i]->len = ip->client->config->requested_option_count;
    options[i]->buf_size =
        ip->client->config->requested_option_count;
    options[i]->timeout = 0xFFFFFFFF;
 
    /* If we are requesting an address that hasn't yet been assigned
       to us, use the DHCP Requested Address option. */
    if (ip->client->state == S_REQUESTING) {
        /* Send back the server identifier... */
        i = DHO_DHCP_SERVER_IDENTIFIER;
        options[i] = &option_elements[i];
        options[i]->value = lease->options[i].data;
        options[i]->len = lease->options[i].len;
        options[i]->buf_size = lease->options[i].len;
        options[i]->timeout = 0xFFFFFFFF;
    }
    if (ip->client->state == S_REQUESTING ||
        ip->client->state == S_REBOOTING) {
        ip->client->requested_address = lease->address;
        i = DHO_DHCP_REQUESTED_ADDRESS;
        options[i] = &option_elements[i];
        options[i]->value = lease->address.iabuf;
        options[i]->len = lease->address.len;
        options[i]->buf_size = lease->address.len;
        options[i]->timeout = 0xFFFFFFFF;
    } else
        ip->client->requested_address.len = 0;
 
    /* Send any options requested in the config file. */
    for (i = 0; i < 256; i++)
        if (!options[i] &&
            ip->client->config->send_options[i].data) {
            options[i] = &option_elements[i];
            options[i]->value =
                ip->client->config->send_options[i].data;
            options[i]->len =
                ip->client->config->send_options[i].len;
            options[i]->buf_size =
                ip->client->config->send_options[i].len;
            options[i]->timeout = 0xFFFFFFFF;
        }
 
    /* Set up the option buffer... */
    ip->client->packet_length = cons_options(NULL, &ip->client->packet, 0,
        options);
    if (ip->client->packet_length < BOOTP_MIN_LEN)
        ip->client->packet_length = BOOTP_MIN_LEN;
 
    ip->client->packet.op = BOOTREQUEST;
    ip->client->packet.htype = ip->hw_address.htype;
    ip->client->packet.hlen = ip->hw_address.hlen;
    ip->client->packet.hops = 0;
    ip->client->packet.xid = ip->client->xid;
    ip->client->packet.secs = 0; /* Filled in by send_request. */
 
    /* If we own the address we're requesting, put it in ciaddr;
       otherwise set ciaddr to zero. */
    if (ip->client->state == S_BOUND ||
        ip->client->state == S_RENEWING ||
        ip->client->state == S_REBINDING) {
        memcpy(&ip->client->packet.ciaddr,
            lease->address.iabuf, lease->address.len);
        ip->client->packet.flags = 0;
    } else {
        memset(&ip->client->packet.ciaddr, 0,
            sizeof(ip->client->packet.ciaddr));
        ip->client->packet.flags = 0;
    }
 
    memset(&ip->client->packet.yiaddr, 0,
        sizeof(ip->client->packet.yiaddr));
    memset(&ip->client->packet.siaddr, 0,
        sizeof(ip->client->packet.siaddr));
    memset(&ip->client->packet.giaddr, 0,
        sizeof(ip->client->packet.giaddr));
    memcpy(ip->client->packet.chaddr,
        ip->hw_address.haddr, ip->hw_address.hlen);
}

Referenced by state_bound(), state_reboot(), and state_selecting().

new_hash()

struct hash_table * new_hash

(

void

)

Definition at line 53 of file hash.c.

{
    struct hash_table *rv = new_hash_table (DEFAULT_HASH_SIZE);
    if (!rv)
        return rv;
    memset (&rv -> buckets [0], 0,
        DEFAULT_HASH_SIZE * sizeof (struct hash_bucket *));
    return rv;
}

Referenced by initialize_universes(), and test_put_hash().

new_hash_bucket()

struct hash_bucket * new_hash_bucket

(

void

)

Definition at line 71 of file alloc.c.

{
    struct hash_bucket *rval = calloc(1, sizeof(struct hash_bucket));
 
    return (rval);
}

Referenced by add_hash().

new_hash_table()

struct hash_table * new_hash_table

(

int

count

)

Definition at line 57 of file alloc.c.

{
    struct hash_table *rval;
 
    rval = calloc(1, sizeof(struct hash_table) -
        (DEFAULT_HASH_SIZE * sizeof(struct hash_bucket *)) +
        (count * sizeof(struct hash_bucket *)));
    if (rval == NULL)
        return (NULL);
    rval->hash_count = count;
    return (rval);
}

Referenced by new_hash().

new_parse()

void new_parse

(

char *

)

new_string_list()

struct string_list * new_string_list

(

size_t

size

)

Definition at line 46 of file alloc.c.

{
    struct string_list *rval;
 
    rval = calloc(1, sizeof(struct string_list) + size);
    if (rval != NULL)
        rval->string = ((char *)rval) + sizeof(struct string_list);
    return (rval);
}

next_token()

int next_token	(	char **	,
		FILE *
	)

Referenced by get_token(), and wcstok_s().

note()

void int int note	(	char *	,
			...
	)

packet_to_lease()

struct client_lease * packet_to_lease

(

struct packet *

packet

)

Definition at line 972 of file dhclient.c.

{
    struct client_lease *lease;
    int i;
 
    lease = malloc(sizeof(struct client_lease));
 
    if (!lease) {
        warning("dhcpoffer: no memory to record lease.");
        return (NULL);
    }
 
    memset(lease, 0, sizeof(*lease));
 
    /* Copy the lease options. */
    for (i = 0; i < 256; i++) {
        if (packet->options[i].len) {
            lease->options[i].data =
                malloc(packet->options[i].len + 1);
            if (!lease->options[i].data) {
                warning("dhcpoffer: no memory for option %d", i);
                free_client_lease(lease);
                return (NULL);
            } else {
                memcpy(lease->options[i].data,
                    packet->options[i].data,
                    packet->options[i].len);
                lease->options[i].len =
                    packet->options[i].len;
                lease->options[i].data[lease->options[i].len] =
                    0;
            }
            if (!check_option(lease,i)) {
                /* ignore a bogus lease offer */
                warning("Invalid lease option - ignoring offer");
                free_client_lease(lease);
                return (NULL);
            }
        }
    }
 
    lease->address.len = sizeof(packet->raw->yiaddr);
    memcpy(lease->address.iabuf, &packet->raw->yiaddr, lease->address.len);
#ifdef __REACTOS__
    if (packet->raw->siaddr.S_un.S_addr == 0)
    {
        lease->serveraddress.len = packet->client_addr.len;
        memcpy(lease->serveraddress.iabuf, &packet->client_addr.iabuf, packet->client_addr.len);
    }
    else
    {
        lease->serveraddress.len = sizeof(packet->raw->siaddr);
        memcpy(lease->serveraddress.iabuf, &packet->raw->siaddr, lease->serveraddress.len);
    }
#endif
 
    /* If the server name was filled out, copy it. */
    if ((!packet->options[DHO_DHCP_OPTION_OVERLOAD].len ||
        !(packet->options[DHO_DHCP_OPTION_OVERLOAD].data[0] & 2)) &&
        packet->raw->sname[0]) {
        lease->server_name = malloc(DHCP_SNAME_LEN + 1);
        if (!lease->server_name) {
            warning("dhcpoffer: no memory for server name.");
            free_client_lease(lease);
            return (NULL);
        }
        memcpy(lease->server_name, packet->raw->sname, DHCP_SNAME_LEN);
        lease->server_name[DHCP_SNAME_LEN]='\0';
        if (!res_hnok(lease->server_name) ) {
            warning("Bogus server name %s",  lease->server_name );
            free_client_lease(lease);
            return (NULL);
        }
 
    }
 
    /* Ditto for the filename. */
    if ((!packet->options[DHO_DHCP_OPTION_OVERLOAD].len ||
        !(packet->options[DHO_DHCP_OPTION_OVERLOAD].data[0] & 1)) &&
        packet->raw->file[0]) {
        /* Don't count on the NUL terminator. */
        lease->filename = malloc(DHCP_FILE_LEN + 1);
        if (!lease->filename) {
            warning("dhcpoffer: no memory for filename.");
            free_client_lease(lease);
            return (NULL);
        }
        memcpy(lease->filename, packet->raw->file, DHCP_FILE_LEN);
        lease->filename[DHCP_FILE_LEN]='\0';
    }
    return lease;
}

Referenced by dhcpack(), and dhcpoffer().

parse_client_lease_declaration()

void parse_client_lease_declaration	(	FILE *	,
		struct client_lease *	,
		struct interface_info **
	)

parse_client_lease_statement()

void parse_client_lease_statement	(	FILE *	,
		int
	)

parse_client_statement()

void parse_client_statement	(	FILE *	,
		struct interface_info *	,
		struct client_config *
	)

parse_date()

time_t parse_date

(

FILE *

)

parse_hardware_param()

void parse_hardware_param	(	FILE *	,
		struct hardware *
	)

parse_interface_declaration()

void parse_interface_declaration	(	FILE *	,
		struct client_config *
	)

parse_ip_addr()

int parse_ip_addr	(	FILE *	,
		struct iaddr *
	)

parse_lease_time()

void parse_lease_time	(	FILE *	,
		time_t *
	)

parse_numeric_aggregate()

unsigned char * parse_numeric_aggregate	(	FILE *	,
		unsigned char *	,
		int *	,
		int	,
		int	,
		int
	)

parse_option_decl()

struct dhcp_option * parse_option_decl	(	FILE *	,
		struct option_data *
	)

parse_option_list()

int parse_option_list	(	FILE *	,
		u_int8_t *
	)

parse_reject_statement()

void parse_reject_statement	(	FILE *	,
		struct client_config *
	)

parse_semi()

int parse_semi

(

FILE *

)

parse_string()

char * parse_string

(

FILE *

)

parse_string_list()

void parse_string_list	(	FILE *	,
		struct string_list **	,
		int
	)

parse_warn()

void int int int int parse_warn	(	char *	,
			...
	)

parse_X()

int parse_X	(	FILE *	,
		u_int8_t *	,
		int
	)

peek_token()

int peek_token	(	char **	,
		FILE *
	)

piaddr()

char * piaddr

(

struct iaddr

addr

)

Definition at line 6 of file util.c.

                                  {
    struct sockaddr_in sa;
    memcpy(&sa.sin_addr,addr.iabuf,sizeof(sa.sin_addr));
    return inet_ntoa( sa.sin_addr );
}

Referenced by bind_lease(), bootp(), dhcp(), dhcpack(), dhcpnak(), dhcpoffer(), priv_script_write_params(), set_name_servers(), setup_adapter(), and write_client_lease().

pretty_print_option()

char * pretty_print_option	(	unsigned int	code,
		unsigned char *	data,
		int	len,
		int	emit_commas,
		int	emit_quotes
	)

Definition at line 396 of file options.c.

{
    static char optbuf[32768]; /* XXX */
    int hunksize = 0, numhunk = -1, numelem = 0;
    char fmtbuf[32], *op = optbuf;
    int i, j, k, opleft = sizeof(optbuf);
    unsigned char *dp = data;
    struct in_addr foo;
    char comma;
 
    /* Code should be between 0 and 255. */
    if (code > 255)
        error("pretty_print_option: bad code %d", code);
 
    if (emit_commas)
        comma = ',';
    else
        comma = ' ';
 
    /* Figure out the size of the data. */
    for (i = 0; dhcp_options[code].format[i]; i++) {
        if (!numhunk) {
            warning("%s: Excess information in format string: %s",
                dhcp_options[code].name,
                &(dhcp_options[code].format[i]));
            break;
        }
        numelem++;
        fmtbuf[i] = dhcp_options[code].format[i];
        switch (dhcp_options[code].format[i]) {
        case 'A':
            --numelem;
            fmtbuf[i] = 0;
            numhunk = 0;
            break;
        case 'X':
            for (k = 0; k < len; k++)
                if (!isascii(data[k]) ||
                    !isprint(data[k]))
                    break;
            if (k == len) {
                fmtbuf[i] = 't';
                numhunk = -2;
            } else {
                fmtbuf[i] = 'x';
                hunksize++;
                comma = ':';
                numhunk = 0;
            }
            fmtbuf[i + 1] = 0;
            break;
        case 't':
            fmtbuf[i] = 't';
            fmtbuf[i + 1] = 0;
            numhunk = -2;
            break;
        case 'I':
        case 'l':
        case 'L':
            hunksize += 4;
            break;
        case 's':
        case 'S':
            hunksize += 2;
            break;
        case 'b':
        case 'B':
        case 'f':
            hunksize++;
            break;
        case 'e':
            break;
        default:
            warning("%s: garbage in format string: %s",
                dhcp_options[code].name,
                &(dhcp_options[code].format[i]));
            break;
        }
    }
 
    /* Check for too few bytes... */
    if (hunksize > len) {
        warning("%s: expecting at least %d bytes; got %d",
            dhcp_options[code].name, hunksize, len);
        return ("<error>");
    }
    /* Check for too many bytes... */
    if (numhunk == -1 && hunksize < len)
        warning("%s: %d extra bytes",
            dhcp_options[code].name, len - hunksize);
 
    /* If this is an array, compute its size. */
    if (!numhunk)
        numhunk = len / hunksize;
    /* See if we got an exact number of hunks. */
    if (numhunk > 0 && numhunk * hunksize < len)
        warning("%s: %d extra bytes at end of array",
            dhcp_options[code].name, len - numhunk * hunksize);
 
    /* A one-hunk array prints the same as a single hunk. */
    if (numhunk < 0)
        numhunk = 1;
 
    /* Cycle through the array (or hunk) printing the data. */
    for (i = 0; i < numhunk; i++) {
        for (j = 0; j < numelem; j++) {
            int opcount;
            switch (fmtbuf[j]) {
            case 't':
                if (emit_quotes) {
                    *op++ = '"';
                    opleft--;
                }
                for (; dp < data + len; dp++) {
                    if (!isascii(*dp) ||
                        !isprint(*dp)) {
                        if (dp + 1 != data + len ||
                            *dp != 0) {
                            _snprintf(op, opleft,
                                "\\%03o", *dp);
                            op += 4;
                            opleft -= 4;
                        }
                    } else if (*dp == '"' ||
                        *dp == '\'' ||
                        *dp == '$' ||
                        *dp == '`' ||
                        *dp == '\\') {
                        *op++ = '\\';
                        *op++ = *dp;
                        opleft -= 2;
                    } else {
                        *op++ = *dp;
                        opleft--;
                    }
                }
                if (emit_quotes) {
                    *op++ = '"';
                    opleft--;
                }
 
                *op = 0;
                break;
            case 'I':
                foo.s_addr = htonl(getULong(dp));
                strncpy(op, inet_ntoa(foo), opleft - 1);
                op[opleft - 1] = ANSI_NULL;
                opcount = strlen(op);
                if (opcount >= opleft)
                    goto toobig;
                opleft -= opcount;
                dp += 4;
                break;
            case 'l':
                opcount = _snprintf(op, opleft, "%ld",
                    (long)getLong(dp));
                if (opcount >= opleft || opcount == -1)
                    goto toobig;
                opleft -= opcount;
                dp += 4;
                break;
            case 'L':
                opcount = _snprintf(op, opleft, "%ld",
                    (unsigned long)getULong(dp));
                if (opcount >= opleft || opcount == -1)
                    goto toobig;
                opleft -= opcount;
                dp += 4;
                break;
            case 's':
                opcount = _snprintf(op, opleft, "%d",
                    getShort(dp));
                if (opcount >= opleft || opcount == -1)
                    goto toobig;
                opleft -= opcount;
                dp += 2;
                break;
            case 'S':
                opcount = _snprintf(op, opleft, "%d",
                    getUShort(dp));
                if (opcount >= opleft || opcount == -1)
                    goto toobig;
                opleft -= opcount;
                dp += 2;
                break;
            case 'b':
                opcount = _snprintf(op, opleft, "%d",
                    *(char *)dp++);
                if (opcount >= opleft || opcount == -1)
                    goto toobig;
                opleft -= opcount;
                break;
            case 'B':
                opcount = _snprintf(op, opleft, "%d", *dp++);
                if (opcount >= opleft || opcount == -1)
                    goto toobig;
                opleft -= opcount;
                break;
            case 'x':
                opcount = _snprintf(op, opleft, "%x", *dp++);
                if (opcount >= opleft || opcount == -1)
                    goto toobig;
                opleft -= opcount;
                break;
            case 'f':
                opcount = (size_t) strncpy(op, *dp++ ? "true" : "false", opleft - 1);
                op[opleft - 1] = ANSI_NULL;
                if (opcount >= opleft)
                    goto toobig;
                opleft -= opcount;
                break;
            default:
                warning("Unexpected format code %c", fmtbuf[j]);
            }
            op += strlen(op);
            opleft -= strlen(op);
            if (opleft < 1)
                goto toobig;
            if (j + 1 < numelem && comma != ':') {
                *op++ = ' ';
                opleft--;
            }
        }
        if (i + 1 < numhunk) {
            *op++ = comma;
            opleft--;
        }
        if (opleft < 1)
            goto toobig;
 
    }
    return (optbuf);
 toobig:
    warning("dhcp option too large");
    return ("<error>");
}

Referenced by check_option(), priv_script_write_params(), and write_client_lease().

priv_script_go()

int priv_script_go

(

void

)

priv_script_init()

void priv_script_init	(	struct interface_info *	ip,
		char *	reason,
		char *	medium
	)

Definition at line 1999 of file dhclient.c.

{
    if (ip) {
            // XXX Do we need to do anything?
        }
}

priv_script_write_params()

void priv_script_write_params	(	struct interface_info *	ip,
		char *	prefix,
		struct client_lease *	lease
	)

Definition at line 2007 of file dhclient.c.

{
    u_int8_t dbuf[1500];
    int i, len = 0;
 
#if 0
    script_set_env(ip->client, prefix, "ip_address",
        piaddr(lease->address));
#endif
 
    if (lease->options[DHO_SUBNET_MASK].len &&
        (lease->options[DHO_SUBNET_MASK].len <
        sizeof(lease->address.iabuf))) {
        struct iaddr netmask, subnet, broadcast;
 
        memcpy(netmask.iabuf, lease->options[DHO_SUBNET_MASK].data,
            lease->options[DHO_SUBNET_MASK].len);
        netmask.len = lease->options[DHO_SUBNET_MASK].len;
 
        subnet = subnet_number(lease->address, netmask);
        if (subnet.len) {
#if 0
            script_set_env(ip->client, prefix, "network_number",
                piaddr(subnet));
#endif
            if (!lease->options[DHO_BROADCAST_ADDRESS].len) {
                broadcast = broadcast_addr(subnet, netmask);
                if (broadcast.len)
#if 0
                    script_set_env(ip->client, prefix,
                        "broadcast_address",
                        piaddr(broadcast));
#else
                                ;
#endif
            }
        }
    }
 
#if 0
    if (lease->filename)
        script_set_env(ip->client, prefix, "filename", lease->filename);
    if (lease->server_name)
        script_set_env(ip->client, prefix, "server_name",
            lease->server_name);
#endif
 
    for (i = 0; i < 256; i++) {
        u_int8_t *dp = NULL;
 
        if (ip->client->config->defaults[i].len) {
            if (lease->options[i].len) {
                switch (
                    ip->client->config->default_actions[i]) {
                case ACTION_DEFAULT:
                    dp = lease->options[i].data;
                    len = lease->options[i].len;
                    break;
                case ACTION_SUPERSEDE:
supersede:
                    dp = ip->client->
                        config->defaults[i].data;
                    len = ip->client->
                        config->defaults[i].len;
                    break;
                case ACTION_PREPEND:
                    len = ip->client->
                        config->defaults[i].len +
                        lease->options[i].len;
                    if (len >= sizeof(dbuf)) {
                        warning("no space to %s %s",
                            "prepend option",
                            dhcp_options[i].name);
                        goto supersede;
                    }
                    dp = dbuf;
                    memcpy(dp,
                        ip->client->
                        config->defaults[i].data,
                        ip->client->
                        config->defaults[i].len);
                    memcpy(dp + ip->client->
                        config->defaults[i].len,
                        lease->options[i].data,
                        lease->options[i].len);
                    dp[len] = '\0';
                    break;
                case ACTION_APPEND:
                    len = ip->client->
                        config->defaults[i].len +
                        lease->options[i].len + 1;
                    if (len > sizeof(dbuf)) {
                        warning("no space to %s %s",
                            "append option",
                            dhcp_options[i].name);
                        goto supersede;
                    }
                    dp = dbuf;
                    memcpy(dp,
                        lease->options[i].data,
                        lease->options[i].len);
                    memcpy(dp + lease->options[i].len,
                        ip->client->
                        config->defaults[i].data,
                        ip->client->
                        config->defaults[i].len);
                    dp[len-1] = '\0';
                }
            } else {
                dp = ip->client->
                    config->defaults[i].data;
                len = ip->client->
                    config->defaults[i].len;
            }
        } else if (lease->options[i].len) {
            len = lease->options[i].len;
            dp = lease->options[i].data;
        } else {
            len = 0;
        }
#if 0
        if (len) {
            char name[256];
 
            if (dhcp_option_ev_name(name, sizeof(name),
                &dhcp_options[i]))
                script_set_env(ip->client, prefix, name,
                    pretty_print_option(i, dp, len, 0, 0));
        }
#endif
    }
#if 0
    snprintf(tbuf, sizeof(tbuf), "%d", (int)lease->expiry);
    script_set_env(ip->client, prefix, "expiry", tbuf);
#endif
}

putLong()

void putLong	(	unsigned char *	,
		int32_t
	)

putShort()

void putShort	(	unsigned char *	,
		int
	)

putULong()

void putULong	(	unsigned char *	,
		u_int32_t
	)

putUShort()

void putUShort	(	unsigned char *	,
		unsigned int
	)

read_client_conf()

int read_client_conf

(

struct interface_info *

ifi

)

Definition at line 106 of file util.c.

                                                 {
       /* What a strange dance */
       struct client_config *config;
       char ComputerName [MAX_COMPUTERNAME_LENGTH + 1];
       LPSTR lpCompName;
       DWORD ComputerNameSize = sizeof ComputerName / sizeof ComputerName[0];
       LPSTR lpClassIdentifier = "MSFT 5.0";
 
       if ((ifi!= NULL) && (ifi->client->config != NULL))
          config = ifi->client->config;
       else
       {
           warn("util.c read_client_conf poorly implemented!");
           return 0;
       }
 
 
       GetComputerName(ComputerName, & ComputerNameSize);
       debug("Hostname: %s, length: %lu",
               ComputerName, ComputerNameSize);
       /* This never gets freed since it's only called once */
       lpCompName =
       HeapAlloc(GetProcessHeap(), 0, ComputerNameSize + 1);
       if (lpCompName !=NULL) {
           memcpy(lpCompName, ComputerName, ComputerNameSize + 1);
           /* Send our hostname, some dhcpds use this to update DNS */
           config->send_options[DHO_HOST_NAME].data = (u_int8_t*)lpCompName;
           config->send_options[DHO_HOST_NAME].len = ComputerNameSize;
           debug("Hostname: %s, length: %d",
                 config->send_options[DHO_HOST_NAME].data,
                 config->send_options[DHO_HOST_NAME].len);
       } else {
           error("Failed to allocate heap for hostname");
       }
       /* Both Linux and Windows send this */
       config->send_options[DHO_DHCP_CLIENT_IDENTIFIER].data =
             ifi->hw_address.haddr;
       config->send_options[DHO_DHCP_CLIENT_IDENTIFIER].len =
             ifi->hw_address.hlen;
 
        /* Set the Vendor Class ID */
       config->send_options[DHO_DHCP_CLASS_IDENTIFIER].data = (u_int8_t*)lpClassIdentifier;
       config->send_options[DHO_DHCP_CLASS_IDENTIFIER].len = strlen(lpClassIdentifier);
 
       /* Setup the requested option list */
       config->requested_options
           [config->requested_option_count++] = DHO_SUBNET_MASK;
       config->requested_options
           [config->requested_option_count++] = DHO_DOMAIN_NAME;
       config->requested_options
           [config->requested_option_count++] = DHO_ROUTERS;
       config->requested_options
           [config->requested_option_count++] = DHO_DOMAIN_NAME_SERVERS;
       config->requested_options
           [config->requested_option_count++] = DHO_NETBIOS_NAME_SERVERS;
       config->requested_options
           [config->requested_option_count++] = DHO_NETBIOS_NODE_TYPE;
       config->requested_options
           [config->requested_option_count++] = DHO_NETBIOS_SCOPE;
       config->requested_options
           [config->requested_option_count++] = DHO_ROUTER_DISCOVERY;
       config->requested_options
           [config->requested_option_count++] = DHO_STATIC_ROUTES;
       config->requested_options
           [config->requested_option_count++] = 249;
       config->requested_options
           [config->requested_option_count++] = DHO_VENDOR_ENCAPSULATED_OPTIONS;
 
       warn("util.c read_client_conf poorly implemented!");
    return 0;
}

Referenced by AdapterDiscoveryThread().

read_client_leases()

void read_client_leases

(

void

)

receive_packet()

ssize_t receive_packet	(	struct interface_info *	ip,
		unsigned char *	packet_data,
		size_t	packet_len,
		struct sockaddr_in *	dest,
		struct hardware *	hardware
	)

Definition at line 34 of file socket.c.

                                                   {
    int recv_addr_size = sizeof(*dest);
    int result;
 
    if (packet_len > INT_MAX)
        return WSAEMSGSIZE;
 
    result =
        recvfrom (ip -> rfdesc, (char *)packet_data, (int)packet_len, 0,
                  (struct sockaddr *)dest, &recv_addr_size );
    return result;
}

Referenced by got_one().

reinitialize_interfaces()

void reinitialize_interfaces

(

void

)

remove_protocol()

void remove_protocol

(

struct protocol *

proto

)

Definition at line 359 of file dispatch.c.

{
    struct protocol *p, *next, *prev;
    struct interface_info *ip = proto->local;
    struct timeout *t, *q, *u;
    
    t = NULL;
    q = timeouts;
    while (q != NULL)
    {
        /* Remove all timeouts for this protocol */
        if (q->what == ip)
        {
            /* Unlink the timeout from previous */
            if (t)
                t->next = q->next;
            else
                timeouts = q->next;
                        
            /* Advance to the next timeout */
            u = q->next;
            
            /* Add it to the free list */
            q->next = free_timeouts;
            free_timeouts = q;
        }
        else
        {
            /* Advance to the next timeout */
            u = q->next;
            
            /* Update the previous pointer */
            t = q;
        }
        
        /* Advance */
        q = u;
    }
 
    prev = NULL;
    for (p = protocols; p; p = next) {
        next = p->next;
        if (p == proto) {
            if (prev)
                prev->next = p->next;
            else
                protocols = p->next;
            free(p);
        }
    }
}

Referenced by AdapterDiscoveryThread(), got_one(), Server_AcquireParameters(), Server_EnableDhcp(), Server_ReleaseParameters(), and Server_StaticRefreshParams().

rewrite_client_leases()

void rewrite_client_leases

(

struct interface_info *

ifi

)

Definition at line 1911 of file dhclient.c.

{
    struct client_lease *lp;
 
    if (!leaseFile) {
        leaseFile = fopen(path_dhclient_db, "w");
        if (!leaseFile)
            error("can't create %s", path_dhclient_db);
    } else {
        fflush(leaseFile);
        rewind(leaseFile);
    }
 
    for (lp = ifi->client->leases; lp; lp = lp->next)
        write_client_lease(ifi, lp, 1);
    if (ifi->client->active)
        write_client_lease(ifi, ifi->client->active, 1);
 
    fflush(leaseFile);
}

Referenced by write_client_lease().

script_flush_env()

void script_flush_env

(

struct client_state *

)

script_go()

int script_go

(

void

)

script_init()

void script_init	(	char *	,
		struct string_list *
	)

script_set_env()

void script_set_env	(	struct client_state *	,
		const char *	,
		const char *	,
		const char *
	)

Referenced by priv_script_write_params().

script_write_params()

void script_write_params	(	char *	,
		struct client_lease *
	)

send_decline()

void send_decline

(

void *

ipp

)

Definition at line 1531 of file dhclient.c.

{
    struct interface_info *ip = ipp;
 
    note("DHCPDECLINE on %s to %s port %d", ip->name,
        inet_ntoa(sockaddr_broadcast.sin_addr),
        ntohs(sockaddr_broadcast.sin_port));
 
    /* Send out a packet. */
    (void) send_packet(ip, &ip->client->packet, ip->client->packet_length,
        inaddr_any, &sockaddr_broadcast, NULL);
}

send_discover()

void send_discover

(

void *

ipp

)

Definition at line 1106 of file dhclient.c.

{
    struct interface_info *ip = ipp;
    int interval, increase = 1;
        time_t cur_time;
 
        DH_DbgPrint(MID_TRACE,("Doing discover on interface %p\n",ip));
 
        time(&cur_time);
 
    /* Figure out how long it's been since we started transmitting. */
    interval = cur_time - ip->client->first_sending;
 
    /* If we're past the panic timeout, call the script and tell it
       we haven't found anything for this interface yet. */
    if (interval > ip->client->config->timeout) {
        state_panic(ip);
        ip->client->first_sending = cur_time;
    }
 
    /* If we're selecting media, try the whole list before doing
       the exponential backoff, but if we've already received an
       offer, stop looping, because we obviously have it right. */
    if (!ip->client->offered_leases &&
        ip->client->config->media) {
        int fail = 0;
 
        if (ip->client->medium) {
            ip->client->medium = ip->client->medium->next;
            increase = 0;
        }
        if (!ip->client->medium) {
            if (fail)
                error("No valid media types for %s!", ip->name);
            ip->client->medium = ip->client->config->media;
            increase = 1;
        }
 
        note("Trying medium \"%s\" %d", ip->client->medium->string,
            increase);
                /* XXX Support other media types eventually */
    }
 
    /*
     * If we're supposed to increase the interval, do so.  If it's
     * currently zero (i.e., we haven't sent any packets yet), set
     * it to one; otherwise, add to it a random number between zero
     * and two times itself.  On average, this means that it will
     * double with every transmission.
     */
    if (increase) {
        if (!ip->client->interval)
            ip->client->interval =
                ip->client->config->initial_interval;
        else {
            ip->client->interval += (rand() >> 2) %
                (2 * ip->client->interval);
        }
 
        /* Don't backoff past cutoff. */
        if (ip->client->interval >
            ip->client->config->backoff_cutoff)
            ip->client->interval =
                ((ip->client->config->backoff_cutoff / 2)
                 + ((rand() >> 2) %
                    ip->client->config->backoff_cutoff));
    } else if (!ip->client->interval)
        ip->client->interval =
            ip->client->config->initial_interval;
 
    /* If the backoff would take us to the panic timeout, just use that
       as the interval. */
    if (cur_time + ip->client->interval >
        ip->client->first_sending + ip->client->config->timeout)
        ip->client->interval =
            (ip->client->first_sending +
             ip->client->config->timeout) - cur_time + 1;
 
    /* Record the number of seconds since we started sending. */
    if (interval < 65536)
        ip->client->packet.secs = htons(interval);
    else
        ip->client->packet.secs = htons(65535);
    ip->client->secs = ip->client->packet.secs;
 
    note("DHCPDISCOVER on %s to %s port %d interval %ld",
        ip->name, inet_ntoa(sockaddr_broadcast.sin_addr),
        ntohs(sockaddr_broadcast.sin_port), (long int)ip->client->interval);
 
    /* Send out a packet. */
    (void)send_packet(ip, &ip->client->packet, ip->client->packet_length,
        inaddr_any, &sockaddr_broadcast, NULL);
 
        DH_DbgPrint(MID_TRACE,("discover timeout: now %x -> then %x\n",
                               cur_time, cur_time + ip->client->interval));
 
    add_timeout(cur_time + ip->client->interval, send_discover, ip);
}

Referenced by dhcpoffer(), send_discover(), state_init(), and state_selecting().

send_packet()

ssize_t send_packet	(	struct interface_info *	ip,
		struct dhcp_packet *	p,
		size_t	size,
		struct in_addr	addr,
		struct sockaddr_in *	broadcast,
		struct hardware *	hardware
	)

Definition at line 9 of file socket.c.

                                                 {
    int result;
 
    if (size > INT_MAX)
        return WSAEMSGSIZE;
 
    result =
        sendto( ip->wfdesc, (char *)p, (int)size, 0,
                (struct sockaddr *)broadcast, sizeof(*broadcast) );
 
    if (result < 0) {
        note ("send_packet: %x", result);
        if (result == WSAENETUNREACH)
            note ("send_packet: please consult README file%s",
                  " regarding broadcast address.");
    }
 
    return result;
}

Referenced by send_decline(), send_discover(), send_release(), and send_request().

send_release()

void send_release

(

void *

ipp

)

Definition at line 1545 of file dhclient.c.

{
    struct interface_info *ip = ipp;
    struct sockaddr_in destination;
    struct in_addr from;
 
    memset(&destination, 0, sizeof(destination));
    memcpy(&destination.sin_addr.s_addr,
           ip->client->destination.iabuf,
           sizeof(destination.sin_addr.s_addr));
    destination.sin_port = htons(REMOTE_PORT);
    destination.sin_family = AF_INET;
 
    memcpy(&from, ip->client->active->address.iabuf,
        sizeof(from));
 
    note("DHCPRELEASE on %s to %s port %d", ip->name,
        inet_ntoa(destination.sin_addr), ntohs(destination.sin_port));
 
    /* Send out a packet. */
    (void) send_packet(ip, &ip->client->packet, ip->client->packet_length,
        from, &destination, NULL);
}

Referenced by state_release().

send_request()

void send_request

(

void *

ipp

)

Definition at line 1402 of file dhclient.c.

{
    struct interface_info *ip = ipp;
    struct sockaddr_in destination;
    struct in_addr from;
    int interval;
        time_t cur_time;
 
        time(&cur_time); 
 
    /* Figure out how long it's been since we started transmitting. */
    interval = cur_time - ip->client->first_sending;
 
    /* If we're in the INIT-REBOOT or REQUESTING state and we're
       past the reboot timeout, go to INIT and see if we can
       DISCOVER an address... */
    /* XXX In the INIT-REBOOT state, if we don't get an ACK, it
       means either that we're on a network with no DHCP server,
       or that our server is down.  In the latter case, assuming
       that there is a backup DHCP server, DHCPDISCOVER will get
       us a new address, but we could also have successfully
       reused our old address.  In the former case, we're hosed
       anyway.  This is not a win-prone situation. */
    if ((ip->client->state == S_REBOOTING ||
        ip->client->state == S_REQUESTING) &&
        interval > ip->client->config->reboot_timeout) {
        ip->client->state = S_INIT;
        cancel_timeout(send_request, ip);
        state_init(ip);
        return;
    }
 
    /* If we're in the reboot state, make sure the media is set up
       correctly. */
    if (ip->client->state == S_REBOOTING &&
        !ip->client->medium &&
        ip->client->active->medium ) {
        /* If the medium we chose won't fly, go to INIT state. */
                /* XXX Nothing for now */
 
        /* Record the medium. */
        ip->client->medium = ip->client->active->medium;
    }
 
    /* If the lease has expired, relinquish the address and go back
       to the INIT state. */
    if (ip->client->state != S_REQUESTING &&
        cur_time > ip->client->active->expiry) {
            PDHCP_ADAPTER Adapter = AdapterFindInfo( ip );
            /* Run the client script with the new parameters. */
            /* No script actions necessary in the expiry case */
            /* Now do a preinit on the interface so that we can
               discover a new address. */
 
            if( Adapter )
            {
                DeleteIPAddress( Adapter->NteContext );
                Adapter->NteContext = 0;
            }
 
            ip->client->state = S_INIT;
            state_init(ip);
            return;
    }
 
    /* Do the exponential backoff... */
    if (!ip->client->interval)
        ip->client->interval = ip->client->config->initial_interval;
    else
        ip->client->interval += ((rand() >> 2) %
            (2 * ip->client->interval));
 
    /* Don't backoff past cutoff. */
    if (ip->client->interval >
        ip->client->config->backoff_cutoff)
        ip->client->interval =
            ((ip->client->config->backoff_cutoff / 2) +
            ((rand() >> 2) % ip->client->interval));
 
    /* If the backoff would take us to the expiry time, just set the
       timeout to the expiry time. */
    if (ip->client->state != S_REQUESTING &&
        cur_time + ip->client->interval >
        ip->client->active->expiry)
        ip->client->interval =
            ip->client->active->expiry - cur_time + 1;
 
    /* If the lease T2 time has elapsed, or if we're not yet bound,
       broadcast the DHCPREQUEST rather than unicasting. */
    memset(&destination, 0, sizeof(destination));
    if (ip->client->state == S_REQUESTING ||
        ip->client->state == S_REBOOTING ||
        cur_time > ip->client->active->rebind)
        destination.sin_addr.s_addr = INADDR_BROADCAST;
    else
        memcpy(&destination.sin_addr.s_addr,
            ip->client->destination.iabuf,
            sizeof(destination.sin_addr.s_addr));
    destination.sin_port = htons(REMOTE_PORT);
    destination.sin_family = AF_INET;
//  destination.sin_len = sizeof(destination);
 
    if (ip->client->state != S_REQUESTING)
        memcpy(&from, ip->client->active->address.iabuf,
            sizeof(from));
    else
        from.s_addr = INADDR_ANY;
 
    /* Record the number of seconds since we started sending. */
    if (ip->client->state == S_REQUESTING)
        ip->client->packet.secs = ip->client->secs;
    else {
        if (interval < 65536)
            ip->client->packet.secs = htons(interval);
        else
            ip->client->packet.secs = htons(65535);
    }
 
    note("DHCPREQUEST on %s to %s port %d", ip->name,
        inet_ntoa(destination.sin_addr), ntohs(destination.sin_port));
 
    /* Send out a packet. */
    (void) send_packet(ip, &ip->client->packet, ip->client->packet_length,
        from, &destination, NULL);
 
    add_timeout(cur_time + ip->client->interval, send_request, ip);
}

skip_to_semi()

void skip_to_semi

(

FILE *

)

state_bound()

void state_bound

(

void *

ipp

)

Definition at line 770 of file dhclient.c.

{
    struct interface_info *ip = ipp;
 
    ASSERT_STATE(state, S_BOUND);
 
    /* T1 has expired. */
    make_request(ip, ip->client->active);
    ip->client->xid = ip->client->packet.xid;
 
    if (ip->client->active->options[DHO_DHCP_SERVER_IDENTIFIER].len == 4) {
        memcpy(ip->client->destination.iabuf, ip->client->active->
            options[DHO_DHCP_SERVER_IDENTIFIER].data, 4);
        ip->client->destination.len = 4;
    } else
        ip->client->destination = iaddr_broadcast;
 
    time(&ip->client->first_sending);
    ip->client->interval = ip->client->config->initial_interval;
    ip->client->state = S_RENEWING;
 
    /* Send the first packet immediately. */
    send_request(ip);
}

Referenced by bind_lease().

state_init()

void state_init

(

void *

ipp

)

Definition at line 210 of file dhclient.c.

{
    struct interface_info *ip = ipp;
 
    ASSERT_STATE(state, S_INIT);
 
    /* Make a DHCPDISCOVER packet, and set appropriate per-interface
       flags. */
    make_discover(ip, ip->client->active);
    ip->client->xid = ip->client->packet.xid;
    ip->client->destination = iaddr_broadcast;
    ip->client->state = S_SELECTING;
    time(&ip->client->first_sending);
    ip->client->interval = ip->client->config->initial_interval;
 
    /* Add an immediate timeout to cause the first DHCPDISCOVER packet
       to go out. */
    send_discover(ip);
}

Referenced by AdapterDiscoveryThread(), device_init(), dhcpnak(), send_request(), state_reboot(), state_selecting(), wined3d_cs_create(), wined3d_cs_exec_reset_state(), and wined3d_device_reset().

state_panic()

void state_panic

(

void *

ipp

)

Definition at line 1212 of file dhclient.c.

{
    CHAR szKeyNameBuffer[200] = "SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces\\";
    CHAR Server[] = "255.255.255.255";
    CHAR SubnetMask[] = "255.255.0.0";
    CHAR AddressBuffer[32];
    struct interface_info *ip = ipp;
    uint16_t address_low;
    int i;
    IPAddr IpAddress;
    ULONG Buffer[20];
    ULONG BufferSize;
    DWORD ret;
    HKEY hKey = NULL;
    PDHCP_ADAPTER Adapter = AdapterFindInfo(ip);
    NTSTATUS Status;
    DWORD lease = 0;
    time_t cur_time, never_time = 0x7FFFFFFF;
    struct in_addr addr;
    DWORD dwAddressType = 0;
 
    note("No DHCPOFFERS received.");
 
    time(&cur_time);
 
    strcat(szKeyNameBuffer, Adapter->DhclientInfo.name);
    if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, szKeyNameBuffer, 0, KEY_WRITE, &hKey) != ERROR_SUCCESS)
        hKey = NULL;
 
    if (Adapter && !Adapter->NteContext)
    {
        DH_DbgPrint(MID_TRACE,("DHCPCSVC: Failed to receive a response from a DHCP server\n"));
        if ((Adapter->AlternateConfiguration != NULL) &&
            (Adapter->AlternateConfiguration->IpAddress != 0))
        {
            /* Use the alternate configuration */
            DH_DbgPrint(MID_TRACE,("DHCPCSVC: The alternate configuration will be used.\n"));
 
            /* IPAddress & SubnetMask */
            Status = AddIPAddress(htonl(Adapter->AlternateConfiguration->IpAddress),
                                  htonl(Adapter->AlternateConfiguration->SubnetMask),
                                  Adapter->IfMib.dwIndex,
                                  &Adapter->NteContext,
                                  &Adapter->NteInstance);
            if (!NT_SUCCESS(Status))
                DH_DbgPrint(MID_TRACE,("AddIPAddress: %lx\n", Status));
 
            /* DefaultGateway */
            if (Adapter->AlternateConfiguration->DefaultGateway != 0)
            {
                Adapter->RouterMib.dwForwardDest = 0; /* Default route */
                Adapter->RouterMib.dwForwardMask = 0;
                Adapter->RouterMib.dwForwardMetric1 = 1;
                Adapter->RouterMib.dwForwardIfIndex = Adapter->IfMib.dwIndex;
 
                if (Adapter->RouterMib.dwForwardNextHop)
                {
                    /* If we set a default route before, delete it before continuing */
                    DeleteIpForwardEntry(&Adapter->RouterMib);
                }
 
                Adapter->RouterMib.dwForwardNextHop = htonl(Adapter->AlternateConfiguration->DefaultGateway);
 
                Status = CreateIpForwardEntry(&Adapter->RouterMib);
                if (!NT_SUCCESS(Status))
                    DH_DbgPrint(MID_TRACE,("CreateIpForwardEntry: %lx\n", Status));
            }
 
            if (hKey)
            {
                addr.S_un.S_addr = htonl(Adapter->AlternateConfiguration->IpAddress);
                RtlIpv4AddressToStringA(&addr, AddressBuffer);
                RegSetValueExA(hKey, "DhcpIPAddress", 0, REG_SZ, (LPBYTE)AddressBuffer, strlen(AddressBuffer) + 1);
                addr.S_un.S_addr = htonl(Adapter->AlternateConfiguration->SubnetMask);
                RtlIpv4AddressToStringA(&addr, AddressBuffer);
                RegSetValueExA(hKey, "DhcpSubnetMask", 0, REG_SZ, (LPBYTE)AddressBuffer, strlen(AddressBuffer) + 1);
                if (Adapter->AlternateConfiguration->DefaultGateway != 0)
                {
                    addr.S_un.S_addr = htonl(Adapter->AlternateConfiguration->DefaultGateway);
                    RtlIpv4AddressToStringA(&addr, AddressBuffer);
                    RegSetValueExA(hKey, "DhcpDefaultGateway", 0, REG_SZ, (LPBYTE)AddressBuffer, strlen(AddressBuffer) + 1);
                }
                else
                {
                    RegDeleteValueA(hKey, "DhcpDefaultGateway");
                }
                RegSetValueExA(hKey, "DhcpServer", 0, REG_SZ, (LPBYTE)Server, strlen(Server) + 1);
                RegDeleteValueA(hKey, "DhcpDomain");
 
                if (Adapter->AlternateConfiguration->DnsServer1 != 0)
                {
                    char *pPtr;
                    addr.S_un.S_addr = htonl(Adapter->AlternateConfiguration->DnsServer1);
                    pPtr = RtlIpv4AddressToStringA(&addr, AddressBuffer);
                    if (Adapter->AlternateConfiguration->DnsServer2 != 0)
                    {
                        *pPtr = ' ';
                        pPtr++;
                        addr.S_un.S_addr = htonl(Adapter->AlternateConfiguration->DnsServer2);
                        RtlIpv4AddressToStringA(&addr, pPtr);
                    }
 
                    RegSetValueExA(hKey, "DhcpNameServer", 0, REG_SZ, (LPBYTE)AddressBuffer, strlen(AddressBuffer) + 1);
                }
                else
                {
                    RegDeleteValueA(hKey, "DhcpNameServer");
                }
 
                RegDeleteValueA(hKey, "IPAutoconfigurationAddress");
                RegDeleteValueA(hKey, "IPAutoconfigurationMask");
 
                RegSetValueExA(hKey, "Lease", 0, REG_DWORD, (LPBYTE)&lease, sizeof(DWORD));
                RegSetValueExA(hKey, "LeaseObtainedTime", 0, REG_DWORD, (LPBYTE)&cur_time, sizeof(DWORD));
                RegSetValueExA(hKey, "LeaseTerminatesTime", 0, REG_DWORD, (LPBYTE)&never_time, sizeof(DWORD));
                RegSetValueExA(hKey, "T1", 0, REG_DWORD, (LPBYTE)&cur_time, sizeof(DWORD));
                RegSetValueExA(hKey, "T2", 0, REG_DWORD, (LPBYTE)&cur_time, sizeof(DWORD));
                RegSetValueExA(hKey, "AddressType", 0, REG_DWORD, (LPBYTE)&dwAddressType, sizeof(DWORD));
            }
        }
        else
        {
            /* Generate an automatic private address */
            DH_DbgPrint(MID_TRACE,("DHCPCSVC: An automatic private address will be assigned.\n"));
 
            /* FIXME: The address generation code sucks */
            srand(0);
 
            for (;;)
            {
                address_low = rand();
                for (i = 0; i < ip->hw_address.hlen; i++)
                    address_low += ip->hw_address.haddr[i];
 
                IpAddress = htonl(0xA9FE0000 | address_low);  // 169.254.X.X
 
                /* Send an ARP request to check if the IP address is already in use */
                BufferSize = sizeof(Buffer);
                ret = SendARP(IpAddress,
                              IpAddress,
                              Buffer,
                              &BufferSize);
                DH_DbgPrint(MID_TRACE,("DHCPCSVC: SendARP returned %lu\n", ret));
                if (ret != 0)
                {
                    /* The IP address is not in use */
                    DH_DbgPrint(MID_TRACE,("DHCPCSVC: Using automatic private address\n"));
                    Status = AddIPAddress(IpAddress,
                                          htonl(0xFFFF0000), // 255.255.0.0
                                          Adapter->IfMib.dwIndex,
                                          &Adapter->NteContext,
                                          &Adapter->NteInstance);
                    if (!NT_SUCCESS(Status))
                        DH_DbgPrint(MID_TRACE,("AddIPAddress: %lx\n", Status));
 
                    if (hKey)
                    {
                        addr.S_un.S_addr = IpAddress;
                        RtlIpv4AddressToStringA(&addr, AddressBuffer);
                        RegSetValueExA(hKey, "DhcpIPAddress", 0, REG_SZ, (LPBYTE)AddressBuffer, strlen(AddressBuffer) + 1);
                        RegSetValueExA(hKey, "DhcpSubnetMask", 0, REG_SZ, (LPBYTE)SubnetMask, strlen(SubnetMask) + 1);
                        RegSetValueExA(hKey, "DhcpServer", 0, REG_SZ, (LPBYTE)Server, strlen(Server) + 1);
                        RegDeleteValueA(hKey, "DhcpDefaultGateway");
                        RegDeleteValueA(hKey, "DhcpDomain");
                        RegDeleteValueA(hKey, "DhcpNameServer");
 
                        RegSetValueExA(hKey, "IPAutoconfigurationAddress", 0, REG_SZ, (LPBYTE)AddressBuffer, strlen(AddressBuffer) + 1);
                        RegSetValueExA(hKey, "IPAutoconfigurationMask", 0, REG_SZ, (LPBYTE)SubnetMask, strlen(SubnetMask) + 1);
 
                        RegSetValueExA(hKey, "Lease", 0, REG_DWORD, (LPBYTE)&lease, sizeof(DWORD));
                        RegSetValueExA(hKey, "LeaseObtainedTime", 0, REG_DWORD, (LPBYTE)&cur_time, sizeof(DWORD));
                        RegSetValueExA(hKey, "LeaseTerminatesTime", 0, REG_DWORD, (LPBYTE)&never_time, sizeof(DWORD));
                        RegSetValueExA(hKey, "T1", 0, REG_DWORD, (LPBYTE)&cur_time, sizeof(DWORD));
                        RegSetValueExA(hKey, "T2", 0, REG_DWORD, (LPBYTE)&cur_time, sizeof(DWORD));
                        dwAddressType = 1;
                        RegSetValueExA(hKey, "AddressType", 0, REG_DWORD, (LPBYTE)&dwAddressType, sizeof(DWORD));
                    }
 
                    goto done;
                }
            }
        }
    }
 
done:
    if (hKey)
        RegCloseKey(hKey);
}

Referenced by send_discover().

state_reboot()

void state_reboot

(

void *

ipp

)

Definition at line 172 of file dhclient.c.

{
    struct interface_info *ip = ipp;
    ULONG foo = (ULONG) GetTickCount();
 
    /* If we don't remember an active lease, go straight to INIT. */
    if (!ip->client->active || ip->client->active->is_bootp) {
        state_init(ip);
        return;
    }
 
    /* We are in the rebooting state. */
    ip->client->state = S_REBOOTING;
 
    /* make_request doesn't initialize xid because it normally comes
       from the DHCPDISCOVER, but we haven't sent a DHCPDISCOVER,
       so pick an xid now. */
    ip->client->xid = RtlRandom(&foo);
 
    /* Make a DHCPREQUEST packet, and set appropriate per-interface
       flags. */
    make_request(ip, ip->client->active);
    ip->client->destination = iaddr_broadcast;
    time(&ip->client->first_sending);
    ip->client->interval = ip->client->config->initial_interval;
 
    /* Zap the medium list... */
    ip->client->medium = NULL;
 
    /* Send out the first DHCPREQUEST packet. */
    send_request(ip);
}

Referenced by Server_AcquireParameters(), and Server_EnableDhcp().

state_release()

void state_release

(

void *

ipp

)

Definition at line 231 of file dhclient.c.

{
    struct interface_info *ip = ipp;
    ULONG foo = (ULONG) GetTickCount();
 
    ASSERT_STATE(state, S_BOUND);
 
    /* Make a DHCPRELEASE packet, and set appropriate per-interface
       flags. */
    make_release(ip, ip->client->active);
 
    /* make_request doesn't initialize xid because it normally comes
       from the DHCPDISCOVER, but we haven't sent a DHCPDISCOVER,
       so pick an xid now. */
    ip->client->xid = RtlRandom(&foo);
    send_release(ip);
 
    ip->client->state = S_RELEASED;
    unbind_lease(ip);
}

Referenced by Server_ReleaseParameters().

state_requesting()

void state_requesting

(

void *

)

state_selecting()

void state_selecting

(

void *

ipp

)

Definition at line 257 of file dhclient.c.

{
    struct interface_info *ip = ipp;
    struct client_lease *lp, *next, *picked;
        time_t cur_time;
 
    ASSERT_STATE(state, S_SELECTING);
 
        time(&cur_time);
 
    /* Cancel state_selecting and send_discover timeouts, since either
       one could have got us here. */
    cancel_timeout(state_selecting, ip);
    cancel_timeout(send_discover, ip);
 
    /* We have received one or more DHCPOFFER packets.   Currently,
       the only criterion by which we judge leases is whether or
       not we get a response when we arp for them. */
    picked = NULL;
    for (lp = ip->client->offered_leases; lp; lp = next) {
        next = lp->next;
 
        /* Check to see if we got an ARPREPLY for the address
           in this particular lease. */
        if (!picked) {
                    if( !check_arp(ip,lp) ) goto freeit;
                    picked = lp;
                    picked->next = NULL;
        } else {
freeit:
            free_client_lease(lp);
        }
    }
    ip->client->offered_leases = NULL;
 
    /* If we just tossed all the leases we were offered, go back
       to square one. */
    if (!picked) {
        ip->client->state = S_INIT;
        state_init(ip);
        return;
    }
 
    /* If it was a BOOTREPLY, we can just take the address right now. */
    if (!picked->options[DHO_DHCP_MESSAGE_TYPE].len) {
        ip->client->new = picked;
 
        /* Make up some lease expiry times
           XXX these should be configurable. */
        ip->client->new->expiry = cur_time + 12000;
        ip->client->new->renewal += cur_time + 8000;
        ip->client->new->rebind += cur_time + 10000;
 
        ip->client->state = S_REQUESTING;
 
        /* Bind to the address we received. */
        bind_lease(ip);
        return;
    }
 
    /* Go to the REQUESTING state. */
    ip->client->destination = iaddr_broadcast;
    ip->client->state = S_REQUESTING;
    ip->client->first_sending = cur_time;
    ip->client->interval = ip->client->config->initial_interval;
 
    /* Make a DHCPREQUEST packet from the lease we picked. */
    make_request(ip, picked);
    ip->client->xid = ip->client->packet.xid;
 
    /* Toss the lease we picked - we'll get it back in a DHCPACK. */
    free_client_lease(picked);
 
    /* Add an immediate timeout to send the first DHCPREQUEST packet. */
    send_request(ip);
}

Referenced by dhcpoffer(), and state_selecting().

subnet_number()

struct iaddr subnet_number	(	struct iaddr	addr,
		struct iaddr	mask
	)

Definition at line 183 of file util.c.

                                                                   {
    struct iaddr bcast = { 0 };
    return bcast;
}

Referenced by priv_script_write_params().

unbind_lease()

void unbind_lease

(

struct interface_info *

ip

)

Definition at line 742 of file dhclient.c.

{
    PDHCP_ADAPTER Adapter;
 
    if (ip->client->active) {
        free_client_lease(ip->client->active);
        ip->client->active = NULL;
    }
 
    Adapter = AdapterFindInfo( ip );
    if (Adapter) {
        reset_adapter(Adapter);
        unset_name_servers(Adapter);
        unset_domain(Adapter);
    }
    else {
        warning("Could not find adapter for info %p\n", ip);
        return;
    }
}

Referenced by state_release().

warning()

void int warning	(	char *	format,
			...
	)

Definition at line 129 of file uimain.c.

{
  va_list ap;
  char text[512];
  char text1[512];
 
  sprintf(text1, "WARNING: ");
  va_start(ap, format);
  vsprintf(text, format, ap);
  va_end(ap);
  strcat(text1, text);
  mi_warning(text1);
}

write_client_lease()

void write_client_lease	(	struct interface_info *	ip,
		struct client_lease *	lease,
		int	rewrite
	)

Definition at line 1933 of file dhclient.c.

{
    static int leases_written;
    struct tm *t;
    int i;
 
    if (!rewrite) {
        if (leases_written++ > 20) {
            rewrite_client_leases(ip);
            leases_written = 0;
        }
    }
 
    /* If the lease came from the config file, we don't need to stash
       a copy in the lease database. */
    if (lease->is_static)
        return;
 
    if (!leaseFile) {   /* XXX */
        leaseFile = fopen(path_dhclient_db, "w");
        if (!leaseFile) {
            error("can't create %s", path_dhclient_db);
                        return;
                }
    }
 
    fprintf(leaseFile, "lease {\n");
    if (lease->is_bootp)
        fprintf(leaseFile, "  bootp;\n");
    fprintf(leaseFile, "  interface \"%s\";\n", ip->name);
    fprintf(leaseFile, "  fixed-address %s;\n", piaddr(lease->address));
    if (lease->filename)
        fprintf(leaseFile, "  filename \"%s\";\n", lease->filename);
    if (lease->server_name)
        fprintf(leaseFile, "  server-name \"%s\";\n",
            lease->server_name);
    if (lease->medium)
        fprintf(leaseFile, "  medium \"%s\";\n", lease->medium->string);
    for (i = 0; i < 256; i++)
        if (lease->options[i].len)
            fprintf(leaseFile, "  option %s %s;\n",
                dhcp_options[i].name,
                pretty_print_option(i, lease->options[i].data,
                lease->options[i].len, 1, 1));
 
    t = gmtime(&lease->renewal);
        if (t)
        fprintf(leaseFile, "  renew %d %d/%d/%d %02d:%02d:%02d;\n",
            t->tm_wday, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
            t->tm_hour, t->tm_min, t->tm_sec);
    t = gmtime(&lease->rebind);
        if (t)
        fprintf(leaseFile, "  rebind %d %d/%d/%d %02d:%02d:%02d;\n",
             t->tm_wday, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
             t->tm_hour, t->tm_min, t->tm_sec);
    t = gmtime(&lease->expiry);
        if (t)
        fprintf(leaseFile, "  expire %d %d/%d/%d %02d:%02d:%02d;\n",
            t->tm_wday, t->tm_year + 1900, t->tm_mon + 1, t->tm_mday,
            t->tm_hour, t->tm_min, t->tm_sec);
    fprintf(leaseFile, "}\n");
    fflush(leaseFile);
}

Referenced by rewrite_client_leases().

Variable Documentation

bootp_packet_handler

void(* bootp_packet_handler) (struct interface_info *, struct dhcp_packet *, int, unsigned int, struct iaddr, struct hardware *) ( struct interface_info *  , struct dhcp_packet *  , int  , unsigned int  , struct iaddr  , struct hardware *    )

extern

Definition at line 59 of file dispatch.c.

Referenced by got_one(), and init_client().

comment_index

int comment_index

extern

comments

char comments[4096]

extern

Referenced by D3DDisassemble(), and D3DXDisassembleShader().

cur_time

time_t cur_time

extern

Referenced by bind_lease(), create_msft_typelib(), dhcpack(), dhcpoffer(), dispatch(), do_host_lookup(), FreeUrlCacheSpaceW(), main(), reset_adapter(), rpcrt4_http_timer_calc_timeout(), send_discover(), send_request(), state_panic(), state_selecting(), TIME_MMSysTimeCallback(), urlcache_hash_entry_is_locked(), and urlcache_rate_entry().

dhcp_option_default_priority_list

unsigned char dhcp_option_default_priority_list[]

extern

Definition at line 329 of file tables.c.

Referenced by cons_options().

dhcp_options

struct dhcp_option dhcp_options[256]

extern

Definition at line 68 of file tables.c.

Referenced by initialize_universes(), parse_option_buffer(), pretty_print_option(), priv_script_write_params(), and write_client_lease().

dhcp_universe

struct universe dhcp_universe

extern

Definition at line 67 of file tables.c.

Referenced by initialize_universes().

eol_token

int eol_token

extern

lexchar

void int int int int int lexchar

Definition at line 311 of file dhcpd.h.

lexline

void int int int int int lexline

extern

log_perror

int log_perror

extern

Definition at line 76 of file dhclient.c.

log_priority

int log_priority

extern

Definition at line 92 of file dhclient.c.

path_dhclient_conf

char* path_dhclient_conf

extern

Definition at line 73 of file dhclient.c.

path_dhclient_db

char* path_dhclient_db

extern

Definition at line 74 of file dhclient.c.

Referenced by rewrite_client_leases(), and write_client_lease().

sizeof_dhcp_option_default_priority_list

int sizeof_dhcp_option_default_priority_list

extern

Definition at line 408 of file tables.c.

Referenced by cons_options().

tlname

char * tlname

Definition at line 312 of file dhcpd.h.

token_line

char* token_line

extern

top_level_config

struct client_config top_level_config

extern

universe_hash

struct hash_table universe_hash

extern

Definition at line 672 of file tables.c.

Referenced by initialize_universes().

warnings_occurred

int warnings_occurred

extern