1 /* 2 * dhcpcd - DHCP client daemon 3 * Copyright 2006-2008 Roy Marples <roy (at) 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 #include <sys/stat.h> 29 #include <sys/time.h> 30 #include <sys/types.h> 31 #include <arpa/inet.h> 32 33 #ifdef __linux__ 34 # include <netinet/ether.h> 35 #endif 36 37 #include <errno.h> 38 #include <poll.h> 39 #include <signal.h> 40 #include <stdlib.h> 41 #include <stdio.h> 42 #include <string.h> 43 #include <time.h> 44 #include <unistd.h> 45 46 #include "config.h" 47 #include "common.h" 48 #include "client.h" 49 #include "configure.h" 50 #include "dhcp.h" 51 #include "dhcpcd.h" 52 #include "net.h" 53 #include "logger.h" 54 #include "signals.h" 55 56 #define IPV4LL_LEASETIME 2 57 58 /* Some platforms don't define INFTIM */ 59 #ifndef INFTIM 60 # define INFTIM -1 61 #endif 62 63 #define STATE_INIT 0 64 #define STATE_DISCOVERING 1 65 #define STATE_REQUESTING 2 66 #define STATE_BOUND 3 67 #define STATE_RENEWING 4 68 #define STATE_REBINDING 5 69 #define STATE_REBOOT 6 70 #define STATE_RENEW_REQUESTED 7 71 #define STATE_INIT_IPV4LL 8 72 #define STATE_PROBING 9 73 #define STATE_ANNOUNCING 10 74 75 /* Constants taken from RFC 2131. */ 76 #define T1 0.5 77 #define T2 0.875 78 #define DHCP_BASE 4 79 #define DHCP_MAX 64 80 #define DHCP_RAND_MIN -1 81 #define DHCP_RAND_MAX 1 82 #define DHCP_ARP_FAIL 10 83 84 /* We should define a maximum for the NAK exponential backoff */ 85 #define NAKOFF_MAX 60 86 87 #define SOCKET_CLOSED 0 88 #define SOCKET_OPEN 1 89 90 /* These are for IPV4LL, RFC 3927. */ 91 #define PROBE_WAIT 1 92 #define PROBE_NUM 3 93 #define PROBE_MIN 1 94 #define PROBE_MAX 2 95 #define ANNOUNCE_WAIT 2 96 /* BSD systems always do a grauitous ARP when assigning an address, 97 * so we can do one less announce. */ 98 #ifdef BSD 99 # define ANNOUNCE_NUM 1 100 #else 101 # define ANNOUNCE_NUM 2 102 #endif 103 #define ANNOUNCE_INTERVAL 2 104 #define MAX_CONFLICTS 10 105 #define RATE_LIMIT_INTERVAL 60 106 #define DEFEND_INTERVAL 10 107 108 109 /* number of usecs in a second. */ 110 #define USECS_SECOND 1000000 111 /* As we use timevals, we should use the usec part for 112 * greater randomisation. */ 113 #define DHCP_RAND_MIN_U DHCP_RAND_MIN * USECS_SECOND 114 #define DHCP_RAND_MAX_U DHCP_RAND_MAX * USECS_SECOND 115 #define PROBE_MIN_U PROBE_MIN * USECS_SECOND 116 #define PROBE_MAX_U PROBE_MAX * USECS_SECOND 117 118 #define timernorm(tvp) \ 119 do { \ 120 while ((tvp)->tv_usec >= 1000000) { \ 121 (tvp)->tv_sec++; \ 122 (tvp)->tv_usec -= 1000000; \ 123 } \ 124 } while (0 /* CONSTCOND */); 125 126 #define timerneg(tvp) ((tvp)->tv_sec < 0 || (tvp)->tv_usec < 0) 127 128 struct if_state { 129 int options; 130 struct interface *interface; 131 struct dhcp_message *offer; 132 struct dhcp_message *new; 133 struct dhcp_message *old; 134 struct dhcp_lease lease; 135 struct timeval timeout; 136 struct timeval stop; 137 struct timeval exit; 138 int state; 139 int messages; 140 time_t nakoff; 141 uint32_t xid; 142 int socket; 143 int *pid_fd; 144 int signal_fd; 145 int carrier; 146 int probes; 147 int claims; 148 int conflicts; 149 time_t defend; 150 struct in_addr fail; 151 }; 152 153 #define LINK_UP 1 154 #define LINK_UNKNOWN 0 155 #define LINK_DOWN -1 156 157 struct dhcp_op { 158 uint8_t value; 159 const char *name; 160 }; 161 162 static const struct dhcp_op const dhcp_ops[] = { 163 { DHCP_DISCOVER, "DHCP_DISCOVER" }, 164 { DHCP_OFFER, "DHCP_OFFER" }, 165 { DHCP_REQUEST, "DHCP_REQUEST" }, 166 { DHCP_DECLINE, "DHCP_DECLINE" }, 167 { DHCP_ACK, "DHCP_ACK" }, 168 { DHCP_NAK, "DHCP_NAK" }, 169 { DHCP_RELEASE, "DHCP_RELEASE" }, 170 { DHCP_INFORM, "DHCP_INFORM" }, 171 { 0, NULL } 172 }; 173 174 static const char * 175 get_dhcp_op(uint8_t type) 176 { 177 const struct dhcp_op *d; 178 179 for (d = dhcp_ops; d->name; d++) 180 if (d->value == type) 181 return d->name; 182 return NULL; 183 } 184 185 #ifdef THERE_IS_NO_FORK 186 #define daemonise(a,b) 0 187 #else 188 static int 189 daemonise(struct if_state *state, const struct options *options) 190 { 191 pid_t pid; 192 sigset_t full; 193 sigset_t old; 194 char buf = '\0'; 195 int sidpipe[2]; 196 197 if (state->options & DHCPCD_DAEMONISED || 198 !(options->options & DHCPCD_DAEMONISE)) 199 return 0; 200 201 sigfillset(&full); 202 sigprocmask(SIG_SETMASK, &full, &old); 203 204 /* Setup a signal pipe so parent knows when to exit. */ 205 if (pipe(sidpipe) == -1) { 206 logger(LOG_ERR,"pipe: %s", strerror(errno)); 207 return -1; 208 } 209 210 logger(LOG_DEBUG, "forking to background"); 211 switch (pid = fork()) { 212 case -1: 213 logger(LOG_ERR, "fork: %s", strerror(errno)); 214 exit(EXIT_FAILURE); 215 /* NOTREACHED */ 216 case 0: 217 setsid(); 218 /* Notify parent it's safe to exit as we've detached. */ 219 close(sidpipe[0]); 220 if (write(sidpipe[1], &buf, 1) != 1) 221 logger(LOG_ERR, "write: %s", strerror(errno)); 222 close(sidpipe[1]); 223 close_fds(); 224 break; 225 default: 226 /* Reset signals as we're the parent about to exit. */ 227 signal_reset(); 228 /* Wait for child to detach */ 229 close(sidpipe[1]); 230 if (read(sidpipe[0], &buf, 1) != 1) 231 logger(LOG_ERR, "read: %s", strerror(errno)); 232 close(sidpipe[0]); 233 break; 234 } 235 236 /* Done with the fd now */ 237 if (pid != 0) { 238 writepid(*state->pid_fd, pid); 239 close(*state->pid_fd); 240 *state->pid_fd = -1; 241 } 242 243 sigprocmask(SIG_SETMASK, &old, NULL); 244 if (pid == 0) { 245 state->options |= DHCPCD_DAEMONISED; 246 timerclear(&state->exit); 247 return 0; 248 } 249 state->options |= DHCPCD_PERSISTENT | DHCPCD_FORKED; 250 return -1; 251 } 252 #endif 253 254 #define THIRTY_YEARS_IN_SECONDS 946707779 255 static size_t 256 get_duid(unsigned char *duid, const struct interface *iface) 257 { 258 FILE *f; 259 uint16_t type = 0; 260 uint16_t hw = 0; 261 uint32_t ul; 262 time_t t; 263 int x = 0; 264 unsigned char *p = duid; 265 size_t len = 0, l = 0; 266 char *buffer = NULL, *line, *option; 267 268 /* If we already have a DUID then use it as it's never supposed 269 * to change once we have one even if the interfaces do */ 270 if ((f = fopen(DUID, "r"))) { 271 while ((get_line(&buffer, &len, f))) { 272 line = buffer; 273 while ((option = strsep(&line, " \t"))) 274 if (*option != '\0') 275 break; 276 if (!option || *option == '\0' || *option == '#') 277 continue; 278 l = hwaddr_aton(NULL, option); 279 if (l && l <= DUID_LEN) { 280 hwaddr_aton(duid, option); 281 break; 282 } 283 l = 0; 284 } 285 fclose(f); 286 free(buffer); 287 if (l) 288 return l; 289 } else { 290 if (errno != ENOENT) 291 return 0; 292 } 293 294 /* No file? OK, lets make one based on our interface */ 295 if (!(f = fopen(DUID, "w"))) 296 return 0; 297 type = htons(1); /* DUI-D-LLT */ 298 memcpy(p, &type, 2); 299 p += 2; 300 hw = htons(iface->family); 301 memcpy(p, &hw, 2); 302 p += 2; 303 /* time returns seconds from jan 1 1970, but DUID-LLT is 304 * seconds from jan 1 2000 modulo 2^32 */ 305 t = time(NULL) - THIRTY_YEARS_IN_SECONDS; 306 ul = htonl(t & 0xffffffff); 307 memcpy(p, &ul, 4); 308 p += 4; 309 /* Finally, add the MAC address of the interface */ 310 memcpy(p, iface->hwaddr, iface->hwlen); 311 p += iface->hwlen; 312 len = p - duid; 313 x = fprintf(f, "%s\n", hwaddr_ntoa(duid, len)); 314 fclose(f); 315 /* Failed to write the duid? scrub it, we cannot use it */ 316 if (x < 1) { 317 len = 0; 318 unlink(DUID); 319 } 320 return len; 321 } 322 323 static struct dhcp_message* 324 ipv4ll_get_dhcp(uint32_t old_addr) 325 { 326 uint32_t u32; 327 struct dhcp_message *dhcp; 328 uint8_t *p; 329 330 dhcp = xzalloc(sizeof(*dhcp)); 331 /* Put some LL options in */ 332 p = dhcp->options; 333 *p++ = DHO_SUBNETMASK; 334 *p++ = sizeof(u32); 335 u32 = htonl(LINKLOCAL_MASK); 336 memcpy(p, &u32, sizeof(u32)); 337 p += sizeof(u32); 338 *p++ = DHO_BROADCAST; 339 *p++ = sizeof(u32); 340 u32 = htonl(LINKLOCAL_BRDC); 341 memcpy(p, &u32, sizeof(u32)); 342 p += sizeof(u32); 343 *p++ = DHO_END; 344 345 for (;;) { 346 dhcp->yiaddr = htonl(LINKLOCAL_ADDR | 347 (((uint32_t)abs((int)arc4random()) 348 % 0xFD00) + 0x0100)); 349 if (dhcp->yiaddr != old_addr && 350 IN_LINKLOCAL(ntohl(dhcp->yiaddr))) 351 break; 352 } 353 return dhcp; 354 } 355 356 static double 357 timeval_to_double(struct timeval *tv) 358 { 359 return tv->tv_sec * 1.0 + tv->tv_usec * 1.0e-6; 360 } 361 362 static void 363 get_lease(struct dhcp_lease *lease, const struct dhcp_message *dhcp) 364 { 365 time_t t; 366 367 if (lease->frominfo) 368 return; 369 lease->addr.s_addr = dhcp->yiaddr; 370 371 if (get_option_addr(&lease->net, dhcp, DHO_SUBNETMASK) == -1) 372 lease->net.s_addr = get_netmask(dhcp->yiaddr); 373 if (get_option_uint32(&lease->leasetime, dhcp, DHO_LEASETIME) == 0) { 374 /* Ensure that we can use the lease */ 375 t = 0; 376 if (t + (time_t)lease->leasetime < t) { 377 logger(LOG_WARNING, "lease of %u would overflow, " 378 "treating as infinite", lease->leasetime); 379 lease->leasetime = ~0U; /* Infinite lease */ 380 } 381 } else 382 lease->leasetime = DEFAULT_LEASETIME; 383 if (get_option_uint32(&lease->renewaltime, dhcp, DHO_RENEWALTIME) != 0) 384 lease->renewaltime = 0; 385 if (get_option_uint32(&lease->rebindtime, dhcp, DHO_REBINDTIME) != 0) 386 lease->rebindtime = 0; 387 } 388 389 static int 390 get_old_lease(struct if_state *state) 391 { 392 struct interface *iface = state->interface; 393 struct dhcp_lease *lease = &state->lease; 394 struct dhcp_message *dhcp = NULL; 395 struct timeval tv; 396 unsigned int offset = 0; 397 struct stat sb; 398 399 if (stat(iface->leasefile, &sb) == -1) { 400 if (errno != ENOENT) 401 logger(LOG_ERR, "stat: %s", strerror(errno)); 402 goto eexit; 403 } 404 if (!IN_LINKLOCAL(ntohl(iface->addr.s_addr))) 405 logger(LOG_INFO, "trying to use old lease in `%s'", 406 iface->leasefile); 407 if ((dhcp = read_lease(iface)) == NULL) { 408 logger(LOG_INFO, "read_lease: %s", strerror(errno)); 409 goto eexit; 410 } 411 lease->frominfo = 0; 412 get_lease(&state->lease, dhcp); 413 lease->frominfo = 1; 414 lease->leasedfrom = sb.st_mtime; 415 416 /* Vitaly important we remove the server information here */ 417 state->lease.server.s_addr = 0; 418 dhcp->servername[0] = '\0'; 419 420 if (!IN_LINKLOCAL(ntohl(dhcp->yiaddr))) { 421 if (!(state->options & DHCPCD_LASTLEASE)) 422 goto eexit; 423 424 /* Ensure that we can still use the lease */ 425 if (gettimeofday(&tv, NULL) == -1) { 426 logger(LOG_ERR, "gettimeofday: %s", strerror(errno)); 427 goto eexit; 428 } 429 430 offset = tv.tv_sec - lease->leasedfrom; 431 if (lease->leasedfrom && 432 tv.tv_sec - lease->leasedfrom > (time_t)lease->leasetime) 433 { 434 logger(LOG_ERR, "lease expired %u seconds ago", 435 offset + lease->leasetime); 436 /* Persistent interfaces should still try and use the 437 * lease if we can't contact a DHCP server. 438 * We just set the timeout to 1 second. */ 439 if (state->options & DHCPCD_PERSISTENT) 440 offset = lease->renewaltime - 1; 441 else 442 goto eexit; 443 } 444 lease->leasetime -= offset; 445 lease->rebindtime -= offset; 446 lease->renewaltime -= offset; 447 } 448 449 free(state->old); 450 state->old = state->new; 451 state->new = NULL; 452 state->offer = dhcp; 453 return 0; 454 455 eexit: 456 lease->addr.s_addr = 0; 457 free(dhcp); 458 return -1; 459 } 460 461 static int 462 client_setup(struct if_state *state, const struct options *options) 463 { 464 struct interface *iface = state->interface; 465 struct dhcp_lease *lease = &state->lease; 466 struct in_addr addr; 467 struct timeval tv; 468 size_t len = 0; 469 unsigned char *duid = NULL; 470 uint32_t ul; 471 472 state->state = STATE_INIT; 473 state->nakoff = 1; 474 state->options = options->options; 475 timerclear(&tv); 476 477 if (options->request_address.s_addr == 0 && 478 (options->options & DHCPCD_INFORM || 479 options->options & DHCPCD_REQUEST || 480 (options->options & DHCPCD_DAEMONISED && 481 !(options->options & DHCPCD_BACKGROUND)))) 482 { 483 if (get_old_lease(state) != 0) 484 return -1; 485 timerclear(&state->timeout); 486 487 if (!(options->options & DHCPCD_DAEMONISED) && 488 IN_LINKLOCAL(ntohl(lease->addr.s_addr))) 489 { 490 logger(LOG_ERR, "cannot request a link local address"); 491 return -1; 492 } 493 } else { 494 lease->addr.s_addr = options->request_address.s_addr; 495 lease->net.s_addr = options->request_netmask.s_addr; 496 } 497 498 /* If INFORMing, ensure the interface has the address */ 499 if (state->options & DHCPCD_INFORM && 500 has_address(iface->name, &lease->addr, &lease->net) < 1) 501 { 502 addr.s_addr = lease->addr.s_addr | ~lease->net.s_addr; 503 logger(LOG_DEBUG, "adding IP address %s/%d", 504 inet_ntoa(lease->addr), inet_ntocidr(lease->net)); 505 if (add_address(iface->name, &lease->addr, 506 &lease->net, &addr) == -1) 507 { 508 logger(LOG_ERR, "add_address: %s", strerror(errno)); 509 return -1; 510 } 511 iface->addr.s_addr = lease->addr.s_addr; 512 iface->net.s_addr = lease->net.s_addr; 513 } 514 515 /* If we haven't specified a ClientID and our hardware address 516 * length is greater than DHCP_CHADDR_LEN then we enforce a ClientID 517 * of the hardware address family and the hardware address. */ 518 if (!(state->options & DHCPCD_CLIENTID) && iface->hwlen > DHCP_CHADDR_LEN) 519 state->options |= DHCPCD_CLIENTID; 520 521 if (*options->clientid) { 522 iface->clientid = xmalloc(options->clientid[0] + 1); 523 memcpy(iface->clientid, 524 options->clientid, options->clientid[0] + 1); 525 } else if (state->options & DHCPCD_CLIENTID) { 526 if (state->options & DHCPCD_DUID) { 527 duid = xmalloc(DUID_LEN); 528 if ((len = get_duid(duid, iface)) == 0) 529 logger(LOG_ERR, "get_duid: %s", 530 strerror(errno)); 531 } 532 533 if (len > 0) { 534 logger(LOG_DEBUG, "DUID = %s", 535 hwaddr_ntoa(duid, len)); 536 537 iface->clientid = xmalloc(len + 6); 538 iface->clientid[0] = len + 5; 539 iface->clientid[1] = 255; /* RFC 4361 */ 540 541 /* IAID is 4 bytes, so if the iface name is 4 bytes 542 * or less, use it */ 543 ul = strlen(iface->name); 544 if (ul < 5) { 545 memcpy(iface->clientid + 2, iface->name, ul); 546 if (ul < 4) 547 memset(iface->clientid + 2 + ul, 548 0, 4 - ul); 549 } else { 550 /* Name isn't 4 bytes, so use the index */ 551 ul = htonl(if_nametoindex(iface->name)); 552 memcpy(iface->clientid + 2, &ul, 4); 553 } 554 555 memcpy(iface->clientid + 6, duid, len); 556 free(duid); 557 } 558 if (len == 0) { 559 len = iface->hwlen + 1; 560 iface->clientid = xmalloc(len + 1); 561 iface->clientid[0] = len; 562 iface->clientid[1] = iface->family; 563 memcpy(iface->clientid + 2, iface->hwaddr, iface->hwlen); 564 } 565 } 566 567 if (state->options & DHCPCD_LINK) { 568 open_link_socket(iface); 569 switch (carrier_status(iface->name)) { 570 case 0: 571 state->carrier = LINK_DOWN; 572 break; 573 case 1: 574 state->carrier = LINK_UP; 575 break; 576 default: 577 state->carrier = LINK_UNKNOWN; 578 } 579 } 580 581 if (options->timeout > 0 && 582 !(state->options & DHCPCD_DAEMONISED)) 583 { 584 if (state->options & DHCPCD_IPV4LL) { 585 state->stop.tv_sec = options->timeout; 586 if (!(state->options & DHCPCD_BACKGROUND)) 587 state->exit.tv_sec = state->stop.tv_sec + 10; 588 } else if (!(state->options & DHCPCD_BACKGROUND)) 589 state->exit.tv_sec = options->timeout; 590 } 591 return 0; 592 } 593 594 static int 595 do_socket(struct if_state *state, int mode) 596 { 597 if (state->interface->raw_fd != -1) { 598 close(state->interface->raw_fd); 599 state->interface->raw_fd = -1; 600 } 601 if (mode == SOCKET_CLOSED) { 602 if (state->interface->udp_fd != -1) { 603 close(state->interface->udp_fd); 604 state->interface->udp_fd = -1; 605 } 606 if (state->interface->arp_fd != -1) { 607 close(state->interface->arp_fd); 608 state->interface->arp_fd = -1; 609 } 610 } 611 612 /* Always have the UDP socket open to avoid the kernel sending 613 * ICMP unreachable messages. */ 614 /* For systems without SO_BINDTODEVICE, (ie BSD ones) we may get an 615 * error or EADDRINUSE when binding to INADDR_ANY as another dhcpcd 616 * instance could be running. 617 * Oddly enough, we don't care about this as the socket is there 618 * just to please the kernel - we don't care for reading from it. */ 619 if (mode == SOCKET_OPEN && 620 state->interface->udp_fd == -1 && 621 open_udp_socket(state->interface) == -1 && 622 (errno != EADDRINUSE || state->interface->addr.s_addr != 0)) 623 logger(LOG_ERR, "open_udp_socket: %s", strerror(errno)); 624 625 if (mode == SOCKET_OPEN) 626 if (open_socket(state->interface, ETHERTYPE_IP) == -1) { 627 logger(LOG_ERR, "open_socket: %s", strerror(errno)); 628 return -1; 629 } 630 state->socket = mode; 631 return 0; 632 } 633 634 static ssize_t 635 send_message(struct if_state *state, int type, const struct options *options) 636 { 637 struct dhcp_message *dhcp; 638 uint8_t *udp; 639 ssize_t len, r; 640 struct in_addr from, to; 641 in_addr_t a = 0; 642 643 if (state->carrier == LINK_DOWN) 644 return 0; 645 if (type == DHCP_RELEASE) 646 logger(LOG_DEBUG, "sending %s with xid 0x%x", 647 get_dhcp_op(type), state->xid); 648 else 649 logger(LOG_DEBUG, 650 "sending %s with xid 0x%x, next in %0.2f seconds", 651 get_dhcp_op(type), state->xid, 652 timeval_to_double(&state->timeout)); 653 state->messages++; 654 if (state->messages < 0) 655 state->messages = INT_MAX; 656 /* If we couldn't open a UDP port for our IP address 657 * then we cannot renew. 658 * This could happen if our IP was pulled out from underneath us. */ 659 if (state->interface->udp_fd == -1) { 660 a = state->interface->addr.s_addr; 661 state->interface->addr.s_addr = 0; 662 } 663 len = make_message(&dhcp, state->interface, &state->lease, state->xid, 664 type, options); 665 if (state->interface->udp_fd == -1) 666 state->interface->addr.s_addr = a; 667 from.s_addr = dhcp->ciaddr; 668 if (from.s_addr) 669 to.s_addr = state->lease.server.s_addr; 670 else 671 to.s_addr = 0; 672 if (to.s_addr && to.s_addr != INADDR_BROADCAST) { 673 r = send_packet(state->interface, to, (uint8_t *)dhcp, len); 674 if (r == -1) 675 logger(LOG_ERR, "send_packet: %s", strerror(errno)); 676 } else { 677 len = make_udp_packet(&udp, (uint8_t *)dhcp, len, from, to); 678 r = send_raw_packet(state->interface, ETHERTYPE_IP, udp, len); 679 free(udp); 680 if (r == -1) 681 logger(LOG_ERR, "send_raw_packet: %s", strerror(errno)); 682 } 683 free(dhcp); 684 /* Failed to send the packet? Return to the init state */ 685 if (r == -1) { 686 state->state = STATE_INIT; 687 timerclear(&state->timeout); 688 /* We need to set a timeout so we fall through gracefully */ 689 state->stop.tv_sec = 1; 690 state->stop.tv_usec = 0; 691 do_socket(state, SOCKET_CLOSED); 692 } 693 return r; 694 } 695 696 static void 697 drop_config(struct if_state *state, const char *reason, 698 const struct options *options) 699 { 700 if (state->new || strcmp(reason, "FAIL") == 0) { 701 configure(state->interface, reason, NULL, state->new, 702 &state->lease, options, 0); 703 free(state->old); 704 state->old = NULL; 705 free(state->new); 706 state->new = NULL; 707 } 708 state->lease.addr.s_addr = 0; 709 } 710 711 static void 712 reduce_timers(struct if_state *state, const struct timeval *tv) 713 { 714 if (timerisset(&state->exit)) { 715 timersub(&state->exit, tv, &state->exit); 716 if (!timerisset(&state->exit)) 717 state->exit.tv_sec = -1; 718 } 719 if (timerisset(&state->stop)) { 720 timersub(&state->stop, tv, &state->stop); 721 if (!timerisset(&state->stop)) 722 state->stop.tv_sec = -1; 723 } 724 if (timerisset(&state->timeout)) { 725 timersub(&state->timeout, tv, &state->timeout); 726 if (!timerisset(&state->timeout)) 727 state->timeout.tv_sec = -1; 728 } 729 } 730 731 static struct timeval * 732 get_lowest_timer(struct if_state *state) 733 { 734 struct timeval *ref = NULL; 735 736 if (timerisset(&state->exit)) 737 ref = &state->exit; 738 if (timerisset(&state->stop)) { 739 if (!ref || timercmp(&state->stop, ref, <)) 740 ref = &state->stop; 741 } 742 if (timerisset(&state->timeout)) { 743 if (!ref || timercmp(&state->timeout, ref, <)) 744 ref = &state->timeout; 745 } 746 return ref; 747 } 748 749 static int 750 wait_for_fd(struct if_state *state, int *fd) 751 { 752 struct pollfd fds[4]; /* signal, link, raw, arp */ 753 struct interface *iface = state->interface; 754 int i, r, nfds = 0, msecs = -1; 755 struct timeval start, stop, diff, *ref; 756 static int lastinf = 0; 757 758 /* Ensure that we haven't already timed out */ 759 ref = get_lowest_timer(state); 760 if (ref && timerneg(ref)) 761 return 0; 762 763 /* We always listen to signals */ 764 fds[nfds].fd = state->signal_fd; 765 fds[nfds].events = POLLIN; 766 nfds++; 767 /* And links */ 768 if (iface->link_fd != -1) { 769 fds[nfds].fd = iface->link_fd; 770 fds[nfds].events = POLLIN; 771 nfds++; 772 } 773 774 if (state->lease.leasetime == ~0U && 775 state->state == STATE_BOUND) 776 { 777 if (!lastinf) { 778 logger(LOG_DEBUG, "waiting for infinity"); 779 lastinf = 1; 780 } 781 ref = NULL; 782 } else if (state->carrier == LINK_DOWN && !ref) { 783 if (!lastinf) { 784 logger(LOG_DEBUG, "waiting for carrier"); 785 lastinf = 1; 786 } 787 if (timerisset(&state->exit)) 788 ref = &state->exit; 789 else 790 ref = NULL; 791 } else { 792 if (iface->raw_fd != -1) { 793 fds[nfds].fd = iface->raw_fd; 794 fds[nfds].events = POLLIN; 795 nfds++; 796 } 797 if (iface->arp_fd != -1) { 798 fds[nfds].fd = iface->arp_fd; 799 fds[nfds].events = POLLIN; 800 nfds++; 801 } 802 } 803 804 /* Wait and then reduce the timers. 805 * If we reduce a timer to zero, set it negative to indicate timeout. 806 * We cannot reliably use select as there is no guarantee we will 807 * actually wait the whole time if greater than 31 days according 808 * to POSIX. So we loop on poll if needed as it's limitation of 809 * INT_MAX milliseconds is known. */ 810 for (;;) { 811 get_monotonic(&start); 812 if (ref) { 813 lastinf = 0; 814 if (ref->tv_sec > INT_MAX / 1000 || 815 (ref->tv_sec == INT_MAX / 1000 && 816 (ref->tv_usec + 999) / 1000 > INT_MAX % 1000)) 817 msecs = INT_MAX; 818 else 819 msecs = ref->tv_sec * 1000 + 820 (ref->tv_usec + 999) / 1000; 821 } else 822 msecs = -1; 823 r = poll(fds, nfds, msecs); 824 get_monotonic(&stop); 825 timersub(&stop, &start, &diff); 826 reduce_timers(state, &diff); 827 if (r == -1) { 828 if (errno != EINTR) 829 logger(LOG_ERR, "poll: %s", strerror(errno)); 830 return -1; 831 } 832 if (r) 833 break; 834 /* We should not have an infinite timeout if we get here */ 835 if (timerneg(ref)) 836 return 0; 837 } 838 839 /* We configured our array in the order we should deal with them */ 840 for (i = 0; i < nfds; i++) { 841 if (fds[i].revents & POLLERR) { 842 syslog(LOG_ERR, "poll: POLLERR on fd %d", fds[i].fd); 843 errno = EBADF; 844 return -1; 845 } 846 if (fds[i].revents & POLLNVAL) { 847 syslog(LOG_ERR, "poll: POLLNVAL on fd %d", fds[i].fd); 848 errno = EINVAL; 849 return -1; 850 } 851 if (fds[i].revents & (POLLIN | POLLHUP)) { 852 *fd = fds[i].fd; 853 return r; 854 } 855 } 856 /* We should never get here. */ 857 return 0; 858 } 859 860 static int 861 handle_signal(int sig, struct if_state *state, const struct options *options) 862 { 863 struct dhcp_lease *lease = &state->lease; 864 865 switch (sig) { 866 case SIGINT: 867 logger(LOG_INFO, "received SIGINT, stopping"); 868 if (!(state->options & DHCPCD_PERSISTENT)) 869 drop_config(state, "STOP", options); 870 return -1; 871 case SIGTERM: 872 logger(LOG_INFO, "received SIGTERM, stopping"); 873 if (!(state->options & DHCPCD_PERSISTENT)) 874 drop_config(state, "STOP", options); 875 return -1; 876 case SIGALRM: 877 logger(LOG_INFO, "received SIGALRM, renewing lease"); 878 do_socket(state, SOCKET_CLOSED); 879 state->state = STATE_RENEW_REQUESTED; 880 timerclear(&state->timeout); 881 timerclear(&state->stop); 882 return 1; 883 case SIGHUP: 884 logger(LOG_INFO, "received SIGHUP, releasing lease"); 885 if (lease->addr.s_addr && 886 !IN_LINKLOCAL(ntohl(lease->addr.s_addr))) 887 { 888 do_socket(state, SOCKET_OPEN); 889 state->xid = arc4random(); 890 send_message(state, DHCP_RELEASE, options); 891 do_socket(state, SOCKET_CLOSED); 892 } 893 drop_config(state, "RELEASE", options); 894 return -1; 895 default: 896 logger (LOG_ERR, 897 "received signal %d, but don't know what to do with it", 898 sig); 899 } 900 901 return 0; 902 } 903 904 static int bind_dhcp(struct if_state *state, const struct options *options) 905 { 906 struct interface *iface = state->interface; 907 struct dhcp_lease *lease = &state->lease; 908 const char *reason = NULL; 909 struct timeval start, stop, diff; 910 int retval; 911 912 free(state->old); 913 state->old = state->new; 914 state->new = state->offer; 915 state->offer = NULL; 916 state->messages = 0; 917 state->conflicts = 0; 918 state->defend = 0; 919 timerclear(&state->exit); 920 if (clock_monotonic) 921 get_monotonic(&lease->boundtime); 922 923 if (options->options & DHCPCD_INFORM) { 924 if (options->request_address.s_addr != 0) 925 lease->addr.s_addr = options->request_address.s_addr; 926 else 927 lease->addr.s_addr = iface->addr.s_addr; 928 logger(LOG_INFO, "received approval for %s", 929 inet_ntoa(lease->addr)); 930 state->state = STATE_BOUND; 931 state->lease.leasetime = ~0U; 932 timerclear(&state->stop); 933 reason = "INFORM"; 934 } else if (IN_LINKLOCAL(htonl(state->new->yiaddr))) { 935 get_lease(lease, state->new); 936 logger(LOG_INFO, "using IPv4LL address %s", 937 inet_ntoa(lease->addr)); 938 state->state = STATE_INIT; 939 timerclear(&state->timeout); 940 reason = "IPV4LL"; 941 } else { 942 if (gettimeofday(&start, NULL) == 0) 943 lease->leasedfrom = start.tv_sec; 944 945 get_lease(lease, state->new); 946 if (lease->frominfo) 947 reason = "TIMEOUT"; 948 949 if (lease->leasetime == ~0U) { 950 lease->renewaltime = lease->rebindtime = lease->leasetime; 951 logger(LOG_INFO, "leased %s for infinity", 952 inet_ntoa(lease->addr)); 953 state->state = STATE_BOUND; 954 timerclear(&state->stop); 955 } else { 956 if (lease->rebindtime == 0) 957 lease->rebindtime = lease->leasetime * T2; 958 else if (lease->rebindtime >= lease->leasetime) { 959 lease->rebindtime = lease->leasetime * T2; 960 logger(LOG_ERR, 961 "rebind time greater than lease " 962 "time, forcing to %u seconds", 963 lease->rebindtime); 964 } 965 if (lease->renewaltime == 0) 966 lease->renewaltime = lease->leasetime * T1; 967 else if (lease->renewaltime > lease->rebindtime) { 968 lease->renewaltime = lease->leasetime * T1; 969 logger(LOG_ERR, 970 "renewal time greater than rebind time, " 971 "forcing to %u seconds", 972 lease->renewaltime); 973 } 974 logger(LOG_INFO, 975 "leased %s for %u seconds", 976 inet_ntoa(lease->addr), lease->leasetime); 977 state->stop.tv_sec = lease->renewaltime; 978 state->stop.tv_usec = 0; 979 } 980 state->state = STATE_BOUND; 981 } 982 983 state->xid = 0; 984 timerclear(&state->timeout); 985 if (!reason) { 986 if (state->old) { 987 if (state->old->yiaddr == state->new->yiaddr && 988 lease->server.s_addr) 989 reason = "RENEW"; 990 else 991 reason = "REBIND"; 992 } else 993 reason = "BOUND"; 994 } 995 /* If we have a monotonic clock we can safely substract the 996 * script execution time from our timers. 997 * Otherwise we can't as the script may update the real time. */ 998 if (clock_monotonic) 999 get_monotonic(&start); 1000 retval = configure(iface, reason, state->new, state->old, 1001 &state->lease, options, 1); 1002 if (clock_monotonic) { 1003 get_monotonic(&stop); 1004 timersub(&stop, &start, &diff); 1005 reduce_timers(state, &diff); 1006 } 1007 if (retval != 0) 1008 return -1; 1009 return daemonise(state, options); 1010 } 1011 1012 static int 1013 handle_timeout_fail(struct if_state *state, const struct options *options) 1014 { 1015 struct dhcp_lease *lease = &state->lease; 1016 struct interface *iface = state->interface; 1017 int gotlease = -1, r; 1018 const char *reason = NULL; 1019 1020 timerclear(&state->stop); 1021 timerclear(&state->exit); 1022 if (state->state != STATE_DISCOVERING) 1023 state->messages = 0; 1024 1025 switch (state->state) { 1026 case STATE_INIT: /* FALLTHROUGH */ 1027 case STATE_DISCOVERING: /* FALLTHROUGH */ 1028 case STATE_REQUESTING: 1029 if (IN_LINKLOCAL(ntohl(iface->addr.s_addr))) { 1030 if (!(state->options & DHCPCD_DAEMONISED)) 1031 logger(LOG_ERR, "timed out"); 1032 } else { 1033 if (iface->addr.s_addr != 0 && 1034 !(state->options & DHCPCD_INFORM)) 1035 logger(LOG_ERR, "lost lease"); 1036 else if (state->carrier != LINK_DOWN || 1037 !(state->options & DHCPCD_DAEMONISED)) 1038 logger(LOG_ERR, "timed out"); 1039 } 1040 do_socket(state, SOCKET_CLOSED); 1041 if (state->options & DHCPCD_INFORM || 1042 state->options & DHCPCD_TEST) 1043 return -1; 1044 1045 if (state->carrier != LINK_DOWN && 1046 (state->options & DHCPCD_IPV4LL || 1047 state->options & DHCPCD_LASTLEASE)) 1048 gotlease = get_old_lease(state); 1049 1050 if (state->carrier != LINK_DOWN && 1051 state->options & DHCPCD_IPV4LL && 1052 gotlease != 0) 1053 { 1054 logger(LOG_INFO, "probing for an IPV4LL address"); 1055 free(state->offer); 1056 lease->frominfo = 0; 1057 state->offer = ipv4ll_get_dhcp(0); 1058 gotlease = 0; 1059 } 1060 1061 if (gotlease == 0 && 1062 state->offer->yiaddr != iface->addr.s_addr && 1063 state->options & DHCPCD_ARP) 1064 { 1065 state->state = STATE_PROBING; 1066 state->claims = 0; 1067 state->probes = 0; 1068 if (iface->addr.s_addr) 1069 state->conflicts = 0; 1070 return 1; 1071 } 1072 1073 if (gotlease == 0) { 1074 r = bind_dhcp(state, options); 1075 logger(LOG_DEBUG, "renew in %ld seconds", 1076 (long int)state->stop.tv_sec); 1077 return r; 1078 } 1079 if (iface->addr.s_addr) 1080 reason = "EXPIRE"; 1081 else 1082 reason = "FAIL"; 1083 drop_config(state, reason, options); 1084 if (!(state->options & DHCPCD_DAEMONISED) && 1085 (state->options & DHCPCD_DAEMONISE)) 1086 return -1; 1087 state->state = STATE_RENEW_REQUESTED; 1088 return 1; 1089 case STATE_BOUND: 1090 logger(LOG_INFO, "renewing lease of %s",inet_ntoa(lease->addr)); 1091 if (state->carrier != LINK_DOWN) 1092 do_socket(state, SOCKET_OPEN); 1093 state->xid = arc4random(); 1094 state->state = STATE_RENEWING; 1095 state->stop.tv_sec = lease->rebindtime - lease->renewaltime; 1096 break; 1097 case STATE_RENEWING: 1098 logger(LOG_ERR, "failed to renew, attempting to rebind"); 1099 state->state = STATE_REBINDING; 1100 if (lease->server.s_addr == 0) 1101 state->stop.tv_sec = options->timeout; 1102 else 1103 state->stop.tv_sec = lease->rebindtime - \ 1104 lease->renewaltime; 1105 lease->server.s_addr = 0; 1106 break; 1107 case STATE_REBINDING: 1108 logger(LOG_ERR, "failed to rebind"); 1109 reason = "EXPIRE"; 1110 drop_config(state, reason, options); 1111 state->state = STATE_INIT; 1112 break; 1113 case STATE_PROBING: /* FALLTHROUGH */ 1114 case STATE_ANNOUNCING: 1115 /* We should have lost carrier here and exit timer went */ 1116 logger(LOG_ERR, "timed out"); 1117 return -1; 1118 default: 1119 logger(LOG_DEBUG, "handle_timeout_failed: invalid state %d", 1120 state->state); 1121 } 1122 1123 /* This effectively falls through into the handle_timeout funtion */ 1124 return 1; 1125 } 1126 1127 static int 1128 handle_timeout(struct if_state *state, const struct options *options) 1129 { 1130 struct dhcp_lease *lease = &state->lease; 1131 struct interface *iface = state->interface; 1132 int i = 0; 1133 struct in_addr addr; 1134 struct timeval tv; 1135 1136 timerclear(&state->timeout); 1137 if (timerneg(&state->exit)) 1138 return handle_timeout_fail(state, options); 1139 1140 if (state->state == STATE_RENEW_REQUESTED && 1141 IN_LINKLOCAL(ntohl(lease->addr.s_addr))) 1142 { 1143 state->state = STATE_PROBING; 1144 free(state->offer); 1145 state->offer = read_lease(state->interface); 1146 state->probes = 0; 1147 state->claims = 0; 1148 } 1149 switch (state->state) { 1150 case STATE_INIT_IPV4LL: 1151 state->state = STATE_PROBING; 1152 free(state->offer); 1153 state->offer = ipv4ll_get_dhcp(0); 1154 state->probes = 0; 1155 state->claims = 0; 1156 /* FALLTHROUGH */ 1157 case STATE_PROBING: 1158 if (iface->arp_fd == -1) 1159 open_socket(iface, ETHERTYPE_ARP); 1160 if (state->probes < PROBE_NUM) { 1161 if (state->probes == 0) { 1162 addr.s_addr = state->offer->yiaddr; 1163 logger(LOG_INFO, "checking %s is available" 1164 " on attached networks", 1165 inet_ntoa(addr)); 1166 } 1167 state->probes++; 1168 if (state->probes < PROBE_NUM) { 1169 state->timeout.tv_sec = PROBE_MIN; 1170 state->timeout.tv_usec = arc4random() % 1171 (PROBE_MAX_U - PROBE_MIN_U); 1172 timernorm(&state->timeout); 1173 } else { 1174 state->timeout.tv_sec = ANNOUNCE_WAIT; 1175 state->timeout.tv_usec = 0; 1176 } 1177 logger(LOG_DEBUG, 1178 "sending ARP probe (%d of %d), next in %0.2f seconds", 1179 state->probes, PROBE_NUM, 1180 timeval_to_double(&state->timeout)); 1181 if (send_arp(iface, ARPOP_REQUEST, 0, 1182 state->offer->yiaddr) == -1) 1183 { 1184 logger(LOG_ERR, "send_arp: %s", strerror(errno)); 1185 return -1; 1186 } 1187 return 0; 1188 } else { 1189 /* We've waited for ANNOUNCE_WAIT after the final probe 1190 * so the address is now ours */ 1191 i = bind_dhcp(state, options); 1192 state->state = STATE_ANNOUNCING; 1193 state->timeout.tv_sec = ANNOUNCE_INTERVAL; 1194 state->timeout.tv_usec = 0; 1195 return i; 1196 } 1197 break; 1198 case STATE_ANNOUNCING: 1199 if (iface->arp_fd == -1) 1200 open_socket(iface, ETHERTYPE_ARP); 1201 if (state->claims < ANNOUNCE_NUM) { 1202 state->claims++; 1203 if (state->claims < ANNOUNCE_NUM) { 1204 state->timeout.tv_sec = ANNOUNCE_INTERVAL; 1205 state->timeout.tv_usec = 0; 1206 logger(LOG_DEBUG, 1207 "sending ARP announce (%d of %d)," 1208 " next in %0.2f seconds", 1209 state->claims, ANNOUNCE_NUM, 1210 timeval_to_double(&state->timeout)); 1211 } else 1212 logger(LOG_DEBUG, 1213 "sending ARP announce (%d of %d)", 1214 state->claims, ANNOUNCE_NUM); 1215 i = send_arp(iface, ARPOP_REQUEST, 1216 state->new->yiaddr, state->new->yiaddr); 1217 if (i == -1) { 1218 logger(LOG_ERR, "send_arp: %s", strerror(errno)); 1219 return -1; 1220 } 1221 } 1222 if (state->claims < ANNOUNCE_NUM) 1223 return 0; 1224 if (IN_LINKLOCAL(htonl(state->new->yiaddr))) { 1225 /* We should pretend to be at the end 1226 * of the DHCP negotation cycle */ 1227 state->state = STATE_INIT; 1228 state->messages = DHCP_MAX / DHCP_BASE; 1229 state->probes = 0; 1230 state->claims = 0; 1231 timerclear(&state->stop); 1232 goto dhcp_timeout; 1233 } else { 1234 state->state = STATE_BOUND; 1235 close(iface->arp_fd); 1236 iface->arp_fd = -1; 1237 if (lease->leasetime != ~0U) { 1238 state->stop.tv_sec = lease->renewaltime; 1239 state->stop.tv_usec = 0; 1240 if (clock_monotonic) { 1241 get_monotonic(&tv); 1242 timersub(&tv, &lease->boundtime, &tv); 1243 timersub(&state->stop, &tv, &state->stop); 1244 } else { 1245 state->stop.tv_sec -= 1246 (ANNOUNCE_INTERVAL * ANNOUNCE_NUM); 1247 } 1248 logger(LOG_DEBUG, "renew in %ld seconds", 1249 (long int)state->stop.tv_sec); 1250 } 1251 } 1252 return 0; 1253 } 1254 1255 if (timerneg(&state->stop)) 1256 return handle_timeout_fail(state, options); 1257 1258 switch (state->state) { 1259 case STATE_BOUND: /* FALLTHROUGH */ 1260 case STATE_RENEW_REQUESTED: 1261 timerclear(&state->stop); 1262 /* FALLTHROUGH */ 1263 case STATE_INIT: 1264 if (state->carrier == LINK_DOWN) 1265 return 0; 1266 do_socket(state, SOCKET_OPEN); 1267 state->xid = arc4random(); 1268 iface->start_uptime = uptime(); 1269 break; 1270 } 1271 1272 switch(state->state) { 1273 case STATE_RENEW_REQUESTED: 1274 /* If a renew was requested (ie, didn't timeout) we actually 1275 * enter the REBIND state so that we broadcast to all servers. 1276 * We need to do this for when we change networks. */ 1277 lease->server.s_addr = 0; 1278 state->messages = 0; 1279 if (lease->addr.s_addr && !(state->options & DHCPCD_INFORM)) { 1280 logger(LOG_INFO, "rebinding lease of %s", 1281 inet_ntoa(lease->addr)); 1282 state->state = STATE_REBINDING; 1283 state->stop.tv_sec = options->timeout; 1284 state->stop.tv_usec = 0; 1285 break; 1286 } 1287 /* FALLTHROUGH */ 1288 case STATE_INIT: 1289 if (lease->addr.s_addr == 0 || 1290 IN_LINKLOCAL(ntohl(iface->addr.s_addr))) 1291 { 1292 logger(LOG_INFO, "broadcasting for a lease"); 1293 state->state = STATE_DISCOVERING; 1294 } else if (state->options & DHCPCD_INFORM) { 1295 logger(LOG_INFO, "broadcasting inform for %s", 1296 inet_ntoa(lease->addr)); 1297 state->state = STATE_REQUESTING; 1298 } else { 1299 logger(LOG_INFO, "broadcasting for a lease of %s", 1300 inet_ntoa(lease->addr)); 1301 state->state = STATE_REQUESTING; 1302 } 1303 if (!lease->addr.s_addr && !timerisset(&state->stop)) { 1304 state->stop.tv_sec = DHCP_MAX + DHCP_RAND_MIN; 1305 state->stop.tv_usec = arc4random() % (DHCP_RAND_MAX_U - DHCP_RAND_MIN_U); 1306 timernorm(&state->stop); 1307 } 1308 break; 1309 } 1310 1311 dhcp_timeout: 1312 if (state->carrier == LINK_DOWN) { 1313 timerclear(&state->timeout); 1314 return 0; 1315 } 1316 state->timeout.tv_sec = DHCP_BASE; 1317 for (i = 0; i < state->messages; i++) { 1318 state->timeout.tv_sec *= 2; 1319 if (state->timeout.tv_sec > DHCP_MAX) { 1320 state->timeout.tv_sec = DHCP_MAX; 1321 break; 1322 } 1323 } 1324 state->timeout.tv_sec += DHCP_RAND_MIN; 1325 state->timeout.tv_usec = arc4random() % 1326 (DHCP_RAND_MAX_U - DHCP_RAND_MIN_U); 1327 timernorm(&state->timeout); 1328 1329 /* We send the message here so that the timeout is reported */ 1330 switch (state->state) { 1331 case STATE_DISCOVERING: 1332 send_message(state, DHCP_DISCOVER, options); 1333 break; 1334 case STATE_REQUESTING: 1335 if (state->options & DHCPCD_INFORM) { 1336 send_message(state, DHCP_INFORM, options); 1337 break; 1338 } 1339 /* FALLTHROUGH */ 1340 case STATE_RENEWING: /* FALLTHROUGH */ 1341 case STATE_REBINDING: 1342 if (iface->raw_fd == -1) 1343 do_socket(state, SOCKET_OPEN); 1344 send_message(state, DHCP_REQUEST, options); 1345 break; 1346 } 1347 1348 return 0; 1349 } 1350 1351 static void 1352 log_dhcp(int lvl, const char *msg, const struct dhcp_message *dhcp) 1353 { 1354 char *a; 1355 struct in_addr addr; 1356 int r; 1357 1358 if (strcmp(msg, "NAK:") == 0) 1359 a = get_option_string(dhcp, DHO_MESSAGE); 1360 else { 1361 addr.s_addr = dhcp->yiaddr; 1362 a = xstrdup(inet_ntoa(addr)); 1363 } 1364 r = get_option_addr(&addr, dhcp, DHO_SERVERID); 1365 if (dhcp->servername[0] && r == 0) 1366 logger(lvl, "%s %s from %s `%s'", msg, a, 1367 inet_ntoa(addr), dhcp->servername); 1368 else if (r == 0) 1369 logger(lvl, "%s %s from %s", msg, a, inet_ntoa(addr)); 1370 else 1371 logger(lvl, "%s %s", msg, a); 1372 free(a); 1373 } 1374 1375 static int 1376 handle_dhcp(struct if_state *state, struct dhcp_message **dhcpp, 1377 const struct options *options) 1378 { 1379 struct dhcp_message *dhcp = *dhcpp; 1380 struct interface *iface = state->interface; 1381 struct dhcp_lease *lease = &state->lease; 1382 uint8_t type, tmp; 1383 struct in_addr addr; 1384 size_t i; 1385 int r; 1386 1387 /* reset the message counter */ 1388 state->messages = 0; 1389 1390 /* We have to have DHCP type to work */ 1391 if (get_option_uint8(&type, dhcp, DHO_MESSAGETYPE) == -1) { 1392 logger(LOG_ERR, "ignoring message; no DHCP type"); 1393 return 0; 1394 } 1395 /* Every DHCP message should include ServerID */ 1396 if (get_option_addr(&addr, dhcp, DHO_SERVERID) == -1) { 1397 logger(LOG_ERR, "ignoring message; no Server ID"); 1398 return 0; 1399 } 1400 1401 /* Ensure that it's not from a blacklisted server. 1402 * We should expand this to check IP and/or hardware address 1403 * at the packet level. */ 1404 if (options->blacklist_len != 0 && 1405 get_option_addr(&addr, dhcp, DHO_SERVERID) == 0) 1406 { 1407 for (i = 0; i < options->blacklist_len; i++) { 1408 if (options->blacklist[i] != addr.s_addr) 1409 continue; 1410 if (dhcp->servername[0]) 1411 logger(LOG_WARNING, 1412 "ignoring blacklisted server %s `%s'", 1413 inet_ntoa(addr), dhcp->servername); 1414 else 1415 logger(LOG_WARNING, 1416 "ignoring blacklisted server %s", 1417 inet_ntoa(addr)); 1418 return 0; 1419 } 1420 } 1421 1422 /* We should restart on a NAK */ 1423 if (type == DHCP_NAK) { 1424 log_dhcp(LOG_WARNING, "NAK:", dhcp); 1425 drop_config(state, "EXPIRE", options); 1426 do_socket(state, SOCKET_CLOSED); 1427 state->state = STATE_INIT; 1428 /* If we constantly get NAKS then we should slowly back off */ 1429 if (state->nakoff == 0) { 1430 state->nakoff = 1; 1431 timerclear(&state->timeout); 1432 } else { 1433 state->timeout.tv_sec = state->nakoff; 1434 state->timeout.tv_usec = 0; 1435 state->nakoff *= 2; 1436 if (state->nakoff > NAKOFF_MAX) 1437 state->nakoff = NAKOFF_MAX; 1438 } 1439 return 0; 1440 } 1441 1442 /* No NAK, so reset the backoff */ 1443 state->nakoff = 1; 1444 1445 /* Ensure that all required options are present */ 1446 for (i = 1; i < 255; i++) { 1447 if (has_option_mask(options->requiremask, i) && 1448 get_option_uint8(&tmp, dhcp, i) != 0) 1449 { 1450 log_dhcp(LOG_WARNING, "reject", dhcp); 1451 return 0; 1452 } 1453 } 1454 1455 if (type == DHCP_OFFER && state->state == STATE_DISCOVERING) { 1456 lease->addr.s_addr = dhcp->yiaddr; 1457 get_option_addr(&lease->server, dhcp, DHO_SERVERID); 1458 log_dhcp(LOG_INFO, "offered", dhcp); 1459 if (state->options & DHCPCD_TEST) { 1460 run_script(options, iface->name, "TEST", dhcp, NULL); 1461 /* Fake the fact we forked so we return 0 to userland */ 1462 state->options |= DHCPCD_FORKED; 1463 return -1; 1464 } 1465 free(state->offer); 1466 state->offer = dhcp; 1467 *dhcpp = NULL; 1468 timerclear(&state->timeout); 1469 state->state = STATE_REQUESTING; 1470 return 1; 1471 } 1472 1473 if (type == DHCP_OFFER) { 1474 log_dhcp(LOG_INFO, "ignoring offer of", dhcp); 1475 return 0; 1476 } 1477 1478 /* We should only be dealing with acks */ 1479 if (type != DHCP_ACK) { 1480 log_dhcp(LOG_ERR, "not ACK or OFFER", dhcp); 1481 return 0; 1482 } 1483 1484 switch (state->state) { 1485 case STATE_RENEW_REQUESTED: 1486 case STATE_REQUESTING: 1487 case STATE_RENEWING: 1488 case STATE_REBINDING: 1489 if (!(state->options & DHCPCD_INFORM)) { 1490 get_option_addr(&lease->server, 1491 dhcp, DHO_SERVERID); 1492 log_dhcp(LOG_INFO, "acknowledged", dhcp); 1493 } 1494 free(state->offer); 1495 state->offer = dhcp; 1496 *dhcpp = NULL; 1497 break; 1498 default: 1499 logger(LOG_ERR, "wrong state %d", state->state); 1500 } 1501 1502 lease->frominfo = 0; 1503 do_socket(state, SOCKET_CLOSED); 1504 if (state->options & DHCPCD_ARP && 1505 iface->addr.s_addr != state->offer->yiaddr) 1506 { 1507 /* If the interface already has the address configured 1508 * then we can't ARP for duplicate detection. */ 1509 addr.s_addr = state->offer->yiaddr; 1510 if (!has_address(iface->name, &addr, NULL)) { 1511 state->state = STATE_PROBING; 1512 state->claims = 0; 1513 state->probes = 0; 1514 state->conflicts = 0; 1515 timerclear(&state->stop); 1516 return 1; 1517 } 1518 } 1519 1520 r = bind_dhcp(state, options); 1521 if (!(state->options & DHCPCD_ARP)) { 1522 if (!(state->options & DHCPCD_INFORM)) 1523 logger(LOG_DEBUG, "renew in %ld seconds", 1524 (long int)state->stop.tv_sec); 1525 return r; 1526 } 1527 state->state = STATE_ANNOUNCING; 1528 if (state->options & DHCPCD_FORKED) 1529 return r; 1530 return 1; 1531 } 1532 1533 static int 1534 handle_dhcp_packet(struct if_state *state, const struct options *options) 1535 { 1536 uint8_t *packet; 1537 struct interface *iface = state->interface; 1538 struct dhcp_message *dhcp = NULL; 1539 const uint8_t *pp; 1540 ssize_t bytes; 1541 int retval = -1; 1542 1543 /* We loop through until our buffer is empty. 1544 * The benefit is that if we get >1 DHCP packet in our buffer and 1545 * the first one fails for any reason, we can use the next. */ 1546 packet = xmalloc(udp_dhcp_len); 1547 for(;;) { 1548 bytes = get_raw_packet(iface, ETHERTYPE_IP, 1549 packet, udp_dhcp_len); 1550 if (bytes == 0) { 1551 retval = 0; 1552 break; 1553 } 1554 if (bytes == -1) 1555 break; 1556 if (valid_udp_packet(packet, bytes) == -1) 1557 continue; 1558 bytes = get_udp_data(&pp, packet); 1559 if ((size_t)bytes > sizeof(*dhcp)) { 1560 logger(LOG_ERR, "packet greater than DHCP size"); 1561 continue; 1562 } 1563 if (!dhcp) 1564 dhcp = xzalloc(sizeof(*dhcp)); 1565 memcpy(dhcp, pp, bytes); 1566 if (dhcp->cookie != htonl(MAGIC_COOKIE)) { 1567 logger(LOG_DEBUG, "bogus cookie, ignoring"); 1568 continue; 1569 } 1570 /* Ensure it's the right transaction */ 1571 if (state->xid != dhcp->xid) { 1572 logger(LOG_DEBUG, 1573 "ignoring packet with xid 0x%x as" 1574 " it's not ours (0x%x)", 1575 dhcp->xid, state->xid); 1576 continue; 1577 } 1578 /* Ensure packet is for us */ 1579 if (iface->hwlen <= sizeof(dhcp->chaddr) && 1580 memcmp(dhcp->chaddr, iface->hwaddr, iface->hwlen)) 1581 { 1582 logger(LOG_DEBUG, "xid 0x%x is not for our hwaddr %s", 1583 dhcp->xid, 1584 hwaddr_ntoa(dhcp->chaddr, sizeof(dhcp->chaddr))); 1585 continue; 1586 } 1587 retval = handle_dhcp(state, &dhcp, options); 1588 if (retval == 0 && state->options & DHCPCD_TEST) 1589 state->options |= DHCPCD_FORKED; 1590 break; 1591 } 1592 1593 free(packet); 1594 free(dhcp); 1595 return retval; 1596 } 1597 1598 static int 1599 handle_arp_packet(struct if_state *state) 1600 { 1601 struct arphdr reply; 1602 uint32_t reply_s; 1603 uint32_t reply_t; 1604 uint8_t arp_reply[sizeof(reply) + 2 * sizeof(reply_s) + 2 * HWADDR_LEN]; 1605 uint8_t *hw_s, *hw_t; 1606 ssize_t bytes; 1607 struct interface *iface = state->interface; 1608 1609 state->fail.s_addr = 0; 1610 for(;;) { 1611 bytes = get_raw_packet(iface, ETHERTYPE_ARP, 1612 arp_reply, sizeof(arp_reply)); 1613 if (bytes == 0 || bytes == -1) 1614 return (int)bytes; 1615 /* We must have a full ARP header */ 1616 if ((size_t)bytes < sizeof(reply)) 1617 continue; 1618 memcpy(&reply, arp_reply, sizeof(reply)); 1619 /* Protocol must be IP. */ 1620 if (reply.ar_pro != htons(ETHERTYPE_IP)) 1621 continue; 1622 if (reply.ar_pln != sizeof(reply_s)) 1623 continue; 1624 /* Only these types are recognised */ 1625 if (reply.ar_op != htons(ARPOP_REPLY) && 1626 reply.ar_op != htons(ARPOP_REQUEST)) 1627 continue; 1628 1629 /* Get pointers to the hardware addreses */ 1630 hw_s = arp_reply + sizeof(reply); 1631 hw_t = hw_s + reply.ar_hln + reply.ar_pln; 1632 /* Ensure we got all the data */ 1633 if ((hw_t + reply.ar_hln + reply.ar_pln) - arp_reply > bytes) 1634 continue; 1635 /* Ignore messages from ourself */ 1636 if (reply.ar_hln == iface->hwlen && 1637 memcmp(hw_s, iface->hwaddr, iface->hwlen) == 0) 1638 continue; 1639 /* Copy out the IP addresses */ 1640 memcpy(&reply_s, hw_s + reply.ar_hln, reply.ar_pln); 1641 memcpy(&reply_t, hw_t + reply.ar_hln, reply.ar_pln); 1642 1643 /* Check for conflict */ 1644 if (state->offer && 1645 (reply_s == state->offer->yiaddr || 1646 (reply_s == 0 && reply_t == state->offer->yiaddr))) 1647 state->fail.s_addr = state->offer->yiaddr; 1648 1649 /* Handle IPv4LL conflicts */ 1650 if (IN_LINKLOCAL(htonl(iface->addr.s_addr)) && 1651 (reply_s == iface->addr.s_addr || 1652 (reply_s == 0 && reply_t == iface->addr.s_addr))) 1653 state->fail.s_addr = iface->addr.s_addr; 1654 1655 if (state->fail.s_addr) { 1656 logger(LOG_ERR, "hardware address %s claims %s", 1657 hwaddr_ntoa((unsigned char *)hw_s, 1658 (size_t)reply.ar_hln), 1659 inet_ntoa(state->fail)); 1660 errno = EEXIST; 1661 return -1; 1662 } 1663 } 1664 } 1665 1666 static int 1667 handle_arp_fail(struct if_state *state, const struct options *options) 1668 { 1669 time_t up; 1670 int cookie = state->offer->cookie; 1671 1672 if (!IN_LINKLOCAL(htonl(state->fail.s_addr))) { 1673 if (cookie) { 1674 state->timeout.tv_sec = DHCP_ARP_FAIL; 1675 state->timeout.tv_usec = 0; 1676 do_socket(state, SOCKET_OPEN); 1677 send_message(state, DHCP_DECLINE, options); 1678 do_socket(state, SOCKET_CLOSED); 1679 } 1680 state->state = STATE_INIT; 1681 free(state->offer); 1682 state->offer = NULL; 1683 state->lease.addr.s_addr = 0; 1684 if (!cookie) 1685 return 1; 1686 return 0; 1687 } 1688 1689 if (state->fail.s_addr == state->interface->addr.s_addr) { 1690 if (state->state == STATE_PROBING) 1691 /* This should only happen when SIGALRM or 1692 * link when down/up and we have a conflict. */ 1693 drop_config(state, "EXPIRE", options); 1694 else { 1695 up = uptime(); 1696 if (state->defend + DEFEND_INTERVAL > up) { 1697 drop_config(state, "EXPIRE", options); 1698 state->conflicts = -1; 1699 /* drop through to set conflicts to 0 */ 1700 } else { 1701 state->defend = up; 1702 return 0; 1703 } 1704 } 1705 } 1706 do_socket(state, SOCKET_CLOSED); 1707 state->conflicts++; 1708 timerclear(&state->stop); 1709 if (state->conflicts > MAX_CONFLICTS) { 1710 logger(LOG_ERR, "failed to obtain an IPv4LL address"); 1711 state->state = STATE_INIT; 1712 timerclear(&state->timeout); 1713 if (!(state->options & DHCPCD_DAEMONISED) && 1714 (state->options & DHCPCD_DAEMONISE)) 1715 return -1; 1716 return 1; 1717 } 1718 state->state = STATE_INIT_IPV4LL; 1719 state->timeout.tv_sec = PROBE_WAIT; 1720 state->timeout.tv_usec = 0; 1721 return 0; 1722 } 1723 1724 static int 1725 handle_link(struct if_state *state) 1726 { 1727 int retval; 1728 1729 retval = link_changed(state->interface); 1730 if (retval == -1) { 1731 logger(LOG_ERR, "link_changed: %s", strerror(errno)); 1732 return -1; 1733 } 1734 if (retval == 0) 1735 return 0; 1736 1737 switch (carrier_status(state->interface->name)) { 1738 case -1: 1739 logger(LOG_ERR, "carrier_status: %s", strerror(errno)); 1740 return -1; 1741 case 0: 1742 if (state->carrier != LINK_DOWN) { 1743 logger(LOG_INFO, "carrier lost"); 1744 state->carrier = LINK_DOWN; 1745 do_socket(state, SOCKET_CLOSED); 1746 timerclear(&state->timeout); 1747 if (state->state != STATE_BOUND) 1748 timerclear(&state->stop); 1749 } 1750 break; 1751 default: 1752 if (state->carrier != LINK_UP) { 1753 logger(LOG_INFO, "carrier acquired"); 1754 state->state = STATE_RENEW_REQUESTED; 1755 state->carrier = LINK_UP; 1756 timerclear(&state->timeout); 1757 timerclear(&state->stop); 1758 return 1; 1759 } 1760 break; 1761 } 1762 return 0; 1763 } 1764 1765 int 1766 dhcp_run(const struct options *options, int *pid_fd) 1767 { 1768 struct interface *iface; 1769 struct if_state *state = NULL; 1770 int fd = -1, r = 0, sig; 1771 1772 iface = read_interface(options->interface, options->metric); 1773 if (!iface) { 1774 logger(LOG_ERR, "read_interface: %s", strerror(errno)); 1775 goto eexit; 1776 } 1777 logger(LOG_DEBUG, "hardware address = %s", 1778 hwaddr_ntoa(iface->hwaddr, iface->hwlen)); 1779 state = xzalloc(sizeof(*state)); 1780 state->pid_fd = pid_fd; 1781 state->interface = iface; 1782 if (!(options->options & DHCPCD_TEST)) 1783 run_script(options, iface->name, "PREINIT", NULL, NULL); 1784 1785 if (client_setup(state, options) == -1) 1786 goto eexit; 1787 if (signal_init() == -1) 1788 goto eexit; 1789 if (signal_setup() == -1) 1790 goto eexit; 1791 state->signal_fd = signal_fd(); 1792 1793 if (state->options & DHCPCD_BACKGROUND && 1794 !(state->options & DHCPCD_DAEMONISED)) 1795 if (daemonise(state, options) == -1) 1796 goto eexit; 1797 1798 if (state->carrier == LINK_DOWN) 1799 logger(LOG_INFO, "waiting for carrier"); 1800 1801 for (;;) { 1802 if (r == 0) 1803 r = handle_timeout(state, options); 1804 else if (r > 0) { 1805 if (fd == state->signal_fd) { 1806 if ((sig = signal_read()) != -1) 1807 r = handle_signal(sig, state, options); 1808 } else if (fd == iface->link_fd) 1809 r = handle_link(state); 1810 else if (fd == iface->raw_fd) 1811 r = handle_dhcp_packet(state, options); 1812 else if (fd == iface->arp_fd) { 1813 if ((r = handle_arp_packet(state)) == -1) 1814 r = handle_arp_fail(state, options); 1815 } else 1816 r = 0; 1817 } 1818 if (r == -1) 1819 break; 1820 if (r == 0) { 1821 fd = -1; 1822 r = wait_for_fd(state, &fd); 1823 if (r == -1 && errno == EINTR) { 1824 r = 1; 1825 fd = state->signal_fd; 1826 } 1827 } else 1828 r = 0; 1829 } 1830 1831 eexit: 1832 if (iface) { 1833 do_socket(state, SOCKET_CLOSED); 1834 if (iface->link_fd != -1) 1835 close(iface->link_fd); 1836 free_routes(iface->routes); 1837 free(iface->clientid); 1838 free(iface->buffer); 1839 free(iface); 1840 } 1841 1842 if (state) { 1843 if (state->options & DHCPCD_FORKED) 1844 r = 0; 1845 if (state->options & DHCPCD_DAEMONISED) 1846 unlink(options->pidfile); 1847 free(state->offer); 1848 free(state->new); 1849 free(state->old); 1850 free(state); 1851 } 1852 1853 return r; 1854 } 1855
