X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=networking%2Fudhcp%2Fdhcpc.c;h=9a2fe35e4d169e0b03047cef61e441d4ea4f46c9;hb=695fa51c80047eb25cc82e6e1630b4545a6bc0b6;hp=c1ef19519ec220baea83b1e7ad555fc270007e75;hpb=c321b51dc61f975625a0bfc67cf159f159ee2612;p=oweals%2Fbusybox.git diff --git a/networking/udhcp/dhcpc.c b/networking/udhcp/dhcpc.c index c1ef19519..9a2fe35e4 100644 --- a/networking/udhcp/dhcpc.c +++ b/networking/udhcp/dhcpc.c @@ -7,9 +7,7 @@ * * Licensed under the GPL v2 or later, see the file LICENSE in this tarball. */ - #include - /* Override ENABLE_FEATURE_PIDFILE - ifupdown needs our pidfile to always exist */ #define WANT_PIDFILE 1 #include "common.h" @@ -20,19 +18,25 @@ static int sockfd = -1; -#define LISTEN_NONE 0 +#define LISTEN_NONE 0 #define LISTEN_KERNEL 1 -#define LISTEN_RAW 2 +#define LISTEN_RAW 2 static smallint listen_mode; +/* initial state: (re)start DHCP negotiation */ #define INIT_SELECTING 0 +/* discover was sent, DHCPOFFER reply received */ #define REQUESTING 1 +/* select/renew was sent, DHCPACK reply received */ #define BOUND 2 +/* half of lease passed, want to renew it by sending unicast renew requests */ #define RENEWING 3 +/* renew requests were not answered, lease is almost over, send broadcast renew */ #define REBINDING 4 -#define INIT_REBOOT 5 -#define RENEW_REQUESTED 6 -#define RELEASED 7 +/* manually requested renew (SIGUSR1) */ +#define RENEW_REQUESTED 5 +/* release, possibly manually requested (SIGUSR2) */ +#define RELEASED 6 static smallint state; /* struct client_config_t client_config is in bb_common_bufsiz1 */ @@ -41,13 +45,22 @@ static smallint state; /* just a little helper */ static void change_listen_mode(int new_mode) { - DEBUG("entering %s listen mode", - new_mode ? (new_mode == 1 ? "kernel" : "raw") : "none"); + log1("Entering listen mode: %s", + new_mode != LISTEN_NONE + ? (new_mode == LISTEN_KERNEL ? "kernel" : "raw") + : "none" + ); + + listen_mode = new_mode; if (sockfd >= 0) { close(sockfd); sockfd = -1; } - listen_mode = new_mode; + if (new_mode == LISTEN_KERNEL) + sockfd = udhcp_listen_socket(/*INADDR_ANY,*/ CLIENT_PORT, client_config.interface); + else if (new_mode != LISTEN_NONE) + sockfd = udhcp_raw_socket(client_config.ifindex); + /* else LISTEN_NONE: sockfd stay closed */ } @@ -127,7 +140,7 @@ int udhcpc_main(int argc UNUSED_PARAM, char **argv) { uint8_t *temp, *message; char *str_c, *str_V, *str_h, *str_F, *str_r; - USE_FEATURE_UDHCP_PORT(char *str_P;) + IF_FEATURE_UDHCP_PORT(char *str_P;) llist_t *list_O = NULL; int tryagain_timeout = 20; int discover_timeout = 3; @@ -143,10 +156,10 @@ int udhcpc_main(int argc UNUSED_PARAM, char **argv) int max_fd; int retval; struct timeval tv; - struct dhcpMessage packet; + struct dhcp_packet packet; fd_set rfds; -#if ENABLE_GETOPT_LONG +#if ENABLE_LONG_OPTS static const char udhcpc_longopts[] ALIGN1 = "clientid\0" Required_argument "c" "clientid-none\0" No_argument "C" @@ -169,8 +182,8 @@ int udhcpc_main(int argc UNUSED_PARAM, char **argv) "no-default-options\0" No_argument "o" "foreground\0" No_argument "f" "background\0" No_argument "b" - USE_FEATURE_UDHCPC_ARPING("arping\0" No_argument "a") - USE_FEATURE_UDHCP_PORT("client-port\0" Required_argument "P") + IF_FEATURE_UDHCPC_ARPING("arping\0" No_argument "a") + IF_FEATURE_UDHCP_PORT("client-port\0" Required_argument "P") ; #endif enum { @@ -189,42 +202,49 @@ int udhcpc_main(int argc UNUSED_PARAM, char **argv) OPT_s = 1 << 12, OPT_T = 1 << 13, OPT_t = 1 << 14, - OPT_v = 1 << 15, - OPT_S = 1 << 16, - OPT_A = 1 << 17, - OPT_O = 1 << 18, - OPT_o = 1 << 19, - OPT_f = 1 << 20, + OPT_S = 1 << 15, + OPT_A = 1 << 16, + OPT_O = 1 << 17, + OPT_o = 1 << 18, + OPT_f = 1 << 19, /* The rest has variable bit positions, need to be clever */ - OPTBIT_f = 20, - USE_FOR_MMU( OPTBIT_b,) - USE_FEATURE_UDHCPC_ARPING(OPTBIT_a,) - USE_FEATURE_UDHCP_PORT( OPTBIT_P,) - USE_FOR_MMU( OPT_b = 1 << OPTBIT_b,) - USE_FEATURE_UDHCPC_ARPING(OPT_a = 1 << OPTBIT_a,) - USE_FEATURE_UDHCP_PORT( OPT_P = 1 << OPTBIT_P,) + OPTBIT_f = 19, + USE_FOR_MMU( OPTBIT_b,) + IF_FEATURE_UDHCPC_ARPING(OPTBIT_a,) + IF_FEATURE_UDHCP_PORT( OPTBIT_P,) + USE_FOR_MMU( OPT_b = 1 << OPTBIT_b,) + IF_FEATURE_UDHCPC_ARPING(OPT_a = 1 << OPTBIT_a,) + IF_FEATURE_UDHCP_PORT( OPT_P = 1 << OPTBIT_P,) }; /* Default options. */ - USE_FEATURE_UDHCP_PORT(SERVER_PORT = 67;) - USE_FEATURE_UDHCP_PORT(CLIENT_PORT = 68;) + IF_FEATURE_UDHCP_PORT(SERVER_PORT = 67;) + IF_FEATURE_UDHCP_PORT(CLIENT_PORT = 68;) client_config.interface = "eth0"; client_config.script = DEFAULT_SCRIPT; /* Parse command line */ /* Cc: mutually exclusive; O: list; -T,-t,-A take numeric param */ - opt_complementary = "c--C:C--c:O::T+:t+:A+"; - USE_GETOPT_LONG(applet_long_options = udhcpc_longopts;) - opt = getopt32(argv, "c:CV:H:h:F:i:np:qRr:s:T:t:vSA:O:of" + opt_complementary = "c--C:C--c:O::T+:t+:A+" +#if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1 + ":vv" +#endif + ; + IF_LONG_OPTS(applet_long_options = udhcpc_longopts;) + opt = getopt32(argv, "c:CV:H:h:F:i:np:qRr:s:T:t:SA:O:of" USE_FOR_MMU("b") - USE_FEATURE_UDHCPC_ARPING("a") - USE_FEATURE_UDHCP_PORT("P:") + IF_FEATURE_UDHCPC_ARPING("a") + IF_FEATURE_UDHCP_PORT("P:") + "v" , &str_c, &str_V, &str_h, &str_h, &str_F , &client_config.interface, &client_config.pidfile, &str_r /* i,p */ , &client_config.script /* s */ , &discover_timeout, &discover_retries, &tryagain_timeout /* T,t,A */ , &list_O - USE_FEATURE_UDHCP_PORT(, &str_P) + IF_FEATURE_UDHCP_PORT(, &str_P) +#if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1 + , &dhcp_verbose +#endif ); if (opt & OPT_c) client_config.clientid = alloc_dhcp_option(DHCP_CLIENT_ID, str_c, 0); @@ -246,10 +266,6 @@ int udhcpc_main(int argc UNUSED_PARAM, char **argv) } if (opt & OPT_r) requested_ip = inet_addr(str_r); - if (opt & OPT_v) { - puts("version "BB_VER); - return 0; - } #if ENABLE_FEATURE_UDHCP_PORT if (opt & OPT_P) { CLIENT_PORT = xatou16(str_P); @@ -267,18 +283,23 @@ int udhcpc_main(int argc UNUSED_PARAM, char **argv) client_config.opt_mask[n >> 3] |= 1 << (n & 7); } - if (udhcp_read_interface(client_config.interface, &client_config.ifindex, - NULL, client_config.arp)) + if (udhcp_read_interface(client_config.interface, + &client_config.ifindex, + NULL, + client_config.client_mac) + ) { return 1; + } + #if !BB_MMU /* on NOMMU reexec (i.e., background) early */ if (!(opt & OPT_f)) { bb_daemonize_or_rexec(0 /* flags */, argv); - logmode = 0; + logmode = LOGMODE_NONE; } #endif if (opt & OPT_S) { - openlog(applet_name, LOG_PID, LOG_LOCAL0); + openlog(applet_name, LOG_PID, LOG_DAEMON); logmode |= LOGMODE_SYSLOG; } @@ -293,17 +314,17 @@ int udhcpc_main(int argc UNUSED_PARAM, char **argv) /* Goes to stdout (unless NOMMU) and possibly syslog */ bb_info_msg("%s (v"BB_VER") started", applet_name); - /* if not set, and not suppressed, setup the default client ID */ + /* If not set, and not suppressed, set up the default client ID */ if (!client_config.clientid && !(opt & OPT_C)) { client_config.clientid = alloc_dhcp_option(DHCP_CLIENT_ID, "", 7); client_config.clientid[OPT_DATA] = 1; - memcpy(client_config.clientid + OPT_DATA+1, client_config.arp, 6); + memcpy(client_config.clientid + OPT_DATA+1, client_config.client_mac, 6); } if (!client_config.vendorclass) client_config.vendorclass = alloc_dhcp_option(DHCP_VENDOR, "udhcp "BB_VER, 0); - /* setup the signal pipe */ + /* Set up the signal pipe */ udhcp_sp_setup(); state = INIT_SELECTING; @@ -318,27 +339,33 @@ int udhcpc_main(int argc UNUSED_PARAM, char **argv) * "continue" statements in code below jump to the top of the loop. */ for (;;) { - unsigned timestamp_before_wait; + /* silence "uninitialized!" warning */ + unsigned timestamp_before_wait = timestamp_before_wait; + + //bb_error_msg("sockfd:%d, listen_mode:%d", sockfd, listen_mode); + + /* Was opening raw or udp socket here + * if (listen_mode != LISTEN_NONE && sockfd < 0), + * but on fast network renew responses return faster + * than we open sockets. Thus this code is moved + * to change_listen_mode(). Thus we open listen socket + * BEFORE we send renew request (see "case BOUND:"). */ - if (listen_mode != LISTEN_NONE && sockfd < 0) { - if (listen_mode == LISTEN_KERNEL) - sockfd = udhcp_listen_socket(/*INADDR_ANY,*/ CLIENT_PORT, client_config.interface); - else - sockfd = udhcp_raw_socket(client_config.ifindex); - } max_fd = udhcp_sp_fd_set(&rfds, sockfd); tv.tv_sec = timeout - already_waited_sec; tv.tv_usec = 0; retval = 0; /* If we already timed out, fall through, else... */ - if (tv.tv_sec > 0) { + if ((int)tv.tv_sec > 0) { timestamp_before_wait = (unsigned)monotonic_sec(); - DEBUG("Waiting on select..."); + log1("Waiting on select..."); retval = select(max_fd + 1, &rfds, NULL, NULL, &tv); if (retval < 0) { /* EINTR? A signal was caught, don't panic */ - if (errno == EINTR) + if (errno == EINTR) { + already_waited_sec += (unsigned)monotonic_sec() - timestamp_before_wait; continue; + } /* Else: an error occured, panic! */ bb_perror_msg_and_die("select"); } @@ -356,9 +383,8 @@ int udhcpc_main(int argc UNUSED_PARAM, char **argv) if (packet_num < discover_retries) { if (packet_num == 0) xid = random_xid(); - - send_discover(xid, requested_ip); /* broadcast */ - + /* broadcast */ + send_discover(xid, requested_ip); timeout = discover_timeout; packet_num++; continue; @@ -382,62 +408,62 @@ int udhcpc_main(int argc UNUSED_PARAM, char **argv) timeout = tryagain_timeout; packet_num = 0; continue; - case RENEW_REQUESTED: case REQUESTING: if (packet_num < discover_retries) { - /* send request packet */ - if (state == RENEW_REQUESTED) /* unicast */ - send_renew(xid, server_addr, requested_ip); - else /* broadcast */ - send_select(xid, server_addr, requested_ip); - + /* send broadcast select packet */ + send_select(xid, server_addr, requested_ip); timeout = discover_timeout; packet_num++; continue; } - /* timed out, go back to init state */ - if (state == RENEW_REQUESTED) - udhcp_run_script(NULL, "deconfig"); + /* Timed out, go back to init state. + * "discover...select...discover..." loops + * were seen in the wild. Treat them similarly + * to "no response to discover" case */ change_listen_mode(LISTEN_RAW); state = INIT_SELECTING; - /* "discover...select...discover..." loops - * were seen in the wild. Treat then similarly - * to "no response to discover" case */ - if (state == REQUESTING) - goto leasefail; - timeout = 0; - packet_num = 0; - continue; + goto leasefail; case BOUND: - /* Half of the lease passed, time to enter renewing state */ - change_listen_mode(LISTEN_KERNEL); - DEBUG("Entering renew state"); + /* 1/2 lease passed, enter renewing state */ state = RENEWING; + change_listen_mode(LISTEN_KERNEL); + log1("Entering renew state"); /* fall right through */ + case RENEW_REQUESTED: /* manual (SIGUSR1) renew */ + case_RENEW_REQUESTED: case RENEWING: if (timeout > 60) { - /* send a request packet */ - send_renew(xid, server_addr, requested_ip); /* unicast */ + /* send an unicast renew request */ + /* Sometimes observed to fail (EADDRNOTAVAIL) to bind + * a new UDP socket for sending inside send_renew. + * I hazard to guess existing listening socket + * is somehow conflicting with it, but why is it + * not deterministic then?! Strange. + * Anyway, it does recover by eventually failing through + * into INIT_SELECTING state. + */ + send_renew(xid, server_addr, requested_ip); timeout >>= 1; continue; } /* Timed out, enter rebinding state */ - DEBUG("Entering rebinding state"); + log1("Entering rebinding state"); state = REBINDING; /* fall right through */ case REBINDING: + /* Switch to bcast receive */ + change_listen_mode(LISTEN_RAW); /* Lease is *really* about to run out, * try to find DHCP server using broadcast */ if (timeout > 0) { - /* send a request packet */ - send_renew(xid, 0 /* INADDR_ANY*/, requested_ip); /* broadcast */ + /* send a broadcast renew request */ + send_renew(xid, 0 /*INADDR_ANY*/, requested_ip); timeout >>= 1; continue; } /* Timed out, enter init state */ bb_info_msg("Lease lost, entering init state"); udhcp_run_script(NULL, "deconfig"); - change_listen_mode(LISTEN_RAW); state = INIT_SELECTING; /*timeout = 0; - already is */ packet_num = 0; @@ -447,20 +473,48 @@ int udhcpc_main(int argc UNUSED_PARAM, char **argv) /* yah, I know, *you* say it would never happen */ timeout = INT_MAX; continue; /* back to main loop */ + } /* if select timed out */ + + /* select() didn't timeout, something happened */ + + /* Is it a signal? */ + /* note: udhcp_sp_read checks FD_ISSET before reading */ + switch (udhcp_sp_read(&rfds)) { + case SIGUSR1: + perform_renew(); + if (state == RENEW_REQUESTED) + goto case_RENEW_REQUESTED; + /* Start things over */ + packet_num = 0; + /* Kill any timeouts, user wants this to hurry along */ + timeout = 0; + continue; + case SIGUSR2: + perform_release(requested_ip, server_addr); + timeout = INT_MAX; + continue; + case SIGTERM: + bb_info_msg("Received SIGTERM"); + if (opt & OPT_R) /* release on quit */ + perform_release(requested_ip, server_addr); + goto ret0; } - /* select() didn't timeout, something did happen. */ - /* Is is a packet? */ - if (listen_mode != LISTEN_NONE && FD_ISSET(sockfd, &rfds)) { + /* Is it a packet? */ + if (listen_mode == LISTEN_NONE || !FD_ISSET(sockfd, &rfds)) + continue; /* no */ + + { int len; - /* A packet is ready, read it */ + /* A packet is ready, read it */ if (listen_mode == LISTEN_KERNEL) len = udhcp_recv_kernel_packet(&packet, sockfd); else len = udhcp_recv_raw_packet(&packet, sockfd); - if (len == -1) { /* error is severe, reopen socket */ - DEBUG("error on read, %s, reopening socket", strerror(errno)); + if (len == -1) { + /* Error is severe, reopen socket */ + bb_info_msg("Read error: %s, reopening socket", strerror(errno)); sleep(discover_timeout); /* 3 seconds by default */ change_listen_mode(listen_mode); /* just close and reopen */ } @@ -470,164 +524,151 @@ int udhcpc_main(int argc UNUSED_PARAM, char **argv) already_waited_sec += (unsigned)monotonic_sec() - timestamp_before_wait; if (len < 0) continue; + } - if (packet.xid != xid) { - DEBUG("Ignoring XID %x (our xid is %x)", - (unsigned)packet.xid, (unsigned)xid); - continue; - } + if (packet.xid != xid) { + log1("xid %x (our is %x), ignoring packet", + (unsigned)packet.xid, (unsigned)xid); + continue; + } - /* Ignore packets that aren't for us */ - if (memcmp(packet.chaddr, client_config.arp, 6)) { - DEBUG("Packet does not have our chaddr - ignoring"); - continue; - } + /* Ignore packets that aren't for us */ + if (packet.hlen != 6 + || memcmp(packet.chaddr, client_config.client_mac, 6) + ) { +//FIXME: need to also check that last 10 bytes are zero + log1("chaddr does not match, ignoring packet"); // log2? + continue; + } - message = get_option(&packet, DHCP_MESSAGE_TYPE); - if (message == NULL) { - bb_error_msg("cannot get message type from packet - ignoring"); - continue; - } + message = get_option(&packet, DHCP_MESSAGE_TYPE); + if (message == NULL) { + bb_error_msg("no message type option, ignoring packet"); + continue; + } - switch (state) { - case INIT_SELECTING: - /* Must be a DHCPOFFER to one of our xid's */ - if (*message == DHCPOFFER) { - /* TODO: why we don't just fetch server's IP from IP header? */ - temp = get_option(&packet, DHCP_SERVER_ID); - if (!temp) { - bb_error_msg("no server ID in message"); - continue; - /* still selecting - this server looks bad */ - } + switch (state) { + case INIT_SELECTING: + /* Must be a DHCPOFFER to one of our xid's */ + if (*message == DHCPOFFER) { + /* TODO: why we don't just fetch server's IP from IP header? */ + temp = get_option(&packet, DHCP_SERVER_ID); + if (!temp) { + bb_error_msg("no server ID in message"); + continue; + /* still selecting - this server looks bad */ + } + /* it IS unaligned sometimes, don't "optimize" */ + move_from_unaligned32(server_addr, temp); + xid = packet.xid; + requested_ip = packet.yiaddr; + + /* enter requesting state */ + state = REQUESTING; + timeout = 0; + packet_num = 0; + already_waited_sec = 0; + } + continue; + case REQUESTING: + case RENEWING: + case RENEW_REQUESTED: + case REBINDING: + if (*message == DHCPACK) { + temp = get_option(&packet, DHCP_LEASE_TIME); + if (!temp) { + bb_error_msg("no lease time with ACK, using 1 hour lease"); + lease_seconds = 60 * 60; + } else { /* it IS unaligned sometimes, don't "optimize" */ - server_addr = get_unaligned_u32p((uint32_t*)temp); - xid = packet.xid; - requested_ip = packet.yiaddr; - - /* enter requesting state */ - state = REQUESTING; - timeout = 0; - packet_num = 0; - already_waited_sec = 0; + move_from_unaligned32(lease_seconds, temp); + lease_seconds = ntohl(lease_seconds); + lease_seconds &= 0x0fffffff; /* paranoia: must not be prone to overflows */ + if (lease_seconds < 10) /* and not too small */ + lease_seconds = 10; } - continue; - case RENEW_REQUESTED: - case REQUESTING: - case RENEWING: - case REBINDING: - if (*message == DHCPACK) { - temp = get_option(&packet, DHCP_LEASE_TIME); - if (!temp) { - bb_error_msg("no lease time with ACK, using 1 hour lease"); - lease_seconds = 60 * 60; - } else { - /* can be misaligned, thus memcpy */ - memcpy(&lease_seconds, temp, 4); - lease_seconds = ntohl(lease_seconds); - lease_seconds &= 0x0fffffff; /* paranoia: must not be prone to overflows */ - if (lease_seconds < 10) /* and not too small */ - lease_seconds = 10; - } -//FIXME: why do we check ARP only after we've got DHCPACK? -//Shouldn't we do it immediately after DHCPOFFER? #if ENABLE_FEATURE_UDHCPC_ARPING - if (opt & OPT_a) { - if (!arpping(packet.yiaddr, - (uint32_t) 0, - client_config.arp, - client_config.interface) - ) { - bb_info_msg("offered address is in use " - "(got ARP reply), declining"); -//NB: not clear whether it should be unicast or bcast. -//Currently it is a bcast. Why? - send_decline(xid, server_addr, packet.yiaddr); - - if (state != REQUESTING) - udhcp_run_script(NULL, "deconfig"); - change_listen_mode(LISTEN_RAW); - state = INIT_SELECTING; - requested_ip = 0; - timeout = tryagain_timeout; - packet_num = 0; - already_waited_sec = 0; - continue; /* back to main loop */ - } - } -#endif - /* enter bound state */ - timeout = lease_seconds / 2; - { - struct in_addr temp_addr; - temp_addr.s_addr = packet.yiaddr; - bb_info_msg("Lease of %s obtained, lease time %u", - inet_ntoa(temp_addr), (unsigned)lease_seconds); - } - requested_ip = packet.yiaddr; - udhcp_run_script(&packet, - ((state == RENEWING || state == REBINDING) ? "renew" : "bound")); - - state = BOUND; - change_listen_mode(LISTEN_NONE); - if (opt & OPT_q) { /* quit after lease */ - if (opt & OPT_R) /* release on quit */ - perform_release(requested_ip, server_addr); - goto ret0; - } -#if BB_MMU /* NOMMU case backgrounded earlier */ - if (!(opt & OPT_f)) { - client_background(); - /* do not background again! */ - opt = ((opt & ~OPT_b) | OPT_f); + if (opt & OPT_a) { +/* RFC 2131 3.1 paragraph 5: + * "The client receives the DHCPACK message with configuration + * parameters. The client SHOULD perform a final check on the + * parameters (e.g., ARP for allocated network address), and notes + * the duration of the lease specified in the DHCPACK message. At this + * point, the client is configured. If the client detects that the + * address is already in use (e.g., through the use of ARP), + * the client MUST send a DHCPDECLINE message to the server and restarts + * the configuration process..." */ + if (!arpping(packet.yiaddr, + NULL, + (uint32_t) 0, + client_config.client_mac, + client_config.interface) + ) { + bb_info_msg("Offered address is in use " + "(got ARP reply), declining"); + send_decline(xid, server_addr, packet.yiaddr); + + if (state != REQUESTING) + udhcp_run_script(NULL, "deconfig"); + change_listen_mode(LISTEN_RAW); + state = INIT_SELECTING; + requested_ip = 0; + timeout = tryagain_timeout; + packet_num = 0; + already_waited_sec = 0; + continue; /* back to main loop */ } + } #endif - already_waited_sec = 0; - continue; /* back to main loop */ + /* enter bound state */ + timeout = lease_seconds / 2; + { + struct in_addr temp_addr; + temp_addr.s_addr = packet.yiaddr; + bb_info_msg("Lease of %s obtained, lease time %u", + inet_ntoa(temp_addr), (unsigned)lease_seconds); } - if (*message == DHCPNAK) { - /* return to init state */ - bb_info_msg("Received DHCP NAK"); - udhcp_run_script(&packet, "nak"); - if (state != REQUESTING) - udhcp_run_script(NULL, "deconfig"); - change_listen_mode(LISTEN_RAW); - sleep(3); /* avoid excessive network traffic */ - state = INIT_SELECTING; - requested_ip = 0; - timeout = 0; - packet_num = 0; - already_waited_sec = 0; + requested_ip = packet.yiaddr; + udhcp_run_script(&packet, state == REQUESTING ? "bound" : "renew"); + + state = BOUND; + change_listen_mode(LISTEN_NONE); + if (opt & OPT_q) { /* quit after lease */ + if (opt & OPT_R) /* release on quit */ + perform_release(requested_ip, server_addr); + goto ret0; } - continue; - /* case BOUND, RELEASED: - ignore all packets */ + /* future renew failures should not exit (JM) */ + opt &= ~OPT_n; +#if BB_MMU /* NOMMU case backgrounded earlier */ + if (!(opt & OPT_f)) { + client_background(); + /* do not background again! */ + opt = ((opt & ~OPT_b) | OPT_f); + } +#endif + already_waited_sec = 0; + continue; /* back to main loop */ } - continue; /* back to main loop */ - } - - /* select() didn't timeout, something did happen. - * But it wasn't a packet. It's a signal pipe then. */ - { - int signo = udhcp_sp_read(&rfds); - switch (signo) { - case SIGUSR1: - perform_renew(); - /* start things over */ - packet_num = 0; - /* Kill any timeouts because the user wants this to hurry along */ + if (*message == DHCPNAK) { + /* return to init state */ + bb_info_msg("Received DHCP NAK"); + udhcp_run_script(&packet, "nak"); + if (state != REQUESTING) + udhcp_run_script(NULL, "deconfig"); + change_listen_mode(LISTEN_RAW); + sleep(3); /* avoid excessive network traffic */ + state = INIT_SELECTING; + requested_ip = 0; timeout = 0; - break; - case SIGUSR2: - perform_release(requested_ip, server_addr); - timeout = INT_MAX; - break; - case SIGTERM: - bb_info_msg("Received SIGTERM"); - if (opt & OPT_R) /* release on quit */ - perform_release(requested_ip, server_addr); - goto ret0; + packet_num = 0; + already_waited_sec = 0; } + continue; + /* case BOUND: - ignore all packets */ + /* case RELEASED: - ignore all packets */ } + /* back to main loop */ } /* for (;;) - main loop ends */ ret0: