networking/udhcp/dhcpd.c

   1 /* vi: set sw=4 ts=4: */
   2 /*
   3  * udhcp server
   4  * Copyright (C) 1999 Matthew Ramsay <matthewr@moreton.com.au>
   5  *                      Chris Trew <ctrew@moreton.com.au>
   6  *
   7  * Rewrite by Russ Dill <Russ.Dill@asu.edu> July 2001
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 //usage:#define udhcpd_trivial_usage
  25 //usage:       "[-fS] [-I ADDR]" IF_FEATURE_UDHCP_PORT(" [-P N]") " [CONFFILE]"
  26 //usage:#define udhcpd_full_usage "\n\n"
  27 //usage:       "DHCP server\n"
  28 //usage:     "\n        -f      Run in foreground"
  29 //usage:     "\n        -S      Log to syslog too"
  30 //usage:     "\n        -I ADDR Local address"
  31 //usage:     "\n        -a MSEC Timeout for ARP ping (default 2000)"
  32 //usage:        IF_FEATURE_UDHCP_PORT(
  33 //usage:     "\n        -P N    Use port N (default 67)"
  34 //usage:        )
  35
  36 #include <syslog.h>
  37 #include "common.h"
  38 #include "dhcpc.h"
  39 #include "dhcpd.h"
  40
  41
  42 /* Send a packet to a specific mac address and ip address by creating our own ip packet */
  43 static void send_packet_to_client(struct dhcp_packet *dhcp_pkt, int force_broadcast)
  44 {
  45         const uint8_t *chaddr;
  46         uint32_t ciaddr;
  47
  48         // Was:
  49         //if (force_broadcast) { /* broadcast */ }
  50         //else if (dhcp_pkt->ciaddr) { /* unicast to dhcp_pkt->ciaddr */ }
  51         //else if (dhcp_pkt->flags & htons(BROADCAST_FLAG)) { /* broadcast */ }
  52         //else { /* unicast to dhcp_pkt->yiaddr */ }
  53         // But this is wrong: yiaddr is _our_ idea what client's IP is
  54         // (for example, from lease file). Client may not know that,
  55         // and may not have UDP socket listening on that IP!
  56         // We should never unicast to dhcp_pkt->yiaddr!
  57         // dhcp_pkt->ciaddr, OTOH, comes from client's request packet,
  58         // and can be used.
  59
  60         if (force_broadcast
  61          || (dhcp_pkt->flags & htons(BROADCAST_FLAG))
  62          || dhcp_pkt->ciaddr == 0
  63         ) {
  64                 log1("Broadcasting packet to client");
  65                 ciaddr = INADDR_BROADCAST;
  66                 chaddr = MAC_BCAST_ADDR;
  67         } else {
  68                 log1("Unicasting packet to client ciaddr");
  69                 ciaddr = dhcp_pkt->ciaddr;
  70                 chaddr = dhcp_pkt->chaddr;
  71         }
  72
  73         udhcp_send_raw_packet(dhcp_pkt,
  74                 /*src*/ server_config.server_nip, SERVER_PORT,
  75                 /*dst*/ ciaddr, CLIENT_PORT, chaddr,
  76                 server_config.ifindex);
  77 }
  78
  79 /* Send a packet to gateway_nip using the kernel ip stack */
  80 static void send_packet_to_relay(struct dhcp_packet *dhcp_pkt)
  81 {
  82         log1("Forwarding packet to relay");
  83
  84         udhcp_send_kernel_packet(dhcp_pkt,
  85                         server_config.server_nip, SERVER_PORT,
  86                         dhcp_pkt->gateway_nip, SERVER_PORT);
  87 }
  88
  89 static void send_packet(struct dhcp_packet *dhcp_pkt, int force_broadcast)
  90 {
  91         if (dhcp_pkt->gateway_nip)
  92                 send_packet_to_relay(dhcp_pkt);
  93         else
  94                 send_packet_to_client(dhcp_pkt, force_broadcast);
  95 }
  96
  97 static void init_packet(struct dhcp_packet *packet, struct dhcp_packet *oldpacket, char type)
  98 {
  99         /* Sets op, htype, hlen, cookie fields
 100          * and adds DHCP_MESSAGE_TYPE option */
 101         udhcp_init_header(packet, type);
 102
 103         packet->xid = oldpacket->xid;
 104         memcpy(packet->chaddr, oldpacket->chaddr, sizeof(oldpacket->chaddr));
 105         packet->flags = oldpacket->flags;
 106         packet->gateway_nip = oldpacket->gateway_nip;
 107         packet->ciaddr = oldpacket->ciaddr;
 108         udhcp_add_simple_option(packet, DHCP_SERVER_ID, server_config.server_nip);
 109 }
 110
 111 /* Fill options field, siaddr_nip, and sname and boot_file fields.
 112  * TODO: teach this code to use overload option.
 113  */
 114 static void add_server_options(struct dhcp_packet *packet)
 115 {
 116         struct option_set *curr = server_config.options;
 117
 118         while (curr) {
 119                 if (curr->data[OPT_CODE] != DHCP_LEASE_TIME)
 120                         udhcp_add_binary_option(packet, curr->data);
 121                 curr = curr->next;
 122         }
 123
 124         packet->siaddr_nip = server_config.siaddr_nip;
 125
 126         if (server_config.sname)
 127                 strncpy((char*)packet->sname, server_config.sname, sizeof(packet->sname) - 1);
 128         if (server_config.boot_file)
 129                 strncpy((char*)packet->file, server_config.boot_file, sizeof(packet->file) - 1);
 130 }
 131
 132 static uint32_t select_lease_time(struct dhcp_packet *packet)
 133 {
 134         uint32_t lease_time_sec = server_config.max_lease_sec;
 135         uint8_t *lease_time_opt = udhcp_get_option(packet, DHCP_LEASE_TIME);
 136         if (lease_time_opt) {
 137                 move_from_unaligned32(lease_time_sec, lease_time_opt);
 138                 lease_time_sec = ntohl(lease_time_sec);
 139                 if (lease_time_sec > server_config.max_lease_sec)
 140                         lease_time_sec = server_config.max_lease_sec;
 141                 if (lease_time_sec < server_config.min_lease_sec)
 142                         lease_time_sec = server_config.min_lease_sec;
 143         }
 144         return lease_time_sec;
 145 }
 146
 147 /* We got a DHCP DISCOVER. Send an OFFER. */
 148 /* NOINLINE: limit stack usage in caller */
 149 static NOINLINE void send_offer(struct dhcp_packet *oldpacket,
 150                 uint32_t static_lease_nip,
 151                 struct dyn_lease *lease,
 152                 uint8_t *requested_ip_opt,
 153                 unsigned arpping_ms)
 154 {
 155         struct dhcp_packet packet;
 156         uint32_t lease_time_sec;
 157         struct in_addr addr;
 158
 159         init_packet(&packet, oldpacket, DHCPOFFER);
 160
 161         /* If it is a static lease, use its IP */
 162         packet.yiaddr = static_lease_nip;
 163         /* Else: */
 164         if (!static_lease_nip) {
 165                 /* We have no static lease for client's chaddr */
 166                 uint32_t req_nip;
 167                 const char *p_host_name;
 168
 169                 if (lease) {
 170                         /* We have a dynamic lease for client's chaddr.
 171                          * Reuse its IP (even if lease is expired).
 172                          * Note that we ignore requested IP in this case.
 173                          */
 174                         packet.yiaddr = lease->lease_nip;
 175                 }
 176                 /* Or: if client has requested an IP */
 177                 else if (requested_ip_opt != NULL
 178                  /* (read IP) */
 179                  && (move_from_unaligned32(req_nip, requested_ip_opt), 1)
 180                  /* and the IP is in the lease range */
 181                  && ntohl(req_nip) >= server_config.start_ip
 182                  && ntohl(req_nip) <= server_config.end_ip
 183                  /* and */
 184                  && (  !(lease = find_lease_by_nip(req_nip)) /* is not already taken */
 185                     || is_expired_lease(lease) /* or is taken, but expired */
 186                     )
 187                 ) {
 188                         packet.yiaddr = req_nip;
 189                 }
 190                 else {
 191                         /* Otherwise, find a free IP */
 192                         packet.yiaddr = find_free_or_expired_nip(oldpacket->chaddr, arpping_ms);
 193                 }
 194
 195                 if (!packet.yiaddr) {
 196                         bb_error_msg("no free IP addresses. OFFER abandoned");
 197                         return;
 198                 }
 199                 /* Reserve the IP for a short time hoping to get DHCPREQUEST soon */
 200                 p_host_name = (const char*) udhcp_get_option(oldpacket, DHCP_HOST_NAME);
 201                 lease = add_lease(packet.chaddr, packet.yiaddr,
 202                                 server_config.offer_time,
 203                                 p_host_name,
 204                                 p_host_name ? (unsigned char)p_host_name[OPT_LEN - OPT_DATA] : 0
 205                 );
 206                 if (!lease) {
 207                         bb_error_msg("no free IP addresses. OFFER abandoned");
 208                         return;
 209                 }
 210         }
 211
 212         lease_time_sec = select_lease_time(oldpacket);
 213         udhcp_add_simple_option(&packet, DHCP_LEASE_TIME, htonl(lease_time_sec));
 214         add_server_options(&packet);
 215
 216         addr.s_addr = packet.yiaddr;
 217         bb_info_msg("Sending OFFER of %s", inet_ntoa(addr));
 218         /* send_packet emits error message itself if it detects failure */
 219         send_packet(&packet, /*force_bcast:*/ 0);
 220 }
 221
 222 /* NOINLINE: limit stack usage in caller */
 223 static NOINLINE void send_NAK(struct dhcp_packet *oldpacket)
 224 {
 225         struct dhcp_packet packet;
 226
 227         init_packet(&packet, oldpacket, DHCPNAK);
 228
 229         log1("Sending NAK");
 230         send_packet(&packet, /*force_bcast:*/ 1);
 231 }
 232
 233 /* NOINLINE: limit stack usage in caller */
 234 static NOINLINE void send_ACK(struct dhcp_packet *oldpacket, uint32_t yiaddr)
 235 {
 236         struct dhcp_packet packet;
 237         uint32_t lease_time_sec;
 238         struct in_addr addr;
 239         const char *p_host_name;
 240
 241         init_packet(&packet, oldpacket, DHCPACK);
 242         packet.yiaddr = yiaddr;
 243
 244         lease_time_sec = select_lease_time(oldpacket);
 245         udhcp_add_simple_option(&packet, DHCP_LEASE_TIME, htonl(lease_time_sec));
 246
 247         add_server_options(&packet);
 248
 249         addr.s_addr = yiaddr;
 250         bb_info_msg("Sending ACK to %s", inet_ntoa(addr));
 251         send_packet(&packet, /*force_bcast:*/ 0);
 252
 253         p_host_name = (const char*) udhcp_get_option(oldpacket, DHCP_HOST_NAME);
 254         add_lease(packet.chaddr, packet.yiaddr,
 255                 lease_time_sec,
 256                 p_host_name,
 257                 p_host_name ? (unsigned char)p_host_name[OPT_LEN - OPT_DATA] : 0
 258         );
 259         if (ENABLE_FEATURE_UDHCPD_WRITE_LEASES_EARLY) {
 260                 /* rewrite the file with leases at every new acceptance */
 261                 write_leases();
 262         }
 263 }
 264
 265 /* NOINLINE: limit stack usage in caller */
 266 static NOINLINE void send_inform(struct dhcp_packet *oldpacket)
 267 {
 268         struct dhcp_packet packet;
 269
 270         /* "If a client has obtained a network address through some other means
 271          * (e.g., manual configuration), it may use a DHCPINFORM request message
 272          * to obtain other local configuration parameters.  Servers receiving a
 273          * DHCPINFORM message construct a DHCPACK message with any local
 274          * configuration parameters appropriate for the client without:
 275          * allocating a new address, checking for an existing binding, filling
 276          * in 'yiaddr' or including lease time parameters.  The servers SHOULD
 277          * unicast the DHCPACK reply to the address given in the 'ciaddr' field
 278          * of the DHCPINFORM message.
 279          * ...
 280          * The server responds to a DHCPINFORM message by sending a DHCPACK
 281          * message directly to the address given in the 'ciaddr' field
 282          * of the DHCPINFORM message.  The server MUST NOT send a lease
 283          * expiration time to the client and SHOULD NOT fill in 'yiaddr'."
 284          */
 285 //TODO: do a few sanity checks: is ciaddr set?
 286 //Better yet: is ciaddr == IP source addr?
 287         init_packet(&packet, oldpacket, DHCPACK);
 288         add_server_options(&packet);
 289
 290         send_packet(&packet, /*force_bcast:*/ 0);
 291 }
 292
 293
 294 /* globals */
 295 struct dyn_lease *g_leases;
 296 /* struct server_config_t server_config is in bb_common_bufsiz1 */
 297
 298
 299 int udhcpd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 300 int udhcpd_main(int argc UNUSED_PARAM, char **argv)
 301 {
 302         int server_socket = -1, retval, max_sock;
 303         uint8_t *state;
 304         unsigned timeout_end;
 305         unsigned num_ips;
 306         unsigned opt;
 307         struct option_set *option;
 308         char *str_I = str_I;
 309         const char *str_a = "2000";
 310         unsigned arpping_ms;
 311         IF_FEATURE_UDHCP_PORT(char *str_P;)
 312
 313 #if ENABLE_FEATURE_UDHCP_PORT
 314         SERVER_PORT = 67;
 315         CLIENT_PORT = 68;
 316 #endif
 317
 318 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
 319         opt_complementary = "vv";
 320 #endif
 321         opt = getopt32(argv, "fSI:va:"
 322                 IF_FEATURE_UDHCP_PORT("P:")
 323                 , &str_I
 324                 , &str_a
 325                 IF_FEATURE_UDHCP_PORT(, &str_P)
 326                 IF_UDHCP_VERBOSE(, &dhcp_verbose)
 327                 );
 328         if (!(opt & 1)) { /* no -f */
 329                 bb_daemonize_or_rexec(0, argv);
 330                 logmode = LOGMODE_NONE;
 331         }
 332         /* update argv after the possible vfork+exec in daemonize */
 333         argv += optind;
 334         if (opt & 2) { /* -S */
 335                 openlog(applet_name, LOG_PID, LOG_DAEMON);
 336                 logmode |= LOGMODE_SYSLOG;
 337         }
 338         if (opt & 4) { /* -I */
 339                 len_and_sockaddr *lsa = xhost_and_af2sockaddr(str_I, 0, AF_INET);
 340                 server_config.server_nip = lsa->u.sin.sin_addr.s_addr;
 341                 free(lsa);
 342         }
 343 #if ENABLE_FEATURE_UDHCP_PORT
 344         if (opt & 32) { /* -P */
 345                 SERVER_PORT = xatou16(str_P);
 346                 CLIENT_PORT = SERVER_PORT + 1;
 347         }
 348 #endif
 349         arpping_ms = xatou(str_a);
 350
 351         /* Would rather not do read_config before daemonization -
 352          * otherwise NOMMU machines will parse config twice */
 353         read_config(argv[0] ? argv[0] : DHCPD_CONF_FILE);
 354
 355         /* Make sure fd 0,1,2 are open */
 356         bb_sanitize_stdio();
 357         /* Equivalent of doing a fflush after every \n */
 358         setlinebuf(stdout);
 359
 360         /* Create pidfile */
 361         write_pidfile(server_config.pidfile);
 362         /* if (!..) bb_perror_msg("can't create pidfile %s", pidfile); */
 363
 364         bb_info_msg("%s (v"BB_VER") started", applet_name);
 365
 366         option = udhcp_find_option(server_config.options, DHCP_LEASE_TIME);
 367         server_config.max_lease_sec = DEFAULT_LEASE_TIME;
 368         if (option) {
 369                 move_from_unaligned32(server_config.max_lease_sec, option->data + OPT_DATA);
 370                 server_config.max_lease_sec = ntohl(server_config.max_lease_sec);
 371         }
 372
 373         /* Sanity check */
 374         num_ips = server_config.end_ip - server_config.start_ip + 1;
 375         if (server_config.max_leases > num_ips) {
 376                 bb_error_msg("max_leases=%u is too big, setting to %u",
 377                         (unsigned)server_config.max_leases, num_ips);
 378                 server_config.max_leases = num_ips;
 379         }
 380
 381         g_leases = xzalloc(server_config.max_leases * sizeof(g_leases[0]));
 382         read_leases(server_config.lease_file);
 383
 384         if (udhcp_read_interface(server_config.interface,
 385                         &server_config.ifindex,
 386                         (server_config.server_nip == 0 ? &server_config.server_nip : NULL),
 387                         server_config.server_mac)
 388         ) {
 389                 retval = 1;
 390                 goto ret;
 391         }
 392
 393         /* Setup the signal pipe */
 394         udhcp_sp_setup();
 395
 396  continue_with_autotime:
 397         timeout_end = monotonic_sec() + server_config.auto_time;
 398         while (1) { /* loop until universe collapses */
 399                 fd_set rfds;
 400                 struct dhcp_packet packet;
 401                 int bytes;
 402                 struct timeval tv;
 403                 uint8_t *server_id_opt;
 404                 uint8_t *requested_ip_opt;
 405                 uint32_t requested_nip = requested_nip; /* for compiler */
 406                 uint32_t static_lease_nip;
 407                 struct dyn_lease *lease, fake_lease;
 408
 409                 if (server_socket < 0) {
 410                         server_socket = udhcp_listen_socket(/*INADDR_ANY,*/ SERVER_PORT,
 411                                         server_config.interface);
 412                 }
 413
 414                 max_sock = udhcp_sp_fd_set(&rfds, server_socket);
 415                 if (server_config.auto_time) {
 416                         tv.tv_sec = timeout_end - monotonic_sec();
 417                         tv.tv_usec = 0;
 418                 }
 419                 retval = 0;
 420                 if (!server_config.auto_time || tv.tv_sec > 0) {
 421                         retval = select(max_sock + 1, &rfds, NULL, NULL,
 422                                         server_config.auto_time ? &tv : NULL);
 423                 }
 424                 if (retval == 0) {
 425                         write_leases();
 426                         goto continue_with_autotime;
 427                 }
 428                 if (retval < 0 && errno != EINTR) {
 429                         log1("Error on select");
 430                         continue;
 431                 }
 432
 433                 switch (udhcp_sp_read(&rfds)) {
 434                 case SIGUSR1:
 435                         bb_info_msg("Received SIGUSR1");
 436                         write_leases();
 437                         /* why not just reset the timeout, eh */
 438                         goto continue_with_autotime;
 439                 case SIGTERM:
 440                         bb_info_msg("Received SIGTERM");
 441                         write_leases();
 442                         goto ret0;
 443                 case 0: /* no signal: read a packet */
 444                         break;
 445                 default: /* signal or error (probably EINTR): back to select */
 446                         continue;
 447                 }
 448
 449                 bytes = udhcp_recv_kernel_packet(&packet, server_socket);
 450                 if (bytes < 0) {
 451                         /* bytes can also be -2 ("bad packet data") */
 452                         if (bytes == -1 && errno != EINTR) {
 453                                 log1("Read error: %s, reopening socket", strerror(errno));
 454                                 close(server_socket);
 455                                 server_socket = -1;
 456                         }
 457                         continue;
 458                 }
 459                 if (packet.hlen != 6) {
 460                         bb_error_msg("MAC length != 6, ignoring packet");
 461                         continue;
 462                 }
 463                 if (packet.op != BOOTREQUEST) {
 464                         bb_error_msg("not a REQUEST, ignoring packet");
 465                         continue;
 466                 }
 467                 state = udhcp_get_option(&packet, DHCP_MESSAGE_TYPE);
 468                 if (state == NULL || state[0] < DHCP_MINTYPE || state[0] > DHCP_MAXTYPE) {
 469                         bb_error_msg("no or bad message type option, ignoring packet");
 470                         continue;
 471                 }
 472
 473                 /* Get SERVER_ID if present */
 474                 server_id_opt = udhcp_get_option(&packet, DHCP_SERVER_ID);
 475                 if (server_id_opt) {
 476                         uint32_t server_id_network_order;
 477                         move_from_unaligned32(server_id_network_order, server_id_opt);
 478                         if (server_id_network_order != server_config.server_nip) {
 479                                 /* client talks to somebody else */
 480                                 log1("server ID doesn't match, ignoring");
 481                                 continue;
 482                         }
 483                 }
 484
 485                 /* Look for a static/dynamic lease */
 486                 static_lease_nip = get_static_nip_by_mac(server_config.static_leases, &packet.chaddr);
 487                 if (static_lease_nip) {
 488                         bb_info_msg("Found static lease: %x", static_lease_nip);
 489                         memcpy(&fake_lease.lease_mac, &packet.chaddr, 6);
 490                         fake_lease.lease_nip = static_lease_nip;
 491                         fake_lease.expires = 0;
 492                         lease = &fake_lease;
 493                 } else {
 494                         lease = find_lease_by_mac(packet.chaddr);
 495                 }
 496
 497                 /* Get REQUESTED_IP if present */
 498                 requested_ip_opt = udhcp_get_option(&packet, DHCP_REQUESTED_IP);
 499                 if (requested_ip_opt) {
 500                         move_from_unaligned32(requested_nip, requested_ip_opt);
 501                 }
 502
 503                 switch (state[0]) {
 504
 505                 case DHCPDISCOVER:
 506                         log1("Received DISCOVER");
 507
 508                         send_offer(&packet, static_lease_nip, lease, requested_ip_opt, arpping_ms);
 509                         break;
 510
 511                 case DHCPREQUEST:
 512                         log1("Received REQUEST");
 513 /* RFC 2131:
 514
 515 o DHCPREQUEST generated during SELECTING state:
 516
 517    Client inserts the address of the selected server in 'server
 518    identifier', 'ciaddr' MUST be zero, 'requested IP address' MUST be
 519    filled in with the yiaddr value from the chosen DHCPOFFER.
 520
 521    Note that the client may choose to collect several DHCPOFFER
 522    messages and select the "best" offer.  The client indicates its
 523    selection by identifying the offering server in the DHCPREQUEST
 524    message.  If the client receives no acceptable offers, the client
 525    may choose to try another DHCPDISCOVER message.  Therefore, the
 526    servers may not receive a specific DHCPREQUEST from which they can
 527    decide whether or not the client has accepted the offer.
 528
 529 o DHCPREQUEST generated during INIT-REBOOT state:
 530
 531    'server identifier' MUST NOT be filled in, 'requested IP address'
 532    option MUST be filled in with client's notion of its previously
 533    assigned address. 'ciaddr' MUST be zero. The client is seeking to
 534    verify a previously allocated, cached configuration. Server SHOULD
 535    send a DHCPNAK message to the client if the 'requested IP address'
 536    is incorrect, or is on the wrong network.
 537
 538    Determining whether a client in the INIT-REBOOT state is on the
 539    correct network is done by examining the contents of 'giaddr', the
 540    'requested IP address' option, and a database lookup. If the DHCP
 541    server detects that the client is on the wrong net (i.e., the
 542    result of applying the local subnet mask or remote subnet mask (if
 543    'giaddr' is not zero) to 'requested IP address' option value
 544    doesn't match reality), then the server SHOULD send a DHCPNAK
 545    message to the client.
 546
 547    If the network is correct, then the DHCP server should check if
 548    the client's notion of its IP address is correct. If not, then the
 549    server SHOULD send a DHCPNAK message to the client. If the DHCP
 550    server has no record of this client, then it MUST remain silent,
 551    and MAY output a warning to the network administrator. This
 552    behavior is necessary for peaceful coexistence of non-
 553    communicating DHCP servers on the same wire.
 554
 555    If 'giaddr' is 0x0 in the DHCPREQUEST message, the client is on
 556    the same subnet as the server.  The server MUST broadcast the
 557    DHCPNAK message to the 0xffffffff broadcast address because the
 558    client may not have a correct network address or subnet mask, and
 559    the client may not be answering ARP requests.
 560
 561    If 'giaddr' is set in the DHCPREQUEST message, the client is on a
 562    different subnet.  The server MUST set the broadcast bit in the
 563    DHCPNAK, so that the relay agent will broadcast the DHCPNAK to the
 564    client, because the client may not have a correct network address
 565    or subnet mask, and the client may not be answering ARP requests.
 566
 567 o DHCPREQUEST generated during RENEWING state:
 568
 569    'server identifier' MUST NOT be filled in, 'requested IP address'
 570    option MUST NOT be filled in, 'ciaddr' MUST be filled in with
 571    client's IP address. In this situation, the client is completely
 572    configured, and is trying to extend its lease. This message will
 573    be unicast, so no relay agents will be involved in its
 574    transmission.  Because 'giaddr' is therefore not filled in, the
 575    DHCP server will trust the value in 'ciaddr', and use it when
 576    replying to the client.
 577
 578    A client MAY choose to renew or extend its lease prior to T1.  The
 579    server may choose not to extend the lease (as a policy decision by
 580    the network administrator), but should return a DHCPACK message
 581    regardless.
 582
 583 o DHCPREQUEST generated during REBINDING state:
 584
 585    'server identifier' MUST NOT be filled in, 'requested IP address'
 586    option MUST NOT be filled in, 'ciaddr' MUST be filled in with
 587    client's IP address. In this situation, the client is completely
 588    configured, and is trying to extend its lease. This message MUST
 589    be broadcast to the 0xffffffff IP broadcast address.  The DHCP
 590    server SHOULD check 'ciaddr' for correctness before replying to
 591    the DHCPREQUEST.
 592
 593    The DHCPREQUEST from a REBINDING client is intended to accommodate
 594    sites that have multiple DHCP servers and a mechanism for
 595    maintaining consistency among leases managed by multiple servers.
 596    A DHCP server MAY extend a client's lease only if it has local
 597    administrative authority to do so.
 598 */
 599                         if (!requested_ip_opt) {
 600                                 requested_nip = packet.ciaddr;
 601                                 if (requested_nip == 0) {
 602                                         log1("no requested IP and no ciaddr, ignoring");
 603                                         break;
 604                                 }
 605                         }
 606                         if (lease && requested_nip == lease->lease_nip) {
 607                                 /* client requested or configured IP matches the lease.
 608                                  * ACK it, and bump lease expiration time. */
 609                                 send_ACK(&packet, lease->lease_nip);
 610                                 break;
 611                         }
 612                         /* No lease for this MAC, or lease IP != requested IP */
 613
 614                         if (server_id_opt    /* client is in SELECTING state */
 615                          || requested_ip_opt /* client is in INIT-REBOOT state */
 616                         ) {
 617                                 /* "No, we don't have this IP for you" */
 618                                 send_NAK(&packet);
 619                         } /* else: client is in RENEWING or REBINDING, do not answer */
 620
 621                         break;
 622
 623                 case DHCPDECLINE:
 624                         /* RFC 2131:
 625                          * "If the server receives a DHCPDECLINE message,
 626                          * the client has discovered through some other means
 627                          * that the suggested network address is already
 628                          * in use. The server MUST mark the network address
 629                          * as not available and SHOULD notify the local
 630                          * sysadmin of a possible configuration problem."
 631                          *
 632                          * SERVER_ID must be present,
 633                          * REQUESTED_IP must be present,
 634                          * chaddr must be filled in,
 635                          * ciaddr must be 0 (we do not check this)
 636                          */
 637                         log1("Received DECLINE");
 638                         if (server_id_opt
 639                          && requested_ip_opt
 640                          && lease  /* chaddr matches this lease */
 641                          && requested_nip == lease->lease_nip
 642                         ) {
 643                                 memset(lease->lease_mac, 0, sizeof(lease->lease_mac));
 644                                 lease->expires = time(NULL) + server_config.decline_time;
 645                         }
 646                         break;
 647
 648                 case DHCPRELEASE:
 649                         /* "Upon receipt of a DHCPRELEASE message, the server
 650                          * marks the network address as not allocated."
 651                          *
 652                          * SERVER_ID must be present,
 653                          * REQUESTED_IP must not be present (we do not check this),
 654                          * chaddr must be filled in,
 655                          * ciaddr must be filled in
 656                          */
 657                         log1("Received RELEASE");
 658                         if (server_id_opt
 659                          && lease  /* chaddr matches this lease */
 660                          && packet.ciaddr == lease->lease_nip
 661                         ) {
 662                                 lease->expires = time(NULL);
 663                         }
 664                         break;
 665
 666                 case DHCPINFORM:
 667                         log1("Received INFORM");
 668                         send_inform(&packet);
 669                         break;
 670                 }
 671         }
 672  ret0:
 673         retval = 0;
 674  ret:
 675         /*if (server_config.pidfile) - server_config.pidfile is never NULL */
 676                 remove_pidfile(server_config.pidfile);
 677         return retval;
 678 }