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