source: branches/3.2/mindi-busybox/networking/udhcp/dhcpd.c @ 3232

Last change on this file since 3232 was 3232, checked in by bruno, 6 years ago
  • Update mindi-busybox to 1.21.1
File size: 21.3 KB
Line 
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 */
41static 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 */
78static 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
87static 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
95static 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 */
112static 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
130static 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 */
147static 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 */
220static 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 */
231static 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 */
263static 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 */
292struct dyn_lease *g_leases;
293/* struct server_config_t server_config is in bb_common_bufsiz1 */
294
295
296int udhcpd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
297int 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
499o 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
513o 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
551o 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
567o 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}
Note: See TracBrowser for help on using the repository browser.