Context Navigation

source: MondoRescue/branches/3.2/mindi-busybox/networking/udhcp/dhcpc.c@ 3232

Visit:

Last change on this file since 3232 was 3232, checked in by Bruno Cornec, 10 years ago
Update mindi-busybox to 1.21.1
File size: 54.9 KB

Rev	Line
[1765]	1	/* vi: set sw=4 ts=4: */
[2725]	2	/*
	3	* udhcp client
[821]	4	*
	5	* Russ Dill <Russ.Dill@asu.edu> July 2001
	6	*
[2725]	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
[821]	20	*/
[1765]	21	#include <syslog.h>
	22	/* Override ENABLE_FEATURE_PIDFILE - ifupdown needs our pidfile to always exist */
	23	#define WANT_PIDFILE 1
[821]	24	#include "common.h"
	25	#include "dhcpd.h"
	26	#include "dhcpc.h"
	27
[3232]	28	#include <netinet/if_ether.h>
[2725]	29	#include <linux/filter.h>
[3232]	30	#include <linux/if_packet.h>
[1765]	31
[3232]	32	/* "struct client_config_t client_config" is in bb_common_bufsiz1 */
[2725]	33
	34
[3232]	35	#if ENABLE_LONG_OPTS
	36	static const char udhcpc_longopts[] ALIGN1 =
	37	"clientid-none\0" No_argument "C"
	38	"vendorclass\0" Required_argument "V"
	39	"hostname\0" Required_argument "H"
	40	"fqdn\0" Required_argument "F"
	41	"interface\0" Required_argument "i"
	42	"now\0" No_argument "n"
	43	"pidfile\0" Required_argument "p"
	44	"quit\0" No_argument "q"
	45	"release\0" No_argument "R"
	46	"request\0" Required_argument "r"
	47	"script\0" Required_argument "s"
	48	"timeout\0" Required_argument "T"
	49	"retries\0" Required_argument "t"
	50	"tryagain\0" Required_argument "A"
	51	"syslog\0" No_argument "S"
	52	"request-option\0" Required_argument "O"
	53	"no-default-options\0" No_argument "o"
	54	"foreground\0" No_argument "f"
	55	"background\0" No_argument "b"
	56	"broadcast\0" No_argument "B"
	57	IF_FEATURE_UDHCPC_ARPING("arping\0" No_argument "a")
	58	IF_FEATURE_UDHCP_PORT("client-port\0" Required_argument "P")
	59	;
	60	#endif
	61	/* Must match getopt32 option string order */
	62	enum {
	63	OPT_C = 1 << 0,
	64	OPT_V = 1 << 1,
	65	OPT_H = 1 << 2,
	66	OPT_h = 1 << 3,
	67	OPT_F = 1 << 4,
	68	OPT_i = 1 << 5,
	69	OPT_n = 1 << 6,
	70	OPT_p = 1 << 7,
	71	OPT_q = 1 << 8,
	72	OPT_R = 1 << 9,
	73	OPT_r = 1 << 10,
	74	OPT_s = 1 << 11,
	75	OPT_T = 1 << 12,
	76	OPT_t = 1 << 13,
	77	OPT_S = 1 << 14,
	78	OPT_A = 1 << 15,
	79	OPT_O = 1 << 16,
	80	OPT_o = 1 << 17,
	81	OPT_x = 1 << 18,
	82	OPT_f = 1 << 19,
	83	OPT_B = 1 << 20,
	84	/* The rest has variable bit positions, need to be clever */
	85	OPTBIT_B = 20,
	86	USE_FOR_MMU( OPTBIT_b,)
	87	IF_FEATURE_UDHCPC_ARPING(OPTBIT_a,)
	88	IF_FEATURE_UDHCP_PORT( OPTBIT_P,)
	89	USE_FOR_MMU( OPT_b = 1 << OPTBIT_b,)
	90	IF_FEATURE_UDHCPC_ARPING(OPT_a = 1 << OPTBIT_a,)
	91	IF_FEATURE_UDHCP_PORT( OPT_P = 1 << OPTBIT_P,)
	92	};
	93
	94
[2725]	95	/* Script execution code */
	96
	97	/* get a rough idea of how long an option will be (rounding up...) */
	98	static const uint8_t len_of_option_as_string[] = {
	99	[OPTION_IP ] = sizeof("255.255.255.255 "),
	100	[OPTION_IP_PAIR ] = sizeof("255.255.255.255 ") * 2,
	101	[OPTION_STATIC_ROUTES ] = sizeof("255.255.255.255/32 255.255.255.255 "),
[3232]	102	[OPTION_6RD ] = sizeof("32 128 ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff 255.255.255.255 "),
[2725]	103	[OPTION_STRING ] = 1,
[3232]	104	[OPTION_STRING_HOST ] = 1,
[2725]	105	#if ENABLE_FEATURE_UDHCP_RFC3397
	106	[OPTION_DNS_STRING ] = 1, /* unused */
	107	/* Hmmm, this severely overestimates size if SIP_SERVERS option
	108	* is in domain name form: N-byte option in binary form
	109	* mallocs ~16*N bytes. But it is freed almost at once.
	110	*/
	111	[OPTION_SIP_SERVERS ] = sizeof("255.255.255.255 "),
	112	#endif
	113	// [OPTION_BOOLEAN ] = sizeof("yes "),
	114	[OPTION_U8 ] = sizeof("255 "),
	115	[OPTION_U16 ] = sizeof("65535 "),
	116	// [OPTION_S16 ] = sizeof("-32768 "),
	117	[OPTION_U32 ] = sizeof("4294967295 "),
	118	[OPTION_S32 ] = sizeof("-2147483684 "),
	119	};
	120
	121	/* note: ip is a pointer to an IP in network order, possibly misaliged */
	122	static int sprint_nip(char dest, const char pre, const uint8_t *ip)
	123	{
	124	return sprintf(dest, "%s%u.%u.%u.%u", pre, ip[0], ip[1], ip[2], ip[3]);
	125	}
	126
	127	/* really simple implementation, just count the bits */
	128	static int mton(uint32_t mask)
	129	{
	130	int i = 0;
	131	mask = ntohl(mask); /* 111110000-like bit pattern */
	132	while (mask) {
	133	i++;
	134	mask <<= 1;
	135	}
	136	return i;
	137	}
	138
[3232]	139	/* Check if a given label represents a valid DNS label
	140	* Return pointer to the first character after the label upon success,
	141	* NULL otherwise.
	142	* See RFC1035, 2.3.1
	143	*/
	144	/* We don't need to be particularly anal. For example, allowing _, hyphen
	145	* at the end, or leading and trailing dots would be ok, since it
	146	* can't be used for attacks. (Leading hyphen can be, if someone uses
	147	* cmd "$hostname"
	148	* in the script: then hostname may be treated as an option)
	149	*/
	150	static const char valid_domain_label(const char label)
	151	{
	152	unsigned char ch;
	153	unsigned pos = 0;
	154
	155	for (;;) {
	156	ch = *label;
	157	if ((ch\|0x20) < 'a' \|\| (ch\|0x20) > 'z') {
	158	if (pos == 0) {
	159	/* label must begin with letter */
	160	return NULL;
	161	}
	162	if (ch < '0' \|\| ch > '9') {
	163	if (ch == '\0' \|\| ch == '.')
	164	return label;
	165	/* DNS allows only '-', but we are more permissive */
	166	if (ch != '-' && ch != '_')
	167	return NULL;
	168	}
	169	}
	170	label++;
	171	pos++;
	172	//Do we want this?
	173	//if (pos > 63) /* NS_MAXLABEL; labels must be 63 chars or less */
	174	// return NULL;
	175	}
	176	}
	177
	178	/* Check if a given name represents a valid DNS name */
	179	/* See RFC1035, 2.3.1 */
	180	static int good_hostname(const char *name)
	181	{
	182	//const char *start = name;
	183
	184	for (;;) {
	185	name = valid_domain_label(name);
	186	if (!name)
	187	return 0;
	188	if (!name[0])
	189	return 1;
	190	//Do we want this?
	191	//return ((name - start) < 1025); /* NS_MAXDNAME */
	192	name++;
	193	}
	194	}
	195
