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         /* "The server responds to a DHCPINFORM message by sending a DHCPACK
 251          * message directly to the address given in the 'ciaddr' field
 252          * of the DHCPINFORM message.  The server MUST NOT send a lease
 253          * expiration time to the client and SHOULD NOT fill in 'yiaddr'."
 254          */
 255         init_packet(&packet, oldpacket, DHCPACK);
 256         add_server_options(&packet);
 257
 258         send_packet(&packet, /*force_bcast:*/ 0);
 259 }
 260
 261
 262 /* globals */
 263 struct dyn_lease *g_leases;
 264 /* struct server_config_t server_config is in bb_common_bufsiz1 */
 265
 266
 267 int udhcpd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 268 int udhcpd_main(int argc UNUSED_PARAM, char **argv)
 269 {
 270         fd_set rfds;
 271         int server_socket = -1, retval, max_sock;
 272         struct dhcp_packet packet;
 273         uint8_t *state;
 274         uint32_t static_lease_nip;
 275         unsigned timeout_end;
 276         unsigned num_ips;
 277         unsigned opt;
 278         struct option_set *option;
 279         struct dyn_lease *lease, fake_lease;
 280         IF_FEATURE_UDHCP_PORT(char *str_P;)
 281
 282 #if ENABLE_FEATURE_UDHCP_PORT
 283         SERVER_PORT = 67;
 284         CLIENT_PORT = 68;
 285 #endif
 286
 287 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
 288         opt_complementary = "vv";
 289 #endif
 290         opt = getopt32(argv, "fSv"
 291                 IF_FEATURE_UDHCP_PORT("P:", &str_P)
 292 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
 293                 , &dhcp_verbose
 294 #endif
 295                 );
 296         argv += optind;
 297         if (!(opt & 1)) { /* no -f */
 298                 bb_daemonize_or_rexec(0, argv);
 299                 logmode = LOGMODE_NONE;
 300         }
 301         if (opt & 2) { /* -S */
 302                 openlog(applet_name, LOG_PID, LOG_DAEMON);
 303                 logmode |= LOGMODE_SYSLOG;
 304         }
 305 #if ENABLE_FEATURE_UDHCP_PORT
 306         if (opt & 8) { /* -P */
 307                 SERVER_PORT = xatou16(str_P);
 308                 CLIENT_PORT = SERVER_PORT + 1;
 309         }
 310 #endif
 311         /* Would rather not do read_config before daemonization -
 312          * otherwise NOMMU machines will parse config twice */
 313         read_config(argv[0] ? argv[0] : DHCPD_CONF_FILE);
 314
 315         /* Make sure fd 0,1,2 are open */
 316         bb_sanitize_stdio();
 317         /* Equivalent of doing a fflush after every \n */
 318         setlinebuf(stdout);
 319
 320         /* Create pidfile */
 321         write_pidfile(server_config.pidfile);
 322         /* if (!..) bb_perror_msg("can't create pidfile %s", pidfile); */
 323
 324         bb_info_msg("%s (v"BB_VER") started", applet_name);
 325
 326         option = udhcp_find_option(server_config.options, DHCP_LEASE_TIME);
 327         server_config.max_lease_sec = DEFAULT_LEASE_TIME;
 328         if (option) {
 329                 move_from_unaligned32(server_config.max_lease_sec, option->data + OPT_DATA);
 330                 server_config.max_lease_sec = ntohl(server_config.max_lease_sec);
 331         }
 332
 333         /* Sanity check */
 334         num_ips = server_config.end_ip - server_config.start_ip + 1;
 335         if (server_config.max_leases > num_ips) {
 336                 bb_error_msg("max_leases=%u is too big, setting to %u",
 337                         (unsigned)server_config.max_leases, num_ips);
 338                 server_config.max_leases = num_ips;
 339         }
 340
 341         g_leases = xzalloc(server_config.max_leases * sizeof(g_leases[0]));
 342         read_leases(server_config.lease_file);
 343
 344         if (udhcp_read_interface(server_config.interface,
 345                         &server_config.ifindex,
 346                         &server_config.server_nip,
 347                         server_config.server_mac)
 348         ) {
 349                 retval = 1;
 350                 goto ret;
 351         }
 352
 353         /* Setup the signal pipe */
 354         udhcp_sp_setup();
 355
 356         timeout_end = monotonic_sec() + server_config.auto_time;
 357         while (1) { /* loop until universe collapses */
 358                 int bytes;
 359                 struct timeval tv;
 360                 uint8_t *server_id_opt;
 361                 uint8_t *requested_opt;
 362                 uint32_t requested_nip = requested_nip; /* for compiler */
 363
 364                 if (server_socket < 0) {
 365                         server_socket = udhcp_listen_socket(/*INADDR_ANY,*/ SERVER_PORT,
 366                                         server_config.interface);
 367                 }
 368
 369                 max_sock = udhcp_sp_fd_set(&rfds, server_socket);
 370                 if (server_config.auto_time) {
 371                         tv.tv_sec = timeout_end - monotonic_sec();
 372                         tv.tv_usec = 0;
 373                 }
 374                 retval = 0;
 375                 if (!server_config.auto_time || tv.tv_sec > 0) {
 376                         retval = select(max_sock + 1, &rfds, NULL, NULL,
 377                                         server_config.auto_time ? &tv : NULL);
 378                 }
 379                 if (retval == 0) {
 380                         write_leases();
 381                         timeout_end = monotonic_sec() + server_config.auto_time;
 382                         continue;
 383                 }
 384                 if (retval < 0 && errno != EINTR) {
 385                         log1("Error on select");
 386                         continue;
 387                 }
 388
 389                 switch (udhcp_sp_read(&rfds)) {
 390                 case SIGUSR1:
 391                         bb_info_msg("Received SIGUSR1");
 392                         write_leases();
 393                         /* why not just reset the timeout, eh */
 394                         timeout_end = monotonic_sec() + server_config.auto_time;
 395                         continue;
 396                 case SIGTERM:
 397                         bb_info_msg("Received SIGTERM");
 398                         goto ret0;
 399                 case 0: /* no signal: read a packet */
 400                         break;
 401                 default: /* signal or error (probably EINTR): back to select */
 402                         continue;
 403                 }
 404
 405                 bytes = udhcp_recv_kernel_packet(&packet, server_socket);
 406                 if (bytes < 0) {
 407                         /* bytes can also be -2 ("bad packet data") */
 408                         if (bytes == -1 && errno != EINTR) {
 409                                 log1("Read error: %s, reopening socket", strerror(errno));
 410                                 close(server_socket);
 411                                 server_socket = -1;
 412                         }
 413                         continue;
 414                 }
 415                 if (packet.hlen != 6) {
 416                         bb_error_msg("MAC length != 6, ignoring packet");
 417                         continue;
 418                 }
 419                 if (packet.op != BOOTREQUEST) {
 420                         bb_error_msg("not a REQUEST, ignoring packet");
 421                         continue;
 422                 }
 423                 state = udhcp_get_option(&packet, DHCP_MESSAGE_TYPE);
 424                 if (state == NULL || state[0] < DHCP_MINTYPE || state[0] > DHCP_MAXTYPE) {
 425                         bb_error_msg("no or bad message type option, ignoring packet");
 426                         continue;
 427                 }
 428
 429                 /* Look for a static/dynamic lease */
 430                 static_lease_nip = get_static_nip_by_mac(server_config.static_leases, &packet.chaddr);
 431                 if (static_lease_nip) {
 432                         bb_info_msg("Found static lease: %x", static_lease_nip);
 433                         memcpy(&fake_lease.lease_mac, &packet.chaddr, 6);
 434                         fake_lease.lease_nip = static_lease_nip;
 435                         fake_lease.expires = 0;
 436                         lease = &fake_lease;
 437                 } else {
 438                         lease = find_lease_by_mac(packet.chaddr);
 439                 }
 440
 441                 /* Get REQUESTED_IP and SERVER_ID if present */
 442                 server_id_opt = udhcp_get_option(&packet, DHCP_SERVER_ID);
 443                 if (server_id_opt) {
 444                         uint32_t server_id_net;
 445                         move_from_unaligned32(server_id_net, server_id_opt);
 446                         if (server_id_net != server_config.server_nip) {
 447                                 /* client talks to somebody else */
 448                                 log1("server ID doesn't match, ignoring");
 449                                 continue;
 450                         }
 451                 }
 452                 requested_opt = udhcp_get_option(&packet, DHCP_REQUESTED_IP);
 453                 if (requested_opt) {
 454                         move_from_unaligned32(requested_nip, requested_opt);
 455                 }
 456
 457                 switch (state[0]) {
 458
 459                 case DHCPDISCOVER:
 460                         log1("Received DISCOVER");
 461
 462                         send_offer(&packet, static_lease_nip, lease);
 463                         break;
 464
 465                 case DHCPREQUEST:
 466                         log1("Received REQUEST");
 467 /* RFC 2131:
 468
 469 o DHCPREQUEST generated during SELECTING state:
 470
 471    Client inserts the address of the selected server in 'server
 472    identifier', 'ciaddr' MUST be zero, 'requested IP address' MUST be
 473    filled in with the yiaddr value from the chosen DHCPOFFER.
 474
 475    Note that the client may choose to collect several DHCPOFFER
 476    messages and select the "best" offer.  The client indicates its
 477    selection by identifying the offering server in the DHCPREQUEST
 478    message.  If the client receives no acceptable offers, the client
 479    may choose to try another DHCPDISCOVER message.  Therefore, the
 480    servers may not receive a specific DHCPREQUEST from which they can
 481    decide whether or not the client has accepted the offer.
 482
 483 o DHCPREQUEST generated during INIT-REBOOT state:
 484
 485    'server identifier' MUST NOT be filled in, 'requested IP address'
 486    option MUST be filled in with client's notion of its previously
 487    assigned address. 'ciaddr' MUST be zero. The client is seeking to
 488    verify a previously allocated, cached configuration. Server SHOULD
 489    send a DHCPNAK message to the client if the 'requested IP address'
 490    is incorrect, or is on the wrong network.
 491
 492    Determining whether a client in the INIT-REBOOT state is on the
 493    correct network is done by examining the contents of 'giaddr', the
 494    'requested IP address' option, and a database lookup. If the DHCP
 495    server detects that the client is on the wrong net (i.e., the
 496    result of applying the local subnet mask or remote subnet mask (if
 497    'giaddr' is not zero) to 'requested IP address' option value
 498    doesn't match reality), then the server SHOULD send a DHCPNAK
 499    message to the client.
 500
 501    If the network is correct, then the DHCP server should check if
 502    the client's notion of its IP address is correct. If not, then the
 503    server SHOULD send a DHCPNAK message to the client. If the DHCP
 504    server has no record of this client, then it MUST remain silent,
 505    and MAY output a warning to the network administrator. This
 506    behavior is necessary for peaceful coexistence of non-
 507    communicating DHCP servers on the same wire.
 508
 509    If 'giaddr' is 0x0 in the DHCPREQUEST message, the client is on
 510    the same subnet as the server.  The server MUST broadcast the
 511    DHCPNAK message to the 0xffffffff broadcast address because the
 512    client may not have a correct network address or subnet mask, and
 513    the client may not be answering ARP requests.
 514
 515    If 'giaddr' is set in the DHCPREQUEST message, the client is on a
 516    different subnet.  The server MUST set the broadcast bit in the
 517    DHCPNAK, so that the relay agent will broadcast the DHCPNAK to the
 518    client, because the client may not have a correct network address
 519    or subnet mask, and the client may not be answering ARP requests.
 520
 521 o DHCPREQUEST generated during RENEWING state:
 522
 523    'server identifier' MUST NOT be filled in, 'requested IP address'
 524    option MUST NOT be filled in, 'ciaddr' MUST be filled in with
 525    client's IP address. In this situation, the client is completely
 526    configured, and is trying to extend its lease. This message will
 527    be unicast, so no relay agents will be involved in its
 528    transmission.  Because 'giaddr' is therefore not filled in, the
 529    DHCP server will trust the value in 'ciaddr', and use it when
 530    replying to the client.
 531
 532    A client MAY choose to renew or extend its lease prior to T1.  The
 533    server may choose not to extend the lease (as a policy decision by
 534    the network administrator), but should return a DHCPACK message
 535    regardless.
 536
 537 o DHCPREQUEST generated during REBINDING state:
 538
 539    'server identifier' MUST NOT be filled in, 'requested IP address'
 540    option MUST NOT be filled in, 'ciaddr' MUST be filled in with
 541    client's IP address. In this situation, the client is completely
 542    configured, and is trying to extend its lease. This message MUST
 543    be broadcast to the 0xffffffff IP broadcast address.  The DHCP
 544    server SHOULD check 'ciaddr' for correctness before replying to
 545    the DHCPREQUEST.
 546
 547    The DHCPREQUEST from a REBINDING client is intended to accommodate
 548    sites that have multiple DHCP servers and a mechanism for
 549    maintaining consistency among leases managed by multiple servers.
 550    A DHCP server MAY extend a client's lease only if it has local
 551    administrative authority to do so.
 552 */
 553                         if (!requested_opt) {
 554                                 requested_nip = packet.ciaddr;
 555                                 if (requested_nip == 0) {
 556                                         log1("no requested IP and no ciaddr, ignoring");
 557                                         break;
 558                                 }
 559                         }
 560                         if (lease && requested_nip == lease->lease_nip) {
 561                                 /* client requested or configured IP matches the lease.
 562                                  * ACK it, and bump lease expiration time. */
 563                                 send_ACK(&packet, lease->lease_nip);
 564                                 break;
 565                         }
 566                         if (server_id_opt) {
 567                                 /* client was talking specifically to us.
 568                                  * "No, we don't have this IP for you". */
 569                                 send_NAK(&packet);
 570                         }
 571                         break;
 572
 573                 case DHCPDECLINE:
 574                         /* RFC 2131:
 575                          * "If the server receives a DHCPDECLINE message,
 576                          * the client has discovered through some other means
 577                          * that the suggested network address is already
 578                          * in use. The server MUST mark the network address
 579                          * as not available and SHOULD notify the local
 580                          * sysadmin of a possible configuration problem."
 581                          *
 582                          * SERVER_ID must be present,
 583                          * REQUESTED_IP must be present,
 584                          * chaddr must be filled in,
 585                          * ciaddr must be 0 (we do not check this)
 586                          */
 587                         log1("Received DECLINE");
 588                         if (server_id_opt
 589                          && requested_opt
 590                          && lease  /* chaddr matches this lease */
 591                          && requested_nip == lease->lease_nip
 592                         ) {
 593                                 memset(lease->lease_mac, 0, sizeof(lease->lease_mac));
 594                                 lease->expires = time(NULL) + server_config.decline_time;
 595                         }
 596                         break;
 597
 598                 case DHCPRELEASE:
 599                         /* "Upon receipt of a DHCPRELEASE message, the server
 600                          * marks the network address as not allocated."
 601                          *
 602                          * SERVER_ID must be present,
 603                          * REQUESTED_IP must not be present (we do not check this),
 604                          * chaddr must be filled in,
 605                          * ciaddr must be filled in
 606                          */
 607                         log1("Received RELEASE");
 608                         if (server_id_opt
 609                          && lease  /* chaddr matches this lease */
 610                          && packet.ciaddr == lease->lease_nip
 611                         ) {
 612                                 lease->expires = time(NULL);
 613                         }
 614                         break;
 615
 616                 case DHCPINFORM:
 617                         log1("Received INFORM");
 618                         send_inform(&packet);
 619                         break;
 620                 }
 621         }
 622  ret0:
 623         retval = 0;
 624  ret:
 625         /*if (server_config.pidfile) - server_config.pidfile is never NULL */
 626                 remove_pidfile(server_config.pidfile);
 627         return retval;
 628 }