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

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