[2725]	196	/* Create "opt_name=opt_value" string */
	197	static NOINLINE char xmalloc_optname_optval(uint8_t option, const struct dhcp_optflag optflag, const char opt_name)
	198	{
	199	unsigned upper_length;
	200	int len, type, optlen;
	201	char dest, ret;
	202
[3232]	203	/* option points to OPT_DATA, need to go back to get OPT_LEN */
	204	len = option[-OPT_DATA + OPT_LEN];
[2725]	205
	206	type = optflag->flags & OPTION_TYPE_MASK;
	207	optlen = dhcp_option_lengths[type];
[3232]	208	upper_length = len_of_option_as_string[type]
	209	* ((unsigned)(len + optlen - 1) / (unsigned)optlen);
[2725]	210
	211	dest = ret = xmalloc(upper_length + strlen(opt_name) + 2);
	212	dest += sprintf(ret, "%s=", opt_name);
	213
	214	while (len >= optlen) {
	215	switch (type) {
[3232]	216	case OPTION_IP:
[2725]	217	case OPTION_IP_PAIR:
	218	dest += sprint_nip(dest, "", option);
[3232]	219	if (type == OPTION_IP)
	220	break;
	221	dest += sprint_nip(dest, "/", option + 4);
[2725]	222	break;
	223	// case OPTION_BOOLEAN:
	224	// dest += sprintf(dest, *option ? "yes" : "no");
	225	// break;
	226	case OPTION_U8:
	227	dest += sprintf(dest, "%u", *option);
	228	break;
	229	// case OPTION_S16:
	230	case OPTION_U16: {
	231	uint16_t val_u16;
	232	move_from_unaligned16(val_u16, option);
	233	dest += sprintf(dest, "%u", ntohs(val_u16));
	234	break;
	235	}
	236	case OPTION_S32:
	237	case OPTION_U32: {
	238	uint32_t val_u32;
	239	move_from_unaligned32(val_u32, option);
	240	dest += sprintf(dest, type == OPTION_U32 ? "%lu" : "%ld", (unsigned long) ntohl(val_u32));
	241	break;
	242	}
[3232]	243	/* Note: options which use 'return' instead of 'break'
	244	* (for example, OPTION_STRING) skip the code which handles
	245	* the case of list of options.
	246	*/
[2725]	247	case OPTION_STRING:
[3232]	248	case OPTION_STRING_HOST:
[2725]	249	memcpy(dest, option, len);
	250	dest[len] = '\0';
[3232]	251	if (type == OPTION_STRING_HOST && !good_hostname(dest))
	252	safe_strncpy(dest, "bad", len);
	253	return ret;
[2725]	254	case OPTION_STATIC_ROUTES: {
	255	/* Option binary format:
	256	* mask [one byte, 0..32]
	257	* ip [big endian, 0..4 bytes depending on mask]
	258	* router [big endian, 4 bytes]
	259	* may be repeated
	260	*
	261	* We convert it to a string "IP/MASK ROUTER IP2/MASK2 ROUTER2"
	262	*/
	263	const char *pfx = "";
	264
	265	while (len >= 1 + 4) { /* mask + 0-byte ip + router */
	266	uint32_t nip;
	267	uint8_t *p;
	268	unsigned mask;
	269	int bytes;
	270
	271	mask = *option++;
	272	if (mask > 32)
	273	break;
	274	len--;
	275
	276	nip = 0;
	277	p = (void*) &nip;
	278	bytes = (mask + 7) / 8; /* 0 -> 0, 1..8 -> 1, 9..16 -> 2 etc */
	279	while (--bytes >= 0) {
	280	p++ = option++;
	281	len--;
	282	}
	283	if (len < 4)
	284	break;
	285
	286	/* print ip/mask */
	287	dest += sprint_nip(dest, pfx, (void*) &nip);
	288	pfx = " ";
	289	dest += sprintf(dest, "/%u ", mask);
	290	/* print router */
	291	dest += sprint_nip(dest, "", option);
	292	option += 4;
	293	len -= 4;
	294	}
	295
	296	return ret;
	297	}
[3232]	298	case OPTION_6RD:
	299	/* Option binary format (see RFC 5969):
	300	* 0 1 2 3
	301	* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
	302	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	303	* \| OPTION_6RD \| option-length \| IPv4MaskLen \| 6rdPrefixLen \|
	304	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	305	* \| 6rdPrefix \|
	306	* ... (16 octets) ...
	307	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	308	* ... 6rdBRIPv4Address(es) ...
	309	* +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
	310	* We convert it to a string
	311	* "IPv4MaskLen 6rdPrefixLen 6rdPrefix 6rdBRIPv4Address..."
	312	*
	313	* Sanity check: ensure that our length is at least 22 bytes, that
	314	* IPv4MaskLen <= 32,
	315	* 6rdPrefixLen <= 128,
	316	* 6rdPrefixLen + (32 - IPv4MaskLen) <= 128
	317	* (2nd condition need no check - it follows from 1st and 3rd).
	318	* Else, return envvar with empty value ("optname=")
	319	*/
	320	if (len >= (1 + 1 + 16 + 4)
	321	&& option[0] <= 32
	322	&& (option[1] + 32 - option[0]) <= 128
	323	) {
	324	/* IPv4MaskLen */
	325	dest += sprintf(dest, "%u ", *option++);
	326	/* 6rdPrefixLen */
	327	dest += sprintf(dest, "%u ", *option++);
	328	/* 6rdPrefix */
	329	dest += sprint_nip6(dest, /* "", */ option);
	330	option += 16;
	331	len -= 1 + 1 + 16 + 4;
	332	/* "+ 4" above corresponds to the length of IPv4 addr
	333	* we consume in the loop below */
	334	while (1) {
	335	/* 6rdBRIPv4Address(es) */
	336	dest += sprint_nip(dest, " ", option);
	337	option += 4;
	338	len -= 4; /* do we have yet another 4+ bytes? */
	339	if (len < 0)
	340	break; /* no */
	341	}
	342	}
	343
	344	return ret;
[2725]	345	#if ENABLE_FEATURE_UDHCP_RFC3397
	346	case OPTION_DNS_STRING:
	347	/* unpack option into dest; use ret for prefix (i.e., "optname=") */
	348	dest = dname_dec(option, len, ret);
	349	if (dest) {
	350	free(ret);
	351	return dest;
	352	}
	353	/* error. return "optname=" string */
	354	return ret;
	355	case OPTION_SIP_SERVERS:
	356	/* Option binary format:
	357	* type: byte
	358	* type=0: domain names, dns-compressed
	359	* type=1: IP addrs
	360	*/
	361	option++;
	362	len--;
	363	if (option[-1] == 0) {
	364	dest = dname_dec(option, len, ret);
	365	if (dest) {
	366	free(ret);
	367	return dest;
	368	}
	369	} else
	370	if (option[-1] == 1) {
	371	const char *pfx = "";
	372	while (1) {
	373	len -= 4;
	374	if (len < 0)
	375	break;
	376	dest += sprint_nip(dest, pfx, option);
	377	pfx = " ";
	378	option += 4;
	379	}
	380	}
	381	return ret;
	382	#endif
	383	} /* switch */
[3232]	384
	385	/* If we are here, try to format any remaining data
	386	* in the option as another, similarly-formatted option
	387	*/
[2725]	388	option += optlen;
	389	len -= optlen;
	390	// TODO: it can be a list only if (optflag->flags & OPTION_LIST).
	391	// Should we bail out/warn if we see multi-ip option which is
	392	// not allowed to be such (for example, DHCP_BROADCAST)? -
[3232]	393	if (len < optlen /* \|\| !(optflag->flags & OPTION_LIST) */)
[2725]	394	break;
	395	*dest++ = ' ';
	396	*dest = '\0';
[3232]	397	} /* while */
	398
[2725]	399	return ret;
	400	}
	401
	402	/* put all the parameters into the environment */
	403	static char *fill_envp(struct dhcp_packet packet)
	404	{
	405	int envc;
	406	int i;
	407	char envp, curr;
	408	const char *opt_name;
	409	uint8_t *temp;
	410	uint8_t overload = 0;
	411
[3232]	412	#define BITMAP unsigned
	413	#define BBITS (sizeof(BITMAP) * 8)
	414	#define BMASK(i) (1 << (i & (sizeof(BITMAP) * 8 - 1)))
	415	#define FOUND_OPTS(i) (found_opts[(unsigned)i / BBITS])
	416	BITMAP found_opts[256 / BBITS];
	417
	418	memset(found_opts, 0, sizeof(found_opts));
	419
[2725]	420	/* We need 6 elements for:
	421	* "interface=IFACE"
	422	* "ip=N.N.N.N" from packet->yiaddr
	423	* "siaddr=IP" from packet->siaddr_nip (unless 0)
	424	* "boot_file=FILE" from packet->file (unless overloaded)
	425	* "sname=SERVER_HOSTNAME" from packet->sname (unless overloaded)
	426	* terminating NULL
	427	*/
	428	envc = 6;
	429	/* +1 element for each option, +2 for subnet option: */
	430	if (packet) {
[3232]	431	/* note: do not search for "pad" (0) and "end" (255) options */
	432	//TODO: change logic to scan packet _once_
	433	for (i = 1; i < 255; i++) {
	434	temp = udhcp_get_option(packet, i);
	435	if (temp) {
	436	if (i == DHCP_OPTION_OVERLOAD)
	437	overload = *temp;
	438	else if (i == DHCP_SUBNET)
	439	envc++; /* for $mask */
[2725]	440	envc++;
[3232]	441	/if (i != DHCP_MESSAGE_TYPE)/
	442	FOUND_OPTS(i) \|= BMASK(i);
[2725]	443	}
	444	}
	445	}
[3232]	446	curr = envp = xzalloc(sizeof(envp[0]) * envc);
[2725]	447
	448	*curr = xasprintf("interface=%s", client_config.interface);
	449	putenv(*curr++);
	450
	451	if (!packet)
	452	return envp;
	453
[3232]	454	/* Export BOOTP fields. Fields we don't (yet?) export:
	455	* uint8_t op; // always BOOTREPLY
	456	* uint8_t htype; // hardware address type. 1 = 10mb ethernet
	457	* uint8_t hlen; // hardware address length
	458	* uint8_t hops; // used by relay agents only
	459	* uint32_t xid;
	460	* uint16_t secs; // elapsed since client began acquisition/renewal
	461	* uint16_t flags; // only one flag so far: bcast. Never set by server
	462	* uint32_t ciaddr; // client IP (usually == yiaddr. can it be different
	463	* // if during renew server wants to give us differn IP?)
	464	* uint32_t gateway_nip; // relay agent IP address
	465	* uint8_t chaddr[16]; // link-layer client hardware address (MAC)
	466	* TODO: export gateway_nip as $giaddr?
	467	*/
	468	/* Most important one: yiaddr as $ip */
[2725]	469	*curr = xmalloc(sizeof("ip=255.255.255.255"));
	470	sprint_nip(curr, "ip=", (uint8_t ) &packet->yiaddr);
	471	putenv(*curr++);
[3232]	472	if (packet->siaddr_nip) {
	473	/* IP address of next server to use in bootstrap */
	474	*curr = xmalloc(sizeof("siaddr=255.255.255.255"));
	475	sprint_nip(curr, "siaddr=", (uint8_t ) &packet->siaddr_nip);
	476	putenv(*curr++);
	477	}
	478	if (!(overload & FILE_FIELD) && packet->file[0]) {
	479	/* watch out for invalid packets */
	480	*curr = xasprintf("boot_file=%."DHCP_PKT_FILE_LEN_STR"s", packet->file);
	481	putenv(*curr++);
	482	}
	483	if (!(overload & SNAME_FIELD) && packet->sname[0]) {
	484	/* watch out for invalid packets */
	485	*curr = xasprintf("sname=%."DHCP_PKT_SNAME_LEN_STR"s", packet->sname);
	486	putenv(*curr++);
	487	}
[2725]	488
[3232]	489	/* Export known DHCP options */
[2725]	490	opt_name = dhcp_option_strings;
	491	i = 0;
	492	while (*opt_name) {
[3232]	493	uint8_t code = dhcp_optflags[i].code;
	494	BITMAP *found_ptr = &FOUND_OPTS(code);
	495	BITMAP found_mask = BMASK(code);
	496	if (!(*found_ptr & found_mask))
[2725]	497	goto next;
[3232]	498	found_ptr &= ~found_mask; / leave only unknown options */
	499	temp = udhcp_get_option(packet, code);
[2725]	500	*curr = xmalloc_optname_optval(temp, &dhcp_optflags[i], opt_name);
	501	putenv(*curr++);
[3232]	502	if (code == DHCP_SUBNET) {
[2725]	503	/* Subnet option: make things like "$ip/$mask" possible */
	504	uint32_t subnet;
	505	move_from_unaligned32(subnet, temp);
[3232]	506	*curr = xasprintf("mask=%u", mton(subnet));
[2725]	507	putenv(*curr++);
	508	}
	509	next:
	510	opt_name += strlen(opt_name) + 1;
	511	i++;
	512	}
[3232]	513	/* Export unknown options */
	514	for (i = 0; i < 256;) {
	515	BITMAP bitmap = FOUND_OPTS(i);
	516	if (!bitmap) {
	517	i += BBITS;
	518	continue;
	519	}
	520	if (bitmap & BMASK(i)) {
	521	unsigned len, ofs;
	522
	523	temp = udhcp_get_option(packet, i);
	524	/* udhcp_get_option returns ptr to data portion,
	525	* need to go back to get len
	526	*/
	527	len = temp[-OPT_DATA + OPT_LEN];
	528	curr = xmalloc(sizeof("optNNN=") + 1 + len2);
	529	ofs = sprintf(*curr, "opt%u=", i);
	530	bin2hex(curr + ofs, (void*) temp, len) = '\0';
	531	putenv(*curr++);
	532	}
	533	i++;
[2725]	534	}
[3232]	535
[2725]	536	return envp;
	537	}
	538
	539	/* Call a script with a par file and env vars */
	540	static void udhcp_run_script(struct dhcp_packet packet, const char name)
	541	{
	542	char envp, curr;
	543	char *argv[3];
	544
	545	envp = fill_envp(packet);
	546
	547	/* call script */
	548	log1("Executing %s %s", client_config.script, name);
	549	argv[0] = (char*) client_config.script;
	550	argv[1] = (char*) name;
	551	argv[2] = NULL;
	552	spawn_and_wait(argv);
	553
	554	for (curr = envp; *curr; curr++) {
	555	log2(" %s", *curr);
	556	bb_unsetenv_and_free(*curr);
	557	}
	558	free(envp);
	559	}
	560
	561
	562	/* Sending/receiving packets */
	563
	564	static ALWAYS_INLINE uint32_t random_xid(void)
	565	{
	566	return rand();
	567	}
	568
	569	/* Initialize the packet with the proper defaults */
	570	static void init_packet(struct dhcp_packet *packet, char type)
	571	{
[3232]	572	uint16_t secs;
	573
[2725]	574	/* Fill in: op, htype, hlen, cookie fields; message type option: */
	575	udhcp_init_header(packet, type);
	576
	577	packet->xid = random_xid();
	578
[3232]	579	client_config.last_secs = monotonic_sec();
	580	if (client_config.first_secs == 0)
	581	client_config.first_secs = client_config.last_secs;
	582	secs = client_config.last_secs - client_config.first_secs;
	583	packet->secs = htons(secs);
	584
[2725]	585	memcpy(packet->chaddr, client_config.client_mac, 6);
	586	if (client_config.clientid)
	587	udhcp_add_binary_option(packet, client_config.clientid);
	588	}
	589
	590	static void add_client_options(struct dhcp_packet *packet)
	591	{
	592	int i, end, len;
	593
	594	udhcp_add_simple_option(packet, DHCP_MAX_SIZE, htons(IP_UDP_DHCP_SIZE));
	595
	596	/* Add a "param req" option with the list of options we'd like to have
	597	* from stubborn DHCP servers. Pull the data from the struct in common.c.
	598	* No bounds checking because it goes towards the head of the packet. */
	599	end = udhcp_end_option(packet->options);
	600	len = 0;
[3232]	601	for (i = 1; i < DHCP_END; i++) {
	602	if (client_config.opt_mask[i >> 3] & (1 << (i & 7))) {
	603	packet->options[end + OPT_DATA + len] = i;
[2725]	604	len++;
	605	}
	606	}
	607	if (len) {
	608	packet->options[end + OPT_CODE] = DHCP_PARAM_REQ;
	609	packet->options[end + OPT_LEN] = len;
	610	packet->options[end + OPT_DATA + len] = DHCP_END;
	611	}
	612
	613	if (client_config.vendorclass)
	614	udhcp_add_binary_option(packet, client_config.vendorclass);
	615	if (client_config.hostname)
	616	udhcp_add_binary_option(packet, client_config.hostname);
	617	if (client_config.fqdn)
	618	udhcp_add_binary_option(packet, client_config.fqdn);
	619
[3232]	620	/* Request broadcast replies if we have no IP addr */
	621	if ((option_mask32 & OPT_B) && packet->ciaddr == 0)
	622	packet->flags \|= htons(BROADCAST_FLAG);
	623
[2725]	624	/* Add -x options if any */
	625	{
	626	struct option_set *curr = client_config.options;
	627	while (curr) {
	628	udhcp_add_binary_option(packet, curr->data);
	629	curr = curr->next;
	630	}
	631	// if (client_config.sname)
	632	// strncpy((char*)packet->sname, client_config.sname, sizeof(packet->sname) - 1);
	633	// if (client_config.boot_file)
	634	// strncpy((char*)packet->file, client_config.boot_file, sizeof(packet->file) - 1);
	635	}
[3232]	636
	637	// This will be needed if we remove -V VENDOR_STR in favor of
	638	// -x vendor:VENDOR_STR
	639	//if (!udhcp_find_option(packet.options, DHCP_VENDOR))
	640	// /* not set, set the default vendor ID */
	641	// ...add (DHCP_VENDOR, "udhcp "BB_VER) opt...
[2725]	642	}
	643
	644	/* RFC 2131
	645	* 4.4.4 Use of broadcast and unicast
	646	*
	647	* The DHCP client broadcasts DHCPDISCOVER, DHCPREQUEST and DHCPINFORM
	648	* messages, unless the client knows the address of a DHCP server.
	649	* The client unicasts DHCPRELEASE messages to the server. Because
	650	* the client is declining the use of the IP address supplied by the server,
	651	* the client broadcasts DHCPDECLINE messages.
	652	*
	653	* When the DHCP client knows the address of a DHCP server, in either
	654	* INIT or REBOOTING state, the client may use that address
	655	* in the DHCPDISCOVER or DHCPREQUEST rather than the IP broadcast address.
	656	* The client may also use unicast to send DHCPINFORM messages
	657	* to a known DHCP server. If the client receives no response to DHCP
	658	* messages sent to the IP address of a known DHCP server, the DHCP
	659	* client reverts to using the IP broadcast address.
[1765]	660	*/
[2725]	661
	662	static int raw_bcast_from_client_config_ifindex(struct dhcp_packet *packet)
	663	{
	664	return udhcp_send_raw_packet(packet,
	665	/src/ INADDR_ANY, CLIENT_PORT,
	666	/dst/ INADDR_BROADCAST, SERVER_PORT, MAC_BCAST_ADDR,
	667	client_config.ifindex);
	668	}
	669
	670	/* Broadcast a DHCP discover packet to the network, with an optionally requested IP */
	671	/* NOINLINE: limit stack usage in caller */
	672	static NOINLINE int send_discover(uint32_t xid, uint32_t requested)
	673	{
	674	struct dhcp_packet packet;
	675
	676	/* Fill in: op, htype, hlen, cookie, chaddr fields,
	677	* random xid field (we override it below),
	678	* client-id option (unless -C), message type option:
	679	*/
	680	init_packet(&packet, DHCPDISCOVER);
	681
	682	packet.xid = xid;
	683	if (requested)
	684	udhcp_add_simple_option(&packet, DHCP_REQUESTED_IP, requested);
	685
	686	/* Add options: maxsize,
	687	* optionally: hostname, fqdn, vendorclass,
	688	* "param req" option according to -O, options specified with -x
	689	*/
	690	add_client_options(&packet);
	691
	692	bb_info_msg("Sending discover...");
	693	return raw_bcast_from_client_config_ifindex(&packet);
	694	}
	695
	696	/* Broadcast a DHCP request message */
	697	/* RFC 2131 3.1 paragraph 3:
	698	* "The client _broadcasts_ a DHCPREQUEST message..."
	699	*/
	700	/* NOINLINE: limit stack usage in caller */
	701	static NOINLINE int send_select(uint32_t xid, uint32_t server, uint32_t requested)
	702	{
	703	struct dhcp_packet packet;
	704	struct in_addr addr;
	705
	706	/*
	707	* RFC 2131 4.3.2 DHCPREQUEST message
	708	* ...
	709	* If the DHCPREQUEST message contains a 'server identifier'
	710	* option, the message is in response to a DHCPOFFER message.
	711	* Otherwise, the message is a request to verify or extend an
	712	* existing lease. If the client uses a 'client identifier'
	713	* in a DHCPREQUEST message, it MUST use that same 'client identifier'
	714	* in all subsequent messages. If the client included a list
	715	* of requested parameters in a DHCPDISCOVER message, it MUST
	716	* include that list in all subsequent messages.
	717	*/
	718	/* Fill in: op, htype, hlen, cookie, chaddr fields,
	719	* random xid field (we override it below),
	720	* client-id option (unless -C), message type option:
	721	*/
	722	init_packet(&packet, DHCPREQUEST);
	723
	724	packet.xid = xid;
	725	udhcp_add_simple_option(&packet, DHCP_REQUESTED_IP, requested);
	726
	727	udhcp_add_simple_option(&packet, DHCP_SERVER_ID, server);
	728
	729	/* Add options: maxsize,
	730	* optionally: hostname, fqdn, vendorclass,
	731	* "param req" option according to -O, and options specified with -x
	732	*/
	733	add_client_options(&packet);
	734
	735	addr.s_addr = requested;
	736	bb_info_msg("Sending select for %s...", inet_ntoa(addr));
	737	return raw_bcast_from_client_config_ifindex(&packet);
	738	}
	739
	740	/* Unicast or broadcast a DHCP renew message */
	741	/* NOINLINE: limit stack usage in caller */
	742	static NOINLINE int send_renew(uint32_t xid, uint32_t server, uint32_t ciaddr)
	743	{
	744	struct dhcp_packet packet;
	745
	746	/*
	747	* RFC 2131 4.3.2 DHCPREQUEST message
	748	* ...
	749	* DHCPREQUEST generated during RENEWING state:
	750	*
	751	* 'server identifier' MUST NOT be filled in, 'requested IP address'
	752	* option MUST NOT be filled in, 'ciaddr' MUST be filled in with
	753	* client's IP address. In this situation, the client is completely
	754	* configured, and is trying to extend its lease. This message will
	755	* be unicast, so no relay agents will be involved in its
	756	* transmission. Because 'giaddr' is therefore not filled in, the
	757	* DHCP server will trust the value in 'ciaddr', and use it when
	758	* replying to the client.
	759	*/
	760	/* Fill in: op, htype, hlen, cookie, chaddr fields,
	761	* random xid field (we override it below),
	762	* client-id option (unless -C), message type option:
	763	*/
	764	init_packet(&packet, DHCPREQUEST);
	765
	766	packet.xid = xid;
	767	packet.ciaddr = ciaddr;
	768
	769	/* Add options: maxsize,
	770	* optionally: hostname, fqdn, vendorclass,
	771	* "param req" option according to -O, and options specified with -x
	772	*/
	773	add_client_options(&packet);
	774
	775	bb_info_msg("Sending renew...");
	776	if (server)
	777	return udhcp_send_kernel_packet(&packet,
	778	ciaddr, CLIENT_PORT,
	779	server, SERVER_PORT);
	780	return raw_bcast_from_client_config_ifindex(&packet);
	781	}
	782
	783	#if ENABLE_FEATURE_UDHCPC_ARPING
	784	/* Broadcast a DHCP decline message */
	785	/* NOINLINE: limit stack usage in caller */
