Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/usr.sbin/dhcpd/dhclient.c

403 lines
11 KiB
C
Raw Blame History

/* dhcp.c
DHCP Client (really lame DHCP client). */
/*
* Copyright (c) 1995, 1996 The Internet Software Consortium.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of The Internet Software Consortium nor the names
* of its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INTERNET SOFTWARE CONSORTIUM AND
* CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE INTERNET SOFTWARE CONSORTIUM OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* This software has been written for the Internet Software Consortium
* by Ted Lemon <mellon@fugue.com> in cooperation with Vixie
* Enterprises. To learn more about the Internet Software Consortium,
* see ``http://www.vix.com/isc''. To learn more about Vixie
* Enterprises, see ``http://www.vix.com''.
*/
#ifndef lint
static char copyright[] =
"$Id: dhclient.c,v 1.1.1.1 1996/10/03 06:33:25 mrg Exp $ Copyright (c) 1995, 1996 The Internet Software Consortium. All rights reserved.\n";
#endif /* not lint */
#include "dhcpd.h"
TIME cur_time;
TIME default_lease_time = 43200; /* 12 hours... */
TIME max_lease_time = 86400; /* 24 hours... */
struct tree_cache *global_options [256];
struct iaddr server_identifier;
int server_identifier_matched;
int log_perror = 1;
#ifdef USE_FALLBACK
struct interface_info fallback_interface;
#endif
u_int16_t server_port;
int log_priority;
int lexline, lexchar;
char *tlname, *token_line;
static void usage PROTO ((void));
int main (argc, argv, envp)
int argc;
char **argv, **envp;
{
int i;
struct servent *ent;
struct interface_info *interface;
#ifdef SYSLOG_4_2
openlog ("dhclient", LOG_NDELAY);
log_priority = LOG_DAEMON;
#else
openlog ("dhclient", LOG_NDELAY, LOG_DAEMON);
#endif
#ifndef NO_PUTENV
/* ensure mktime() calls are processed in UTC */
putenv("TZ=GMT0");
#endif /* !NO_PUTENV */
#if !(defined (DEBUG) || defined (SYSLOG_4_2))
setlogmask (LOG_UPTO (LOG_INFO));
#endif
for (i = 1; i < argc; i++) {
if (!strcmp (argv [i], "-p")) {
if (++i == argc)
usage ();
server_port = htons (atoi (argv [i]));
debug ("binding to user-specified port %d",
ntohs (server_port));
} else
usage ();
}
/* Default to the DHCP/BOOTP port. */
if (!server_port)
{
ent = getservbyname ("dhcpc", "udp");
if (!ent)
server_port = htons (68);
else
server_port = ent -> s_port;
endservent ();
}
/* Get the current time... */
GET_TIME (&cur_time);
/* Discover all the network interfaces and initialize them. */
discover_interfaces (0);
for (interface = interfaces; interface; interface = interface -> next)
send_discover (interface);
/* Receive packets and dispatch them... */
dispatch ();
/* Not reached */
return 0;
}
static void usage ()
{
error ("Usage: dhclient [-p <port>]");
}
void cleanup ()
{
}
int commit_leases ()
{
return 0;
}
int write_lease (lease)
struct lease *lease;
{
return 0;
}
void db_startup ()
{
}
void bootp (packet)
struct packet *packet;
{
note ("BOOTREPLY from %s",
print_hw_addr (packet -> raw -> htype,
packet -> raw -> hlen,
packet -> raw -> chaddr));
}
void dhcp (packet)
struct packet *packet;
{
switch (packet -> packet_type) {
case DHCPOFFER:
dhcpoffer (packet);
break;
case DHCPNAK:
dhcpnak (packet);
break;
case DHCPACK:
dhcpack (packet);
break;
default:
break;
}
}
void dhcpoffer (packet)
struct packet *packet;
{
note ("DHCPOFFER from %s",
print_hw_addr (packet -> raw -> htype,
packet -> raw -> hlen,
packet -> raw -> chaddr));
dump_packet (packet);
send_request (packet);
}
void dhcpack (packet)
struct packet *packet;
{
note ("DHCPACK from %s",
print_hw_addr (packet -> raw -> htype,
packet -> raw -> hlen,
packet -> raw -> chaddr));
dump_packet (packet);
}
void dhcpnak (packet)
struct packet *packet;
{
note ("DHCPNAK from %s",
print_hw_addr (packet -> raw -> htype,
packet -> raw -> hlen,
packet -> raw -> chaddr));
}
static u_int8_t requested_options [] = {
DHO_DHCP_REQUESTED_ADDRESS,
DHO_SUBNET_MASK,
DHO_ROUTERS,
DHO_DOMAIN_NAME_SERVERS,
DHO_HOST_NAME,
DHO_DOMAIN_NAME,
DHO_BROADCAST_ADDRESS };
void send_discover (interface)
struct interface_info *interface;
{
struct sockaddr_in to;
int result;
struct dhcp_packet raw;
unsigned char discover = DHCPDISCOVER;
struct packet outgoing;
struct tree_cache *options [256];
struct tree_cache dhcpdiscover_tree;
struct tree_cache dhcprqo_tree;
memset (options, 0, sizeof options);
memset (&outgoing, 0, sizeof outgoing);
memset (&raw, 0, sizeof raw);
outgoing.raw = &raw;
/* Set DHCP_MESSAGE_TYPE to DHCPNAK */
options [DHO_DHCP_MESSAGE_TYPE] = &dhcpdiscover_tree;
options [DHO_DHCP_MESSAGE_TYPE] -> value = &discover;
options [DHO_DHCP_MESSAGE_TYPE] -> len = sizeof discover;
options [DHO_DHCP_MESSAGE_TYPE] -> buf_size = sizeof discover;
options [DHO_DHCP_MESSAGE_TYPE] -> timeout = 0xFFFFFFFF;
options [DHO_DHCP_MESSAGE_TYPE] -> tree = (struct tree *)0;
/* Set DHCP_MESSAGE to whatever the message is */
options [DHO_DHCP_MESSAGE] = &dhcprqo_tree;
options [DHO_DHCP_MESSAGE] -> value = requested_options;
options [DHO_DHCP_MESSAGE] -> len = sizeof requested_options;
options [DHO_DHCP_MESSAGE] -> buf_size = sizeof requested_options;
options [DHO_DHCP_MESSAGE] -> timeout = 0xFFFFFFFF;
options [DHO_DHCP_MESSAGE] -> tree = (struct tree *)0;
/* Set up the option buffer... */
cons_options ((struct packet *)0, &outgoing, options, 0, 0);
memset (&raw.ciaddr, 0, sizeof raw.ciaddr);
memset (&raw.siaddr, 0, sizeof raw.siaddr);
memset (&raw.giaddr, 0, sizeof raw.giaddr);
memcpy (raw.chaddr,
interface -> hw_address.haddr, interface -> hw_address.hlen);
raw.hlen = interface -> hw_address.hlen;
raw.htype = interface -> hw_address.htype;
raw.xid = random ();
raw.secs = 1;
raw.flags = htons (BOOTP_BROADCAST);
raw.hops = 0;
raw.op = BOOTREQUEST;
/* Report what we're sending... */
note ("DHCPDISCOVER to %s", interface -> name);
#ifdef DEBUG_PACKET
dump_packet (&outgoing);
dump_raw ((unsigned char *)&raw, outgoing.packet_length);
#endif
/* Set up the common stuff... */
to.sin_family = AF_INET;
#ifdef HAVE_SA_LEN
to.sin_len = sizeof to;
#endif
memset (to.sin_zero, 0, sizeof to.sin_zero);
to.sin_addr.s_addr = htonl (INADDR_BROADCAST);
to.sin_port = htons (ntohs (server_port) - 1); /* XXX */
errno = 0;
result = send_packet (interface, (struct packet *)0,
&raw, outgoing.packet_length,
raw.siaddr, &to, (struct hardware *)0);
if (result < 0)
warn ("send_packet: %m");
}
void send_request (packet)
struct packet *packet;
{
struct sockaddr_in to;
int result;
struct dhcp_packet raw;
unsigned char request = DHCPREQUEST;
struct packet outgoing;
struct tree_cache *options [256];
struct tree_cache dhcprequest_tree;
struct tree_cache dhcprqo_tree;
struct tree_cache dhcprqa_tree;
struct tree_cache dhcpsid_tree;
memset (options, 0, sizeof options);
memset (&outgoing, 0, sizeof outgoing);
memset (&raw, 0, sizeof raw);
outgoing.raw = &raw;
/* Set DHCP_MESSAGE_TYPE to DHCPNAK */
options [DHO_DHCP_MESSAGE_TYPE] = &dhcprequest_tree;
options [DHO_DHCP_MESSAGE_TYPE] -> value = &request;
options [DHO_DHCP_MESSAGE_TYPE] -> len = sizeof request;
options [DHO_DHCP_MESSAGE_TYPE] -> buf_size = sizeof request;
options [DHO_DHCP_MESSAGE_TYPE] -> timeout = 0xFFFFFFFF;
options [DHO_DHCP_MESSAGE_TYPE] -> tree = (struct tree *)0;
/* Set DHCP_MESSAGE to whatever the message is */
options [DHO_DHCP_MESSAGE] = &dhcprqo_tree;
options [DHO_DHCP_MESSAGE] -> value = requested_options;
options [DHO_DHCP_MESSAGE] -> len = sizeof requested_options;
options [DHO_DHCP_MESSAGE] -> buf_size = sizeof requested_options;
options [DHO_DHCP_MESSAGE] -> timeout = 0xFFFFFFFF;
options [DHO_DHCP_MESSAGE] -> tree = (struct tree *)0;
/* Request the address we were offered... */
options [DHO_DHCP_REQUESTED_ADDRESS] = &dhcprqa_tree;
options [DHO_DHCP_REQUESTED_ADDRESS] -> value =
(unsigned char *)&packet -> raw -> yiaddr;
options [DHO_DHCP_REQUESTED_ADDRESS] -> len = 4;
options [DHO_DHCP_REQUESTED_ADDRESS] -> buf_size = 4;
options [DHO_DHCP_REQUESTED_ADDRESS] -> timeout = 0xFFFFFFFF;
options [DHO_DHCP_REQUESTED_ADDRESS] -> tree = (struct tree *)0;
/* Send back the server identifier... */
options [DHO_DHCP_SERVER_IDENTIFIER] = &dhcpsid_tree;
options [DHO_DHCP_SERVER_IDENTIFIER] -> value =
packet -> options [DHO_DHCP_SERVER_IDENTIFIER].data;
options [DHO_DHCP_SERVER_IDENTIFIER] -> len =
packet -> options [DHO_DHCP_SERVER_IDENTIFIER].len;
options [DHO_DHCP_SERVER_IDENTIFIER] -> buf_size =
packet -> options [DHO_DHCP_SERVER_IDENTIFIER].len;
options [DHO_DHCP_SERVER_IDENTIFIER] -> timeout = 0xFFFFFFFF;
options [DHO_DHCP_SERVER_IDENTIFIER] -> tree = (struct tree *)0;
/* Set up the option buffer... */
cons_options ((struct packet *)0, &outgoing, options, 0, 0);
memset (&raw.ciaddr, 0, sizeof raw.ciaddr);
raw.siaddr = packet -> raw -> siaddr;
raw.giaddr = packet -> raw -> giaddr;
memcpy (raw.chaddr,
packet -> interface -> hw_address.haddr,
packet -> interface -> hw_address.hlen);
raw.hlen = packet -> interface -> hw_address.hlen;
raw.htype = packet -> interface -> hw_address.htype;
raw.xid = packet -> raw -> xid;
raw.secs = packet -> raw -> secs;
raw.flags = htons (BOOTP_BROADCAST);
raw.hops = packet -> raw -> hops;
raw.op = BOOTREQUEST;
/* Report what we're sending... */
note ("DHCPREQUEST to %s", packet -> interface -> name);
#ifdef DEBUG_PACKET
dump_packet (&outgoing);
dump_raw ((unsigned char *)&raw, outgoing.packet_length);
#endif
/* Set up the common stuff... */
to.sin_family = AF_INET;
#ifdef HAVE_SA_LEN
to.sin_len = sizeof to;
#endif
memset (to.sin_zero, 0, sizeof to.sin_zero);
to.sin_addr.s_addr = htonl (INADDR_BROADCAST);
to.sin_port = htons (ntohs (server_port) - 1); /* XXX */
errno = 0;
result = send_packet (packet -> interface, (struct packet *)0,
&raw, outgoing.packet_length,
raw.siaddr, &to, (struct hardware *)0);
if (result < 0)
warn ("send_packet: %m");
}
Reference in New Issue View Git Blame Copy Permalink