1 /* SPDX-License-Identifier: BSD-2-Clause */
2 /*
3 * dhcpcd - DHCP client daemon
4 * Copyright (c) 2006-2021 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-2021 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
usage(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
free_globals(struct dhcpcd_ctx * ctx)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
handle_exit_timeout(void * arg)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 *
dhcpcd_af(int af)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
dhcpcd_ifafwaiting(const struct interface * ifp)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_INET;
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
dhcpcd_afwaiting(const struct dhcpcd_ctx * ctx)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
dhcpcd_ipwaited(struct dhcpcd_ctx * ctx)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
dhcpcd_daemonise(struct dhcpcd_ctx * ctx)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
dhcpcd_drop(struct interface * ifp,int stop)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
stop_interface(struct interface * ifp,const char * reason)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
configure_interface1(struct interface * ifp)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
dhcpcd_selectprofile(struct interface * ifp,const char * profile)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
configure_interface(struct interface * ifp,int argc,char ** argv,unsigned long long options)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
dhcpcd_initstate2(struct interface * ifp,unsigned long long options)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
dhcpcd_initstate1(struct interface * ifp,int argc,char ** argv,unsigned long long options)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
dhcpcd_initstate(struct interface * ifp,unsigned long long options)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
dhcpcd_reportssid(struct interface * ifp)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
dhcpcd_nocarrier_roaming(struct interface * ifp)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
dhcpcd_handlecarrier(struct interface * ifp,int carrier,unsigned int flags)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
warn_iaid_conflict(struct interface * ifp,uint16_t ia_type,uint8_t * iaid)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
dhcpcd_initduid(struct dhcpcd_ctx * ctx,struct interface * ifp)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
dhcpcd_startinterface(void * arg)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
dhcpcd_prestartinterface(void * arg)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
run_preinit(struct interface * ifp)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
dhcpcd_activateinterface(struct interface * ifp,unsigned long long options)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
dhcpcd_handleinterface(void * arg,int action,const char * ifname)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
1109 return e;
1110 }
1111
1112 static void
dhcpcd_handlelink(void * arg)1113 dhcpcd_handlelink(void *arg)
1114 {
1115 struct dhcpcd_ctx *ctx = arg;
1116
1117 if (if_handlelink(ctx) == -1) {
1118 if (errno == ENOBUFS || errno == ENOMEM) {
1119 dhcpcd_linkoverflow(ctx);
1120 return;
1121 }
1122 if (errno != ENOTSUP)
1123 logerr(__func__);
1124 }
1125 }
1126
1127 static void
dhcpcd_checkcarrier(void * arg)1128 dhcpcd_checkcarrier(void *arg)
1129 {
1130 struct interface *ifp0 = arg, *ifp;
1131
1132 ifp = if_find(ifp0->ctx->ifaces, ifp0->name);
1133 if (ifp == NULL || ifp->carrier == ifp0->carrier)
1134 return;
1135
1136 dhcpcd_handlecarrier(ifp, ifp0->carrier, ifp0->flags);
1137 if_free(ifp0);
1138 }
1139
1140 #ifndef SMALL
1141 static void
dhcpcd_setlinkrcvbuf(struct dhcpcd_ctx * ctx)1142 dhcpcd_setlinkrcvbuf(struct dhcpcd_ctx *ctx)
1143 {
1144 socklen_t socklen;
1145
1146 if (ctx->link_rcvbuf == 0)
1147 return;
1148
1149 logdebugx("setting route socket receive buffer size to %d bytes",
1150 ctx->link_rcvbuf);
1151
1152 socklen = sizeof(ctx->link_rcvbuf);
1153 if (setsockopt(ctx->link_fd, SOL_SOCKET,
1154 SO_RCVBUF, &ctx->link_rcvbuf, socklen) == -1)
1155 logerr(__func__);
1156 }
1157 #endif
1158
1159 static void
dhcpcd_runprestartinterface(void * arg)1160 dhcpcd_runprestartinterface(void *arg)
1161 {
1162 struct interface *ifp = arg;
1163
1164 run_preinit(ifp);
1165 dhcpcd_prestartinterface(ifp);
1166 }
1167
1168 void
dhcpcd_linkoverflow(struct dhcpcd_ctx * ctx)1169 dhcpcd_linkoverflow(struct dhcpcd_ctx *ctx)
1170 {
1171 socklen_t socklen;
1172 int rcvbuflen;
1173 char buf[2048];
1174 ssize_t rlen;
1175 size_t rcnt;
1176 struct if_head *ifaces;
1177 struct ifaddrs *ifaddrs;
1178 struct interface *ifp, *ifn, *ifp1;
1179
1180 socklen = sizeof(rcvbuflen);
1181 if (getsockopt(ctx->link_fd, SOL_SOCKET,
1182 SO_RCVBUF, &rcvbuflen, &socklen) == -1) {
1183 logerr("%s: getsockopt", __func__);
1184 rcvbuflen = 0;
1185 }
1186 #ifdef __linux__
1187 else
1188 rcvbuflen /= 2;
1189 #endif
1190
1191 logerrx("route socket overflowed (rcvbuflen %d)"
1192 " - learning interface state", rcvbuflen);
1193
1194 /* Drain the socket.
1195 * We cannot open a new one due to privsep. */
1196 rcnt = 0;
1197 do {
1198 rlen = read(ctx->link_fd, buf, sizeof(buf));
1199 if (++rcnt % 1000 == 0)
1200 logwarnx("drained %zu messages", rcnt);
1201 } while (rlen != -1 || errno == ENOBUFS || errno == ENOMEM);
1202 if (rcnt % 1000 != 0)
1203 logwarnx("drained %zu messages", rcnt);
1204
1205 /* Work out the current interfaces. */
1206 ifaces = if_discover(ctx, &ifaddrs, ctx->ifc, ctx->ifv);
1207 if (ifaces == NULL) {
1208 logerr(__func__);
1209 return;
1210 }
1211
1212 /* Punt departed interfaces */
1213 TAILQ_FOREACH_SAFE(ifp, ctx->ifaces, next, ifn) {
1214 if (if_find(ifaces, ifp->name) != NULL)
1215 continue;
1216 dhcpcd_handleinterface(ctx, -1, ifp->name);
1217 }
1218
1219 /* Add new interfaces */
1220 while ((ifp = TAILQ_FIRST(ifaces)) != NULL ) {
1221 TAILQ_REMOVE(ifaces, ifp, next);
1222 ifp1 = if_find(ctx->ifaces, ifp->name);
1223 if (ifp1 != NULL) {
1224 /* If the interface already exists,
1225 * check carrier state.
1226 * dhcpcd_checkcarrier will free ifp. */
1227 eloop_timeout_add_sec(ctx->eloop, 0,
1228 dhcpcd_checkcarrier, ifp);
1229 continue;
1230 }
1231 TAILQ_INSERT_TAIL(ctx->ifaces, ifp, next);
1232 if (ifp->active) {
1233 dhcpcd_initstate(ifp, 0);
1234 eloop_timeout_add_sec(ctx->eloop, 0,
1235 dhcpcd_runprestartinterface, ifp);
1236 }
1237 }
1238 free(ifaces);
1239
1240 /* Update address state. */
1241 if_markaddrsstale(ctx->ifaces);
1242 if_learnaddrs(ctx, ctx->ifaces, &ifaddrs);
1243 if_deletestaleaddrs(ctx->ifaces);
1244 }
1245
1246 void
dhcpcd_handlehwaddr(struct interface * ifp,uint16_t hwtype,const void * hwaddr,uint8_t hwlen)1247 dhcpcd_handlehwaddr(struct interface *ifp,
1248 uint16_t hwtype, const void *hwaddr, uint8_t hwlen)
1249 {
1250 char buf[sizeof(ifp->hwaddr) * 3];
1251
1252 if (hwaddr == NULL || !if_valid_hwaddr(hwaddr, hwlen))
1253 hwlen = 0;
1254
1255 if (hwlen > sizeof(ifp->hwaddr)) {
1256 errno = ENOBUFS;
1257 logerr("%s: %s", __func__, ifp->name);
1258 return;
1259 }
1260
1261 if (ifp->hwtype != hwtype) {
1262 if (ifp->active)
1263 loginfox("%s: hardware address type changed"
1264 " from %d to %d", ifp->name, ifp->hwtype, hwtype);
1265 ifp->hwtype = hwtype;
1266 }
1267
1268 if (ifp->hwlen == hwlen &&
1269 (hwlen == 0 || memcmp(ifp->hwaddr, hwaddr, hwlen) == 0))
1270 return;
1271
1272 if (ifp->active) {
1273 loginfox("%s: old hardware address: %s", ifp->name,
1274 hwaddr_ntoa(ifp->hwaddr, ifp->hwlen, buf, sizeof(buf)));
1275 loginfox("%s: new hardware address: %s", ifp->name,
1276 hwaddr_ntoa(hwaddr, hwlen, buf, sizeof(buf)));
1277 }
1278 ifp->hwlen = hwlen;
1279 if (hwaddr != NULL)
1280 memcpy(ifp->hwaddr, hwaddr, hwlen);
1281 }
1282
1283 static void
if_reboot(struct interface * ifp,int argc,char ** argv)1284 if_reboot(struct interface *ifp, int argc, char **argv)
1285 {
1286 #ifdef INET
1287 unsigned long long oldopts;
1288
1289 oldopts = ifp->options->options;
1290 #endif
1291 script_runreason(ifp, "RECONFIGURE");
1292 dhcpcd_initstate1(ifp, argc, argv, 0);
1293 #ifdef INET
1294 dhcp_reboot_newopts(ifp, oldopts);
1295 #endif
1296 #ifdef DHCP6
1297 dhcp6_reboot(ifp);
1298 #endif
1299 dhcpcd_prestartinterface(ifp);
1300 }
1301
1302 static void
reload_config(struct dhcpcd_ctx * ctx)1303 reload_config(struct dhcpcd_ctx *ctx)
1304 {
1305 struct if_options *ifo;
1306
1307 free_globals(ctx);
1308 if ((ifo = read_config(ctx, NULL, NULL, NULL)) == NULL)
1309 return;
1310 add_options(ctx, NULL, ifo, ctx->argc, ctx->argv);
1311 /* We need to preserve these options. */
1312 if (ctx->options & DHCPCD_STARTED)
1313 ifo->options |= DHCPCD_STARTED;
1314 if (ctx->options & DHCPCD_MANAGER)
1315 ifo->options |= DHCPCD_MANAGER;
1316 if (ctx->options & DHCPCD_DAEMONISED)
1317 ifo->options |= DHCPCD_DAEMONISED;
1318 if (ctx->options & DHCPCD_PRIVSEP)
1319 ifo->options |= DHCPCD_PRIVSEP;
1320 ctx->options = ifo->options;
1321 free_options(ctx, ifo);
1322 }
1323
1324 static void
reconf_reboot(struct dhcpcd_ctx * ctx,int action,int argc,char ** argv,int oi)1325 reconf_reboot(struct dhcpcd_ctx *ctx, int action, int argc, char **argv, int oi)
1326 {
1327 int i;
1328 struct interface *ifp;
1329
1330 TAILQ_FOREACH(ifp, ctx->ifaces, next) {
1331 for (i = oi; i < argc; i++) {
1332 if (strcmp(ifp->name, argv[i]) == 0)
1333 break;
1334 }
1335 if (oi != argc && i == argc)
1336 continue;
1337 if (ifp->active == IF_ACTIVE_USER) {
1338 if (action)
1339 if_reboot(ifp, argc, argv);
1340 #ifdef INET
1341 else
1342 ipv4_applyaddr(ifp);
1343 #endif
1344 } else if (i != argc) {
1345 ifp->active = IF_ACTIVE_USER;
1346 dhcpcd_initstate1(ifp, argc, argv, 0);
1347 run_preinit(ifp);
1348 dhcpcd_prestartinterface(ifp);
1349 }
1350 }
1351 }
1352
1353 static void
stop_all_interfaces(struct dhcpcd_ctx * ctx,unsigned long long opts)1354 stop_all_interfaces(struct dhcpcd_ctx *ctx, unsigned long long opts)
1355 {
1356 struct interface *ifp;
1357
1358 ctx->options |= DHCPCD_EXITING;
1359 if (ctx->ifaces == NULL)
1360 return;
1361
1362 /* Drop the last interface first */
1363 TAILQ_FOREACH_REVERSE(ifp, ctx->ifaces, if_head, next) {
1364 if (!ifp->active)
1365 continue;
1366 ifp->options->options |= opts;
1367 if (ifp->options->options & DHCPCD_RELEASE)
1368 ifp->options->options &= ~DHCPCD_PERSISTENT;
1369 ifp->options->options |= DHCPCD_EXITING;
1370 stop_interface(ifp, NULL);
1371 }
1372 }
1373
1374 static void
dhcpcd_ifrenew(struct interface * ifp)1375 dhcpcd_ifrenew(struct interface *ifp)
1376 {
1377
1378 if (!ifp->active)
1379 return;
1380
1381 if (ifp->options->options & DHCPCD_LINK && !if_is_link_up(ifp))
1382 return;
1383
1384 #ifdef INET
1385 dhcp_renew(ifp);
1386 #endif
1387 #ifdef INET6
1388 #define DHCPCD_RARENEW (DHCPCD_IPV6 | DHCPCD_IPV6RS)
1389 if ((ifp->options->options & DHCPCD_RARENEW) == DHCPCD_RARENEW)
1390 ipv6nd_startrs(ifp);
1391 #endif
1392 #ifdef DHCP6
1393 dhcp6_renew(ifp);
1394 #endif
1395 }
1396
1397 static void
dhcpcd_renew(struct dhcpcd_ctx * ctx)1398 dhcpcd_renew(struct dhcpcd_ctx *ctx)
1399 {
1400 struct interface *ifp;
1401
1402 TAILQ_FOREACH(ifp, ctx->ifaces, next) {
1403 dhcpcd_ifrenew(ifp);
1404 }
1405 }
1406
1407 #ifdef USE_SIGNALS
1408 #define sigmsg "received %s, %s"
1409 static void
dhcpcd_signal_cb(int sig,void * arg)1410 dhcpcd_signal_cb(int sig, void *arg)
1411 {
1412 struct dhcpcd_ctx *ctx = arg;
1413 unsigned long long opts;
1414 int exit_code;
1415
1416 if (ctx->options & DHCPCD_DUMPLEASE) {
1417 eloop_exit(ctx->eloop, EXIT_FAILURE);
1418 return;
1419 }
1420
1421 if (sig != SIGCHLD && ctx->options & DHCPCD_FORKED) {
1422 if (sig != SIGHUP &&
1423 write(ctx->fork_fd, &sig, sizeof(sig)) == -1)
1424 logerr("%s: write", __func__);
1425 return;
1426 }
1427
1428 opts = 0;
1429 exit_code = EXIT_FAILURE;
1430 switch (sig) {
1431 case SIGINT:
1432 loginfox(sigmsg, "SIGINT", "stopping");
1433 break;
1434 case SIGTERM:
1435 loginfox(sigmsg, "SIGTERM", "stopping");
1436 exit_code = EXIT_SUCCESS;
1437 break;
1438 case SIGALRM:
1439 loginfox(sigmsg, "SIGALRM", "releasing");
1440 opts |= DHCPCD_RELEASE;
1441 exit_code = EXIT_SUCCESS;
1442 break;
1443 case SIGHUP:
1444 loginfox(sigmsg, "SIGHUP", "rebinding");
1445 reload_config(ctx);
1446 /* Preserve any options passed on the commandline
1447 * when we were started. */
1448 reconf_reboot(ctx, 1, ctx->argc, ctx->argv,
1449 ctx->argc - ctx->ifc);
1450 return;
1451 case SIGUSR1:
1452 loginfox(sigmsg, "SIGUSR1", "renewing");
1453 dhcpcd_renew(ctx);
1454 return;
1455 case SIGUSR2:
1456 loginfox(sigmsg, "SIGUSR2", "reopening log");
1457 #ifdef PRIVSEP
1458 if (IN_PRIVSEP(ctx)) {
1459 if (ps_root_logreopen(ctx) == -1)
1460 logerr("ps_root_logreopen");
1461 return;
1462 }
1463 #endif
1464 if (logopen(ctx->logfile) == -1)
1465 logerr("logopen");
1466 return;
1467 case SIGCHLD:
1468 while (waitpid(-1, NULL, WNOHANG) > 0)
1469 ;
1470 return;
1471 default:
1472 logerrx("received signal %d but don't know what to do with it",
1473 sig);
1474 return;
1475 }
1476
1477 if (!(ctx->options & DHCPCD_TEST))
1478 stop_all_interfaces(ctx, opts);
1479 eloop_exit(ctx->eloop, exit_code);
1480 }
1481 #endif
1482
1483 int
dhcpcd_handleargs(struct dhcpcd_ctx * ctx,struct fd_list * fd,int argc,char ** argv)1484 dhcpcd_handleargs(struct dhcpcd_ctx *ctx, struct fd_list *fd,
1485 int argc, char **argv)
1486 {
1487 struct interface *ifp;
1488 unsigned long long opts;
1489 int opt, oi, do_reboot, do_renew, af = AF_UNSPEC;
1490 size_t len, l, nifaces;
1491 char *tmp, *p;
1492
1493 /* Special commands for our control socket
1494 * as the other end should be blocking until it gets the
1495 * expected reply we should be safely able just to change the
1496 * write callback on the fd */
1497 /* Make any change here in privsep-control.c as well. */
1498 if (strcmp(*argv, "--version") == 0) {
1499 return control_queue(fd, UNCONST(VERSION),
1500 strlen(VERSION) + 1);
1501 } else if (strcmp(*argv, "--getconfigfile") == 0) {
1502 return control_queue(fd, UNCONST(fd->ctx->cffile),
1503 strlen(fd->ctx->cffile) + 1);
1504 } else if (strcmp(*argv, "--getinterfaces") == 0) {
1505 optind = argc = 0;
1506 goto dumplease;
1507 } else if (strcmp(*argv, "--listen") == 0) {
1508 fd->flags |= FD_LISTEN;
1509 return 0;
1510 }
1511
1512 /* Log the command */
1513 len = 1;
1514 for (opt = 0; opt < argc; opt++)
1515 len += strlen(argv[opt]) + 1;
1516 tmp = malloc(len);
1517 if (tmp == NULL)
1518 return -1;
1519 p = tmp;
1520 for (opt = 0; opt < argc; opt++) {
1521 l = strlen(argv[opt]);
1522 strlcpy(p, argv[opt], len);
1523 len -= l + 1;
1524 p += l;
1525 *p++ = ' ';
1526 }
1527 *--p = '\0';
1528 loginfox("control command: %s", tmp);
1529 free(tmp);
1530
1531 optind = 0;
1532 oi = 0;
1533 opts = 0;
1534 do_reboot = do_renew = 0;
1535 while ((opt = getopt_long(argc, argv, IF_OPTS, cf_options, &oi)) != -1)
1536 {
1537 switch (opt) {
1538 case 'g':
1539 /* Assumed if below not set */
1540 break;
1541 case 'k':
1542 opts |= DHCPCD_RELEASE;
1543 break;
1544 case 'n':
1545 do_reboot = 1;
1546 break;
1547 case 'p':
1548 opts |= DHCPCD_PERSISTENT;
1549 break;
1550 case 'x':
1551 opts |= DHCPCD_EXITING;
1552 break;
1553 case 'N':
1554 do_renew = 1;
1555 break;
1556 case 'U':
1557 opts |= DHCPCD_DUMPLEASE;
1558 break;
1559 case '4':
1560 af = AF_INET;
1561 break;
1562 case '6':
1563 af = AF_INET6;
1564 break;
1565 }
1566 }
1567
1568 if (opts & DHCPCD_DUMPLEASE) {
1569 ctx->options |= DHCPCD_DUMPLEASE;
1570 dumplease:
1571 nifaces = 0;
1572 TAILQ_FOREACH(ifp, ctx->ifaces, next) {
1573 if (!ifp->active)
1574 continue;
1575 for (oi = optind; oi < argc; oi++) {
1576 if (strcmp(ifp->name, argv[oi]) == 0)
1577 break;
1578 }
1579 if (optind == argc || oi < argc) {
1580 opt = send_interface(NULL, ifp, af);
1581 if (opt == -1)
1582 goto dumperr;
1583 nifaces += (size_t)opt;
1584 }
1585 }
1586 if (write(fd->fd, &nifaces, sizeof(nifaces)) != sizeof(nifaces))
1587 goto dumperr;
1588 TAILQ_FOREACH(ifp, ctx->ifaces, next) {
1589 if (!ifp->active)
1590 continue;
1591 for (oi = optind; oi < argc; oi++) {
1592 if (strcmp(ifp->name, argv[oi]) == 0)
1593 break;
1594 }
1595 if (optind == argc || oi < argc) {
1596 if (send_interface(fd, ifp, af) == -1)
1597 goto dumperr;
1598 }
1599 }
1600 ctx->options &= ~DHCPCD_DUMPLEASE;
1601 return 0;
1602 dumperr:
1603 ctx->options &= ~DHCPCD_DUMPLEASE;
1604 return -1;
1605 }
1606
1607 /* Only privileged users can control dhcpcd via the socket. */
1608 if (fd->flags & FD_UNPRIV) {
1609 errno = EPERM;
1610 return -1;
1611 }
1612
1613 if (opts & (DHCPCD_EXITING | DHCPCD_RELEASE)) {
1614 if (optind == argc) {
1615 stop_all_interfaces(ctx, opts);
1616 eloop_exit(ctx->eloop, EXIT_SUCCESS);
1617 return 0;
1618 }
1619 for (oi = optind; oi < argc; oi++) {
1620 if ((ifp = if_find(ctx->ifaces, argv[oi])) == NULL)
1621 continue;
1622 if (!ifp->active)
1623 continue;
1624 ifp->options->options |= opts;
1625 if (opts & DHCPCD_RELEASE)
1626 ifp->options->options &= ~DHCPCD_PERSISTENT;
1627 stop_interface(ifp, NULL);
1628 }
1629 return 0;
1630 }
1631
1632 if (do_renew) {
1633 if (optind == argc) {
1634 dhcpcd_renew(ctx);
1635 return 0;
1636 }
1637 for (oi = optind; oi < argc; oi++) {
1638 if ((ifp = if_find(ctx->ifaces, argv[oi])) == NULL)
1639 continue;
1640 dhcpcd_ifrenew(ifp);
1641 }
1642 return 0;
1643 }
1644
1645 reload_config(ctx);
1646 /* XXX: Respect initial commandline options? */
1647 reconf_reboot(ctx, do_reboot, argc, argv, optind - 1);
1648 return 0;
1649 }
1650
1651 static void dhcpcd_readdump1(void *);
1652
1653 static void
dhcpcd_readdump2(void * arg)1654 dhcpcd_readdump2(void *arg)
1655 {
1656 struct dhcpcd_ctx *ctx = arg;
1657 ssize_t len;
1658 int exit_code = EXIT_FAILURE;
1659
1660 len = read(ctx->control_fd, ctx->ctl_buf + ctx->ctl_bufpos,
1661 ctx->ctl_buflen - ctx->ctl_bufpos);
1662 if (len == -1) {
1663 logerr(__func__);
1664 goto finished;
1665 } else if (len == 0)
1666 goto finished;
1667 if ((size_t)len + ctx->ctl_bufpos != ctx->ctl_buflen) {
1668 ctx->ctl_bufpos += (size_t)len;
1669 return;
1670 }
1671
1672 if (ctx->ctl_buf[ctx->ctl_buflen - 1] != '\0') /* unlikely */
1673 ctx->ctl_buf[ctx->ctl_buflen - 1] = '\0';
1674 script_dump(ctx->ctl_buf, ctx->ctl_buflen);
1675 fflush(stdout);
1676 if (--ctx->ctl_extra != 0) {
1677 putchar('\n');
1678 eloop_event_add(ctx->eloop, ctx->control_fd,
1679 dhcpcd_readdump1, ctx);
1680 return;
1681 }
1682 exit_code = EXIT_SUCCESS;
1683
1684 finished:
1685 shutdown(ctx->control_fd, SHUT_RDWR);
1686 eloop_exit(ctx->eloop, exit_code);
1687 }
1688
1689 static void
dhcpcd_readdump1(void * arg)1690 dhcpcd_readdump1(void *arg)
1691 {
1692 struct dhcpcd_ctx *ctx = arg;
1693 ssize_t len;
1694
1695 len = read(ctx->control_fd, &ctx->ctl_buflen, sizeof(ctx->ctl_buflen));
1696 if (len != sizeof(ctx->ctl_buflen)) {
1697 if (len != -1)
1698 errno = EINVAL;
1699 goto err;
1700 }
1701 if (ctx->ctl_buflen > SSIZE_MAX) {
1702 errno = ENOBUFS;
1703 goto err;
1704 }
1705
1706 free(ctx->ctl_buf);
1707 ctx->ctl_buf = malloc(ctx->ctl_buflen);
1708 if (ctx->ctl_buf == NULL)
1709 goto err;
1710
1711 ctx->ctl_bufpos = 0;
1712 eloop_event_add(ctx->eloop, ctx->control_fd,
1713 dhcpcd_readdump2, ctx);
1714 return;
1715
1716 err:
1717 logerr(__func__);
1718 eloop_exit(ctx->eloop, EXIT_FAILURE);
1719 }
1720
1721 static void
dhcpcd_readdump0(void * arg)1722 dhcpcd_readdump0(void *arg)
1723 {
1724 struct dhcpcd_ctx *ctx = arg;
1725 ssize_t len;
1726
1727 len = read(ctx->control_fd, &ctx->ctl_extra, sizeof(ctx->ctl_extra));
1728 if (len != sizeof(ctx->ctl_extra)) {
1729 if (len != -1)
1730 errno = EINVAL;
1731 logerr(__func__);
1732 eloop_exit(ctx->eloop, EXIT_FAILURE);
1733 return;
1734 }
1735
1736 if (ctx->ctl_extra == 0) {
1737 eloop_exit(ctx->eloop, EXIT_SUCCESS);
1738 return;
1739 }
1740
1741 eloop_event_add(ctx->eloop, ctx->control_fd,
1742 dhcpcd_readdump1, ctx);
1743 }
1744
1745 static void
dhcpcd_readdumptimeout(void * arg)1746 dhcpcd_readdumptimeout(void *arg)
1747 {
1748 struct dhcpcd_ctx *ctx = arg;
1749
1750 logerrx(__func__);
1751 eloop_exit(ctx->eloop, EXIT_FAILURE);
1752 }
1753
1754 static int
dhcpcd_readdump(struct dhcpcd_ctx * ctx)1755 dhcpcd_readdump(struct dhcpcd_ctx *ctx)
1756 {
1757
1758 ctx->options |= DHCPCD_FORKED;
1759 if (eloop_timeout_add_sec(ctx->eloop, 5,
1760 dhcpcd_readdumptimeout, ctx) == -1)
1761 return -1;
1762 return eloop_event_add(ctx->eloop, ctx->control_fd,
1763 dhcpcd_readdump0, ctx);
1764 }
1765
1766 static void
dhcpcd_fork_cb(void * arg)1767 dhcpcd_fork_cb(void *arg)
1768 {
1769 struct dhcpcd_ctx *ctx = arg;
1770 int exit_code;
1771 ssize_t len;
1772
1773 len = read(ctx->fork_fd, &exit_code, sizeof(exit_code));
1774 if (len == -1) {
1775 logerr(__func__);
1776 exit_code = EXIT_FAILURE;
1777 } else if ((size_t)len < sizeof(exit_code)) {
1778 logerrx("%s: truncated read %zd (expected %zu)",
1779 __func__, len, sizeof(exit_code));
1780 exit_code = EXIT_FAILURE;
1781 }
1782 if (ctx->options & DHCPCD_FORKED)
1783 eloop_exit(ctx->eloop, exit_code);
1784 else
1785 dhcpcd_signal_cb(exit_code, ctx);
1786 }
1787
1788 static void
dhcpcd_stderr_cb(void * arg)1789 dhcpcd_stderr_cb(void *arg)
1790 {
1791 struct dhcpcd_ctx *ctx = arg;
1792 char log[BUFSIZ];
1793 ssize_t len;
1794
1795 len = read(ctx->stderr_fd, log, sizeof(log));
1796 if (len == -1) {
1797 if (errno != ECONNRESET)
1798 logerr(__func__);
1799 return;
1800 }
1801
1802 log[len] = '\0';
1803 fprintf(stderr, "%s", log);
1804 }
1805
1806 int
main(int argc,char ** argv,char ** envp)1807 main(int argc, char **argv, char **envp)
1808 {
1809 struct dhcpcd_ctx ctx;
1810 struct ifaddrs *ifaddrs = NULL;
1811 struct if_options *ifo;
1812 struct interface *ifp;
1813 sa_family_t family = AF_UNSPEC;
1814 int opt, oi = 0, i;
1815 unsigned int logopts, t;
1816 ssize_t len;
1817 #if defined(USE_SIGNALS) || !defined(THERE_IS_NO_FORK)
1818 pid_t pid;
1819 int fork_fd[2], stderr_fd[2];
1820 #endif
1821 #ifdef USE_SIGNALS
1822 int sig = 0;
1823 const char *siga = NULL;
1824 size_t si;
1825 #endif
1826
1827 #ifdef SETPROCTITLE_H
1828 setproctitle_init(argc, argv, envp);
1829 #else
1830 UNUSED(envp);
1831 #endif
1832
1833 /* Test for --help and --version */
1834 if (argc > 1) {
1835 if (strcmp(argv[1], "--help") == 0) {
1836 usage();
1837 return EXIT_SUCCESS;
1838 } else if (strcmp(argv[1], "--version") == 0) {
1839 printf(""PACKAGE" "VERSION"\n%s\n", dhcpcd_copyright);
1840 printf("Compiled in features:"
1841 #ifdef INET
1842 " INET"
1843 #endif
1844 #ifdef ARP
1845 " ARP"
1846 #endif
1847 #ifdef ARPING
1848 " ARPing"
1849 #endif
1850 #ifdef IPV4LL
1851 " IPv4LL"
1852 #endif
1853 #ifdef INET6
1854 " INET6"
1855 #endif
1856 #ifdef DHCP6
1857 " DHCPv6"
1858 #endif
1859 #ifdef AUTH
1860 " AUTH"
1861 #endif
1862 #ifdef PRIVSEP
1863 " PRIVSEP"
1864 #endif
1865 "\n");
1866 return EXIT_SUCCESS;
1867 }
1868 }
1869
1870 memset(&ctx, 0, sizeof(ctx));
1871
1872 ifo = NULL;
1873 ctx.cffile = CONFIG;
1874 ctx.script = UNCONST(dhcpcd_default_script);
1875 ctx.control_fd = ctx.control_unpriv_fd = ctx.link_fd = -1;
1876 ctx.pf_inet_fd = -1;
1877 #ifdef PF_LINK
1878 ctx.pf_link_fd = -1;
1879 #endif
1880
1881 TAILQ_INIT(&ctx.control_fds);
1882 #ifdef USE_SIGNALS
1883 ctx.fork_fd = -1;
1884 #endif
1885 #ifdef PLUGIN_DEV
1886 ctx.dev_fd = -1;
1887 #endif
1888 #ifdef INET
1889 ctx.udp_rfd = -1;
1890 ctx.udp_wfd = -1;
1891 #endif
1892 #if defined(INET6) && !defined(__sun)
1893 ctx.nd_fd = -1;
1894 #endif
1895 #ifdef DHCP6
1896 ctx.dhcp6_rfd = -1;
1897 ctx.dhcp6_wfd = -1;
1898 #endif
1899 #ifdef PRIVSEP
1900 ctx.ps_root_fd = ctx.ps_log_fd = ctx.ps_data_fd = -1;
1901 ctx.ps_inet_fd = ctx.ps_control_fd = -1;
1902 TAILQ_INIT(&ctx.ps_processes);
1903 #endif
1904
1905 /* Check our streams for validity */
1906 ctx.stdin_valid = fcntl(STDIN_FILENO, F_GETFD) != -1;
1907 ctx.stdout_valid = fcntl(STDOUT_FILENO, F_GETFD) != -1;
1908 ctx.stderr_valid = fcntl(STDERR_FILENO, F_GETFD) != -1;
1909
1910 logopts = LOGERR_LOG | LOGERR_LOG_DATE | LOGERR_LOG_PID;
1911 if (ctx.stderr_valid)
1912 logopts |= LOGERR_ERR;
1913
1914 i = 0;
1915
1916 while ((opt = getopt_long(argc, argv,
1917 ctx.options & DHCPCD_PRINT_PIDFILE ? NOERR_IF_OPTS : IF_OPTS,
1918 cf_options, &oi)) != -1)
1919 {
1920 switch (opt) {
1921 case '4':
1922 family = AF_INET;
1923 break;
1924 case '6':
1925 family = AF_INET6;
1926 break;
1927 case 'f':
1928 ctx.cffile = optarg;
1929 break;
1930 case 'j':
1931 free(ctx.logfile);
1932 ctx.logfile = strdup(optarg);
1933 break;
1934 #ifdef USE_SIGNALS
1935 case 'k':
1936 sig = SIGALRM;
1937 siga = "ALRM";
1938 break;
1939 case 'n':
1940 sig = SIGHUP;
1941 siga = "HUP";
1942 break;
1943 case 'g':
1944 case 'p':
1945 /* Force going via command socket as we're
1946 * out of user definable signals. */
1947 i = 4;
1948 break;
1949 case 'q':
1950 /* -qq disables console output entirely.
1951 * This is important for systemd because it logs
1952 * both console AND syslog to the same log
1953 * resulting in untold confusion. */
1954 if (logopts & LOGERR_QUIET)
1955 logopts &= ~LOGERR_ERR;
1956 else
1957 logopts |= LOGERR_QUIET;
1958 break;
1959 case 'x':
1960 sig = SIGTERM;
1961 siga = "TERM";
1962 break;
1963 case 'N':
1964 sig = SIGUSR1;
1965 siga = "USR1";
1966 break;
1967 #endif
1968 case 'P':
1969 ctx.options |= DHCPCD_PRINT_PIDFILE;
1970 logopts &= ~(LOGERR_LOG | LOGERR_ERR);
1971 break;
1972 case 'T':
1973 i = 1;
1974 logopts &= ~LOGERR_LOG;
1975 break;
1976 case 'U':
1977 i = 3;
1978 break;
1979 case 'V':
1980 i = 2;
1981 break;
1982 case '?':
1983 if (ctx.options & DHCPCD_PRINT_PIDFILE)
1984 continue;
1985 usage();
1986 goto exit_failure;
1987 }
1988 }
1989
1990 if (optind != argc - 1)
1991 ctx.options |= DHCPCD_MANAGER;
1992
1993 logsetopts(logopts);
1994 logopen(ctx.logfile);
1995
1996 ctx.argv = argv;
1997 ctx.argc = argc;
1998 ctx.ifc = argc - optind;
1999 ctx.ifv = argv + optind;
2000
2001 rt_init(&ctx);
2002
2003 ifo = read_config(&ctx, NULL, NULL, NULL);
2004 if (ifo == NULL) {
2005 if (ctx.options & DHCPCD_PRINT_PIDFILE)
2006 goto printpidfile;
2007 goto exit_failure;
2008 }
2009
2010 opt = add_options(&ctx, NULL, ifo, argc, argv);
2011 if (opt != 1) {
2012 if (ctx.options & DHCPCD_PRINT_PIDFILE)
2013 goto printpidfile;
2014 if (opt == 0)
2015 usage();
2016 goto exit_failure;
2017 }
2018 if (i == 2) {
2019 printf("Interface options:\n");
2020 if (optind == argc - 1) {
2021 free_options(&ctx, ifo);
2022 ifo = read_config(&ctx, argv[optind], NULL, NULL);
2023 if (ifo == NULL)
2024 goto exit_failure;
2025 add_options(&ctx, NULL, ifo, argc, argv);
2026 }
2027 if_printoptions();
2028 #ifdef INET
2029 if (family == 0 || family == AF_INET) {
2030 printf("\nDHCPv4 options:\n");
2031 dhcp_printoptions(&ctx,
2032 ifo->dhcp_override, ifo->dhcp_override_len);
2033 }
2034 #endif
2035 #ifdef INET6
2036 if (family == 0 || family == AF_INET6) {
2037 printf("\nND options:\n");
2038 ipv6nd_printoptions(&ctx,
2039 ifo->nd_override, ifo->nd_override_len);
2040 #ifdef DHCP6
2041 printf("\nDHCPv6 options:\n");
2042 dhcp6_printoptions(&ctx,
2043 ifo->dhcp6_override, ifo->dhcp6_override_len);
2044 #endif
2045 }
2046 #endif
2047 goto exit_success;
2048 }
2049 ctx.options |= ifo->options;
2050
2051 if (i == 1 || i == 3) {
2052 if (i == 1)
2053 ctx.options |= DHCPCD_TEST;
2054 else
2055 ctx.options |= DHCPCD_DUMPLEASE;
2056 ctx.options |= DHCPCD_PERSISTENT;
2057 ctx.options &= ~DHCPCD_DAEMONISE;
2058 }
2059
2060 #ifdef THERE_IS_NO_FORK
2061 ctx.options &= ~DHCPCD_DAEMONISE;
2062 #endif
2063
2064 if (ctx.options & DHCPCD_DEBUG)
2065 logsetopts(logopts | LOGERR_DEBUG);
2066
2067 if (!(ctx.options & (DHCPCD_TEST | DHCPCD_DUMPLEASE))) {
2068 printpidfile:
2069 /* If we have any other args, we should run as a single dhcpcd
2070 * instance for that interface. */
2071 if (optind == argc - 1 && !(ctx.options & DHCPCD_MANAGER)) {
2072 const char *per;
2073 const char *ifname;
2074
2075 ifname = *ctx.ifv;
2076 if (ifname == NULL || strlen(ifname) > IF_NAMESIZE) {
2077 errno = ifname == NULL ? EINVAL : E2BIG;
2078 logerr("%s: ", ifname);
2079 goto exit_failure;
2080 }
2081 /* Allow a dhcpcd interface per address family */
2082 switch(family) {
2083 case AF_INET:
2084 per = "-4";
2085 break;
2086 case AF_INET6:
2087 per = "-6";
2088 break;
2089 default:
2090 per = "";
2091 }
2092 snprintf(ctx.pidfile, sizeof(ctx.pidfile),
2093 PIDFILE, ifname, per, ".");
2094 } else {
2095 snprintf(ctx.pidfile, sizeof(ctx.pidfile),
2096 PIDFILE, "", "", "");
2097 ctx.options |= DHCPCD_MANAGER;
2098 }
2099 if (ctx.options & DHCPCD_PRINT_PIDFILE) {
2100 printf("%s\n", ctx.pidfile);
2101 goto exit_success;
2102 }
2103 }
2104
2105 if (chdir("/") == -1)
2106 logerr("%s: chdir: /", __func__);
2107
2108 /* Freeing allocated addresses from dumping leases can trigger
2109 * eloop removals as well, so init here. */
2110 if ((ctx.eloop = eloop_new()) == NULL) {
2111 logerr("%s: eloop_init", __func__);
2112 goto exit_failure;
2113 }
2114
2115 #ifdef USE_SIGNALS
2116 for (si = 0; si < dhcpcd_signals_ignore_len; si++)
2117 signal(dhcpcd_signals_ignore[si], SIG_IGN);
2118
2119 /* Save signal mask, block and redirect signals to our handler */
2120 eloop_signal_set_cb(ctx.eloop,
2121 dhcpcd_signals, dhcpcd_signals_len,
2122 dhcpcd_signal_cb, &ctx);
2123 if (eloop_signal_mask(ctx.eloop, &ctx.sigset) == -1) {
2124 logerr("%s: eloop_signal_mask", __func__);
2125 goto exit_failure;
2126 }
2127
2128 if (sig != 0) {
2129 pid = pidfile_read(ctx.pidfile);
2130 if (pid != 0 && pid != -1)
2131 loginfox("sending signal %s to pid %d", siga, pid);
2132 if (pid == 0 || pid == -1 || kill(pid, sig) != 0) {
2133 if (sig != SIGHUP && sig != SIGUSR1 && errno != EPERM)
2134 logerrx(PACKAGE" not running");
2135 if (pid != 0 && pid != -1 && errno != ESRCH) {
2136 logerr("kill");
2137 goto exit_failure;
2138 }
2139 unlink(ctx.pidfile);
2140 if (sig != SIGHUP && sig != SIGUSR1)
2141 goto exit_failure;
2142 } else {
2143 struct timespec ts;
2144
2145 if (sig == SIGHUP || sig == SIGUSR1)
2146 goto exit_success;
2147 /* Spin until it exits */
2148 loginfox("waiting for pid %d to exit", pid);
2149 ts.tv_sec = 0;
2150 ts.tv_nsec = 100000000; /* 10th of a second */
2151 for(i = 0; i < 100; i++) {
2152 nanosleep(&ts, NULL);
2153 if (pidfile_read(ctx.pidfile) == -1)
2154 goto exit_success;
2155 }
2156 logerrx("pid %d failed to exit", pid);
2157 goto exit_failure;
2158 }
2159 }
2160 #endif
2161
2162 #ifdef PRIVSEP
2163 ps_init(&ctx);
2164 #endif
2165
2166 #ifndef SMALL
2167 if (ctx.options & DHCPCD_DUMPLEASE &&
2168 ioctl(fileno(stdin), FIONREAD, &i, sizeof(i)) == 0 &&
2169 i > 0)
2170 {
2171 ctx.options |= DHCPCD_FORKED; /* pretend child process */
2172 #ifdef PRIVSEP
2173 if (IN_PRIVSEP(&ctx) && ps_managersandbox(&ctx, NULL) == -1)
2174 goto exit_failure;
2175 #endif
2176 ifp = calloc(1, sizeof(*ifp));
2177 if (ifp == NULL) {
2178 logerr(__func__);
2179 goto exit_failure;
2180 }
2181 ifp->ctx = &ctx;
2182 ifp->options = ifo;
2183 switch (family) {
2184 case AF_INET:
2185 #ifdef INET
2186 if (dhcp_dump(ifp) == -1)
2187 goto exit_failure;
2188 break;
2189 #else
2190 logerrx("No DHCP support");
2191 goto exit_failure;
2192 #endif
2193 case AF_INET6:
2194 #ifdef DHCP6
2195 if (dhcp6_dump(ifp) == -1)
2196 goto exit_failure;
2197 break;
2198 #else
2199 logerrx("No DHCP6 support");
2200 goto exit_failure;
2201 #endif
2202 default:
2203 logerrx("Family not specified. Please use -4 or -6.");
2204 goto exit_failure;
2205 }
2206 goto exit_success;
2207 }
2208 #endif
2209
2210 /* Test against siga instead of sig to avoid gcc
2211 * warning about a bogus potential signed overflow.
2212 * The end result will be the same. */
2213 if ((siga == NULL || i == 4 || ctx.ifc != 0) &&
2214 !(ctx.options & DHCPCD_TEST))
2215 {
2216 ctx.options |= DHCPCD_FORKED; /* avoid socket unlink */
2217 if (!(ctx.options & DHCPCD_MANAGER))
2218 ctx.control_fd = control_open(argv[optind], family,
2219 ctx.options & DHCPCD_DUMPLEASE);
2220 if (!(ctx.options & DHCPCD_MANAGER) && ctx.control_fd == -1)
2221 ctx.control_fd = control_open(argv[optind], AF_UNSPEC,
2222 ctx.options & DHCPCD_DUMPLEASE);
2223 if (ctx.control_fd == -1)
2224 ctx.control_fd = control_open(NULL, AF_UNSPEC,
2225 ctx.options & DHCPCD_DUMPLEASE);
2226 if (ctx.control_fd != -1) {
2227 #ifdef PRIVSEP
2228 if (IN_PRIVSEP(&ctx) &&
2229 ps_managersandbox(&ctx, NULL) == -1)
2230 goto exit_failure;
2231 #endif
2232 if (!(ctx.options & DHCPCD_DUMPLEASE))
2233 loginfox("sending commands to dhcpcd process");
2234 len = control_send(&ctx, argc, argv);
2235 if (len > 0)
2236 logdebugx("send OK");
2237 else {
2238 logerr("%s: control_send", __func__);
2239 goto exit_failure;
2240 }
2241 if (ctx.options & DHCPCD_DUMPLEASE) {
2242 if (dhcpcd_readdump(&ctx) == -1) {
2243 logerr("%s: dhcpcd_readdump", __func__);
2244 goto exit_failure;
2245 }
2246 goto run_loop;
2247 }
2248 goto exit_success;
2249 } else {
2250 if (errno != ENOENT)
2251 logerr("%s: control_open", __func__);
2252 if (ctx.options & DHCPCD_DUMPLEASE) {
2253 if (errno == ENOENT)
2254 logerrx("dhcpcd is not running");
2255 goto exit_failure;
2256 }
2257 if (errno == EPERM || errno == EACCES)
2258 goto exit_failure;
2259 }
2260 ctx.options &= ~DHCPCD_FORKED;
2261 }
2262
2263 if (!(ctx.options & DHCPCD_TEST)) {
2264 /* Ensure we have the needed directories */
2265 if (mkdir(DBDIR, 0750) == -1 && errno != EEXIST)
2266 logerr("%s: mkdir: %s", __func__, DBDIR);
2267 if (mkdir(RUNDIR, 0755) == -1 && errno != EEXIST)
2268 logerr("%s: mkdir: %s", __func__, RUNDIR);
2269 if ((pid = pidfile_lock(ctx.pidfile)) != 0) {
2270 if (pid == -1)
2271 logerr("%s: pidfile_lock: %s",
2272 __func__, ctx.pidfile);
2273 else
2274 logerrx(PACKAGE
2275 " already running on pid %d (%s)",
2276 pid, ctx.pidfile);
2277 goto exit_failure;
2278 }
2279 }
2280
2281 loginfox(PACKAGE "-" VERSION " starting");
2282 if (ctx.stdin_valid && freopen(_PATH_DEVNULL, "w", stdin) == NULL)
2283 logwarn("freopen stdin");
2284
2285 #if defined(USE_SIGNALS) && !defined(THERE_IS_NO_FORK)
2286 if (!(ctx.options & DHCPCD_DAEMONISE))
2287 goto start_manager;
2288
2289 if (xsocketpair(AF_UNIX, SOCK_DGRAM | SOCK_CXNB, 0, fork_fd) == -1 ||
2290 (ctx.stderr_valid &&
2291 xsocketpair(AF_UNIX, SOCK_DGRAM | SOCK_CXNB, 0, stderr_fd) == -1))
2292 {
2293 logerr("socketpair");
2294 goto exit_failure;
2295 }
2296 switch (pid = fork()) {
2297 case -1:
2298 logerr("fork");
2299 goto exit_failure;
2300 case 0:
2301 ctx.fork_fd = fork_fd[1];
2302 close(fork_fd[0]);
2303 #ifdef PRIVSEP_RIGHTS
2304 if (ps_rights_limit_fd(ctx.fork_fd) == -1) {
2305 logerr("ps_rights_limit_fdpair");
2306 goto exit_failure;
2307 }
2308 #endif
2309 eloop_event_add(ctx.eloop, ctx.fork_fd, dhcpcd_fork_cb, &ctx);
2310
2311 /*
2312 * Redirect stderr to the stderr socketpair.
2313 * Redirect stdout as well.
2314 * dhcpcd doesn't output via stdout, but something in
2315 * a called script might.
2316 */
2317 if (ctx.stderr_valid) {
2318 if (dup2(stderr_fd[1], STDERR_FILENO) == -1 ||
2319 (ctx.stdout_valid &&
2320 dup2(stderr_fd[1], STDOUT_FILENO) == -1))
2321 logerr("dup2");
2322 close(stderr_fd[0]);
2323 close(stderr_fd[1]);
2324 } else if (ctx.stdout_valid) {
2325 if (freopen(_PATH_DEVNULL, "w", stdout) == NULL)
2326 logerr("freopen stdout");
2327 }
2328 if (setsid() == -1) {
2329 logerr("%s: setsid", __func__);
2330 goto exit_failure;
2331 }
2332 /* Ensure we can never get a controlling terminal */
2333 switch (pid = fork()) {
2334 case -1:
2335 logerr("fork");
2336 goto exit_failure;
2337 case 0:
2338 break;
2339 default:
2340 ctx.options |= DHCPCD_FORKED; /* A lie */
2341 i = EXIT_SUCCESS;
2342 goto exit1;
2343 }
2344 break;
2345 default:
2346 setproctitle("[launcher]");
2347 ctx.options |= DHCPCD_FORKED | DHCPCD_LAUNCHER;
2348 ctx.fork_fd = fork_fd[0];
2349 close(fork_fd[1]);
2350 #ifdef PRIVSEP_RIGHTS
2351 if (ps_rights_limit_fd(ctx.fork_fd) == -1) {
2352 logerr("ps_rights_limit_fd");
2353 goto exit_failure;
2354 }
2355 #endif
2356 eloop_event_add(ctx.eloop, ctx.fork_fd, dhcpcd_fork_cb, &ctx);
2357
2358 if (ctx.stderr_valid) {
2359 ctx.stderr_fd = stderr_fd[0];
2360 close(stderr_fd[1]);
2361 #ifdef PRIVSEP_RIGHTS
2362 if (ps_rights_limit_fd(ctx.stderr_fd) == 1) {
2363 logerr("ps_rights_limit_fd");
2364 goto exit_failure;
2365 }
2366 #endif
2367 eloop_event_add(ctx.eloop, ctx.stderr_fd,
2368 dhcpcd_stderr_cb, &ctx);
2369 }
2370 #ifdef PRIVSEP
2371 if (IN_PRIVSEP(&ctx) && ps_managersandbox(&ctx, NULL) == -1)
2372 goto exit_failure;
2373 #endif
2374 goto run_loop;
2375 }
2376
2377 /* We have now forked, setsid, forked once more.
2378 * From this point on, we are the controlling daemon. */
2379 logdebugx("spawned manager process on PID %d", getpid());
2380 start_manager:
2381 ctx.options |= DHCPCD_STARTED;
2382 if ((pid = pidfile_lock(ctx.pidfile)) != 0) {
2383 logerr("%s: pidfile_lock %d", __func__, pid);
2384 #ifdef PRIVSEP
2385 /* privsep has not started ... */
2386 ctx.options &= ~DHCPCD_PRIVSEP;
2387 #endif
2388 goto exit_failure;
2389 }
2390 #endif
2391
2392 os_init();
2393
2394 #if defined(BSD) && defined(INET6)
2395 /* Disable the kernel RTADV sysctl as early as possible. */
2396 if (ctx.options & DHCPCD_IPV6 && ctx.options & DHCPCD_IPV6RS)
2397 if_disable_rtadv();
2398 #endif
2399
2400 #ifdef PRIVSEP
2401 if (IN_PRIVSEP(&ctx) && ps_start(&ctx) == -1) {
2402 logerr("ps_start");
2403 goto exit_failure;
2404 }
2405 if (ctx.options & DHCPCD_FORKED)
2406 goto run_loop;
2407 #endif
2408
2409 if (!(ctx.options & DHCPCD_TEST)) {
2410 if (control_start(&ctx,
2411 ctx.options & DHCPCD_MANAGER ?
2412 NULL : argv[optind], family) == -1)
2413 {
2414 logerr("%s: control_start", __func__);
2415 goto exit_failure;
2416 }
2417 }
2418
2419 #ifdef PLUGIN_DEV
2420 /* Start any dev listening plugin which may want to
2421 * change the interface name provided by the kernel */
2422 if (!IN_PRIVSEP(&ctx) &&
2423 (ctx.options & (DHCPCD_MANAGER | DHCPCD_DEV)) ==
2424 (DHCPCD_MANAGER | DHCPCD_DEV))
2425 dev_start(&ctx, dhcpcd_handleinterface);
2426 #endif
2427
2428 setproctitle("%s%s%s",
2429 ctx.options & DHCPCD_MANAGER ? "[manager]" : argv[optind],
2430 ctx.options & DHCPCD_IPV4 ? " [ip4]" : "",
2431 ctx.options & DHCPCD_IPV6 ? " [ip6]" : "");
2432
2433 if (if_opensockets(&ctx) == -1) {
2434 logerr("%s: if_opensockets", __func__);
2435 goto exit_failure;
2436 }
2437 #ifndef SMALL
2438 dhcpcd_setlinkrcvbuf(&ctx);
2439 #endif
2440
2441 /* Try and create DUID from the machine UUID. */
2442 dhcpcd_initduid(&ctx, NULL);
2443
2444 /* Cache the default vendor option. */
2445 if (dhcp_vendor(ctx.vendor, sizeof(ctx.vendor)) == -1)
2446 logerr("dhcp_vendor");
2447
2448 /* Start handling kernel messages for interfaces, addresses and
2449 * routes. */
2450 eloop_event_add(ctx.eloop, ctx.link_fd, dhcpcd_handlelink, &ctx);
2451
2452 #ifdef PRIVSEP
2453 if (IN_PRIVSEP(&ctx) && ps_managersandbox(&ctx, "stdio route") == -1)
2454 goto exit_failure;
2455 #endif
2456
2457 /* When running dhcpcd against a single interface, we need to retain
2458 * the old behaviour of waiting for an IP address */
2459 if (ctx.ifc == 1 && !(ctx.options & DHCPCD_BACKGROUND))
2460 ctx.options |= DHCPCD_WAITIP;
2461
2462 ctx.ifaces = if_discover(&ctx, &ifaddrs, ctx.ifc, ctx.ifv);
2463 if (ctx.ifaces == NULL) {
2464 logerr("%s: if_discover", __func__);
2465 goto exit_failure;
2466 }
2467 for (i = 0; i < ctx.ifc; i++) {
2468 if ((ifp = if_find(ctx.ifaces, ctx.ifv[i])) == NULL)
2469 logerrx("%s: interface not found",
2470 ctx.ifv[i]);
2471 else if (!ifp->active)
2472 logerrx("%s: interface has an invalid configuration",
2473 ctx.ifv[i]);
2474 }
2475 TAILQ_FOREACH(ifp, ctx.ifaces, next) {
2476 if (ifp->active == IF_ACTIVE_USER)
2477 break;
2478 }
2479 if (ifp == NULL) {
2480 if (ctx.ifc == 0) {
2481 int loglevel;
2482
2483 loglevel = ctx.options & DHCPCD_INACTIVE ?
2484 LOG_DEBUG : LOG_ERR;
2485 logmessage(loglevel, "no valid interfaces found");
2486 dhcpcd_daemonise(&ctx);
2487 } else
2488 goto exit_failure;
2489 if (!(ctx.options & DHCPCD_LINK)) {
2490 logerrx("aborting as link detection is disabled");
2491 goto exit_failure;
2492 }
2493 }
2494
2495 TAILQ_FOREACH(ifp, ctx.ifaces, next) {
2496 if (ifp->active)
2497 dhcpcd_initstate1(ifp, argc, argv, 0);
2498 }
2499 if_learnaddrs(&ctx, ctx.ifaces, &ifaddrs);
2500
2501 if (ctx.options & DHCPCD_BACKGROUND)
2502 dhcpcd_daemonise(&ctx);
2503
2504 opt = 0;
2505 TAILQ_FOREACH(ifp, ctx.ifaces, next) {
2506 if (ifp->active) {
2507 run_preinit(ifp);
2508 if (if_is_link_up(ifp))
2509 opt = 1;
2510 }
2511 }
2512
2513 if (!(ctx.options & DHCPCD_BACKGROUND)) {
2514 if (ctx.options & DHCPCD_MANAGER)
2515 t = ifo->timeout;
2516 else {
2517 t = 0;
2518 TAILQ_FOREACH(ifp, ctx.ifaces, next) {
2519 if (ifp->active) {
2520 t = ifp->options->timeout;
2521 break;
2522 }
2523 }
2524 }
2525 if (opt == 0 &&
2526 ctx.options & DHCPCD_LINK &&
2527 !(ctx.options & DHCPCD_WAITIP))
2528 {
2529 int loglevel;
2530
2531 loglevel = ctx.options & DHCPCD_INACTIVE ?
2532 LOG_DEBUG : LOG_WARNING;
2533 logmessage(loglevel, "no interfaces have a carrier");
2534 dhcpcd_daemonise(&ctx);
2535 } else if (t > 0 &&
2536 /* Test mode removes the daemonise bit, so check for both */
2537 ctx.options & (DHCPCD_DAEMONISE | DHCPCD_TEST))
2538 {
2539 eloop_timeout_add_sec(ctx.eloop, t,
2540 handle_exit_timeout, &ctx);
2541 }
2542 }
2543 free_options(&ctx, ifo);
2544 ifo = NULL;
2545
2546 TAILQ_FOREACH(ifp, ctx.ifaces, next) {
2547 if (ifp->active)
2548 eloop_timeout_add_sec(ctx.eloop, 0,
2549 dhcpcd_prestartinterface, ifp);
2550 }
2551
2552 run_loop:
2553 i = eloop_start(ctx.eloop, &ctx.sigset);
2554 if (i < 0) {
2555 logerr("%s: eloop_start", __func__);
2556 goto exit_failure;
2557 }
2558 goto exit1;
2559
2560 exit_success:
2561 i = EXIT_SUCCESS;
2562 goto exit1;
2563
2564 exit_failure:
2565 i = EXIT_FAILURE;
2566
2567 exit1:
2568 if (!(ctx.options & DHCPCD_TEST) && control_stop(&ctx) == -1)
2569 logerr("%s: control_stop", __func__);
2570 if (ifaddrs != NULL) {
2571 #ifdef PRIVSEP_GETIFADDRS
2572 if (IN_PRIVSEP(&ctx))
2573 free(ifaddrs);
2574 else
2575 #endif
2576 freeifaddrs(ifaddrs);
2577 }
2578 /* ps_stop will clear DHCPCD_PRIVSEP but we need to
2579 * remember it to avoid attemping to remove the pidfile */
2580 oi = ctx.options & DHCPCD_PRIVSEP ? 1 : 0;
2581 #ifdef PRIVSEP
2582 ps_stop(&ctx);
2583 #endif
2584 /* Free memory and close fd's */
2585 if (ctx.ifaces) {
2586 while ((ifp = TAILQ_FIRST(ctx.ifaces))) {
2587 TAILQ_REMOVE(ctx.ifaces, ifp, next);
2588 if_free(ifp);
2589 }
2590 free(ctx.ifaces);
2591 ctx.ifaces = NULL;
2592 }
2593 free_options(&ctx, ifo);
2594 #ifdef HAVE_OPEN_MEMSTREAM
2595 if (ctx.script_fp)
2596 fclose(ctx.script_fp);
2597 #endif
2598 free(ctx.script_buf);
2599 free(ctx.script_env);
2600 rt_dispose(&ctx);
2601 free(ctx.duid);
2602 if (ctx.link_fd != -1) {
2603 eloop_event_delete(ctx.eloop, ctx.link_fd);
2604 close(ctx.link_fd);
2605 }
2606 if_closesockets(&ctx);
2607 free_globals(&ctx);
2608 #ifdef INET6
2609 ipv6_ctxfree(&ctx);
2610 #endif
2611 #ifdef PLUGIN_DEV
2612 dev_stop(&ctx);
2613 #endif
2614 #ifdef PRIVSEP
2615 eloop_free(ctx.ps_eloop);
2616 #endif
2617 eloop_free(ctx.eloop);
2618 if (ctx.script != dhcpcd_default_script)
2619 free(ctx.script);
2620 if (ctx.options & DHCPCD_STARTED && !(ctx.options & DHCPCD_FORKED))
2621 loginfox(PACKAGE " exited");
2622 logclose();
2623 free(ctx.logfile);
2624 free(ctx.ctl_buf);
2625 #ifdef SETPROCTITLE_H
2626 setproctitle_fini();
2627 #endif
2628 #ifdef USE_SIGNALS
2629 if (ctx.options & DHCPCD_STARTED) {
2630 /* Try to detach from the launch process. */
2631 if (ctx.fork_fd != -1 &&
2632 write(ctx.fork_fd, &i, sizeof(i)) == -1)
2633 logerr("%s: write", __func__);
2634 }
2635 if (ctx.options & DHCPCD_FORKED || oi != 0)
2636 _exit(i); /* so atexit won't remove our pidfile */
2637 #endif
2638 return i;
2639 }
2640