[3232]	786	static NOINLINE int send_decline(/uint32_t xid,/ uint32_t server, uint32_t requested)
[2725]	787	{
	788	struct dhcp_packet packet;
	789
	790	/* Fill in: op, htype, hlen, cookie, chaddr, random xid fields,
	791	* client-id option (unless -C), message type option:
	792	*/
	793	init_packet(&packet, DHCPDECLINE);
	794
[3232]	795	#if 0
[2725]	796	/* RFC 2131 says DHCPDECLINE's xid is randomly selected by client,
	797	* but in case the server is buggy and wants DHCPDECLINE's xid
	798	* to match the xid which started entire handshake,
	799	* we use the same xid we used in initial DHCPDISCOVER:
	800	*/
	801	packet.xid = xid;
[3232]	802	#endif
[2725]	803	/* DHCPDECLINE uses "requested ip", not ciaddr, to store offered IP */
	804	udhcp_add_simple_option(&packet, DHCP_REQUESTED_IP, requested);
	805
	806	udhcp_add_simple_option(&packet, DHCP_SERVER_ID, server);
	807
	808	bb_info_msg("Sending decline...");
	809	return raw_bcast_from_client_config_ifindex(&packet);
	810	}
	811	#endif
	812
	813	/* Unicast a DHCP release message */
	814	static int send_release(uint32_t server, uint32_t ciaddr)
	815	{
	816	struct dhcp_packet packet;
	817
	818	/* Fill in: op, htype, hlen, cookie, chaddr, random xid fields,
	819	* client-id option (unless -C), message type option:
	820	*/
	821	init_packet(&packet, DHCPRELEASE);
	822
	823	/* DHCPRELEASE uses ciaddr, not "requested ip", to store IP being released */
	824	packet.ciaddr = ciaddr;
	825
	826	udhcp_add_simple_option(&packet, DHCP_SERVER_ID, server);
	827
	828	bb_info_msg("Sending release...");
	829	return udhcp_send_kernel_packet(&packet, ciaddr, CLIENT_PORT, server, SERVER_PORT);
	830	}
	831
	832	/* Returns -1 on errors that are fatal for the socket, -2 for those that aren't */
	833	/* NOINLINE: limit stack usage in caller */
	834	static NOINLINE int udhcp_recv_raw_packet(struct dhcp_packet *dhcp_pkt, int fd)
	835	{
	836	int bytes;
	837	struct ip_udp_dhcp_packet packet;
	838	uint16_t check;
[3232]	839	unsigned char cmsgbuf[CMSG_LEN(sizeof(struct tpacket_auxdata))];
	840	struct iovec iov;
	841	struct msghdr msg;
	842	struct cmsghdr *cmsg;
[2725]	843
[3232]	844	/* used to use just safe_read(fd, &packet, sizeof(packet))
	845	* but we need to check for TP_STATUS_CSUMNOTREADY :(
	846	*/
	847	iov.iov_base = &packet;
	848	iov.iov_len = sizeof(packet);
	849	memset(&msg, 0, sizeof(msg));
	850	msg.msg_iov = &iov;
	851	msg.msg_iovlen = 1;
	852	msg.msg_control = cmsgbuf;
	853	msg.msg_controllen = sizeof(cmsgbuf);
	854	for (;;) {
	855	bytes = recvmsg(fd, &msg, 0);
	856	if (bytes < 0) {
	857	if (errno == EINTR)
	858	continue;
	859	log1("Packet read error, ignoring");
	860	/* NB: possible down interface, etc. Caller should pause. */
	861	return bytes; /* returns -1 */
	862	}
	863	break;
[2725]	864	}
	865
	866	if (bytes < (int) (sizeof(packet.ip) + sizeof(packet.udp))) {
	867	log1("Packet is too short, ignoring");
	868	return -2;
	869	}
	870
	871	if (bytes < ntohs(packet.ip.tot_len)) {
	872	/* packet is bigger than sizeof(packet), we did partial read */
	873	log1("Oversized packet, ignoring");
	874	return -2;
	875	}
	876
	877	/* ignore any extra garbage bytes */
	878	bytes = ntohs(packet.ip.tot_len);
	879
	880	/* make sure its the right packet for us, and that it passes sanity checks */
[3232]	881	if (packet.ip.protocol != IPPROTO_UDP
	882	\|\| packet.ip.version != IPVERSION
[2725]	883	\|\| packet.ip.ihl != (sizeof(packet.ip) >> 2)
	884	\|\| packet.udp.dest != htons(CLIENT_PORT)
	885	/* \|\| bytes > (int) sizeof(packet) - can't happen */
	886	\|\| ntohs(packet.udp.len) != (uint16_t)(bytes - sizeof(packet.ip))
	887	) {
	888	log1("Unrelated/bogus packet, ignoring");
	889	return -2;
	890	}
	891
	892	/* verify IP checksum */
	893	check = packet.ip.check;
	894	packet.ip.check = 0;
[3232]	895	if (check != inet_cksum((uint16_t *)&packet.ip, sizeof(packet.ip))) {
[2725]	896	log1("Bad IP header checksum, ignoring");
	897	return -2;
	898	}
	899
[3232]	900	for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
	901	if (cmsg->cmsg_level == SOL_PACKET
	902	&& cmsg->cmsg_type == PACKET_AUXDATA
	903	) {
	904	/* some VMs don't checksum UDP and TCP data
	905	* they send to the same physical machine,
	906	* here we detect this case:
	907	*/
	908	struct tpacket_auxdata aux = (void )CMSG_DATA(cmsg);
	909	if (aux->tp_status & TP_STATUS_CSUMNOTREADY)
	910	goto skip_udp_sum_check;
	911	}
	912	}
	913
