?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import dhcpcd-10.0.2 with the following changes:
[dragonfly.git] / contrib / dhcpcd / src / dhcpcd.c
blobe06733d318bc30ad6f5af7af849a2067224b9d4f
1 /* SPDX-License-Identifier: BSD-2-Clause */
2 /*
3 * dhcpcd - DHCP client daemon
4 * Copyright (c) 2006-2023 Roy Marples <roy@marples.name>
5 * All rights reserved
6
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
29 static const char dhcpcd_copyright[] = "Copyright (c) 2006-2023 Roy Marples";
30
31 #include <sys/file.h>
32 #include <sys/ioctl.h>
33 #include <sys/socket.h>
34 #include <sys/stat.h>
35 #include <sys/time.h>
36 #include <sys/types.h>
37 #include <sys/uio.h>
38 #include <sys/wait.h>
39
40 #include <ctype.h>
41 #include <errno.h>
42 #include <fcntl.h>
43 #include <getopt.h>
44 #include <limits.h>
45 #include <paths.h>
46 #include <signal.h>
47 #include <stdio.h>
48 #include <stdlib.h>
49 #include <string.h>
50 #include <syslog.h>
51 #include <unistd.h>
52 #include <time.h>
53
54 #include "config.h"
55 #include "arp.h"
56 #include "common.h"
57 #include "control.h"
58 #include "dev.h"
59 #include "dhcp-common.h"
60 #include "dhcpcd.h"
61 #include "dhcp.h"
62 #include "dhcp6.h"
63 #include "duid.h"
64 #include "eloop.h"
65 #include "if.h"
66 #include "if-options.h"
67 #include "ipv4.h"
68 #include "ipv4ll.h"
69 #include "ipv6.h"
70 #include "ipv6nd.h"
71 #include "logerr.h"
72 #include "privsep.h"
73 #include "script.h"
74
75 #ifdef HAVE_CAPSICUM
76 #include <sys/capsicum.h>
77 #endif
78 #ifdef HAVE_UTIL_H
79 #include <util.h>
80 #endif
81
82 #ifdef USE_SIGNALS
83 const int dhcpcd_signals[] = {
84 SIGTERM,
85 SIGINT,
86 SIGALRM,
87 SIGHUP,
88 SIGUSR1,
89 SIGUSR2,
90 SIGCHLD,
91 };
92 const size_t dhcpcd_signals_len = __arraycount(dhcpcd_signals);
93
94 const int dhcpcd_signals_ignore[] = {
95 SIGPIPE,
96 };
97 const size_t dhcpcd_signals_ignore_len = __arraycount(dhcpcd_signals_ignore);
98 #endif
99
100 const char *dhcpcd_default_script = SCRIPT;
101
102 static void
103 usage(void)
104 {
105
106 printf("usage: "PACKAGE"\t[-146ABbDdEGgHJKLMNPpqTV]\n"
107 "\t\t[-C, --nohook hook] [-c, --script script]\n"
108 "\t\t[-e, --env value] [-F, --fqdn FQDN] [-f, --config file]\n"
109 "\t\t[-h, --hostname hostname] [-I, --clientid clientid]\n"
110 "\t\t[-i, --vendorclassid vendorclassid] [-j, --logfile logfile]\n"
111 "\t\t[-l, --leasetime seconds] [-m, --metric metric]\n"
112 "\t\t[-O, --nooption option] [-o, --option option]\n"
113 "\t\t[-Q, --require option] [-r, --request address]\n"
114 "\t\t[-S, --static value]\n"
115 "\t\t[-s, --inform address[/cidr[/broadcast_address]]]\n [--inform6]"
116 "\t\t[-t, --timeout seconds] [-u, --userclass class]\n"
117 "\t\t[-v, --vendor code, value] [-W, --whitelist address[/cidr]] [-w]\n"
118 "\t\t[--waitip [4 | 6]] [-y, --reboot seconds]\n"
119 "\t\t[-X, --blacklist address[/cidr]] [-Z, --denyinterfaces pattern]\n"
120 "\t\t[-z, --allowinterfaces pattern] [--inactive] [interface] [...]\n"
121 " "PACKAGE"\t-n, --rebind [interface]\n"
122 " "PACKAGE"\t-k, --release [interface]\n"
123 " "PACKAGE"\t-U, --dumplease interface\n"
124 " "PACKAGE"\t--version\n"
125 " "PACKAGE"\t-x, --exit [interface]\n");
126 }
127
128 static void
129 free_globals(struct dhcpcd_ctx *ctx)
130 {
131 struct dhcp_opt *opt;
132
133 if (ctx->ifac) {
134 for (; ctx->ifac > 0; ctx->ifac--)
135 free(ctx->ifav[ctx->ifac - 1]);
136 free(ctx->ifav);
137 ctx->ifav = NULL;
138 }
139 if (ctx->ifdc) {
140 for (; ctx->ifdc > 0; ctx->ifdc--)
141 free(ctx->ifdv[ctx->ifdc - 1]);
142 free(ctx->ifdv);
143 ctx->ifdv = NULL;
144 }
145 if (ctx->ifcc) {
146 for (; ctx->ifcc > 0; ctx->ifcc--)
147 free(ctx->ifcv[ctx->ifcc - 1]);
148 free(ctx->ifcv);
149 ctx->ifcv = NULL;
150 }
151
152 #ifdef INET
153 if (ctx->dhcp_opts) {
154 for (opt = ctx->dhcp_opts;
155 ctx->dhcp_opts_len > 0;
156 opt++, ctx->dhcp_opts_len--)
157 free_dhcp_opt_embenc(opt);
158 free(ctx->dhcp_opts);
159 ctx->dhcp_opts = NULL;
160 }
161 #endif
162 #ifdef INET6
163 if (ctx->nd_opts) {
164 for (opt = ctx->nd_opts;
165 ctx->nd_opts_len > 0;
166 opt++, ctx->nd_opts_len--)
167 free_dhcp_opt_embenc(opt);
168 free(ctx->nd_opts);
169 ctx->nd_opts = NULL;
170 }
171 #ifdef DHCP6
172 if (ctx->dhcp6_opts) {
173 for (opt = ctx->dhcp6_opts;
174 ctx->dhcp6_opts_len > 0;
175 opt++, ctx->dhcp6_opts_len--)
176 free_dhcp_opt_embenc(opt);
177 free(ctx->dhcp6_opts);
178 ctx->dhcp6_opts = NULL;
179 }
180 #endif
181 #endif
182 if (ctx->vivso) {
183 for (opt = ctx->vivso;
184 ctx->vivso_len > 0;
185 opt++, ctx->vivso_len--)
186 free_dhcp_opt_embenc(opt);
187 free(ctx->vivso);
188 ctx->vivso = NULL;
189 }
190 }
191
192 static void
193 handle_exit_timeout(void *arg)
194 {
195 struct dhcpcd_ctx *ctx;
196
197 ctx = arg;
198 logerrx("timed out");
199 if (!(ctx->options & DHCPCD_MANAGER)) {
200 struct interface *ifp;
201
202 TAILQ_FOREACH(ifp, ctx->ifaces, next) {
203 if (ifp->active == IF_ACTIVE_USER)
204 script_runreason(ifp, "STOPPED");
205 }
206 eloop_exit(ctx->eloop, EXIT_FAILURE);
207 return;
208 }
209 ctx->options |= DHCPCD_NOWAITIP;
210 dhcpcd_daemonise(ctx);
211 }
212
213 static const char *
214 dhcpcd_af(int af)
215 {
216
217 switch (af) {
218 case AF_UNSPEC:
219 return "IP";
220 case AF_INET:
221 return "IPv4";
222 case AF_INET6:
223 return "IPv6";
224 default:
225 return NULL;
226 }
227 }
228
229 int
230 dhcpcd_ifafwaiting(const struct interface *ifp)
231 {
232 unsigned long long opts;
233 bool foundany = false;
234
235 if (ifp->active != IF_ACTIVE_USER)
236 return AF_MAX;
237
238 #define DHCPCD_WAITALL (DHCPCD_WAITIP4 | DHCPCD_WAITIP6)
239 opts = ifp->options->options;
240 #ifdef INET
241 if (opts & DHCPCD_WAITIP4 ||
242 (opts & DHCPCD_WAITIP && !(opts & DHCPCD_WAITALL)))
243 {
244 bool foundaddr = ipv4_hasaddr(ifp);
245
246 if (opts & DHCPCD_WAITIP4 && !foundaddr)
247 return AF_INET;
248 if (foundaddr)
249 foundany = true;
250 }
251 #endif
252 #ifdef INET6
253 if (opts & DHCPCD_WAITIP6 ||
254 (opts & DHCPCD_WAITIP && !(opts & DHCPCD_WAITALL)))
255 {
256 bool foundaddr = ipv6_hasaddr(ifp);
257
258 if (opts & DHCPCD_WAITIP6 && !foundaddr)
259 return AF_INET6;
260 if (foundaddr)
261 foundany = true;
262 }
263 #endif
264
265 if (opts & DHCPCD_WAITIP && !(opts & DHCPCD_WAITALL) && !foundany)
266 return AF_UNSPEC;
267 return AF_MAX;
268 }
269
270 int
271 dhcpcd_afwaiting(const struct dhcpcd_ctx *ctx)
272 {
273 unsigned long long opts;
274 const struct interface *ifp;
275 int af;
276
277 if (!(ctx->options & DHCPCD_WAITOPTS))
278 return AF_MAX;
279
280 opts = ctx->options;
281 TAILQ_FOREACH(ifp, ctx->ifaces, next) {
282 #ifdef INET
283 if (opts & (DHCPCD_WAITIP | DHCPCD_WAITIP4) &&
284 ipv4_hasaddr(ifp))
285 opts &= ~(DHCPCD_WAITIP | DHCPCD_WAITIP4);
286 #endif
287 #ifdef INET6
288 if (opts & (DHCPCD_WAITIP | DHCPCD_WAITIP6) &&
289 ipv6_hasaddr(ifp))
290 opts &= ~(DHCPCD_WAITIP | DHCPCD_WAITIP6);
291 #endif
292 if (!(opts & DHCPCD_WAITOPTS))
293 break;
294 }
295 if (opts & DHCPCD_WAITIP)
296 af = AF_UNSPEC;
297 else if (opts & DHCPCD_WAITIP4)
298 af = AF_INET;
299 else if (opts & DHCPCD_WAITIP6)
300 af = AF_INET6;
301 else
302 return AF_MAX;
303 return af;
304 }
305
306 static int
307 dhcpcd_ipwaited(struct dhcpcd_ctx *ctx)
308 {
309 struct interface *ifp;
310 int af;
311
312 TAILQ_FOREACH(ifp, ctx->ifaces, next) {
313 if ((af = dhcpcd_ifafwaiting(ifp)) != AF_MAX) {
314 logdebugx("%s: waiting for an %s address",
315 ifp->name, dhcpcd_af(af));
316 return 0;
317 }
318 }
319
320 if ((af = dhcpcd_afwaiting(ctx)) != AF_MAX) {
321 logdebugx("waiting for an %s address",
322 dhcpcd_af(af));
323 return 0;
324 }
325
326 return 1;
327 }
328
329 /* Returns the pid of the child, otherwise 0. */
330 void
331 dhcpcd_daemonise(struct dhcpcd_ctx *ctx)
332 {
333 #ifdef THERE_IS_NO_FORK
334 eloop_timeout_delete(ctx->eloop, handle_exit_timeout, ctx);
335 errno = ENOSYS;
336 return;
337 #else
338 int i;
339 unsigned int logopts = loggetopts();
340
341 if (ctx->options & DHCPCD_DAEMONISE &&
342 !(ctx->options & (DHCPCD_DAEMONISED | DHCPCD_NOWAITIP)))
343 {
344 if (!dhcpcd_ipwaited(ctx))
345 return;
346 }
347
348 if (ctx->options & DHCPCD_ONESHOT) {
349 loginfox("exiting due to oneshot");
350 eloop_exit(ctx->eloop, EXIT_SUCCESS);
351 return;
352 }
353
354 eloop_timeout_delete(ctx->eloop, handle_exit_timeout, ctx);
355 if (ctx->options & DHCPCD_DAEMONISED ||
356 !(ctx->options & DHCPCD_DAEMONISE))
357 return;
358
359 /* Don't use loginfo because this makes no sense in a log. */
360 if (!(logopts & LOGERR_QUIET) && ctx->stderr_valid)
361 (void)fprintf(stderr,
362 "forked to background, child pid %d\n", getpid());
363 i = EXIT_SUCCESS;
364 if (write(ctx->fork_fd, &i, sizeof(i)) == -1)
365 logerr("write");
366 ctx->options |= DHCPCD_DAEMONISED;
367 eloop_event_delete(ctx->eloop, ctx->fork_fd);
368 close(ctx->fork_fd);
369 ctx->fork_fd = -1;
370
371 /*
372 * Stop writing to stderr.
373 * On the happy path, only the manager process writes to stderr,
374 * so this just stops wasting fprintf calls to nowhere.
375 * All other calls - ie errors in privsep processes or script output,
376 * will error when printing.
377 * If we *really* want to fix that, then we need to suck
378 * stderr/stdout in the manager process and either disacrd it or pass
379 * it to the launcher process and then to stderr.
380 */
381 logopts &= ~LOGERR_ERR;
382 logsetopts(logopts);
383 #endif
384 }
385
386 static void
387 dhcpcd_drop(struct interface *ifp, int stop)
388 {
389
390 #ifdef DHCP6
391 dhcp6_drop(ifp, stop ? NULL : "EXPIRE6");
392 #endif
393 #ifdef INET6
394 ipv6nd_drop(ifp);
395 ipv6_drop(ifp);
396 #endif
397 #ifdef IPV4LL
398 ipv4ll_drop(ifp);
399 #endif
400 #ifdef INET
401 dhcp_drop(ifp, stop ? "STOP" : "EXPIRE");
402 #endif
403 #ifdef ARP
404 arp_drop(ifp);
405 #endif
406 #if !defined(DHCP6) && !defined(DHCP)
407 UNUSED(stop);
408 #endif
409 }
410
411 static void
412 stop_interface(struct interface *ifp, const char *reason)
413 {
414 struct dhcpcd_ctx *ctx;
415
416 ctx = ifp->ctx;
417 loginfox("%s: removing interface", ifp->name);
418 ifp->options->options |= DHCPCD_STOPPING;
419
420 dhcpcd_drop(ifp, 1);
421 script_runreason(ifp, reason == NULL ? "STOPPED" : reason);
422
423 /* Delete all timeouts for the interfaces */
424 eloop_q_timeout_delete(ctx->eloop, ELOOP_QUEUE_ALL, NULL, ifp);
425
426 /* De-activate the interface */
427 ifp->active = IF_INACTIVE;
428 ifp->options->options &= ~DHCPCD_STOPPING;
429
430 if (!(ctx->options & (DHCPCD_MANAGER | DHCPCD_TEST)))
431 eloop_exit(ctx->eloop, EXIT_FAILURE);
432 }
433
434 static void
435 configure_interface1(struct interface *ifp)
436 {
437 struct if_options *ifo = ifp->options;
438
439 /* Do any platform specific configuration */
440 if_conf(ifp);
441
442 /* If we want to release a lease, we can't really persist the
443 * address either. */
444 if (ifo->options & DHCPCD_RELEASE)
445 ifo->options &= ~DHCPCD_PERSISTENT;
446
447 if (ifp->flags & (IFF_POINTOPOINT | IFF_LOOPBACK)) {
448 ifo->options &= ~DHCPCD_ARP;
449 if (!(ifp->flags & IFF_MULTICAST))
450 ifo->options &= ~DHCPCD_IPV6RS;
451 if (!(ifo->options & (DHCPCD_INFORM | DHCPCD_WANTDHCP)))
452 ifo->options |= DHCPCD_STATIC;
453 }
454
455 if (ifo->metric != -1)
456 ifp->metric = (unsigned int)ifo->metric;
457
458 #ifdef INET6
459 /* We want to setup INET6 on the interface as soon as possible. */
460 if (ifp->active == IF_ACTIVE_USER &&
461 ifo->options & DHCPCD_IPV6 &&
462 !(ifp->ctx->options & (DHCPCD_DUMPLEASE | DHCPCD_TEST)))
463 {
464 /* If not doing any DHCP, disable the RDNSS requirement. */
465 if (!(ifo->options & (DHCPCD_DHCP | DHCPCD_DHCP6)))
466 ifo->options &= ~DHCPCD_IPV6RA_REQRDNSS;
467 if_setup_inet6(ifp);
468 }
469 #endif
470
471 if (!(ifo->options & DHCPCD_IAID)) {
472 /*
473 * An IAID is for identifying a unqiue interface within
474 * the client. It is 4 bytes long. Working out a default
475 * value is problematic.
476 *
477 * Interface name and number are not stable
478 * between different OS's. Some OS's also cannot make
479 * up their mind what the interface should be called
480 * (yes, udev, I'm looking at you).
481 * Also, the name could be longer than 4 bytes.
482 * Also, with pluggable interfaces the name and index
483 * could easily get swapped per actual interface.
484 *
485 * The MAC address is 6 bytes long, the final 3
486 * being unique to the manufacturer and the initial 3
487 * being unique to the organisation which makes it.
488 * We could use the last 4 bytes of the MAC address
489 * as the IAID as it's the most stable part given the
490 * above, but equally it's not guaranteed to be
491 * unique.
492 *
493 * Given the above, and our need to reliably work
494 * between reboots without persitent storage,
495 * generating the IAID from the MAC address is the only
496 * logical default.
497 * Saying that, if a VLANID has been specified then we
498 * can use that. It's possible that different interfaces
499 * can have the same VLANID, but this is no worse than
500 * generating the IAID from the duplicate MAC address.
501 *
502 * dhclient uses the last 4 bytes of the MAC address.
503 * dibbler uses an increamenting counter.
504 * wide-dhcpv6 uses 0 or a configured value.
505 * odhcp6c uses 1.
506 * Windows 7 uses the first 3 bytes of the MAC address
507 * and an unknown byte.
508 * dhcpcd-6.1.0 and earlier used the interface name,
509 * falling back to interface index if name > 4.
510 */
511 if (ifp->vlanid != 0) {
512 uint32_t vlanid;
513
514 /* Maximal VLANID is 4095, so prefix with 0xff
515 * so we don't conflict with an interface index. */
516 vlanid = htonl(ifp->vlanid | 0xff000000);
517 memcpy(ifo->iaid, &vlanid, sizeof(vlanid));
518 } else if (ifo->options & DHCPCD_ANONYMOUS)
519 memset(ifo->iaid, 0, sizeof(ifo->iaid));
520 else if (ifp->hwlen >= sizeof(ifo->iaid)) {
521 memcpy(ifo->iaid,
522 ifp->hwaddr + ifp->hwlen - sizeof(ifo->iaid),
523 sizeof(ifo->iaid));
524 } else {
525 uint32_t len;
526
527 len = (uint32_t)strlen(ifp->name);
528 if (len <= sizeof(ifo->iaid)) {
529 memcpy(ifo->iaid, ifp->name, len);
530 if (len < sizeof(ifo->iaid))
531 memset(ifo->iaid + len, 0,
532 sizeof(ifo->iaid) - len);
533 } else {
534 /* IAID is the same size as a uint32_t */
535 len = htonl(ifp->index);
536 memcpy(ifo->iaid, &len, sizeof(ifo->iaid));
537 }
538 }
539 ifo->options |= DHCPCD_IAID;
540 }
541
542 #ifdef DHCP6
543 if (ifo->ia_len == 0 && ifo->options & DHCPCD_IPV6 &&
544 ifp->name[0] != '\0')
545 {
546 ifo->ia = malloc(sizeof(*ifo->ia));
547 if (ifo->ia == NULL)
548 logerr(__func__);
549 else {
550 ifo->ia_len = 1;
551 ifo->ia->ia_type = D6_OPTION_IA_NA;
552 memcpy(ifo->ia->iaid, ifo->iaid, sizeof(ifo->iaid));
553 memset(&ifo->ia->addr, 0, sizeof(ifo->ia->addr));
554 #ifndef SMALL
555 ifo->ia->sla = NULL;
556 ifo->ia->sla_len = 0;
557 #endif
558 }
559 } else {
560 size_t i;
561
562 for (i = 0; i < ifo->ia_len; i++) {
563 if (!ifo->ia[i].iaid_set) {
564 memcpy(&ifo->ia[i].iaid, ifo->iaid,
565 sizeof(ifo->ia[i].iaid));
566 ifo->ia[i].iaid_set = 1;
567 }
568 }
569 }
570 #endif
571
572 /* If root is network mounted, we don't want to kill the connection
573 * if the DHCP server goes the way of the dodo OR dhcpcd is rebooting
574 * and the lease file has expired. */
575 if (is_root_local() == 0)
576 ifo->options |= DHCPCD_LASTLEASE_EXTEND;
577 }
578
579 int
580 dhcpcd_selectprofile(struct interface *ifp, const char *profile)
581 {
582 struct if_options *ifo;
583 char pssid[PROFILE_LEN];
584
585 if (ifp->ssid_len) {
586 ssize_t r;
587
588 r = print_string(pssid, sizeof(pssid), OT_ESCSTRING,
589 ifp->ssid, ifp->ssid_len);
590 if (r == -1) {
591 logerr(__func__);
592 pssid[0] = '\0';
593 }
594 } else
595 pssid[0] = '\0';
596 ifo = read_config(ifp->ctx, ifp->name, pssid, profile);
597 if (ifo == NULL) {
598 logdebugx("%s: no profile %s", ifp->name, profile);
599 return -1;
600 }
601 if (profile != NULL) {
602 strlcpy(ifp->profile, profile, sizeof(ifp->profile));
603 loginfox("%s: selected profile %s", ifp->name, profile);
604 } else
605 *ifp->profile = '\0';
606
607 free_options(ifp->ctx, ifp->options);
608 ifp->options = ifo;
609 if (profile) {
610 add_options(ifp->ctx, ifp->name, ifp->options,
611 ifp->ctx->argc, ifp->ctx->argv);
612 configure_interface1(ifp);
613 }
614 return 1;
615 }
616
617 static void
618 configure_interface(struct interface *ifp, int argc, char **argv,
619 unsigned long long options)
620 {
621 time_t old;
622
623 old = ifp->options ? ifp->options->mtime : 0;
624 dhcpcd_selectprofile(ifp, NULL);
625 if (ifp->options == NULL) {
626 /* dhcpcd cannot continue with this interface. */
627 ifp->active = IF_INACTIVE;
628 return;
629 }
630 add_options(ifp->ctx, ifp->name, ifp->options, argc, argv);
631 ifp->options->options |= options;
632 configure_interface1(ifp);
633
634 /* If the mtime has changed drop any old lease */
635 if (old != 0 && ifp->options->mtime != old) {
636 logwarnx("%s: config file changed, expiring leases",
637 ifp->name);
638 dhcpcd_drop(ifp, 0);
639 }
640 }
641
642 static void
643 dhcpcd_initstate2(struct interface *ifp, unsigned long long options)
644 {
645 struct if_options *ifo;
646
647 if (options) {
648 if ((ifo = default_config(ifp->ctx)) == NULL) {
649 logerr(__func__);
650 return;
651 }
652 ifo->options |= options;
653 free(ifp->options);
654 ifp->options = ifo;
655 } else
656 ifo = ifp->options;
657
658 #ifdef INET6
659 if (ifo->options & DHCPCD_IPV6 && ipv6_init(ifp->ctx) == -1) {
660 logerr(__func__);
661 ifo->options &= ~DHCPCD_IPV6;
662 }
663 #endif
664 }
665
666 static void
667 dhcpcd_initstate1(struct interface *ifp, int argc, char **argv,
668 unsigned long long options)
669 {
670
671 configure_interface(ifp, argc, argv, options);
672 if (ifp->active)
673 dhcpcd_initstate2(ifp, 0);
674 }
675
676 static void
677 dhcpcd_initstate(struct interface *ifp, unsigned long long options)
678 {
679
680 dhcpcd_initstate1(ifp, ifp->ctx->argc, ifp->ctx->argv, options);
681 }
682
683 static void
684 dhcpcd_reportssid(struct interface *ifp)
685 {
686 char pssid[IF_SSIDLEN * 4];
687
688 if (print_string(pssid, sizeof(pssid), OT_ESCSTRING,
689 ifp->ssid, ifp->ssid_len) == -1)
690 {
691 logerr(__func__);
692 return;
693 }
694
695 loginfox("%s: connected to Access Point: %s", ifp->name, pssid);
696 }
697
698 static void
699 dhcpcd_nocarrier_roaming(struct interface *ifp)
700 {
701
702 loginfox("%s: carrier lost - roaming", ifp->name);
703
704 #ifdef ARP
705 arp_drop(ifp);
706 #endif
707 #ifdef INET
708 dhcp_abort(ifp);
709 #endif
710 #ifdef DHCP6
711 dhcp6_abort(ifp);
712 #endif
713
714 rt_build(ifp->ctx, AF_UNSPEC);
715 script_runreason(ifp, "NOCARRIER_ROAMING");
716 }
717
718 void
719 dhcpcd_handlecarrier(struct interface *ifp, int carrier, unsigned int flags)
720 {
721 bool was_link_up = if_is_link_up(ifp);
722 bool was_roaming = if_roaming(ifp);
723
724 ifp->carrier = carrier;
725 ifp->flags = flags;
726
727 if (!if_is_link_up(ifp)) {
728 if (!ifp->active || (!was_link_up && !was_roaming))
729 return;
730
731 /*
732 * If the interface is roaming (generally on wireless)
733 * then while we are not up, we are not down either.
734 * Preserve the network state until we either disconnect
735 * or re-connect.
736 */
737 if (!ifp->options->randomise_hwaddr && if_roaming(ifp)) {
738 dhcpcd_nocarrier_roaming(ifp);
739 return;
740 }
741
742 loginfox("%s: carrier lost", ifp->name);
743 script_runreason(ifp, "NOCARRIER");
744 dhcpcd_drop(ifp, 0);
745
746 if (ifp->options->randomise_hwaddr) {
747 bool is_up = ifp->flags & IFF_UP;
748
749 if (is_up)
750 if_down(ifp);
751 if (if_randomisemac(ifp) == -1 && errno != ENXIO)
752 logerr(__func__);
753 if (is_up)
754 if_up(ifp);
755 }
756
757 return;
758 }
759
760 /*
761 * At this point carrier is NOT DOWN and we have IFF_UP.
762 * We should treat LINK_UNKNOWN as up as the driver may not support
763 * link state changes.
764 * The consideration of any other information about carrier should
765 * be handled in the OS specific if_carrier() function.
766 */
767 if (was_link_up)
768 return;
769
770 if (ifp->active) {
771 if (carrier == LINK_UNKNOWN)
772 loginfox("%s: carrier unknown, assuming up", ifp->name);
773 else
774 loginfox("%s: carrier acquired", ifp->name);
775 }
776
777 #if !defined(__linux__) && !defined(__NetBSD__)
778 /* BSD does not emit RTM_NEWADDR or RTM_CHGADDR when the
779 * hardware address changes so we have to go
780 * through the disovery process to work it out. */
781 dhcpcd_handleinterface(ifp->ctx, 0, ifp->name);
782 #endif
783
784 if (ifp->wireless) {
785 uint8_t ossid[IF_SSIDLEN];
786 size_t olen;
787
788 olen = ifp->ssid_len;
789 memcpy(ossid, ifp->ssid, ifp->ssid_len);
790 if_getssid(ifp);
791
792 /* If we changed SSID network, drop leases */
793 if ((ifp->ssid_len != olen ||
794 memcmp(ifp->ssid, ossid, ifp->ssid_len)) && ifp->active)
795 {
796 dhcpcd_reportssid(ifp);
797 dhcpcd_drop(ifp, 0);
798 #ifdef IPV4LL
799 ipv4ll_reset(ifp);
800 #endif
801 }
802 }
803
804 if (!ifp->active)
805 return;
806
807 dhcpcd_initstate(ifp, 0);
808 script_runreason(ifp, "CARRIER");
809
810 #ifdef INET6
811 /* Set any IPv6 Routers we remembered to expire faster than they
812 * would normally as we maybe on a new network. */
813 ipv6nd_startexpire(ifp);
814 #ifdef IPV6_MANAGETEMPADDR
815 /* RFC4941 Section 3.5 */
816 ipv6_regentempaddrs(ifp);
817 #endif
818 #endif
819
820 dhcpcd_startinterface(ifp);
821 }
822
823 static void
824 warn_iaid_conflict(struct interface *ifp, uint16_t ia_type, uint8_t *iaid)
825 {
826 struct interface *ifn;
827 #ifdef INET6
828 size_t i;
829 struct if_ia *ia;
830 #endif
831
832 TAILQ_FOREACH(ifn, ifp->ctx->ifaces, next) {
833 if (ifn == ifp || !ifn->active)
834 continue;
835 if (ifn->options->options & DHCPCD_ANONYMOUS)
836 continue;
837 if (ia_type == 0 &&
838 memcmp(ifn->options->iaid, iaid,
839 sizeof(ifn->options->iaid)) == 0)
840 break;
841 #ifdef INET6
842 for (i = 0; i < ifn->options->ia_len; i++) {
843 ia = &ifn->options->ia[i];
844 if (ia->ia_type == ia_type &&
845 memcmp(ia->iaid, iaid, sizeof(ia->iaid)) == 0)
846 break;
847 }
848 #endif
849 }
850
851 /* This is only a problem if the interfaces are on the same network. */
852 if (ifn)
853 logerrx("%s: IAID conflicts with one assigned to %s",
854 ifp->name, ifn->name);
855 }
856
857 static void
858 dhcpcd_initduid(struct dhcpcd_ctx *ctx, struct interface *ifp)
859 {
860 char buf[DUID_LEN * 3];
861
862 if (ctx->duid != NULL) {
863 if (ifp == NULL)
864 goto log;
865 return;
866 }
867
868 duid_init(ctx, ifp);
869 if (ctx->duid == NULL)
870 return;
871
872 log:
873 loginfox("DUID %s",
874 hwaddr_ntoa(ctx->duid, ctx->duid_len, buf, sizeof(buf)));
875 }
876
877 void
878 dhcpcd_startinterface(void *arg)
879 {
880 struct interface *ifp = arg;
881 struct if_options *ifo = ifp->options;
882
883 if (ifo->options & DHCPCD_LINK && !if_is_link_up(ifp)) {
884 loginfox("%s: waiting for carrier", ifp->name);
885 return;
886 }
887
888 if (ifo->options & (DHCPCD_DUID | DHCPCD_IPV6) &&
889 !(ifo->options & DHCPCD_ANONYMOUS))
890 {
891 char buf[sizeof(ifo->iaid) * 3];
892 #ifdef INET6
893 size_t i;
894 struct if_ia *ia;
895 #endif
896
897 /* Try and init DUID from the interface hardware address */
898 dhcpcd_initduid(ifp->ctx, ifp);
899
900 /* Report IAIDs */
901 loginfox("%s: IAID %s", ifp->name,
902 hwaddr_ntoa(ifo->iaid, sizeof(ifo->iaid),
903 buf, sizeof(buf)));
904 warn_iaid_conflict(ifp, 0, ifo->iaid);
905
906 #ifdef INET6
907 for (i = 0; i < ifo->ia_len; i++) {
908 ia = &ifo->ia[i];
909 if (memcmp(ifo->iaid, ia->iaid, sizeof(ifo->iaid))) {
910 loginfox("%s: IA type %u IAID %s",
911 ifp->name, ia->ia_type,
912 hwaddr_ntoa(ia->iaid, sizeof(ia->iaid),
913 buf, sizeof(buf)));
914 warn_iaid_conflict(ifp, ia->ia_type, ia->iaid);
915 }
916 }
917 #endif
918 }
919
920 #ifdef INET6
921 if (ifo->options & DHCPCD_IPV6 && ipv6_start(ifp) == -1) {
922 logerr("%s: ipv6_start", ifp->name);
923 ifo->options &= ~DHCPCD_IPV6;
924 }
925
926 if (ifo->options & DHCPCD_IPV6) {
927 if (ifp->active == IF_ACTIVE_USER) {
928 ipv6_startstatic(ifp);
929
930 if (ifo->options & DHCPCD_IPV6RS)
931 ipv6nd_startrs(ifp);
932 }
933
934 #ifdef DHCP6
935 /* DHCPv6 could be turned off, but the interface
936 * is still delegated to. */
937 if (ifp->active)
938 dhcp6_find_delegates(ifp);
939
940 if (ifo->options & DHCPCD_DHCP6) {
941 if (ifp->active == IF_ACTIVE_USER) {
942 enum DH6S d6_state;
943
944 if (ifo->options & DHCPCD_IA_FORCED)
945 d6_state = DH6S_INIT;
946 else if (ifo->options & DHCPCD_INFORM6)
947 d6_state = DH6S_INFORM;
948 else
949 d6_state = DH6S_CONFIRM;
950 if (dhcp6_start(ifp, d6_state) == -1)
951 logerr("%s: dhcp6_start", ifp->name);
952 }
953 }
954 #endif
955 }
956 #endif
957
958 #ifdef INET
959 if (ifo->options & DHCPCD_IPV4 && ifp->active == IF_ACTIVE_USER) {
960 /* Ensure we have an IPv4 state before starting DHCP */
961 if (ipv4_getstate(ifp) != NULL)
962 dhcp_start(ifp);
963 }
964 #endif
965 }
966
967 static void
968 dhcpcd_prestartinterface(void *arg)
969 {
970 struct interface *ifp = arg;
971 struct dhcpcd_ctx *ctx = ifp->ctx;
972 bool randmac_down;
973
974 if (ifp->carrier <= LINK_DOWN &&
975 ifp->options->randomise_hwaddr &&
976 ifp->flags & IFF_UP)
977 {
978 if_down(ifp);
979 randmac_down = true;
980 } else
981 randmac_down = false;
982
983 if ((!(ctx->options & DHCPCD_MANAGER) ||
984 ifp->options->options & DHCPCD_IF_UP || randmac_down) &&
985 !(ifp->flags & IFF_UP))
986 {
987 if (ifp->options->randomise_hwaddr &&
988 if_randomisemac(ifp) == -1)
989 logerr(__func__);
990 if (if_up(ifp) == -1)
991 logerr(__func__);
992 }
993
994 dhcpcd_startinterface(ifp);
995 }
996
997 static void
998 run_preinit(struct interface *ifp)
999 {
1000
1001 if (ifp->ctx->options & DHCPCD_TEST)
1002 return;
1003
1004 script_runreason(ifp, "PREINIT");
1005 if (ifp->wireless && if_is_link_up(ifp))
1006 dhcpcd_reportssid(ifp);
1007 if (ifp->options->options & DHCPCD_LINK && ifp->carrier != LINK_UNKNOWN)
1008 script_runreason(ifp,
1009 ifp->carrier == LINK_UP ? "CARRIER" : "NOCARRIER");
1010 }
1011
1012 void
1013 dhcpcd_activateinterface(struct interface *ifp, unsigned long long options)
1014 {
1015
1016 if (ifp->active)
1017 return;
1018
1019 ifp->active = IF_ACTIVE;
1020 dhcpcd_initstate2(ifp, options);
1021
1022 /* It's possible we might not have been able to load
1023 * a config. */
1024 if (!ifp->active)
1025 return;
1026
1027 configure_interface1(ifp);
1028 run_preinit(ifp);
1029 dhcpcd_prestartinterface(ifp);
1030 }
1031
1032 int
1033 dhcpcd_handleinterface(void *arg, int action, const char *ifname)
1034 {
1035 struct dhcpcd_ctx *ctx = arg;
1036 struct ifaddrs *ifaddrs;
1037 struct if_head *ifs;
1038 struct interface *ifp, *iff;
1039 const char * const argv[] = { ifname };
1040 int e;
1041
1042 if (action == -1) {
1043 ifp = if_find(ctx->ifaces, ifname);
1044 if (ifp == NULL) {
1045 errno = ESRCH;
1046 return -1;
1047 }
1048 if (ifp->active) {
1049 logdebugx("%s: interface departed", ifp->name);
1050 stop_interface(ifp, "DEPARTED");
1051 }
1052 TAILQ_REMOVE(ctx->ifaces, ifp, next);
1053 if_free(ifp);
1054 return 0;
1055 }
1056
1057 ifs = if_discover(ctx, &ifaddrs, -1, UNCONST(argv));
1058 if (ifs == NULL) {
1059 logerr(__func__);
1060 return -1;
1061 }
1062
1063 ifp = if_find(ifs, ifname);
1064 if (ifp == NULL) {
1065 /* This can happen if an interface is quickly added
1066 * and then removed. */
1067 errno = ENOENT;
1068 e = -1;
1069 goto out;
1070 }
1071 e = 1;
1072
1073 /* Check if we already have the interface */
1074 iff = if_find(ctx->ifaces, ifp->name);
1075
1076 if (iff != NULL) {
1077 if (iff->active)
1078 logdebugx("%s: interface updated", iff->name);
1079 /* The flags and hwaddr could have changed */
1080 iff->flags = ifp->flags;
1081 iff->hwlen = ifp->hwlen;
1082 if (ifp->hwlen != 0)
1083 memcpy(iff->hwaddr, ifp->hwaddr, iff->hwlen);
1084 } else {
1085 TAILQ_REMOVE(ifs, ifp, next);
1086 TAILQ_INSERT_TAIL(ctx->ifaces, ifp, next);
1087 if (ifp->active) {
1088 logdebugx("%s: interface added", ifp->name);
1089 dhcpcd_initstate(ifp, 0);
1090 run_preinit(ifp);
1091 }
1092 iff = ifp;
1093 }
1094
1095 if (action > 0) {
1096 if_learnaddrs(ctx, ifs, &ifaddrs);
1097 if (iff->active)
1098 dhcpcd_prestartinterface(iff);
1099 }
1100
1101 out:
1102 /* Free our discovered list */
1103 while ((ifp = TAILQ_FIRST(ifs))) {
1104 TAILQ_REMOVE(ifs, ifp, next);
1105 if_free(ifp);
1106 }
1107 free(ifs);
1108 if_freeifaddrs(ctx, &ifaddrs);
1109
1110 return e;
1111 }
1112
1113 static void
1114 dhcpcd_handlelink(void *arg, unsigned short events)
1115 {
1116 struct dhcpcd_ctx *ctx = arg;
1117
1118 if (events != ELE_READ)
1119 logerrx("%s: unexpected event 0x%04x", __func__, events);
1120
1121 if (if_handlelink(ctx) == -1) {
1122 if (errno == ENOBUFS || errno == ENOMEM) {
1123 dhcpcd_linkoverflow(ctx);
1124 return;
1125 }
1126 if (errno != ENOTSUP)
1127 logerr(__func__);
1128 }
1129 }
1130
1131 static void
1132 dhcpcd_checkcarrier(void *arg)
1133 {
1134 struct interface *ifp0 = arg, *ifp;
1135
1136 ifp = if_find(ifp0->ctx->ifaces, ifp0->name);
1137 if (ifp == NULL || ifp->carrier == ifp0->carrier)
1138 return;
1139
1140 dhcpcd_handlecarrier(ifp, ifp0->carrier, ifp0->flags);
1141 if_free(ifp0);
1142 }
1143
1144 #ifndef SMALL
1145 static void
1146 dhcpcd_setlinkrcvbuf(struct dhcpcd_ctx *ctx)
1147 {
1148 socklen_t socklen;
1149
1150 if (ctx->link_rcvbuf == 0)
1151 return;
1152
1153 logdebugx("setting route socket receive buffer size to %d bytes",
1154 ctx->link_rcvbuf);
1155
1156 socklen = sizeof(ctx->link_rcvbuf);
1157 if (setsockopt(ctx->link_fd, SOL_SOCKET,
1158 SO_RCVBUF, &ctx->link_rcvbuf, socklen) == -1)
1159 logerr(__func__);
1160 }
1161 #endif
1162
1163 static void
1164 dhcpcd_runprestartinterface(void *arg)
1165 {
1166 struct interface *ifp = arg;
1167
1168 run_preinit(ifp);
1169 dhcpcd_prestartinterface(ifp);
1170 }
1171
1172 void
1173 dhcpcd_linkoverflow(struct dhcpcd_ctx *ctx)
1174 {
1175 socklen_t socklen;
1176 int rcvbuflen;
1177 char buf[2048];
1178 ssize_t rlen;
1179 size_t rcnt;
1180 struct if_head *ifaces;
1181 struct ifaddrs *ifaddrs;
1182 struct interface *ifp, *ifn, *ifp1;
1183
1184 socklen = sizeof(rcvbuflen);
1185 if (getsockopt(ctx->link_fd, SOL_SOCKET,
1186 SO_RCVBUF, &rcvbuflen, &socklen) == -1) {
1187 logerr("%s: getsockopt", __func__);
1188 rcvbuflen = 0;
1189 }
1190 #ifdef __linux__
1191 else
1192 rcvbuflen /= 2;
1193 #endif
1194
1195 logerrx("route socket overflowed (rcvbuflen %d)"
1196 " - learning interface state", rcvbuflen);
1197
1198 /* Drain the socket.
1199 * We cannot open a new one due to privsep. */
1200 rcnt = 0;
1201 do {
1202 rlen = read(ctx->link_fd, buf, sizeof(buf));
1203 if (++rcnt % 1000 == 0)
1204 logwarnx("drained %zu messages", rcnt);
1205 } while (rlen != -1 || errno == ENOBUFS || errno == ENOMEM);
1206 if (rcnt % 1000 != 0)
1207 logwarnx("drained %zu messages", rcnt);
1208
1209 /* Work out the current interfaces. */
1210 ifaces = if_discover(ctx, &ifaddrs, ctx->ifc, ctx->ifv);
1211 if (ifaces == NULL) {
1212 logerr(__func__);
1213 return;
1214 }
1215
1216 /* Punt departed interfaces */
1217 TAILQ_FOREACH_SAFE(ifp, ctx->ifaces, next, ifn) {
1218 if (if_find(ifaces, ifp->name) != NULL)
1219 continue;
1220 dhcpcd_handleinterface(ctx, -1, ifp->name);
1221 }
1222
1223 /* Add new interfaces */
1224 while ((ifp = TAILQ_FIRST(ifaces)) != NULL ) {
1225 TAILQ_REMOVE(ifaces, ifp, next);
1226 ifp1 = if_find(ctx->ifaces, ifp->name);
1227 if (ifp1 != NULL) {
1228 /* If the interface already exists,
1229 * check carrier state.
1230 * dhcpcd_checkcarrier will free ifp. */
1231 eloop_timeout_add_sec(ctx->eloop, 0,
1232 dhcpcd_checkcarrier, ifp);
1233 continue;
1234 }
1235 TAILQ_INSERT_TAIL(ctx->ifaces, ifp, next);
1236 if (ifp->active) {
1237 dhcpcd_initstate(ifp, 0);
1238 eloop_timeout_add_sec(ctx->eloop, 0,
1239 dhcpcd_runprestartinterface, ifp);
1240 }
1241 }
1242 free(ifaces);
1243
1244 /* Update address state. */
1245 if_markaddrsstale(ctx->ifaces);
1246 if_learnaddrs(ctx, ctx->ifaces, &ifaddrs);
1247 if_deletestaleaddrs(ctx->ifaces);
1248 if_freeifaddrs(ctx, &ifaddrs);
1249 }
1250
1251 void
1252 dhcpcd_handlehwaddr(struct interface *ifp,
1253 uint16_t hwtype, const void *hwaddr, uint8_t hwlen)
1254 {
1255 char buf[sizeof(ifp->hwaddr) * 3];
1256
1257 if (hwaddr == NULL || !if_valid_hwaddr(hwaddr, hwlen))
1258 hwlen = 0;
1259
1260 if (hwlen > sizeof(ifp->hwaddr)) {
1261 errno = ENOBUFS;
1262 logerr("%s: %s", __func__, ifp->name);
1263 return;
1264 }
1265
1266 if (ifp->hwtype != hwtype) {
1267 if (ifp->active)
1268 loginfox("%s: hardware address type changed"
1269 " from %d to %d", ifp->name, ifp->hwtype, hwtype);
1270 ifp->hwtype = hwtype;
1271 }
1272
1273 if (ifp->hwlen == hwlen &&
1274 (hwlen == 0 || memcmp(ifp->hwaddr, hwaddr, hwlen) == 0))
1275 return;
1276
1277 if (ifp->active) {
1278 loginfox("%s: old hardware address: %s", ifp->name,
1279 hwaddr_ntoa(ifp->hwaddr, ifp->hwlen, buf, sizeof(buf)));
1280 loginfox("%s: new hardware address: %s", ifp->name,
1281 hwaddr_ntoa(hwaddr, hwlen, buf, sizeof(buf)));
1282 }
1283 ifp->hwlen = hwlen;
1284 if (hwaddr != NULL)
1285 memcpy(ifp->hwaddr, hwaddr, hwlen);
1286 }
1287
1288 static void
1289 if_reboot(struct interface *ifp, int argc, char **argv)
1290 {
1291 #ifdef INET
1292 unsigned long long oldopts;
1293
1294 oldopts = ifp->options->options;
1295 #endif
1296 script_runreason(ifp, "RECONFIGURE");
1297 dhcpcd_initstate1(ifp, argc, argv, 0);
1298 #ifdef INET
1299 dhcp_reboot_newopts(ifp, oldopts);
1300 #endif
1301 #ifdef DHCP6
1302 dhcp6_reboot(ifp);
1303 #endif
1304 dhcpcd_prestartinterface(ifp);
1305 }
1306
1307 static void
1308 reload_config(struct dhcpcd_ctx *ctx)
1309 {
1310 struct if_options *ifo;
1311
1312 free_globals(ctx);
1313 if ((ifo = read_config(ctx, NULL, NULL, NULL)) == NULL)
1314 return;
1315 add_options(ctx, NULL, ifo, ctx->argc, ctx->argv);
1316 /* We need to preserve these options. */
1317 if (ctx->options & DHCPCD_STARTED)
1318 ifo->options |= DHCPCD_STARTED;
1319 if (ctx->options & DHCPCD_MANAGER)
1320 ifo->options |= DHCPCD_MANAGER;
1321 if (ctx->options & DHCPCD_DAEMONISED)
1322 ifo->options |= DHCPCD_DAEMONISED;
1323 if (ctx->options & DHCPCD_PRIVSEP)
1324 ifo->options |= DHCPCD_PRIVSEP;
1325 ctx->options = ifo->options;
1326 free_options(ctx, ifo);
1327 }
1328
1329 static void
1330 reconf_reboot(struct dhcpcd_ctx *ctx, int action, int argc, char **argv, int oi)
1331 {
1332 int i;
1333 struct interface *ifp;
1334
1335 TAILQ_FOREACH(ifp, ctx->ifaces, next) {
1336 for (i = oi; i < argc; i++) {
1337 if (strcmp(ifp->name, argv[i]) == 0)
1338 break;
1339 }
1340 if (oi != argc && i == argc)
1341 continue;
1342 if (ifp->active == IF_ACTIVE_USER) {
1343 if (action)
1344 if_reboot(ifp, argc, argv);
1345 #ifdef INET
1346 else
1347 ipv4_applyaddr(ifp);
1348 #endif
1349 } else if (i != argc) {
1350 ifp->active = IF_ACTIVE_USER;
1351 dhcpcd_initstate1(ifp, argc, argv, 0);
1352 run_preinit(ifp);
1353 dhcpcd_prestartinterface(ifp);
1354 }
1355 }
1356 }
1357
1358 static void
1359 stop_all_interfaces(struct dhcpcd_ctx *ctx, unsigned long long opts)
1360 {
1361 struct interface *ifp;
1362
1363 ctx->options |= DHCPCD_EXITING;
1364 if (ctx->ifaces == NULL)
1365 return;
1366
1367 /* Drop the last interface first */
1368 TAILQ_FOREACH_REVERSE(ifp, ctx->ifaces, if_head, next) {
1369 if (!ifp->active)
1370 continue;
1371 ifp->options->options |= opts;
1372 if (ifp->options->options & DHCPCD_RELEASE)
1373 ifp->options->options &= ~DHCPCD_PERSISTENT;
1374 ifp->options->options |= DHCPCD_EXITING;
1375 stop_interface(ifp, NULL);
1376 }
1377 }
1378
1379 static void
1380 dhcpcd_ifrenew(struct interface *ifp)
1381 {
1382
1383 if (!ifp->active)
1384 return;
1385
1386 if (ifp->options->options & DHCPCD_LINK && !if_is_link_up(ifp))
1387 return;
1388
1389 #ifdef INET
1390 dhcp_renew(ifp);
1391 #endif
1392 #ifdef INET6
1393 #define DHCPCD_RARENEW (DHCPCD_IPV6 | DHCPCD_IPV6RS)
1394 if ((ifp->options->options & DHCPCD_RARENEW) == DHCPCD_RARENEW)
1395 ipv6nd_startrs(ifp);
1396 #endif
1397 #ifdef DHCP6
1398 dhcp6_renew(ifp);
1399 #endif
1400 }
1401
1402 static void
1403 dhcpcd_renew(struct dhcpcd_ctx *ctx)
1404 {
1405 struct interface *ifp;
1406
1407 TAILQ_FOREACH(ifp, ctx->ifaces, next) {
1408 dhcpcd_ifrenew(ifp);
1409 }
1410 }
1411
1412 #ifdef USE_SIGNALS
1413 #define sigmsg "received %s, %s"
1414 void
1415 dhcpcd_signal_cb(int sig, void *arg)
1416 {
1417 struct dhcpcd_ctx *ctx = arg;
1418 unsigned long long opts;
1419 int exit_code;
1420
1421 if (ctx->options & DHCPCD_DUMPLEASE) {
1422 eloop_exit(ctx->eloop, EXIT_FAILURE);
1423 return;
1424 }
1425
1426 if (sig != SIGCHLD && ctx->options & DHCPCD_FORKED) {
1427 if (sig != SIGHUP &&
1428 write(ctx->fork_fd, &sig, sizeof(sig)) == -1)
1429 logerr("%s: write", __func__);
1430 return;
1431 }
1432
1433 opts = 0;
1434 exit_code = EXIT_FAILURE;
1435 switch (sig) {
1436 case SIGINT:
1437 loginfox(sigmsg, "SIGINT", "stopping");
1438 break;
1439 case SIGTERM:
1440 loginfox(sigmsg, "SIGTERM", "stopping");
1441 exit_code = EXIT_SUCCESS;
1442 break;
1443 case SIGALRM:
1444 loginfox(sigmsg, "SIGALRM", "releasing");
1445 opts |= DHCPCD_RELEASE;
1446 exit_code = EXIT_SUCCESS;
1447 break;
1448 case SIGHUP:
1449 loginfox(sigmsg, "SIGHUP", "rebinding");
1450 reload_config(ctx);
1451 /* Preserve any options passed on the commandline
1452 * when we were started. */
1453 reconf_reboot(ctx, 1, ctx->argc, ctx->argv,
1454 ctx->argc - ctx->ifc);
1455 return;
1456 case SIGUSR1:
1457 loginfox(sigmsg, "SIGUSR1", "renewing");
1458 dhcpcd_renew(ctx);
1459 return;
1460 case SIGUSR2:
1461 loginfox(sigmsg, "SIGUSR2", "reopening log");
1462 #ifdef PRIVSEP
1463 if (IN_PRIVSEP(ctx)) {
1464 if (ps_root_logreopen(ctx) == -1)
1465 logerr("ps_root_logreopen");
1466 return;
1467 }
1468 #endif
1469 if (logopen(ctx->logfile) == -1)
1470 logerr("logopen");
1471 return;
1472 case SIGCHLD:
1473 #ifdef PRIVSEP
1474 ps_root_signalcb(sig, ctx);
1475 #else
1476 while (waitpid(-1, NULL, WNOHANG) > 0)
1477 ;
1478 #endif
1479 return;
1480 default:
1481 logerrx("received signal %d but don't know what to do with it",
1482 sig);
1483 return;
1484 }
1485
1486 if (!(ctx->options & DHCPCD_TEST))
1487 stop_all_interfaces(ctx, opts);
1488 eloop_exit(ctx->eloop, exit_code);
1489 }
1490 #endif
1491
1492 int
1493 dhcpcd_handleargs(struct dhcpcd_ctx *ctx, struct fd_list *fd,
1494 int argc, char **argv)
1495 {
1496 struct interface *ifp;
1497 unsigned long long opts;
1498 int opt, oi, do_reboot, do_renew, af = AF_UNSPEC;
1499 size_t len, l, nifaces;
1500 char *tmp, *p;
1501
1502 /* Special commands for our control socket
1503 * as the other end should be blocking until it gets the
1504 * expected reply we should be safely able just to change the
1505 * write callback on the fd */
1506 /* Make any change here in privsep-control.c as well. */
1507 if (strcmp(*argv, "--version") == 0) {
1508 return control_queue(fd, UNCONST(VERSION),
1509 strlen(VERSION) + 1);
1510 } else if (strcmp(*argv, "--getconfigfile") == 0) {
1511 return control_queue(fd, UNCONST(fd->ctx->cffile),
1512 strlen(fd->ctx->cffile) + 1);
1513 } else if (strcmp(*argv, "--getinterfaces") == 0) {
1514 optind = argc = 0;
1515 goto dumplease;
1516 } else if (strcmp(*argv, "--listen") == 0) {
1517 fd->flags |= FD_LISTEN;
1518 return 0;
1519 }
1520
1521 /* Log the command */
1522 len = 1;
1523 for (opt = 0; opt < argc; opt++)
1524 len += strlen(argv[opt]) + 1;
1525 tmp = malloc(len);
1526 if (tmp == NULL)
1527 return -1;
1528 p = tmp;
1529 for (opt = 0; opt < argc; opt++) {
1530 l = strlen(argv[opt]);
1531 strlcpy(p, argv[opt], len);
1532 len -= l + 1;
1533 p += l;
1534 *p++ = ' ';
1535 }
1536 *--p = '\0';
1537 loginfox("control command: %s", tmp);
1538 free(tmp);
1539
1540 optind = 0;
1541 oi = 0;
1542 opts = 0;
1543 do_reboot = do_renew = 0;
1544 while ((opt = getopt_long(argc, argv, IF_OPTS, cf_options, &oi)) != -1)
1545 {
1546 switch (opt) {
1547 case 'g':
1548 /* Assumed if below not set */
1549 break;
1550 case 'k':
1551 opts |= DHCPCD_RELEASE;
1552 break;
1553 case 'n':
1554 do_reboot = 1;
1555 break;
1556 case 'p':
1557 opts |= DHCPCD_PERSISTENT;
1558 break;
1559 case 'x':
1560 opts |= DHCPCD_EXITING;
1561 break;
1562 case 'N':
1563 do_renew = 1;
1564 break;
1565 case 'U':
1566 opts |= DHCPCD_DUMPLEASE;
1567 break;
1568 case '4':
1569 af = AF_INET;
1570 break;
1571 case '6':
1572 af = AF_INET6;
1573 break;
1574 }
1575 }
1576
1577 if (opts & DHCPCD_DUMPLEASE) {
1578 ctx->options |= DHCPCD_DUMPLEASE;
1579 dumplease:
1580 nifaces = 0;
1581 TAILQ_FOREACH(ifp, ctx->ifaces, next) {
1582 if (!ifp->active)
1583 continue;
1584 for (oi = optind; oi < argc; oi++) {
1585 if (strcmp(ifp->name, argv[oi]) == 0)
1586 break;
1587 }
1588 if (optind == argc || oi < argc) {
1589 opt = send_interface(NULL, ifp, af);
1590 if (opt == -1)
1591 goto dumperr;
1592 nifaces += (size_t)opt;
1593 }
1594 }
1595 if (write(fd->fd, &nifaces, sizeof(nifaces)) != sizeof(nifaces))
1596 goto dumperr;
1597 TAILQ_FOREACH(ifp, ctx->ifaces, next) {
1598 if (!ifp->active)
1599 continue;
1600 for (oi = optind; oi < argc; oi++) {
1601 if (strcmp(ifp->name, argv[oi]) == 0)
1602 break;
1603 }
1604 if (optind == argc || oi < argc) {
1605 if (send_interface(fd, ifp, af) == -1)
1606 goto dumperr;
1607 }
1608 }
1609 ctx->options &= ~DHCPCD_DUMPLEASE;
1610 return 0;
1611 dumperr:
1612 ctx->options &= ~DHCPCD_DUMPLEASE;
1613 return -1;
1614 }
1615
1616 /* Only privileged users can control dhcpcd via the socket. */
1617 if (fd->flags & FD_UNPRIV) {
1618 errno = EPERM;
1619 return -1;
1620 }
1621
1622 if (opts & (DHCPCD_EXITING | DHCPCD_RELEASE)) {
1623 if (optind == argc) {
1624 stop_all_interfaces(ctx, opts);
1625 eloop_exit(ctx->eloop, EXIT_SUCCESS);
1626 return 0;
1627 }
1628 for (oi = optind; oi < argc; oi++) {
1629 if ((ifp = if_find(ctx->ifaces, argv[oi])) == NULL)
1630 continue;
1631 if (!ifp->active)
1632 continue;
1633 ifp->options->options |= opts;
1634 if (opts & DHCPCD_RELEASE)
1635 ifp->options->options &= ~DHCPCD_PERSISTENT;
1636 stop_interface(ifp, NULL);
1637 }
1638 return 0;
1639 }
1640
1641 if (do_renew) {
1642 if (optind == argc) {
1643 dhcpcd_renew(ctx);
1644 return 0;
1645 }
1646 for (oi = optind; oi < argc; oi++) {
1647 if ((ifp = if_find(ctx->ifaces, argv[oi])) == NULL)
1648 continue;
1649 dhcpcd_ifrenew(ifp);
1650 }
1651 return 0;
1652 }
1653
1654 reload_config(ctx);
1655 /* XXX: Respect initial commandline options? */
1656 reconf_reboot(ctx, do_reboot, argc, argv, optind - 1);
1657 return 0;
1658 }
1659
1660 static void dhcpcd_readdump1(void *, unsigned short);
1661
1662 static void
1663 dhcpcd_readdump2(void *arg, unsigned short events)
1664 {
1665 struct dhcpcd_ctx *ctx = arg;
1666 ssize_t len;
1667 int exit_code = EXIT_FAILURE;
1668
1669 if (events != ELE_READ)
1670 logerrx("%s: unexpected event 0x%04x", __func__, events);
1671
1672 len = read(ctx->control_fd, ctx->ctl_buf + ctx->ctl_bufpos,
1673 ctx->ctl_buflen - ctx->ctl_bufpos);
1674 if (len == -1) {
1675 logerr(__func__);
1676 goto finished;
1677 } else if (len == 0)
1678 goto finished;
1679 if ((size_t)len + ctx->ctl_bufpos != ctx->ctl_buflen) {
1680 ctx->ctl_bufpos += (size_t)len;
1681 return;
1682 }
1683
1684 if (ctx->ctl_buf[ctx->ctl_buflen - 1] != '\0') /* unlikely */
1685 ctx->ctl_buf[ctx->ctl_buflen - 1] = '\0';
1686 script_dump(ctx->ctl_buf, ctx->ctl_buflen);
1687 fflush(stdout);
1688 if (--ctx->ctl_extra != 0) {
1689 putchar('\n');
1690 if (eloop_event_add(ctx->eloop, ctx->control_fd, ELE_READ,
1691 dhcpcd_readdump1, ctx) == -1)
1692 logerr("%s: eloop_event_add", __func__);
1693 return;
1694 }
1695 exit_code = EXIT_SUCCESS;
1696
1697 finished:
1698 shutdown(ctx->control_fd, SHUT_RDWR);
1699 eloop_exit(ctx->eloop, exit_code);
1700 }
1701
1702 static void
1703 dhcpcd_readdump1(void *arg, unsigned short events)
1704 {
1705 struct dhcpcd_ctx *ctx = arg;
1706 ssize_t len;
1707
1708 if (events != ELE_READ)
1709 logerrx("%s: unexpected event 0x%04x", __func__, events);
1710
1711 len = read(ctx->control_fd, &ctx->ctl_buflen, sizeof(ctx->ctl_buflen));
1712 if (len != sizeof(ctx->ctl_buflen)) {
1713 if (len != -1)
1714 errno = EINVAL;
1715 goto err;
1716 }
1717 if (ctx->ctl_buflen > SSIZE_MAX) {
1718 errno = ENOBUFS;
1719 goto err;
1720 }
1721
1722 free(ctx->ctl_buf);
1723 ctx->ctl_buf = malloc(ctx->ctl_buflen);
1724 if (ctx->ctl_buf == NULL)
1725 goto err;
1726
1727 ctx->ctl_bufpos = 0;
1728 if (eloop_event_add(ctx->eloop, ctx->control_fd, ELE_READ,
1729 dhcpcd_readdump2, ctx) == -1)
1730 logerr("%s: eloop_event_add", __func__);
1731 return;
1732
1733 err:
1734 logerr(__func__);
1735 eloop_exit(ctx->eloop, EXIT_FAILURE);
1736 }
1737
1738 static void
1739 dhcpcd_readdump0(void *arg, unsigned short events)
1740 {
1741 struct dhcpcd_ctx *ctx = arg;
1742 ssize_t len;
1743
1744 if (events != ELE_READ)
1745 logerrx("%s: unexpected event 0x%04x", __func__, events);
1746
1747 len = read(ctx->control_fd, &ctx->ctl_extra, sizeof(ctx->ctl_extra));
1748 if (len != sizeof(ctx->ctl_extra)) {
1749 if (len != -1)
1750 errno = EINVAL;
1751 logerr(__func__);
1752 eloop_exit(ctx->eloop, EXIT_FAILURE);
1753 return;
1754 }
1755
1756 if (ctx->ctl_extra == 0) {
1757 eloop_exit(ctx->eloop, EXIT_SUCCESS);
1758 return;
1759 }
1760
1761 if (eloop_event_add(ctx->eloop, ctx->control_fd, ELE_READ,
1762 dhcpcd_readdump1, ctx) == -1)
1763 logerr("%s: eloop_event_add", __func__);
1764 }
1765
1766 static void
1767 dhcpcd_readdumptimeout(void *arg)
1768 {
1769 struct dhcpcd_ctx *ctx = arg;
1770
1771 logerrx(__func__);
1772 eloop_exit(ctx->eloop, EXIT_FAILURE);
1773 }
1774
1775 static int
1776 dhcpcd_readdump(struct dhcpcd_ctx *ctx)
1777 {
1778
1779 ctx->options |= DHCPCD_FORKED;
1780 if (eloop_timeout_add_sec(ctx->eloop, 5,
1781 dhcpcd_readdumptimeout, ctx) == -1)
1782 return -1;
1783 return eloop_event_add(ctx->eloop, ctx->control_fd, ELE_READ,
1784 dhcpcd_readdump0, ctx);
1785 }
1786
1787 static void
1788 dhcpcd_fork_cb(void *arg, unsigned short events)
1789 {
1790 struct dhcpcd_ctx *ctx = arg;
1791 int exit_code;
1792 ssize_t len;
1793
1794 if (!(events & ELE_READ))
1795 logerrx("%s: unexpected event 0x%04x", __func__, events);
1796
1797 len = read(ctx->fork_fd, &exit_code, sizeof(exit_code));
1798 if (len == -1) {
1799 logerr(__func__);
1800 exit_code = EXIT_FAILURE;
1801 } else if ((size_t)len < sizeof(exit_code)) {
1802 logerrx("%s: truncated read %zd (expected %zu)",
1803 __func__, len, sizeof(exit_code));
1804 exit_code = EXIT_FAILURE;
1805 }
1806 if (ctx->options & DHCPCD_FORKED)
1807 eloop_exit(ctx->eloop, exit_code);
1808 else
1809 dhcpcd_signal_cb(exit_code, ctx);
1810 }
1811
1812 static void
1813 dhcpcd_stderr_cb(void *arg, unsigned short events)
1814 {
1815 struct dhcpcd_ctx *ctx = arg;
1816 char log[BUFSIZ];
1817 ssize_t len;
1818
1819 if (events & ELE_HANGUP)
1820 eloop_exit(ctx->eloop, EXIT_SUCCESS);
1821
1822 if (!(events & ELE_READ))
1823 return;
1824
1825 len = read(ctx->stderr_fd, log, sizeof(log));
1826 if (len == -1) {
1827 if (errno != ECONNRESET)
1828 logerr(__func__);
1829 return;
1830 }
1831
1832 log[len] = '\0';
1833 fprintf(stderr, "%s", log);
1834 }
1835
1836 static void
1837 dhcpcd_pidfile_timeout(void *arg)
1838 {
1839 struct dhcpcd_ctx *ctx = arg;
1840 pid_t pid;
1841
1842 pid = pidfile_read(ctx->pidfile);
1843
1844 if(pid == -1)
1845 eloop_exit(ctx->eloop, EXIT_SUCCESS);
1846 else if (++ctx->duid_len >= 100) { /* overload duid_len */
1847 logerrx("pid %d failed to exit", pid);
1848 eloop_exit(ctx->eloop, EXIT_FAILURE);
1849 } else
1850 eloop_timeout_add_msec(ctx->eloop, 100,
1851 dhcpcd_pidfile_timeout, ctx);
1852 }
1853
1854 int
1855 main(int argc, char **argv, char **envp)
1856 {
1857 struct dhcpcd_ctx ctx;
1858 struct ifaddrs *ifaddrs = NULL;
1859 struct if_options *ifo;
1860 struct interface *ifp;
1861 sa_family_t family = AF_UNSPEC;
1862 int opt, oi = 0, i;
1863 unsigned int logopts, t;
1864 ssize_t len;
1865 #if defined(USE_SIGNALS) || !defined(THERE_IS_NO_FORK)
1866 pid_t pid;
1867 int fork_fd[2], stderr_fd[2];
1868 #endif
1869 #ifdef USE_SIGNALS
1870 int sig = 0;
1871 const char *siga = NULL;
1872 size_t si;
1873 #endif
1874
1875 #ifdef SETPROCTITLE_H
1876 setproctitle_init(argc, argv, envp);
1877 #else
1878 UNUSED(envp);
1879 #endif
1880
1881 /* Test for --help and --version */
1882 if (argc > 1) {
1883 if (strcmp(argv[1], "--help") == 0) {
1884 usage();
1885 return EXIT_SUCCESS;
1886 } else if (strcmp(argv[1], "--version") == 0) {
1887 printf(""PACKAGE" "VERSION"\n%s\n", dhcpcd_copyright);
1888 printf("Compiled in features:"
1889 #ifdef INET
1890 " INET"
1891 #endif
1892 #ifdef ARP
1893 " ARP"
1894 #endif
1895 #ifdef ARPING
1896 " ARPing"
1897 #endif
1898 #ifdef IPV4LL
1899 " IPv4LL"
1900 #endif
1901 #ifdef INET6
1902 " INET6"
1903 #endif
1904 #ifdef DHCP6
1905 " DHCPv6"
1906 #endif
1907 #ifdef AUTH
1908 " AUTH"
1909 #endif
1910 #ifdef PRIVSEP
1911 " PRIVSEP"
1912 #endif
1913 "\n");
1914 return EXIT_SUCCESS;
1915 }
1916 }
1917
1918 memset(&ctx, 0, sizeof(ctx));
1919
1920 ifo = NULL;
1921 ctx.cffile = CONFIG;
1922 ctx.script = UNCONST(dhcpcd_default_script);
1923 ctx.control_fd = ctx.control_unpriv_fd = ctx.link_fd = -1;
1924 ctx.pf_inet_fd = -1;
1925 #ifdef PF_LINK
1926 ctx.pf_link_fd = -1;
1927 #endif
1928
1929 TAILQ_INIT(&ctx.control_fds);
1930 #ifdef USE_SIGNALS
1931 ctx.fork_fd = -1;
1932 #endif
1933 #ifdef PLUGIN_DEV
1934 ctx.dev_fd = -1;
1935 #endif
1936 #ifdef INET
1937 ctx.udp_rfd = -1;
1938 ctx.udp_wfd = -1;
1939 #endif
1940 #if defined(INET6) && !defined(__sun)
1941 ctx.nd_fd = -1;
1942 #endif
1943 #ifdef DHCP6
1944 ctx.dhcp6_rfd = -1;
1945 ctx.dhcp6_wfd = -1;
1946 #endif
1947 #ifdef PRIVSEP
1948 ctx.ps_log_fd = -1;
1949 TAILQ_INIT(&ctx.ps_processes);
1950 #endif
1951
1952 /* Check our streams for validity */
1953 ctx.stdin_valid = fcntl(STDIN_FILENO, F_GETFD) != -1;
1954 ctx.stdout_valid = fcntl(STDOUT_FILENO, F_GETFD) != -1;
1955 ctx.stderr_valid = fcntl(STDERR_FILENO, F_GETFD) != -1;
1956
1957 logopts = LOGERR_LOG | LOGERR_LOG_DATE | LOGERR_LOG_PID;
1958 if (ctx.stderr_valid)
1959 logopts |= LOGERR_ERR;
1960
1961 i = 0;
1962
1963 while ((opt = getopt_long(argc, argv,
1964 ctx.options & DHCPCD_PRINT_PIDFILE ? NOERR_IF_OPTS : IF_OPTS,
1965 cf_options, &oi)) != -1)
1966 {
1967 switch (opt) {
1968 case '4':
1969 family = AF_INET;
1970 break;
1971 case '6':
1972 family = AF_INET6;
1973 break;
1974 case 'f':
1975 ctx.cffile = optarg;
1976 break;
1977 case 'j':
1978 free(ctx.logfile);
1979 ctx.logfile = strdup(optarg);
1980 break;
1981 #ifdef USE_SIGNALS
1982 case 'k':
1983 sig = SIGALRM;
1984 siga = "ALRM";
1985 break;
1986 case 'n':
1987 sig = SIGHUP;
1988 siga = "HUP";
1989 break;
1990 case 'q':
1991 /* -qq disables console output entirely.
1992 * This is important for systemd because it logs
1993 * both console AND syslog to the same log
1994 * resulting in untold confusion. */
1995 if (logopts & LOGERR_QUIET)
1996 logopts &= ~LOGERR_ERR;
1997 else
1998 logopts |= LOGERR_QUIET;
1999 break;
2000 case 'x':
2001 sig = SIGTERM;
2002 siga = "TERM";
2003 break;
2004 case 'N':
2005 sig = SIGUSR1;
2006 siga = "USR1";
2007 break;
2008 #endif
2009 case 'P':
2010 ctx.options |= DHCPCD_PRINT_PIDFILE;
2011 logopts &= ~(LOGERR_LOG | LOGERR_ERR);
2012 break;
2013 case 'T':
2014 i = 1;
2015 logopts &= ~LOGERR_LOG;
2016 break;
2017 case 'U':
2018 i = 3;
2019 break;
2020 case 'V':
2021 i = 2;
2022 break;
2023 case '?':
2024 if (ctx.options & DHCPCD_PRINT_PIDFILE)
2025 continue;
2026 usage();
2027 goto exit_failure;
2028 }
2029 }
2030
2031 if (optind != argc - 1)
2032 ctx.options |= DHCPCD_MANAGER;
2033
2034 logsetopts(logopts);
2035 logopen(ctx.logfile);
2036
2037 ctx.argv = argv;
2038 ctx.argc = argc;
2039 ctx.ifc = argc - optind;
2040 ctx.ifv = argv + optind;
2041
2042 rt_init(&ctx);
2043
2044 ifo = read_config(&ctx, NULL, NULL, NULL);
2045 if (ifo == NULL) {
2046 if (ctx.options & DHCPCD_PRINT_PIDFILE)
2047 goto printpidfile;
2048 goto exit_failure;
2049 }
2050
2051 opt = add_options(&ctx, NULL, ifo, argc, argv);
2052 if (opt != 1) {
2053 if (ctx.options & DHCPCD_PRINT_PIDFILE)
2054 goto printpidfile;
2055 if (opt == 0)
2056 usage();
2057 goto exit_failure;
2058 }
2059 if (i == 2) {
2060 printf("Interface options:\n");
2061 if (optind == argc - 1) {
2062 free_options(&ctx, ifo);
2063 ifo = read_config(&ctx, argv[optind], NULL, NULL);
2064 if (ifo == NULL)
2065 goto exit_failure;
2066 add_options(&ctx, NULL, ifo, argc, argv);
2067 }
2068 if_printoptions();
2069 #ifdef INET
2070 if (family == 0 || family == AF_INET) {
2071 printf("\nDHCPv4 options:\n");
2072 dhcp_printoptions(&ctx,
2073 ifo->dhcp_override, ifo->dhcp_override_len);
2074 }
2075 #endif
2076 #ifdef INET6
2077 if (family == 0 || family == AF_INET6) {
2078 printf("\nND options:\n");
2079 ipv6nd_printoptions(&ctx,
2080 ifo->nd_override, ifo->nd_override_len);
2081 #ifdef DHCP6
2082 printf("\nDHCPv6 options:\n");
2083 dhcp6_printoptions(&ctx,
2084 ifo->dhcp6_override, ifo->dhcp6_override_len);
2085 #endif
2086 }
2087 #endif
2088 goto exit_success;
2089 }
2090 ctx.options |= ifo->options;
2091
2092 if (i == 1 || i == 3) {
2093 if (i == 1)
2094 ctx.options |= DHCPCD_TEST;
2095 else
2096 ctx.options |= DHCPCD_DUMPLEASE;
2097 ctx.options |= DHCPCD_PERSISTENT;
2098 ctx.options &= ~DHCPCD_DAEMONISE;
2099 }
2100
2101 #ifdef THERE_IS_NO_FORK
2102 ctx.options &= ~DHCPCD_DAEMONISE;
2103 #endif
2104
2105 if (ctx.options & DHCPCD_DEBUG)
2106 logsetopts(logopts | LOGERR_DEBUG);
2107
2108 if (!(ctx.options & (DHCPCD_TEST | DHCPCD_DUMPLEASE))) {
2109 printpidfile:
2110 /* If we have any other args, we should run as a single dhcpcd
2111 * instance for that interface. */
2112 if (optind == argc - 1 && !(ctx.options & DHCPCD_MANAGER)) {
2113 const char *per;
2114 const char *ifname;
2115
2116 ifname = *ctx.ifv;
2117 if (ifname == NULL || strlen(ifname) > IF_NAMESIZE) {
2118 errno = ifname == NULL ? EINVAL : E2BIG;
2119 logerr("%s: ", ifname);
2120 goto exit_failure;
2121 }
2122 /* Allow a dhcpcd interface per address family */
2123 switch(family) {
2124 case AF_INET:
2125 per = "-4";
2126 break;
2127 case AF_INET6:
2128 per = "-6";
2129 break;
2130 default:
2131 per = "";
2132 }
2133 snprintf(ctx.pidfile, sizeof(ctx.pidfile),
2134 PIDFILE, ifname, per, ".");
2135 } else {
2136 snprintf(ctx.pidfile, sizeof(ctx.pidfile),
2137 PIDFILE, "", "", "");
2138 ctx.options |= DHCPCD_MANAGER;
2139
2140 /*
2141 * If we are given any interfaces, we
2142 * cannot send a signal as that would impact
2143 * other interfaces.
2144 */
2145 if (optind != argc)
2146 sig = 0;
2147 }
2148 if (ctx.options & DHCPCD_PRINT_PIDFILE) {
2149 printf("%s\n", ctx.pidfile);
2150 goto exit_success;
2151 }
2152 }
2153
2154 if (chdir("/") == -1)
2155 logerr("%s: chdir: /", __func__);
2156
2157 /* Freeing allocated addresses from dumping leases can trigger
2158 * eloop removals as well, so init here. */
2159 if ((ctx.eloop = eloop_new()) == NULL) {
2160 logerr("%s: eloop_init", __func__);
2161 goto exit_failure;
2162 }
2163
2164 #ifdef USE_SIGNALS
2165 for (si = 0; si < dhcpcd_signals_ignore_len; si++)
2166 signal(dhcpcd_signals_ignore[si], SIG_IGN);
2167
2168 /* Save signal mask, block and redirect signals to our handler */
2169 eloop_signal_set_cb(ctx.eloop,
2170 dhcpcd_signals, dhcpcd_signals_len,
2171 dhcpcd_signal_cb, &ctx);
2172 if (eloop_signal_mask(ctx.eloop, &ctx.sigset) == -1) {
2173 logerr("%s: eloop_signal_mask", __func__);
2174 goto exit_failure;
2175 }
2176
2177 if (sig != 0) {
2178 pid = pidfile_read(ctx.pidfile);
2179 if (pid != 0 && pid != -1)
2180 loginfox("sending signal %s to pid %d", siga, pid);
2181 if (pid == 0 || pid == -1 || kill(pid, sig) != 0) {
2182 if (pid != 0 && pid != -1 && errno != ESRCH) {
2183 logerr("kill");
2184 goto exit_failure;
2185 }
2186 unlink(ctx.pidfile);
2187 /* We can still continue and send the command
2188 * via the control socket. */
2189 } else {
2190 if (sig == SIGHUP || sig == SIGUSR1)
2191 goto exit_success;
2192 /* Spin until it exits */
2193 loginfox("waiting for pid %d to exit", pid);
2194 dhcpcd_pidfile_timeout(&ctx);
2195 goto run_loop;
2196 }
2197 }
2198 #endif
2199
2200 #ifdef PRIVSEP
2201 ps_init(&ctx);
2202 #endif
2203
2204 #ifndef SMALL
2205 if (ctx.options & DHCPCD_DUMPLEASE &&
2206 ioctl(fileno(stdin), FIONREAD, &i, sizeof(i)) == 0 &&
2207 i > 0)
2208 {
2209 ctx.options |= DHCPCD_FORKED; /* pretend child process */
2210 #ifdef PRIVSEP
2211 if (IN_PRIVSEP(&ctx) && ps_managersandbox(&ctx, NULL) == -1)
2212 goto exit_failure;
2213 #endif
2214 ifp = calloc(1, sizeof(*ifp));
2215 if (ifp == NULL) {
2216 logerr(__func__);
2217 goto exit_failure;
2218 }
2219 ifp->ctx = &ctx;
2220 ifp->options = ifo;
2221 switch (family) {
2222 case AF_INET:
2223 #ifdef INET
2224 if (dhcp_dump(ifp) == -1)
2225 goto exit_failure;
2226 break;
2227 #else
2228 logerrx("No DHCP support");
2229 goto exit_failure;
2230 #endif
2231 case AF_INET6:
2232 #ifdef DHCP6
2233 if (dhcp6_dump(ifp) == -1)
2234 goto exit_failure;
2235 break;
2236 #else
2237 logerrx("No DHCP6 support");
2238 goto exit_failure;
2239 #endif
2240 default:
2241 logerrx("Family not specified. Please use -4 or -6.");
2242 goto exit_failure;
2243 }
2244 goto exit_success;
2245 }
2246 #endif
2247
2248 /* Try and contact the manager process to send the instruction. */
2249 if (!(ctx.options & DHCPCD_TEST)) {
2250 ctx.options |= DHCPCD_FORKED; /* avoid socket unlink */
2251 if (!(ctx.options & DHCPCD_MANAGER))
2252 ctx.control_fd = control_open(argv[optind], family,
2253 ctx.options & DHCPCD_DUMPLEASE);
2254 if (!(ctx.options & DHCPCD_MANAGER) && ctx.control_fd == -1)
2255 ctx.control_fd = control_open(argv[optind], AF_UNSPEC,
2256 ctx.options & DHCPCD_DUMPLEASE);
2257 if (ctx.control_fd == -1)
2258 ctx.control_fd = control_open(NULL, AF_UNSPEC,
2259 ctx.options & DHCPCD_DUMPLEASE);
2260 if (ctx.control_fd != -1) {
2261 #ifdef PRIVSEP
2262 if (IN_PRIVSEP(&ctx) &&
2263 ps_managersandbox(&ctx, NULL) == -1)
2264 goto exit_failure;
2265 #endif
2266 if (!(ctx.options & DHCPCD_DUMPLEASE))
2267 loginfox("sending commands to dhcpcd process");
2268 len = control_send(&ctx, argc, argv);
2269 if (len > 0)
2270 logdebugx("send OK");
2271 else {
2272 logerr("%s: control_send", __func__);
2273 goto exit_failure;
2274 }
2275 if (ctx.options & DHCPCD_DUMPLEASE) {
2276 if (dhcpcd_readdump(&ctx) == -1) {
2277 logerr("%s: dhcpcd_readdump", __func__);
2278 goto exit_failure;
2279 }
2280 goto run_loop;
2281 }
2282 goto exit_success;
2283 } else {
2284 if (errno != ENOENT)
2285 logerr("%s: control_open", __func__);
2286 /* If asking dhcpcd to exit and we failed to
2287 * send a signal or a message then we
2288 * don't proceed past here. */
2289 if (ctx.options & DHCPCD_DUMPLEASE ||
2290 sig == SIGTERM || sig == SIGALRM)
2291 {
2292 if (errno == ENOENT)
2293 logerrx(PACKAGE" is not running");
2294 goto exit_failure;
2295 }
2296 if (errno == EPERM || errno == EACCES)
2297 goto exit_failure;
2298 }
2299 ctx.options &= ~DHCPCD_FORKED;
2300 }
2301
2302 if (!(ctx.options & DHCPCD_TEST)) {
2303 /* Ensure we have the needed directories */
2304 if (mkdir(DBDIR, 0750) == -1 && errno != EEXIST)
2305 logerr("%s: mkdir: %s", __func__, DBDIR);
2306 if (mkdir(RUNDIR, 0755) == -1 && errno != EEXIST)
2307 logerr("%s: mkdir: %s", __func__, RUNDIR);
2308 if ((pid = pidfile_lock(ctx.pidfile)) != 0) {
2309 if (pid == -1)
2310 logerr("%s: pidfile_lock: %s",
2311 __func__, ctx.pidfile);
2312 else
2313 logerrx(PACKAGE
2314 " already running on pid %d (%s)",
2315 pid, ctx.pidfile);
2316 goto exit_failure;
2317 }
2318 }
2319
2320 loginfox(PACKAGE "-" VERSION " starting");
2321 if (ctx.stdin_valid && freopen(_PATH_DEVNULL, "w", stdin) == NULL)
2322 logwarn("freopen stdin");
2323
2324 #if defined(USE_SIGNALS) && !defined(THERE_IS_NO_FORK)
2325 if (!(ctx.options & DHCPCD_DAEMONISE))
2326 goto start_manager;
2327
2328 if (xsocketpair(AF_UNIX, SOCK_SEQPACKET|SOCK_CXNB, 0, fork_fd) == -1 ||
2329 (ctx.stderr_valid &&
2330 xsocketpair(AF_UNIX, SOCK_SEQPACKET|SOCK_CXNB, 0, stderr_fd) == -1))
2331 {
2332 logerr("socketpair");
2333 goto exit_failure;
2334 }
2335 switch (pid = fork()) {
2336 case -1:
2337 logerr("fork");
2338 goto exit_failure;
2339 case 0:
2340 ctx.fork_fd = fork_fd[1];
2341 close(fork_fd[0]);
2342 #ifdef PRIVSEP_RIGHTS
2343 if (ps_rights_limit_fd(ctx.fork_fd) == -1) {
2344 logerr("ps_rights_limit_fdpair");
2345 goto exit_failure;
2346 }
2347 #endif
2348 if (eloop_event_add(ctx.eloop, ctx.fork_fd, ELE_READ,
2349 dhcpcd_fork_cb, &ctx) == -1)
2350 logerr("%s: eloop_event_add", __func__);
2351
2352 /*
2353 * Redirect stderr to the stderr socketpair.
2354 * Redirect stdout as well.
2355 * dhcpcd doesn't output via stdout, but something in
2356 * a called script might.
2357 */
2358 if (ctx.stderr_valid) {
2359 if (dup2(stderr_fd[1], STDERR_FILENO) == -1 ||
2360 (ctx.stdout_valid &&
2361 dup2(stderr_fd[1], STDOUT_FILENO) == -1))
2362 logerr("dup2");
2363 close(stderr_fd[0]);
2364 close(stderr_fd[1]);
2365 } else if (ctx.stdout_valid) {
2366 if (freopen(_PATH_DEVNULL, "w", stdout) == NULL)
2367 logerr("freopen stdout");
2368 }
2369 if (setsid() == -1) {
2370 logerr("%s: setsid", __func__);
2371 goto exit_failure;
2372 }
2373 /* Ensure we can never get a controlling terminal */
2374 switch (pid = fork()) {
2375 case -1:
2376 logerr("fork");
2377 goto exit_failure;
2378 case 0:
2379 eloop_forked(ctx.eloop);
2380 break;
2381 default:
2382 ctx.options |= DHCPCD_FORKED; /* A lie */
2383 i = EXIT_SUCCESS;
2384 goto exit1;
2385 }
2386 break;
2387 default:
2388 setproctitle("[launcher]");
2389 ctx.options |= DHCPCD_FORKED | DHCPCD_LAUNCHER;
2390 ctx.fork_fd = fork_fd[0];
2391 close(fork_fd[1]);
2392 #ifdef PRIVSEP_RIGHTS
2393 if (ps_rights_limit_fd(ctx.fork_fd) == -1) {
2394 logerr("ps_rights_limit_fd");
2395 goto exit_failure;
2396 }
2397 #endif
2398 if (eloop_event_add(ctx.eloop, ctx.fork_fd, ELE_READ,
2399 dhcpcd_fork_cb, &ctx) == -1)
2400 logerr("%s: eloop_event_add", __func__);
2401
2402 if (ctx.stderr_valid) {
2403 ctx.stderr_fd = stderr_fd[0];
2404 close(stderr_fd[1]);
2405 #ifdef PRIVSEP_RIGHTS
2406 if (ps_rights_limit_fd(ctx.stderr_fd) == 1) {
2407 logerr("ps_rights_limit_fd");
2408 goto exit_failure;
2409 }
2410 #endif
2411 if (eloop_event_add(ctx.eloop, ctx.stderr_fd, ELE_READ,
2412 dhcpcd_stderr_cb, &ctx) == -1)
2413 logerr("%s: eloop_event_add", __func__);
2414 }
2415 #ifdef PRIVSEP
2416 if (IN_PRIVSEP(&ctx) && ps_managersandbox(&ctx, NULL) == -1)
2417 goto exit_failure;
2418 #endif
2419 goto run_loop;
2420 }
2421
2422 /* We have now forked, setsid, forked once more.
2423 * From this point on, we are the controlling daemon. */
2424 logdebugx("spawned manager process on PID %d", getpid());
2425 start_manager:
2426 ctx.options |= DHCPCD_STARTED;
2427 if ((pid = pidfile_lock(ctx.pidfile)) != 0) {
2428 logerr("%s: pidfile_lock %d", __func__, pid);
2429 #ifdef PRIVSEP
2430 /* privsep has not started ... */
2431 ctx.options &= ~DHCPCD_PRIVSEP;
2432 #endif
2433 goto exit_failure;
2434 }
2435 #endif
2436
2437 os_init();
2438
2439 #if defined(BSD) && defined(INET6)
2440 /* Disable the kernel RTADV sysctl as early as possible. */
2441 if (ctx.options & DHCPCD_IPV6 && ctx.options & DHCPCD_IPV6RS)
2442 if_disable_rtadv();
2443 #endif
2444
2445 #ifdef PRIVSEP
2446 if (IN_PRIVSEP(&ctx) && ps_start(&ctx) == -1) {
2447 logerr("ps_start");
2448 goto exit_failure;
2449 }
2450 if (ctx.options & DHCPCD_FORKED)
2451 goto run_loop;
2452 #endif
2453
2454 if (!(ctx.options & DHCPCD_TEST)) {
2455 if (control_start(&ctx,
2456 ctx.options & DHCPCD_MANAGER ?
2457 NULL : argv[optind], family) == -1)
2458 {
2459 logerr("%s: control_start", __func__);
2460 goto exit_failure;
2461 }
2462 }
2463
2464 #ifdef PLUGIN_DEV
2465 /* Start any dev listening plugin which may want to
2466 * change the interface name provided by the kernel */
2467 if (!IN_PRIVSEP(&ctx) &&
2468 (ctx.options & (DHCPCD_MANAGER | DHCPCD_DEV)) ==
2469 (DHCPCD_MANAGER | DHCPCD_DEV))
2470 dev_start(&ctx, dhcpcd_handleinterface);
2471 #endif
2472
2473 setproctitle("%s%s%s",
2474 ctx.options & DHCPCD_MANAGER ? "[manager]" : argv[optind],
2475 ctx.options & DHCPCD_IPV4 ? " [ip4]" : "",
2476 ctx.options & DHCPCD_IPV6 ? " [ip6]" : "");
2477
2478 if (if_opensockets(&ctx) == -1) {
2479 logerr("%s: if_opensockets", __func__);
2480 goto exit_failure;
2481 }
2482 #ifndef SMALL
2483 dhcpcd_setlinkrcvbuf(&ctx);
2484 #endif
2485
2486 /* Try and create DUID from the machine UUID. */
2487 dhcpcd_initduid(&ctx, NULL);
2488
2489 /* Cache the default vendor option. */
2490 if (dhcp_vendor(ctx.vendor, sizeof(ctx.vendor)) == -1)
2491 logerr("dhcp_vendor");
2492
2493 /* Start handling kernel messages for interfaces, addresses and
2494 * routes. */
2495 if (eloop_event_add(ctx.eloop, ctx.link_fd, ELE_READ,
2496 dhcpcd_handlelink, &ctx) == -1)
2497 logerr("%s: eloop_event_add", __func__);
2498
2499 #ifdef PRIVSEP
2500 if (IN_PRIVSEP(&ctx) && ps_managersandbox(&ctx, "stdio route") == -1)
2501 goto exit_failure;
2502 #endif
2503
2504 /* When running dhcpcd against a single interface, we need to retain
2505 * the old behaviour of waiting for an IP address */
2506 if (ctx.ifc == 1 && !(ctx.options & DHCPCD_BACKGROUND))
2507 ctx.options |= DHCPCD_WAITIP;
2508
2509 ctx.ifaces = if_discover(&ctx, &ifaddrs, ctx.ifc, ctx.ifv);
2510 if (ctx.ifaces == NULL) {
2511 logerr("%s: if_discover", __func__);
2512 goto exit_failure;
2513 }
2514 for (i = 0; i < ctx.ifc; i++) {
2515 if ((ifp = if_find(ctx.ifaces, ctx.ifv[i])) == NULL)
2516 logerrx("%s: interface not found",
2517 ctx.ifv[i]);
2518 else if (!ifp->active)
2519 logerrx("%s: interface has an invalid configuration",
2520 ctx.ifv[i]);
2521 }
2522 TAILQ_FOREACH(ifp, ctx.ifaces, next) {
2523 if (ifp->active == IF_ACTIVE_USER)
2524 break;
2525 }
2526 if (ifp == NULL) {
2527 if (ctx.ifc == 0) {
2528 int loglevel;
2529
2530 loglevel = ctx.options & DHCPCD_INACTIVE ?
2531 LOG_DEBUG : LOG_ERR;
2532 logmessage(loglevel, "no valid interfaces found");
2533 dhcpcd_daemonise(&ctx);
2534 } else
2535 goto exit_failure;
2536 if (!(ctx.options & DHCPCD_LINK)) {
2537 logerrx("aborting as link detection is disabled");
2538 goto exit_failure;
2539 }
2540 }
2541
2542 TAILQ_FOREACH(ifp, ctx.ifaces, next) {
2543 if (ifp->active)
2544 dhcpcd_initstate1(ifp, argc, argv, 0);
2545 }
2546 if_learnaddrs(&ctx, ctx.ifaces, &ifaddrs);
2547 if_freeifaddrs(&ctx, &ifaddrs);
2548 ifaddrs = NULL;
2549
2550 if (ctx.options & DHCPCD_BACKGROUND)
2551 dhcpcd_daemonise(&ctx);
2552
2553 opt = 0;
2554 TAILQ_FOREACH(ifp, ctx.ifaces, next) {
2555 if (ifp->active) {
2556 run_preinit(ifp);
2557 if (if_is_link_up(ifp))
2558 opt = 1;
2559 }
2560 }
2561
2562 if (!(ctx.options & DHCPCD_BACKGROUND)) {
2563 if (ctx.options & DHCPCD_MANAGER)
2564 t = ifo->timeout;
2565 else {
2566 t = 0;
2567 TAILQ_FOREACH(ifp, ctx.ifaces, next) {
2568 if (ifp->active) {
2569 t = ifp->options->timeout;
2570 break;
2571 }
2572 }
2573 }
2574 if (opt == 0 &&
2575 ctx.options & DHCPCD_LINK &&
2576 !(ctx.options & DHCPCD_WAITIP))
2577 {
2578 int loglevel;
2579
2580 loglevel = ctx.options & DHCPCD_INACTIVE ?
2581 LOG_DEBUG : LOG_WARNING;
2582 logmessage(loglevel, "no interfaces have a carrier");
2583 dhcpcd_daemonise(&ctx);
2584 } else if (t > 0 &&
2585 /* Test mode removes the daemonise bit, so check for both */
2586 ctx.options & (DHCPCD_DAEMONISE | DHCPCD_TEST))
2587 {
2588 eloop_timeout_add_sec(ctx.eloop, t,
2589 handle_exit_timeout, &ctx);
2590 }
2591 }
2592 free_options(&ctx, ifo);
2593 ifo = NULL;
2594
2595 TAILQ_FOREACH(ifp, ctx.ifaces, next) {
2596 if (ifp->active)
2597 eloop_timeout_add_sec(ctx.eloop, 0,
2598 dhcpcd_prestartinterface, ifp);
2599 }
2600
2601 run_loop:
2602 i = eloop_start(ctx.eloop, &ctx.sigset);
2603 if (i < 0) {
2604 logerr("%s: eloop_start", __func__);
2605 goto exit_failure;
2606 }
2607 goto exit1;
2608
2609 exit_success:
2610 i = EXIT_SUCCESS;
2611 goto exit1;
2612
2613 exit_failure:
2614 i = EXIT_FAILURE;
2615
2616 exit1:
2617 if (!(ctx.options & DHCPCD_TEST) && control_stop(&ctx) == -1)
2618 logerr("%s: control_stop", __func__);
2619 if_freeifaddrs(&ctx, &ifaddrs);
2620 #ifdef PRIVSEP
2621 ps_stop(&ctx);
2622 #endif
2623 /* Free memory and close fd's */
2624 if (ctx.ifaces) {
2625 while ((ifp = TAILQ_FIRST(ctx.ifaces))) {
2626 TAILQ_REMOVE(ctx.ifaces, ifp, next);
2627 if_free(ifp);
2628 }
2629 free(ctx.ifaces);
2630 ctx.ifaces = NULL;
2631 }
2632 free_options(&ctx, ifo);
2633 #ifdef HAVE_OPEN_MEMSTREAM
2634 if (ctx.script_fp)
2635 fclose(ctx.script_fp);
2636 #endif
2637 free(ctx.script_buf);
2638 free(ctx.script_env);
2639 rt_dispose(&ctx);
2640 free(ctx.duid);
2641 if (ctx.link_fd != -1) {
2642 eloop_event_delete(ctx.eloop, ctx.link_fd);
2643 close(ctx.link_fd);
2644 }
2645 if_closesockets(&ctx);
2646 free_globals(&ctx);
2647 #ifdef INET6
2648 ipv6_ctxfree(&ctx);
2649 #endif
2650 #ifdef PLUGIN_DEV
2651 dev_stop(&ctx);
2652 #endif
2653 if (ctx.script != dhcpcd_default_script)
2654 free(ctx.script);
2655 #ifdef PRIVSEP
2656 if (ps_stopwait(&ctx) != EXIT_SUCCESS)
2657 i = EXIT_FAILURE;
2658 #endif
2659 if (ctx.options & DHCPCD_STARTED && !(ctx.options & DHCPCD_FORKED))
2660 loginfox(PACKAGE " exited");
2661 #ifdef PRIVSEP
2662 if (ps_root_stop(&ctx) == -1)
2663 i = EXIT_FAILURE;
2664 eloop_free(ctx.ps_eloop);
2665 #endif
2666 eloop_free(ctx.eloop);
2667 logclose();
2668 free(ctx.logfile);
2669 free(ctx.ctl_buf);
2670 #ifdef SETPROCTITLE_H
2671 setproctitle_fini();
2672 #endif
2673 #ifdef USE_SIGNALS
2674 if (ctx.options & DHCPCD_STARTED) {
2675 /* Try to detach from the launch process. */
2676 if (ctx.fork_fd != -1 &&
2677 write(ctx.fork_fd, &i, sizeof(i)) == -1)
2678 logerr("%s: write", __func__);
2679 }
2680 if (ctx.options & (DHCPCD_FORKED | DHCPCD_PRIVSEP))
2681 _exit(i); /* so atexit won't remove our pidfile */
2682 #endif
2683 return i;
2684 }
DragonFly BSD