networking/udhcp/dhcpc.c

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