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,
137 uint32_t static_lease_nip,
138 struct dyn_lease *lease,
139 uint8_t *requested_ip_opt)
141 struct dhcp_packet packet;
142 uint32_t lease_time_sec;
145 init_packet(&packet, oldpacket, DHCPOFFER);
147 /* If it is a static lease, use its IP */
148 packet.yiaddr = static_lease_nip;
150 if (!static_lease_nip) {
151 /* We have no static lease for client's chaddr */
153 const char *p_host_name;
156 /* We have a dynamic lease for client's chaddr.
157 * Reuse its IP (even if lease is expired).
158 * Note that we ignore requested IP in this case.
160 packet.yiaddr = lease->lease_nip;
162 /* Or: if client has requested an IP */
163 else if (requested_ip_opt != NULL
165 && (move_from_unaligned32(req_nip, requested_ip_opt), 1)
166 /* and the IP is in the lease range */
167 && ntohl(req_nip) >= server_config.start_ip
168 && ntohl(req_nip) <= server_config.end_ip
170 && ( !(lease = find_lease_by_nip(req_nip)) /* is not already taken */
171 || is_expired_lease(lease) /* or is taken, but expired */
174 packet.yiaddr = req_nip;
177 /* Otherwise, find a free IP */
178 packet.yiaddr = find_free_or_expired_nip(oldpacket->chaddr);
181 if (!packet.yiaddr) {
182 bb_error_msg("no free IP addresses. OFFER abandoned");
185 /* Reserve the IP for a short time hoping to get DHCPREQUEST soon */
186 p_host_name = (const char*) udhcp_get_option(oldpacket, DHCP_HOST_NAME);
187 lease = add_lease(packet.chaddr, packet.yiaddr,
188 server_config.offer_time,
190 p_host_name ? (unsigned char)p_host_name[OPT_LEN - OPT_DATA] : 0
193 bb_error_msg("no free IP addresses. OFFER abandoned");
198 lease_time_sec = select_lease_time(oldpacket);
199 udhcp_add_simple_option(&packet, DHCP_LEASE_TIME, htonl(lease_time_sec));
200 add_server_options(&packet);
202 addr.s_addr = packet.yiaddr;
203 bb_info_msg("Sending OFFER of %s", inet_ntoa(addr));
204 /* send_packet emits error message itself if it detects failure */
205 send_packet(&packet, /*force_bcast:*/ 0);
208 /* NOINLINE: limit stack usage in caller */
209 static NOINLINE void send_NAK(struct dhcp_packet *oldpacket)
211 struct dhcp_packet packet;
213 init_packet(&packet, oldpacket, DHCPNAK);
216 send_packet(&packet, /*force_bcast:*/ 1);
219 /* NOINLINE: limit stack usage in caller */
220 static NOINLINE void send_ACK(struct dhcp_packet *oldpacket, uint32_t yiaddr)
222 struct dhcp_packet packet;
223 uint32_t lease_time_sec;
225 const char *p_host_name;
227 init_packet(&packet, oldpacket, DHCPACK);
228 packet.yiaddr = yiaddr;
230 lease_time_sec = select_lease_time(oldpacket);
231 udhcp_add_simple_option(&packet, DHCP_LEASE_TIME, htonl(lease_time_sec));
233 add_server_options(&packet);
235 addr.s_addr = yiaddr;
236 bb_info_msg("Sending ACK to %s", inet_ntoa(addr));
237 send_packet(&packet, /*force_bcast:*/ 0);
239 p_host_name = (const char*) udhcp_get_option(oldpacket, DHCP_HOST_NAME);
240 add_lease(packet.chaddr, packet.yiaddr,
243 p_host_name ? (unsigned char)p_host_name[OPT_LEN - OPT_DATA] : 0
245 if (ENABLE_FEATURE_UDHCPD_WRITE_LEASES_EARLY) {
246 /* rewrite the file with leases at every new acceptance */
251 /* NOINLINE: limit stack usage in caller */
252 static NOINLINE void send_inform(struct dhcp_packet *oldpacket)
254 struct dhcp_packet packet;
256 /* "If a client has obtained a network address through some other means
257 * (e.g., manual configuration), it may use a DHCPINFORM request message
258 * to obtain other local configuration parameters. Servers receiving a
259 * DHCPINFORM message construct a DHCPACK message with any local
260 * configuration parameters appropriate for the client without:
261 * allocating a new address, checking for an existing binding, filling
262 * in 'yiaddr' or including lease time parameters. The servers SHOULD
263 * unicast the DHCPACK reply to the address given in the 'ciaddr' field
264 * of the DHCPINFORM message.
266 * The server responds to a DHCPINFORM message by sending a DHCPACK
267 * message directly to the address given in the 'ciaddr' field
268 * of the DHCPINFORM message. The server MUST NOT send a lease
269 * expiration time to the client and SHOULD NOT fill in 'yiaddr'."
271 //TODO: do a few sanity checks: is ciaddr set?
272 //Better yet: is ciaddr == IP source addr?
273 init_packet(&packet, oldpacket, DHCPACK);
274 add_server_options(&packet);
276 send_packet(&packet, /*force_bcast:*/ 0);
281 struct dyn_lease *g_leases;
282 /* struct server_config_t server_config is in bb_common_bufsiz1 */
285 int udhcpd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
286 int udhcpd_main(int argc UNUSED_PARAM, char **argv)
288 int server_socket = -1, retval, max_sock;
290 unsigned timeout_end;
293 struct option_set *option;
294 IF_FEATURE_UDHCP_PORT(char *str_P;)
296 #if ENABLE_FEATURE_UDHCP_PORT
301 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
302 opt_complementary = "vv";
304 opt = getopt32(argv, "fSv"
305 IF_FEATURE_UDHCP_PORT("P:", &str_P)
306 #if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
310 if (!(opt & 1)) { /* no -f */
311 bb_daemonize_or_rexec(0, argv);
312 logmode = LOGMODE_NONE;
314 /* update argv after the possible vfork+exec in daemonize */
316 if (opt & 2) { /* -S */
317 openlog(applet_name, LOG_PID, LOG_DAEMON);
318 logmode |= LOGMODE_SYSLOG;
320 #if ENABLE_FEATURE_UDHCP_PORT
321 if (opt & 8) { /* -P */
322 SERVER_PORT = xatou16(str_P);
323 CLIENT_PORT = SERVER_PORT + 1;
326 /* Would rather not do read_config before daemonization -
327 * otherwise NOMMU machines will parse config twice */
328 read_config(argv[0] ? argv[0] : DHCPD_CONF_FILE);
330 /* Make sure fd 0,1,2 are open */
332 /* Equivalent of doing a fflush after every \n */
336 write_pidfile(server_config.pidfile);
337 /* if (!..) bb_perror_msg("can't create pidfile %s", pidfile); */
339 bb_info_msg("%s (v"BB_VER") started", applet_name);
341 option = udhcp_find_option(server_config.options, DHCP_LEASE_TIME);
342 server_config.max_lease_sec = DEFAULT_LEASE_TIME;
344 move_from_unaligned32(server_config.max_lease_sec, option->data + OPT_DATA);
345 server_config.max_lease_sec = ntohl(server_config.max_lease_sec);
349 num_ips = server_config.end_ip - server_config.start_ip + 1;
350 if (server_config.max_leases > num_ips) {
351 bb_error_msg("max_leases=%u is too big, setting to %u",
352 (unsigned)server_config.max_leases, num_ips);
353 server_config.max_leases = num_ips;
356 g_leases = xzalloc(server_config.max_leases * sizeof(g_leases[0]));
357 read_leases(server_config.lease_file);
359 if (udhcp_read_interface(server_config.interface,
360 &server_config.ifindex,
361 &server_config.server_nip,
362 server_config.server_mac)
368 /* Setup the signal pipe */
371 timeout_end = monotonic_sec() + server_config.auto_time;
372 while (1) { /* loop until universe collapses */
374 struct dhcp_packet packet;
377 uint8_t *server_id_opt;
378 uint8_t *requested_ip_opt;
379 uint32_t requested_nip = requested_nip; /* for compiler */
380 uint32_t static_lease_nip;
381 struct dyn_lease *lease, fake_lease;
383 if (server_socket < 0) {
384 server_socket = udhcp_listen_socket(/*INADDR_ANY,*/ SERVER_PORT,
385 server_config.interface);
388 max_sock = udhcp_sp_fd_set(&rfds, server_socket);
389 if (server_config.auto_time) {
390 tv.tv_sec = timeout_end - monotonic_sec();
394 if (!server_config.auto_time || tv.tv_sec > 0) {
395 retval = select(max_sock + 1, &rfds, NULL, NULL,
396 server_config.auto_time ? &tv : NULL);
400 timeout_end = monotonic_sec() + server_config.auto_time;
403 if (retval < 0 && errno != EINTR) {
404 log1("Error on select");
408 switch (udhcp_sp_read(&rfds)) {
410 bb_info_msg("Received SIGUSR1");
412 /* why not just reset the timeout, eh */
413 timeout_end = monotonic_sec() + server_config.auto_time;
416 bb_info_msg("Received SIGTERM");
418 case 0: /* no signal: read a packet */
420 default: /* signal or error (probably EINTR): back to select */
424 bytes = udhcp_recv_kernel_packet(&packet, server_socket);
426 /* bytes can also be -2 ("bad packet data") */
427 if (bytes == -1 && errno != EINTR) {
428 log1("Read error: %s, reopening socket", strerror(errno));
429 close(server_socket);
434 if (packet.hlen != 6) {
435 bb_error_msg("MAC length != 6, ignoring packet");
438 if (packet.op != BOOTREQUEST) {
439 bb_error_msg("not a REQUEST, ignoring packet");
442 state = udhcp_get_option(&packet, DHCP_MESSAGE_TYPE);
443 if (state == NULL || state[0] < DHCP_MINTYPE || state[0] > DHCP_MAXTYPE) {
444 bb_error_msg("no or bad message type option, ignoring packet");
448 /* Get SERVER_ID if present */
449 server_id_opt = udhcp_get_option(&packet, DHCP_SERVER_ID);
451 uint32_t server_id_net;
452 move_from_unaligned32(server_id_net, server_id_opt);
453 if (server_id_net != server_config.server_nip) {
454 /* client talks to somebody else */
455 log1("server ID doesn't match, ignoring");
460 /* Look for a static/dynamic lease */
461 static_lease_nip = get_static_nip_by_mac(server_config.static_leases, &packet.chaddr);
462 if (static_lease_nip) {
463 bb_info_msg("Found static lease: %x", static_lease_nip);
464 memcpy(&fake_lease.lease_mac, &packet.chaddr, 6);
465 fake_lease.lease_nip = static_lease_nip;
466 fake_lease.expires = 0;
469 lease = find_lease_by_mac(packet.chaddr);
472 /* Get REQUESTED_IP if present */
473 requested_ip_opt = udhcp_get_option(&packet, DHCP_REQUESTED_IP);
474 if (requested_ip_opt) {
475 move_from_unaligned32(requested_nip, requested_ip_opt);
481 log1("Received DISCOVER");
483 send_offer(&packet, static_lease_nip, lease, requested_ip_opt);
487 log1("Received REQUEST");
490 o DHCPREQUEST generated during SELECTING state:
492 Client inserts the address of the selected server in 'server
493 identifier', 'ciaddr' MUST be zero, 'requested IP address' MUST be
494 filled in with the yiaddr value from the chosen DHCPOFFER.
496 Note that the client may choose to collect several DHCPOFFER
497 messages and select the "best" offer. The client indicates its
498 selection by identifying the offering server in the DHCPREQUEST
499 message. If the client receives no acceptable offers, the client
500 may choose to try another DHCPDISCOVER message. Therefore, the
501 servers may not receive a specific DHCPREQUEST from which they can
502 decide whether or not the client has accepted the offer.
504 o DHCPREQUEST generated during INIT-REBOOT state:
506 'server identifier' MUST NOT be filled in, 'requested IP address'
507 option MUST be filled in with client's notion of its previously
508 assigned address. 'ciaddr' MUST be zero. The client is seeking to
509 verify a previously allocated, cached configuration. Server SHOULD
510 send a DHCPNAK message to the client if the 'requested IP address'
511 is incorrect, or is on the wrong network.
513 Determining whether a client in the INIT-REBOOT state is on the
514 correct network is done by examining the contents of 'giaddr', the
515 'requested IP address' option, and a database lookup. If the DHCP
516 server detects that the client is on the wrong net (i.e., the
517 result of applying the local subnet mask or remote subnet mask (if
518 'giaddr' is not zero) to 'requested IP address' option value
519 doesn't match reality), then the server SHOULD send a DHCPNAK
520 message to the client.
522 If the network is correct, then the DHCP server should check if
523 the client's notion of its IP address is correct. If not, then the
524 server SHOULD send a DHCPNAK message to the client. If the DHCP
525 server has no record of this client, then it MUST remain silent,
526 and MAY output a warning to the network administrator. This
527 behavior is necessary for peaceful coexistence of non-
528 communicating DHCP servers on the same wire.
530 If 'giaddr' is 0x0 in the DHCPREQUEST message, the client is on
531 the same subnet as the server. The server MUST broadcast the
532 DHCPNAK message to the 0xffffffff broadcast address because the
533 client may not have a correct network address or subnet mask, and
534 the client may not be answering ARP requests.
536 If 'giaddr' is set in the DHCPREQUEST message, the client is on a
537 different subnet. The server MUST set the broadcast bit in the
538 DHCPNAK, so that the relay agent will broadcast the DHCPNAK to the
539 client, because the client may not have a correct network address
540 or subnet mask, and the client may not be answering ARP requests.
542 o DHCPREQUEST generated during RENEWING state:
544 'server identifier' MUST NOT be filled in, 'requested IP address'
545 option MUST NOT be filled in, 'ciaddr' MUST be filled in with
546 client's IP address. In this situation, the client is completely
547 configured, and is trying to extend its lease. This message will
548 be unicast, so no relay agents will be involved in its
549 transmission. Because 'giaddr' is therefore not filled in, the
550 DHCP server will trust the value in 'ciaddr', and use it when
551 replying to the client.
553 A client MAY choose to renew or extend its lease prior to T1. The
554 server may choose not to extend the lease (as a policy decision by
555 the network administrator), but should return a DHCPACK message
558 o DHCPREQUEST generated during REBINDING state:
560 'server identifier' MUST NOT be filled in, 'requested IP address'
561 option MUST NOT be filled in, 'ciaddr' MUST be filled in with
562 client's IP address. In this situation, the client is completely
563 configured, and is trying to extend its lease. This message MUST
564 be broadcast to the 0xffffffff IP broadcast address. The DHCP
565 server SHOULD check 'ciaddr' for correctness before replying to
568 The DHCPREQUEST from a REBINDING client is intended to accommodate
569 sites that have multiple DHCP servers and a mechanism for
570 maintaining consistency among leases managed by multiple servers.
571 A DHCP server MAY extend a client's lease only if it has local
572 administrative authority to do so.
574 if (!requested_ip_opt) {
575 requested_nip = packet.ciaddr;
576 if (requested_nip == 0) {
577 log1("no requested IP and no ciaddr, ignoring");
581 if (lease && requested_nip == lease->lease_nip) {
582 /* client requested or configured IP matches the lease.
583 * ACK it, and bump lease expiration time. */
584 send_ACK(&packet, lease->lease_nip);
588 /* client was talking specifically to us.
589 * "No, we don't have this IP for you". */
596 * "If the server receives a DHCPDECLINE message,
597 * the client has discovered through some other means
598 * that the suggested network address is already
599 * in use. The server MUST mark the network address
600 * as not available and SHOULD notify the local
601 * sysadmin of a possible configuration problem."
603 * SERVER_ID must be present,
604 * REQUESTED_IP must be present,
605 * chaddr must be filled in,
606 * ciaddr must be 0 (we do not check this)
608 log1("Received DECLINE");
611 && lease /* chaddr matches this lease */
612 && requested_nip == lease->lease_nip
614 memset(lease->lease_mac, 0, sizeof(lease->lease_mac));
615 lease->expires = time(NULL) + server_config.decline_time;
620 /* "Upon receipt of a DHCPRELEASE message, the server
621 * marks the network address as not allocated."
623 * SERVER_ID must be present,
624 * REQUESTED_IP must not be present (we do not check this),
625 * chaddr must be filled in,
626 * ciaddr must be filled in
628 log1("Received RELEASE");
630 && lease /* chaddr matches this lease */
631 && packet.ciaddr == lease->lease_nip
633 lease->expires = time(NULL);
638 log1("Received INFORM");
639 send_inform(&packet);
646 /*if (server_config.pidfile) - server_config.pidfile is never NULL */
647 remove_pidfile(server_config.pidfile);