networking/udhcp/dhcpc.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * udhcp DHCP 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"
  27 #include "options.h"
  28
  29 #include <asm/types.h>
  30 #if (defined(__GLIBC__) && __GLIBC__ >= 2 && __GLIBC_MINOR__ >= 1) || defined(_NEWLIB_VERSION)
  31 # include <netpacket/packet.h>
  32 # include <net/ethernet.h>
  33 #else
  34 # include <linux/if_packet.h>
  35 # include <linux/if_ether.h>
  36 #endif
  37 #include <linux/filter.h>
  38
  39
  40 static int sockfd = -1;
  41
  42 #define LISTEN_NONE   0
  43 #define LISTEN_KERNEL 1
  44 #define LISTEN_RAW    2
  45 static smallint listen_mode;
  46
  47 /* initial state: (re)start DHCP negotiation */
  48 #define INIT_SELECTING  0
  49 /* discover was sent, DHCPOFFER reply received */
  50 #define REQUESTING      1
  51 /* select/renew was sent, DHCPACK reply received */
  52 #define BOUND           2
  53 /* half of lease passed, want to renew it by sending unicast renew requests */
  54 #define RENEWING        3
  55 /* renew requests were not answered, lease is almost over, send broadcast renew */
  56 #define REBINDING       4
  57 /* manually requested renew (SIGUSR1) */
  58 #define RENEW_REQUESTED 5
  59 /* release, possibly manually requested (SIGUSR2) */
  60 #define RELEASED        6
  61 static smallint state;
  62
  63 /* struct client_config_t client_config is in bb_common_bufsiz1 */
  64
  65
  66
  67 static int udhcp_raw_socket(int ifindex)
  68 {
  69         int fd;
  70         struct sockaddr_ll sock;
  71
  72         /*
  73          * Comment:
  74          *
  75          *      I've selected not to see LL header, so BPF doesn't see it, too.
  76          *      The filter may also pass non-IP and non-ARP packets, but we do
  77          *      a more complete check when receiving the message in userspace.
  78          *
  79          * and filter shamelessly stolen from:
  80          *
  81          *      http://www.flamewarmaster.de/software/dhcpclient/
  82          *
  83          * There are a few other interesting ideas on that page (look under
  84          * "Motivation").  Use of netlink events is most interesting.  Think
  85          * of various network servers listening for events and reconfiguring.
  86          * That would obsolete sending HUP signals and/or make use of restarts.
  87          *
  88          * Copyright: 2006, 2007 Stefan Rompf <sux@loplof.de>.
  89          * License: GPL v2.
  90          *
  91          * TODO: make conditional?
  92          */
  93 #define SERVER_AND_CLIENT_PORTS  ((67 << 16) + 68)
  94         static const struct sock_filter filter_instr[] = {
  95                 /* check for udp */
  96                 BPF_STMT(BPF_LD|BPF_B|BPF_ABS, 9),
  97                 BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, IPPROTO_UDP, 2, 0),     /* L5, L1, is UDP? */
  98                 /* ugly check for arp on ethernet-like and IPv4 */
  99                 BPF_STMT(BPF_LD|BPF_W|BPF_ABS, 2),                      /* L1: */
 100                 BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, 0x08000604, 3, 4),      /* L3, L4 */
 101                 /* skip IP header */
 102                 BPF_STMT(BPF_LDX|BPF_B|BPF_MSH, 0),                     /* L5: */
 103                 /* check udp source and destination ports */
 104                 BPF_STMT(BPF_LD|BPF_W|BPF_IND, 0),
 105                 BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, SERVER_AND_CLIENT_PORTS, 0, 1), /* L3, L4 */
 106                 /* returns */
 107                 BPF_STMT(BPF_RET|BPF_K, 0x0fffffff ),                   /* L3: pass */
 108                 BPF_STMT(BPF_RET|BPF_K, 0),                             /* L4: reject */
 109         };
 110         static const struct sock_fprog filter_prog = {
 111                 .len = sizeof(filter_instr) / sizeof(filter_instr[0]),
 112                 /* casting const away: */
 113                 .filter = (struct sock_filter *) filter_instr,
 114         };
 115
 116         log1("Opening raw socket on ifindex %d", ifindex); //log2?
 117
 118         fd = xsocket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_IP));
 119         log1("Got raw socket fd %d", fd); //log2?
 120
 121         if (SERVER_PORT == 67 && CLIENT_PORT == 68) {
 122                 /* Use only if standard ports are in use */
 123                 /* Ignoring error (kernel may lack support for this) */
 124                 if (setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &filter_prog,
 125                                 sizeof(filter_prog)) >= 0)
 126                         log1("Attached filter to raw socket fd %d", fd); // log?
 127         }
 128
 129         sock.sll_family = AF_PACKET;
 130         sock.sll_protocol = htons(ETH_P_IP);
 131         sock.sll_ifindex = ifindex;
 132         xbind(fd, (struct sockaddr *) &sock, sizeof(sock));
 133         log1("Created raw socket");
 134
 135         return fd;
 136 }
 137
 138
 139 /* just a little helper */
 140 static void change_listen_mode(int new_mode)
 141 {
 142         log1("Entering listen mode: %s",
 143                 new_mode != LISTEN_NONE
 144                         ? (new_mode == LISTEN_KERNEL ? "kernel" : "raw")
 145                         : "none"
 146         );
 147
 148         listen_mode = new_mode;
 149         if (sockfd >= 0) {
 150                 close(sockfd);
 151                 sockfd = -1;
 152         }
 153         if (new_mode == LISTEN_KERNEL)
 154                 sockfd = udhcp_listen_socket(/*INADDR_ANY,*/ CLIENT_PORT, client_config.interface);
 155         else if (new_mode != LISTEN_NONE)
 156                 sockfd = udhcp_raw_socket(client_config.ifindex);
 157         /* else LISTEN_NONE: sockfd stays closed */
 158 }
 159
 160
 161 /* perform a renew */
 162 static void perform_renew(void)
 163 {
 164         bb_info_msg("Performing a DHCP renew");
 165         switch (state) {
 166         case BOUND:
 167                 change_listen_mode(LISTEN_KERNEL);
 168         case RENEWING:
 169         case REBINDING:
 170                 state = RENEW_REQUESTED;
 171                 break;
 172         case RENEW_REQUESTED: /* impatient are we? fine, square 1 */
 173                 udhcp_run_script(NULL, "deconfig");
 174         case REQUESTING:
 175         case RELEASED:
 176                 change_listen_mode(LISTEN_RAW);
 177                 state = INIT_SELECTING;
 178                 break;
 179         case INIT_SELECTING:
 180                 break;
 181         }
 182 }
 183
 184
 185 /* perform a release */
 186 static void perform_release(uint32_t requested_ip, uint32_t server_addr)
 187 {
 188         char buffer[sizeof("255.255.255.255")];
 189         struct in_addr temp_addr;
 190
 191         /* send release packet */
 192         if (state == BOUND || state == RENEWING || state == REBINDING) {
 193                 temp_addr.s_addr = server_addr;
 194                 strcpy(buffer, inet_ntoa(temp_addr));
 195                 temp_addr.s_addr = requested_ip;
 196                 bb_info_msg("Unicasting a release of %s to %s",
 197                                 inet_ntoa(temp_addr), buffer);
 198                 send_release(server_addr, requested_ip); /* unicast */
 199                 udhcp_run_script(NULL, "deconfig");
 200         }
 201         bb_info_msg("Entering released state");
 202
 203         change_listen_mode(LISTEN_NONE);
 204         state = RELEASED;
 205 }
 206
 207
 208 #if BB_MMU
 209 static void client_background(void)
 210 {
 211         bb_daemonize(0);
 212         logmode &= ~LOGMODE_STDIO;
 213         /* rewrite pidfile, as our pid is different now */
 214         write_pidfile(client_config.pidfile);
 215 }
 216 #endif
 217
 218
 219 static uint8_t* alloc_dhcp_option(int code, const char *str, int extra)
 220 {
 221         uint8_t *storage;
 222         int len = strnlen(str, 255);
 223         storage = xzalloc(len + extra + OPT_DATA);
 224         storage[OPT_CODE] = code;
 225         storage[OPT_LEN] = len + extra;
 226         memcpy(storage + extra + OPT_DATA, str, len);
 227         return storage;
 228 }
 229
 230
 231 int udhcpc_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 232 int udhcpc_main(int argc UNUSED_PARAM, char **argv)
 233 {
 234         uint8_t *temp, *message;
 235         const char *str_c, *str_V, *str_h, *str_F, *str_r;
 236         IF_FEATURE_UDHCP_PORT(char *str_P;)
 237         llist_t *list_O = NULL;
 238         int tryagain_timeout = 20;
 239         int discover_timeout = 3;
 240         int discover_retries = 3;
 241         uint32_t server_addr = server_addr; /* for compiler */
 242         uint32_t requested_ip = 0;
 243         uint32_t xid = 0;
 244         uint32_t lease_seconds = 0; /* can be given as 32-bit quantity */
 245         int packet_num;
 246         int timeout; /* must be signed */
 247         unsigned already_waited_sec;
 248         unsigned opt;
 249         int max_fd;
 250         int retval;
 251         struct timeval tv;
 252         struct dhcp_packet packet;
 253         fd_set rfds;
 254
 255 #if ENABLE_LONG_OPTS
 256         static const char udhcpc_longopts[] ALIGN1 =
 257                 "clientid\0"       Required_argument "c"
 258                 "clientid-none\0"  No_argument       "C"
 259                 "vendorclass\0"    Required_argument "V"
 260                 "hostname\0"       Required_argument "H"
 261                 "fqdn\0"           Required_argument "F"
 262                 "interface\0"      Required_argument "i"
 263                 "now\0"            No_argument       "n"
 264                 "pidfile\0"        Required_argument "p"
 265                 "quit\0"           No_argument       "q"
 266                 "release\0"        No_argument       "R"
 267                 "request\0"        Required_argument "r"
 268                 "script\0"         Required_argument "s"
 269                 "timeout\0"        Required_argument "T"
 270                 "version\0"        No_argument       "v"
 271                 "retries\0"        Required_argument "t"
 272                 "tryagain\0"       Required_argument "A"
 273                 "syslog\0"         No_argument       "S"
 274                 "request-option\0" Required_argument "O"
 275                 "no-default-options\0" No_argument   "o"
 276                 "foreground\0"     No_argument       "f"
 277                 "background\0"     No_argument       "b"
 278                 IF_FEATURE_UDHCPC_ARPING("arping\0"     No_argument       "a")
 279                 IF_FEATURE_UDHCP_PORT("client-port\0"   Required_argument "P")
 280                 ;
 281 #endif
 282         enum {
 283                 OPT_c = 1 << 0,
 284                 OPT_C = 1 << 1,
 285                 OPT_V = 1 << 2,
 286                 OPT_H = 1 << 3,
 287                 OPT_h = 1 << 4,
 288                 OPT_F = 1 << 5,
 289                 OPT_i = 1 << 6,
 290                 OPT_n = 1 << 7,
 291                 OPT_p = 1 << 8,
 292                 OPT_q = 1 << 9,
 293                 OPT_R = 1 << 10,
 294                 OPT_r = 1 << 11,
 295                 OPT_s = 1 << 12,
 296                 OPT_T = 1 << 13,
 297                 OPT_t = 1 << 14,
 298                 OPT_S = 1 << 15,
 299                 OPT_A = 1 << 16,
 300                 OPT_O = 1 << 17,
 301                 OPT_o = 1 << 18,
 302                 OPT_f = 1 << 19,
 303 /* The rest has variable bit positions, need to be clever */
 304                 OPTBIT_f = 19,
 305                 USE_FOR_MMU(             OPTBIT_b,)
 306                 IF_FEATURE_UDHCPC_ARPING(OPTBIT_a,)
 307                 IF_FEATURE_UDHCP_PORT(   OPTBIT_P,)
 308                 USE_FOR_MMU(             OPT_b = 1 << OPTBIT_b,)
 309                 IF_FEATURE_UDHCPC_ARPING(OPT_a = 1 << OPTBIT_a,)
 310                 IF_FEATURE_UDHCP_PORT(   OPT_P = 1 << OPTBIT_P,)
 311         };
 312
 313         /* Default options. */
 314         IF_FEATURE_UDHCP_PORT(SERVER_PORT = 67;)
 315         IF_FEATURE_UDHCP_PORT(CLIENT_PORT = 68;)
 316         client_config.interface = "eth0";
 317         client_config.script = DEFAULT_SCRIPT;
 318         str_V = "udhcp "BB_VER;
 319
 320         /* Parse command line */
 321         /* Cc: mutually exclusive; O: list; -T,-t,-A take numeric param */
 322         opt_complementary = "c--C:C--c:O::T+:t+:A+"
 323 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
 324                 ":vv"
 325 #endif
 326                 ;
 327         IF_LONG_OPTS(applet_long_options = udhcpc_longopts;)
 328         opt = getopt32(argv, "c:CV:H:h:F:i:np:qRr:s:T:t:SA:O:of"
 329                 USE_FOR_MMU("b")
 330                 IF_FEATURE_UDHCPC_ARPING("a")
 331                 IF_FEATURE_UDHCP_PORT("P:")
 332                 "v"
 333                 , &str_c, &str_V, &str_h, &str_h, &str_F
 334                 , &client_config.interface, &client_config.pidfile, &str_r /* i,p */
 335                 , &client_config.script /* s */
 336                 , &discover_timeout, &discover_retries, &tryagain_timeout /* T,t,A */
 337                 , &list_O
 338                 IF_FEATURE_UDHCP_PORT(, &str_P)
 339 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
 340                 , &dhcp_verbose
 341 #endif
 342                 );
 343         if (opt & (OPT_h|OPT_H))
 344                 client_config.hostname = alloc_dhcp_option(DHCP_HOST_NAME, str_h, 0);
 345         if (opt & OPT_F) {
 346                 /* FQDN option format: [0x51][len][flags][0][0]<fqdn> */
 347                 client_config.fqdn = alloc_dhcp_option(DHCP_FQDN, str_F, 3);
 348                 /* Flag bits: 0000NEOS
 349                  * S: 1 = Client requests server to update A RR in DNS as well as PTR
 350                  * O: 1 = Server indicates to client that DNS has been updated regardless
 351                  * E: 1 = Name is in DNS format, i.e. <4>host<6>domain<3>com<0>,
 352                  *    not "host.domain.com". Format 0 is obsolete.
 353                  * N: 1 = Client requests server to not update DNS (S must be 0 then)
 354                  * Two [0] bytes which follow are deprecated and must be 0.
 355                  */
 356                 client_config.fqdn[OPT_DATA + 0] = 0x1;
 357                 /*client_config.fqdn[OPT_DATA + 1] = 0; - xzalloc did it */
 358                 /*client_config.fqdn[OPT_DATA + 2] = 0; */
 359         }
 360         if (opt & OPT_r)
 361                 requested_ip = inet_addr(str_r);
 362 #if ENABLE_FEATURE_UDHCP_PORT
 363         if (opt & OPT_P) {
 364                 CLIENT_PORT = xatou16(str_P);
 365                 SERVER_PORT = CLIENT_PORT - 1;
 366         }
 367 #endif
 368         if (opt & OPT_o)
 369                 client_config.no_default_options = 1;
 370         while (list_O) {
 371                 char *optstr = llist_pop(&list_O);
 372                 int n = index_in_strings(dhcp_option_strings, optstr);
 373                 if (n < 0)
 374                         bb_error_msg_and_die("unknown option '%s'", optstr);
 375                 n = dhcp_options[n].code;
 376                 client_config.opt_mask[n >> 3] |= 1 << (n & 7);
 377         }
 378
 379         if (udhcp_read_interface(client_config.interface,
 380                         &client_config.ifindex,
 381                         NULL,
 382                         client_config.client_mac)
 383         ) {
 384                 return 1;
 385         }
 386
 387         if (opt & OPT_c) {
 388                 client_config.clientid = alloc_dhcp_option(DHCP_CLIENT_ID, str_c, 0);
 389         } else if (!(opt & OPT_C)) {
 390                 /* not set and not suppressed, set the default client ID */
 391                 client_config.clientid = alloc_dhcp_option(DHCP_CLIENT_ID, "", 7);
 392                 client_config.clientid[OPT_DATA] = 1; /* type: ethernet */
 393                 memcpy(client_config.clientid + OPT_DATA+1, client_config.client_mac, 6);
 394         }
 395         if (str_V[0] != '\0')
 396                 client_config.vendorclass = alloc_dhcp_option(DHCP_VENDOR, str_V, 0);
 397 #if !BB_MMU
 398         /* on NOMMU reexec (i.e., background) early */
 399         if (!(opt & OPT_f)) {
 400                 bb_daemonize_or_rexec(0 /* flags */, argv);
 401                 logmode = LOGMODE_NONE;
 402         }
 403 #endif
 404         if (opt & OPT_S) {
 405                 openlog(applet_name, LOG_PID, LOG_DAEMON);
 406                 logmode |= LOGMODE_SYSLOG;
 407         }
 408
 409         /* Make sure fd 0,1,2 are open */
 410         bb_sanitize_stdio();
 411         /* Equivalent of doing a fflush after every \n */
 412         setlinebuf(stdout);
 413
 414         /* Create pidfile */
 415         write_pidfile(client_config.pidfile);
 416
 417         /* Goes to stdout (unless NOMMU) and possibly syslog */
 418         bb_info_msg("%s (v"BB_VER") started", applet_name);
 419
 420         /* Set up the signal pipe */
 421         udhcp_sp_setup();
 422
 423         state = INIT_SELECTING;
 424         udhcp_run_script(NULL, "deconfig");
 425         change_listen_mode(LISTEN_RAW);
 426         packet_num = 0;
 427         timeout = 0;
 428         already_waited_sec = 0;
 429
 430         /* Main event loop. select() waits on signal pipe and possibly
 431          * on sockfd.
 432          * "continue" statements in code below jump to the top of the loop.
 433          */
 434         for (;;) {
 435                 /* silence "uninitialized!" warning */
 436                 unsigned timestamp_before_wait = timestamp_before_wait;
 437
 438                 //bb_error_msg("sockfd:%d, listen_mode:%d", sockfd, listen_mode);
 439
 440                 /* Was opening raw or udp socket here
 441                  * if (listen_mode != LISTEN_NONE && sockfd < 0),
 442                  * but on fast network renew responses return faster
 443                  * than we open sockets. Thus this code is moved
 444                  * to change_listen_mode(). Thus we open listen socket
 445                  * BEFORE we send renew request (see "case BOUND:"). */
 446
 447                 max_fd = udhcp_sp_fd_set(&rfds, sockfd);
 448
 449                 tv.tv_sec = timeout - already_waited_sec;
 450                 tv.tv_usec = 0;
 451                 retval = 0; /* If we already timed out, fall through, else... */
 452                 if ((int)tv.tv_sec > 0) {
 453                         timestamp_before_wait = (unsigned)monotonic_sec();
 454                         log1("Waiting on select...");
 455                         retval = select(max_fd + 1, &rfds, NULL, NULL, &tv);
 456                         if (retval < 0) {
 457                                 /* EINTR? A signal was caught, don't panic */
 458                                 if (errno == EINTR) {
 459                                         already_waited_sec += (unsigned)monotonic_sec() - timestamp_before_wait;
 460                                         continue;
 461                                 }
 462                                 /* Else: an error occured, panic! */
 463                                 bb_perror_msg_and_die("select");
 464                         }
 465                 }
 466
 467                 /* If timeout dropped to zero, time to become active:
 468                  * resend discover/renew/whatever
 469                  */
 470                 if (retval == 0) {
 471                         /* We will restart the wait in any case */
 472                         already_waited_sec = 0;
 473
 474                         switch (state) {
 475                         case INIT_SELECTING:
 476                                 if (packet_num < discover_retries) {
 477                                         if (packet_num == 0)
 478                                                 xid = random_xid();
 479                                         /* broadcast */
 480                                         send_discover(xid, requested_ip);
 481                                         timeout = discover_timeout;
 482                                         packet_num++;
 483                                         continue;
 484                                 }
 485  leasefail:
 486                                 udhcp_run_script(NULL, "leasefail");
 487 #if BB_MMU /* -b is not supported on NOMMU */
 488                                 if (opt & OPT_b) { /* background if no lease */
 489                                         bb_info_msg("No lease, forking to background");
 490                                         client_background();
 491                                         /* do not background again! */
 492                                         opt = ((opt & ~OPT_b) | OPT_f);
 493                                 } else
 494 #endif
 495                                 if (opt & OPT_n) { /* abort if no lease */
 496                                         bb_info_msg("No lease, failing");
 497                                         retval = 1;
 498                                         goto ret;
 499                                 }
 500                                 /* wait before trying again */
 501                                 timeout = tryagain_timeout;
 502                                 packet_num = 0;
 503                                 continue;
 504                         case REQUESTING:
 505                                 if (packet_num < discover_retries) {
 506                                         /* send broadcast select packet */
 507                                         send_select(xid, server_addr, requested_ip);
 508                                         timeout = discover_timeout;
 509                                         packet_num++;
 510                                         continue;
 511                                 }
 512                                 /* Timed out, go back to init state.
 513                                  * "discover...select...discover..." loops
 514                                  * were seen in the wild. Treat them similarly
 515                                  * to "no response to discover" case */
 516                                 change_listen_mode(LISTEN_RAW);
 517                                 state = INIT_SELECTING;
 518                                 goto leasefail;
 519                         case BOUND:
 520                                 /* 1/2 lease passed, enter renewing state */
 521                                 state = RENEWING;
 522                                 change_listen_mode(LISTEN_KERNEL);
 523                                 log1("Entering renew state");
 524                                 /* fall right through */
 525                         case RENEW_REQUESTED: /* manual (SIGUSR1) renew */
 526                         case_RENEW_REQUESTED:
 527                         case RENEWING:
 528                                 if (timeout > 60) {
 529                                         /* send an unicast renew request */
 530                         /* Sometimes observed to fail (EADDRNOTAVAIL) to bind
 531                          * a new UDP socket for sending inside send_renew.
 532                          * I hazard to guess existing listening socket
 533                          * is somehow conflicting with it, but why is it
 534                          * not deterministic then?! Strange.
 535                          * Anyway, it does recover by eventually failing through
 536                          * into INIT_SELECTING state.
 537                          */
 538                                         send_renew(xid, server_addr, requested_ip);
 539                                         timeout >>= 1;
 540                                         continue;
 541                                 }
 542                                 /* Timed out, enter rebinding state */
 543                                 log1("Entering rebinding state");
 544                                 state = REBINDING;
 545                                 /* fall right through */
 546                         case REBINDING:
 547                                 /* Switch to bcast receive */
 548                                 change_listen_mode(LISTEN_RAW);
 549                                 /* Lease is *really* about to run out,
 550                                  * try to find DHCP server using broadcast */
 551                                 if (timeout > 0) {
 552                                         /* send a broadcast renew request */
 553                                         send_renew(xid, 0 /*INADDR_ANY*/, requested_ip);
 554                                         timeout >>= 1;
 555                                         continue;
 556                                 }
 557                                 /* Timed out, enter init state */
 558                                 bb_info_msg("Lease lost, entering init state");
 559                                 udhcp_run_script(NULL, "deconfig");
 560                                 state = INIT_SELECTING;
 561                                 /*timeout = 0; - already is */
 562                                 packet_num = 0;
 563                                 continue;
 564                         /* case RELEASED: */
 565                         }
 566                         /* yah, I know, *you* say it would never happen */
 567                         timeout = INT_MAX;
 568                         continue; /* back to main loop */
 569                 } /* if select timed out */
 570
 571                 /* select() didn't timeout, something happened */
 572
 573                 /* Is it a signal? */
 574                 /* note: udhcp_sp_read checks FD_ISSET before reading */
 575                 switch (udhcp_sp_read(&rfds)) {
 576                 case SIGUSR1:
 577                         perform_renew();
 578                         if (state == RENEW_REQUESTED)
 579                                 goto case_RENEW_REQUESTED;
 580                         /* Start things over */
 581                         packet_num = 0;
 582                         /* Kill any timeouts, user wants this to hurry along */
 583                         timeout = 0;
 584                         continue;
 585                 case SIGUSR2:
 586                         perform_release(requested_ip, server_addr);
 587                         timeout = INT_MAX;
 588                         continue;
 589                 case SIGTERM:
 590                         bb_info_msg("Received SIGTERM");
 591                         if (opt & OPT_R) /* release on quit */
 592                                 perform_release(requested_ip, server_addr);
 593                         goto ret0;
 594                 }
 595
 596                 /* Is it a packet? */
 597                 if (listen_mode == LISTEN_NONE || !FD_ISSET(sockfd, &rfds))
 598                         continue; /* no */
 599
 600                 {
 601                         int len;
 602
 603                         /* A packet is ready, read it */
 604                         if (listen_mode == LISTEN_KERNEL)
 605                                 len = udhcp_recv_kernel_packet(&packet, sockfd);
 606                         else
 607                                 len = udhcp_recv_raw_packet(&packet, sockfd);
 608                         if (len == -1) {
 609                                 /* Error is severe, reopen socket */
 610                                 bb_info_msg("Read error: %s, reopening socket", strerror(errno));
 611                                 sleep(discover_timeout); /* 3 seconds by default */
 612                                 change_listen_mode(listen_mode); /* just close and reopen */
 613                         }
 614                         /* If this packet will turn out to be unrelated/bogus,
 615                          * we will go back and wait for next one.
 616                          * Be sure timeout is properly decreased. */
 617                         already_waited_sec += (unsigned)monotonic_sec() - timestamp_before_wait;
 618                         if (len < 0)
 619                                 continue;
 620                 }
 621
 622                 if (packet.xid != xid) {
 623                         log1("xid %x (our is %x), ignoring packet",
 624                                 (unsigned)packet.xid, (unsigned)xid);
 625                         continue;
 626                 }
 627
 628                 /* Ignore packets that aren't for us */
 629                 if (packet.hlen != 6
 630                  || memcmp(packet.chaddr, client_config.client_mac, 6)
 631                 ) {
 632 //FIXME: need to also check that last 10 bytes are zero
 633                         log1("chaddr does not match, ignoring packet"); // log2?
 634                         continue;
 635                 }
 636
 637                 message = get_option(&packet, DHCP_MESSAGE_TYPE);
 638                 if (message == NULL) {
 639                         bb_error_msg("no message type option, ignoring packet");
 640                         continue;
 641                 }
 642
 643                 switch (state) {
 644                 case INIT_SELECTING:
 645                         /* Must be a DHCPOFFER to one of our xid's */
 646                         if (*message == DHCPOFFER) {
 647                 /* TODO: why we don't just fetch server's IP from IP header? */
 648                                 temp = get_option(&packet, DHCP_SERVER_ID);
 649                                 if (!temp) {
 650                                         bb_error_msg("no server ID in message");
 651                                         continue;
 652                                         /* still selecting - this server looks bad */
 653                                 }
 654                                 /* it IS unaligned sometimes, don't "optimize" */
 655                                 move_from_unaligned32(server_addr, temp);
 656                                 xid = packet.xid;
 657                                 requested_ip = packet.yiaddr;
 658
 659                                 /* enter requesting state */
 660                                 state = REQUESTING;
 661                                 timeout = 0;
 662                                 packet_num = 0;
 663                                 already_waited_sec = 0;
 664                         }
 665                         continue;
 666                 case REQUESTING:
 667                 case RENEWING:
 668                 case RENEW_REQUESTED:
 669                 case REBINDING:
 670                         if (*message == DHCPACK) {
 671                                 temp = get_option(&packet, DHCP_LEASE_TIME);
 672                                 if (!temp) {
 673                                         bb_error_msg("no lease time with ACK, using 1 hour lease");
 674                                         lease_seconds = 60 * 60;
 675                                 } else {
 676                                         /* it IS unaligned sometimes, don't "optimize" */
 677                                         move_from_unaligned32(lease_seconds, temp);
 678                                         lease_seconds = ntohl(lease_seconds);
 679                                         lease_seconds &= 0x0fffffff; /* paranoia: must not be prone to overflows */
 680                                         if (lease_seconds < 10) /* and not too small */
 681                                                 lease_seconds = 10;
 682                                 }
 683 #if ENABLE_FEATURE_UDHCPC_ARPING
 684                                 if (opt & OPT_a) {
 685 /* RFC 2131 3.1 paragraph 5:
 686  * "The client receives the DHCPACK message with configuration
 687  * parameters. The client SHOULD perform a final check on the
 688  * parameters (e.g., ARP for allocated network address), and notes
 689  * the duration of the lease specified in the DHCPACK message. At this
 690  * point, the client is configured. If the client detects that the
 691  * address is already in use (e.g., through the use of ARP),
 692  * the client MUST send a DHCPDECLINE message to the server and restarts
 693  * the configuration process..." */
 694                                         if (!arpping(packet.yiaddr,
 695                                                         NULL,
 696                                                         (uint32_t) 0,
 697                                                         client_config.client_mac,
 698                                                         client_config.interface)
 699                                         ) {
 700                                                 bb_info_msg("Offered address is in use "
 701                                                         "(got ARP reply), declining");
 702                                                 send_decline(xid, server_addr, packet.yiaddr);
 703
 704                                                 if (state != REQUESTING)
 705                                                         udhcp_run_script(NULL, "deconfig");
 706                                                 change_listen_mode(LISTEN_RAW);
 707                                                 state = INIT_SELECTING;
 708                                                 requested_ip = 0;
 709                                                 timeout = tryagain_timeout;
 710                                                 packet_num = 0;
 711                                                 already_waited_sec = 0;
 712                                                 continue; /* back to main loop */
 713                                         }
 714                                 }
 715 #endif
 716                                 /* enter bound state */
 717                                 timeout = lease_seconds / 2;
 718                                 {
 719                                         struct in_addr temp_addr;
 720                                         temp_addr.s_addr = packet.yiaddr;
 721                                         bb_info_msg("Lease of %s obtained, lease time %u",
 722                                                 inet_ntoa(temp_addr), (unsigned)lease_seconds);
 723                                 }
 724                                 requested_ip = packet.yiaddr;
 725                                 udhcp_run_script(&packet, state == REQUESTING ? "bound" : "renew");
 726
 727                                 state = BOUND;
 728                                 change_listen_mode(LISTEN_NONE);
 729                                 if (opt & OPT_q) { /* quit after lease */
 730                                         if (opt & OPT_R) /* release on quit */
 731                                                 perform_release(requested_ip, server_addr);
 732                                         goto ret0;
 733                                 }
 734                                 /* future renew failures should not exit (JM) */
 735                                 opt &= ~OPT_n;
 736 #if BB_MMU /* NOMMU case backgrounded earlier */
 737                                 if (!(opt & OPT_f)) {
 738                                         client_background();
 739                                         /* do not background again! */
 740                                         opt = ((opt & ~OPT_b) | OPT_f);
 741                                 }
 742 #endif
 743                                 already_waited_sec = 0;
 744                                 continue; /* back to main loop */
 745                         }
 746                         if (*message == DHCPNAK) {
 747                                 /* return to init state */
 748                                 bb_info_msg("Received DHCP NAK");
 749                                 udhcp_run_script(&packet, "nak");
 750                                 if (state != REQUESTING)
 751                                         udhcp_run_script(NULL, "deconfig");
 752                                 change_listen_mode(LISTEN_RAW);
 753                                 sleep(3); /* avoid excessive network traffic */
 754                                 state = INIT_SELECTING;
 755                                 requested_ip = 0;
 756                                 timeout = 0;
 757                                 packet_num = 0;
 758                                 already_waited_sec = 0;
 759                         }
 760                         continue;
 761                 /* case BOUND: - ignore all packets */
 762                 /* case RELEASED: - ignore all packets */
 763                 }
 764                 /* back to main loop */
 765         } /* for (;;) - main loop ends */
 766
 767  ret0:
 768         retval = 0;
 769  ret:
 770         /*if (client_config.pidfile) - remove_pidfile has its own check */
 771                 remove_pidfile(client_config.pidfile);
 772         return retval;
 773 }