[2725]	914	/* verify UDP checksum. IP header has to be modified for this */
	915	memset(&packet.ip, 0, offsetof(struct iphdr, protocol));
	916	/* ip.xx fields which are not memset: protocol, check, saddr, daddr */
	917	packet.ip.tot_len = packet.udp.len; /* yes, this is needed */
	918	check = packet.udp.check;
	919	packet.udp.check = 0;
[3232]	920	if (check && check != inet_cksum((uint16_t *)&packet, bytes)) {
[2725]	921	log1("Packet with bad UDP checksum received, ignoring");
	922	return -2;
	923	}
[3232]	924	skip_udp_sum_check:
[2725]	925
[3232]	926	if (packet.data.cookie != htonl(DHCP_MAGIC)) {
[2725]	927	bb_info_msg("Packet with bad magic, ignoring");
	928	return -2;
	929	}
[3232]	930
	931	log1("Received a packet");
	932	udhcp_dump_packet(&packet.data);
	933
	934	bytes -= sizeof(packet.ip) + sizeof(packet.udp);
	935	memcpy(dhcp_pkt, &packet.data, bytes);
	936	return bytes;
[2725]	937	}
	938
	939
	940	/* Main */
	941
[1765]	942	static int sockfd = -1;
[821]	943
[2725]	944	#define LISTEN_NONE 0
[821]	945	#define LISTEN_KERNEL 1
[2725]	946	#define LISTEN_RAW 2
[1765]	947	static smallint listen_mode;
[821]	948
[2725]	949	/* initial state: (re)start DHCP negotiation */
	950	#define INIT_SELECTING 0
	951	/* discover was sent, DHCPOFFER reply received */
	952	#define REQUESTING 1
	953	/* select/renew was sent, DHCPACK reply received */
	954	#define BOUND 2
	955	/* half of lease passed, want to renew it by sending unicast renew requests */
	956	#define RENEWING 3
	957	/* renew requests were not answered, lease is almost over, send broadcast renew */
	958	#define REBINDING 4
	959	/* manually requested renew (SIGUSR1) */
	960	#define RENEW_REQUESTED 5
	961	/* release, possibly manually requested (SIGUSR2) */
	962	#define RELEASED 6
