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