summaryrefslogtreecommitdiff
path: root/networking/udhcp/dhcpd.c (plain)
blob: e116ba3af4a14baf782fa6125be1a355f0c1e7d0
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//applet:IF_UDHCPD(APPLET(udhcpd, BB_DIR_USR_SBIN, BB_SUID_DROP))
24
25//kbuild:lib-$(CONFIG_UDHCPD) += common.o packet.o signalpipe.o socket.o
26//kbuild:lib-$(CONFIG_UDHCPD) += dhcpd.o arpping.o
27//kbuild:lib-$(CONFIG_FEATURE_UDHCP_RFC3397) += domain_codec.o
28
29//usage:#define udhcpd_trivial_usage
30//usage: "[-fS] [-I ADDR]" IF_FEATURE_UDHCP_PORT(" [-P N]") " [CONFFILE]"
31//usage:#define udhcpd_full_usage "\n\n"
32//usage: "DHCP server\n"
33//usage: "\n -f Run in foreground"
34//usage: "\n -S Log to syslog too"
35//usage: "\n -I ADDR Local address"
36//usage: "\n -a MSEC Timeout for ARP ping (default 2000)"
37//usage: IF_FEATURE_UDHCP_PORT(
38//usage: "\n -P N Use port N (default 67)"
39//usage: )
40
41#include <netinet/ether.h>
42#include <syslog.h>
43#include "common.h"
44#include "dhcpc.h"
45#include "dhcpd.h"
46
47/* globals */
48struct dyn_lease *g_leases;
49/* struct server_config_t server_config is in bb_common_bufsiz1 */
50
51/* Takes the address of the pointer to the static_leases linked list,
52 * address to a 6 byte mac address,
53 * 4 byte IP address */
54static void add_static_lease(struct static_lease **st_lease_pp,
55 uint8_t *mac,
56 uint32_t nip)
57{
58 struct static_lease *st_lease;
59
60 /* Find the tail of the list */
61 while ((st_lease = *st_lease_pp) != NULL) {
62 st_lease_pp = &st_lease->next;
63 }
64
65 /* Add new node */
66 *st_lease_pp = st_lease = xzalloc(sizeof(*st_lease));
67 memcpy(st_lease->mac, mac, 6);
68 st_lease->nip = nip;
69 /*st_lease->next = NULL;*/
70}
71
72/* Find static lease IP by mac */
73static uint32_t get_static_nip_by_mac(struct static_lease *st_lease, void *mac)
74{
75 while (st_lease) {
76 if (memcmp(st_lease->mac, mac, 6) == 0)
77 return st_lease->nip;
78 st_lease = st_lease->next;
79 }
80
81 return 0;
82}
83
84static int is_nip_reserved(struct static_lease *st_lease, uint32_t nip)
85{
86 while (st_lease) {
87 if (st_lease->nip == nip)
88 return 1;
89 st_lease = st_lease->next;
90 }
91
92 return 0;
93}
94
95#if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 2
96/* Print out static leases just to check what's going on */
97/* Takes the address of the pointer to the static_leases linked list */
98static void log_static_leases(struct static_lease **st_lease_pp)
99{
100 struct static_lease *cur;
101
102 if (dhcp_verbose < 2)
103 return;
104
105 cur = *st_lease_pp;
106 while (cur) {
107 bb_error_msg("static lease: mac:%02x:%02x:%02x:%02x:%02x:%02x nip:%x",
108 cur->mac[0], cur->mac[1], cur->mac[2],
109 cur->mac[3], cur->mac[4], cur->mac[5],
110 cur->nip
111 );
112 cur = cur->next;
113 }
114}
115#else
116# define log_static_leases(st_lease_pp) ((void)0)
117#endif
118
119/* Find the oldest expired lease, NULL if there are no expired leases */
120static struct dyn_lease *oldest_expired_lease(void)
121{
122 struct dyn_lease *oldest_lease = NULL;
123 leasetime_t oldest_time = time(NULL);
124 unsigned i;
125
126 /* Unexpired leases have g_leases[i].expires >= current time
127 * and therefore can't ever match */
128 for (i = 0; i < server_config.max_leases; i++) {
129 if (g_leases[i].expires == 0 /* empty entry */
130 || g_leases[i].expires < oldest_time
131 ) {
132 oldest_time = g_leases[i].expires;
133 oldest_lease = &g_leases[i];
134 }
135 }
136 return oldest_lease;
137}
138
139/* Clear out all leases with matching nonzero chaddr OR yiaddr.
140 * If chaddr == NULL, this is a conflict lease.
141 */
142static void clear_leases(const uint8_t *chaddr, uint32_t yiaddr)
143{
144 unsigned i;
145
146 for (i = 0; i < server_config.max_leases; i++) {
147 if ((chaddr && memcmp(g_leases[i].lease_mac, chaddr, 6) == 0)
148 || (yiaddr && g_leases[i].lease_nip == yiaddr)
149 ) {
150 memset(&g_leases[i], 0, sizeof(g_leases[i]));
151 }
152 }
153}
154
155/* Add a lease into the table, clearing out any old ones.
156 * If chaddr == NULL, this is a conflict lease.
157 */
158static struct dyn_lease *add_lease(
159 const uint8_t *chaddr, uint32_t yiaddr,
160 leasetime_t leasetime,
161 const char *hostname, int hostname_len)
162{
163 struct dyn_lease *oldest;
164
165 /* clean out any old ones */
166 clear_leases(chaddr, yiaddr);
167
168 oldest = oldest_expired_lease();
169
170 if (oldest) {
171 memset(oldest, 0, sizeof(*oldest));
172 if (hostname) {
173 char *p;
174
175 hostname_len++; /* include NUL */
176 if (hostname_len > sizeof(oldest->hostname))
177 hostname_len = sizeof(oldest->hostname);
178 p = safe_strncpy(oldest->hostname, hostname, hostname_len);
179 /*
180 * Sanitization (s/bad_char/./g).
181 * The intent is not to allow only "DNS-valid" hostnames,
182 * but merely make dumpleases output safe for shells to use.
183 * We accept "0-9A-Za-z._-", all other chars turn to dots.
184 */
185 while (*p) {
186 if (!isalnum(*p) && *p != '-' && *p != '_')
187 *p = '.';
188 p++;
189 }
190 }
191 if (chaddr)
192 memcpy(oldest->lease_mac, chaddr, 6);
193 oldest->lease_nip = yiaddr;
194 oldest->expires = time(NULL) + leasetime;
195 }
196
197 return oldest;
198}
199
200/* True if a lease has expired */
201static int is_expired_lease(struct dyn_lease *lease)
202{
203 return (lease->expires < (leasetime_t) time(NULL));
204}
205
206/* Find the first lease that matches MAC, NULL if no match */
207static struct dyn_lease *find_lease_by_mac(const uint8_t *mac)
208{
209 unsigned i;
210
211 for (i = 0; i < server_config.max_leases; i++)
212 if (memcmp(g_leases[i].lease_mac, mac, 6) == 0)
213 return &g_leases[i];
214
215 return NULL;
216}
217
218/* Find the first lease that matches IP, NULL is no match */
219static struct dyn_lease *find_lease_by_nip(uint32_t nip)
220{
221 unsigned i;
222
223 for (i = 0; i < server_config.max_leases; i++)
224 if (g_leases[i].lease_nip == nip)
225 return &g_leases[i];
226
227 return NULL;
228}
229
230/* Check if the IP is taken; if it is, add it to the lease table */
231static int nobody_responds_to_arp(uint32_t nip, const uint8_t *safe_mac, unsigned arpping_ms)
232{
233 struct in_addr temp;
234 int r;
235
236 r = arpping(nip, safe_mac,
237 server_config.server_nip,
238 server_config.server_mac,
239 server_config.interface,
240 arpping_ms);
241 if (r)
242 return r;
243
244 temp.s_addr = nip;
245 bb_error_msg("%s belongs to someone, reserving it for %u seconds",
246 inet_ntoa(temp), (unsigned)server_config.conflict_time);
247 add_lease(NULL, nip, server_config.conflict_time, NULL, 0);
248 return 0;
249}
250
251/* Find a new usable (we think) address */
252static uint32_t find_free_or_expired_nip(const uint8_t *safe_mac, unsigned arpping_ms)
253{
254 uint32_t addr;
255 struct dyn_lease *oldest_lease = NULL;
256
257#if ENABLE_FEATURE_UDHCPD_BASE_IP_ON_MAC
258 uint32_t stop;
259 unsigned i, hash;
260
261 /* hash hwaddr: use the SDBM hashing algorithm. Seems to give good
262 * dispersal even with similarly-valued "strings".
263 */
264 hash = 0;
265 for (i = 0; i < 6; i++)
266 hash += safe_mac[i] + (hash << 6) + (hash << 16) - hash;
267
268 /* pick a seed based on hwaddr then iterate until we find a free address. */
269 addr = server_config.start_ip
270 + (hash % (1 + server_config.end_ip - server_config.start_ip));
271 stop = addr;
272#else
273 addr = server_config.start_ip;
274#define stop (server_config.end_ip + 1)
275#endif
276 do {
277 uint32_t nip;
278 struct dyn_lease *lease;
279
280 /* ie, 192.168.55.0 */
281 if ((addr & 0xff) == 0)
282 goto next_addr;
283 /* ie, 192.168.55.255 */
284 if ((addr & 0xff) == 0xff)
285 goto next_addr;
286 nip = htonl(addr);
287 /* skip our own address */
288 if (nip == server_config.server_nip)
289 goto next_addr;
290 /* is this a static lease addr? */
291 if (is_nip_reserved(server_config.static_leases, nip))
292 goto next_addr;
293
294 lease = find_lease_by_nip(nip);
295 if (!lease) {
296//TODO: DHCP servers do not always sit on the same subnet as clients: should *ping*, not arp-ping!
297 if (nobody_responds_to_arp(nip, safe_mac, arpping_ms))
298 return nip;
299 } else {
300 if (!oldest_lease || lease->expires < oldest_lease->expires)
301 oldest_lease = lease;
302 }
303
304 next_addr:
305 addr++;
306#if ENABLE_FEATURE_UDHCPD_BASE_IP_ON_MAC
307 if (addr > server_config.end_ip)
308 addr = server_config.start_ip;
309#endif
310 } while (addr != stop);
311
312 if (oldest_lease
313 && is_expired_lease(oldest_lease)
314 && nobody_responds_to_arp(oldest_lease->lease_nip, safe_mac, arpping_ms)
315 ) {
316 return oldest_lease->lease_nip;
317 }
318
319 return 0;
320}
321
322/* On these functions, make sure your datatype matches */
323static int FAST_FUNC read_str(const char *line, void *arg)
324{
325 char **dest = arg;
326
327 free(*dest);
328 *dest = xstrdup(line);
329 return 1;
330}
331
332static int FAST_FUNC read_u32(const char *line, void *arg)
333{
334 *(uint32_t*)arg = bb_strtou32(line, NULL, 10);
335 return errno == 0;
336}
337
338static int FAST_FUNC read_staticlease(const char *const_line, void *arg)
339{
340 char *line;
341 char *mac_string;
342 char *ip_string;
343 struct ether_addr mac_bytes; /* it's "struct { uint8_t mac[6]; }" */
344 uint32_t nip;
345
346 /* Read mac */
347 line = (char *) const_line;
348 mac_string = strtok_r(line, " \t", &line);
349 if (!mac_string || !ether_aton_r(mac_string, &mac_bytes))
350 return 0;
351
352 /* Read ip */
353 ip_string = strtok_r(NULL, " \t", &line);
354 if (!ip_string || !udhcp_str2nip(ip_string, &nip))
355 return 0;
356
357 add_static_lease(arg, (uint8_t*) &mac_bytes, nip);
358
359 log_static_leases(arg);
360
361 return 1;
362}
363
364struct config_keyword {
365 const char *keyword;
366 int (*handler)(const char *line, void *var) FAST_FUNC;
367 unsigned ofs;
368 const char *def;
369};
370
371#define OFS(field) offsetof(struct server_config_t, field)
372
373static const struct config_keyword keywords[] = {
374 /* keyword handler variable address default */
375 {"start" , udhcp_str2nip , OFS(start_ip ), "192.168.0.20"},
376 {"end" , udhcp_str2nip , OFS(end_ip ), "192.168.0.254"},
377 {"interface" , read_str , OFS(interface ), "eth0"},
378 /* Avoid "max_leases value not sane" warning by setting default
379 * to default_end_ip - default_start_ip + 1: */
380 {"max_leases" , read_u32 , OFS(max_leases ), "235"},
381 {"auto_time" , read_u32 , OFS(auto_time ), "7200"},
382 {"decline_time" , read_u32 , OFS(decline_time ), "3600"},
383 {"conflict_time", read_u32 , OFS(conflict_time), "3600"},
384 {"offer_time" , read_u32 , OFS(offer_time ), "60"},
385 {"min_lease" , read_u32 , OFS(min_lease_sec), "60"},
386 {"lease_file" , read_str , OFS(lease_file ), LEASES_FILE},
387 {"pidfile" , read_str , OFS(pidfile ), "/var/run/udhcpd.pid"},
388 {"siaddr" , udhcp_str2nip , OFS(siaddr_nip ), "0.0.0.0"},
389 /* keywords with no defaults must be last! */
390 {"option" , udhcp_str2optset, OFS(options ), ""},
391 {"opt" , udhcp_str2optset, OFS(options ), ""},
392 {"notify_file" , read_str , OFS(notify_file ), NULL},
393 {"sname" , read_str , OFS(sname ), NULL},
394 {"boot_file" , read_str , OFS(boot_file ), NULL},
395 {"static_lease" , read_staticlease, OFS(static_leases), ""},
396};
397enum { KWS_WITH_DEFAULTS = ARRAY_SIZE(keywords) - 6 };
398
399static NOINLINE void read_config(const char *file)
400{
401 parser_t *parser;
402 const struct config_keyword *k;
403 unsigned i;
404 char *token[2];
405
406 for (i = 0; i < KWS_WITH_DEFAULTS; i++)
407 keywords[i].handler(keywords[i].def, (char*)&server_config + keywords[i].ofs);
408
409 parser = config_open(file);
410 while (config_read(parser, token, 2, 2, "# \t", PARSE_NORMAL)) {
411 for (k = keywords, i = 0; i < ARRAY_SIZE(keywords); k++, i++) {
412 if (strcasecmp(token[0], k->keyword) == 0) {
413 if (!k->handler(token[1], (char*)&server_config + k->ofs)) {
414 bb_error_msg("can't parse line %u in %s",
415 parser->lineno, file);
416 /* reset back to the default value */
417 k->handler(k->def, (char*)&server_config + k->ofs);
418 }
419 break;
420 }
421 }
422 }
423 config_close(parser);
424
425 server_config.start_ip = ntohl(server_config.start_ip);
426 server_config.end_ip = ntohl(server_config.end_ip);
427}
428
429static void write_leases(void)
430{
431 int fd;
432 unsigned i;
433 leasetime_t curr;
434 int64_t written_at;
435
436 fd = open_or_warn(server_config.lease_file, O_WRONLY|O_CREAT|O_TRUNC);
437 if (fd < 0)
438 return;
439
440 curr = written_at = time(NULL);
441
442 written_at = SWAP_BE64(written_at);
443 full_write(fd, &written_at, sizeof(written_at));
444
445 for (i = 0; i < server_config.max_leases; i++) {
446 leasetime_t tmp_time;
447
448 if (g_leases[i].lease_nip == 0)
449 continue;
450
451 /* Screw with the time in the struct, for easier writing */
452 tmp_time = g_leases[i].expires;
453
454 g_leases[i].expires -= curr;
455 if ((signed_leasetime_t) g_leases[i].expires < 0)
456 g_leases[i].expires = 0;
457 g_leases[i].expires = htonl(g_leases[i].expires);
458
459 /* No error check. If the file gets truncated,
460 * we lose some leases on restart. Oh well. */
461 full_write(fd, &g_leases[i], sizeof(g_leases[i]));
462
463 /* Then restore it when done */
464 g_leases[i].expires = tmp_time;
465 }
466 close(fd);
467
468 if (server_config.notify_file) {
469 char *argv[3];
470 argv[0] = server_config.notify_file;
471 argv[1] = server_config.lease_file;
472 argv[2] = NULL;
473 spawn_and_wait(argv);
474 }
475}
476
477static NOINLINE void read_leases(const char *file)
478{
479 struct dyn_lease lease;
480 int64_t written_at, time_passed;
481 int fd;
482#if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
483 unsigned i = 0;
484#endif
485
486 fd = open_or_warn(file, O_RDONLY);
487 if (fd < 0)
488 return;
489
490 if (full_read(fd, &written_at, sizeof(written_at)) != sizeof(written_at))
491 goto ret;
492 written_at = SWAP_BE64(written_at);
493
494 time_passed = time(NULL) - written_at;
495 /* Strange written_at, or lease file from old version of udhcpd
496 * which had no "written_at" field? */
497 if ((uint64_t)time_passed > 12 * 60 * 60)
498 goto ret;
499
500 while (full_read(fd, &lease, sizeof(lease)) == sizeof(lease)) {
501 uint32_t y = ntohl(lease.lease_nip);
502 if (y >= server_config.start_ip && y <= server_config.end_ip) {
503 signed_leasetime_t expires = ntohl(lease.expires) - (signed_leasetime_t)time_passed;
504 uint32_t static_nip;
505
506 if (expires <= 0)
507 /* We keep expired leases: add_lease() will add
508 * a lease with 0 seconds remaining.
509 * Fewer IP address changes this way for mass reboot scenario.
510 */
511 expires = 0;
512
513 /* Check if there is a different static lease for this IP or MAC */
514 static_nip = get_static_nip_by_mac(server_config.static_leases, lease.lease_mac);
515 if (static_nip) {
516 /* NB: we do not add lease even if static_nip == lease.lease_nip.
517 */
518 continue;
519 }
520 if (is_nip_reserved(server_config.static_leases, lease.lease_nip))
521 continue;
522
523 /* NB: add_lease takes "relative time", IOW,
524 * lease duration, not lease deadline. */
525 if (add_lease(lease.lease_mac, lease.lease_nip,
526 expires,
527 lease.hostname, sizeof(lease.hostname)
528 ) == 0
529 ) {
530 bb_error_msg("too many leases while loading %s", file);
531 break;
532 }
533#if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
534 i++;
535#endif
536 }
537 }
538 log1("read %d leases", i);
539 ret:
540 close(fd);
541}
542
543/* Send a packet to a specific mac address and ip address by creating our own ip packet */
544static void send_packet_to_client(struct dhcp_packet *dhcp_pkt, int force_broadcast)
545{
546 const uint8_t *chaddr;
547 uint32_t ciaddr;
548
549 // Was:
550 //if (force_broadcast) { /* broadcast */ }
551 //else if (dhcp_pkt->ciaddr) { /* unicast to dhcp_pkt->ciaddr */ }
552 //else if (dhcp_pkt->flags & htons(BROADCAST_FLAG)) { /* broadcast */ }
553 //else { /* unicast to dhcp_pkt->yiaddr */ }
554 // But this is wrong: yiaddr is _our_ idea what client's IP is
555 // (for example, from lease file). Client may not know that,
556 // and may not have UDP socket listening on that IP!
557 // We should never unicast to dhcp_pkt->yiaddr!
558 // dhcp_pkt->ciaddr, OTOH, comes from client's request packet,
559 // and can be used.
560
561 if (force_broadcast
562 || (dhcp_pkt->flags & htons(BROADCAST_FLAG))
563 || dhcp_pkt->ciaddr == 0
564 ) {
565 log1("broadcasting packet to client");
566 ciaddr = INADDR_BROADCAST;
567 chaddr = MAC_BCAST_ADDR;
568 } else {
569 log1("unicasting packet to client ciaddr");
570 ciaddr = dhcp_pkt->ciaddr;
571 chaddr = dhcp_pkt->chaddr;
572 }
573
574 udhcp_send_raw_packet(dhcp_pkt,
575 /*src*/ server_config.server_nip, SERVER_PORT,
576 /*dst*/ ciaddr, CLIENT_PORT, chaddr,
577 server_config.ifindex);
578}
579
580/* Send a packet to gateway_nip using the kernel ip stack */
581static void send_packet_to_relay(struct dhcp_packet *dhcp_pkt)
582{
583 log1("forwarding packet to relay");
584
585 udhcp_send_kernel_packet(dhcp_pkt,
586 server_config.server_nip, SERVER_PORT,
587 dhcp_pkt->gateway_nip, SERVER_PORT);
588}
589
590static void send_packet(struct dhcp_packet *dhcp_pkt, int force_broadcast)
591{
592 if (dhcp_pkt->gateway_nip)
593 send_packet_to_relay(dhcp_pkt);
594 else
595 send_packet_to_client(dhcp_pkt, force_broadcast);
596}
597
598static void init_packet(struct dhcp_packet *packet, struct dhcp_packet *oldpacket, char type)
599{
600 /* Sets op, htype, hlen, cookie fields
601 * and adds DHCP_MESSAGE_TYPE option */
602 udhcp_init_header(packet, type);
603
604 packet->xid = oldpacket->xid;
605 memcpy(packet->chaddr, oldpacket->chaddr, sizeof(oldpacket->chaddr));
606 packet->flags = oldpacket->flags;
607 packet->gateway_nip = oldpacket->gateway_nip;
608 packet->ciaddr = oldpacket->ciaddr;
609 udhcp_add_simple_option(packet, DHCP_SERVER_ID, server_config.server_nip);
610}
611
612/* Fill options field, siaddr_nip, and sname and boot_file fields.
613 * TODO: teach this code to use overload option.
614 */
615static void add_server_options(struct dhcp_packet *packet)
616{
617 struct option_set *curr = server_config.options;
618
619 while (curr) {
620 if (curr->data[OPT_CODE] != DHCP_LEASE_TIME)
621 udhcp_add_binary_option(packet, curr->data);
622 curr = curr->next;
623 }
624
625 packet->siaddr_nip = server_config.siaddr_nip;
626
627 if (server_config.sname)
628 strncpy((char*)packet->sname, server_config.sname, sizeof(packet->sname) - 1);
629 if (server_config.boot_file)
630 strncpy((char*)packet->file, server_config.boot_file, sizeof(packet->file) - 1);
631}
632
633static uint32_t select_lease_time(struct dhcp_packet *packet)
634{
635 uint32_t lease_time_sec = server_config.max_lease_sec;
636 uint8_t *lease_time_opt = udhcp_get_option(packet, DHCP_LEASE_TIME);
637 if (lease_time_opt) {
638 move_from_unaligned32(lease_time_sec, lease_time_opt);
639 lease_time_sec = ntohl(lease_time_sec);
640 if (lease_time_sec > server_config.max_lease_sec)
641 lease_time_sec = server_config.max_lease_sec;
642 if (lease_time_sec < server_config.min_lease_sec)
643 lease_time_sec = server_config.min_lease_sec;
644 }
645 return lease_time_sec;
646}
647
648/* We got a DHCP DISCOVER. Send an OFFER. */
649/* NOINLINE: limit stack usage in caller */
650static NOINLINE void send_offer(struct dhcp_packet *oldpacket,
651 uint32_t static_lease_nip,
652 struct dyn_lease *lease,
653 uint8_t *requested_ip_opt,
654 unsigned arpping_ms)
655{
656 struct dhcp_packet packet;
657 uint32_t lease_time_sec;
658 struct in_addr addr;
659
660 init_packet(&packet, oldpacket, DHCPOFFER);
661
662 /* If it is a static lease, use its IP */
663 packet.yiaddr = static_lease_nip;
664 /* Else: */
665 if (!static_lease_nip) {
666 /* We have no static lease for client's chaddr */
667 uint32_t req_nip;
668 const char *p_host_name;
669
670 if (lease) {
671 /* We have a dynamic lease for client's chaddr.
672 * Reuse its IP (even if lease is expired).
673 * Note that we ignore requested IP in this case.
674 */
675 packet.yiaddr = lease->lease_nip;
676 }
677 /* Or: if client has requested an IP */
678 else if (requested_ip_opt != NULL
679 /* (read IP) */
680 && (move_from_unaligned32(req_nip, requested_ip_opt), 1)
681 /* and the IP is in the lease range */
682 && ntohl(req_nip) >= server_config.start_ip
683 && ntohl(req_nip) <= server_config.end_ip
684 /* and */
685 && ( !(lease = find_lease_by_nip(req_nip)) /* is not already taken */
686 || is_expired_lease(lease) /* or is taken, but expired */
687 )
688 ) {
689 packet.yiaddr = req_nip;
690 }
691 else {
692 /* Otherwise, find a free IP */
693 packet.yiaddr = find_free_or_expired_nip(oldpacket->chaddr, arpping_ms);
694 }
695
696 if (!packet.yiaddr) {
697 bb_error_msg("no free IP addresses. OFFER abandoned");
698 return;
699 }
700 /* Reserve the IP for a short time hoping to get DHCPREQUEST soon */
701 p_host_name = (const char*) udhcp_get_option(oldpacket, DHCP_HOST_NAME);
702 lease = add_lease(packet.chaddr, packet.yiaddr,
703 server_config.offer_time,
704 p_host_name,
705 p_host_name ? (unsigned char)p_host_name[OPT_LEN - OPT_DATA] : 0
706 );
707 if (!lease) {
708 bb_error_msg("no free IP addresses. OFFER abandoned");
709 return;
710 }
711 }
712
713 lease_time_sec = select_lease_time(oldpacket);
714 udhcp_add_simple_option(&packet, DHCP_LEASE_TIME, htonl(lease_time_sec));
715 add_server_options(&packet);
716
717 addr.s_addr = packet.yiaddr;
718 bb_error_msg("sending OFFER of %s", inet_ntoa(addr));
719 /* send_packet emits error message itself if it detects failure */
720 send_packet(&packet, /*force_bcast:*/ 0);
721}
722
723/* NOINLINE: limit stack usage in caller */
724static NOINLINE void send_NAK(struct dhcp_packet *oldpacket)
725{
726 struct dhcp_packet packet;
727
728 init_packet(&packet, oldpacket, DHCPNAK);
729
730 log1("sending %s", "NAK");
731 send_packet(&packet, /*force_bcast:*/ 1);
732}
733
734/* NOINLINE: limit stack usage in caller */
735static NOINLINE void send_ACK(struct dhcp_packet *oldpacket, uint32_t yiaddr)
736{
737 struct dhcp_packet packet;
738 uint32_t lease_time_sec;
739 struct in_addr addr;
740 const char *p_host_name;
741
742 init_packet(&packet, oldpacket, DHCPACK);
743 packet.yiaddr = yiaddr;
744
745 lease_time_sec = select_lease_time(oldpacket);
746 udhcp_add_simple_option(&packet, DHCP_LEASE_TIME, htonl(lease_time_sec));
747
748 add_server_options(&packet);
749
750 addr.s_addr = yiaddr;
751 bb_error_msg("sending ACK to %s", inet_ntoa(addr));
752 send_packet(&packet, /*force_bcast:*/ 0);
753
754 p_host_name = (const char*) udhcp_get_option(oldpacket, DHCP_HOST_NAME);
755 add_lease(packet.chaddr, packet.yiaddr,
756 lease_time_sec,
757 p_host_name,
758 p_host_name ? (unsigned char)p_host_name[OPT_LEN - OPT_DATA] : 0
759 );
760 if (ENABLE_FEATURE_UDHCPD_WRITE_LEASES_EARLY) {
761 /* rewrite the file with leases at every new acceptance */
762 write_leases();
763 }
764}
765
766/* NOINLINE: limit stack usage in caller */
767static NOINLINE void send_inform(struct dhcp_packet *oldpacket)
768{
769 struct dhcp_packet packet;
770
771 /* "If a client has obtained a network address through some other means
772 * (e.g., manual configuration), it may use a DHCPINFORM request message
773 * to obtain other local configuration parameters. Servers receiving a
774 * DHCPINFORM message construct a DHCPACK message with any local
775 * configuration parameters appropriate for the client without:
776 * allocating a new address, checking for an existing binding, filling
777 * in 'yiaddr' or including lease time parameters. The servers SHOULD
778 * unicast the DHCPACK reply to the address given in the 'ciaddr' field
779 * of the DHCPINFORM message.
780 * ...
781 * The server responds to a DHCPINFORM message by sending a DHCPACK
782 * message directly to the address given in the 'ciaddr' field
783 * of the DHCPINFORM message. The server MUST NOT send a lease
784 * expiration time to the client and SHOULD NOT fill in 'yiaddr'."
785 */
786//TODO: do a few sanity checks: is ciaddr set?
787//Better yet: is ciaddr == IP source addr?
788 init_packet(&packet, oldpacket, DHCPACK);
789 add_server_options(&packet);
790
791 send_packet(&packet, /*force_bcast:*/ 0);
792}
793
794int udhcpd_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
795int udhcpd_main(int argc UNUSED_PARAM, char **argv)
796{
797 int server_socket = -1, retval, max_sock;
798 uint8_t *state;
799 unsigned timeout_end;
800 unsigned num_ips;
801 unsigned opt;
802 struct option_set *option;
803 char *str_I = str_I;
804 const char *str_a = "2000";
805 unsigned arpping_ms;
806 IF_FEATURE_UDHCP_PORT(char *str_P;)
807
808 setup_common_bufsiz();
809
810 IF_FEATURE_UDHCP_PORT(SERVER_PORT = 67;)
811 IF_FEATURE_UDHCP_PORT(CLIENT_PORT = 68;)
812
813#if defined CONFIG_UDHCP_DEBUG && CONFIG_UDHCP_DEBUG >= 1
814 opt_complementary = "vv";
815#endif
816 opt = getopt32(argv, "fSI:va:"
817 IF_FEATURE_UDHCP_PORT("P:")
818 , &str_I
819 , &str_a
820 IF_FEATURE_UDHCP_PORT(, &str_P)
821 IF_UDHCP_VERBOSE(, &dhcp_verbose)
822 );
823 if (!(opt & 1)) { /* no -f */
824 bb_daemonize_or_rexec(0, argv);
825 logmode = LOGMODE_NONE;
826 }
827 /* update argv after the possible vfork+exec in daemonize */
828 argv += optind;
829 if (opt & 2) { /* -S */
830 openlog(applet_name, LOG_PID, LOG_DAEMON);
831 logmode |= LOGMODE_SYSLOG;
832 }
833 if (opt & 4) { /* -I */
834 len_and_sockaddr *lsa = xhost_and_af2sockaddr(str_I, 0, AF_INET);
835 server_config.server_nip = lsa->u.sin.sin_addr.s_addr;
836 free(lsa);
837 }
838#if ENABLE_FEATURE_UDHCP_PORT
839 if (opt & 32) { /* -P */
840 SERVER_PORT = xatou16(str_P);
841 CLIENT_PORT = SERVER_PORT + 1;
842 }
843#endif
844 arpping_ms = xatou(str_a);
845
846 /* Would rather not do read_config before daemonization -
847 * otherwise NOMMU machines will parse config twice */
848 read_config(argv[0] ? argv[0] : DHCPD_CONF_FILE);
849
850 /* Make sure fd 0,1,2 are open */
851 bb_sanitize_stdio();
852 /* Equivalent of doing a fflush after every \n */
853 setlinebuf(stdout);
854
855 /* Create pidfile */
856 write_pidfile(server_config.pidfile);
857 /* if (!..) bb_perror_msg("can't create pidfile %s", pidfile); */
858
859 bb_error_msg("started, v"BB_VER);
860
861 option = udhcp_find_option(server_config.options, DHCP_LEASE_TIME);
862 server_config.max_lease_sec = DEFAULT_LEASE_TIME;
863 if (option) {
864 move_from_unaligned32(server_config.max_lease_sec, option->data + OPT_DATA);
865 server_config.max_lease_sec = ntohl(server_config.max_lease_sec);
866 }
867
868 /* Sanity check */
869 num_ips = server_config.end_ip - server_config.start_ip + 1;
870 if (server_config.max_leases > num_ips) {
871 bb_error_msg("max_leases=%u is too big, setting to %u",
872 (unsigned)server_config.max_leases, num_ips);
873 server_config.max_leases = num_ips;
874 }
875
876 g_leases = xzalloc(server_config.max_leases * sizeof(g_leases[0]));
877 read_leases(server_config.lease_file);
878
879 if (udhcp_read_interface(server_config.interface,
880 &server_config.ifindex,
881 (server_config.server_nip == 0 ? &server_config.server_nip : NULL),
882 server_config.server_mac)
883 ) {
884 retval = 1;
885 goto ret;
886 }
887
888 /* Setup the signal pipe */
889 udhcp_sp_setup();
890
891 continue_with_autotime:
892 timeout_end = monotonic_sec() + server_config.auto_time;
893 while (1) { /* loop until universe collapses */
894 fd_set rfds;
895 struct dhcp_packet packet;
896 int bytes;
897 struct timeval tv;
898 uint8_t *server_id_opt;
899 uint8_t *requested_ip_opt;
900 uint32_t requested_nip = requested_nip; /* for compiler */
901 uint32_t static_lease_nip;
902 struct dyn_lease *lease, fake_lease;
903
904 if (server_socket < 0) {
905 server_socket = udhcp_listen_socket(/*INADDR_ANY,*/ SERVER_PORT,
906 server_config.interface);
907 }
908
909 max_sock = udhcp_sp_fd_set(&rfds, server_socket);
910 if (server_config.auto_time) {
911 /* cast to signed is essential if tv_sec is wider than int */
912 tv.tv_sec = (int)(timeout_end - monotonic_sec());
913 tv.tv_usec = 0;
914 }
915 retval = 0;
916 if (!server_config.auto_time || tv.tv_sec > 0) {
917 retval = select(max_sock + 1, &rfds, NULL, NULL,
918 server_config.auto_time ? &tv : NULL);
919 }
920 if (retval == 0) {
921 write_leases();
922 goto continue_with_autotime;
923 }
924 if (retval < 0 && errno != EINTR) {
925 log1("error on select");
926 continue;
927 }
928
929 switch (udhcp_sp_read(&rfds)) {
930 case SIGUSR1:
931 bb_error_msg("received %s", "SIGUSR1");
932 write_leases();
933 /* why not just reset the timeout, eh */
934 goto continue_with_autotime;
935 case SIGTERM:
936 bb_error_msg("received %s", "SIGTERM");
937 write_leases();
938 goto ret0;
939 case 0: /* no signal: read a packet */
940 break;
941 default: /* signal or error (probably EINTR): back to select */
942 continue;
943 }
944
945 bytes = udhcp_recv_kernel_packet(&packet, server_socket);
946 if (bytes < 0) {
947 /* bytes can also be -2 ("bad packet data") */
948 if (bytes == -1 && errno != EINTR) {
949 log1("read error: %s, reopening socket", strerror(errno));
950 close(server_socket);
951 server_socket = -1;
952 }
953 continue;
954 }
955 if (packet.hlen != 6) {
956 bb_error_msg("MAC length != 6, ignoring packet");
957 continue;
958 }
959 if (packet.op != BOOTREQUEST) {
960 bb_error_msg("not a REQUEST, ignoring packet");
961 continue;
962 }
963 state = udhcp_get_option(&packet, DHCP_MESSAGE_TYPE);
964 if (state == NULL || state[0] < DHCP_MINTYPE || state[0] > DHCP_MAXTYPE) {
965 bb_error_msg("no or bad message type option, ignoring packet");
966 continue;
967 }
968
969 /* Get SERVER_ID if present */
970 server_id_opt = udhcp_get_option(&packet, DHCP_SERVER_ID);
971 if (server_id_opt) {
972 uint32_t server_id_network_order;
973 move_from_unaligned32(server_id_network_order, server_id_opt);
974 if (server_id_network_order != server_config.server_nip) {
975 /* client talks to somebody else */
976 log1("server ID doesn't match, ignoring");
977 continue;
978 }
979 }
980
981 /* Look for a static/dynamic lease */
982 static_lease_nip = get_static_nip_by_mac(server_config.static_leases, &packet.chaddr);
983 if (static_lease_nip) {
984 bb_error_msg("found static lease: %x", static_lease_nip);
985 memcpy(&fake_lease.lease_mac, &packet.chaddr, 6);
986 fake_lease.lease_nip = static_lease_nip;
987 fake_lease.expires = 0;
988 lease = &fake_lease;
989 } else {
990 lease = find_lease_by_mac(packet.chaddr);
991 }
992
993 /* Get REQUESTED_IP if present */
994 requested_ip_opt = udhcp_get_option(&packet, DHCP_REQUESTED_IP);
995 if (requested_ip_opt) {
996 move_from_unaligned32(requested_nip, requested_ip_opt);
997 }
998
999 switch (state[0]) {
1000
1001 case DHCPDISCOVER:
1002 log1("received %s", "DISCOVER");
1003
1004 send_offer(&packet, static_lease_nip, lease, requested_ip_opt, arpping_ms);
1005 break;
1006
1007 case DHCPREQUEST:
1008 log1("received %s", "REQUEST");
1009/* RFC 2131:
1010
1011o DHCPREQUEST generated during SELECTING state:
1012
1013 Client inserts the address of the selected server in 'server
1014 identifier', 'ciaddr' MUST be zero, 'requested IP address' MUST be
1015 filled in with the yiaddr value from the chosen DHCPOFFER.
1016
1017 Note that the client may choose to collect several DHCPOFFER
1018 messages and select the "best" offer. The client indicates its
1019 selection by identifying the offering server in the DHCPREQUEST
1020 message. If the client receives no acceptable offers, the client
1021 may choose to try another DHCPDISCOVER message. Therefore, the
1022 servers may not receive a specific DHCPREQUEST from which they can
1023 decide whether or not the client has accepted the offer.
1024
1025o DHCPREQUEST generated during INIT-REBOOT state:
1026
1027 'server identifier' MUST NOT be filled in, 'requested IP address'
1028 option MUST be filled in with client's notion of its previously
1029 assigned address. 'ciaddr' MUST be zero. The client is seeking to
1030 verify a previously allocated, cached configuration. Server SHOULD
1031 send a DHCPNAK message to the client if the 'requested IP address'
1032 is incorrect, or is on the wrong network.
1033
1034 Determining whether a client in the INIT-REBOOT state is on the
1035 correct network is done by examining the contents of 'giaddr', the
1036 'requested IP address' option, and a database lookup. If the DHCP
1037 server detects that the client is on the wrong net (i.e., the
1038 result of applying the local subnet mask or remote subnet mask (if
1039 'giaddr' is not zero) to 'requested IP address' option value
1040 doesn't match reality), then the server SHOULD send a DHCPNAK
1041 message to the client.
1042
1043 If the network is correct, then the DHCP server should check if
1044 the client's notion of its IP address is correct. If not, then the
1045 server SHOULD send a DHCPNAK message to the client. If the DHCP
1046 server has no record of this client, then it MUST remain silent,
1047 and MAY output a warning to the network administrator. This
1048 behavior is necessary for peaceful coexistence of non-
1049 communicating DHCP servers on the same wire.
1050
1051 If 'giaddr' is 0x0 in the DHCPREQUEST message, the client is on
1052 the same subnet as the server. The server MUST broadcast the
1053 DHCPNAK message to the 0xffffffff broadcast address because the
1054 client may not have a correct network address or subnet mask, and
1055 the client may not be answering ARP requests.
1056
1057 If 'giaddr' is set in the DHCPREQUEST message, the client is on a
1058 different subnet. The server MUST set the broadcast bit in the
1059 DHCPNAK, so that the relay agent will broadcast the DHCPNAK to the
1060 client, because the client may not have a correct network address
1061 or subnet mask, and the client may not be answering ARP requests.
1062
1063o DHCPREQUEST generated during RENEWING state:
1064
1065 'server identifier' MUST NOT be filled in, 'requested IP address'
1066 option MUST NOT be filled in, 'ciaddr' MUST be filled in with
1067 client's IP address. In this situation, the client is completely
1068 configured, and is trying to extend its lease. This message will
1069 be unicast, so no relay agents will be involved in its
1070 transmission. Because 'giaddr' is therefore not filled in, the
1071 DHCP server will trust the value in 'ciaddr', and use it when
1072 replying to the client.
1073
1074 A client MAY choose to renew or extend its lease prior to T1. The
1075 server may choose not to extend the lease (as a policy decision by
1076 the network administrator), but should return a DHCPACK message
1077 regardless.
1078
1079o DHCPREQUEST generated during REBINDING state:
1080
1081 'server identifier' MUST NOT be filled in, 'requested IP address'
1082 option MUST NOT be filled in, 'ciaddr' MUST be filled in with
1083 client's IP address. In this situation, the client is completely
1084 configured, and is trying to extend its lease. This message MUST
1085 be broadcast to the 0xffffffff IP broadcast address. The DHCP
1086 server SHOULD check 'ciaddr' for correctness before replying to
1087 the DHCPREQUEST.
1088
1089 The DHCPREQUEST from a REBINDING client is intended to accommodate
1090 sites that have multiple DHCP servers and a mechanism for
1091 maintaining consistency among leases managed by multiple servers.
1092 A DHCP server MAY extend a client's lease only if it has local
1093 administrative authority to do so.
1094*/
1095 if (!requested_ip_opt) {
1096 requested_nip = packet.ciaddr;
1097 if (requested_nip == 0) {
1098 log1("no requested IP and no ciaddr, ignoring");
1099 break;
1100 }
1101 }
1102 if (lease && requested_nip == lease->lease_nip) {
1103 /* client requested or configured IP matches the lease.
1104 * ACK it, and bump lease expiration time. */
1105 send_ACK(&packet, lease->lease_nip);
1106 break;
1107 }
1108 /* No lease for this MAC, or lease IP != requested IP */
1109
1110 if (server_id_opt /* client is in SELECTING state */
1111 || requested_ip_opt /* client is in INIT-REBOOT state */
1112 ) {
1113 /* "No, we don't have this IP for you" */
1114 send_NAK(&packet);
1115 } /* else: client is in RENEWING or REBINDING, do not answer */
1116
1117 break;
1118
1119 case DHCPDECLINE:
1120 /* RFC 2131:
1121 * "If the server receives a DHCPDECLINE message,
1122 * the client has discovered through some other means
1123 * that the suggested network address is already
1124 * in use. The server MUST mark the network address
1125 * as not available and SHOULD notify the local
1126 * sysadmin of a possible configuration problem."
1127 *
1128 * SERVER_ID must be present,
1129 * REQUESTED_IP must be present,
1130 * chaddr must be filled in,
1131 * ciaddr must be 0 (we do not check this)
1132 */
1133 log1("received %s", "DECLINE");
1134 if (server_id_opt
1135 && requested_ip_opt
1136 && lease /* chaddr matches this lease */
1137 && requested_nip == lease->lease_nip
1138 ) {
1139 memset(lease->lease_mac, 0, sizeof(lease->lease_mac));
1140 lease->expires = time(NULL) + server_config.decline_time;
1141 }
1142 break;
1143
1144 case DHCPRELEASE:
1145 /* "Upon receipt of a DHCPRELEASE message, the server
1146 * marks the network address as not allocated."
1147 *
1148 * SERVER_ID must be present,
1149 * REQUESTED_IP must not be present (we do not check this),
1150 * chaddr must be filled in,
1151 * ciaddr must be filled in
1152 */
1153 log1("received %s", "RELEASE");
1154 if (server_id_opt
1155 && lease /* chaddr matches this lease */
1156 && packet.ciaddr == lease->lease_nip
1157 ) {
1158 lease->expires = time(NULL);
1159 }
1160 break;
1161
1162 case DHCPINFORM:
1163 log1("received %s", "INFORM");
1164 send_inform(&packet);
1165 break;
1166 }
1167 }
1168 ret0:
1169 retval = 0;
1170 ret:
1171 /*if (server_config.pidfile) - server_config.pidfile is never NULL */
1172 remove_pidfile(server_config.pidfile);
1173 return retval;
1174}
1175
generated by cgit at 2024-05-15 23:51:19 (GMT)