[1765]	963	static smallint state;
[821]	964
[2725]	965	static int udhcp_raw_socket(int ifindex)
	966	{
	967	int fd;
	968	struct sockaddr_ll sock;
[1765]	969
[2725]	970	/*
	971	* Comment:
	972	*
	973	* I've selected not to see LL header, so BPF doesn't see it, too.
	974	* The filter may also pass non-IP and non-ARP packets, but we do
	975	* a more complete check when receiving the message in userspace.
	976	*
	977	* and filter shamelessly stolen from:
	978	*
	979	* http://www.flamewarmaster.de/software/dhcpclient/
	980	*
	981	* There are a few other interesting ideas on that page (look under
	982	* "Motivation"). Use of netlink events is most interesting. Think
	983	* of various network servers listening for events and reconfiguring.
	984	* That would obsolete sending HUP signals and/or make use of restarts.
	985	*
	986	* Copyright: 2006, 2007 Stefan Rompf <sux@loplof.de>.
	987	* License: GPL v2.
	988	*
	989	* TODO: make conditional?
	990	*/
	991	static const struct sock_filter filter_instr[] = {
[3232]	992	/* load 9th byte (protocol) */
[2725]	993	BPF_STMT(BPF_LD\|BPF_B\|BPF_ABS, 9),
[3232]	994	/* jump to L1 if it is IPPROTO_UDP, else to L4 */
	995	BPF_JUMP(BPF_JMP\|BPF_JEQ\|BPF_K, IPPROTO_UDP, 0, 6),
	996	/* L1: load halfword from offset 6 (flags and frag offset) */
	997	BPF_STMT(BPF_LD\|BPF_H\|BPF_ABS, 6),
	998	/* jump to L4 if any bits in frag offset field are set, else to L2 */
	999	BPF_JUMP(BPF_JMP\|BPF_JSET\|BPF_K, 0x1fff, 4, 0),
	1000	/* L2: skip IP header (load index reg with header len) */
	1001	BPF_STMT(BPF_LDX\|BPF_B\|BPF_MSH, 0),
	1002	/* load udp destination port from halfword[header_len + 2] */
	1003	BPF_STMT(BPF_LD\|BPF_H\|BPF_IND, 2),
	1004	/* jump to L3 if udp dport is CLIENT_PORT, else to L4 */
	1005	BPF_JUMP(BPF_JMP\|BPF_JEQ\|BPF_K, 68, 0, 1),
	1006	/* L3: accept packet */
	1007	BPF_STMT(BPF_RET\|BPF_K, 0xffffffff),
	1008	/* L4: discard packet */
	1009	BPF_STMT(BPF_RET\|BPF_K, 0),
[2725]	1010	};
	1011	static const struct sock_fprog filter_prog = {
	1012	.len = sizeof(filter_instr) / sizeof(filter_instr[0]),
	1013	/* casting const away: */
	1014	.filter = (struct sock_filter *) filter_instr,
	1015	};
[1765]	1016
[2725]	1017	log1("Opening raw socket on ifindex %d", ifindex); //log2?
	1018
	1019	fd = xsocket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));
[3232]	1020	log1("Got raw socket fd"); //log2?
[2725]	1021
[3232]	1022	sock.sll_family = AF_PACKET;
	1023	sock.sll_protocol = htons(ETH_P_IP);
	1024	sock.sll_ifindex = ifindex;
	1025	xbind(fd, (struct sockaddr *) &sock, sizeof(sock));
	1026
	1027	if (CLIENT_PORT == 68) {
	1028	/* Use only if standard port is in use */
[2725]	1029	/* Ignoring error (kernel may lack support for this) */
	1030	if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &filter_prog,
	1031	sizeof(filter_prog)) >= 0)
[3232]	1032	log1("Attached filter to raw socket fd"); // log?
[2725]	1033	}
	1034
[3232]	1035	if (setsockopt(fd, SOL_PACKET, PACKET_AUXDATA,
	1036	&const_int_1, sizeof(int)) < 0
	1037	) {
	1038	if (errno != ENOPROTOOPT)
	1039	log1("Can't set PACKET_AUXDATA on raw socket");
	1040	}
	1041
[2725]	1042	log1("Created raw socket");
	1043
	1044	return fd;
	1045	}
	1046
	1047	static void change_listen_mode(int new_mode)
[821]	1048	{
[2725]	1049	log1("Entering listen mode: %s",
	1050	new_mode != LISTEN_NONE
	1051	? (new_mode == LISTEN_KERNEL ? "kernel" : "raw")
	1052	: "none"
	1053	);
	1054
	1055	listen_mode = new_mode;
[1765]	1056	if (sockfd >= 0) {
	1057	close(sockfd);
	1058	sockfd = -1;
	1059	}
[2725]	1060	if (new_mode == LISTEN_KERNEL)
	1061	sockfd = udhcp_listen_socket(/INADDR_ANY,/ CLIENT_PORT, client_config.interface);
	1062	else if (new_mode != LISTEN_NONE)
	1063	sockfd = udhcp_raw_socket(client_config.ifindex);
	1064	/* else LISTEN_NONE: sockfd stays closed */
[821]	1065	}
	1066
[3232]	1067	/* Called only on SIGUSR1 */
[821]	1068	static void perform_renew(void)
	1069	{
[1765]	1070	bb_info_msg("Performing a DHCP renew");
[821]	1071	switch (state) {
	1072	case BOUND:
[2725]	1073	change_listen_mode(LISTEN_KERNEL);
[821]	1074	case RENEWING:
	1075	case REBINDING:
	1076	state = RENEW_REQUESTED;
	1077	break;
	1078	case RENEW_REQUESTED: /* impatient are we? fine, square 1 */
	1079	udhcp_run_script(NULL, "deconfig");
	1080	case REQUESTING:
	1081	case RELEASED:
[2725]	1082	change_listen_mode(LISTEN_RAW);
[821]	1083	state = INIT_SELECTING;
	1084	break;
	1085	case INIT_SELECTING:
	1086	break;
	1087	}
	1088	}
	1089
[3232]	1090	static void perform_release(uint32_t server_addr, uint32_t requested_ip)
[821]	1091	{
[1765]	1092	char buffer[sizeof("255.255.255.255")];
[821]	1093	struct in_addr temp_addr;
	1094
	1095	/* send release packet */
	1096	if (state == BOUND \|\| state == RENEWING \|\| state == REBINDING) {
	1097	temp_addr.s_addr = server_addr;
[1765]	1098	strcpy(buffer, inet_ntoa(temp_addr));
[821]	1099	temp_addr.s_addr = requested_ip;
[1765]	1100	bb_info_msg("Unicasting a release of %s to %s",
[821]	1101	inet_ntoa(temp_addr), buffer);
	1102	send_release(server_addr, requested_ip); /* unicast */
	1103	udhcp_run_script(NULL, "deconfig");
	1104	}
[1765]	1105	bb_info_msg("Entering released state");
[821]	1106
[2725]	1107	change_listen_mode(LISTEN_NONE);
[821]	1108	state = RELEASED;
	1109	}
	1110
[1765]	1111	static uint8_t* alloc_dhcp_option(int code, const char *str, int extra)
[821]	1112	{
[1765]	1113	uint8_t *storage;
[2725]	1114	int len = strnlen(str, 255);
[1765]	1115	storage = xzalloc(len + extra + OPT_DATA);
	1116	storage[OPT_CODE] = code;
	1117	storage[OPT_LEN] = len + extra;
	1118	memcpy(storage + extra + OPT_DATA, str, len);
	1119	return storage;
	1120	}
	1121
[2725]	1122	#if BB_MMU
	1123	static void client_background(void)
	1124	{
	1125	bb_daemonize(0);
	1126	logmode &= ~LOGMODE_STDIO;
	1127	/* rewrite pidfile, as our pid is different now */
	1128	write_pidfile(client_config.pidfile);
	1129	}
	1130	#endif
[1765]	1131
[2725]	1132	//usage:#if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
	1133	//usage:# define IF_UDHCP_VERBOSE(...) __VA_ARGS__
	1134	//usage:#else
	1135	//usage:# define IF_UDHCP_VERBOSE(...)
	1136	//usage:#endif
	1137	//usage:#define udhcpc_trivial_usage
[3232]	1138	//usage: "[-fbnq"IF_UDHCP_VERBOSE("v")"oCRB] [-i IFACE] [-r IP] [-s PROG] [-p PIDFILE]\n"
	1139	//usage: " [-V VENDOR] [-x OPT:VAL]... [-O OPT]..." IF_FEATURE_UDHCP_PORT(" [-P N]")
[2725]	1140	//usage:#define udhcpc_full_usage "\n"
	1141	//usage: IF_LONG_OPTS(
	1142	//usage: "\n -i,--interface IFACE Interface to use (default eth0)"
	1143	//usage: "\n -p,--pidfile FILE Create pidfile"
	1144	//usage: "\n -s,--script PROG Run PROG at DHCP events (default "CONFIG_UDHCPC_DEFAULT_SCRIPT")"
