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 /* NOINLINE: limit stack usage in caller */
136 static NOINLINE void send_offer(struct dhcp_packet *oldpacket, uint32_t static_lease_nip, struct dyn_lease *lease)
138 struct dhcp_packet packet;
139 uint32_t lease_time_sec;
142 init_packet(&packet, oldpacket, DHCPOFFER);
144 /* If it is a static lease, use its IP */
145 packet.yiaddr = static_lease_nip;
147 if (!static_lease_nip) {
148 /* We have no static lease for client's chaddr */
151 const char *p_host_name;
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.
158 packet.yiaddr = lease->lease_nip;
160 /* Or: if client has requested an IP */
161 else if ((req_ip_opt = udhcp_get_option(oldpacket, DHCP_REQUESTED_IP)) != NULL
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
168 && ( !(lease = find_lease_by_nip(req_nip)) /* is not already taken */
169 || is_expired_lease(lease) /* or is taken, but expired */
172 packet.yiaddr = req_nip;
175 /* Otherwise, find a free IP */
176 packet.yiaddr = find_free_or_expired_nip(oldpacket->chaddr);
179 if (!packet.yiaddr) {
180 bb_error_msg("no free IP addresses. OFFER abandoned");
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,
188 p_host_name ? (unsigned char)p_host_name[OPT_LEN - OPT_DATA] : 0
191 bb_error_msg("no free IP addresses. OFFER abandoned");
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);
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);
206 /* NOINLINE: limit stack usage in caller */
207 static NOINLINE void send_NAK(struct dhcp_packet *oldpacket)
209 struct dhcp_packet packet;
211 init_packet(&packet, oldpacket, DHCPNAK);
214 send_packet(&packet, /*force_bcast:*/ 1);
217 /* NOINLINE: limit stack usage in caller */
218 static NOINLINE void send_ACK(struct dhcp_packet *oldpacket, uint32_t yiaddr)
220 struct dhcp_packet packet;
221 uint32_t lease_time_sec;
223 const char *p_host_name;
225 init_packet(&packet, oldpacket, DHCPACK);
226 packet.yiaddr = yiaddr;
228 lease_time_sec = select_lease_time(oldpacket);
229 udhcp_add_simple_option(&packet, DHCP_LEASE_TIME, htonl(lease_time_sec));
231 add_server_options(&packet);
233 addr.s_addr = yiaddr;
234 bb_info_msg("Sending ACK to %s", inet_ntoa(addr));
235 send_packet(&packet, /*force_bcast:*/ 0);
237 p_host_name = (const char*) udhcp_get_option(oldpacket, DHCP_HOST_NAME);
238 add_lease(packet.chaddr, packet.yiaddr,
241 p_host_name ? (unsigned char)p_host_name[OPT_LEN - OPT_DATA] : 0
243 if (ENABLE_FEATURE_UDHCPD_WRITE_LEASES_EARLY) {
244 /* rewrite the file with leases at every new acceptance */
249 /* NOINLINE: limit stack usage in caller */
250 static NOINLINE void send_inform(struct dhcp_packet *oldpacket)
252 struct dhcp_packet packet;
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.
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'."
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);
274 send_packet(&packet, /*force_bcast:*/ 0);
279 struct dyn_lease *g_leases;
280 /* struct server_config_t server_config is in bb_common_bufsiz1 */
283 int udhcpd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
284 int udhcpd_main(int argc UNUSED_PARAM, char **argv)
287 int server_socket = -1, retval, max_sock;
288 struct dhcp_packet packet;
290 uint32_t static_lease_nip;
291 unsigned timeout_end;
294 struct option_set *option;
295 struct dyn_lease *lease, fake_lease;
296 IF_FEATURE_UDHCP_PORT(char *str_P;)
298 #if ENABLE_FEATURE_UDHCP_PORT
303 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
304 opt_complementary = "vv";
306 opt = getopt32(argv, "fSv"
307 IF_FEATURE_UDHCP_PORT("P:", &str_P)
308 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
312 if (!(opt & 1)) { /* no -f */
313 bb_daemonize_or_rexec(0, argv);
314 logmode = LOGMODE_NONE;
316 /* update argv after the possible vfork+exec in daemonize */
318 if (opt & 2) { /* -S */
319 openlog(applet_name, LOG_PID, LOG_DAEMON);
320 logmode |= LOGMODE_SYSLOG;
322 #if ENABLE_FEATURE_UDHCP_PORT
323 if (opt & 8) { /* -P */
324 SERVER_PORT = xatou16(str_P);
325 CLIENT_PORT = SERVER_PORT + 1;
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);
332 /* Make sure fd 0,1,2 are open */
334 /* Equivalent of doing a fflush after every \n */
338 write_pidfile(server_config.pidfile);
339 /* if (!..) bb_perror_msg("can't create pidfile %s", pidfile); */
341 bb_info_msg("%s (v"BB_VER") started", applet_name);
343 option = udhcp_find_option(server_config.options, DHCP_LEASE_TIME);
344 server_config.max_lease_sec = DEFAULT_LEASE_TIME;
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);
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;
358 g_leases = xzalloc(server_config.max_leases * sizeof(g_leases[0]));
359 read_leases(server_config.lease_file);
361 if (udhcp_read_interface(server_config.interface,
362 &server_config.ifindex,
363 &server_config.server_nip,
364 server_config.server_mac)
370 /* Setup the signal pipe */
373 timeout_end = monotonic_sec() + server_config.auto_time;
374 while (1) { /* loop until universe collapses */
377 uint8_t *server_id_opt;
378 uint8_t *requested_opt;
379 uint32_t requested_nip = requested_nip; /* for compiler */
381 if (server_socket < 0) {
382 server_socket = udhcp_listen_socket(/*INADDR_ANY,*/ SERVER_PORT,
383 server_config.interface);
386 max_sock = udhcp_sp_fd_set(&rfds, server_socket);
387 if (server_config.auto_time) {
388 tv.tv_sec = timeout_end - monotonic_sec();
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);
398 timeout_end = monotonic_sec() + server_config.auto_time;
401 if (retval < 0 && errno != EINTR) {
402 log1("Error on select");
406 switch (udhcp_sp_read(&rfds)) {
408 bb_info_msg("Received SIGUSR1");
410 /* why not just reset the timeout, eh */
411 timeout_end = monotonic_sec() + server_config.auto_time;
414 bb_info_msg("Received SIGTERM");
416 case 0: /* no signal: read a packet */
418 default: /* signal or error (probably EINTR): back to select */
422 bytes = udhcp_recv_kernel_packet(&packet, server_socket);
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);
432 if (packet.hlen != 6) {
433 bb_error_msg("MAC length != 6, ignoring packet");
436 if (packet.op != BOOTREQUEST) {
437 bb_error_msg("not a REQUEST, ignoring packet");
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");
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;
455 lease = find_lease_by_mac(packet.chaddr);
458 /* Get REQUESTED_IP and SERVER_ID if present */
459 server_id_opt = udhcp_get_option(&packet, DHCP_SERVER_ID);
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");
469 requested_opt = udhcp_get_option(&packet, DHCP_REQUESTED_IP);
471 move_from_unaligned32(requested_nip, requested_opt);
477 log1("Received DISCOVER");
479 send_offer(&packet, static_lease_nip, lease);
483 log1("Received REQUEST");
486 o DHCPREQUEST generated during SELECTING state:
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.
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.
500 o DHCPREQUEST generated during INIT-REBOOT state:
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.
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.
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.
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.
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.
538 o DHCPREQUEST generated during RENEWING state:
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.
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
554 o DHCPREQUEST generated during REBINDING state:
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
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.
570 if (!requested_opt) {
571 requested_nip = packet.ciaddr;
572 if (requested_nip == 0) {
573 log1("no requested IP and no ciaddr, ignoring");
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);
584 /* client was talking specifically to us.
585 * "No, we don't have this IP for you". */
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."
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)
604 log1("Received DECLINE");
607 && lease /* chaddr matches this lease */
608 && requested_nip == lease->lease_nip
610 memset(lease->lease_mac, 0, sizeof(lease->lease_mac));
611 lease->expires = time(NULL) + server_config.decline_time;
616 /* "Upon receipt of a DHCPRELEASE message, the server
617 * marks the network address as not allocated."
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
624 log1("Received RELEASE");
626 && lease /* chaddr matches this lease */
627 && packet.ciaddr == lease->lease_nip
629 lease->expires = time(NULL);
634 log1("Received INFORM");
635 send_inform(&packet);
642 /*if (server_config.pidfile) - server_config.pidfile is never NULL */
643 remove_pidfile(server_config.pidfile);