1 /* vi: set sw=4 ts=4: */
4 * Copyright (C) 1999 Matthew Ramsay <matthewr@moreton.com.au>
5 * Chris Trew <ctrew@moreton.com.au>
7 * Rewrite by Russ Dill <Russ.Dill@asu.edu> July 2001
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.
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.
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.
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)
32 const uint8_t *chaddr;
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,
48 || (dhcp_pkt->flags & htons(BROADCAST_FLAG))
49 || dhcp_pkt->ciaddr == 0
51 log1("Broadcasting packet to client");
52 ciaddr = INADDR_BROADCAST;
53 chaddr = MAC_BCAST_ADDR;
55 log1("Unicasting packet to client ciaddr");
56 ciaddr = dhcp_pkt->ciaddr;
57 chaddr = dhcp_pkt->chaddr;
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);
66 /* Send a packet to gateway_nip using the kernel ip stack */
67 static void send_packet_to_relay(struct dhcp_packet *dhcp_pkt)
69 log1("Forwarding packet to relay");
71 udhcp_send_kernel_packet(dhcp_pkt,
72 server_config.server_nip, SERVER_PORT,
73 dhcp_pkt->gateway_nip, SERVER_PORT);
76 static void send_packet(struct dhcp_packet *dhcp_pkt, int force_broadcast)
78 if (dhcp_pkt->gateway_nip)
79 send_packet_to_relay(dhcp_pkt);
81 send_packet_to_client(dhcp_pkt, force_broadcast);
84 static void init_packet(struct dhcp_packet *packet, struct dhcp_packet *oldpacket, char type)
86 /* Sets op, htype, hlen, cookie fields
87 * and adds DHCP_MESSAGE_TYPE option */
88 udhcp_init_header(packet, type);
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);
98 /* Fill options field, siaddr_nip, and sname and boot_file fields.
99 * TODO: teach this code to use overload option.
101 static void add_server_options(struct dhcp_packet *packet)
103 struct option_set *curr = server_config.options;
106 if (curr->data[OPT_CODE] != DHCP_LEASE_TIME)
107 udhcp_add_binary_option(packet, curr->data);
111 packet->siaddr_nip = server_config.siaddr_nip;
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);
119 static uint32_t select_lease_time(struct dhcp_packet *packet)
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;
131 return lease_time_sec;
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)
137 struct dhcp_packet packet;
138 uint32_t lease_time_sec;
141 init_packet(&packet, oldpacket, DHCPOFFER);
143 /* If it is a static lease, use its IP */
144 packet.yiaddr = static_lease_nip;
146 if (!static_lease_nip) {
147 /* We have no static lease for client's chaddr */
150 const char *p_host_name;
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.
157 packet.yiaddr = lease->lease_nip;
159 /* Or: if client has requested an IP */
160 else if ((req_ip_opt = udhcp_get_option(oldpacket, DHCP_REQUESTED_IP)) != NULL
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
167 && ( !(lease = find_lease_by_nip(req_nip)) /* is not already taken */
168 || is_expired_lease(lease) /* or is taken, but expired */
171 packet.yiaddr = req_nip;
174 /* Otherwise, find a free IP */
175 packet.yiaddr = find_free_or_expired_nip(oldpacket->chaddr);
178 if (!packet.yiaddr) {
179 bb_error_msg("no free IP addresses. OFFER abandoned");
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,
187 p_host_name ? (unsigned char)p_host_name[OPT_LEN - OPT_DATA] : 0
190 bb_error_msg("no free IP addresses. OFFER abandoned");
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);
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);
205 static void send_NAK(struct dhcp_packet *oldpacket)
207 struct dhcp_packet packet;
209 init_packet(&packet, oldpacket, DHCPNAK);
212 send_packet(&packet, /*force_bcast:*/ 1);
215 static void send_ACK(struct dhcp_packet *oldpacket, uint32_t yiaddr)
217 struct dhcp_packet packet;
218 uint32_t lease_time_sec;
220 const char *p_host_name;
222 init_packet(&packet, oldpacket, DHCPACK);
223 packet.yiaddr = yiaddr;
225 lease_time_sec = select_lease_time(oldpacket);
226 udhcp_add_simple_option(&packet, DHCP_LEASE_TIME, htonl(lease_time_sec));
228 add_server_options(&packet);
230 addr.s_addr = yiaddr;
231 bb_info_msg("Sending ACK to %s", inet_ntoa(addr));
232 send_packet(&packet, /*force_bcast:*/ 0);
234 p_host_name = (const char*) udhcp_get_option(oldpacket, DHCP_HOST_NAME);
235 add_lease(packet.chaddr, packet.yiaddr,
238 p_host_name ? (unsigned char)p_host_name[OPT_LEN - OPT_DATA] : 0
240 if (ENABLE_FEATURE_UDHCPD_WRITE_LEASES_EARLY) {
241 /* rewrite the file with leases at every new acceptance */
246 static void send_inform(struct dhcp_packet *oldpacket)
248 struct dhcp_packet packet;
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.
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'."
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);
270 send_packet(&packet, /*force_bcast:*/ 0);
275 struct dyn_lease *g_leases;
276 /* struct server_config_t server_config is in bb_common_bufsiz1 */
279 int udhcpd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
280 int udhcpd_main(int argc UNUSED_PARAM, char **argv)
283 int server_socket = -1, retval, max_sock;
284 struct dhcp_packet packet;
286 uint32_t static_lease_nip;
287 unsigned timeout_end;
290 struct option_set *option;
291 struct dyn_lease *lease, fake_lease;
292 IF_FEATURE_UDHCP_PORT(char *str_P;)
294 #if ENABLE_FEATURE_UDHCP_PORT
299 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
300 opt_complementary = "vv";
302 opt = getopt32(argv, "fSv"
303 IF_FEATURE_UDHCP_PORT("P:", &str_P)
304 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
308 if (!(opt & 1)) { /* no -f */
309 bb_daemonize_or_rexec(0, argv);
310 logmode = LOGMODE_NONE;
312 /* update argv after the possible vfork+exec in daemonize */
314 if (opt & 2) { /* -S */
315 openlog(applet_name, LOG_PID, LOG_DAEMON);
316 logmode |= LOGMODE_SYSLOG;
318 #if ENABLE_FEATURE_UDHCP_PORT
319 if (opt & 8) { /* -P */
320 SERVER_PORT = xatou16(str_P);
321 CLIENT_PORT = SERVER_PORT + 1;
324 /* Would rather not do read_config before daemonization -
325 * otherwise NOMMU machines will parse config twice */
326 read_config(argv[0] ? argv[0] : DHCPD_CONF_FILE);
328 /* Make sure fd 0,1,2 are open */
330 /* Equivalent of doing a fflush after every \n */
334 write_pidfile(server_config.pidfile);
335 /* if (!..) bb_perror_msg("can't create pidfile %s", pidfile); */
337 bb_info_msg("%s (v"BB_VER") started", applet_name);
339 option = udhcp_find_option(server_config.options, DHCP_LEASE_TIME);
340 server_config.max_lease_sec = DEFAULT_LEASE_TIME;
342 move_from_unaligned32(server_config.max_lease_sec, option->data + OPT_DATA);
343 server_config.max_lease_sec = ntohl(server_config.max_lease_sec);
347 num_ips = server_config.end_ip - server_config.start_ip + 1;
348 if (server_config.max_leases > num_ips) {
349 bb_error_msg("max_leases=%u is too big, setting to %u",
350 (unsigned)server_config.max_leases, num_ips);
351 server_config.max_leases = num_ips;
354 g_leases = xzalloc(server_config.max_leases * sizeof(g_leases[0]));
355 read_leases(server_config.lease_file);
357 if (udhcp_read_interface(server_config.interface,
358 &server_config.ifindex,
359 &server_config.server_nip,
360 server_config.server_mac)
366 /* Setup the signal pipe */
369 timeout_end = monotonic_sec() + server_config.auto_time;
370 while (1) { /* loop until universe collapses */
373 uint8_t *server_id_opt;
374 uint8_t *requested_opt;
375 uint32_t requested_nip = requested_nip; /* for compiler */
377 if (server_socket < 0) {
378 server_socket = udhcp_listen_socket(/*INADDR_ANY,*/ SERVER_PORT,
379 server_config.interface);
382 max_sock = udhcp_sp_fd_set(&rfds, server_socket);
383 if (server_config.auto_time) {
384 tv.tv_sec = timeout_end - monotonic_sec();
388 if (!server_config.auto_time || tv.tv_sec > 0) {
389 retval = select(max_sock + 1, &rfds, NULL, NULL,
390 server_config.auto_time ? &tv : NULL);
394 timeout_end = monotonic_sec() + server_config.auto_time;
397 if (retval < 0 && errno != EINTR) {
398 log1("Error on select");
402 switch (udhcp_sp_read(&rfds)) {
404 bb_info_msg("Received SIGUSR1");
406 /* why not just reset the timeout, eh */
407 timeout_end = monotonic_sec() + server_config.auto_time;
410 bb_info_msg("Received SIGTERM");
412 case 0: /* no signal: read a packet */
414 default: /* signal or error (probably EINTR): back to select */
418 bytes = udhcp_recv_kernel_packet(&packet, server_socket);
420 /* bytes can also be -2 ("bad packet data") */
421 if (bytes == -1 && errno != EINTR) {
422 log1("Read error: %s, reopening socket", strerror(errno));
423 close(server_socket);
428 if (packet.hlen != 6) {
429 bb_error_msg("MAC length != 6, ignoring packet");
432 if (packet.op != BOOTREQUEST) {
433 bb_error_msg("not a REQUEST, ignoring packet");
436 state = udhcp_get_option(&packet, DHCP_MESSAGE_TYPE);
437 if (state == NULL || state[0] < DHCP_MINTYPE || state[0] > DHCP_MAXTYPE) {
438 bb_error_msg("no or bad message type option, ignoring packet");
442 /* Look for a static/dynamic lease */
443 static_lease_nip = get_static_nip_by_mac(server_config.static_leases, &packet.chaddr);
444 if (static_lease_nip) {
445 bb_info_msg("Found static lease: %x", static_lease_nip);
446 memcpy(&fake_lease.lease_mac, &packet.chaddr, 6);
447 fake_lease.lease_nip = static_lease_nip;
448 fake_lease.expires = 0;
451 lease = find_lease_by_mac(packet.chaddr);
454 /* Get REQUESTED_IP and SERVER_ID if present */
455 server_id_opt = udhcp_get_option(&packet, DHCP_SERVER_ID);
457 uint32_t server_id_net;
458 move_from_unaligned32(server_id_net, server_id_opt);
459 if (server_id_net != server_config.server_nip) {
460 /* client talks to somebody else */
461 log1("server ID doesn't match, ignoring");
465 requested_opt = udhcp_get_option(&packet, DHCP_REQUESTED_IP);
467 move_from_unaligned32(requested_nip, requested_opt);
473 log1("Received DISCOVER");
475 send_offer(&packet, static_lease_nip, lease);
479 log1("Received REQUEST");
482 o DHCPREQUEST generated during SELECTING state:
484 Client inserts the address of the selected server in 'server
485 identifier', 'ciaddr' MUST be zero, 'requested IP address' MUST be
486 filled in with the yiaddr value from the chosen DHCPOFFER.
488 Note that the client may choose to collect several DHCPOFFER
489 messages and select the "best" offer. The client indicates its
490 selection by identifying the offering server in the DHCPREQUEST
491 message. If the client receives no acceptable offers, the client
492 may choose to try another DHCPDISCOVER message. Therefore, the
493 servers may not receive a specific DHCPREQUEST from which they can
494 decide whether or not the client has accepted the offer.
496 o DHCPREQUEST generated during INIT-REBOOT state:
498 'server identifier' MUST NOT be filled in, 'requested IP address'
499 option MUST be filled in with client's notion of its previously
500 assigned address. 'ciaddr' MUST be zero. The client is seeking to
501 verify a previously allocated, cached configuration. Server SHOULD
502 send a DHCPNAK message to the client if the 'requested IP address'
503 is incorrect, or is on the wrong network.
505 Determining whether a client in the INIT-REBOOT state is on the
506 correct network is done by examining the contents of 'giaddr', the
507 'requested IP address' option, and a database lookup. If the DHCP
508 server detects that the client is on the wrong net (i.e., the
509 result of applying the local subnet mask or remote subnet mask (if
510 'giaddr' is not zero) to 'requested IP address' option value
511 doesn't match reality), then the server SHOULD send a DHCPNAK
512 message to the client.
514 If the network is correct, then the DHCP server should check if
515 the client's notion of its IP address is correct. If not, then the
516 server SHOULD send a DHCPNAK message to the client. If the DHCP
517 server has no record of this client, then it MUST remain silent,
518 and MAY output a warning to the network administrator. This
519 behavior is necessary for peaceful coexistence of non-
520 communicating DHCP servers on the same wire.
522 If 'giaddr' is 0x0 in the DHCPREQUEST message, the client is on
523 the same subnet as the server. The server MUST broadcast the
524 DHCPNAK message to the 0xffffffff broadcast address because the
525 client may not have a correct network address or subnet mask, and
526 the client may not be answering ARP requests.
528 If 'giaddr' is set in the DHCPREQUEST message, the client is on a
529 different subnet. The server MUST set the broadcast bit in the
530 DHCPNAK, so that the relay agent will broadcast the DHCPNAK to the
531 client, because the client may not have a correct network address
532 or subnet mask, and the client may not be answering ARP requests.
534 o DHCPREQUEST generated during RENEWING state:
536 'server identifier' MUST NOT be filled in, 'requested IP address'
537 option MUST NOT be filled in, 'ciaddr' MUST be filled in with
538 client's IP address. In this situation, the client is completely
539 configured, and is trying to extend its lease. This message will
540 be unicast, so no relay agents will be involved in its
541 transmission. Because 'giaddr' is therefore not filled in, the
542 DHCP server will trust the value in 'ciaddr', and use it when
543 replying to the client.
545 A client MAY choose to renew or extend its lease prior to T1. The
546 server may choose not to extend the lease (as a policy decision by
547 the network administrator), but should return a DHCPACK message
550 o DHCPREQUEST generated during REBINDING state:
552 'server identifier' MUST NOT be filled in, 'requested IP address'
553 option MUST NOT be filled in, 'ciaddr' MUST be filled in with
554 client's IP address. In this situation, the client is completely
555 configured, and is trying to extend its lease. This message MUST
556 be broadcast to the 0xffffffff IP broadcast address. The DHCP
557 server SHOULD check 'ciaddr' for correctness before replying to
560 The DHCPREQUEST from a REBINDING client is intended to accommodate
561 sites that have multiple DHCP servers and a mechanism for
562 maintaining consistency among leases managed by multiple servers.
563 A DHCP server MAY extend a client's lease only if it has local
564 administrative authority to do so.
566 if (!requested_opt) {
567 requested_nip = packet.ciaddr;
568 if (requested_nip == 0) {
569 log1("no requested IP and no ciaddr, ignoring");
573 if (lease && requested_nip == lease->lease_nip) {
574 /* client requested or configured IP matches the lease.
575 * ACK it, and bump lease expiration time. */
576 send_ACK(&packet, lease->lease_nip);
580 /* client was talking specifically to us.
581 * "No, we don't have this IP for you". */
588 * "If the server receives a DHCPDECLINE message,
589 * the client has discovered through some other means
590 * that the suggested network address is already
591 * in use. The server MUST mark the network address
592 * as not available and SHOULD notify the local
593 * sysadmin of a possible configuration problem."
595 * SERVER_ID must be present,
596 * REQUESTED_IP must be present,
597 * chaddr must be filled in,
598 * ciaddr must be 0 (we do not check this)
600 log1("Received DECLINE");
603 && lease /* chaddr matches this lease */
604 && requested_nip == lease->lease_nip
606 memset(lease->lease_mac, 0, sizeof(lease->lease_mac));
607 lease->expires = time(NULL) + server_config.decline_time;
612 /* "Upon receipt of a DHCPRELEASE message, the server
613 * marks the network address as not allocated."
615 * SERVER_ID must be present,
616 * REQUESTED_IP must not be present (we do not check this),
617 * chaddr must be filled in,
618 * ciaddr must be filled in
620 log1("Received RELEASE");
622 && lease /* chaddr matches this lease */
623 && packet.ciaddr == lease->lease_nip
625 lease->expires = time(NULL);
630 log1("Received INFORM");
631 send_inform(&packet);
638 /*if (server_config.pidfile) - server_config.pidfile is never NULL */
639 remove_pidfile(server_config.pidfile);