[3232]	1145	//usage: "\n -B,--broadcast Request broadcast replies"
[2725]	1146	//usage: "\n -t,--retries N Send up to N discover packets"
	1147	//usage: "\n -T,--timeout N Pause between packets (default 3 seconds)"
	1148	//usage: "\n -A,--tryagain N Wait N seconds after failure (default 20)"
	1149	//usage: "\n -f,--foreground Run in foreground"
	1150	//usage: USE_FOR_MMU(
	1151	//usage: "\n -b,--background Background if lease is not obtained"
	1152	//usage: )
	1153	//usage: "\n -n,--now Exit if lease is not obtained"
	1154	//usage: "\n -q,--quit Exit after obtaining lease"
	1155	//usage: "\n -R,--release Release IP on exit"
	1156	//usage: "\n -S,--syslog Log to syslog too"
	1157	//usage: IF_FEATURE_UDHCP_PORT(
	1158	//usage: "\n -P,--client-port N Use port N (default 68)"
	1159	//usage: )
	1160	//usage: IF_FEATURE_UDHCPC_ARPING(
	1161	//usage: "\n -a,--arping Use arping to validate offered address"
	1162	//usage: )
	1163	//usage: "\n -O,--request-option OPT Request option OPT from server (cumulative)"
	1164	//usage: "\n -o,--no-default-options Don't request any options (unless -O is given)"
	1165	//usage: "\n -r,--request IP Request this IP address"
	1166	//usage: "\n -x OPT:VAL Include option OPT in sent packets (cumulative)"
	1167	//usage: "\n Examples of string, numeric, and hex byte opts:"
	1168	//usage: "\n -x hostname:bbox - option 12"
	1169	//usage: "\n -x lease:3600 - option 51 (lease time)"
	1170	//usage: "\n -x 0x3d:0100BEEFC0FFEE - option 61 (client id)"
	1171	//usage: "\n -F,--fqdn NAME Ask server to update DNS mapping for NAME"
	1172	//usage: "\n -V,--vendorclass VENDOR Vendor identifier (default 'udhcp VERSION')"
	1173	//usage: "\n -C,--clientid-none Don't send MAC as client identifier"
	1174	//usage: IF_UDHCP_VERBOSE(
	1175	//usage: "\n -v Verbose"
	1176	//usage: )
	1177	//usage: )
	1178	//usage: IF_NOT_LONG_OPTS(
	1179	//usage: "\n -i IFACE Interface to use (default eth0)"
	1180	//usage: "\n -p FILE Create pidfile"
	1181	//usage: "\n -s PROG Run PROG at DHCP events (default "CONFIG_UDHCPC_DEFAULT_SCRIPT")"
[3232]	1182	//usage: "\n -B Request broadcast replies"
[2725]	1183	//usage: "\n -t N Send up to N discover packets"
	1184	//usage: "\n -T N Pause between packets (default 3 seconds)"
	1185	//usage: "\n -A N Wait N seconds (default 20) after failure"
	1186	//usage: "\n -f Run in foreground"
	1187	//usage: USE_FOR_MMU(
	1188	//usage: "\n -b Background if lease is not obtained"
	1189	//usage: )
	1190	//usage: "\n -n Exit if lease is not obtained"
	1191	//usage: "\n -q Exit after obtaining lease"
	1192	//usage: "\n -R Release IP on exit"
	1193	//usage: "\n -S Log to syslog too"
	1194	//usage: IF_FEATURE_UDHCP_PORT(
	1195	//usage: "\n -P N Use port N (default 68)"
	1196	//usage: )
	1197	//usage: IF_FEATURE_UDHCPC_ARPING(
	1198	//usage: "\n -a Use arping to validate offered address"
	1199	//usage: )
	1200	//usage: "\n -O OPT Request option OPT from server (cumulative)"
	1201	//usage: "\n -o Don't request any options (unless -O is given)"
	1202	//usage: "\n -r IP Request this IP address"
	1203	//usage: "\n -x OPT:VAL Include option OPT in sent packets (cumulative)"
	1204	//usage: "\n Examples of string, numeric, and hex byte opts:"
	1205	//usage: "\n -x hostname:bbox - option 12"
	1206	//usage: "\n -x lease:3600 - option 51 (lease time)"
	1207	//usage: "\n -x 0x3d:0100BEEFC0FFEE - option 61 (client id)"
	1208	//usage: "\n -F NAME Ask server to update DNS mapping for NAME"
	1209	//usage: "\n -V VENDOR Vendor identifier (default 'udhcp VERSION')"
	1210	//usage: "\n -C Don't send MAC as client identifier"
	1211	//usage: IF_UDHCP_VERBOSE(
	1212	//usage: "\n -v Verbose"
	1213	//usage: )
	1214	//usage: )
[3232]	1215	//usage: "\nSignals:"
	1216	//usage: "\n USR1 Renew lease"
	1217	//usage: "\n USR2 Release lease"
[2725]	1218
[3232]	1219
[2725]	1220	int udhcpc_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
	1221	int udhcpc_main(int argc UNUSED_PARAM, char **argv)
