1 /*
2 * dhcpcd - DHCP client daemon
3 * Copyright (c) 2006-2010 Roy Marples <roy@marples.name>
4 * All rights reserved
5
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27
28 const char copyright[] = "Copyright (c) 2006-2010 Roy Marples";
29
30 #include <sys/file.h>
31 #include <sys/socket.h>
32 #include <sys/stat.h>
33 #include <sys/time.h>
34 #include <sys/types.h>
35 #include <sys/uio.h>
36
37 #include <arpa/inet.h>
38 #include <net/route.h>
39
40 #ifdef __linux__
41 # include <asm/types.h> /* for systems with broken headers */
42 # include <linux/rtnetlink.h>
43 #endif
44
45 #include <ctype.h>
46 #include <errno.h>
47 #include <getopt.h>
48 #include <limits.h>
49 #include <paths.h>
50 #include <signal.h>
51 #include <stdio.h>
52 #include <stdlib.h>
53 #include <string.h>
54 #include <syslog.h>
55 #include <unistd.h>
56 #include <time.h>
57
58 #include "arp.h"
59 #include "bind.h"
60 #include "config.h"
61 #include "common.h"
62 #include "configure.h"
63 #include "control.h"
64 #include "dhcpcd.h"
65 #include "duid.h"
66 #include "eloop.h"
67 #include "if-options.h"
68 #include "if-pref.h"
69 #include "ipv4ll.h"
70 #include "net.h"
71 #include "signals.h"
72
73 #ifdef ANDROID
74 #include <linux/capability.h>
75 #include <linux/prctl.h>
76 #include <cutils/properties.h>
77 #include <private/android_filesystem_config.h>
78 #endif
79
80 /* We should define a maximum for the NAK exponential backoff */
81 #define NAKOFF_MAX 60
82
83 /* Wait N nanoseconds between sending a RELEASE and dropping the address.
84 * This gives the kernel enough time to actually send it. */
85 #define RELEASE_DELAY_S 0
86 #define RELEASE_DELAY_NS 10000000
87
88 int options = 0;
89 int pidfd = -1;
90 struct interface *ifaces = NULL;
91 int ifac = 0;
92 char **ifav = NULL;
93 int ifdc = 0;
94 char **ifdv = NULL;
95 /* If set, avoid routes after a DHCP success */
96 int avoid_routes = 0;
97
98 static char **margv;
99 static int margc;
100 static struct if_options *if_options;
101 static char **ifv;
102 static int ifc;
103 static char *cffile;
104 static char *pidfile;
105 static int linkfd = -1;
106
107 struct dhcp_op {
108 uint8_t value;
109 const char *name;
110 };
111
112 static const struct dhcp_op dhcp_ops[] = {
113 { DHCP_DISCOVER, "DISCOVER" },
114 { DHCP_OFFER, "OFFER" },
115 { DHCP_REQUEST, "REQUEST" },
116 { DHCP_DECLINE, "DECLINE" },
117 { DHCP_ACK, "ACK" },
118 { DHCP_NAK, "NAK" },
119 { DHCP_RELEASE, "RELEASE" },
120 { DHCP_INFORM, "INFORM" },
121 { 0, NULL }
122 };
123
124 static void send_release(struct interface *);
125
126 static const char *
get_dhcp_op(uint8_t type)127 get_dhcp_op(uint8_t type)
128 {
129 const struct dhcp_op *d;
130
131 for (d = dhcp_ops; d->name; d++)
132 if (d->value == type)
133 return d->name;
134 return NULL;
135 }
136
137 static pid_t
read_pid(void)138 read_pid(void)
139 {
140 FILE *fp;
141 pid_t pid;
142
143 if ((fp = fopen(pidfile, "r")) == NULL) {
144 errno = ENOENT;
145 return 0;
146 }
147 if (fscanf(fp, "%d", &pid) != 1)
148 pid = 0;
149 fclose(fp);
150 return pid;
151 }
152
153 static void
usage(void)154 usage(void)
155 {
156 printf("usage: "PACKAGE" [-adgknpqwxyADEGHJKLOTV] [-c script] [-f file]"
157 " [-e var=val]\n"
158 " [-h hostname] [-i classID ] [-l leasetime]"
159 " [-m metric] [-o option]\n"
160 " [-r ipaddr] [-s ipaddr] [-t timeout]"
161 " [-u userclass]\n"
162 " [-F none|ptr|both] [-I clientID] [-C hookscript]"
163 " [-Q option]\n"
164 " [-X ipaddr] <interface>\n");
165 }
166
167 static void
cleanup(void)168 cleanup(void)
169 {
170 #ifdef DEBUG_MEMORY
171 struct interface *iface;
172 int i;
173
174 free_options(if_options);
175
176 while (ifaces) {
177 iface = ifaces;
178 ifaces = iface->next;
179 free_interface(iface);
180 }
181
182 for (i = 0; i < ifac; i++)
183 free(ifav[i]);
184 free(ifav);
185 for (i = 0; i < ifdc; i++)
186 free(ifdv[i]);
187 free(ifdv);
188 #endif
189
190 if (linkfd != -1)
191 close(linkfd);
192 if (pidfd > -1) {
193 if (options & DHCPCD_MASTER) {
194 if (stop_control() == -1)
195 syslog(LOG_ERR, "stop_control: %m");
196 }
197 close(pidfd);
198 unlink(pidfile);
199 }
200 #ifdef DEBUG_MEMORY
201 free(pidfile);
202 #endif
203 }
204
205 /* ARGSUSED */
206 void
handle_exit_timeout(_unused void * arg)207 handle_exit_timeout(_unused void *arg)
208 {
209 int timeout;
210
211 syslog(LOG_ERR, "timed out");
212 if (!(options & DHCPCD_TIMEOUT_IPV4LL)) {
213 if (options & DHCPCD_MASTER) {
214 daemonise();
215 return;
216 } else
217 exit(EXIT_FAILURE);
218 }
219 options &= ~DHCPCD_TIMEOUT_IPV4LL;
220 timeout = (PROBE_NUM * PROBE_MAX) + PROBE_WAIT + 1;
221 syslog(LOG_WARNING, "allowing %d seconds for IPv4LL timeout", timeout);
222 add_timeout_sec(timeout, handle_exit_timeout, NULL);
223 }
224
225 void
drop_config(struct interface * iface,const char * reason)226 drop_config(struct interface *iface, const char *reason)
227 {
228 free(iface->state->old);
229 iface->state->old = iface->state->new;
230 iface->state->new = NULL;
231 iface->state->reason = reason;
232 configure(iface);
233 free(iface->state->old);
234 iface->state->old = NULL;
235 iface->state->lease.addr.s_addr = 0;
236 }
237
238 struct interface *
find_interface(const char * ifname)239 find_interface(const char *ifname)
240 {
241 struct interface *ifp;
242
243 for (ifp = ifaces; ifp; ifp = ifp->next)
244 if (strcmp(ifp->name, ifname) == 0)
245 return ifp;
246 return NULL;
247 }
248
249 static void
stop_interface(struct interface * iface)250 stop_interface(struct interface *iface)
251 {
252 struct interface *ifp, *ifl = NULL;
253
254 syslog(LOG_INFO, "%s: removing interface", iface->name);
255 if (strcmp(iface->state->reason, "RELEASE") != 0)
256 drop_config(iface, "STOP");
257 close_sockets(iface);
258 delete_timeout(NULL, iface);
259 for (ifp = ifaces; ifp; ifp = ifp->next) {
260 if (ifp == iface)
261 break;
262 ifl = ifp;
263 }
264 if (ifl)
265 ifl->next = ifp->next;
266 else
267 ifaces = ifp->next;
268 free_interface(ifp);
269 if (!(options & (DHCPCD_MASTER | DHCPCD_TEST)))
270 exit(EXIT_FAILURE);
271 }
272
273 static uint32_t
dhcp_xid(struct interface * iface)274 dhcp_xid(struct interface *iface)
275 {
276 uint32_t xid;
277
278 if (iface->state->options->options & DHCPCD_XID_HWADDR &&
279 iface->hwlen >= sizeof(xid))
280 /* The lower bits are probably more unique on the network */
281 memcpy(&xid, (iface->hwaddr + iface->hwlen) - sizeof(xid),
282 sizeof(xid));
283 else
284 xid = arc4random();
285
286 return xid;
287 }
288
289 static void
send_message(struct interface * iface,int type,void (* callback)(void *))290 send_message(struct interface *iface, int type,
291 void (*callback)(void *))
292 {
293 struct if_state *state = iface->state;
294 struct if_options *ifo = state->options;
295 struct dhcp_message *dhcp;
296 uint8_t *udp;
297 ssize_t len, r;
298 struct in_addr from, to;
299 in_addr_t a = 0;
300 struct timeval tv;
301
302 if (!callback)
303 syslog(LOG_DEBUG, "%s: sending %s with xid 0x%x",
304 iface->name, get_dhcp_op(type), state->xid);
305 else {
306 if (state->interval == 0)
307 state->interval = 4;
308 else {
309 state->interval *= 2;
310 if (state->interval > 64)
311 state->interval = 64;
312 }
313 tv.tv_sec = state->interval + DHCP_RAND_MIN;
314 tv.tv_usec = arc4random() % (DHCP_RAND_MAX_U - DHCP_RAND_MIN_U);
315 syslog(LOG_DEBUG,
316 "%s: sending %s (xid 0x%x), next in %0.2f seconds",
317 iface->name, get_dhcp_op(type), state->xid,
318 timeval_to_double(&tv));
319 }
320
321 /* Ensure sockets are open. */
322 open_sockets(iface);
323
324 /* If we couldn't open a UDP port for our IP address
325 * then we cannot renew.
326 * This could happen if our IP was pulled out from underneath us.
327 * Also, we should not unicast from a BOOTP lease. */
328 if (iface->udp_fd == -1 ||
329 (!(ifo->options & DHCPCD_INFORM) && is_bootp(iface->state->new)))
330 {
331 a = iface->addr.s_addr;
332 iface->addr.s_addr = 0;
333 }
334 len = make_message(&dhcp, iface, type);
335 if (a)
336 iface->addr.s_addr = a;
337 from.s_addr = dhcp->ciaddr;
338 if (from.s_addr)
339 to.s_addr = state->lease.server.s_addr;
340 else
341 to.s_addr = 0;
342 if (to.s_addr && to.s_addr != INADDR_BROADCAST) {
343 r = send_packet(iface, to, (uint8_t *)dhcp, len);
344 if (r == -1) {
345 syslog(LOG_ERR, "%s: send_packet: %m", iface->name);
346 close_sockets(iface);
347 }
348 } else {
349 len = make_udp_packet(&udp, (uint8_t *)dhcp, len, from, to);
350 r = send_raw_packet(iface, ETHERTYPE_IP, udp, len);
351 free(udp);
352 /* If we failed to send a raw packet this normally means
353 * we don't have the ability to work beneath the IP layer
354 * for this interface.
355 * As such we remove it from consideration without actually
356 * stopping the interface. */
357 if (r == -1) {
358 syslog(LOG_ERR, "%s: send_raw_packet: %m", iface->name);
359 if (!(options & DHCPCD_TEST))
360 drop_config(iface, "FAIL");
361 close_sockets(iface);
362 delete_timeout(NULL, iface);
363 callback = NULL;
364 }
365 }
366 free(dhcp);
367
368 /* Even if we fail to send a packet we should continue as we are
369 * as our failure timeouts will change out codepath when needed. */
370 if (callback)
371 add_timeout_tv(&tv, callback, iface);
372 }
373
374 static void
send_inform(void * arg)375 send_inform(void *arg)
376 {
377 send_message((struct interface *)arg, DHCP_INFORM, send_inform);
378 }
379
380 static void
send_discover(void * arg)381 send_discover(void *arg)
382 {
383 send_message((struct interface *)arg, DHCP_DISCOVER, send_discover);
384 }
385
386 static void
send_request(void * arg)387 send_request(void *arg)
388 {
389 send_message((struct interface *)arg, DHCP_REQUEST, send_request);
390 }
391
392 static void
send_renew(void * arg)393 send_renew(void *arg)
394 {
395 send_message((struct interface *)arg, DHCP_REQUEST, send_renew);
396 }
397
398 static void
send_rebind(void * arg)399 send_rebind(void *arg)
400 {
401 send_message((struct interface *)arg, DHCP_REQUEST, send_rebind);
402 }
403
404 void
start_expire(void * arg)405 start_expire(void *arg)
406 {
407 struct interface *iface = arg;
408
409 iface->state->interval = 0;
410 if (iface->addr.s_addr == 0) {
411 /* We failed to reboot, so enter discovery. */
412 iface->state->lease.addr.s_addr = 0;
413 start_discover(iface);
414 return;
415 }
416
417 syslog(LOG_ERR, "%s: lease expired", iface->name);
418 delete_timeout(NULL, iface);
419 drop_config(iface, "EXPIRE");
420 unlink(iface->leasefile);
421 if (iface->carrier != LINK_DOWN)
422 start_interface(iface);
423 }
424
425 static void
log_dhcp(int lvl,const char * msg,const struct interface * iface,const struct dhcp_message * dhcp,const struct in_addr * from)426 log_dhcp(int lvl, const char *msg,
427 const struct interface *iface, const struct dhcp_message *dhcp,
428 const struct in_addr *from)
429 {
430 const char *tfrom;
431 char *a;
432 struct in_addr addr;
433 int r;
434
435 if (strcmp(msg, "NAK:") == 0)
436 a = get_option_string(dhcp, DHO_MESSAGE);
437 else if (dhcp->yiaddr != 0) {
438 addr.s_addr = dhcp->yiaddr;
439 a = xstrdup(inet_ntoa(addr));
440 } else
441 a = NULL;
442
443 tfrom = "from";
444 r = get_option_addr(&addr, dhcp, DHO_SERVERID);
445 if (dhcp->servername[0] && r == 0)
446 syslog(lvl, "%s: %s %s %s %s `%s'", iface->name, msg, a,
447 tfrom, inet_ntoa(addr), dhcp->servername);
448 else {
449 if (r != 0) {
450 tfrom = "via";
451 addr = *from;
452 }
453 if (a == NULL)
454 syslog(lvl, "%s: %s %s %s",
455 iface->name, msg, tfrom, inet_ntoa(addr));
456 else
457 syslog(lvl, "%s: %s %s %s %s",
458 iface->name, msg, a, tfrom, inet_ntoa(addr));
459 }
460 free(a);
461 }
462
463 static int
blacklisted_ip(const struct if_options * ifo,in_addr_t addr)464 blacklisted_ip(const struct if_options *ifo, in_addr_t addr)
465 {
466 size_t i;
467
468 for (i = 0; i < ifo->blacklist_len; i += 2)
469 if (ifo->blacklist[i] == (addr & ifo->blacklist[i + 1]))
470 return 1;
471 return 0;
472 }
473
474 static int
whitelisted_ip(const struct if_options * ifo,in_addr_t addr)475 whitelisted_ip(const struct if_options *ifo, in_addr_t addr)
476 {
477 size_t i;
478
479 if (ifo->whitelist_len == 0)
480 return -1;
481 for (i = 0; i < ifo->whitelist_len; i += 2)
482 if (ifo->whitelist[i] == (addr & ifo->whitelist[i + 1]))
483 return 1;
484 return 0;
485 }
486
487 static void
handle_dhcp(struct interface * iface,struct dhcp_message ** dhcpp,const struct in_addr * from)488 handle_dhcp(struct interface *iface, struct dhcp_message **dhcpp, const struct in_addr *from)
489 {
490 struct if_state *state = iface->state;
491 struct if_options *ifo = state->options;
492 struct dhcp_message *dhcp = *dhcpp;
493 struct dhcp_lease *lease = &state->lease;
494 uint8_t type, tmp;
495 struct in_addr addr;
496 size_t i;
497
498 /* reset the message counter */
499 state->interval = 0;
500
501 /* We may have found a BOOTP server */
502 if (get_option_uint8(&type, dhcp, DHO_MESSAGETYPE) == -1)
503 type = 0;
504
505 if (type == DHCP_NAK) {
506 /* For NAK, only check if we require the ServerID */
507 if (has_option_mask(ifo->requiremask, DHO_SERVERID) &&
508 get_option_addr(&addr, dhcp, DHO_SERVERID) == -1)
509 {
510 log_dhcp(LOG_WARNING, "reject NAK", iface, dhcp, from);
511 return;
512 }
513 /* We should restart on a NAK */
514 log_dhcp(LOG_WARNING, "NAK:", iface, dhcp, from);
515 if (!(options & DHCPCD_TEST)) {
516 drop_config(iface, "NAK");
517 unlink(iface->leasefile);
518 }
519 close_sockets(iface);
520 /* If we constantly get NAKS then we should slowly back off */
521 add_timeout_sec(state->nakoff, start_interface, iface);
522 state->nakoff *= 2;
523 if (state->nakoff > NAKOFF_MAX)
524 state->nakoff = NAKOFF_MAX;
525 return;
526 }
527
528 /* Ensure that all required options are present */
529 for (i = 1; i < 255; i++) {
530 if (has_option_mask(ifo->requiremask, i) &&
531 get_option_uint8(&tmp, dhcp, i) != 0)
532 {
533 /* If we are bootp, then ignore the need for serverid.
534 * To ignore bootp, require dhcp_message_type instead. */
535 if (type == 0 && i == DHO_SERVERID)
536 continue;
537 log_dhcp(LOG_WARNING, "reject DHCP", iface, dhcp, from);
538 return;
539 }
540 }
541
542 /* No NAK, so reset the backoff */
543 state->nakoff = 1;
544
545 if ((type == 0 || type == DHCP_OFFER) &&
546 state->state == DHS_DISCOVER)
547 {
548 lease->frominfo = 0;
549 lease->addr.s_addr = dhcp->yiaddr;
550 lease->cookie = dhcp->cookie;
551 if (type == 0 ||
552 get_option_addr(&lease->server, dhcp, DHO_SERVERID) != 0)
553 lease->server.s_addr = INADDR_ANY;
554 log_dhcp(LOG_INFO, "offered", iface, dhcp, from);
555 free(state->offer);
556 state->offer = dhcp;
557 *dhcpp = NULL;
558 if (options & DHCPCD_TEST) {
559 free(state->old);
560 state->old = state->new;
561 state->new = state->offer;
562 state->offer = NULL;
563 state->reason = "TEST";
564 run_script(iface);
565 exit(EXIT_SUCCESS);
566 }
567 delete_timeout(send_discover, iface);
568 /* We don't request BOOTP addresses */
569 if (type) {
570 /* We used to ARP check here, but that seems to be in
571 * violation of RFC2131 where it only describes
572 * DECLINE after REQUEST.
573 * It also seems that some MS DHCP servers actually
574 * ignore DECLINE if no REQUEST, ie we decline a
575 * DISCOVER. */
576 start_request(iface);
577 return;
578 }
579 }
580
581 if (type) {
582 if (type == DHCP_OFFER) {
583 log_dhcp(LOG_INFO, "ignoring offer of",
584 iface, dhcp, from);
585 return;
586 }
587
588 /* We should only be dealing with acks */
589 if (type != DHCP_ACK) {
590 log_dhcp(LOG_ERR, "not ACK or OFFER",
591 iface, dhcp, from);
592 return;
593 }
594
595 if (!(ifo->options & DHCPCD_INFORM))
596 log_dhcp(LOG_INFO, "acknowledged", iface, dhcp, from);
597 }
598
599 /* BOOTP could have already assigned this above, so check we still
600 * have a pointer. */
601 if (*dhcpp) {
602 free(state->offer);
603 state->offer = dhcp;
604 *dhcpp = NULL;
605 }
606
607 lease->frominfo = 0;
608 delete_timeout(NULL, iface);
609
610 /* We now have an offer, so close the DHCP sockets.
611 * This allows us to safely ARP when broken DHCP servers send an ACK
612 * follows by an invalid NAK. */
613 close_sockets(iface);
614
615 if (ifo->options & DHCPCD_ARP &&
616 iface->addr.s_addr != state->offer->yiaddr)
617 {
618 /* If the interface already has the address configured
619 * then we can't ARP for duplicate detection. */
620 addr.s_addr = state->offer->yiaddr;
621 if (has_address(iface->name, &addr, NULL) != 1) {
622 state->claims = 0;
623 state->probes = 0;
624 state->conflicts = 0;
625 state->state = DHS_PROBE;
626 send_arp_probe(iface);
627 return;
628 }
629 }
630
631 bind_interface(iface);
632 }
633
634 static void
handle_dhcp_packet(void * arg)635 handle_dhcp_packet(void *arg)
636 {
637 struct interface *iface = arg;
638 uint8_t *packet;
639 struct dhcp_message *dhcp = NULL;
640 const uint8_t *pp;
641 ssize_t bytes;
642 struct in_addr from;
643 int i;
644
645 /* We loop through until our buffer is empty.
646 * The benefit is that if we get >1 DHCP packet in our buffer and
647 * the first one fails for any reason, we can use the next. */
648 packet = xmalloc(udp_dhcp_len);
649 for(;;) {
650 bytes = get_raw_packet(iface, ETHERTYPE_IP,
651 packet, udp_dhcp_len);
652 if (bytes == 0 || bytes == -1)
653 break;
654 if (valid_udp_packet(packet, bytes, &from) == -1) {
655 syslog(LOG_ERR, "%s: invalid UDP packet from %s",
656 iface->name, inet_ntoa(from));
657 continue;
658 }
659 i = whitelisted_ip(iface->state->options, from.s_addr);
660 if (i == 0) {
661 syslog(LOG_WARNING,
662 "%s: non whitelisted DHCP packet from %s",
663 iface->name, inet_ntoa(from));
664 continue;
665 } else if (i != 1 &&
666 blacklisted_ip(iface->state->options, from.s_addr) == 1)
667 {
668 syslog(LOG_WARNING,
669 "%s: blacklisted DHCP packet from %s",
670 iface->name, inet_ntoa(from));
671 continue;
672 }
673 if (iface->flags & IFF_POINTOPOINT &&
674 iface->dst.s_addr != from.s_addr)
675 {
676 syslog(LOG_WARNING,
677 "%s: server %s is not destination",
678 iface->name, inet_ntoa(from));
679 }
680 bytes = get_udp_data(&pp, packet);
681 if ((size_t)bytes > sizeof(*dhcp)) {
682 syslog(LOG_ERR,
683 "%s: packet greater than DHCP size from %s",
684 iface->name, inet_ntoa(from));
685 continue;
686 }
687 if (!dhcp)
688 dhcp = xzalloc(sizeof(*dhcp));
689 memcpy(dhcp, pp, bytes);
690 if (dhcp->cookie != htonl(MAGIC_COOKIE)) {
691 syslog(LOG_DEBUG, "%s: bogus cookie from %s",
692 iface->name, inet_ntoa(from));
693 continue;
694 }
695 /* Ensure it's the right transaction */
696 if (iface->state->xid != dhcp->xid) {
697 syslog(LOG_DEBUG,
698 "%s: wrong xid 0x%x (expecting 0x%x) from %s",
699 iface->name, dhcp->xid, iface->state->xid,
700 inet_ntoa(from));
701 continue;
702 }
703 /* Ensure packet is for us */
704 if (iface->hwlen <= sizeof(dhcp->chaddr) &&
705 memcmp(dhcp->chaddr, iface->hwaddr, iface->hwlen))
706 {
707 syslog(LOG_DEBUG, "%s: xid 0x%x is not for hwaddr %s",
708 iface->name, dhcp->xid,
709 hwaddr_ntoa(dhcp->chaddr, sizeof(dhcp->chaddr)));
710 continue;
711 }
712 handle_dhcp(iface, &dhcp, &from);
713 if (iface->raw_fd == -1)
714 break;
715 }
716 free(packet);
717 free(dhcp);
718 }
719
720 static void
send_release(struct interface * iface)721 send_release(struct interface *iface)
722 {
723 struct timespec ts;
724
725 if (iface->state->new != NULL &&
726 iface->state->new->cookie == htonl(MAGIC_COOKIE))
727 {
728 syslog(LOG_INFO, "%s: releasing lease of %s",
729 iface->name, inet_ntoa(iface->state->lease.addr));
730 iface->state->xid = dhcp_xid(iface);
731 send_message(iface, DHCP_RELEASE, NULL);
732 /* Give the packet a chance to go before dropping the ip */
733 ts.tv_sec = RELEASE_DELAY_S;
734 ts.tv_nsec = RELEASE_DELAY_NS;
735 nanosleep(&ts, NULL);
736 drop_config(iface, "RELEASE");
737 }
738 unlink(iface->leasefile);
739 }
740
741 void
send_decline(struct interface * iface)742 send_decline(struct interface *iface)
743 {
744 send_message(iface, DHCP_DECLINE, NULL);
745 }
746
747 static void
configure_interface1(struct interface * iface)748 configure_interface1(struct interface *iface)
749 {
750 struct if_state *ifs = iface->state;
751 struct if_options *ifo = ifs->options;
752 uint8_t *duid;
753 size_t len = 0, ifl;
754
755 /* Do any platform specific configuration */
756 if_conf(iface);
757
758 if (iface->flags & IFF_POINTOPOINT && !(ifo->options & DHCPCD_INFORM))
759 ifo->options |= DHCPCD_STATIC;
760 if (iface->flags & IFF_NOARP ||
761 ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC))
762 ifo->options &= ~(DHCPCD_ARP | DHCPCD_IPV4LL);
763 if (ifo->options & DHCPCD_LINK && carrier_status(iface) == -1)
764 ifo->options &= ~DHCPCD_LINK;
765
766 if (ifo->metric != -1)
767 iface->metric = ifo->metric;
768
769 /* If we haven't specified a ClientID and our hardware address
770 * length is greater than DHCP_CHADDR_LEN then we enforce a ClientID
771 * of the hardware address family and the hardware address. */
772 if (iface->hwlen > DHCP_CHADDR_LEN)
773 ifo->options |= DHCPCD_CLIENTID;
774
775 /* Firewire and InfiniBand interfaces require ClientID and
776 * the broadcast option being set. */
777 switch (iface->family) {
778 case ARPHRD_IEEE1394: /* FALLTHROUGH */
779 case ARPHRD_INFINIBAND:
780 ifo->options |= DHCPCD_CLIENTID | DHCPCD_BROADCAST;
781 break;
782 }
783
784 free(iface->clientid);
785 iface->clientid = NULL;
786 if (*ifo->clientid) {
787 iface->clientid = xmalloc(ifo->clientid[0] + 1);
788 memcpy(iface->clientid, ifo->clientid, ifo->clientid[0] + 1);
789 } else if (ifo->options & DHCPCD_CLIENTID) {
790 if (ifo->options & DHCPCD_DUID) {
791 duid = xmalloc(DUID_LEN);
792 if ((len = get_duid(duid, iface)) == 0)
793 syslog(LOG_ERR, "get_duid: %m");
794 }
795 if (len > 0) {
796 iface->clientid = xmalloc(len + 6);
797 iface->clientid[0] = len + 5;
798 iface->clientid[1] = 255; /* RFC 4361 */
799 ifl = strlen(iface->name);
800 if (ifl < 5) {
801 memcpy(iface->clientid + 2, iface->name, ifl);
802 if (ifl < 4)
803 memset(iface->clientid + 2 + ifl,
804 0, 4 - ifl);
805 } else {
806 ifl = htonl(if_nametoindex(iface->name));
807 memcpy(iface->clientid + 2, &ifl, 4);
808 }
809 } else if (len == 0) {
810 len = iface->hwlen + 1;
811 iface->clientid = xmalloc(len + 1);
812 iface->clientid[0] = len;
813 iface->clientid[1] = iface->family;
814 memcpy(iface->clientid + 2, iface->hwaddr,
815 iface->hwlen);
816 }
817 }
818 if (ifo->options & DHCPCD_CLIENTID)
819 syslog(LOG_DEBUG, "%s: using ClientID %s", iface->name,
820 hwaddr_ntoa(iface->clientid + 1, *iface->clientid));
821 else
822 syslog(LOG_DEBUG, "%s: using hwaddr %s", iface->name,
823 hwaddr_ntoa(iface->hwaddr, iface->hwlen));
824 }
825
826 int
select_profile(struct interface * iface,const char * profile)827 select_profile(struct interface *iface, const char *profile)
828 {
829 struct if_options *ifo;
830 int ret;
831
832 ret = 0;
833 ifo = read_config(cffile, iface->name, iface->ssid, profile);
834 if (ifo == NULL) {
835 syslog(LOG_DEBUG, "%s: no profile %s", iface->name, profile);
836 ret = -1;
837 goto exit;
838 }
839 if (profile != NULL) {
840 strlcpy(iface->state->profile, profile,
841 sizeof(iface->state->profile));
842 syslog(LOG_INFO, "%s: selected profile %s",
843 iface->name, profile);
844 } else
845 *iface->state->profile = '\0';
846 free_options(iface->state->options);
847 iface->state->options = ifo;
848
849 exit:
850 if (profile)
851 configure_interface1(iface);
852 return ret;
853 }
854
855 static void
start_fallback(void * arg)856 start_fallback(void *arg)
857 {
858 struct interface *iface;
859
860 iface = (struct interface *)arg;
861 select_profile(iface, iface->state->options->fallback);
862 start_interface(iface);
863 }
864
865 static void
configure_interface(struct interface * iface,int argc,char ** argv)866 configure_interface(struct interface *iface, int argc, char **argv)
867 {
868 select_profile(iface, NULL);
869 add_options(iface->state->options, argc, argv);
870 configure_interface1(iface);
871 }
872
873 static void
handle_carrier(const char * ifname)874 handle_carrier(const char *ifname)
875 {
876 struct interface *iface;
877 int carrier;
878
879 if (!(options & DHCPCD_LINK))
880 return;
881 for (iface = ifaces; iface; iface = iface->next)
882 if (strcmp(iface->name, ifname) == 0)
883 break;
884 if (!iface || !(iface->state->options->options & DHCPCD_LINK))
885 return;
886 carrier = carrier_status(iface);
887 if (carrier == -1)
888 syslog(LOG_ERR, "%s: carrier_status: %m", ifname);
889 else if (carrier == 0 || !(iface->flags & IFF_RUNNING)) {
890 if (iface->carrier != LINK_DOWN) {
891 iface->carrier = LINK_DOWN;
892 syslog(LOG_INFO, "%s: carrier lost", iface->name);
893 close_sockets(iface);
894 delete_timeouts(iface, start_expire, NULL);
895 drop_config(iface, "NOCARRIER");
896 }
897 } else if (carrier == 1 && (iface->flags & IFF_RUNNING)) {
898 if (iface->carrier != LINK_UP) {
899 iface->carrier = LINK_UP;
900 syslog(LOG_INFO, "%s: carrier acquired", iface->name);
901 if (iface->wireless)
902 getifssid(iface->name, iface->ssid);
903 configure_interface(iface, margc, margv);
904 iface->state->interval = 0;
905 iface->state->reason = "CARRIER";
906 run_script(iface);
907 start_interface(iface);
908 }
909 }
910 }
911
912 void
start_discover(void * arg)913 start_discover(void *arg)
914 {
915 struct interface *iface = arg;
916 struct if_options *ifo = iface->state->options;
917
918 iface->state->state = DHS_DISCOVER;
919 iface->state->xid = dhcp_xid(iface);
920 delete_timeout(NULL, iface);
921 if (ifo->fallback)
922 add_timeout_sec(ifo->timeout, start_fallback, iface);
923 else if (ifo->options & DHCPCD_IPV4LL &&
924 !IN_LINKLOCAL(htonl(iface->addr.s_addr)))
925 {
926 if (IN_LINKLOCAL(htonl(iface->state->fail.s_addr)))
927 add_timeout_sec(RATE_LIMIT_INTERVAL, start_ipv4ll, iface);
928 else
929 add_timeout_sec(ifo->timeout, start_ipv4ll, iface);
930 }
931 syslog(LOG_INFO, "%s: broadcasting for a lease", iface->name);
932 send_discover(iface);
933 }
934
935 void
start_request(void * arg)936 start_request(void *arg)
937 {
938 struct interface *iface = arg;
939
940 iface->state->state = DHS_REQUEST;
941 send_request(iface);
942 }
943
944 void
start_renew(void * arg)945 start_renew(void *arg)
946 {
947 struct interface *iface = arg;
948
949 syslog(LOG_INFO, "%s: renewing lease of %s",
950 iface->name, inet_ntoa(iface->state->lease.addr));
951 iface->state->state = DHS_RENEW;
952 iface->state->xid = dhcp_xid(iface);
953 send_renew(iface);
954 }
955
956 void
start_rebind(void * arg)957 start_rebind(void *arg)
958 {
959 struct interface *iface = arg;
960
961 syslog(LOG_ERR, "%s: failed to renew, attempting to rebind",
962 iface->name);
963 iface->state->state = DHS_REBIND;
964 delete_timeout(send_renew, iface);
965 iface->state->lease.server.s_addr = 0;
966 send_rebind(iface);
967 }
968
969 static void
start_timeout(void * arg)970 start_timeout(void *arg)
971 {
972 struct interface *iface = arg;
973
974 bind_interface(iface);
975 iface->state->interval = 0;
976 start_discover(iface);
977 }
978
979 static struct dhcp_message *
dhcp_message_new(struct in_addr * addr,struct in_addr * mask)980 dhcp_message_new(struct in_addr *addr, struct in_addr *mask)
981 {
982 struct dhcp_message *dhcp;
983 uint8_t *p;
984
985 dhcp = xzalloc(sizeof(*dhcp));
986 dhcp->yiaddr = addr->s_addr;
987 p = dhcp->options;
988 if (mask && mask->s_addr != INADDR_ANY) {
989 *p++ = DHO_SUBNETMASK;
990 *p++ = sizeof(mask->s_addr);
991 memcpy(p, &mask->s_addr, sizeof(mask->s_addr));
992 p+= sizeof(mask->s_addr);
993 }
994 *p++ = DHO_END;
995 return dhcp;
996 }
997
998 static int
handle_3rdparty(struct interface * iface)999 handle_3rdparty(struct interface *iface)
1000 {
1001 struct if_options *ifo;
1002 struct in_addr addr, net, dst;
1003
1004 ifo = iface->state->options;
1005 if (ifo->req_addr.s_addr != INADDR_ANY)
1006 return 0;
1007
1008 if (get_address(iface->name, &addr, &net, &dst) == 1)
1009 handle_ifa(RTM_NEWADDR, iface->name, &addr, &net, &dst);
1010 else {
1011 syslog(LOG_INFO,
1012 "%s: waiting for 3rd party to configure IP address",
1013 iface->name);
1014 iface->state->reason = "3RDPARTY";
1015 run_script(iface);
1016 }
1017 return 1;
1018 }
1019
1020 static void
start_static(struct interface * iface)1021 start_static(struct interface *iface)
1022 {
1023 struct if_options *ifo;
1024
1025 if (handle_3rdparty(iface))
1026 return;
1027 ifo = iface->state->options;
1028 iface->state->offer =
1029 dhcp_message_new(&ifo->req_addr, &ifo->req_mask);
1030 delete_timeout(NULL, iface);
1031 bind_interface(iface);
1032 }
1033
1034 static void
start_inform(struct interface * iface)1035 start_inform(struct interface *iface)
1036 {
1037 if (handle_3rdparty(iface))
1038 return;
1039
1040 if (options & DHCPCD_TEST) {
1041 iface->addr.s_addr = iface->state->options->req_addr.s_addr;
1042 iface->net.s_addr = iface->state->options->req_mask.s_addr;
1043 } else {
1044 iface->state->options->options |= DHCPCD_STATIC;
1045 start_static(iface);
1046 }
1047
1048 iface->state->state = DHS_INFORM;
1049 iface->state->xid = dhcp_xid(iface);
1050 send_inform(iface);
1051 }
1052
1053 void
start_reboot(struct interface * iface)1054 start_reboot(struct interface *iface)
1055 {
1056 struct if_options *ifo = iface->state->options;
1057
1058 if (ifo->options & DHCPCD_LINK && iface->carrier == LINK_DOWN) {
1059 syslog(LOG_INFO, "%s: waiting for carrier", iface->name);
1060 return;
1061 }
1062 if (ifo->options & DHCPCD_STATIC) {
1063 start_static(iface);
1064 return;
1065 }
1066 if (ifo->reboot == 0 || iface->state->offer == NULL) {
1067 start_discover(iface);
1068 return;
1069 }
1070 if (ifo->options & DHCPCD_INFORM) {
1071 syslog(LOG_INFO, "%s: informing address of %s",
1072 iface->name, inet_ntoa(iface->state->lease.addr));
1073 } else if (iface->state->offer->cookie == 0) {
1074 if (ifo->options & DHCPCD_IPV4LL) {
1075 iface->state->claims = 0;
1076 send_arp_announce(iface);
1077 } else
1078 start_discover(iface);
1079 return;
1080 } else {
1081 syslog(LOG_INFO, "%s: rebinding lease of %s",
1082 iface->name, inet_ntoa(iface->state->lease.addr));
1083 }
1084 iface->state->state = DHS_REBOOT;
1085 iface->state->xid = dhcp_xid(iface);
1086 iface->state->lease.server.s_addr = 0;
1087 delete_timeout(NULL, iface);
1088 if (ifo->fallback)
1089 add_timeout_sec(ifo->reboot, start_fallback, iface);
1090 else if (ifo->options & DHCPCD_LASTLEASE &&
1091 iface->state->lease.frominfo)
1092 add_timeout_sec(ifo->reboot, start_timeout, iface);
1093 else if (!(ifo->options & DHCPCD_INFORM &&
1094 options & (DHCPCD_MASTER | DHCPCD_DAEMONISED)))
1095 add_timeout_sec(ifo->reboot, start_expire, iface);
1096 /* Don't bother ARP checking as the server could NAK us first. */
1097 if (ifo->options & DHCPCD_INFORM)
1098 send_inform(iface);
1099 else
1100 send_request(iface);
1101 }
1102
1103 void
start_interface(void * arg)1104 start_interface(void *arg)
1105 {
1106 struct interface *iface = arg;
1107 struct if_options *ifo = iface->state->options;
1108 struct stat st;
1109 struct timeval now;
1110 uint32_t l;
1111 int nolease;
1112
1113 handle_carrier(iface->name);
1114 if (iface->carrier == LINK_DOWN) {
1115 syslog(LOG_INFO, "%s: waiting for carrier", iface->name);
1116 return;
1117 }
1118
1119 iface->start_uptime = uptime();
1120 free(iface->state->offer);
1121 iface->state->offer = NULL;
1122
1123 if (iface->state->arping_index < ifo->arping_len) {
1124 start_arping(iface);
1125 return;
1126 }
1127 if (ifo->options & DHCPCD_STATIC) {
1128 start_static(iface);
1129 return;
1130 }
1131 if (ifo->options & DHCPCD_INFORM) {
1132 start_inform(iface);
1133 return;
1134 }
1135 if (iface->hwlen == 0 && ifo->clientid[0] == '\0') {
1136 syslog(LOG_WARNING, "%s: needs a clientid to configure",
1137 iface->name);
1138 drop_config(iface, "FAIL");
1139 close_sockets(iface);
1140 delete_timeout(NULL, iface);
1141 return;
1142 }
1143 /* We don't want to read the old lease if we NAK an old test */
1144 nolease = iface->state->offer && options & DHCPCD_TEST;
1145 if (!nolease)
1146 iface->state->offer = read_lease(iface);
1147 if (iface->state->offer) {
1148 get_lease(&iface->state->lease, iface->state->offer);
1149 iface->state->lease.frominfo = 1;
1150 if (iface->state->offer->cookie == 0) {
1151 if (iface->state->offer->yiaddr ==
1152 iface->addr.s_addr)
1153 {
1154 free(iface->state->offer);
1155 iface->state->offer = NULL;
1156 }
1157 } else if (iface->state->lease.leasetime != ~0U &&
1158 stat(iface->leasefile, &st) == 0)
1159 {
1160 /* Offset lease times and check expiry */
1161 gettimeofday(&now, NULL);
1162 if ((time_t)iface->state->lease.leasetime <
1163 (time_t)(now.tv_sec - st.st_mtime))
1164 {
1165 syslog(LOG_DEBUG,
1166 "%s: discarding expired lease",
1167 iface->name);
1168 free(iface->state->offer);
1169 iface->state->offer = NULL;
1170 iface->state->lease.addr.s_addr = 0;
1171 } else {
1172 l = now.tv_sec - st.st_mtime;
1173 iface->state->lease.leasetime -= l;
1174 iface->state->lease.renewaltime -= l;
1175 iface->state->lease.rebindtime -= l;
1176 }
1177 }
1178 }
1179 if (iface->state->offer == NULL)
1180 start_discover(iface);
1181 else if (iface->state->offer->cookie == 0 &&
1182 iface->state->options->options & DHCPCD_IPV4LL)
1183 start_ipv4ll(iface);
1184 else
1185 start_reboot(iface);
1186 }
1187
1188 static void
init_state(struct interface * iface,int argc,char ** argv)1189 init_state(struct interface *iface, int argc, char **argv)
1190 {
1191 struct if_state *ifs;
1192
1193 if (iface->state)
1194 ifs = iface->state;
1195 else
1196 ifs = iface->state = xzalloc(sizeof(*ifs));
1197
1198 ifs->state = DHS_INIT;
1199 ifs->reason = "PREINIT";
1200 ifs->nakoff = 1;
1201 configure_interface(iface, argc, argv);
1202 if (!(options & DHCPCD_TEST))
1203 run_script(iface);
1204 /* We need to drop the leasefile so that start_interface
1205 * doesn't load it. */
1206 if (ifs->options->options & DHCPCD_REQUEST)
1207 unlink(iface->leasefile);
1208
1209 if (ifs->options->options & DHCPCD_LINK) {
1210 switch (carrier_status(iface)) {
1211 case 0:
1212 iface->carrier = LINK_DOWN;
1213 ifs->reason = "NOCARRIER";
1214 break;
1215 case 1:
1216 iface->carrier = LINK_UP;
1217 ifs->reason = "CARRIER";
1218 break;
1219 default:
1220 iface->carrier = LINK_UNKNOWN;
1221 return;
1222 }
1223 if (!(options & DHCPCD_TEST))
1224 run_script(iface);
1225 } else
1226 iface->carrier = LINK_UNKNOWN;
1227 }
1228
1229 void
handle_interface(int action,const char * ifname)1230 handle_interface(int action, const char *ifname)
1231 {
1232 struct interface *ifs, *ifp, *ifn, *ifl = NULL;
1233 const char * const argv[] = { ifname };
1234 int i;
1235
1236 if (action == -1) {
1237 ifp = find_interface(ifname);
1238 if (ifp != NULL)
1239 stop_interface(ifp);
1240 return;
1241 } else if (action == 0) {
1242 handle_carrier(ifname);
1243 return;
1244 }
1245
1246 /* If running off an interface list, check it's in it. */
1247 if (ifc) {
1248 for (i = 0; i < ifc; i++)
1249 if (strcmp(ifv[i], ifname) == 0)
1250 break;
1251 if (i >= ifc)
1252 return;
1253 }
1254
1255 ifs = discover_interfaces(-1, UNCONST(argv));
1256 for (ifp = ifs; ifp; ifp = ifp->next) {
1257 if (strcmp(ifp->name, ifname) != 0)
1258 continue;
1259 /* Check if we already have the interface */
1260 for (ifn = ifaces; ifn; ifn = ifn->next) {
1261 if (strcmp(ifn->name, ifp->name) == 0)
1262 break;
1263 ifl = ifn;
1264 }
1265 if (ifn) {
1266 /* The flags and hwaddr could have changed */
1267 ifn->flags = ifp->flags;
1268 ifn->hwlen = ifp->hwlen;
1269 if (ifp->hwlen != 0)
1270 memcpy(ifn->hwaddr, ifp->hwaddr, ifn->hwlen);
1271 } else {
1272 if (ifl)
1273 ifl->next = ifp;
1274 else
1275 ifaces = ifp;
1276 }
1277 init_state(ifp, 0, NULL);
1278 start_interface(ifp);
1279 }
1280 }
1281
1282 #ifdef RTM_CHGADDR
1283 void
handle_hwaddr(const char * ifname,unsigned char * hwaddr,size_t hwlen)1284 handle_hwaddr(const char *ifname, unsigned char *hwaddr, size_t hwlen)
1285 {
1286 struct interface *ifp;
1287 struct if_options *ifo;
1288
1289 for (ifp = ifaces; ifp; ifp = ifp->next)
1290 if (strcmp(ifp->name, ifname) == 0 && ifp->hwlen <= hwlen) {
1291 ifo = ifp->state->options;
1292 if (!(ifo->options &
1293 (DHCPCD_INFORM | DHCPCD_STATIC | DHCPCD_CLIENTID))
1294 && ifp->state->new != NULL &&
1295 ifp->state->new->cookie == htonl(MAGIC_COOKIE))
1296 {
1297 syslog(LOG_INFO,
1298 "%s: expiring for new hardware address",
1299 ifp->name);
1300 drop_config(ifp, "EXPIRE");
1301 }
1302 memcpy(ifp->hwaddr, hwaddr, hwlen);
1303 ifp->hwlen = hwlen;
1304 if (!(ifo->options &
1305 (DHCPCD_INFORM | DHCPCD_STATIC | DHCPCD_CLIENTID)))
1306 {
1307 syslog(LOG_DEBUG, "%s: using hwaddr %s",
1308 ifp->name,
1309 hwaddr_ntoa(ifp->hwaddr, ifp->hwlen));
1310 ifp->state->interval = 0;
1311 ifp->state->nakoff = 1;
1312 start_interface(ifp);
1313 }
1314 }
1315 free(hwaddr);
1316 }
1317 #endif
1318
1319 void
handle_ifa(int type,const char * ifname,struct in_addr * addr,struct in_addr * net,struct in_addr * dst)1320 handle_ifa(int type, const char *ifname,
1321 struct in_addr *addr, struct in_addr *net, struct in_addr *dst)
1322 {
1323 struct interface *ifp;
1324 struct if_options *ifo;
1325 int i;
1326
1327 if (addr->s_addr == INADDR_ANY)
1328 return;
1329 for (ifp = ifaces; ifp; ifp = ifp->next)
1330 if (strcmp(ifp->name, ifname) == 0)
1331 break;
1332 if (ifp == NULL)
1333 return;
1334 ifo = ifp->state->options;
1335 if ((ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC)) == 0 ||
1336 ifo->req_addr.s_addr != INADDR_ANY)
1337 return;
1338
1339 switch (type) {
1340 case RTM_DELADDR:
1341 if (ifp->state->new &&
1342 ifp->state->new->yiaddr == addr->s_addr)
1343 drop_config(ifp, "EXPIRE");
1344 break;
1345 case RTM_NEWADDR:
1346 free(ifp->state->old);
1347 ifp->state->old = ifp->state->new;
1348 ifp->state->new = dhcp_message_new(addr, net);
1349 ifp->dst.s_addr = dst ? dst->s_addr : INADDR_ANY;
1350 if (dst) {
1351 for (i = 1; i < 255; i++)
1352 if (i != DHO_ROUTER &&
1353 has_option_mask(ifo->dstmask, i))
1354 dhcp_message_add_addr(
1355 ifp->state->new,
1356 i, *dst);
1357 }
1358 ifp->state->reason = "STATIC";
1359 build_routes();
1360 run_script(ifp);
1361 if (ifo->options & DHCPCD_INFORM) {
1362 ifp->state->state = DHS_INFORM;
1363 ifp->state->xid = dhcp_xid(ifp);
1364 ifp->state->lease.server.s_addr =
1365 dst ? dst->s_addr : INADDR_ANY;
1366 ifp->addr = *addr;
1367 ifp->net = *net;
1368 send_inform(ifp);
1369 }
1370 break;
1371 }
1372 }
1373
1374 /* ARGSUSED */
1375 static void
handle_link(_unused void * arg)1376 handle_link(_unused void *arg)
1377 {
1378 if (manage_link(linkfd) == -1)
1379 syslog(LOG_ERR, "manage_link: %m");
1380 }
1381
1382 static void
if_reboot(struct interface * iface,int argc,char ** argv)1383 if_reboot(struct interface *iface, int argc, char **argv)
1384 {
1385 const struct if_options *ifo;
1386 int opt;
1387
1388 ifo = iface->state->options;
1389 opt = ifo->options;
1390 configure_interface(iface, argc, argv);
1391 ifo = iface->state->options;
1392 iface->state->interval = 0;
1393 if ((ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC) &&
1394 iface->addr.s_addr != ifo->req_addr.s_addr) ||
1395 (opt & (DHCPCD_INFORM | DHCPCD_STATIC) &&
1396 !(ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC))))
1397 {
1398 drop_config(iface, "EXPIRE");
1399 } else {
1400 free(iface->state->offer);
1401 iface->state->offer = NULL;
1402 }
1403 start_interface(iface);
1404 }
1405
1406 static void
reconf_reboot(int action,int argc,char ** argv,int oi)1407 reconf_reboot(int action, int argc, char **argv, int oi)
1408 {
1409 struct interface *ifl, *ifn, *ifp, *ifs, *ift;
1410
1411 ifs = discover_interfaces(argc - oi, argv + oi);
1412 if (ifs == NULL)
1413 return;
1414
1415 /* Remove any old interfaces */
1416 if (ifaces) {
1417 for (ifl = NULL; ifl != ifaces;) {
1418 /* Work our way backwards */
1419 for (ifp = ifaces; ifp; ifp = ifp->next)
1420 if (ifp->next == ifl) {
1421 ifl = ifp;
1422 break;
1423 }
1424 for (ifn = ifs; ifn; ifn = ifn->next)
1425 if (strcmp(ifn->name, ifp->name) == 0)
1426 break;
1427 if (ifn == NULL) {
1428 ifl = ifp->next;
1429 stop_interface(ifp);
1430 }
1431 }
1432 }
1433
1434 for (ifp = ifs; ifp && (ift = ifp->next, 1); ifp = ift) {
1435 ifl = NULL;
1436 for (ifn = ifaces; ifn; ifn = ifn->next) {
1437 if (strcmp(ifn->name, ifp->name) == 0)
1438 break;
1439 ifl = ifn;
1440 }
1441 if (ifn) {
1442 if (action)
1443 if_reboot(ifn, argc, argv);
1444 else if (ifn->state->new)
1445 configure(ifn);
1446 free_interface(ifp);
1447 } else {
1448 ifp->next = NULL;
1449 init_state(ifp, argc, argv);
1450 start_interface(ifp);
1451 if (ifl)
1452 ifl->next = ifp;
1453 else
1454 ifaces = ifp;
1455 }
1456 }
1457
1458 sort_interfaces();
1459 }
1460
1461 /* ARGSUSED */
1462 static void
handle_signal(_unused void * arg)1463 handle_signal(_unused void *arg)
1464 {
1465 struct interface *ifp, *ifl;
1466 struct if_options *ifo;
1467 int sig = signal_read();
1468 int do_release, do_rebind, i;
1469
1470 do_rebind = do_release = 0;
1471 switch (sig) {
1472 case SIGINT:
1473 syslog(LOG_INFO, "received SIGINT, stopping");
1474 break;
1475 case SIGTERM:
1476 syslog(LOG_INFO, "received SIGTERM, stopping");
1477 break;
1478 case SIGALRM:
1479 #ifdef ANDROID
1480 syslog(LOG_INFO, "received SIGALRM, renewing");
1481 for (ifp = ifaces; ifp; ifp = ifp->next) {
1482 start_renew(ifp);
1483 }
1484 #else
1485 syslog(LOG_INFO, "received SIGALRM, rebinding");
1486 for (i = 0; i < ifac; i++)
1487 free(ifav[i]);
1488 free(ifav);
1489 ifav = NULL;
1490 ifac = 0;
1491 for (i = 0; i < ifdc; i++)
1492 free(ifdv[i]);
1493 free(ifdv);
1494 ifdc = 0;
1495 ifdv = NULL;
1496 ifo = read_config(cffile, NULL, NULL, NULL);
1497 add_options(ifo, margc, margv);
1498 /* We need to preserve these two options. */
1499 if (options & DHCPCD_MASTER)
1500 ifo->options |= DHCPCD_MASTER;
1501 if (options & DHCPCD_DAEMONISED)
1502 ifo->options |= DHCPCD_DAEMONISED;
1503 options = ifo->options;
1504 free_options(ifo);
1505 reconf_reboot(1, 0, NULL, 0);
1506 #endif
1507 return;
1508 case SIGHUP:
1509 syslog(LOG_INFO, "received SIGHUP, releasing");
1510 do_release = 1;
1511 break;
1512 case SIGUSR1:
1513 syslog(LOG_INFO, "received SIGUSR, reconfiguring");
1514 for (ifp = ifaces; ifp; ifp = ifp->next)
1515 if (ifp->state->new)
1516 configure(ifp);
1517 return;
1518 case SIGPIPE:
1519 syslog(LOG_WARNING, "received SIGPIPE");
1520 return;
1521 default:
1522 syslog(LOG_ERR,
1523 "received signal %d, but don't know what to do with it",
1524 sig);
1525 return;
1526 }
1527
1528 if (options & DHCPCD_TEST)
1529 exit(EXIT_FAILURE);
1530
1531 /* As drop_config could re-arrange the order, we do it like this. */
1532 for (;;) {
1533 /* Be sane and drop the last config first */
1534 ifl = NULL;
1535 for (ifp = ifaces; ifp; ifp = ifp->next) {
1536 if (ifp->next == NULL)
1537 break;
1538 ifl = ifp;
1539 }
1540 if (ifp == NULL)
1541 break;
1542 if (ifp->carrier != LINK_DOWN &&
1543 (do_release ||
1544 ifp->state->options->options & DHCPCD_RELEASE))
1545 send_release(ifp);
1546 stop_interface(ifp);
1547 }
1548 exit(EXIT_FAILURE);
1549 }
1550
1551 int
handle_args(struct fd_list * fd,int argc,char ** argv)1552 handle_args(struct fd_list *fd, int argc, char **argv)
1553 {
1554 struct interface *ifp;
1555 int do_exit = 0, do_release = 0, do_reboot = 0, do_reconf = 0;
1556 int opt, oi = 0;
1557 ssize_t len;
1558 size_t l;
1559 struct iovec iov[2];
1560 char *tmp, *p;
1561
1562 if (fd != NULL) {
1563 /* Special commands for our control socket */
1564 if (strcmp(*argv, "--version") == 0) {
1565 len = strlen(VERSION) + 1;
1566 iov[0].iov_base = &len;
1567 iov[0].iov_len = sizeof(ssize_t);
1568 iov[1].iov_base = UNCONST(VERSION);
1569 iov[1].iov_len = len;
1570 if (writev(fd->fd, iov, 2) == -1) {
1571 syslog(LOG_ERR, "writev: %m");
1572 return -1;
1573 }
1574 return 0;
1575 } else if (strcmp(*argv, "--getconfigfile") == 0) {
1576 len = strlen(cffile ? cffile : CONFIG) + 1;
1577 iov[0].iov_base = &len;
1578 iov[0].iov_len = sizeof(ssize_t);
1579 iov[1].iov_base = cffile ? cffile : UNCONST(CONFIG);
1580 iov[1].iov_len = len;
1581 if (writev(fd->fd, iov, 2) == -1) {
1582 syslog(LOG_ERR, "writev: %m");
1583 return -1;
1584 }
1585 return 0;
1586 } else if (strcmp(*argv, "--getinterfaces") == 0) {
1587 len = 0;
1588 if (argc == 1) {
1589 for (ifp = ifaces; ifp; ifp = ifp->next)
1590 len++;
1591 len = write(fd->fd, &len, sizeof(len));
1592 if (len != sizeof(len))
1593 return -1;
1594 for (ifp = ifaces; ifp; ifp = ifp->next)
1595 send_interface(fd->fd, ifp);
1596 return 0;
1597 }
1598 opt = 0;
1599 while (argv[++opt] != NULL) {
1600 for (ifp = ifaces; ifp; ifp = ifp->next)
1601 if (strcmp(argv[opt], ifp->name) == 0)
1602 len++;
1603 }
1604 len = write(fd->fd, &len, sizeof(len));
1605 if (len != sizeof(len))
1606 return -1;
1607 opt = 0;
1608 while (argv[++opt] != NULL) {
1609 for (ifp = ifaces; ifp; ifp = ifp->next)
1610 if (strcmp(argv[opt], ifp->name) == 0)
1611 send_interface(fd->fd, ifp);
1612 }
1613 return 0;
1614 } else if (strcmp(*argv, "--listen") == 0) {
1615 fd->listener = 1;
1616 return 0;
1617 }
1618 }
1619
1620 /* Log the command */
1621 len = 0;
1622 for (opt = 0; opt < argc; opt++)
1623 len += strlen(argv[opt]) + 1;
1624 tmp = p = xmalloc(len + 1);
1625 for (opt = 0; opt < argc; opt++) {
1626 l = strlen(argv[opt]);
1627 strlcpy(p, argv[opt], l + 1);
1628 p += l;
1629 *p++ = ' ';
1630 }
1631 *--p = '\0';
1632 syslog(LOG_INFO, "control command: %s", tmp);
1633 free(tmp);
1634
1635 optind = 0;
1636 while ((opt = getopt_long(argc, argv, IF_OPTS, cf_options, &oi)) != -1)
1637 {
1638 switch (opt) {
1639 case 'g':
1640 do_reconf = 1;
1641 break;
1642 case 'k':
1643 do_release = 1;
1644 break;
1645 case 'n':
1646 do_reboot = 1;
1647 break;
1648 case 'x':
1649 do_exit = 1;
1650 break;
1651 }
1652 }
1653
1654 /* We need at least one interface */
1655 if (optind == argc) {
1656 syslog(LOG_ERR, "handle_args: no interface");
1657 return -1;
1658 }
1659
1660 if (do_release || do_exit) {
1661 for (oi = optind; oi < argc; oi++) {
1662 for (ifp = ifaces; ifp; ifp = ifp->next)
1663 if (strcmp(ifp->name, argv[oi]) == 0)
1664 break;
1665 if (!ifp)
1666 continue;
1667 if (do_release)
1668 ifp->state->options->options |= DHCPCD_RELEASE;
1669 if (ifp->state->options->options & DHCPCD_RELEASE &&
1670 ifp->carrier != LINK_DOWN)
1671 send_release(ifp);
1672 stop_interface(ifp);
1673 }
1674 return 0;
1675 }
1676
1677 reconf_reboot(do_reboot, argc, argv, optind);
1678 return 0;
1679 }
1680
1681 void
open_sockets(struct interface * iface)1682 open_sockets(struct interface *iface)
1683 {
1684 if (iface->raw_fd == -1) {
1685 if (open_socket(iface, ETHERTYPE_IP) == -1)
1686 syslog(LOG_ERR, "%s: open_socket: %m", iface->name);
1687 else
1688 add_event(iface->raw_fd, handle_dhcp_packet, iface);
1689 }
1690 if (iface->udp_fd == -1 &&
1691 iface->addr.s_addr != 0 &&
1692 iface->state->new != NULL &&
1693 (iface->state->new->cookie == htonl(MAGIC_COOKIE) ||
1694 iface->state->options->options & DHCPCD_INFORM))
1695 {
1696 if (open_udp_socket(iface) == -1 && errno != EADDRINUSE)
1697 syslog(LOG_ERR, "%s: open_udp_socket: %m", iface->name);
1698 }
1699 }
1700
1701 void
close_sockets(struct interface * iface)1702 close_sockets(struct interface *iface)
1703 {
1704 if (iface->arp_fd != -1) {
1705 delete_event(iface->arp_fd);
1706 close(iface->arp_fd);
1707 iface->arp_fd = -1;
1708 }
1709 if (iface->raw_fd != -1) {
1710 delete_event(iface->raw_fd);
1711 close(iface->raw_fd);
1712 iface->raw_fd = -1;
1713 }
1714 if (iface->udp_fd != -1) {
1715 /* we don't listen to events on the udp */
1716 close(iface->udp_fd);
1717 iface->udp_fd = -1;
1718 }
1719 }
1720
1721 #ifdef ANDROID
switchUser(void)1722 void switchUser(void)
1723 {
1724 gid_t groups[] = { AID_INET, AID_SHELL };
1725 struct __user_cap_header_struct header;
1726 struct __user_cap_data_struct cap;
1727
1728 setgroups(sizeof(groups)/sizeof(groups[0]), groups);
1729
1730 prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0);
1731
1732 setgid(AID_DHCP);
1733 setuid(AID_DHCP);
1734 header.version = _LINUX_CAPABILITY_VERSION;
1735 header.pid = 0;
1736 cap.effective = cap.permitted =
1737 (1 << CAP_NET_ADMIN) | (1 << CAP_NET_RAW) |
1738 (1 << CAP_NET_BROADCAST) | (1 << CAP_NET_BIND_SERVICE);
1739 cap.inheritable = 0;
1740 capset(&header, &cap);
1741 }
1742 #endif /* ANDROID */
1743
1744 int
main(int argc,char ** argv)1745 main(int argc, char **argv)
1746 {
1747 struct interface *iface;
1748 int opt, oi = 0, signal_fd, sig = 0, i, control_fd;
1749 size_t len;
1750 pid_t pid;
1751 struct timespec ts;
1752
1753 #ifdef ANDROID
1754 /* Reuse system properties for a p2p interface */
1755 char p2p_interface[PROPERTY_KEY_MAX];
1756 switchUser();
1757 #endif
1758 closefrom(3);
1759 openlog(PACKAGE, LOG_PERROR | LOG_PID, LOG_DAEMON);
1760 setlogmask(LOG_UPTO(LOG_INFO));
1761
1762 /* Test for --help and --version */
1763 if (argc > 1) {
1764 if (strcmp(argv[1], "--help") == 0) {
1765 usage();
1766 exit(EXIT_SUCCESS);
1767 } else if (strcmp(argv[1], "--version") == 0) {
1768 printf(""PACKAGE" "VERSION"\n%s\n", copyright);
1769 exit(EXIT_SUCCESS);
1770 }
1771 }
1772
1773 i = 0;
1774 while ((opt = getopt_long(argc, argv, IF_OPTS, cf_options, &oi)) != -1)
1775 {
1776 switch (opt) {
1777 case 'f':
1778 cffile = optarg;
1779 break;
1780 case 'g':
1781 sig = SIGUSR1;
1782 break;
1783 case 'k':
1784 sig = SIGHUP;
1785 break;
1786 case 'n':
1787 sig = SIGALRM;
1788 break;
1789 case 'x':
1790 sig = SIGTERM;
1791 break;
1792 case 'T':
1793 i = 1;
1794 break;
1795 case 'U':
1796 i = 2;
1797 break;
1798 case 'a':
1799 avoid_routes = 1;
1800 break;
1801 case 'V':
1802 print_options();
1803 exit(EXIT_SUCCESS);
1804 case '?':
1805 usage();
1806 exit(EXIT_FAILURE);
1807 }
1808 }
1809
1810 margv = argv;
1811 margc = argc;
1812 if_options = read_config(cffile, NULL, NULL, NULL);
1813 opt = add_options(if_options, argc, argv);
1814 if (opt != 1) {
1815 if (opt == 0)
1816 usage();
1817 exit(EXIT_FAILURE);
1818 }
1819 options = if_options->options;
1820 if (i != 0) {
1821 if (i == 1)
1822 options |= DHCPCD_TEST;
1823 else
1824 options |= DHCPCD_DUMPLEASE;
1825 options |= DHCPCD_PERSISTENT;
1826 options &= ~DHCPCD_DAEMONISE;
1827 }
1828
1829 #ifdef THERE_IS_NO_FORK
1830 options &= ~DHCPCD_DAEMONISE;
1831 #endif
1832
1833 if (options & DHCPCD_DEBUG)
1834 setlogmask(LOG_UPTO(LOG_DEBUG));
1835 if (options & DHCPCD_QUIET)
1836 close(STDERR_FILENO);
1837
1838 if (!(options & (DHCPCD_TEST | DHCPCD_DUMPLEASE))) {
1839 /* If we have any other args, we should run as a single dhcpcd
1840 * instance for that interface. */
1841 len = strlen(PIDFILE) + IF_NAMESIZE + 2;
1842 pidfile = xmalloc(len);
1843 if (optind == argc - 1)
1844 snprintf(pidfile, len, PIDFILE, "-", argv[optind]);
1845 else {
1846 snprintf(pidfile, len, PIDFILE, "", "");
1847 options |= DHCPCD_MASTER;
1848 }
1849 }
1850
1851 if (chdir("/") == -1)
1852 syslog(LOG_ERR, "chdir `/': %m");
1853 atexit(cleanup);
1854
1855 if (options & DHCPCD_DUMPLEASE) {
1856 if (optind != argc - 1) {
1857 syslog(LOG_ERR, "dumplease requires an interface");
1858 exit(EXIT_FAILURE);
1859 }
1860 ifaces = iface = xzalloc(sizeof(*iface));
1861 strlcpy(iface->name, argv[optind], sizeof(iface->name));
1862 snprintf(iface->leasefile, sizeof(iface->leasefile),
1863 LEASEFILE, iface->name);
1864 iface->state = xzalloc(sizeof(*iface->state));
1865 iface->state->options = xzalloc(sizeof(*iface->state->options));
1866 strlcpy(iface->state->options->script, if_options->script,
1867 sizeof(iface->state->options->script));
1868 iface->state->new = read_lease(iface);
1869 if (iface->state->new == NULL && errno == ENOENT) {
1870 strlcpy(iface->leasefile, argv[optind],
1871 sizeof(iface->leasefile));
1872 iface->state->new = read_lease(iface);
1873 }
1874 if (iface->state->new == NULL) {
1875 if (errno == ENOENT)
1876 syslog(LOG_ERR, "%s: no lease to dump",
1877 iface->name);
1878 exit(EXIT_FAILURE);
1879 }
1880 iface->state->reason = "DUMP";
1881 run_script(iface);
1882 exit(EXIT_SUCCESS);
1883 }
1884
1885 if (!(options & (DHCPCD_MASTER | DHCPCD_TEST))) {
1886 control_fd = open_control();
1887 if (control_fd != -1) {
1888 syslog(LOG_INFO,
1889 "sending commands to master dhcpcd process");
1890 i = send_control(argc, argv);
1891 if (i > 0) {
1892 syslog(LOG_DEBUG, "send OK");
1893 exit(EXIT_SUCCESS);
1894 } else {
1895 syslog(LOG_ERR, "failed to send commands");
1896 exit(EXIT_FAILURE);
1897 }
1898 } else {
1899 if (errno != ENOENT)
1900 syslog(LOG_ERR, "open_control: %m");
1901 }
1902 }
1903
1904 #ifndef ANDROID
1905 /* android runs us as user "dhcp" */
1906 if (geteuid())
1907 syslog(LOG_WARNING,
1908 PACKAGE " will not work correctly unless run as root");
1909 #endif
1910 if (sig != 0) {
1911 #ifdef ANDROID
1912 char pidpropname[PROPERTY_KEY_MAX];
1913 char pidpropval[PROPERTY_VALUE_MAX];
1914
1915 if (optind != argc - 1) {
1916 syslog(LOG_ERR, "Android requires an interface");
1917 exit(EXIT_FAILURE);
1918 }
1919
1920 if (strncmp(argv[optind], "p2p", 3) == 0) {
1921 strncpy(p2p_interface, "p2p", sizeof(p2p_interface));
1922 } else {
1923 strncpy(p2p_interface, argv[optind], sizeof(p2p_interface));
1924 }
1925
1926 if (snprintf(pidpropname,
1927 sizeof(pidpropname),
1928 "dhcp.%s.pid", p2p_interface) >= PROPERTY_KEY_MAX)
1929 exit(EXIT_FAILURE);
1930 property_get(pidpropname, pidpropval, NULL);
1931 if (strlen(pidpropval) == 0)
1932 exit(EXIT_FAILURE);
1933 pid = atoi(pidpropval);
1934 #else
1935 pid = read_pid();
1936 #endif
1937 if (pid != 0)
1938 syslog(LOG_INFO, "sending signal %d to pid %d",
1939 sig, pid);
1940 if (pid == 0 || kill(pid, sig) != 0) {
1941 if (sig != SIGALRM)
1942 syslog(LOG_ERR, ""PACKAGE" not running");
1943 if (pid != 0 && errno != ESRCH) {
1944 syslog(LOG_ERR, "kill: %m");
1945 exit(EXIT_FAILURE);
1946 }
1947 unlink(pidfile);
1948 if (sig != SIGALRM)
1949 exit(EXIT_FAILURE);
1950 } else {
1951 if (sig == SIGALRM)
1952 exit(EXIT_SUCCESS);
1953 /* Spin until it exits */
1954 syslog(LOG_INFO, "waiting for pid %d to exit", pid);
1955 ts.tv_sec = 0;
1956 ts.tv_nsec = 100000000; /* 10th of a second */
1957 for(i = 0; i < 100; i++) {
1958 nanosleep(&ts, NULL);
1959 if (read_pid() == 0)
1960 exit(EXIT_SUCCESS);
1961 }
1962 syslog(LOG_ERR, "pid %d failed to exit", pid);
1963 exit(EXIT_FAILURE);
1964 }
1965 }
1966
1967 if (!(options & DHCPCD_TEST)) {
1968 #ifdef ANDROID
1969 char pidpropname[PROPERTY_KEY_MAX];
1970 char pidpropval[PROPERTY_VALUE_MAX];
1971 #endif
1972 #ifndef ANDROID
1973 if ((pid = read_pid()) > 0 &&
1974 kill(pid, 0) == 0)
1975 {
1976 syslog(LOG_ERR, ""PACKAGE
1977 " already running on pid %d (%s)",
1978 pid, pidfile);
1979 exit(EXIT_FAILURE);
1980 }
1981
1982 /* Ensure we have the needed directories */
1983 if (mkdir(RUNDIR, 0755) == -1 && errno != EEXIST) {
1984 syslog(LOG_ERR, "mkdir `%s': %m", RUNDIR);
1985 exit(EXIT_FAILURE);
1986 }
1987 if (mkdir(DBDIR, 0755) == -1 && errno != EEXIST) {
1988 syslog(LOG_ERR, "mkdir `%s': %m", DBDIR);
1989 exit(EXIT_FAILURE);
1990 }
1991 #endif
1992 pidfd = open(pidfile, O_WRONLY | O_CREAT | O_NONBLOCK, 0664);
1993 if (pidfd == -1) {
1994 syslog(LOG_ERR, "open `%s': %m", pidfile);
1995 exit(EXIT_FAILURE);
1996 }
1997 /* Lock the file so that only one instance of dhcpcd runs
1998 * on an interface */
1999 if (flock(pidfd, LOCK_EX | LOCK_NB) == -1) {
2000 syslog(LOG_ERR, "flock `%s': %m", pidfile);
2001 exit(EXIT_FAILURE);
2002 }
2003 if (set_cloexec(pidfd) == -1)
2004 exit(EXIT_FAILURE);
2005 #ifdef ANDROID
2006 if (optind != argc - 1) {
2007 syslog(LOG_ERR, "Android requires an interface");
2008 exit(EXIT_FAILURE);
2009 }
2010
2011 if (strncmp(argv[optind], "p2p", 3) == 0) {
2012 strncpy(p2p_interface, "p2p", sizeof(p2p_interface));
2013 } else {
2014 strncpy(p2p_interface, argv[optind], sizeof(p2p_interface));
2015 }
2016
2017 if (snprintf(pidpropname,
2018 sizeof(pidpropname),
2019 "dhcp.%s.pid", p2p_interface) >= PROPERTY_KEY_MAX)
2020 exit(EXIT_FAILURE);
2021 if (snprintf(pidpropval, sizeof(pidpropval), "%d", getpid()) >= PROPERTY_VALUE_MAX)
2022 exit(EXIT_FAILURE);
2023 property_set(pidpropname, pidpropval);
2024 #else
2025 writepid(pidfd, getpid());
2026 #endif
2027 }
2028
2029 syslog(LOG_INFO, "version " VERSION " starting");
2030
2031 if ((signal_fd = signal_init()) == -1)
2032 exit(EXIT_FAILURE);
2033 if (signal_setup() == -1)
2034 exit(EXIT_FAILURE);
2035 add_event(signal_fd, handle_signal, NULL);
2036
2037 if (options & DHCPCD_MASTER) {
2038 if (start_control() == -1) {
2039 syslog(LOG_ERR, "start_control: %m");
2040 exit(EXIT_FAILURE);
2041 }
2042 }
2043
2044 if (init_sockets() == -1) {
2045 syslog(LOG_ERR, "init_socket: %m");
2046 exit(EXIT_FAILURE);
2047 }
2048 if (if_options->options & DHCPCD_LINK) {
2049 linkfd = open_link_socket();
2050 if (linkfd == -1)
2051 syslog(LOG_ERR, "open_link_socket: %m");
2052 else
2053 add_event(linkfd, handle_link, NULL);
2054 }
2055
2056 ifc = argc - optind;
2057 ifv = argv + optind;
2058
2059 /* When running dhcpcd against a single interface, we need to retain
2060 * the old behaviour of waiting for an IP address */
2061 if (ifc == 1)
2062 options |= DHCPCD_WAITIP;
2063
2064 ifaces = discover_interfaces(ifc, ifv);
2065 for (i = 0; i < ifc; i++) {
2066 for (iface = ifaces; iface; iface = iface->next)
2067 if (strcmp(iface->name, ifv[i]) == 0)
2068 break;
2069 if (!iface)
2070 syslog(LOG_ERR, "%s: interface not found or invalid",
2071 ifv[i]);
2072 }
2073 if (!ifaces) {
2074 if (ifc == 0)
2075 syslog(LOG_ERR, "no valid interfaces found");
2076 else
2077 exit(EXIT_FAILURE);
2078 if (!(options & DHCPCD_LINK)) {
2079 syslog(LOG_ERR,
2080 "aborting as link detection is disabled");
2081 exit(EXIT_FAILURE);
2082 }
2083 }
2084
2085 if (options & DHCPCD_BACKGROUND)
2086 daemonise();
2087
2088 opt = 0;
2089 for (iface = ifaces; iface; iface = iface->next) {
2090 init_state(iface, argc, argv);
2091 if (iface->carrier != LINK_DOWN)
2092 opt = 1;
2093 }
2094
2095 if (!(options & DHCPCD_BACKGROUND)) {
2096 /* If we don't have a carrier, we may have to wait for a second
2097 * before one becomes available if we brought an interface up. */
2098 if (opt == 0 &&
2099 options & DHCPCD_LINK &&
2100 options & DHCPCD_WAITUP &&
2101 !(options & DHCPCD_WAITIP))
2102 {
2103 ts.tv_sec = 1;
2104 ts.tv_nsec = 0;
2105 nanosleep(&ts, NULL);
2106 for (iface = ifaces; iface; iface = iface->next) {
2107 handle_carrier(iface->name);
2108 if (iface->carrier != LINK_DOWN) {
2109 opt = 1;
2110 break;
2111 }
2112 }
2113 }
2114 if (opt == 0 &&
2115 options & DHCPCD_LINK &&
2116 !(options & DHCPCD_WAITIP))
2117 {
2118 syslog(LOG_WARNING, "no interfaces have a carrier");
2119 daemonise();
2120 } else if (if_options->timeout > 0) {
2121 if (options & DHCPCD_IPV4LL)
2122 options |= DHCPCD_TIMEOUT_IPV4LL;
2123 add_timeout_sec(if_options->timeout,
2124 handle_exit_timeout, NULL);
2125 }
2126 }
2127 free_options(if_options);
2128 if_options = NULL;
2129
2130 sort_interfaces();
2131 for (iface = ifaces; iface; iface = iface->next)
2132 add_timeout_sec(0, start_interface, iface);
2133
2134 start_eloop();
2135 exit(EXIT_SUCCESS);
2136 }
2137