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