[1765]	1222	{
[821]	1223	uint8_t temp, message;
[2725]	1224	const char str_V, str_h, str_F, str_r;
	1225	IF_FEATURE_UDHCP_PORT(char *str_P;)
	1226	void *clientid_mac_ptr;
	1227	llist_t *list_O = NULL;
	1228	llist_t *list_x = NULL;
	1229	int tryagain_timeout = 20;
	1230	int discover_timeout = 3;
	1231	int discover_retries = 3;
	1232	uint32_t server_addr = server_addr; /* for compiler */
	1233	uint32_t requested_ip = 0;
[3232]	1234	uint32_t xid = xid; /* for compiler */
[2725]	1235	int packet_num;
	1236	int timeout; /* must be signed */
	1237	unsigned already_waited_sec;
[1765]	1238	unsigned opt;
	1239	int max_fd;
[821]	1240	int retval;
[1765]	1241	fd_set rfds;
[821]	1242
[2725]	1243	/* Default options */
	1244	IF_FEATURE_UDHCP_PORT(SERVER_PORT = 67;)
	1245	IF_FEATURE_UDHCP_PORT(CLIENT_PORT = 68;)
[1765]	1246	client_config.interface = "eth0";
[2725]	1247	client_config.script = CONFIG_UDHCPC_DEFAULT_SCRIPT;
	1248	str_V = "udhcp "BB_VER;
[821]	1249
[1765]	1250	/* Parse command line */
[2725]	1251	/* O,x: list; -T,-t,-A take numeric param */
[3232]	1252	opt_complementary = "O::x::T+:t+:A+" IF_UDHCP_VERBOSE(":vv") ;
[2725]	1253	IF_LONG_OPTS(applet_long_options = udhcpc_longopts;)
[3232]	1254	opt = getopt32(argv, "CV:H:h:F:i:np:qRr:s:T:t:SA:O:ox:fB"
[2725]	1255	USE_FOR_MMU("b")
	1256	IF_FEATURE_UDHCPC_ARPING("a")
	1257	IF_FEATURE_UDHCP_PORT("P:")
	1258	"v"
	1259	, &str_V, &str_h, &str_h, &str_F
	1260	, &client_config.interface, &client_config.pidfile, &str_r /* i,p */
	1261	, &client_config.script /* s */
	1262	, &discover_timeout, &discover_retries, &tryagain_timeout /* T,t,A */
	1263	, &list_O
	1264	, &list_x
	1265	IF_FEATURE_UDHCP_PORT(, &str_P)
[3232]	1266	IF_UDHCP_VERBOSE(, &dhcp_verbose)
	1267	);
	1268	if (opt & (OPT_h\|OPT_H)) {
	1269	//msg added 2011-11
	1270	bb_error_msg("option -h NAME is deprecated, use -x hostname:NAME");
[1765]	1271	client_config.hostname = alloc_dhcp_option(DHCP_HOST_NAME, str_h, 0);
[3232]	1272	}
[1765]	1273	if (opt & OPT_F) {
[2725]	1274	/* FQDN option format: [0x51][len][flags][0][0]<fqdn> */
[1765]	1275	client_config.fqdn = alloc_dhcp_option(DHCP_FQDN, str_F, 3);
[2725]	1276	/* Flag bits: 0000NEOS
	1277	* S: 1 = Client requests server to update A RR in DNS as well as PTR
	1278	* O: 1 = Server indicates to client that DNS has been updated regardless
	1279	* E: 1 = Name is in DNS format, i.e. <4>host<6>domain<3>com<0>,
	1280	* not "host.domain.com". Format 0 is obsolete.
	1281	* N: 1 = Client requests server to not update DNS (S must be 0 then)
	1282	* Two [0] bytes which follow are deprecated and must be 0.
	1283	*/
[1765]	1284	client_config.fqdn[OPT_DATA + 0] = 0x1;
[2725]	1285	/client_config.fqdn[OPT_DATA + 1] = 0; - xzalloc did it /
	1286	/client_config.fqdn[OPT_DATA + 2] = 0; /
[821]	1287	}
[1765]	1288	if (opt & OPT_r)
	1289	requested_ip = inet_addr(str_r);
[2725]	1290	#if ENABLE_FEATURE_UDHCP_PORT
	1291	if (opt & OPT_P) {
	1292	CLIENT_PORT = xatou16(str_P);
	1293	SERVER_PORT = CLIENT_PORT - 1;
[1765]	1294	}
[2725]	1295	#endif
	1296	while (list_O) {
	1297	char *optstr = llist_pop(&list_O);
[3232]	1298	unsigned n = bb_strtou(optstr, NULL, 0);
	1299	if (errno \|\| n > 254) {
	1300	n = udhcp_option_idx(optstr);
	1301	n = dhcp_optflags[n].code;
	1302	}
[2725]	1303	client_config.opt_mask[n >> 3] \|= 1 << (n & 7);
	1304	}
[3232]	1305	if (!(opt & OPT_o)) {
	1306	unsigned i, n;
	1307	for (i = 0; (n = dhcp_optflags[i].code) != 0; i++) {
	1308	if (dhcp_optflags[i].flags & OPTION_REQ) {
	1309	client_config.opt_mask[n >> 3] \|= 1 << (n & 7);
	1310	}
	1311	}
	1312	}
[2725]	1313	while (list_x) {
	1314	char *optstr = llist_pop(&list_x);
	1315	char *colon = strchr(optstr, ':');
	1316	if (colon)
	1317	*colon = ' ';
	1318	/* now it looks similar to udhcpd's config file line:
	1319	* "optname optval", using the common routine: */
	1320	udhcp_str2optset(optstr, &client_config.options);
	1321	}
[821]	1322
[2725]	1323	if (udhcp_read_interface(client_config.interface,
	1324	&client_config.ifindex,
	1325	NULL,
	1326	client_config.client_mac)
	1327	) {
	1328	return 1;
	1329	}
	1330
	1331	clientid_mac_ptr = NULL;
	1332	if (!(opt & OPT_C) && !udhcp_find_option(client_config.options, DHCP_CLIENT_ID)) {
	1333	/* not suppressed and not set, set the default client ID */
	1334	client_config.clientid = alloc_dhcp_option(DHCP_CLIENT_ID, "", 7);
	1335	client_config.clientid[OPT_DATA] = 1; /* type: ethernet */
	1336	clientid_mac_ptr = client_config.clientid + OPT_DATA+1;
	1337	memcpy(clientid_mac_ptr, client_config.client_mac, 6);
	1338	}
[3232]	1339	if (str_V[0] != '\0') {
	1340	// can drop -V, str_V, client_config.vendorclass,
	1341	// but need to add "vendor" to the list of recognized
	1342	// string opts for this to work;
	1343	// and need to tweak add_client_options() too...
	1344	// ...so the question is, should we?
	1345	//bb_error_msg("option -V VENDOR is deprecated, use -x vendor:VENDOR");
[2725]	1346	client_config.vendorclass = alloc_dhcp_option(DHCP_VENDOR, str_V, 0);
[3232]	1347	}
	1348
[2725]	1349	#if !BB_MMU
	1350	/* on NOMMU reexec (i.e., background) early */
	1351	if (!(opt & OPT_f)) {
	1352	bb_daemonize_or_rexec(0 /* flags */, argv);
	1353	logmode = LOGMODE_NONE;
	1354	}
	1355	#endif
[1765]	1356	if (opt & OPT_S) {
[2725]	1357	openlog(applet_name, LOG_PID, LOG_DAEMON);
[1765]	1358	logmode \|= LOGMODE_SYSLOG;
	1359	}
[821]	1360
[1765]	1361	/* Make sure fd 0,1,2 are open */
	1362	bb_sanitize_stdio();
	1363	/* Equivalent of doing a fflush after every \n */
	1364	setlinebuf(stdout);
	1365	/* Create pidfile */
	1366	write_pidfile(client_config.pidfile);
[2725]	1367	/* Goes to stdout (unless NOMMU) and possibly syslog */
	1368	bb_info_msg("%s (v"BB_VER") started", applet_name);
	1369	/* Set up the signal pipe */
[821]	1370	udhcp_sp_setup();
[2725]	1371	/* We want random_xid to be random... */
	1372	srand(monotonic_us());
[821]	1373
	1374	state = INIT_SELECTING;
	1375	udhcp_run_script(NULL, "deconfig");
[2725]	1376	change_listen_mode(LISTEN_RAW);
	1377	packet_num = 0;
	1378	timeout = 0;
	1379	already_waited_sec = 0;
[821]	1380
[2725]	1381	/* Main event loop. select() waits on signal pipe and possibly
	1382	* on sockfd.
	1383	* "continue" statements in code below jump to the top of the loop.
	1384	*/
[821]	1385	for (;;) {
[3232]	1386	struct timeval tv;
	1387	struct dhcp_packet packet;
[2725]	1388	/* silence "uninitialized!" warning */
	1389	unsigned timestamp_before_wait = timestamp_before_wait;
[821]	1390
[2725]	1391	//bb_error_msg("sockfd:%d, listen_mode:%d", sockfd, listen_mode);
	1392
	1393	/* Was opening raw or udp socket here
	1394	* if (listen_mode != LISTEN_NONE && sockfd < 0),
	1395	* but on fast network renew responses return faster
	1396	* than we open sockets. Thus this code is moved
	1397	* to change_listen_mode(). Thus we open listen socket
	1398	* BEFORE we send renew request (see "case BOUND:"). */
	1399
[1765]	1400	max_fd = udhcp_sp_fd_set(&rfds, sockfd);
[821]	1401
[2725]	1402	tv.tv_sec = timeout - already_waited_sec;
	1403	tv.tv_usec = 0;
	1404	retval = 0;
	1405	/* If we already timed out, fall through with retval = 0, else... */
	1406	if ((int)tv.tv_sec > 0) {
[3232]	1407	log1("Waiting on select %u seconds", (int)tv.tv_sec);
[2725]	1408	timestamp_before_wait = (unsigned)monotonic_sec();
[821]	1409	retval = select(max_fd + 1, &rfds, NULL, NULL, &tv);
[2725]	1410	if (retval < 0) {
	1411	/* EINTR? A signal was caught, don't panic */
	1412	if (errno == EINTR) {
	1413	already_waited_sec += (unsigned)monotonic_sec() - timestamp_before_wait;
	1414	continue;
	1415	}
[1765]	1416	/* Else: an error occured, panic! */
	1417	bb_perror_msg_and_die("select");
	1418	}
[2725]	1419	}
	1420
	1421	/* If timeout dropped to zero, time to become active:
	1422	* resend discover/renew/whatever
	1423	*/
	1424	if (retval == 0) {
	1425	/* When running on a bridge, the ifindex may have changed
	1426	* (e.g. if member interfaces were added/removed
	1427	* or if the status of the bridge changed).
	1428	* Refresh ifindex and client_mac:
	1429	*/
	1430	if (udhcp_read_interface(client_config.interface,
	1431	&client_config.ifindex,
	1432	NULL,
	1433	client_config.client_mac)
	1434	) {
[3232]	1435	goto ret0; /* iface is gone? */
[2725]	1436	}
	1437	if (clientid_mac_ptr)
	1438	memcpy(clientid_mac_ptr, client_config.client_mac, 6);
	1439
	1440	/* We will restart the wait in any case */
	1441	already_waited_sec = 0;
	1442
[821]	1443	switch (state) {
	1444	case INIT_SELECTING:
[3232]	1445	if (!discover_retries \|\| packet_num < discover_retries) {
[821]	1446	if (packet_num == 0)
	1447	xid = random_xid();
[2725]	1448	/* broadcast */
	1449	send_discover(xid, requested_ip);
	1450	timeout = discover_timeout;
[821]	1451	packet_num++;
[2725]	1452	continue;
[821]	1453	}
[2725]	1454	leasefail:
	1455	udhcp_run_script(NULL, "leasefail");
	1456	#if BB_MMU /* -b is not supported on NOMMU */
	1457	if (opt & OPT_b) { /* background if no lease */
	1458	bb_info_msg("No lease, forking to background");
	1459	client_background();
	1460	/* do not background again! */
	1461	opt = ((opt & ~OPT_b) \| OPT_f);
	1462	} else
	1463	#endif
	1464	if (opt & OPT_n) { /* abort if no lease */
	1465	bb_info_msg("No lease, failing");
	1466	retval = 1;
	1467	goto ret;
	1468	}
	1469	/* wait before trying again */
	1470	timeout = tryagain_timeout;
	1471	packet_num = 0;
	1472	continue;
[821]	1473	case REQUESTING:
[3232]	1474	if (!discover_retries \|\| packet_num < discover_retries) {
[2725]	1475	/* send broadcast select packet */
	1476	send_select(xid, server_addr, requested_ip);
	1477	timeout = discover_timeout;
[821]	1478	packet_num++;
[2725]	1479	continue;
[821]	1480	}
[2725]	1481	/* Timed out, go back to init state.
	1482	* "discover...select...discover..." loops
	1483	* were seen in the wild. Treat them similarly
	1484	* to "no response to discover" case */
	1485	change_listen_mode(LISTEN_RAW);
	1486	state = INIT_SELECTING;
	1487	goto leasefail;
[821]	1488	case BOUND:
[2725]	1489	/* 1/2 lease passed, enter renewing state */
[821]	1490	state = RENEWING;
[3232]	1491	client_config.first_secs = 0; /* make secs field count from 0 */
[2725]	1492	change_listen_mode(LISTEN_KERNEL);
	1493	log1("Entering renew state");
[821]	1494	/* fall right through */
[2725]	1495	case RENEW_REQUESTED: /* manual (SIGUSR1) renew */
	1496	case_RENEW_REQUESTED:
[821]	1497	case RENEWING:
[2725]	1498	if (timeout > 60) {
	1499	/* send an unicast renew request */
	1500	/* Sometimes observed to fail (EADDRNOTAVAIL) to bind
	1501	* a new UDP socket for sending inside send_renew.
	1502	* I hazard to guess existing listening socket
	1503	* is somehow conflicting with it, but why is it
	1504	* not deterministic then?! Strange.
	1505	* Anyway, it does recover by eventually failing through
	1506	* into INIT_SELECTING state.
	1507	*/
	1508	send_renew(xid, server_addr, requested_ip);
	1509	timeout >>= 1;
	1510	continue;
[821]	1511	}
[2725]	1512	/* Timed out, enter rebinding state */
	1513	log1("Entering rebinding state");
	1514	state = REBINDING;
	1515	/* fall right through */
[821]	1516	case REBINDING:
[2725]	1517	/* Switch to bcast receive */
	1518	change_listen_mode(LISTEN_RAW);
	1519	/* Lease is really about to run out,
	1520	* try to find DHCP server using broadcast */
	1521	if (timeout > 0) {
	1522	/* send a broadcast renew request */
	1523	send_renew(xid, 0 /INADDR_ANY/, requested_ip);
	1524	timeout >>= 1;
	1525	continue;
[821]	1526	}
[2725]	1527	/* Timed out, enter init state */
	1528	bb_info_msg("Lease lost, entering init state");
	1529	udhcp_run_script(NULL, "deconfig");
	1530	state = INIT_SELECTING;
[3232]	1531	client_config.first_secs = 0; /* make secs field count from 0 */
[2725]	1532	/timeout = 0; - already is /
	1533	packet_num = 0;
	1534	continue;
	1535	/* case RELEASED: */
[821]	1536	}
[2725]	1537	/* yah, I know, you say it would never happen */
	1538	timeout = INT_MAX;
	1539	continue; /* back to main loop */
	1540	} /* if select timed out */
[821]	1541
[2725]	1542	/* select() didn't timeout, something happened */
[821]	1543
[2725]	1544	/* Is it a signal? */
	1545	/* note: udhcp_sp_read checks FD_ISSET before reading */
	1546	switch (udhcp_sp_read(&rfds)) {
	1547	case SIGUSR1:
[3232]	1548	client_config.first_secs = 0; /* make secs field count from 0 */
	1549	already_waited_sec = 0;
[2725]	1550	perform_renew();
[3232]	1551	if (state == RENEW_REQUESTED) {
	1552	/* We might be either on the same network
	1553	* (in which case renew might work),
	1554	* or we might be on a completely different one
	1555	* (in which case renew won't ever succeed).
	1556	* For the second case, must make sure timeout
	1557	* is not too big, or else we can send
	1558	* futile renew requests for hours.
	1559	* (Ab)use -A TIMEOUT value (usually 20 sec)
	1560	* as a cap on the timeout.
	1561	*/
	1562	if (timeout > tryagain_timeout)
	1563	timeout = tryagain_timeout;
[2725]	1564	goto case_RENEW_REQUESTED;
[3232]	1565	}
[2725]	1566	/* Start things over */
	1567	packet_num = 0;
	1568	/* Kill any timeouts, user wants this to hurry along */
	1569	timeout = 0;
	1570	continue;
	1571	case SIGUSR2:
[3232]	1572	perform_release(server_addr, requested_ip);
[2725]	1573	timeout = INT_MAX;
	1574	continue;
	1575	case SIGTERM:
	1576	bb_info_msg("Received SIGTERM");
	1577	goto ret0;
	1578	}
[821]	1579
[2725]	1580	/* Is it a packet? */
	1581	if (listen_mode == LISTEN_NONE \|\| !FD_ISSET(sockfd, &rfds))
	1582	continue; /* no */
	1583
	1584	{
	1585	int len;
	1586
	1587	/* A packet is ready, read it */
	1588	if (listen_mode == LISTEN_KERNEL)
	1589	len = udhcp_recv_kernel_packet(&packet, sockfd);
	1590	else
	1591	len = udhcp_recv_raw_packet(&packet, sockfd);
	1592	if (len == -1) {
	1593	/* Error is severe, reopen socket */
	1594	bb_info_msg("Read error: %s, reopening socket", strerror(errno));
	1595	sleep(discover_timeout); /* 3 seconds by default */
	1596	change_listen_mode(listen_mode); /* just close and reopen */
[821]	1597	}
[2725]	1598	/* If this packet will turn out to be unrelated/bogus,
	1599	* we will go back and wait for next one.
	1600	* Be sure timeout is properly decreased. */
	1601	already_waited_sec += (unsigned)monotonic_sec() - timestamp_before_wait;
	1602	if (len < 0)
[821]	1603	continue;
[2725]	1604	}
[821]	1605
[2725]	1606	if (packet.xid != xid) {
	1607	log1("xid %x (our is %x), ignoring packet",
	1608	(unsigned)packet.xid, (unsigned)xid);
	1609	continue;
	1610	}
	1611
	1612	/* Ignore packets that aren't for us */
	1613	if (packet.hlen != 6
	1614	\|\| memcmp(packet.chaddr, client_config.client_mac, 6) != 0
	1615	) {
	1616	//FIXME: need to also check that last 10 bytes are zero
	1617	log1("chaddr does not match, ignoring packet"); // log2?
	1618	continue;
	1619	}
	1620
	1621	message = udhcp_get_option(&packet, DHCP_MESSAGE_TYPE);
	1622	if (message == NULL) {
	1623	bb_error_msg("no message type option, ignoring packet");
	1624	continue;
	1625	}
	1626
	1627	switch (state) {
	1628	case INIT_SELECTING:
[3232]	1629	/* Must be a DHCPOFFER */
[2725]	1630	if (*message == DHCPOFFER) {
[3232]	1631	/* What exactly is server's IP? There are several values.
	1632	* Example DHCP offer captured with tchdump:
	1633	*
	1634	* 10.34.25.254:67 > 10.34.25.202:68 // IP header's src
	1635	* BOOTP fields:
	1636	* Your-IP 10.34.25.202
	1637	* Server-IP 10.34.32.125 // "next server" IP
	1638	* Gateway-IP 10.34.25.254 // relay's address (if DHCP relays are in use)
	1639	* DHCP options:
	1640	* DHCP-Message Option 53, length 1: Offer
	1641	* Server-ID Option 54, length 4: 10.34.255.7 // "server ID"
	1642	* Default-Gateway Option 3, length 4: 10.34.25.254 // router
	1643	*
	1644	* We think that real server IP (one to use in renew/release)
	1645	* is one in Server-ID option. But I am not 100% sure.
	1646	* IP header's src and Gateway-IP (same in this example)
	1647	* might work too.
	1648	* "Next server" and router are definitely wrong ones to use, though...
	1649	*/
[2725]	1650	temp = udhcp_get_option(&packet, DHCP_SERVER_ID);
	1651	if (!temp) {
	1652	bb_error_msg("no server ID, ignoring packet");
	1653	continue;
	1654	/* still selecting - this server looks bad */
	1655	}
	1656	/* it IS unaligned sometimes, don't "optimize" */
	1657	move_from_unaligned32(server_addr, temp);
	1658	/xid = packet.xid; - already is /
	1659	requested_ip = packet.yiaddr;
	1660
	1661	/* enter requesting state */
	1662	state = REQUESTING;
	1663	timeout = 0;
	1664	packet_num = 0;
	1665	already_waited_sec = 0;
[821]	1666	}
[2725]	1667	continue;
	1668	case REQUESTING:
	1669	case RENEWING:
	1670	case RENEW_REQUESTED:
	1671	case REBINDING:
	1672	if (*message == DHCPACK) {
[3232]	1673	uint32_t lease_seconds;
	1674	struct in_addr temp_addr;
	1675
[2725]	1676	temp = udhcp_get_option(&packet, DHCP_LEASE_TIME);
	1677	if (!temp) {
	1678	bb_error_msg("no lease time with ACK, using 1 hour lease");
	1679	lease_seconds = 60 * 60;
	1680	} else {
	1681	/* it IS unaligned sometimes, don't "optimize" */
	1682	move_from_unaligned32(lease_seconds, temp);
	1683	lease_seconds = ntohl(lease_seconds);
[3232]	1684	/* paranoia: must not be too small and not prone to overflows */
	1685	if (lease_seconds < 0x10)
	1686	lease_seconds = 0x10;
	1687	if (lease_seconds >= 0x10000000)
	1688	lease_seconds = 0x0fffffff;
[2725]	1689	}
	1690	#if ENABLE_FEATURE_UDHCPC_ARPING
	1691	if (opt & OPT_a) {
	1692	/* RFC 2131 3.1 paragraph 5:
	1693	* "The client receives the DHCPACK message with configuration
	1694	* parameters. The client SHOULD perform a final check on the
	1695	* parameters (e.g., ARP for allocated network address), and notes
	1696	* the duration of the lease specified in the DHCPACK message. At this
	1697	* point, the client is configured. If the client detects that the
	1698	* address is already in use (e.g., through the use of ARP),
	1699	* the client MUST send a DHCPDECLINE message to the server and restarts
	1700	* the configuration process..." */
	1701	if (!arpping(packet.yiaddr,
	1702	NULL,
	1703	(uint32_t) 0,
	1704	client_config.client_mac,
	1705	client_config.interface)
	1706	) {
	1707	bb_info_msg("Offered address is in use "
	1708	"(got ARP reply), declining");
[3232]	1709	send_decline(/xid,/ server_addr, packet.yiaddr);
[821]	1710
[2725]	1711	if (state != REQUESTING)
	1712	udhcp_run_script(NULL, "deconfig");
	1713	change_listen_mode(LISTEN_RAW);
	1714	state = INIT_SELECTING;
[3232]	1715	client_config.first_secs = 0; /* make secs field count from 0 */
[2725]	1716	requested_ip = 0;
	1717	timeout = tryagain_timeout;
[821]	1718	packet_num = 0;
[2725]	1719	already_waited_sec = 0;
	1720	continue; /* back to main loop */
[821]	1721	}
	1722	}
[2725]	1723	#endif
	1724	/* enter bound state */
	1725	timeout = lease_seconds / 2;
[3232]	1726	temp_addr.s_addr = packet.yiaddr;
	1727	bb_info_msg("Lease of %s obtained, lease time %u",
	1728	inet_ntoa(temp_addr), (unsigned)lease_seconds);
[2725]	1729	requested_ip = packet.yiaddr;
	1730	udhcp_run_script(&packet, state == REQUESTING ? "bound" : "renew");
[821]	1731
[2725]	1732	state = BOUND;
	1733	change_listen_mode(LISTEN_NONE);
	1734	if (opt & OPT_q) { /* quit after lease */
	1735	goto ret0;
[821]	1736	}
[2725]	1737	/* future renew failures should not exit (JM) */
	1738	opt &= ~OPT_n;
	1739	#if BB_MMU /* NOMMU case backgrounded earlier */
	1740	if (!(opt & OPT_f)) {
	1741	client_background();
	1742	/* do not background again! */
	1743	opt = ((opt & ~OPT_b) \| OPT_f);
	1744	}
	1745	#endif
[3232]	1746	/* make future renew packets use different xid */
	1747	/* xid = random_xid(); ...but why bother? */
[2725]	1748	already_waited_sec = 0;
	1749	continue; /* back to main loop */
[821]	1750	}
[2725]	1751	if (*message == DHCPNAK) {
	1752	/* return to init state */
	1753	bb_info_msg("Received DHCP NAK");
	1754	udhcp_run_script(&packet, "nak");
	1755	if (state != REQUESTING)
	1756	udhcp_run_script(NULL, "deconfig");
	1757	change_listen_mode(LISTEN_RAW);
	1758	sleep(3); /* avoid excessive network traffic */
	1759	state = INIT_SELECTING;
[3232]	1760	client_config.first_secs = 0; /* make secs field count from 0 */
[2725]	1761	requested_ip = 0;
	1762	timeout = 0;
	1763	packet_num = 0;
	1764	already_waited_sec = 0;
[821]	1765	}
[2725]	1766	continue;
	1767	/* case BOUND: - ignore all packets */
	1768	/* case RELEASED: - ignore all packets */
[821]	1769	}
[2725]	1770	/* back to main loop */
	1771	} /* for (;;) - main loop ends */
	1772
[1765]	1773	ret0:
[3232]	1774	if (opt & OPT_R) /* release on quit */
	1775	perform_release(server_addr, requested_ip);
[1765]	1776	retval = 0;
	1777	ret:
[2725]	1778	/if (client_config.pidfile) - remove_pidfile has its own check /
[1765]	1779	remove_pidfile(client_config.pidfile);
	1780	return retval;
[821]	1781	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: