2 * Copyright (c) 2008, 2009, 2010 Nicira Networks.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 #include "dhcp-client.h"
19 #include <arpa/inet.h>
26 #include <sys/types.h>
31 #include "dynamic-string.h"
35 #include "poll-loop.h"
40 VLOG_DEFINE_THIS_MODULE(dhcp_client)
42 #define DHCLIENT_STATES \
43 DHCLIENT_STATE(INIT, 1 << 0) \
44 DHCLIENT_STATE(INIT_REBOOT, 1 << 1) \
45 DHCLIENT_STATE(REBOOTING, 1 << 2) \
46 DHCLIENT_STATE(SELECTING, 1 << 3) \
47 DHCLIENT_STATE(REQUESTING, 1 << 4) \
48 DHCLIENT_STATE(BOUND, 1 << 5) \
49 DHCLIENT_STATE(RENEWING, 1 << 6) \
50 DHCLIENT_STATE(REBINDING, 1 << 7) \
51 DHCLIENT_STATE(RELEASED, 1 << 8)
53 #define DHCLIENT_STATE(NAME, VALUE) S_##NAME = VALUE,
58 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(60, 60);
61 state_name(enum dhclient_state state)
64 #define DHCLIENT_STATE(NAME, VALUE) case S_##NAME: return #NAME;
73 struct netdev *netdev;
75 void (*modify_request)(struct dhcp_msg *, void *aux);
76 bool (*validate_offer)(const struct dhcp_msg *, void *aux);
80 enum dhclient_state state;
81 unsigned int state_entered; /* When we transitioned to this state. */
82 uint32_t xid; /* In host byte order. */
83 uint32_t ipaddr, netmask, router;
85 struct dhcp_msg *binding;
88 unsigned int retransmit, delay; /* Used by send_reliably(). */
89 unsigned int max_timeout;
91 unsigned int init_delay; /* Used by S_INIT. */
93 time_t lease_expiration;
94 unsigned int bound_timeout;
95 unsigned int renewing_timeout;
96 unsigned int rebinding_timeout;
98 /* Used by dhclient_run() and dhclient_wait() */
99 unsigned int min_timeout;
102 /* Set when we send out a DHCPDISCOVER message. */
108 /* Minimum acceptable lease time, in seconds. */
109 #define MIN_ACCEPTABLE_LEASE 15
111 static void state_transition(struct dhclient *, enum dhclient_state);
112 static unsigned int elapsed_in_this_state(const struct dhclient *cli);
113 static bool timeout(struct dhclient *, unsigned int secs);
115 static void dhclient_msg_init(struct dhclient *, enum dhcp_msg_type,
117 static void send_reliably(struct dhclient *cli,
118 void (*make_packet)(struct dhclient *,
120 static bool do_receive_msg(struct dhclient *, struct dhcp_msg *);
121 static void do_send_msg(struct dhclient *, const struct dhcp_msg *);
122 static bool receive_ack(struct dhclient *);
124 static unsigned int fuzz(unsigned int x, int max_fuzz);
125 static unsigned int calc_t2(unsigned int lease);
126 static unsigned int calc_t1(unsigned int lease, unsigned int t2);
128 static unsigned int clamp(unsigned int x, unsigned int min, unsigned int max);
130 /* Creates a new DHCP client to configure the network device 'netdev_name'
133 * If 'modify_request' is non-null, then each DHCP message to discover or
134 * request an address will be passed to it (along with auxiliary data 'aux').
135 * It may then add any desired options to the message for transmission.
137 * If 'validate_offer' is non-null, then each DHCP message that offers an
138 * address will be passed to it (along with auxiliary data 'aux') for
139 * validation: if it returns true, the address will accepted; otherwise, it
142 * The DHCP client will not start advertising for an IP address until
143 * dhclient_init() is called.
145 * If successful, returns 0 and sets '*cli' to the new DHCP client. Otherwise,
146 * returns a positive errno value and sets '*cli' to a null pointer. */
148 dhclient_create(const char *netdev_name,
149 void (*modify_request)(struct dhcp_msg *, void *aux),
150 bool (*validate_offer)(const struct dhcp_msg *, void *aux),
151 void *aux, struct dhclient **cli_)
153 struct dhclient *cli;
154 struct netdev_options netdev_options;
155 struct netdev *netdev;
160 memset(&netdev_options, 0, sizeof netdev_options);
161 netdev_options.name = netdev_name;
162 netdev_options.ethertype = ETH_TYPE_IP;
164 error = netdev_open(&netdev_options, &netdev);
165 /* XXX install socket filter to catch only DHCP packets. */
167 VLOG_ERR("%s: could not open network device: %s",
168 netdev_name, strerror(error));
172 error = netdev_turn_flags_on(netdev, NETDEV_UP, false);
174 VLOG_ERR("%s: could not bring device up: %s",
175 netdev_name, strerror(error));
176 netdev_close(netdev);
180 cli = xzalloc(sizeof *cli);
181 cli->modify_request = modify_request;
182 cli->validate_offer = validate_offer;
184 cli->netdev = netdev;
185 cli->state = S_RELEASED;
186 cli->state_entered = time_now();
187 cli->xid = random_uint32();
190 cli->retransmit = cli->delay = 0;
191 cli->max_timeout = 64;
192 cli->min_timeout = 1;
199 /* Sets the maximum amount of timeout that 'cli' will wait for a reply from
200 * the DHCP server before retransmitting, in seconds, to 'max_timeout'. The
201 * default is 64 seconds. */
203 dhclient_set_max_timeout(struct dhclient *cli, unsigned int max_timeout)
205 cli->max_timeout = MAX(2, max_timeout);
208 /* Destroys 'cli' and frees all related resources. */
210 dhclient_destroy(struct dhclient *cli)
213 dhcp_msg_uninit(cli->binding);
215 netdev_close(cli->netdev);
221 /* Returns the network device in use by 'cli'. The caller must not destroy
222 * the returned device. */
224 dhclient_get_netdev(struct dhclient *cli)
229 /* Returns the name of the network device in use by 'cli'. The caller must
230 * not modify or destroy the returned string. */
232 dhclient_get_name(const struct dhclient *cli)
234 return netdev_get_name(cli->netdev);
237 /* Forces 'cli' into a (re)initialization state, in which no address is bound
238 * but the client is advertising to obtain one. If 'requested_ip' is nonzero,
239 * then the client will attempt to re-bind to that IP address; otherwise, it
240 * will not ask for any particular address. */
242 dhclient_init(struct dhclient *cli, uint32_t requested_ip)
244 state_transition(cli, requested_ip ? S_INIT_REBOOT : S_INIT);
245 cli->ipaddr = requested_ip;
246 cli->min_timeout = 0;
250 /* Forces 'cli' to release its bound IP address (if any). The client will not
251 * advertise for a new address until dhclient_init() is called again. */
253 dhclient_release(struct dhclient *cli)
255 if (dhclient_is_bound(cli)) {
257 dhclient_msg_init(cli, DHCPRELEASE, &msg);
258 msg.ciaddr = cli->ipaddr;
259 do_send_msg(cli, &msg);
260 dhcp_msg_uninit(&msg);
262 state_transition(cli, S_RELEASED);
263 cli->min_timeout = UINT_MAX;
267 do_force_renew(struct dhclient *cli, int deadline)
269 time_t now = time_now();
270 unsigned int lease_left = sat_sub(cli->lease_expiration, now);
271 if (lease_left <= deadline) {
272 if (cli->state & (S_RENEWING | S_REBINDING)) {
275 deadline = lease_left;
277 if (cli->state & (S_BOUND | S_RENEWING)) {
278 state_transition(cli, S_RENEWING);
279 cli->renewing_timeout = deadline * 3 / 4;
280 cli->rebinding_timeout = deadline * 1 / 4;
282 state_transition(cli, S_REBINDING);
283 cli->rebinding_timeout = deadline;
285 cli->min_timeout = 0;
288 /* Forces 'cli' to attempt to renew the lease its current IP address (if any)
289 * within 'deadline' seconds. If the deadline is not met, then the client
290 * gives up its IP address binding and re-starts the DHCP process. */
292 dhclient_force_renew(struct dhclient *cli, int deadline)
294 /* Drain the receive queue so that we know that any DHCPACK we process is
295 * freshly received. */
296 netdev_drain(cli->netdev);
298 switch (cli->state) {
309 do_force_renew(cli, deadline);
313 dhclient_init(cli, 0);
318 /* Returns true if 'cli' is bound to an IP address, false otherwise. */
320 dhclient_is_bound(const struct dhclient *cli)
322 return cli->state & (S_BOUND | S_RENEWING | S_REBINDING);
325 /* Returns true if 'cli' has changed from bound to unbound, or vice versa, at
326 * least once since the last time this function was called. */
328 dhclient_changed(struct dhclient *cli)
330 bool changed = cli->changed;
335 /* Returns 'cli''s current state, as a string. The caller must not modify or
336 * free the string. */
338 dhclient_get_state(const struct dhclient *cli)
340 return state_name(cli->state);
343 /* Returns the number of seconds spent so far in 'cli''s current state. */
345 dhclient_get_state_elapsed(const struct dhclient *cli)
347 return elapsed_in_this_state(cli);
350 /* If 'cli' is bound, returns the number of seconds remaining in its lease;
351 * otherwise, returns 0. */
353 dhclient_get_lease_remaining(const struct dhclient *cli)
355 if (dhclient_is_bound(cli)) {
356 time_t now = time_now();
357 return cli->lease_expiration > now ? cli->lease_expiration - now : 0;
363 /* If 'cli' is bound to an IP address, returns that IP address; otherwise,
366 dhclient_get_ip(const struct dhclient *cli)
368 return dhclient_is_bound(cli) ? cli->ipaddr : 0;
371 /* If 'cli' is bound to an IP address, returns the netmask for that IP address;
372 * otherwise, returns 0. */
374 dhclient_get_netmask(const struct dhclient *cli)
376 return dhclient_is_bound(cli) ? cli->netmask : 0;
379 /* If 'cli' is bound to an IP address and 'cli' has a default gateway, returns
380 * that default gateway; otherwise, returns 0. */
382 dhclient_get_router(const struct dhclient *cli)
384 return dhclient_is_bound(cli) ? cli->router : 0;
387 /* If 'cli' is bound to an IP address, returns the DHCP message that was
388 * received to obtain that IP address (so that the caller can obtain additional
389 * options from it). Otherwise, returns a null pointer. */
390 const struct dhcp_msg *
391 dhclient_get_config(const struct dhclient *cli)
393 return dhclient_is_bound(cli) ? cli->binding : NULL;
396 /* Configures the network device backing 'cli' to the network address and other
397 * parameters obtained via DHCP. If no address is bound on 'cli', removes any
398 * configured address from 'cli'.
400 * To use a dhclient as a regular DHCP client that binds and unbinds from IP
401 * addresses in the usual fashion, call this function after dhclient_run() if
402 * anything has changed, like so:
405 * if (dhclient_changed(cli)) {
406 * dhclient_configure_netdev(cli);
411 dhclient_configure_netdev(struct dhclient *cli)
413 const char *cli_name = dhclient_get_name(cli);
414 struct in_addr addr = { dhclient_get_ip(cli) };
415 struct in_addr mask = { dhclient_get_netmask(cli) };
416 struct in_addr router = { dhclient_get_router(cli) };
419 error = netdev_set_in4(cli->netdev, addr, mask);
421 VLOG_ERR("%s: could not set address "IP_FMT"/"IP_FMT" (%s)",
422 cli_name, IP_ARGS(&addr.s_addr), IP_ARGS(&mask.s_addr),
426 if (!error && router.s_addr) {
427 error = netdev_add_router(cli->netdev, router);
429 VLOG_ERR("%s: failed to add default route to "IP_FMT" (%s)",
430 cli_name, IP_ARGS(&router), strerror(error));
437 /* If 'cli' is bound and the binding includes DNS domain parameters, updates
438 * /etc/resolv.conf will be updated to match the received parameters. Returns
439 * 0 if successful, otherwise a positive errno value. */
441 dhclient_update_resolv_conf(struct dhclient *cli)
443 const char *cli_name = dhclient_get_name(cli);
446 bool has_domain_name;
451 if (!dhclient_is_bound(cli)) {
454 if (!dhcp_msg_get_ip(cli->binding, DHCP_CODE_DNS_SERVER, 0, &dns_server)) {
455 VLOG_DBG("%s: binding does not include any DNS servers", cli_name);
459 sprintf(new_name, "/etc/resolv.conf.tmp%ld", (long int) getpid());
460 new = fopen(new_name, "w");
462 VLOG_WARN("%s: could not create %s (%s)",
463 cli_name, new_name, strerror(errno));
467 domain_name = dhcp_msg_get_string(cli->binding, DHCP_CODE_DOMAIN_NAME);
468 has_domain_name = domain_name != NULL;
470 if (strspn(domain_name, "-_.0123456789abcdefghijklmnopqrstuvwxyz"
471 "ABCDEFGHIJKLMNOPQRSTUVWXYZ") == strlen(domain_name)) {
472 fprintf(new, "domain %s\n", domain_name);
474 VLOG_WARN("%s: ignoring invalid domain name %s",
475 cli_name, domain_name);
476 has_domain_name = false;
479 VLOG_DBG("%s: binding does not include domain name", cli_name);
483 for (i = 0; dhcp_msg_get_ip(cli->binding, DHCP_CODE_DNS_SERVER,
484 i, &dns_server); i++) {
485 fprintf(new, "nameserver "IP_FMT"\n", IP_ARGS(&dns_server));
488 old = fopen("/etc/resolv.conf", "r");
492 while (fgets(line, sizeof line, old)) {
493 char *kw = xmemdup0(line, strcspn(line, " \t\r\n"));
494 if (strcmp(kw, "nameserver")
496 || (strcmp(kw, "domain") && strcmp(kw, "search")))) {
503 VLOG_DBG("%s: failed to open /etc/resolv.conf (%s)",
504 cli_name, strerror(errno));
507 if (fclose(new) < 0) {
508 VLOG_WARN("%s: closing %s failed (%s)",
509 cli_name, new_name, strerror(errno));
513 if (rename(new_name, "/etc/resolv.conf") < 0) {
514 VLOG_WARN("%s: failed to rename %s to /etc/resolv.conf (%s)",
515 cli_name, new_name, strerror(errno));
525 make_dhcpdiscover(struct dhclient *cli, struct dhcp_msg *msg)
527 cli->secs = elapsed_in_this_state(cli);
528 dhclient_msg_init(cli, DHCPDISCOVER, msg);
530 dhcp_msg_put_ip(msg, DHCP_CODE_REQUESTED_IP, cli->ipaddr);
535 make_dhcprequest(struct dhclient *cli, struct dhcp_msg *msg)
537 dhclient_msg_init(cli, DHCPREQUEST, msg);
538 msg->ciaddr = dhclient_get_ip(cli);
539 if (cli->state == S_REQUESTING) {
540 dhcp_msg_put_ip(msg, DHCP_CODE_SERVER_IDENTIFIER, cli->server_ip);
542 dhcp_msg_put_ip(msg, DHCP_CODE_REQUESTED_IP, cli->ipaddr);
546 do_init(struct dhclient *cli, enum dhclient_state next_state)
548 if (!cli->init_delay) {
549 cli->init_delay = fuzz(2, 1);
551 if (timeout(cli, cli->init_delay)) {
552 state_transition(cli, next_state);
557 dhclient_run_INIT(struct dhclient *cli)
559 do_init(cli, S_SELECTING);
563 dhclient_run_INIT_REBOOT(struct dhclient *cli)
565 do_init(cli, S_REBOOTING);
569 dhclient_run_REBOOTING(struct dhclient *cli)
571 send_reliably(cli, make_dhcprequest);
572 if (!receive_ack(cli) && timeout(cli, 60)) {
573 state_transition(cli, S_INIT);
578 dhcp_receive(struct dhclient *cli, unsigned int msgs, struct dhcp_msg *msg)
580 while (do_receive_msg(cli, msg)) {
581 const char *cli_name = dhclient_get_name(cli);
583 if (msg->type > 31 || !((1u << msg->type) & msgs)) {
584 VLOG_DBG_RL(&rl, "%s: received unexpected %s in %s state: %s",
586 dhcp_type_name(msg->type), state_name(cli->state),
587 dhcp_msg_to_string(msg, false, &cli->s));
588 } else if (msg->xid != cli->xid) {
589 VLOG_DBG_RL(&rl, "%s: ignoring %s with xid != %08"PRIx32" "
590 "in %s state: %s", cli_name,
591 dhcp_type_name(msg->type), msg->xid,
592 state_name(cli->state),
593 dhcp_msg_to_string(msg, false, &cli->s));
597 dhcp_msg_uninit(msg);
603 validate_offered_options(struct dhclient *cli, const struct dhcp_msg *msg)
605 const char *cli_name = dhclient_get_name(cli);
606 uint32_t lease, netmask;
608 if (!dhcp_msg_get_secs(msg, DHCP_CODE_LEASE_TIME, 0, &lease)) {
609 VLOG_WARN_RL(&rl, "%s: %s lacks lease time (%s)",
610 cli_name, dhcp_type_name(msg->type),
611 dhcp_msg_to_string(msg, false, &cli->s));
612 } else if (!dhcp_msg_get_ip(msg, DHCP_CODE_SUBNET_MASK, 0, &netmask)) {
613 VLOG_WARN_RL(&rl, "%s: %s lacks netmask (%s)",
614 cli_name, dhcp_type_name(msg->type),
615 dhcp_msg_to_string(msg, false, &cli->s));
616 } else if (lease < MIN_ACCEPTABLE_LEASE) {
617 VLOG_WARN_RL(&rl, "%s: ignoring %s with %"PRIu32"-second "
618 "lease time (%s)", cli_name,
619 dhcp_type_name(msg->type), lease,
620 dhcp_msg_to_string(msg, false, &cli->s));
621 } else if (cli->validate_offer && !cli->validate_offer(msg, cli->aux)) {
622 VLOG_DBG_RL(&rl, "%s: client validation hook refused offer (%s)",
623 cli_name, dhcp_msg_to_string(msg, false, &cli->s));
631 dhclient_run_SELECTING(struct dhclient *cli)
633 const char *cli_name = dhclient_get_name(cli);
636 send_reliably(cli, make_dhcpdiscover);
637 if (cli->server_ip && timeout(cli, 60)) {
639 state_transition(cli, S_INIT);
641 for (; dhcp_receive(cli, 1u << DHCPOFFER, &msg); dhcp_msg_uninit(&msg)) {
642 if (!validate_offered_options(cli, &msg)) {
645 if (!dhcp_msg_get_ip(&msg, DHCP_CODE_SERVER_IDENTIFIER,
646 0, &cli->server_ip)) {
647 VLOG_WARN_RL(&rl, "%s: DHCPOFFER lacks server identifier (%s)",
648 cli_name, dhcp_msg_to_string(&msg, false, &cli->s));
652 VLOG_DBG_RL(&rl, "%s: accepting DHCPOFFER (%s)",
653 cli_name, dhcp_msg_to_string(&msg, false, &cli->s));
654 cli->ipaddr = msg.yiaddr;
655 state_transition(cli, S_REQUESTING);
661 same_binding(const char *cli_name,
662 const struct dhcp_msg *old, const struct dhcp_msg *new)
664 static const int codes[] = {
665 DHCP_CODE_SUBNET_MASK,
667 DHCP_CODE_DNS_SERVER,
669 DHCP_CODE_DOMAIN_NAME,
672 DHCP_CODE_BROADCAST_ADDRESS,
673 DHCP_CODE_STATIC_ROUTE,
674 DHCP_CODE_ARP_CACHE_TIMEOUT,
675 DHCP_CODE_ETHERNET_ENCAPSULATION,
677 DHCP_CODE_SERVER_IDENTIFIER,
678 DHCP_CODE_OFP_CONTROLLER_VCONN,
679 DHCP_CODE_OFP_PKI_URI,
684 if (old->yiaddr != new->yiaddr) {
685 VLOG_WARN("%s: DHCP binding changed IP address "
686 "from "IP_FMT" to "IP_FMT,
687 cli_name, IP_ARGS(&old->yiaddr), IP_ARGS(&new->yiaddr));
690 for (i = 0; i < ARRAY_SIZE(codes); i++) {
692 const struct dhcp_option *old_opt = &old->options[code];
693 const struct dhcp_option *new_opt = &new->options[code];
694 if (!dhcp_option_equals(old_opt, new_opt)) {
695 struct ds old_string = DS_EMPTY_INITIALIZER;
696 struct ds new_string = DS_EMPTY_INITIALIZER;
697 VLOG_WARN("%s: DHCP binding changed option from %s to %s",
699 dhcp_option_to_string(old_opt, code, &old_string),
700 dhcp_option_to_string(new_opt, code, &new_string));
701 ds_destroy(&old_string);
702 ds_destroy(&new_string);
710 receive_ack(struct dhclient *cli)
714 if (!dhcp_receive(cli, (1u << DHCPACK) | (1u << DHCPNAK), &msg)) {
716 } else if (msg.type == DHCPNAK) {
717 dhcp_msg_uninit(&msg);
718 state_transition(cli, S_INIT);
720 } else if (!validate_offered_options(cli, &msg)) {
721 dhcp_msg_uninit(&msg);
724 uint32_t lease = 0, t1 = 0, t2 = 0;
727 if (!same_binding(dhclient_get_name(cli), cli->binding, &msg)) {
730 dhcp_msg_uninit(cli->binding);
732 cli->binding = xmalloc(sizeof *cli->binding);
734 dhcp_msg_copy(cli->binding, &msg);
736 dhcp_msg_get_secs(&msg, DHCP_CODE_LEASE_TIME, 0, &lease);
737 dhcp_msg_get_secs(&msg, DHCP_CODE_T1, 0, &t1);
738 dhcp_msg_get_secs(&msg, DHCP_CODE_T2, 0, &t2);
739 assert(lease >= MIN_ACCEPTABLE_LEASE);
741 if (!t2 || t2 >= lease) {
744 if (!t1 || t1 >= t2) {
745 t1 = calc_t1(lease, t2);
748 cli->lease_expiration = sat_add(time_now(), lease);
749 cli->bound_timeout = t1;
750 cli->renewing_timeout = t2 - t1;
751 cli->rebinding_timeout = lease - t2;
753 cli->ipaddr = msg.yiaddr;
754 dhcp_msg_get_ip(&msg, DHCP_CODE_SUBNET_MASK, 0, &cli->netmask);
755 if (!dhcp_msg_get_ip(&msg, DHCP_CODE_ROUTER, 0, &cli->router)) {
756 cli->router = INADDR_ANY;
758 state_transition(cli, S_BOUND);
759 VLOG_DBG("%s: bound (%s)", dhclient_get_name(cli),
760 dhcp_msg_to_string(&msg, false, &cli->s));
766 dhclient_run_REQUESTING(struct dhclient *cli)
768 send_reliably(cli, make_dhcprequest);
769 if (!receive_ack(cli) && timeout(cli, 60)) {
770 state_transition(cli, S_INIT);
775 dhclient_run_BOUND(struct dhclient *cli)
777 if (timeout(cli, cli->bound_timeout)) {
778 state_transition(cli, S_RENEWING);
783 dhclient_run_RENEWING(struct dhclient *cli)
785 send_reliably(cli, make_dhcprequest);
786 if (!receive_ack(cli) && timeout(cli, cli->renewing_timeout)) {
787 state_transition(cli, S_REBINDING);
792 dhclient_run_REBINDING(struct dhclient *cli)
794 send_reliably(cli, make_dhcprequest);
795 if (!receive_ack(cli) && timeout(cli, cli->rebinding_timeout)) {
796 state_transition(cli, S_INIT);
801 dhclient_run_RELEASED(struct dhclient *cli OVS_UNUSED)
806 /* Processes the DHCP protocol for 'cli'. */
808 dhclient_run(struct dhclient *cli)
812 old_state = cli->state;
813 cli->min_timeout = UINT_MAX;
815 switch (cli->state) {
816 #define DHCLIENT_STATE(NAME, VALUE) \
817 case S_##NAME: dhclient_run_##NAME(cli); break;
819 #undef DHCLIENT_STATE
823 } while (cli->state != old_state);
826 /* Sets up poll timeouts to wake up the poll loop when 'cli' needs to do some
829 dhclient_wait(struct dhclient *cli)
831 if (cli->min_timeout != UINT_MAX) {
832 long long int wake = sat_add(cli->state_entered, cli->min_timeout);
833 poll_timer_wait_until(wake * 1000);
835 /* Reset timeout to 1 second. This will have no effect ordinarily, because
836 * dhclient_run() will typically set it back to a higher value. If,
837 * however, the caller fails to call dhclient_run() before its next call to
838 * dhclient_wait() we won't potentially block forever. */
839 cli->min_timeout = 1;
841 if (cli->state & (S_SELECTING | S_REQUESTING | S_RENEWING | S_REBINDING)) {
842 netdev_recv_wait(cli->netdev);
847 state_transition(struct dhclient *cli, enum dhclient_state state)
849 const char *cli_name = dhclient_get_name(cli);
850 bool was_bound = dhclient_is_bound(cli);
853 if (cli->state != state) {
854 VLOG_DBG("%s: entering %s", cli_name, state_name(state));
857 cli->state_entered = time_now();
858 cli->retransmit = cli->delay = 0;
859 am_bound = dhclient_is_bound(cli);
860 if (was_bound != am_bound) {
863 assert(cli->binding != NULL);
864 VLOG_INFO("%s: obtained address "IP_FMT", netmask "IP_FMT,
866 IP_ARGS(&cli->ipaddr), IP_ARGS(&cli->netmask));
868 VLOG_INFO("%s: obtained default gateway "IP_FMT,
869 cli_name, IP_ARGS(&cli->router));
872 dhcp_msg_uninit(cli->binding);
876 VLOG_INFO("%s: network address unbound", cli_name);
879 if (cli->state & (S_SELECTING | S_REQUESTING | S_REBOOTING)) {
880 netdev_drain(cli->netdev);
885 send_reliably(struct dhclient *cli,
886 void (*make_packet)(struct dhclient *, struct dhcp_msg *))
888 if (timeout(cli, cli->retransmit)) {
890 make_packet(cli, &msg);
891 if (cli->modify_request) {
892 cli->modify_request(&msg, cli->aux);
894 do_send_msg(cli, &msg);
895 cli->delay = MIN(cli->max_timeout, MAX(4, cli->delay * 2));
896 cli->retransmit += fuzz(cli->delay, 1);
897 timeout(cli, cli->retransmit);
898 dhcp_msg_uninit(&msg);
903 dhclient_msg_init(struct dhclient *cli, enum dhcp_msg_type type,
904 struct dhcp_msg *msg)
907 msg->op = DHCP_BOOTREQUEST;
909 msg->secs = cli->secs;
911 netdev_get_etheraddr(cli->netdev, msg->chaddr);
914 /* If time goes backward this returns a large number, which makes it look like
915 * we've been in the current state a very long time. That's probably
916 * fine for that corner case--we'll just expire our lease, etc., and try to
919 elapsed_in_this_state(const struct dhclient *cli)
921 return time_now() - cli->state_entered;
925 timeout(struct dhclient *cli, unsigned int secs)
927 cli->min_timeout = MIN(cli->min_timeout, secs);
928 return time_now() >= sat_add(cli->state_entered, secs);
932 do_receive_msg(struct dhclient *cli, struct dhcp_msg *msg)
934 const char *cli_name = dhclient_get_name(cli);
935 uint8_t cli_mac[ETH_ADDR_LEN];
939 netdev_get_mtu(cli->netdev, &mtu);
940 ofpbuf_init(&b, mtu + VLAN_ETH_HEADER_LEN);
941 netdev_get_etheraddr(cli->netdev, cli_mac);
942 for (; cli->received < 50; cli->received++) {
943 const struct ip_header *ip;
944 const struct dhcp_header *dhcp;
949 error = netdev_recv(cli->netdev, &b);
954 flow_extract(&b, 0, 0, &flow);
955 if (flow.dl_type != htons(ETH_TYPE_IP)
956 || flow.nw_proto != IP_TYPE_UDP
957 || flow.tp_dst != htons(DHCP_CLIENT_PORT)
958 || !(eth_addr_is_broadcast(flow.dl_dst)
959 || eth_addr_equals(flow.dl_dst, cli_mac))) {
964 if (IP_IS_FRAGMENT(ip->ip_frag_off)) {
965 /* We don't do reassembly. */
966 VLOG_WARN_RL(&rl, "%s: ignoring fragmented DHCP datagram",
973 VLOG_WARN_RL(&rl, "%s: ignoring DHCP datagram with missing "
974 "payload", cli_name);
978 ofpbuf_pull(&b, (char *)b.l7 - (char*)b.data);
979 error = dhcp_parse(msg, &b);
981 if (VLOG_IS_DBG_ENABLED()) {
982 VLOG_DBG_RL(&rl, "%s: received %s", cli_name,
983 dhcp_msg_to_string(msg, false, &cli->s));
985 VLOG_INFO_RL(&rl, "%s: received %s",
986 cli_name, dhcp_type_name(msg->type));
992 netdev_drain(cli->netdev);
999 do_send_msg(struct dhclient *cli, const struct dhcp_msg *msg)
1001 const char *cli_name = dhclient_get_name(cli);
1003 struct eth_header eh;
1004 struct ip_header nh;
1005 struct udp_header th;
1009 ofpbuf_init(&b, ETH_TOTAL_MAX);
1010 ofpbuf_reserve(&b, ETH_HEADER_LEN + IP_HEADER_LEN + UDP_HEADER_LEN);
1012 dhcp_assemble(msg, &b);
1014 netdev_get_etheraddr(cli->netdev, eh.eth_src);
1015 memcpy(eh.eth_dst, eth_addr_broadcast, ETH_ADDR_LEN);
1016 eh.eth_type = htons(ETH_TYPE_IP);
1018 nh.ip_ihl_ver = IP_IHL_VER(5, IP_VERSION);
1020 nh.ip_tot_len = htons(IP_HEADER_LEN + UDP_HEADER_LEN + b.size);
1021 /* We can't guarantee uniqueness of ip_id versus the host's, screwing up
1022 * fragment reassembly, so prevent fragmentation and use an all-zeros
1023 * ip_id. RFC 791 doesn't say we can do this, but Linux does the same
1024 * thing for DF packets, so it must not screw anything up. */
1026 nh.ip_frag_off = htons(IP_DONT_FRAGMENT);
1028 nh.ip_proto = IP_TYPE_UDP;
1030 nh.ip_src = dhclient_get_ip(cli);
1031 /* XXX need to use UDP socket for nonzero server IPs so that we can get
1032 * routing table support.
1034 * if (...have server IP and in appropriate state...) {
1035 * nh.ip_dst = cli->server_ip;
1037 * nh.ip_dst = INADDR_BROADCAST;
1040 nh.ip_dst = INADDR_BROADCAST;
1041 nh.ip_csum = csum(&nh, sizeof nh);
1043 th.udp_src = htons(DHCP_CLIENT_PORT);
1044 th.udp_dst = htons(DHCP_SERVER_PORT);
1045 th.udp_len = htons(UDP_HEADER_LEN + b.size);
1047 udp_csum = csum_add32(0, nh.ip_src);
1048 udp_csum = csum_add32(udp_csum, nh.ip_dst);
1049 udp_csum = csum_add16(udp_csum, IP_TYPE_UDP << 8);
1050 udp_csum = csum_add16(udp_csum, th.udp_len);
1051 udp_csum = csum_continue(udp_csum, &th, sizeof th);
1052 th.udp_csum = csum_finish(csum_continue(udp_csum, b.data, b.size));
1054 ofpbuf_push(&b, &th, sizeof th);
1055 ofpbuf_push(&b, &nh, sizeof nh);
1056 ofpbuf_push(&b, &eh, sizeof eh);
1058 /* Don't try to send the frame if it's too long for an Ethernet frame. We
1059 * disregard the network device's actual MTU because we don't want the
1060 * frame to have to be discarded or fragmented if it travels over a regular
1061 * Ethernet at some point. 1500 bytes should be enough for anyone. */
1062 if (b.size <= ETH_TOTAL_MAX) {
1063 if (VLOG_IS_DBG_ENABLED()) {
1064 VLOG_DBG("%s: sending %s",
1065 cli_name, dhcp_msg_to_string(msg, false, &cli->s));
1067 VLOG_INFO("%s: sending %s", cli_name, dhcp_type_name(msg->type));
1069 error = netdev_send(cli->netdev, &b);
1071 VLOG_ERR("%s: send failed on %s (%s)", cli_name,
1072 netdev_get_name(cli->netdev), strerror(error));
1075 VLOG_ERR("%s: cannot send %zu-byte Ethernet frame", cli_name, b.size);
1082 fuzz(unsigned int x, int max_fuzz)
1084 /* Generate number in range [-max_fuzz, +max_fuzz]. */
1085 int fuzz = random_range(max_fuzz * 2 + 1) - max_fuzz;
1086 unsigned int y = x + fuzz;
1087 return fuzz >= 0 ? (y >= x ? y : UINT_MAX) : (y <= x ? y : 0);
1091 clamp(unsigned int x, unsigned int min, unsigned int max)
1093 return x < min ? min : x > max ? max : x;
1097 calc_t2(unsigned int lease)
1099 unsigned int base = lease * 0.875;
1100 return lease >= 60 ? clamp(fuzz(base, 10), 0, lease - 1) : base;
1104 calc_t1(unsigned int lease, unsigned int t2)
1106 unsigned int base = lease / 2;
1107 return lease >= 60 ? clamp(fuzz(base, 10), 0, t2 - 1) : base;