1 /* SPDX-License-Identifier: BSD-2-Clause */ 2 /* 3 * dhcpcd - DHCP client daemon 4 * Copyright (c) 2006-2020 Roy Marples <roy@marples.name> 5 * All rights reserved 6 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include <sys/param.h> 30 #include <sys/socket.h> 31 32 #include <arpa/inet.h> 33 #include <net/if.h> 34 #include <net/route.h> 35 #include <netinet/if_ether.h> 36 #include <netinet/in_systm.h> 37 #include <netinet/in.h> 38 #include <netinet/ip.h> 39 #define __FAVOR_BSD /* Nasty glibc hack so we can use BSD semantics for UDP */ 40 #include <netinet/udp.h> 41 #undef __FAVOR_BSD 42 43 #ifdef AF_LINK 44 # include <net/if_dl.h> 45 #endif 46 47 #include <assert.h> 48 #include <ctype.h> 49 #include <errno.h> 50 #include <fcntl.h> 51 #include <inttypes.h> 52 #include <stdbool.h> 53 #include <stddef.h> 54 #include <stdio.h> 55 #include <stdlib.h> 56 #include <string.h> 57 #include <unistd.h> 58 #include <syslog.h> 59 60 #define ELOOP_QUEUE ELOOP_DHCP 61 #include "config.h" 62 #include "arp.h" 63 #include "bpf.h" 64 #include "common.h" 65 #include "dhcp.h" 66 #include "dhcpcd.h" 67 #include "dhcp-common.h" 68 #include "duid.h" 69 #include "eloop.h" 70 #include "if.h" 71 #include "ipv4.h" 72 #include "ipv4ll.h" 73 #include "logerr.h" 74 #include "privsep.h" 75 #include "sa.h" 76 #include "script.h" 77 78 #define DAD "Duplicate address detected" 79 #define DHCP_MIN_LEASE 20 80 81 #define IPV4A ADDRIPV4 | ARRAY 82 #define IPV4R ADDRIPV4 | REQUEST 83 84 /* We should define a maximum for the NAK exponential backoff */ 85 #define NAKOFF_MAX 60 86 87 /* Wait N nanoseconds between sending a RELEASE and dropping the address. 88 * This gives the kernel enough time to actually send it. */ 89 #define RELEASE_DELAY_S 0 90 #define RELEASE_DELAY_NS 10000000 91 92 #ifndef IPDEFTTL 93 #define IPDEFTTL 64 /* RFC1340 */ 94 #endif 95 96 /* Support older systems with different defines */ 97 #if !defined(IP_RECVPKTINFO) && defined(IP_PKTINFO) 98 #define IP_RECVPKTINFO IP_PKTINFO 99 #endif 100 101 /* Assert the correct structure size for on wire */ 102 __CTASSERT(sizeof(struct ip) == 20); 103 __CTASSERT(sizeof(struct udphdr) == 8); 104 __CTASSERT(sizeof(struct bootp) == 300); 105 106 struct dhcp_op { 107 uint8_t value; 108 const char *name; 109 }; 110 111 static const struct dhcp_op dhcp_ops[] = { 112 { DHCP_DISCOVER, "DISCOVER" }, 113 { DHCP_OFFER, "OFFER" }, 114 { DHCP_REQUEST, "REQUEST" }, 115 { DHCP_DECLINE, "DECLINE" }, 116 { DHCP_ACK, "ACK" }, 117 { DHCP_NAK, "NAK" }, 118 { DHCP_RELEASE, "RELEASE" }, 119 { DHCP_INFORM, "INFORM" }, 120 { DHCP_FORCERENEW, "FORCERENEW"}, 121 { 0, NULL } 122 }; 123 124 static const char * const dhcp_params[] = { 125 "ip_address", 126 "subnet_cidr", 127 "network_number", 128 "filename", 129 "server_name", 130 NULL 131 }; 132 133 static int dhcp_openbpf(struct interface *); 134 static void dhcp_start1(void *); 135 #if defined(ARP) && (!defined(KERNEL_RFC5227) || defined(ARPING)) 136 static void dhcp_arp_found(struct arp_state *, const struct arp_msg *); 137 #endif 138 static void dhcp_handledhcp(struct interface *, struct bootp *, size_t, 139 const struct in_addr *); 140 static void dhcp_handleifudp(void *); 141 static int dhcp_initstate(struct interface *); 142 143 void 144 dhcp_printoptions(const struct dhcpcd_ctx *ctx, 145 const struct dhcp_opt *opts, size_t opts_len) 146 { 147 const char * const *p; 148 size_t i, j; 149 const struct dhcp_opt *opt, *opt2; 150 int cols; 151 152 for (p = dhcp_params; *p; p++) 153 printf(" %s\n", *p); 154 155 for (i = 0, opt = ctx->dhcp_opts; i < ctx->dhcp_opts_len; i++, opt++) { 156 for (j = 0, opt2 = opts; j < opts_len; j++, opt2++) 157 if (opt->option == opt2->option) 158 break; 159 if (j == opts_len) { 160 cols = printf("%03d %s", opt->option, opt->var); 161 dhcp_print_option_encoding(opt, cols); 162 } 163 } 164 for (i = 0, opt = opts; i < opts_len; i++, opt++) { 165 cols = printf("%03d %s", opt->option, opt->var); 166 dhcp_print_option_encoding(opt, cols); 167 } 168 } 169 170 static const uint8_t * 171 get_option(struct dhcpcd_ctx *ctx, 172 const struct bootp *bootp, size_t bootp_len, 173 unsigned int opt, size_t *opt_len) 174 { 175 const uint8_t *p, *e; 176 uint8_t l, o, ol, overl, *bp; 177 const uint8_t *op; 178 size_t bl; 179 180 if (bootp == NULL || bootp_len < DHCP_MIN_LEN) { 181 errno = EINVAL; 182 return NULL; 183 } 184 185 /* Check we have the magic cookie */ 186 if (!IS_DHCP(bootp)) { 187 errno = ENOTSUP; 188 return NULL; 189 } 190 191 p = bootp->vend + 4; /* options after the 4 byte cookie */ 192 e = (const uint8_t *)bootp + bootp_len; 193 ol = o = overl = 0; 194 bp = NULL; 195 op = NULL; 196 bl = 0; 197 while (p < e) { 198 o = *p++; 199 switch (o) { 200 case DHO_PAD: 201 /* No length to read */ 202 continue; 203 case DHO_END: 204 if (overl & 1) { 205 /* bit 1 set means parse boot file */ 206 overl = (uint8_t)(overl & ~1); 207 p = bootp->file; 208 e = p + sizeof(bootp->file); 209 } else if (overl & 2) { 210 /* bit 2 set means parse server name */ 211 overl = (uint8_t)(overl & ~2); 212 p = bootp->sname; 213 e = p + sizeof(bootp->sname); 214 } else 215 goto exit; 216 /* No length to read */ 217 continue; 218 } 219 220 /* Check we can read the length */ 221 if (p == e) { 222 errno = EINVAL; 223 return NULL; 224 } 225 l = *p++; 226 227 /* Check we can read the option data, if present */ 228 if (p + l > e) { 229 errno = EINVAL; 230 return NULL; 231 } 232 233 if (o == DHO_OPTSOVERLOADED) { 234 /* Ensure we only get this option once by setting 235 * the last bit as well as the value. 236 * This is valid because only the first two bits 237 * actually mean anything in RFC2132 Section 9.3 */ 238 if (l == 1 && !overl) 239 overl = 0x80 | p[0]; 240 } 241 242 if (o == opt) { 243 if (op) { 244 /* We must concatonate the options. */ 245 if (bl + l > ctx->opt_buffer_len) { 246 size_t pos; 247 uint8_t *nb; 248 249 if (bp) 250 pos = (size_t) 251 (bp - ctx->opt_buffer); 252 else 253 pos = 0; 254 nb = realloc(ctx->opt_buffer, bl + l); 255 if (nb == NULL) 256 return NULL; 257 ctx->opt_buffer = nb; 258 ctx->opt_buffer_len = bl + l; 259 bp = ctx->opt_buffer + pos; 260 } 261 if (bp == NULL) 262 bp = ctx->opt_buffer; 263 memcpy(bp, op, ol); 264 bp += ol; 265 } 266 ol = l; 267 op = p; 268 bl += ol; 269 } 270 p += l; 271 } 272 273 exit: 274 if (opt_len) 275 *opt_len = bl; 276 if (bp) { 277 memcpy(bp, op, ol); 278 return (const uint8_t *)ctx->opt_buffer; 279 } 280 if (op) 281 return op; 282 errno = ENOENT; 283 return NULL; 284 } 285 286 static int 287 get_option_addr(struct dhcpcd_ctx *ctx, 288 struct in_addr *a, const struct bootp *bootp, size_t bootp_len, 289 uint8_t option) 290 { 291 const uint8_t *p; 292 size_t len; 293 294 p = get_option(ctx, bootp, bootp_len, option, &len); 295 if (!p || len < (ssize_t)sizeof(a->s_addr)) 296 return -1; 297 memcpy(&a->s_addr, p, sizeof(a->s_addr)); 298 return 0; 299 } 300 301 static int 302 get_option_uint32(struct dhcpcd_ctx *ctx, 303 uint32_t *i, const struct bootp *bootp, size_t bootp_len, uint8_t option) 304 { 305 const uint8_t *p; 306 size_t len; 307 uint32_t d; 308 309 p = get_option(ctx, bootp, bootp_len, option, &len); 310 if (!p || len < (ssize_t)sizeof(d)) 311 return -1; 312 memcpy(&d, p, sizeof(d)); 313 if (i) 314 *i = ntohl(d); 315 return 0; 316 } 317 318 static int 319 get_option_uint16(struct dhcpcd_ctx *ctx, 320 uint16_t *i, const struct bootp *bootp, size_t bootp_len, uint8_t option) 321 { 322 const uint8_t *p; 323 size_t len; 324 uint16_t d; 325 326 p = get_option(ctx, bootp, bootp_len, option, &len); 327 if (!p || len < (ssize_t)sizeof(d)) 328 return -1; 329 memcpy(&d, p, sizeof(d)); 330 if (i) 331 *i = ntohs(d); 332 return 0; 333 } 334 335 static int 336 get_option_uint8(struct dhcpcd_ctx *ctx, 337 uint8_t *i, const struct bootp *bootp, size_t bootp_len, uint8_t option) 338 { 339 const uint8_t *p; 340 size_t len; 341 342 p = get_option(ctx, bootp, bootp_len, option, &len); 343 if (!p || len < (ssize_t)sizeof(*p)) 344 return -1; 345 if (i) 346 *i = *(p); 347 return 0; 348 } 349 350 ssize_t 351 print_rfc3442(FILE *fp, const uint8_t *data, size_t data_len) 352 { 353 const uint8_t *p = data, *e; 354 size_t ocets; 355 uint8_t cidr; 356 struct in_addr addr; 357 358 /* Minimum is 5 -first is CIDR and a router length of 4 */ 359 if (data_len < 5) { 360 errno = EINVAL; 361 return -1; 362 } 363 364 e = p + data_len; 365 while (p < e) { 366 if (p != data) { 367 if (fputc(' ', fp) == EOF) 368 return -1; 369 } 370 cidr = *p++; 371 if (cidr > 32) { 372 errno = EINVAL; 373 return -1; 374 } 375 ocets = (size_t)(cidr + 7) / NBBY; 376 if (p + 4 + ocets > e) { 377 errno = ERANGE; 378 return -1; 379 } 380 /* If we have ocets then we have a destination and netmask */ 381 addr.s_addr = 0; 382 if (ocets > 0) { 383 memcpy(&addr.s_addr, p, ocets); 384 p += ocets; 385 } 386 if (fprintf(fp, "%s/%d", inet_ntoa(addr), cidr) == -1) 387 return -1; 388 389 /* Finally, snag the router */ 390 memcpy(&addr.s_addr, p, 4); 391 p += 4; 392 if (fprintf(fp, " %s", inet_ntoa(addr)) == -1) 393 return -1; 394 } 395 396 if (fputc('\0', fp) == EOF) 397 return -1; 398 return 1; 399 } 400 401 static int 402 decode_rfc3442_rt(rb_tree_t *routes, struct interface *ifp, 403 const uint8_t *data, size_t dl, const struct bootp *bootp) 404 { 405 const uint8_t *p = data; 406 const uint8_t *e; 407 uint8_t cidr; 408 size_t ocets; 409 struct rt *rt = NULL; 410 struct in_addr dest, netmask, gateway; 411 int n; 412 413 /* Minimum is 5 -first is CIDR and a router length of 4 */ 414 if (dl < 5) { 415 errno = EINVAL; 416 return -1; 417 } 418 419 n = 0; 420 e = p + dl; 421 while (p < e) { 422 cidr = *p++; 423 if (cidr > 32) { 424 errno = EINVAL; 425 return -1; 426 } 427 428 ocets = (size_t)(cidr + 7) / NBBY; 429 if (p + 4 + ocets > e) { 430 errno = ERANGE; 431 return -1; 432 } 433 434 if ((rt = rt_new(ifp)) == NULL) 435 return -1; 436 437 /* If we have ocets then we have a destination and netmask */ 438 dest.s_addr = 0; 439 if (ocets > 0) { 440 memcpy(&dest.s_addr, p, ocets); 441 p += ocets; 442 netmask.s_addr = htonl(~0U << (32 - cidr)); 443 } else 444 netmask.s_addr = 0; 445 446 /* Finally, snag the router */ 447 memcpy(&gateway.s_addr, p, 4); 448 p += 4; 449 450 /* An on-link host route is normally set by having the 451 * gateway match the destination or assigned address */ 452 if (gateway.s_addr == dest.s_addr || 453 (gateway.s_addr == bootp->yiaddr || 454 gateway.s_addr == bootp->ciaddr)) 455 { 456 gateway.s_addr = INADDR_ANY; 457 netmask.s_addr = INADDR_BROADCAST; 458 } 459 if (netmask.s_addr == INADDR_BROADCAST) 460 rt->rt_flags = RTF_HOST; 461 462 sa_in_init(&rt->rt_dest, &dest); 463 sa_in_init(&rt->rt_netmask, &netmask); 464 sa_in_init(&rt->rt_gateway, &gateway); 465 if (rt_proto_add(routes, rt)) 466 n = 1; 467 } 468 return n; 469 } 470 471 ssize_t 472 print_rfc3361(FILE *fp, const uint8_t *data, size_t dl) 473 { 474 uint8_t enc; 475 char sip[NS_MAXDNAME]; 476 struct in_addr addr; 477 478 if (dl < 2) { 479 errno = EINVAL; 480 return 0; 481 } 482 483 enc = *data++; 484 dl--; 485 switch (enc) { 486 case 0: 487 if (decode_rfc1035(sip, sizeof(sip), data, dl) == -1) 488 return -1; 489 if (efprintf(fp, "%s", sip) == -1) 490 return -1; 491 break; 492 case 1: 493 if (dl % 4 != 0) { 494 errno = EINVAL; 495 break; 496 } 497 addr.s_addr = INADDR_BROADCAST; 498 for (; 499 dl != 0; 500 data += sizeof(addr.s_addr), dl -= sizeof(addr.s_addr)) 501 { 502 memcpy(&addr.s_addr, data, sizeof(addr.s_addr)); 503 if (fprintf(fp, "%s", inet_ntoa(addr)) == -1) 504 return -1; 505 if (dl != sizeof(addr.s_addr)) { 506 if (fputc(' ', fp) == EOF) 507 return -1; 508 } 509 } 510 if (fputc('\0', fp) == EOF) 511 return -1; 512 break; 513 default: 514 errno = EINVAL; 515 return 0; 516 } 517 518 return 1; 519 } 520 521 static char * 522 get_option_string(struct dhcpcd_ctx *ctx, 523 const struct bootp *bootp, size_t bootp_len, uint8_t option) 524 { 525 size_t len; 526 const uint8_t *p; 527 char *s; 528 529 p = get_option(ctx, bootp, bootp_len, option, &len); 530 if (!p || len == 0 || *p == '\0') 531 return NULL; 532 533 s = malloc(sizeof(char) * (len + 1)); 534 if (s) { 535 memcpy(s, p, len); 536 s[len] = '\0'; 537 } 538 return s; 539 } 540 541 /* This calculates the netmask that we should use for static routes. 542 * This IS different from the calculation used to calculate the netmask 543 * for an interface address. */ 544 static uint32_t 545 route_netmask(uint32_t ip_in) 546 { 547 /* used to be unsigned long - check if error */ 548 uint32_t p = ntohl(ip_in); 549 uint32_t t; 550 551 if (IN_CLASSA(p)) 552 t = ~IN_CLASSA_NET; 553 else { 554 if (IN_CLASSB(p)) 555 t = ~IN_CLASSB_NET; 556 else { 557 if (IN_CLASSC(p)) 558 t = ~IN_CLASSC_NET; 559 else 560 t = 0; 561 } 562 } 563 564 while (t & p) 565 t >>= 1; 566 567 return (htonl(~t)); 568 } 569 570 /* We need to obey routing options. 571 * If we have a CSR then we only use that. 572 * Otherwise we add static routes and then routers. */ 573 static int 574 get_option_routes(rb_tree_t *routes, struct interface *ifp, 575 const struct bootp *bootp, size_t bootp_len) 576 { 577 struct if_options *ifo = ifp->options; 578 const uint8_t *p; 579 const uint8_t *e; 580 struct rt *rt = NULL; 581 struct in_addr dest, netmask, gateway; 582 size_t len; 583 const char *csr = ""; 584 int n; 585 586 /* If we have CSR's then we MUST use these only */ 587 if (!has_option_mask(ifo->nomask, DHO_CSR)) 588 p = get_option(ifp->ctx, bootp, bootp_len, DHO_CSR, &len); 589 else 590 p = NULL; 591 /* Check for crappy MS option */ 592 if (!p && !has_option_mask(ifo->nomask, DHO_MSCSR)) { 593 p = get_option(ifp->ctx, bootp, bootp_len, DHO_MSCSR, &len); 594 if (p) 595 csr = "MS "; 596 } 597 if (p && (n = decode_rfc3442_rt(routes, ifp, p, len, bootp)) != -1) { 598 const struct dhcp_state *state; 599 600 state = D_CSTATE(ifp); 601 if (!(ifo->options & DHCPCD_CSR_WARNED) && 602 !(state->added & STATE_FAKE)) 603 { 604 logdebugx("%s: using %sClassless Static Routes", 605 ifp->name, csr); 606 ifo->options |= DHCPCD_CSR_WARNED; 607 } 608 return n; 609 } 610 611 n = 0; 612 /* OK, get our static routes first. */ 613 if (!has_option_mask(ifo->nomask, DHO_STATICROUTE)) 614 p = get_option(ifp->ctx, bootp, bootp_len, 615 DHO_STATICROUTE, &len); 616 else 617 p = NULL; 618 /* RFC 2131 Section 5.8 states length MUST be in multiples of 8 */ 619 if (p && len % 8 == 0) { 620 e = p + len; 621 while (p < e) { 622 memcpy(&dest.s_addr, p, sizeof(dest.s_addr)); 623 p += 4; 624 memcpy(&gateway.s_addr, p, sizeof(gateway.s_addr)); 625 p += 4; 626 /* RFC 2131 Section 5.8 states default route is 627 * illegal */ 628 if (gateway.s_addr == INADDR_ANY) 629 continue; 630 if ((rt = rt_new(ifp)) == NULL) 631 return -1; 632 633 /* A on-link host route is normally set by having the 634 * gateway match the destination or assigned address */ 635 if (gateway.s_addr == dest.s_addr || 636 (gateway.s_addr == bootp->yiaddr || 637 gateway.s_addr == bootp->ciaddr)) 638 { 639 gateway.s_addr = INADDR_ANY; 640 netmask.s_addr = INADDR_BROADCAST; 641 } else 642 netmask.s_addr = route_netmask(dest.s_addr); 643 if (netmask.s_addr == INADDR_BROADCAST) 644 rt->rt_flags = RTF_HOST; 645 646 sa_in_init(&rt->rt_dest, &dest); 647 sa_in_init(&rt->rt_netmask, &netmask); 648 sa_in_init(&rt->rt_gateway, &gateway); 649 if (rt_proto_add(routes, rt)) 650 n++; 651 } 652 } 653 654 /* Now grab our routers */ 655 if (!has_option_mask(ifo->nomask, DHO_ROUTER)) 656 p = get_option(ifp->ctx, bootp, bootp_len, DHO_ROUTER, &len); 657 else 658 p = NULL; 659 if (p && len % 4 == 0) { 660 e = p + len; 661 dest.s_addr = INADDR_ANY; 662 netmask.s_addr = INADDR_ANY; 663 while (p < e) { 664 if ((rt = rt_new(ifp)) == NULL) 665 return -1; 666 memcpy(&gateway.s_addr, p, sizeof(gateway.s_addr)); 667 p += 4; 668 sa_in_init(&rt->rt_dest, &dest); 669 sa_in_init(&rt->rt_netmask, &netmask); 670 sa_in_init(&rt->rt_gateway, &gateway); 671 if (rt_proto_add(routes, rt)) 672 n++; 673 } 674 } 675 676 return n; 677 } 678 679 uint16_t 680 dhcp_get_mtu(const struct interface *ifp) 681 { 682 const struct dhcp_state *state; 683 uint16_t mtu; 684 685 if (ifp->options->mtu) 686 return (uint16_t)ifp->options->mtu; 687 mtu = 0; /* bogus gcc warning */ 688 if ((state = D_CSTATE(ifp)) == NULL || 689 has_option_mask(ifp->options->nomask, DHO_MTU) || 690 get_option_uint16(ifp->ctx, &mtu, 691 state->new, state->new_len, DHO_MTU) == -1) 692 return 0; 693 return mtu; 694 } 695 696 /* Grab our routers from the DHCP message and apply any MTU value 697 * the message contains */ 698 int 699 dhcp_get_routes(rb_tree_t *routes, struct interface *ifp) 700 { 701 const struct dhcp_state *state; 702 703 if ((state = D_CSTATE(ifp)) == NULL || !(state->added & STATE_ADDED)) 704 return 0; 705 return get_option_routes(routes, ifp, state->new, state->new_len); 706 } 707 708 /* Assumes DHCP options */ 709 static int 710 dhcp_message_add_addr(struct bootp *bootp, 711 uint8_t type, struct in_addr addr) 712 { 713 uint8_t *p; 714 size_t len; 715 716 p = bootp->vend; 717 while (*p != DHO_END) { 718 p++; 719 p += *p + 1; 720 } 721 722 len = (size_t)(p - bootp->vend); 723 if (len + 6 > sizeof(bootp->vend)) { 724 errno = ENOMEM; 725 return -1; 726 } 727 728 *p++ = type; 729 *p++ = 4; 730 memcpy(p, &addr.s_addr, 4); 731 p += 4; 732 *p = DHO_END; 733 return 0; 734 } 735 736 static ssize_t 737 make_message(struct bootp **bootpm, const struct interface *ifp, uint8_t type) 738 { 739 struct bootp *bootp; 740 uint8_t *lp, *p, *e; 741 uint8_t *n_params = NULL; 742 uint32_t ul; 743 uint16_t sz; 744 size_t len, i; 745 const struct dhcp_opt *opt; 746 struct if_options *ifo = ifp->options; 747 const struct dhcp_state *state = D_CSTATE(ifp); 748 const struct dhcp_lease *lease = &state->lease; 749 char hbuf[HOSTNAME_MAX_LEN + 1]; 750 const char *hostname; 751 const struct vivco *vivco; 752 int mtu; 753 #ifdef AUTH 754 uint8_t *auth, auth_len; 755 #endif 756 757 if ((mtu = if_getmtu(ifp)) == -1) 758 logerr("%s: if_getmtu", ifp->name); 759 else if (mtu < MTU_MIN) { 760 if (if_setmtu(ifp, MTU_MIN) == -1) 761 logerr("%s: if_setmtu", ifp->name); 762 mtu = MTU_MIN; 763 } 764 765 if (ifo->options & DHCPCD_BOOTP) 766 bootp = calloc(1, sizeof (*bootp)); 767 else 768 /* Make the maximal message we could send */ 769 bootp = calloc(1, (size_t)(mtu - IP_UDP_SIZE)); 770 771 if (bootp == NULL) 772 return -1; 773 *bootpm = bootp; 774 775 if (state->addr != NULL && 776 (type == DHCP_INFORM || type == DHCP_RELEASE || 777 (type == DHCP_REQUEST && 778 state->addr->mask.s_addr == lease->mask.s_addr && 779 (state->new == NULL || IS_DHCP(state->new)) && 780 !(state->added & (STATE_FAKE | STATE_EXPIRED))))) 781 bootp->ciaddr = state->addr->addr.s_addr; 782 783 bootp->op = BOOTREQUEST; 784 bootp->htype = (uint8_t)ifp->hwtype; 785 if (ifp->hwlen != 0 && ifp->hwlen < sizeof(bootp->chaddr)) { 786 bootp->hlen = (uint8_t)ifp->hwlen; 787 memcpy(&bootp->chaddr, &ifp->hwaddr, ifp->hwlen); 788 } 789 790 if (ifo->options & DHCPCD_BROADCAST && 791 bootp->ciaddr == 0 && 792 type != DHCP_DECLINE && 793 type != DHCP_RELEASE) 794 bootp->flags = htons(BROADCAST_FLAG); 795 796 if (type != DHCP_DECLINE && type != DHCP_RELEASE) { 797 struct timespec tv; 798 unsigned long long secs; 799 800 clock_gettime(CLOCK_MONOTONIC, &tv); 801 secs = eloop_timespec_diff(&tv, &state->started, NULL); 802 if (secs > UINT16_MAX) 803 bootp->secs = htons((uint16_t)UINT16_MAX); 804 else 805 bootp->secs = htons((uint16_t)secs); 806 } 807 808 bootp->xid = htonl(state->xid); 809 810 if (ifo->options & DHCPCD_BOOTP) 811 return sizeof(*bootp); 812 813 p = bootp->vend; 814 e = (uint8_t *)bootp + (mtu - IP_UDP_SIZE) - 1; /* -1 for DHO_END */ 815 816 ul = htonl(MAGIC_COOKIE); 817 memcpy(p, &ul, sizeof(ul)); 818 p += sizeof(ul); 819 820 #define AREA_LEFT (size_t)(e - p) 821 #define AREA_FIT(s) if ((s) > AREA_LEFT) goto toobig 822 #define AREA_CHECK(s) if ((s) + 2UL > AREA_LEFT) goto toobig 823 #define PUT_ADDR(o, a) do { \ 824 AREA_CHECK(4); \ 825 *p++ = (o); \ 826 *p++ = 4; \ 827 memcpy(p, &(a)->s_addr, 4); \ 828 p += 4; \ 829 } while (0 /* CONSTCOND */) 830 831 /* Options are listed in numerical order as per RFC 7844 Section 3.1 832 * XXX: They should be randomised. */ 833 834 bool putip = false; 835 if (lease->addr.s_addr && lease->cookie == htonl(MAGIC_COOKIE)) { 836 if (type == DHCP_DECLINE || 837 (type == DHCP_REQUEST && 838 (state->addr == NULL || 839 state->added & (STATE_FAKE | STATE_EXPIRED) || 840 lease->addr.s_addr != state->addr->addr.s_addr))) 841 { 842 putip = true; 843 PUT_ADDR(DHO_IPADDRESS, &lease->addr); 844 } 845 } 846 847 AREA_CHECK(3); 848 *p++ = DHO_MESSAGETYPE; 849 *p++ = 1; 850 *p++ = type; 851 852 if (lease->addr.s_addr && lease->cookie == htonl(MAGIC_COOKIE)) { 853 if (type == DHCP_RELEASE || putip) { 854 if (lease->server.s_addr) 855 PUT_ADDR(DHO_SERVERID, &lease->server); 856 } 857 } 858 859 if (type == DHCP_DECLINE) { 860 len = strlen(DAD); 861 if (len > AREA_LEFT) { 862 *p++ = DHO_MESSAGE; 863 *p++ = (uint8_t)len; 864 memcpy(p, DAD, len); 865 p += len; 866 } 867 } 868 869 #define DHCP_DIR(type) ((type) == DHCP_DISCOVER || (type) == DHCP_INFORM || \ 870 (type) == DHCP_REQUEST) 871 872 if (DHCP_DIR(type)) { 873 /* vendor is already encoded correctly, so just add it */ 874 if (ifo->vendor[0]) { 875 AREA_CHECK(ifo->vendor[0]); 876 *p++ = DHO_VENDOR; 877 memcpy(p, ifo->vendor, (size_t)ifo->vendor[0] + 1); 878 p += ifo->vendor[0] + 1; 879 } 880 } 881 882 if (type == DHCP_DISCOVER && ifo->options & DHCPCD_REQUEST) 883 PUT_ADDR(DHO_IPADDRESS, &ifo->req_addr); 884 885 if (DHCP_DIR(type)) { 886 if (type != DHCP_INFORM) { 887 if (ifo->leasetime != 0) { 888 AREA_CHECK(4); 889 *p++ = DHO_LEASETIME; 890 *p++ = 4; 891 ul = htonl(ifo->leasetime); 892 memcpy(p, &ul, 4); 893 p += 4; 894 } 895 } 896 897 AREA_CHECK(0); 898 *p++ = DHO_PARAMETERREQUESTLIST; 899 n_params = p; 900 *p++ = 0; 901 for (i = 0, opt = ifp->ctx->dhcp_opts; 902 i < ifp->ctx->dhcp_opts_len; 903 i++, opt++) 904 { 905 if (!DHC_REQOPT(opt, ifo->requestmask, ifo->nomask)) 906 continue; 907 if (type == DHCP_INFORM && 908 (opt->option == DHO_RENEWALTIME || 909 opt->option == DHO_REBINDTIME)) 910 continue; 911 AREA_FIT(1); 912 *p++ = (uint8_t)opt->option; 913 } 914 for (i = 0, opt = ifo->dhcp_override; 915 i < ifo->dhcp_override_len; 916 i++, opt++) 917 { 918 /* Check if added above */ 919 for (lp = n_params + 1; lp < p; lp++) 920 if (*lp == (uint8_t)opt->option) 921 break; 922 if (lp < p) 923 continue; 924 if (!DHC_REQOPT(opt, ifo->requestmask, ifo->nomask)) 925 continue; 926 if (type == DHCP_INFORM && 927 (opt->option == DHO_RENEWALTIME || 928 opt->option == DHO_REBINDTIME)) 929 continue; 930 AREA_FIT(1); 931 *p++ = (uint8_t)opt->option; 932 } 933 *n_params = (uint8_t)(p - n_params - 1); 934 935 if (mtu != -1 && 936 !(has_option_mask(ifo->nomask, DHO_MAXMESSAGESIZE))) 937 { 938 AREA_CHECK(2); 939 *p++ = DHO_MAXMESSAGESIZE; 940 *p++ = 2; 941 sz = htons((uint16_t)(mtu - IP_UDP_SIZE)); 942 memcpy(p, &sz, 2); 943 p += 2; 944 } 945 946 if (ifo->userclass[0] && 947 !has_option_mask(ifo->nomask, DHO_USERCLASS)) 948 { 949 AREA_CHECK(ifo->userclass[0]); 950 *p++ = DHO_USERCLASS; 951 memcpy(p, ifo->userclass, 952 (size_t)ifo->userclass[0] + 1); 953 p += ifo->userclass[0] + 1; 954 } 955 } 956 957 if (state->clientid) { 958 AREA_CHECK(state->clientid[0]); 959 *p++ = DHO_CLIENTID; 960 memcpy(p, state->clientid, (size_t)state->clientid[0] + 1); 961 p += state->clientid[0] + 1; 962 } 963 964 if (DHCP_DIR(type) && 965 !has_option_mask(ifo->nomask, DHO_VENDORCLASSID) && 966 ifo->vendorclassid[0]) 967 { 968 AREA_CHECK(ifo->vendorclassid[0]); 969 *p++ = DHO_VENDORCLASSID; 970 memcpy(p, ifo->vendorclassid, (size_t)ifo->vendorclassid[0]+1); 971 p += ifo->vendorclassid[0] + 1; 972 } 973 974 if (type == DHCP_DISCOVER && 975 !(ifp->ctx->options & DHCPCD_TEST) && 976 DHC_REQ(ifo->requestmask, ifo->nomask, DHO_RAPIDCOMMIT)) 977 { 978 /* RFC 4039 Section 3 */ 979 AREA_CHECK(0); 980 *p++ = DHO_RAPIDCOMMIT; 981 *p++ = 0; 982 } 983 984 if (DHCP_DIR(type)) { 985 hostname = dhcp_get_hostname(hbuf, sizeof(hbuf), ifo); 986 987 /* 988 * RFC4702 3.1 States that if we send the Client FQDN option 989 * then we MUST NOT also send the Host Name option. 990 * Technically we could, but that is not RFC conformant and 991 * also seems to break some DHCP server implemetations such as 992 * Windows. On the other hand, ISC dhcpd is just as non RFC 993 * conformant by not accepting a partially qualified FQDN. 994 */ 995 if (ifo->fqdn != FQDN_DISABLE) { 996 /* IETF DHC-FQDN option (81), RFC4702 */ 997 i = 3; 998 if (hostname) 999 i += encode_rfc1035(hostname, NULL); 1000 AREA_CHECK(i); 1001 *p++ = DHO_FQDN; 1002 *p++ = (uint8_t)i; 1003 /* 1004 * Flags: 0000NEOS 1005 * S: 1 => Client requests Server to update 1006 * a RR in DNS as well as PTR 1007 * O: 1 => Server indicates to client that 1008 * DNS has been updated 1009 * E: 1 => Name data is DNS format 1010 * N: 1 => Client requests Server to not 1011 * update DNS 1012 */ 1013 if (hostname) 1014 *p++ = (uint8_t)((ifo->fqdn & 0x09) | 0x04); 1015 else 1016 *p++ = (FQDN_NONE & 0x09) | 0x04; 1017 *p++ = 0; /* from server for PTR RR */ 1018 *p++ = 0; /* from server for A RR if S=1 */ 1019 if (hostname) { 1020 i = encode_rfc1035(hostname, p); 1021 p += i; 1022 } 1023 } else if (ifo->options & DHCPCD_HOSTNAME && hostname) { 1024 len = strlen(hostname); 1025 AREA_CHECK(len); 1026 *p++ = DHO_HOSTNAME; 1027 *p++ = (uint8_t)len; 1028 memcpy(p, hostname, len); 1029 p += len; 1030 } 1031 } 1032 1033 #ifdef AUTH 1034 auth = NULL; /* appease GCC */ 1035 auth_len = 0; 1036 if (ifo->auth.options & DHCPCD_AUTH_SEND) { 1037 ssize_t alen = dhcp_auth_encode(ifp->ctx, &ifo->auth, 1038 state->auth.token, 1039 NULL, 0, 4, type, NULL, 0); 1040 if (alen != -1 && alen > UINT8_MAX) { 1041 errno = ERANGE; 1042 alen = -1; 1043 } 1044 if (alen == -1) 1045 logerr("%s: dhcp_auth_encode", ifp->name); 1046 else if (alen != 0) { 1047 auth_len = (uint8_t)alen; 1048 AREA_CHECK(auth_len); 1049 *p++ = DHO_AUTHENTICATION; 1050 *p++ = auth_len; 1051 auth = p; 1052 p += auth_len; 1053 } 1054 } 1055 #endif 1056 1057 /* RFC 2563 Auto Configure */ 1058 if (type == DHCP_DISCOVER && ifo->options & DHCPCD_IPV4LL && 1059 !(has_option_mask(ifo->nomask, DHO_AUTOCONFIGURE))) 1060 { 1061 AREA_CHECK(1); 1062 *p++ = DHO_AUTOCONFIGURE; 1063 *p++ = 1; 1064 *p++ = 1; 1065 } 1066 1067 if (DHCP_DIR(type)) { 1068 if (ifo->mudurl[0]) { 1069 AREA_CHECK(ifo->mudurl[0]); 1070 *p++ = DHO_MUDURL; 1071 memcpy(p, ifo->mudurl, (size_t)ifo->mudurl[0] + 1); 1072 p += ifo->mudurl[0] + 1; 1073 } 1074 1075 if (ifo->vivco_len && 1076 !has_option_mask(ifo->nomask, DHO_VIVCO)) 1077 { 1078 AREA_CHECK(sizeof(ul)); 1079 *p++ = DHO_VIVCO; 1080 lp = p++; 1081 *lp = sizeof(ul); 1082 ul = htonl(ifo->vivco_en); 1083 memcpy(p, &ul, sizeof(ul)); 1084 p += sizeof(ul); 1085 for (i = 0, vivco = ifo->vivco; 1086 i < ifo->vivco_len; 1087 i++, vivco++) 1088 { 1089 AREA_FIT(vivco->len); 1090 if (vivco->len + 2 + *lp > 255) { 1091 logerrx("%s: VIVCO option too big", 1092 ifp->name); 1093 free(bootp); 1094 return -1; 1095 } 1096 *p++ = (uint8_t)vivco->len; 1097 memcpy(p, vivco->data, vivco->len); 1098 p += vivco->len; 1099 *lp = (uint8_t)(*lp + vivco->len + 1); 1100 } 1101 } 1102 1103 #ifdef AUTH 1104 if ((ifo->auth.options & DHCPCD_AUTH_SENDREQUIRE) != 1105 DHCPCD_AUTH_SENDREQUIRE && 1106 !has_option_mask(ifo->nomask, DHO_FORCERENEW_NONCE)) 1107 { 1108 /* We support HMAC-MD5 */ 1109 AREA_CHECK(1); 1110 *p++ = DHO_FORCERENEW_NONCE; 1111 *p++ = 1; 1112 *p++ = AUTH_ALG_HMAC_MD5; 1113 } 1114 #endif 1115 } 1116 1117 *p++ = DHO_END; 1118 len = (size_t)(p - (uint8_t *)bootp); 1119 1120 /* Pad out to the BOOTP message length. 1121 * Even if we send a DHCP packet with a variable length vendor area, 1122 * some servers / relay agents don't like packets smaller than 1123 * a BOOTP message which is fine because that's stipulated 1124 * in RFC1542 section 2.1. */ 1125 while (len < sizeof(*bootp)) { 1126 *p++ = DHO_PAD; 1127 len++; 1128 } 1129 1130 #ifdef AUTH 1131 if (ifo->auth.options & DHCPCD_AUTH_SEND && auth_len != 0) 1132 dhcp_auth_encode(ifp->ctx, &ifo->auth, state->auth.token, 1133 (uint8_t *)bootp, len, 4, type, auth, auth_len); 1134 #endif 1135 1136 return (ssize_t)len; 1137 1138 toobig: 1139 logerrx("%s: DHCP message too big", ifp->name); 1140 free(bootp); 1141 return -1; 1142 } 1143 1144 static size_t 1145 read_lease(struct interface *ifp, struct bootp **bootp) 1146 { 1147 union { 1148 struct bootp bootp; 1149 uint8_t buf[FRAMELEN_MAX]; 1150 } buf; 1151 struct dhcp_state *state = D_STATE(ifp); 1152 ssize_t sbytes; 1153 size_t bytes; 1154 uint8_t type; 1155 #ifdef AUTH 1156 const uint8_t *auth; 1157 size_t auth_len; 1158 #endif 1159 1160 /* Safety */ 1161 *bootp = NULL; 1162 1163 if (state->leasefile[0] == '\0') { 1164 logdebugx("reading standard input"); 1165 sbytes = read(fileno(stdin), buf.buf, sizeof(buf.buf)); 1166 } else { 1167 logdebugx("%s: reading lease: %s", 1168 ifp->name, state->leasefile); 1169 sbytes = dhcp_readfile(ifp->ctx, state->leasefile, 1170 buf.buf, sizeof(buf.buf)); 1171 } 1172 if (sbytes == -1) { 1173 if (errno != ENOENT) 1174 logerr("%s: %s", ifp->name, state->leasefile); 1175 return 0; 1176 } 1177 bytes = (size_t)sbytes; 1178 1179 /* Ensure the packet is at lease BOOTP sized 1180 * with a vendor area of 4 octets 1181 * (it should be more, and our read packet enforces this so this 1182 * code should not be needed, but of course people could 1183 * scribble whatever in the stored lease file. */ 1184 if (bytes < DHCP_MIN_LEN) { 1185 logerrx("%s: %s: truncated lease", ifp->name, __func__); 1186 return 0; 1187 } 1188 1189 if (ifp->ctx->options & DHCPCD_DUMPLEASE) 1190 goto out; 1191 1192 /* We may have found a BOOTP server */ 1193 if (get_option_uint8(ifp->ctx, &type, &buf.bootp, bytes, 1194 DHO_MESSAGETYPE) == -1) 1195 type = 0; 1196 1197 #ifdef AUTH 1198 /* Authenticate the message */ 1199 auth = get_option(ifp->ctx, &buf.bootp, bytes, 1200 DHO_AUTHENTICATION, &auth_len); 1201 if (auth) { 1202 if (dhcp_auth_validate(&state->auth, &ifp->options->auth, 1203 &buf.bootp, bytes, 4, type, auth, auth_len) == NULL) 1204 { 1205 logerr("%s: authentication failed", ifp->name); 1206 return 0; 1207 } 1208 if (state->auth.token) 1209 logdebugx("%s: validated using 0x%08" PRIu32, 1210 ifp->name, state->auth.token->secretid); 1211 else 1212 logdebugx("%s: accepted reconfigure key", ifp->name); 1213 } else if ((ifp->options->auth.options & DHCPCD_AUTH_SENDREQUIRE) == 1214 DHCPCD_AUTH_SENDREQUIRE) 1215 { 1216 logerrx("%s: authentication now required", ifp->name); 1217 return 0; 1218 } 1219 #endif 1220 1221 out: 1222 *bootp = malloc(bytes); 1223 if (*bootp == NULL) { 1224 logerr(__func__); 1225 return 0; 1226 } 1227 memcpy(*bootp, buf.buf, bytes); 1228 return bytes; 1229 } 1230 1231 static const struct dhcp_opt * 1232 dhcp_getoverride(const struct if_options *ifo, unsigned int o) 1233 { 1234 size_t i; 1235 const struct dhcp_opt *opt; 1236 1237 for (i = 0, opt = ifo->dhcp_override; 1238 i < ifo->dhcp_override_len; 1239 i++, opt++) 1240 { 1241 if (opt->option == o) 1242 return opt; 1243 } 1244 return NULL; 1245 } 1246 1247 static const uint8_t * 1248 dhcp_getoption(struct dhcpcd_ctx *ctx, 1249 size_t *os, unsigned int *code, size_t *len, 1250 const uint8_t *od, size_t ol, struct dhcp_opt **oopt) 1251 { 1252 size_t i; 1253 struct dhcp_opt *opt; 1254 1255 if (od) { 1256 if (ol < 2) { 1257 errno = EINVAL; 1258 return NULL; 1259 } 1260 *os = 2; /* code + len */ 1261 *code = (unsigned int)*od++; 1262 *len = (size_t)*od++; 1263 if (*len > ol - *os) { 1264 errno = ERANGE; 1265 return NULL; 1266 } 1267 } 1268 1269 *oopt = NULL; 1270 for (i = 0, opt = ctx->dhcp_opts; i < ctx->dhcp_opts_len; i++, opt++) { 1271 if (opt->option == *code) { 1272 *oopt = opt; 1273 break; 1274 } 1275 } 1276 1277 return od; 1278 } 1279 1280 ssize_t 1281 dhcp_env(FILE *fenv, const char *prefix, const struct interface *ifp, 1282 const struct bootp *bootp, size_t bootp_len) 1283 { 1284 const struct if_options *ifo; 1285 const uint8_t *p; 1286 struct in_addr addr; 1287 struct in_addr net; 1288 struct in_addr brd; 1289 struct dhcp_opt *opt, *vo; 1290 size_t i, pl; 1291 char safe[(BOOTP_FILE_LEN * 4) + 1]; 1292 uint8_t overl = 0; 1293 uint32_t en; 1294 1295 ifo = ifp->options; 1296 if (get_option_uint8(ifp->ctx, &overl, bootp, bootp_len, 1297 DHO_OPTSOVERLOADED) == -1) 1298 overl = 0; 1299 1300 if (bootp->yiaddr || bootp->ciaddr) { 1301 /* Set some useful variables that we derive from the DHCP 1302 * message but are not necessarily in the options */ 1303 addr.s_addr = bootp->yiaddr ? bootp->yiaddr : bootp->ciaddr; 1304 if (efprintf(fenv, "%s_ip_address=%s", 1305 prefix, inet_ntoa(addr)) == -1) 1306 return -1; 1307 if (get_option_addr(ifp->ctx, &net, 1308 bootp, bootp_len, DHO_SUBNETMASK) == -1) { 1309 net.s_addr = ipv4_getnetmask(addr.s_addr); 1310 if (efprintf(fenv, "%s_subnet_mask=%s", 1311 prefix, inet_ntoa(net)) == -1) 1312 return -1; 1313 } 1314 if (efprintf(fenv, "%s_subnet_cidr=%d", 1315 prefix, inet_ntocidr(net))== -1) 1316 return -1; 1317 if (get_option_addr(ifp->ctx, &brd, 1318 bootp, bootp_len, DHO_BROADCAST) == -1) 1319 { 1320 brd.s_addr = addr.s_addr | ~net.s_addr; 1321 if (efprintf(fenv, "%s_broadcast_address=%s", 1322 prefix, inet_ntoa(brd)) == -1) 1323 return -1; 1324 } 1325 addr.s_addr = bootp->yiaddr & net.s_addr; 1326 if (efprintf(fenv, "%s_network_number=%s", 1327 prefix, inet_ntoa(addr)) == -1) 1328 return -1; 1329 } 1330 1331 if (*bootp->file && !(overl & 1)) { 1332 print_string(safe, sizeof(safe), OT_STRING, 1333 bootp->file, sizeof(bootp->file)); 1334 if (efprintf(fenv, "%s_filename=%s", prefix, safe) == -1) 1335 return -1; 1336 } 1337 if (*bootp->sname && !(overl & 2)) { 1338 print_string(safe, sizeof(safe), OT_STRING | OT_DOMAIN, 1339 bootp->sname, sizeof(bootp->sname)); 1340 if (efprintf(fenv, "%s_server_name=%s", prefix, safe) == -1) 1341 return -1; 1342 } 1343 1344 /* Zero our indexes */ 1345 for (i = 0, opt = ifp->ctx->dhcp_opts; 1346 i < ifp->ctx->dhcp_opts_len; 1347 i++, opt++) 1348 dhcp_zero_index(opt); 1349 for (i = 0, opt = ifp->options->dhcp_override; 1350 i < ifp->options->dhcp_override_len; 1351 i++, opt++) 1352 dhcp_zero_index(opt); 1353 for (i = 0, opt = ifp->ctx->vivso; 1354 i < ifp->ctx->vivso_len; 1355 i++, opt++) 1356 dhcp_zero_index(opt); 1357 1358 for (i = 0, opt = ifp->ctx->dhcp_opts; 1359 i < ifp->ctx->dhcp_opts_len; 1360 i++, opt++) 1361 { 1362 if (has_option_mask(ifo->nomask, opt->option)) 1363 continue; 1364 if (dhcp_getoverride(ifo, opt->option)) 1365 continue; 1366 p = get_option(ifp->ctx, bootp, bootp_len, opt->option, &pl); 1367 if (p == NULL) 1368 continue; 1369 dhcp_envoption(ifp->ctx, fenv, prefix, ifp->name, 1370 opt, dhcp_getoption, p, pl); 1371 1372 if (opt->option != DHO_VIVSO || pl <= (int)sizeof(uint32_t)) 1373 continue; 1374 memcpy(&en, p, sizeof(en)); 1375 en = ntohl(en); 1376 vo = vivso_find(en, ifp); 1377 if (vo == NULL) 1378 continue; 1379 /* Skip over en + total size */ 1380 p += sizeof(en) + 1; 1381 pl -= sizeof(en) + 1; 1382 dhcp_envoption(ifp->ctx, fenv, prefix, ifp->name, 1383 vo, dhcp_getoption, p, pl); 1384 } 1385 1386 for (i = 0, opt = ifo->dhcp_override; 1387 i < ifo->dhcp_override_len; 1388 i++, opt++) 1389 { 1390 if (has_option_mask(ifo->nomask, opt->option)) 1391 continue; 1392 p = get_option(ifp->ctx, bootp, bootp_len, opt->option, &pl); 1393 if (p == NULL) 1394 continue; 1395 dhcp_envoption(ifp->ctx, fenv, prefix, ifp->name, 1396 opt, dhcp_getoption, p, pl); 1397 } 1398 1399 return 1; 1400 } 1401 1402 static void 1403 get_lease(struct interface *ifp, 1404 struct dhcp_lease *lease, const struct bootp *bootp, size_t len) 1405 { 1406 struct dhcpcd_ctx *ctx; 1407 1408 assert(bootp != NULL); 1409 1410 memcpy(&lease->cookie, bootp->vend, sizeof(lease->cookie)); 1411 /* BOOTP does not set yiaddr for replies when ciaddr is set. */ 1412 lease->addr.s_addr = bootp->yiaddr ? bootp->yiaddr : bootp->ciaddr; 1413 ctx = ifp->ctx; 1414 if (ifp->options->options & (DHCPCD_STATIC | DHCPCD_INFORM)) { 1415 if (ifp->options->req_addr.s_addr != INADDR_ANY) { 1416 lease->mask = ifp->options->req_mask; 1417 if (ifp->options->req_brd.s_addr != INADDR_ANY) 1418 lease->brd = ifp->options->req_brd; 1419 else 1420 lease->brd.s_addr = 1421 lease->addr.s_addr | ~lease->mask.s_addr; 1422 } else { 1423 const struct ipv4_addr *ia; 1424 1425 ia = ipv4_iffindaddr(ifp, &lease->addr, NULL); 1426 assert(ia != NULL); 1427 lease->mask = ia->mask; 1428 lease->brd = ia->brd; 1429 } 1430 } else { 1431 if (get_option_addr(ctx, &lease->mask, bootp, len, 1432 DHO_SUBNETMASK) == -1) 1433 lease->mask.s_addr = 1434 ipv4_getnetmask(lease->addr.s_addr); 1435 if (get_option_addr(ctx, &lease->brd, bootp, len, 1436 DHO_BROADCAST) == -1) 1437 lease->brd.s_addr = 1438 lease->addr.s_addr | ~lease->mask.s_addr; 1439 } 1440 if (get_option_uint32(ctx, &lease->leasetime, 1441 bootp, len, DHO_LEASETIME) != 0) 1442 lease->leasetime = DHCP_INFINITE_LIFETIME; 1443 if (get_option_uint32(ctx, &lease->renewaltime, 1444 bootp, len, DHO_RENEWALTIME) != 0) 1445 lease->renewaltime = 0; 1446 if (get_option_uint32(ctx, &lease->rebindtime, 1447 bootp, len, DHO_REBINDTIME) != 0) 1448 lease->rebindtime = 0; 1449 if (get_option_addr(ctx, &lease->server, bootp, len, DHO_SERVERID) != 0) 1450 lease->server.s_addr = INADDR_ANY; 1451 } 1452 1453 static const char * 1454 get_dhcp_op(uint8_t type) 1455 { 1456 const struct dhcp_op *d; 1457 1458 for (d = dhcp_ops; d->name; d++) 1459 if (d->value == type) 1460 return d->name; 1461 return NULL; 1462 } 1463 1464 static void 1465 dhcp_fallback(void *arg) 1466 { 1467 struct interface *iface; 1468 1469 iface = (struct interface *)arg; 1470 dhcpcd_selectprofile(iface, iface->options->fallback); 1471 dhcpcd_startinterface(iface); 1472 } 1473 1474 static void 1475 dhcp_new_xid(struct interface *ifp) 1476 { 1477 struct dhcp_state *state; 1478 const struct interface *ifp1; 1479 const struct dhcp_state *state1; 1480 1481 state = D_STATE(ifp); 1482 if (ifp->options->options & DHCPCD_XID_HWADDR && 1483 ifp->hwlen >= sizeof(state->xid)) 1484 /* The lower bits are probably more unique on the network */ 1485 memcpy(&state->xid, 1486 (ifp->hwaddr + ifp->hwlen) - sizeof(state->xid), 1487 sizeof(state->xid)); 1488 else { 1489 again: 1490 state->xid = arc4random(); 1491 } 1492 1493 /* Ensure it's unique */ 1494 TAILQ_FOREACH(ifp1, ifp->ctx->ifaces, next) { 1495 if (ifp == ifp1) 1496 continue; 1497 if ((state1 = D_CSTATE(ifp1)) == NULL) 1498 continue; 1499 if (state1->xid == state->xid) 1500 break; 1501 } 1502 if (ifp1 != NULL) { 1503 if (ifp->options->options & DHCPCD_XID_HWADDR && 1504 ifp->hwlen >= sizeof(state->xid)) 1505 { 1506 logerrx("%s: duplicate xid on %s", 1507 ifp->name, ifp1->name); 1508 return; 1509 } 1510 goto again; 1511 } 1512 1513 /* We can't do this when sharing leases across interfaes */ 1514 #if 0 1515 /* As the XID changes, re-apply the filter. */ 1516 if (state->bpf_fd != -1) { 1517 if (bpf_bootp(ifp, state->bpf_fd) == -1) 1518 logerr(__func__); /* try to continue */ 1519 } 1520 #endif 1521 } 1522 1523 void 1524 dhcp_close(struct interface *ifp) 1525 { 1526 struct dhcpcd_ctx *ctx = ifp->ctx; 1527 struct dhcp_state *state = D_STATE(ifp); 1528 1529 if (state == NULL) 1530 return; 1531 1532 #ifdef PRIVSEP 1533 if (IN_PRIVSEP_SE(ctx)) { 1534 ps_bpf_closebootp(ifp); 1535 if (state->addr != NULL) 1536 ps_inet_closebootp(state->addr); 1537 } 1538 #endif 1539 1540 if (state->bpf != NULL) { 1541 eloop_event_delete(ctx->eloop, state->bpf->bpf_fd); 1542 bpf_close(state->bpf); 1543 state->bpf = NULL; 1544 } 1545 if (state->udp_rfd != -1) { 1546 eloop_event_delete(ctx->eloop, state->udp_rfd); 1547 close(state->udp_rfd); 1548 state->udp_rfd = -1; 1549 } 1550 1551 state->interval = 0; 1552 } 1553 1554 int 1555 dhcp_openudp(struct in_addr *ia) 1556 { 1557 int s; 1558 struct sockaddr_in sin; 1559 int n; 1560 1561 if ((s = xsocket(PF_INET, SOCK_DGRAM | SOCK_CXNB, IPPROTO_UDP)) == -1) 1562 return -1; 1563 1564 n = 1; 1565 if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &n, sizeof(n)) == -1) 1566 goto errexit; 1567 #ifdef IP_RECVIF 1568 if (setsockopt(s, IPPROTO_IP, IP_RECVIF, &n, sizeof(n)) == -1) 1569 goto errexit; 1570 #else 1571 if (setsockopt(s, IPPROTO_IP, IP_RECVPKTINFO, &n, sizeof(n)) == -1) 1572 goto errexit; 1573 #endif 1574 #ifdef SO_RERROR 1575 if (setsockopt(s, SOL_SOCKET, SO_RERROR, &n, sizeof(n)) == -1) 1576 goto errexit; 1577 #endif 1578 1579 memset(&sin, 0, sizeof(sin)); 1580 sin.sin_family = AF_INET; 1581 sin.sin_port = htons(BOOTPC); 1582 if (ia != NULL) 1583 sin.sin_addr = *ia; 1584 if (bind(s, (struct sockaddr *)&sin, sizeof(sin)) == -1) 1585 goto errexit; 1586 1587 return s; 1588 1589 errexit: 1590 close(s); 1591 return -1; 1592 } 1593 1594 static uint16_t 1595 in_cksum(const void *data, size_t len, uint32_t *isum) 1596 { 1597 const uint16_t *word = data; 1598 uint32_t sum = isum != NULL ? *isum : 0; 1599 1600 for (; len > 1; len -= sizeof(*word)) 1601 sum += *word++; 1602 1603 if (len == 1) 1604 sum += htons((uint16_t)(*(const uint8_t *)word << 8)); 1605 1606 if (isum != NULL) 1607 *isum = sum; 1608 1609 sum = (sum >> 16) + (sum & 0xffff); 1610 sum += (sum >> 16); 1611 1612 return (uint16_t)~sum; 1613 } 1614 1615 static struct bootp_pkt * 1616 dhcp_makeudppacket(size_t *sz, const uint8_t *data, size_t length, 1617 struct in_addr source, struct in_addr dest) 1618 { 1619 struct bootp_pkt *udpp; 1620 struct ip *ip; 1621 struct udphdr *udp; 1622 1623 if ((udpp = calloc(1, sizeof(*ip) + sizeof(*udp) + length)) == NULL) 1624 return NULL; 1625 ip = &udpp->ip; 1626 udp = &udpp->udp; 1627 1628 /* OK, this is important :) 1629 * We copy the data to our packet and then create a small part of the 1630 * ip structure and an invalid ip_len (basically udp length). 1631 * We then fill the udp structure and put the checksum 1632 * of the whole packet into the udp checksum. 1633 * Finally we complete the ip structure and ip checksum. 1634 * If we don't do the ordering like so then the udp checksum will be 1635 * broken, so find another way of doing it! */ 1636 1637 memcpy(&udpp->bootp, data, length); 1638 1639 ip->ip_p = IPPROTO_UDP; 1640 ip->ip_src.s_addr = source.s_addr; 1641 if (dest.s_addr == 0) 1642 ip->ip_dst.s_addr = INADDR_BROADCAST; 1643 else 1644 ip->ip_dst.s_addr = dest.s_addr; 1645 1646 udp->uh_sport = htons(BOOTPC); 1647 udp->uh_dport = htons(BOOTPS); 1648 udp->uh_ulen = htons((uint16_t)(sizeof(*udp) + length)); 1649 ip->ip_len = udp->uh_ulen; 1650 udp->uh_sum = in_cksum(udpp, sizeof(*ip) + sizeof(*udp) + length, NULL); 1651 1652 ip->ip_v = IPVERSION; 1653 ip->ip_hl = sizeof(*ip) >> 2; 1654 ip->ip_id = (uint16_t)arc4random_uniform(UINT16_MAX); 1655 ip->ip_ttl = IPDEFTTL; 1656 ip->ip_len = htons((uint16_t)(sizeof(*ip) + sizeof(*udp) + length)); 1657 ip->ip_sum = in_cksum(ip, sizeof(*ip), NULL); 1658 if (ip->ip_sum == 0) 1659 ip->ip_sum = 0xffff; /* RFC 768 */ 1660 1661 *sz = sizeof(*ip) + sizeof(*udp) + length; 1662 return udpp; 1663 } 1664 1665 static ssize_t 1666 dhcp_sendudp(struct interface *ifp, struct in_addr *to, void *data, size_t len) 1667 { 1668 struct sockaddr_in sin = { 1669 .sin_family = AF_INET, 1670 .sin_addr = *to, 1671 .sin_port = htons(BOOTPS), 1672 #ifdef HAVE_SA_LEN 1673 .sin_len = sizeof(sin), 1674 #endif 1675 }; 1676 struct udphdr udp = { 1677 .uh_sport = htons(BOOTPC), 1678 .uh_dport = htons(BOOTPS), 1679 .uh_ulen = htons((uint16_t)(sizeof(udp) + len)), 1680 }; 1681 struct iovec iov[] = { 1682 { .iov_base = &udp, .iov_len = sizeof(udp), }, 1683 { .iov_base = data, .iov_len = len, }, 1684 }; 1685 struct msghdr msg = { 1686 .msg_name = (void *)&sin, 1687 .msg_namelen = sizeof(sin), 1688 .msg_iov = iov, 1689 .msg_iovlen = __arraycount(iov), 1690 }; 1691 struct dhcpcd_ctx *ctx = ifp->ctx; 1692 1693 #ifdef PRIVSEP 1694 if (ctx->options & DHCPCD_PRIVSEP) 1695 return ps_inet_sendbootp(ifp, &msg); 1696 #endif 1697 return sendmsg(ctx->udp_wfd, &msg, 0); 1698 } 1699 1700 static void 1701 send_message(struct interface *ifp, uint8_t type, 1702 void (*callback)(void *)) 1703 { 1704 struct dhcp_state *state = D_STATE(ifp); 1705 struct if_options *ifo = ifp->options; 1706 struct bootp *bootp; 1707 struct bootp_pkt *udp; 1708 size_t len, ulen; 1709 ssize_t r; 1710 struct in_addr from, to; 1711 unsigned int RT; 1712 1713 if (callback == NULL) { 1714 /* No carrier? Don't bother sending the packet. */ 1715 if (!if_is_link_up(ifp)) 1716 return; 1717 logdebugx("%s: sending %s with xid 0x%x", 1718 ifp->name, 1719 ifo->options & DHCPCD_BOOTP ? "BOOTP" : get_dhcp_op(type), 1720 state->xid); 1721 RT = 0; /* bogus gcc warning */ 1722 } else { 1723 if (state->interval == 0) 1724 state->interval = 4; 1725 else { 1726 state->interval *= 2; 1727 if (state->interval > 64) 1728 state->interval = 64; 1729 } 1730 RT = (state->interval * MSEC_PER_SEC) + 1731 (arc4random_uniform(MSEC_PER_SEC * 2) - MSEC_PER_SEC); 1732 /* No carrier? Don't bother sending the packet. 1733 * However, we do need to advance the timeout. */ 1734 if (!if_is_link_up(ifp)) 1735 goto fail; 1736 logdebugx("%s: sending %s (xid 0x%x), next in %0.1f seconds", 1737 ifp->name, 1738 ifo->options & DHCPCD_BOOTP ? "BOOTP" : get_dhcp_op(type), 1739 state->xid, 1740 (float)RT / MSEC_PER_SEC); 1741 } 1742 1743 r = make_message(&bootp, ifp, type); 1744 if (r == -1) 1745 goto fail; 1746 len = (size_t)r; 1747 1748 if (!(state->added & (STATE_FAKE | STATE_EXPIRED)) && 1749 state->addr != NULL && 1750 ipv4_iffindaddr(ifp, &state->lease.addr, NULL) != NULL) 1751 from.s_addr = state->lease.addr.s_addr; 1752 else 1753 from.s_addr = INADDR_ANY; 1754 if (from.s_addr != INADDR_ANY && 1755 state->lease.server.s_addr != INADDR_ANY) 1756 to.s_addr = state->lease.server.s_addr; 1757 else 1758 to.s_addr = INADDR_BROADCAST; 1759 1760 /* 1761 * If not listening on the unspecified address we can 1762 * only receive broadcast messages via BPF. 1763 * Sockets bound to an address cannot receive broadcast messages 1764 * even if they are setup to send them. 1765 * Broadcasting from UDP is only an optimisation for rebinding 1766 * and on BSD, at least, is reliant on the subnet route being 1767 * correctly configured to receive the unicast reply. 1768 * As such, we always broadcast and receive the reply to it via BPF. 1769 * This also guarantees we have a DHCP server attached to the 1770 * interface we want to configure because we can't dictate the 1771 * interface via IP_PKTINFO unlike for IPv6. 1772 */ 1773 if (to.s_addr != INADDR_BROADCAST) { 1774 if (dhcp_sendudp(ifp, &to, bootp, len) != -1) 1775 goto out; 1776 logerr("%s: dhcp_sendudp", ifp->name); 1777 } 1778 1779 if (dhcp_openbpf(ifp) == -1) 1780 goto out; 1781 1782 udp = dhcp_makeudppacket(&ulen, (uint8_t *)bootp, len, from, to); 1783 if (udp == NULL) { 1784 logerr("%s: dhcp_makeudppacket", ifp->name); 1785 r = 0; 1786 #ifdef PRIVSEP 1787 } else if (ifp->ctx->options & DHCPCD_PRIVSEP) { 1788 r = ps_bpf_sendbootp(ifp, udp, ulen); 1789 free(udp); 1790 #endif 1791 } else { 1792 r = bpf_send(state->bpf, ETHERTYPE_IP, udp, ulen); 1793 free(udp); 1794 } 1795 /* If we failed to send a raw packet this normally means 1796 * we don't have the ability to work beneath the IP layer 1797 * for this interface. 1798 * As such we remove it from consideration without actually 1799 * stopping the interface. */ 1800 if (r == -1) { 1801 logerr("%s: bpf_send", ifp->name); 1802 switch(errno) { 1803 case ENETDOWN: 1804 case ENETRESET: 1805 case ENETUNREACH: 1806 case ENOBUFS: 1807 break; 1808 default: 1809 if (!(ifp->ctx->options & DHCPCD_TEST)) 1810 dhcp_drop(ifp, "FAIL"); 1811 eloop_timeout_delete(ifp->ctx->eloop, 1812 NULL, ifp); 1813 callback = NULL; 1814 } 1815 } 1816 1817 out: 1818 free(bootp); 1819 1820 fail: 1821 /* Even if we fail to send a packet we should continue as we are 1822 * as our failure timeouts will change out codepath when needed. */ 1823 if (callback != NULL) 1824 eloop_timeout_add_msec(ifp->ctx->eloop, RT, callback, ifp); 1825 } 1826 1827 static void 1828 send_inform(void *arg) 1829 { 1830 1831 send_message((struct interface *)arg, DHCP_INFORM, send_inform); 1832 } 1833 1834 static void 1835 send_discover(void *arg) 1836 { 1837 1838 send_message((struct interface *)arg, DHCP_DISCOVER, send_discover); 1839 } 1840 1841 static void 1842 send_request(void *arg) 1843 { 1844 1845 send_message((struct interface *)arg, DHCP_REQUEST, send_request); 1846 } 1847 1848 static void 1849 send_renew(void *arg) 1850 { 1851 1852 send_message((struct interface *)arg, DHCP_REQUEST, send_renew); 1853 } 1854 1855 static void 1856 send_rebind(void *arg) 1857 { 1858 1859 send_message((struct interface *)arg, DHCP_REQUEST, send_rebind); 1860 } 1861 1862 void 1863 dhcp_discover(void *arg) 1864 { 1865 struct interface *ifp = arg; 1866 struct dhcp_state *state = D_STATE(ifp); 1867 struct if_options *ifo = ifp->options; 1868 1869 state->state = DHS_DISCOVER; 1870 dhcp_new_xid(ifp); 1871 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp); 1872 if (!(state->added & STATE_EXPIRED)) { 1873 if (ifo->fallback) 1874 eloop_timeout_add_sec(ifp->ctx->eloop, 1875 ifo->reboot, dhcp_fallback, ifp); 1876 #ifdef IPV4LL 1877 else if (ifo->options & DHCPCD_IPV4LL) 1878 eloop_timeout_add_sec(ifp->ctx->eloop, 1879 ifo->reboot, ipv4ll_start, ifp); 1880 #endif 1881 } 1882 if (ifo->options & DHCPCD_REQUEST) 1883 loginfox("%s: soliciting a DHCP lease (requesting %s)", 1884 ifp->name, inet_ntoa(ifo->req_addr)); 1885 else 1886 loginfox("%s: soliciting a %s lease", 1887 ifp->name, ifo->options & DHCPCD_BOOTP ? "BOOTP" : "DHCP"); 1888 send_discover(ifp); 1889 } 1890 1891 static void 1892 dhcp_request(void *arg) 1893 { 1894 struct interface *ifp = arg; 1895 struct dhcp_state *state = D_STATE(ifp); 1896 1897 state->state = DHS_REQUEST; 1898 send_request(ifp); 1899 } 1900 1901 static void 1902 dhcp_expire(void *arg) 1903 { 1904 struct interface *ifp = arg; 1905 struct dhcp_state *state = D_STATE(ifp); 1906 1907 if (ifp->options->options & DHCPCD_LASTLEASE_EXTEND) { 1908 logwarnx("%s: DHCP lease expired, extending lease", ifp->name); 1909 state->added |= STATE_EXPIRED; 1910 } else { 1911 logerrx("%s: DHCP lease expired", ifp->name); 1912 dhcp_drop(ifp, "EXPIRE"); 1913 dhcp_unlink(ifp->ctx, state->leasefile); 1914 } 1915 state->interval = 0; 1916 dhcp_discover(ifp); 1917 } 1918 1919 #if defined(ARP) || defined(IN_IFF_DUPLICATED) 1920 static void 1921 dhcp_decline(struct interface *ifp) 1922 { 1923 1924 send_message(ifp, DHCP_DECLINE, NULL); 1925 } 1926 #endif 1927 1928 static void 1929 dhcp_startrenew(void *arg) 1930 { 1931 struct interface *ifp = arg; 1932 struct dhcp_state *state; 1933 struct dhcp_lease *lease; 1934 1935 if ((state = D_STATE(ifp)) == NULL) 1936 return; 1937 1938 /* Only renew in the bound or renew states */ 1939 if (state->state != DHS_BOUND && 1940 state->state != DHS_RENEW) 1941 return; 1942 1943 /* Remove the timeout as the renew may have been forced. */ 1944 eloop_timeout_delete(ifp->ctx->eloop, dhcp_startrenew, ifp); 1945 1946 lease = &state->lease; 1947 logdebugx("%s: renewing lease of %s", ifp->name, 1948 inet_ntoa(lease->addr)); 1949 state->state = DHS_RENEW; 1950 dhcp_new_xid(ifp); 1951 state->interval = 0; 1952 send_renew(ifp); 1953 } 1954 1955 void 1956 dhcp_renew(struct interface *ifp) 1957 { 1958 1959 dhcp_startrenew(ifp); 1960 } 1961 1962 static void 1963 dhcp_rebind(void *arg) 1964 { 1965 struct interface *ifp = arg; 1966 struct dhcp_state *state = D_STATE(ifp); 1967 struct dhcp_lease *lease = &state->lease; 1968 1969 logwarnx("%s: failed to renew DHCP, rebinding", ifp->name); 1970 logdebugx("%s: expire in %"PRIu32" seconds", 1971 ifp->name, lease->leasetime - lease->rebindtime); 1972 state->state = DHS_REBIND; 1973 eloop_timeout_delete(ifp->ctx->eloop, send_renew, ifp); 1974 state->lease.server.s_addr = INADDR_ANY; 1975 state->interval = 0; 1976 ifp->options->options &= ~(DHCPCD_CSR_WARNED | 1977 DHCPCD_ROUTER_HOST_ROUTE_WARNED); 1978 send_rebind(ifp); 1979 } 1980 1981 #if defined(ARP) || defined(IN_IFF_DUPLICATED) 1982 static void 1983 dhcp_finish_dad(struct interface *ifp, struct in_addr *ia) 1984 { 1985 struct dhcp_state *state = D_STATE(ifp); 1986 1987 if (state->state != DHS_PROBE) 1988 return; 1989 if (state->offer == NULL || state->offer->yiaddr != ia->s_addr) 1990 return; 1991 1992 logdebugx("%s: DAD completed for %s", ifp->name, inet_ntoa(*ia)); 1993 if (!(ifp->options->options & DHCPCD_INFORM)) 1994 dhcp_bind(ifp); 1995 #ifndef IN_IFF_DUPLICATED 1996 else { 1997 struct bootp *bootp; 1998 size_t len; 1999 2000 bootp = state->new; 2001 len = state->new_len; 2002 state->new = state->offer; 2003 state->new_len = state->offer_len; 2004 get_lease(ifp, &state->lease, state->new, state->new_len); 2005 ipv4_applyaddr(ifp); 2006 state->new = bootp; 2007 state->new_len = len; 2008 } 2009 #endif 2010 2011 #ifdef IPV4LL 2012 /* Stop IPv4LL now we have a working DHCP address */ 2013 ipv4ll_drop(ifp); 2014 #endif 2015 2016 if (ifp->options->options & DHCPCD_INFORM) 2017 dhcp_inform(ifp); 2018 } 2019 2020 2021 static bool 2022 dhcp_addr_duplicated(struct interface *ifp, struct in_addr *ia) 2023 { 2024 struct dhcp_state *state = D_STATE(ifp); 2025 unsigned long long opts = ifp->options->options; 2026 struct dhcpcd_ctx *ctx = ifp->ctx; 2027 bool deleted = false; 2028 #ifdef IN_IFF_DUPLICATED 2029 struct ipv4_addr *iap; 2030 #endif 2031 2032 if ((state->offer == NULL || state->offer->yiaddr != ia->s_addr) && 2033 !IN_ARE_ADDR_EQUAL(ia, &state->lease.addr)) 2034 return deleted; 2035 2036 /* RFC 2131 3.1.5, Client-server interaction */ 2037 logerrx("%s: DAD detected %s", ifp->name, inet_ntoa(*ia)); 2038 dhcp_unlink(ifp->ctx, state->leasefile); 2039 if (!(opts & DHCPCD_STATIC) && !state->lease.frominfo) 2040 dhcp_decline(ifp); 2041 #ifdef IN_IFF_DUPLICATED 2042 if ((iap = ipv4_iffindaddr(ifp, ia, NULL)) != NULL) { 2043 ipv4_deladdr(iap, 0); 2044 deleted = true; 2045 } 2046 #endif 2047 eloop_timeout_delete(ctx->eloop, NULL, ifp); 2048 if (opts & (DHCPCD_STATIC | DHCPCD_INFORM)) { 2049 state->reason = "EXPIRE"; 2050 script_runreason(ifp, state->reason); 2051 #define NOT_ONLY_SELF (DHCPCD_MASTER | DHCPCD_IPV6RS | DHCPCD_DHCP6) 2052 if (!(ctx->options & NOT_ONLY_SELF)) 2053 eloop_exit(ifp->ctx->eloop, EXIT_FAILURE); 2054 return deleted; 2055 } 2056 eloop_timeout_add_sec(ifp->ctx->eloop, 2057 DHCP_RAND_MAX, dhcp_discover, ifp); 2058 return deleted; 2059 } 2060 #endif 2061 2062 #ifdef ARP 2063 #ifdef KERNEL_RFC5227 2064 static void 2065 dhcp_arp_announced(struct arp_state *state) 2066 { 2067 2068 arp_free(state); 2069 } 2070 #else 2071 static void 2072 dhcp_arp_defend_failed(struct arp_state *astate) 2073 { 2074 struct interface *ifp = astate->iface; 2075 2076 dhcp_drop(ifp, "EXPIRED"); 2077 dhcp_start1(ifp); 2078 } 2079 #endif 2080 2081 #if !defined(KERNEL_RFC5227) || defined(ARPING) 2082 static void dhcp_arp_not_found(struct arp_state *); 2083 2084 static struct arp_state * 2085 dhcp_arp_new(struct interface *ifp, struct in_addr *addr) 2086 { 2087 struct arp_state *astate; 2088 2089 astate = arp_new(ifp, addr); 2090 if (astate == NULL) 2091 return NULL; 2092 2093 astate->found_cb = dhcp_arp_found; 2094 astate->not_found_cb = dhcp_arp_not_found; 2095 #ifdef KERNEL_RFC5227 2096 astate->announced_cb = dhcp_arp_announced; 2097 #else 2098 astate->announced_cb = NULL; 2099 astate->defend_failed_cb = dhcp_arp_defend_failed; 2100 #endif 2101 return astate; 2102 } 2103 #endif 2104 2105 #ifdef ARPING 2106 static int 2107 dhcp_arping(struct interface *ifp) 2108 { 2109 struct dhcp_state *state; 2110 struct if_options *ifo; 2111 struct arp_state *astate; 2112 struct in_addr addr; 2113 2114 state = D_STATE(ifp); 2115 ifo = ifp->options; 2116 2117 if (ifo->arping_len == 0 || state->arping_index > ifo->arping_len) 2118 return 0; 2119 2120 if (state->arping_index + 1 == ifo->arping_len) { 2121 state->arping_index++; 2122 dhcpcd_startinterface(ifp); 2123 return 1; 2124 } 2125 2126 addr.s_addr = ifo->arping[++state->arping_index]; 2127 astate = dhcp_arp_new(ifp, &addr); 2128 if (astate == NULL) { 2129 logerr(__func__); 2130 return -1; 2131 } 2132 arp_probe(astate); 2133 return 1; 2134 } 2135 #endif 2136 2137 #if !defined(KERNEL_RFC5227) || defined(ARPING) 2138 static void 2139 dhcp_arp_not_found(struct arp_state *astate) 2140 { 2141 struct interface *ifp; 2142 2143 ifp = astate->iface; 2144 #ifdef ARPING 2145 if (dhcp_arping(ifp) == 1) { 2146 arp_free(astate); 2147 return; 2148 } 2149 #endif 2150 2151 dhcp_finish_dad(ifp, &astate->addr); 2152 } 2153 2154 static void 2155 dhcp_arp_found(struct arp_state *astate, const struct arp_msg *amsg) 2156 { 2157 struct in_addr addr; 2158 struct interface *ifp = astate->iface; 2159 #ifdef ARPING 2160 struct dhcp_state *state; 2161 struct if_options *ifo; 2162 2163 state = D_STATE(ifp); 2164 2165 ifo = ifp->options; 2166 if (state->arping_index != -1 && 2167 state->arping_index < ifo->arping_len && 2168 amsg && 2169 amsg->sip.s_addr == ifo->arping[state->arping_index]) 2170 { 2171 char buf[HWADDR_LEN * 3]; 2172 2173 hwaddr_ntoa(amsg->sha, ifp->hwlen, buf, sizeof(buf)); 2174 if (dhcpcd_selectprofile(ifp, buf) == -1 && 2175 dhcpcd_selectprofile(ifp, inet_ntoa(amsg->sip)) == -1) 2176 { 2177 /* We didn't find a profile for this 2178 * address or hwaddr, so move to the next 2179 * arping profile */ 2180 dhcp_arp_not_found(astate); 2181 return; 2182 } 2183 arp_free(astate); 2184 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp); 2185 dhcpcd_startinterface(ifp); 2186 return; 2187 } 2188 #else 2189 UNUSED(amsg); 2190 #endif 2191 2192 addr = astate->addr; 2193 arp_free(astate); 2194 dhcp_addr_duplicated(ifp, &addr); 2195 } 2196 #endif 2197 2198 #endif /* ARP */ 2199 2200 void 2201 dhcp_bind(struct interface *ifp) 2202 { 2203 struct dhcpcd_ctx *ctx = ifp->ctx; 2204 struct dhcp_state *state = D_STATE(ifp); 2205 struct if_options *ifo = ifp->options; 2206 struct dhcp_lease *lease = &state->lease; 2207 uint8_t old_state; 2208 2209 state->reason = NULL; 2210 /* If we don't have an offer, we are re-binding a lease on preference, 2211 * normally when two interfaces have a lease matching IP addresses. */ 2212 if (state->offer) { 2213 free(state->old); 2214 state->old = state->new; 2215 state->old_len = state->new_len; 2216 state->new = state->offer; 2217 state->new_len = state->offer_len; 2218 state->offer = NULL; 2219 state->offer_len = 0; 2220 } 2221 get_lease(ifp, lease, state->new, state->new_len); 2222 if (ifo->options & DHCPCD_STATIC) { 2223 loginfox("%s: using static address %s/%d", 2224 ifp->name, inet_ntoa(lease->addr), 2225 inet_ntocidr(lease->mask)); 2226 lease->leasetime = DHCP_INFINITE_LIFETIME; 2227 state->reason = "STATIC"; 2228 } else if (ifo->options & DHCPCD_INFORM) { 2229 loginfox("%s: received approval for %s", 2230 ifp->name, inet_ntoa(lease->addr)); 2231 lease->leasetime = DHCP_INFINITE_LIFETIME; 2232 state->reason = "INFORM"; 2233 } else { 2234 if (lease->frominfo) 2235 state->reason = "TIMEOUT"; 2236 if (lease->leasetime == DHCP_INFINITE_LIFETIME) { 2237 lease->renewaltime = 2238 lease->rebindtime = 2239 lease->leasetime; 2240 loginfox("%s: leased %s for infinity", 2241 ifp->name, inet_ntoa(lease->addr)); 2242 } else { 2243 if (lease->leasetime < DHCP_MIN_LEASE) { 2244 logwarnx("%s: minimum lease is %d seconds", 2245 ifp->name, DHCP_MIN_LEASE); 2246 lease->leasetime = DHCP_MIN_LEASE; 2247 } 2248 if (lease->rebindtime == 0) 2249 lease->rebindtime = 2250 (uint32_t)(lease->leasetime * T2); 2251 else if (lease->rebindtime >= lease->leasetime) { 2252 lease->rebindtime = 2253 (uint32_t)(lease->leasetime * T2); 2254 logwarnx("%s: rebind time greater than lease " 2255 "time, forcing to %"PRIu32" seconds", 2256 ifp->name, lease->rebindtime); 2257 } 2258 if (lease->renewaltime == 0) 2259 lease->renewaltime = 2260 (uint32_t)(lease->leasetime * T1); 2261 else if (lease->renewaltime > lease->rebindtime) { 2262 lease->renewaltime = 2263 (uint32_t)(lease->leasetime * T1); 2264 logwarnx("%s: renewal time greater than " 2265 "rebind time, forcing to %"PRIu32" seconds", 2266 ifp->name, lease->renewaltime); 2267 } 2268 if (state->state == DHS_RENEW && state->addr && 2269 lease->addr.s_addr == state->addr->addr.s_addr && 2270 !(state->added & STATE_FAKE)) 2271 logdebugx("%s: leased %s for %"PRIu32" seconds", 2272 ifp->name, inet_ntoa(lease->addr), 2273 lease->leasetime); 2274 else 2275 loginfox("%s: leased %s for %"PRIu32" seconds", 2276 ifp->name, inet_ntoa(lease->addr), 2277 lease->leasetime); 2278 } 2279 } 2280 if (ctx->options & DHCPCD_TEST) { 2281 state->reason = "TEST"; 2282 script_runreason(ifp, state->reason); 2283 eloop_exit(ctx->eloop, EXIT_SUCCESS); 2284 return; 2285 } 2286 if (state->reason == NULL) { 2287 if (state->old && 2288 !(state->added & (STATE_FAKE | STATE_EXPIRED))) 2289 { 2290 if (state->old->yiaddr == state->new->yiaddr && 2291 lease->server.s_addr && 2292 state->state != DHS_REBIND) 2293 state->reason = "RENEW"; 2294 else 2295 state->reason = "REBIND"; 2296 } else if (state->state == DHS_REBOOT) 2297 state->reason = "REBOOT"; 2298 else 2299 state->reason = "BOUND"; 2300 } 2301 if (lease->leasetime == DHCP_INFINITE_LIFETIME) 2302 lease->renewaltime = lease->rebindtime = lease->leasetime; 2303 else { 2304 eloop_timeout_add_sec(ctx->eloop, 2305 lease->renewaltime, dhcp_startrenew, ifp); 2306 eloop_timeout_add_sec(ctx->eloop, 2307 lease->rebindtime, dhcp_rebind, ifp); 2308 eloop_timeout_add_sec(ctx->eloop, 2309 lease->leasetime, dhcp_expire, ifp); 2310 logdebugx("%s: renew in %"PRIu32" seconds, rebind in %"PRIu32 2311 " seconds", 2312 ifp->name, lease->renewaltime, lease->rebindtime); 2313 } 2314 state->state = DHS_BOUND; 2315 if (!state->lease.frominfo && 2316 !(ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC))) { 2317 logdebugx("%s: writing lease: %s", 2318 ifp->name, state->leasefile); 2319 if (dhcp_writefile(ifp->ctx, state->leasefile, 0640, 2320 state->new, state->new_len) == -1) 2321 logerr("dhcp_writefile: %s", state->leasefile); 2322 } 2323 2324 /* Close the BPF filter as we can now receive DHCP messages 2325 * on a UDP socket. */ 2326 old_state = state->added; 2327 if (ctx->options & DHCPCD_MASTER || 2328 state->old == NULL || 2329 state->old->yiaddr != state->new->yiaddr || old_state & STATE_FAKE) 2330 dhcp_close(ifp); 2331 2332 ipv4_applyaddr(ifp); 2333 2334 /* If not in master mode, open an address specific socket. */ 2335 if (ctx->options & DHCPCD_MASTER || 2336 (state->old != NULL && 2337 state->old->yiaddr == state->new->yiaddr && 2338 old_state & STATE_ADDED && !(old_state & STATE_FAKE))) 2339 return; 2340 2341 #ifdef PRIVSEP 2342 if (IN_PRIVSEP_SE(ctx)) { 2343 if (ps_inet_openbootp(state->addr) == -1) 2344 logerr(__func__); 2345 return; 2346 } 2347 #endif 2348 2349 state->udp_rfd = dhcp_openudp(&state->addr->addr); 2350 if (state->udp_rfd == -1) { 2351 logerr(__func__); 2352 /* Address sharing without master mode is not supported. 2353 * It's also possible another DHCP client could be running, 2354 * which is even worse. 2355 * We still need to work, so re-open BPF. */ 2356 dhcp_openbpf(ifp); 2357 return; 2358 } 2359 eloop_event_add(ctx->eloop, state->udp_rfd, dhcp_handleifudp, ifp); 2360 } 2361 2362 static size_t 2363 dhcp_message_new(struct bootp **bootp, 2364 const struct in_addr *addr, const struct in_addr *mask) 2365 { 2366 uint8_t *p; 2367 uint32_t cookie; 2368 2369 if ((*bootp = calloc(1, sizeof(**bootp))) == NULL) 2370 return 0; 2371 2372 (*bootp)->yiaddr = addr->s_addr; 2373 p = (*bootp)->vend; 2374 2375 cookie = htonl(MAGIC_COOKIE); 2376 memcpy(p, &cookie, sizeof(cookie)); 2377 p += sizeof(cookie); 2378 2379 if (mask->s_addr != INADDR_ANY) { 2380 *p++ = DHO_SUBNETMASK; 2381 *p++ = sizeof(mask->s_addr); 2382 memcpy(p, &mask->s_addr, sizeof(mask->s_addr)); 2383 p+= sizeof(mask->s_addr); 2384 } 2385 2386 *p = DHO_END; 2387 return sizeof(**bootp); 2388 } 2389 2390 #if defined(ARP) || defined(KERNEL_RFC5227) 2391 static int 2392 dhcp_arp_address(struct interface *ifp) 2393 { 2394 struct dhcp_state *state; 2395 struct in_addr addr; 2396 struct ipv4_addr *ia; 2397 2398 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp); 2399 2400 state = D_STATE(ifp); 2401 addr.s_addr = state->offer->yiaddr == INADDR_ANY ? 2402 state->offer->ciaddr : state->offer->yiaddr; 2403 /* If the interface already has the address configured 2404 * then we can't ARP for duplicate detection. */ 2405 ia = ipv4_iffindaddr(ifp, &addr, NULL); 2406 #ifdef IN_IFF_NOTUSEABLE 2407 if (ia == NULL || ia->addr_flags & IN_IFF_NOTUSEABLE) { 2408 state->state = DHS_PROBE; 2409 if (ia == NULL) { 2410 struct dhcp_lease l; 2411 2412 get_lease(ifp, &l, state->offer, state->offer_len); 2413 /* Add the address now, let the kernel handle DAD. */ 2414 ipv4_addaddr(ifp, &l.addr, &l.mask, &l.brd, 2415 l.leasetime, l.rebindtime); 2416 } else if (ia->addr_flags & IN_IFF_DUPLICATED) 2417 dhcp_addr_duplicated(ifp, &ia->addr); 2418 else 2419 loginfox("%s: waiting for DAD on %s", 2420 ifp->name, inet_ntoa(addr)); 2421 return 0; 2422 } 2423 #else 2424 if (!(ifp->flags & IFF_NOARP) && 2425 ifp->options->options & DHCPCD_ARP) 2426 { 2427 struct arp_state *astate; 2428 struct dhcp_lease l; 2429 2430 /* Even if the address exists, we need to defend it. */ 2431 astate = dhcp_arp_new(ifp, &addr); 2432 if (astate == NULL) 2433 return -1; 2434 2435 if (ia == NULL) { 2436 state->state = DHS_PROBE; 2437 get_lease(ifp, &l, state->offer, state->offer_len); 2438 loginfox("%s: probing address %s/%d", 2439 ifp->name, inet_ntoa(l.addr), inet_ntocidr(l.mask)); 2440 /* We need to handle DAD. */ 2441 arp_probe(astate); 2442 return 0; 2443 } 2444 } 2445 #endif 2446 2447 return 1; 2448 } 2449 2450 static void 2451 dhcp_arp_bind(struct interface *ifp) 2452 { 2453 2454 if (ifp->ctx->options & DHCPCD_TEST || 2455 dhcp_arp_address(ifp) == 1) 2456 dhcp_bind(ifp); 2457 } 2458 #endif 2459 2460 static void 2461 dhcp_lastlease(void *arg) 2462 { 2463 struct interface *ifp = arg; 2464 struct dhcp_state *state = D_STATE(ifp); 2465 2466 loginfox("%s: timed out contacting a DHCP server, using last lease", 2467 ifp->name); 2468 #if defined(ARP) || defined(KERNEL_RFC5227) 2469 dhcp_arp_bind(ifp); 2470 #else 2471 dhcp_bind(ifp); 2472 #endif 2473 /* Set expired here because dhcp_bind() -> ipv4_addaddr() will reset 2474 * state */ 2475 state->added |= STATE_EXPIRED; 2476 state->interval = 0; 2477 dhcp_discover(ifp); 2478 } 2479 2480 static void 2481 dhcp_static(struct interface *ifp) 2482 { 2483 struct if_options *ifo; 2484 struct dhcp_state *state; 2485 struct ipv4_addr *ia; 2486 2487 state = D_STATE(ifp); 2488 ifo = ifp->options; 2489 2490 ia = NULL; 2491 if (ifo->req_addr.s_addr == INADDR_ANY && 2492 (ia = ipv4_iffindaddr(ifp, NULL, NULL)) == NULL) 2493 { 2494 loginfox("%s: waiting for 3rd party to " 2495 "configure IP address", ifp->name); 2496 state->reason = "3RDPARTY"; 2497 script_runreason(ifp, state->reason); 2498 return; 2499 } 2500 2501 state->offer_len = dhcp_message_new(&state->offer, 2502 ia ? &ia->addr : &ifo->req_addr, 2503 ia ? &ia->mask : &ifo->req_mask); 2504 if (state->offer_len) 2505 #if defined(ARP) || defined(KERNEL_RFC5227) 2506 dhcp_arp_bind(ifp); 2507 #else 2508 dhcp_bind(ifp); 2509 #endif 2510 } 2511 2512 void 2513 dhcp_inform(struct interface *ifp) 2514 { 2515 struct dhcp_state *state; 2516 struct if_options *ifo; 2517 struct ipv4_addr *ia; 2518 2519 state = D_STATE(ifp); 2520 ifo = ifp->options; 2521 2522 state->state = DHS_INFORM; 2523 free(state->offer); 2524 state->offer = NULL; 2525 state->offer_len = 0; 2526 2527 if (ifo->req_addr.s_addr == INADDR_ANY) { 2528 ia = ipv4_iffindaddr(ifp, NULL, NULL); 2529 if (ia == NULL) { 2530 loginfox("%s: waiting for 3rd party to " 2531 "configure IP address", 2532 ifp->name); 2533 if (!(ifp->ctx->options & DHCPCD_TEST)) { 2534 state->reason = "3RDPARTY"; 2535 script_runreason(ifp, state->reason); 2536 } 2537 return; 2538 } 2539 } else { 2540 ia = ipv4_iffindaddr(ifp, &ifo->req_addr, &ifo->req_mask); 2541 if (ia == NULL) { 2542 if (ifp->ctx->options & DHCPCD_TEST) { 2543 logerrx("%s: cannot add IP address in test mode", 2544 ifp->name); 2545 return; 2546 } 2547 ia = ipv4_iffindaddr(ifp, &ifo->req_addr, NULL); 2548 if (ia != NULL) 2549 /* Netmask must be different, delete it. */ 2550 ipv4_deladdr(ia, 1); 2551 state->offer_len = dhcp_message_new(&state->offer, 2552 &ifo->req_addr, &ifo->req_mask); 2553 #ifdef ARP 2554 if (dhcp_arp_address(ifp) != 1) 2555 return; 2556 #endif 2557 ia = ipv4_iffindaddr(ifp, 2558 &ifo->req_addr, &ifo->req_mask); 2559 assert(ia != NULL); 2560 } 2561 } 2562 2563 state->addr = ia; 2564 state->offer_len = dhcp_message_new(&state->offer, 2565 &ia->addr, &ia->mask); 2566 if (state->offer_len) { 2567 dhcp_new_xid(ifp); 2568 get_lease(ifp, &state->lease, state->offer, state->offer_len); 2569 send_inform(ifp); 2570 } 2571 } 2572 2573 void 2574 dhcp_reboot_newopts(struct interface *ifp, unsigned long long oldopts) 2575 { 2576 struct if_options *ifo; 2577 struct dhcp_state *state = D_STATE(ifp); 2578 2579 if (state == NULL || state->state == DHS_NONE) 2580 return; 2581 ifo = ifp->options; 2582 if ((ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC) && 2583 (state->addr == NULL || 2584 state->addr->addr.s_addr != ifo->req_addr.s_addr)) || 2585 (oldopts & (DHCPCD_INFORM | DHCPCD_STATIC) && 2586 !(ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC)))) 2587 { 2588 dhcp_drop(ifp, "EXPIRE"); 2589 } 2590 } 2591 2592 #ifdef ARP 2593 static int 2594 dhcp_activeaddr(const struct interface *ifp, const struct in_addr *addr) 2595 { 2596 const struct interface *ifp1; 2597 const struct dhcp_state *state; 2598 2599 TAILQ_FOREACH(ifp1, ifp->ctx->ifaces, next) { 2600 if (ifp1 == ifp) 2601 continue; 2602 if ((state = D_CSTATE(ifp1)) == NULL) 2603 continue; 2604 switch(state->state) { 2605 case DHS_REBOOT: 2606 case DHS_RENEW: 2607 case DHS_REBIND: 2608 case DHS_BOUND: 2609 case DHS_INFORM: 2610 break; 2611 default: 2612 continue; 2613 } 2614 if (state->lease.addr.s_addr == addr->s_addr) 2615 return 1; 2616 } 2617 return 0; 2618 } 2619 #endif 2620 2621 static void 2622 dhcp_reboot(struct interface *ifp) 2623 { 2624 struct if_options *ifo; 2625 struct dhcp_state *state = D_STATE(ifp); 2626 #ifdef ARP 2627 struct ipv4_addr *ia; 2628 #endif 2629 2630 if (state == NULL || state->state == DHS_NONE) 2631 return; 2632 ifo = ifp->options; 2633 state->state = DHS_REBOOT; 2634 state->interval = 0; 2635 2636 if (ifo->options & DHCPCD_LINK && !if_is_link_up(ifp)) { 2637 loginfox("%s: waiting for carrier", ifp->name); 2638 return; 2639 } 2640 if (ifo->options & DHCPCD_STATIC) { 2641 dhcp_static(ifp); 2642 return; 2643 } 2644 if (ifo->options & DHCPCD_INFORM) { 2645 loginfox("%s: informing address of %s", 2646 ifp->name, inet_ntoa(state->lease.addr)); 2647 dhcp_inform(ifp); 2648 return; 2649 } 2650 if (ifo->reboot == 0 || state->offer == NULL) { 2651 dhcp_discover(ifp); 2652 return; 2653 } 2654 if (!IS_DHCP(state->offer)) 2655 return; 2656 2657 loginfox("%s: rebinding lease of %s", 2658 ifp->name, inet_ntoa(state->lease.addr)); 2659 2660 #ifdef ARP 2661 #ifndef KERNEL_RFC5227 2662 /* Create the DHCP ARP state so we can defend it. */ 2663 (void)dhcp_arp_new(ifp, &state->lease.addr); 2664 #endif 2665 2666 /* If the address exists on the interface and no other interface 2667 * is currently using it then announce it to ensure this 2668 * interface gets the reply. */ 2669 ia = ipv4_iffindaddr(ifp, &state->lease.addr, NULL); 2670 if (ia != NULL && 2671 !(ifp->ctx->options & DHCPCD_TEST) && 2672 #ifdef IN_IFF_NOTUSEABLE 2673 !(ia->addr_flags & IN_IFF_NOTUSEABLE) && 2674 #endif 2675 dhcp_activeaddr(ifp, &state->lease.addr) == 0) 2676 arp_ifannounceaddr(ifp, &state->lease.addr); 2677 #endif 2678 2679 dhcp_new_xid(ifp); 2680 state->lease.server.s_addr = INADDR_ANY; 2681 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp); 2682 2683 #ifdef IPV4LL 2684 /* Need to add this before dhcp_expire and friends. */ 2685 if (!ifo->fallback && ifo->options & DHCPCD_IPV4LL) 2686 eloop_timeout_add_sec(ifp->ctx->eloop, 2687 ifo->reboot, ipv4ll_start, ifp); 2688 #endif 2689 2690 if (ifo->options & DHCPCD_LASTLEASE && state->lease.frominfo) 2691 eloop_timeout_add_sec(ifp->ctx->eloop, 2692 ifo->reboot, dhcp_lastlease, ifp); 2693 else if (!(ifo->options & DHCPCD_INFORM)) 2694 eloop_timeout_add_sec(ifp->ctx->eloop, 2695 ifo->reboot, dhcp_expire, ifp); 2696 2697 /* Don't bother ARP checking as the server could NAK us first. 2698 * Don't call dhcp_request as that would change the state */ 2699 send_request(ifp); 2700 } 2701 2702 void 2703 dhcp_drop(struct interface *ifp, const char *reason) 2704 { 2705 struct dhcp_state *state; 2706 #ifdef RELEASE_SLOW 2707 struct timespec ts; 2708 #endif 2709 2710 state = D_STATE(ifp); 2711 /* dhcp_start may just have been called and we don't yet have a state 2712 * but we do have a timeout, so punt it. */ 2713 if (state == NULL || state->state == DHS_NONE) { 2714 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp); 2715 return; 2716 } 2717 2718 #ifdef ARP 2719 if (state->addr != NULL) 2720 arp_freeaddr(ifp, &state->addr->addr); 2721 #endif 2722 #ifdef ARPING 2723 state->arping_index = -1; 2724 #endif 2725 2726 if (ifp->options->options & DHCPCD_RELEASE && 2727 !(ifp->options->options & DHCPCD_INFORM)) 2728 { 2729 /* Failure to send the release may cause this function to 2730 * re-enter so guard by setting the state. */ 2731 if (state->state == DHS_RELEASE) 2732 return; 2733 state->state = DHS_RELEASE; 2734 2735 dhcp_unlink(ifp->ctx, state->leasefile); 2736 if (if_is_link_up(ifp) && 2737 state->new != NULL && 2738 state->lease.server.s_addr != INADDR_ANY) 2739 { 2740 loginfox("%s: releasing lease of %s", 2741 ifp->name, inet_ntoa(state->lease.addr)); 2742 dhcp_new_xid(ifp); 2743 send_message(ifp, DHCP_RELEASE, NULL); 2744 #ifdef RELEASE_SLOW 2745 /* Give the packet a chance to go */ 2746 ts.tv_sec = RELEASE_DELAY_S; 2747 ts.tv_nsec = RELEASE_DELAY_NS; 2748 nanosleep(&ts, NULL); 2749 #endif 2750 } 2751 } 2752 #ifdef AUTH 2753 else if (state->auth.reconf != NULL) { 2754 /* 2755 * Drop the lease as the token may only be present 2756 * in the initial reply message and not subsequent 2757 * renewals. 2758 * If dhcpcd is restarted, the token is lost. 2759 * XXX persist this in another file? 2760 */ 2761 dhcp_unlink(ifp->ctx, state->leasefile); 2762 } 2763 #endif 2764 2765 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp); 2766 #ifdef AUTH 2767 dhcp_auth_reset(&state->auth); 2768 #endif 2769 2770 /* Close DHCP ports so a changed interface family is picked 2771 * up by a new BPF state. */ 2772 dhcp_close(ifp); 2773 2774 state->state = DHS_NONE; 2775 free(state->offer); 2776 state->offer = NULL; 2777 state->offer_len = 0; 2778 free(state->old); 2779 state->old = state->new; 2780 state->old_len = state->new_len; 2781 state->new = NULL; 2782 state->new_len = 0; 2783 state->reason = reason; 2784 ipv4_applyaddr(ifp); 2785 free(state->old); 2786 state->old = NULL; 2787 state->old_len = 0; 2788 state->lease.addr.s_addr = 0; 2789 ifp->options->options &= ~(DHCPCD_CSR_WARNED | 2790 DHCPCD_ROUTER_HOST_ROUTE_WARNED); 2791 } 2792 2793 static int 2794 blacklisted_ip(const struct if_options *ifo, in_addr_t addr) 2795 { 2796 size_t i; 2797 2798 for (i = 0; i < ifo->blacklist_len; i += 2) 2799 if (ifo->blacklist[i] == (addr & ifo->blacklist[i + 1])) 2800 return 1; 2801 return 0; 2802 } 2803 2804 #define WHTLST_NONE 0 2805 #define WHTLST_MATCH 1 2806 #define WHTLST_NOMATCH 2 2807 static unsigned int 2808 whitelisted_ip(const struct if_options *ifo, in_addr_t addr) 2809 { 2810 size_t i; 2811 2812 if (ifo->whitelist_len == 0) 2813 return WHTLST_NONE; 2814 for (i = 0; i < ifo->whitelist_len; i += 2) 2815 if (ifo->whitelist[i] == (addr & ifo->whitelist[i + 1])) 2816 return WHTLST_MATCH; 2817 return WHTLST_NOMATCH; 2818 } 2819 2820 static void 2821 log_dhcp(int loglevel, const char *msg, 2822 const struct interface *ifp, const struct bootp *bootp, size_t bootp_len, 2823 const struct in_addr *from, int ad) 2824 { 2825 const char *tfrom; 2826 char *a, sname[sizeof(bootp->sname) * 4]; 2827 struct in_addr addr; 2828 int r; 2829 uint8_t overl; 2830 2831 if (strcmp(msg, "NAK:") == 0) { 2832 a = get_option_string(ifp->ctx, bootp, bootp_len, DHO_MESSAGE); 2833 if (a) { 2834 char *tmp; 2835 size_t al, tmpl; 2836 2837 al = strlen(a); 2838 tmpl = (al * 4) + 1; 2839 tmp = malloc(tmpl); 2840 if (tmp == NULL) { 2841 logerr(__func__); 2842 free(a); 2843 return; 2844 } 2845 print_string(tmp, tmpl, OT_STRING, (uint8_t *)a, al); 2846 free(a); 2847 a = tmp; 2848 } 2849 } else if (ad && bootp->yiaddr != 0) { 2850 addr.s_addr = bootp->yiaddr; 2851 a = strdup(inet_ntoa(addr)); 2852 if (a == NULL) { 2853 logerr(__func__); 2854 return; 2855 } 2856 } else 2857 a = NULL; 2858 2859 tfrom = "from"; 2860 r = get_option_addr(ifp->ctx, &addr, bootp, bootp_len, DHO_SERVERID); 2861 if (get_option_uint8(ifp->ctx, &overl, bootp, bootp_len, 2862 DHO_OPTSOVERLOADED) == -1) 2863 overl = 0; 2864 if (bootp->sname[0] && r == 0 && !(overl & 2)) { 2865 print_string(sname, sizeof(sname), OT_STRING | OT_DOMAIN, 2866 bootp->sname, sizeof(bootp->sname)); 2867 if (a == NULL) 2868 logmessage(loglevel, "%s: %s %s %s %s", 2869 ifp->name, msg, tfrom, inet_ntoa(addr), sname); 2870 else 2871 logmessage(loglevel, "%s: %s %s %s %s %s", 2872 ifp->name, msg, a, tfrom, inet_ntoa(addr), sname); 2873 } else { 2874 if (r != 0) { 2875 tfrom = "via"; 2876 addr = *from; 2877 } 2878 if (a == NULL) 2879 logmessage(loglevel, "%s: %s %s %s", 2880 ifp->name, msg, tfrom, inet_ntoa(addr)); 2881 else 2882 logmessage(loglevel, "%s: %s %s %s %s", 2883 ifp->name, msg, a, tfrom, inet_ntoa(addr)); 2884 } 2885 free(a); 2886 } 2887 2888 /* If we're sharing the same IP address with another interface on the 2889 * same network, we may receive the DHCP reply on the wrong interface. 2890 * Try and re-direct it here. */ 2891 static void 2892 dhcp_redirect_dhcp(struct interface *ifp, struct bootp *bootp, size_t bootp_len, 2893 const struct in_addr *from) 2894 { 2895 struct interface *ifn; 2896 const struct dhcp_state *state; 2897 uint32_t xid; 2898 2899 xid = ntohl(bootp->xid); 2900 TAILQ_FOREACH(ifn, ifp->ctx->ifaces, next) { 2901 if (ifn == ifp) 2902 continue; 2903 state = D_CSTATE(ifn); 2904 if (state == NULL || state->state == DHS_NONE) 2905 continue; 2906 if (state->xid != xid) 2907 continue; 2908 if (ifn->hwlen <= sizeof(bootp->chaddr) && 2909 memcmp(bootp->chaddr, ifn->hwaddr, ifn->hwlen)) 2910 continue; 2911 logdebugx("%s: redirecting DHCP message to %s", 2912 ifp->name, ifn->name); 2913 dhcp_handledhcp(ifn, bootp, bootp_len, from); 2914 } 2915 } 2916 2917 static void 2918 dhcp_handledhcp(struct interface *ifp, struct bootp *bootp, size_t bootp_len, 2919 const struct in_addr *from) 2920 { 2921 struct dhcp_state *state = D_STATE(ifp); 2922 struct if_options *ifo = ifp->options; 2923 struct dhcp_lease *lease = &state->lease; 2924 uint8_t type, tmp; 2925 struct in_addr addr; 2926 unsigned int i; 2927 char *msg; 2928 bool bootp_copied; 2929 #ifdef AUTH 2930 const uint8_t *auth; 2931 size_t auth_len; 2932 #endif 2933 #ifdef IN_IFF_DUPLICATED 2934 struct ipv4_addr *ia; 2935 #endif 2936 2937 #define LOGDHCP0(l, m) \ 2938 log_dhcp((l), (m), ifp, bootp, bootp_len, from, 0) 2939 #define LOGDHCP(l, m) \ 2940 log_dhcp((l), (m), ifp, bootp, bootp_len, from, 1) 2941 2942 #define IS_STATE_ACTIVE(s) ((s)-state != DHS_NONE && \ 2943 (s)->state != DHS_INIT && (s)->state != DHS_BOUND) 2944 2945 if (bootp->op != BOOTREPLY) { 2946 if (IS_STATE_ACTIVE(state)) 2947 logdebugx("%s: op (%d) is not BOOTREPLY", 2948 ifp->name, bootp->op); 2949 return; 2950 } 2951 2952 if (state->xid != ntohl(bootp->xid)) { 2953 if (IS_STATE_ACTIVE(state)) 2954 logdebugx("%s: wrong xid 0x%x (expecting 0x%x) from %s", 2955 ifp->name, ntohl(bootp->xid), state->xid, 2956 inet_ntoa(*from)); 2957 dhcp_redirect_dhcp(ifp, bootp, bootp_len, from); 2958 return; 2959 } 2960 2961 if (ifp->hwlen <= sizeof(bootp->chaddr) && 2962 memcmp(bootp->chaddr, ifp->hwaddr, ifp->hwlen)) 2963 { 2964 if (IS_STATE_ACTIVE(state)) { 2965 char buf[sizeof(bootp->chaddr) * 3]; 2966 2967 logdebugx("%s: xid 0x%x is for hwaddr %s", 2968 ifp->name, ntohl(bootp->xid), 2969 hwaddr_ntoa(bootp->chaddr, sizeof(bootp->chaddr), 2970 buf, sizeof(buf))); 2971 } 2972 dhcp_redirect_dhcp(ifp, bootp, bootp_len, from); 2973 return; 2974 } 2975 2976 if (!ifp->active) 2977 return; 2978 2979 i = whitelisted_ip(ifp->options, from->s_addr); 2980 switch (i) { 2981 case WHTLST_NOMATCH: 2982 logwarnx("%s: non whitelisted DHCP packet from %s", 2983 ifp->name, inet_ntoa(*from)); 2984 return; 2985 case WHTLST_MATCH: 2986 break; 2987 case WHTLST_NONE: 2988 if (blacklisted_ip(ifp->options, from->s_addr) == 1) { 2989 logwarnx("%s: blacklisted DHCP packet from %s", 2990 ifp->name, inet_ntoa(*from)); 2991 return; 2992 } 2993 } 2994 2995 /* We may have found a BOOTP server */ 2996 if (get_option_uint8(ifp->ctx, &type, 2997 bootp, bootp_len, DHO_MESSAGETYPE) == -1) 2998 type = 0; 2999 else if (ifo->options & DHCPCD_BOOTP) { 3000 logdebugx("%s: ignoring DHCP reply (expecting BOOTP)", 3001 ifp->name); 3002 return; 3003 } 3004 3005 #ifdef AUTH 3006 /* Authenticate the message */ 3007 auth = get_option(ifp->ctx, bootp, bootp_len, 3008 DHO_AUTHENTICATION, &auth_len); 3009 if (auth) { 3010 if (dhcp_auth_validate(&state->auth, &ifo->auth, 3011 (uint8_t *)bootp, bootp_len, 4, type, 3012 auth, auth_len) == NULL) 3013 { 3014 LOGDHCP0(LOG_ERR, "authentication failed"); 3015 return; 3016 } 3017 if (state->auth.token) 3018 logdebugx("%s: validated using 0x%08" PRIu32, 3019 ifp->name, state->auth.token->secretid); 3020 else 3021 loginfox("%s: accepted reconfigure key", ifp->name); 3022 } else if (ifo->auth.options & DHCPCD_AUTH_SEND) { 3023 if (ifo->auth.options & DHCPCD_AUTH_REQUIRE) { 3024 LOGDHCP0(LOG_ERR, "no authentication"); 3025 return; 3026 } 3027 LOGDHCP0(LOG_WARNING, "no authentication"); 3028 } 3029 #endif 3030 3031 /* RFC 3203 */ 3032 if (type == DHCP_FORCERENEW) { 3033 if (from->s_addr == INADDR_ANY || 3034 from->s_addr == INADDR_BROADCAST) 3035 { 3036 LOGDHCP(LOG_ERR, "discarding Force Renew"); 3037 return; 3038 } 3039 #ifdef AUTH 3040 if (auth == NULL) { 3041 LOGDHCP(LOG_ERR, "unauthenticated Force Renew"); 3042 if (ifo->auth.options & DHCPCD_AUTH_REQUIRE) 3043 return; 3044 } 3045 if (state->state != DHS_BOUND && state->state != DHS_INFORM) { 3046 LOGDHCP(LOG_DEBUG, "not bound, ignoring Force Renew"); 3047 return; 3048 } 3049 LOGDHCP(LOG_INFO, "Force Renew from"); 3050 /* The rebind and expire timings are still the same, we just 3051 * enter the renew state early */ 3052 if (state->state == DHS_BOUND) 3053 dhcp_renew(ifp); 3054 else { 3055 eloop_timeout_delete(ifp->ctx->eloop, 3056 send_inform, ifp); 3057 dhcp_inform(ifp); 3058 } 3059 #else 3060 LOGDHCP(LOG_ERR, "unauthenticated Force Renew"); 3061 #endif 3062 return; 3063 } 3064 3065 if (state->state == DHS_BOUND) { 3066 LOGDHCP(LOG_DEBUG, "bound, ignoring"); 3067 return; 3068 } 3069 3070 if (state->state == DHS_PROBE) { 3071 /* Ignore any DHCP messages whilst probing a lease to bind. */ 3072 LOGDHCP(LOG_DEBUG, "probing, ignoring"); 3073 return; 3074 } 3075 3076 /* reset the message counter */ 3077 state->interval = 0; 3078 3079 /* Ensure that no reject options are present */ 3080 for (i = 1; i < 255; i++) { 3081 if (has_option_mask(ifo->rejectmask, i) && 3082 get_option_uint8(ifp->ctx, &tmp, 3083 bootp, bootp_len, (uint8_t)i) == 0) 3084 { 3085 LOGDHCP(LOG_WARNING, "reject DHCP"); 3086 return; 3087 } 3088 } 3089 3090 if (type == DHCP_NAK) { 3091 /* For NAK, only check if we require the ServerID */ 3092 if (has_option_mask(ifo->requiremask, DHO_SERVERID) && 3093 get_option_addr(ifp->ctx, &addr, 3094 bootp, bootp_len, DHO_SERVERID) == -1) 3095 { 3096 LOGDHCP(LOG_WARNING, "reject NAK"); 3097 return; 3098 } 3099 3100 /* We should restart on a NAK */ 3101 LOGDHCP(LOG_WARNING, "NAK:"); 3102 if ((msg = get_option_string(ifp->ctx, 3103 bootp, bootp_len, DHO_MESSAGE))) 3104 { 3105 logwarnx("%s: message: %s", ifp->name, msg); 3106 free(msg); 3107 } 3108 if (state->state == DHS_INFORM) /* INFORM should not be NAKed */ 3109 return; 3110 if (!(ifp->ctx->options & DHCPCD_TEST)) { 3111 dhcp_drop(ifp, "NAK"); 3112 dhcp_unlink(ifp->ctx, state->leasefile); 3113 } 3114 3115 /* If we constantly get NAKS then we should slowly back off */ 3116 eloop_timeout_add_sec(ifp->ctx->eloop, 3117 state->nakoff, dhcp_discover, ifp); 3118 if (state->nakoff == 0) 3119 state->nakoff = 1; 3120 else { 3121 state->nakoff *= 2; 3122 if (state->nakoff > NAKOFF_MAX) 3123 state->nakoff = NAKOFF_MAX; 3124 } 3125 return; 3126 } 3127 3128 /* Ensure that all required options are present */ 3129 for (i = 1; i < 255; i++) { 3130 if (has_option_mask(ifo->requiremask, i) && 3131 get_option_uint8(ifp->ctx, &tmp, 3132 bootp, bootp_len, (uint8_t)i) != 0) 3133 { 3134 /* If we are BOOTP, then ignore the need for serverid. 3135 * To ignore BOOTP, require dhcp_message_type. 3136 * However, nothing really stops BOOTP from providing 3137 * DHCP style options as well so the above isn't 3138 * always true. */ 3139 if (type == 0 && i == DHO_SERVERID) 3140 continue; 3141 LOGDHCP(LOG_WARNING, "reject DHCP"); 3142 return; 3143 } 3144 } 3145 3146 /* DHCP Auto-Configure, RFC 2563 */ 3147 if (type == DHCP_OFFER && bootp->yiaddr == 0) { 3148 LOGDHCP(LOG_WARNING, "no address given"); 3149 if ((msg = get_option_string(ifp->ctx, 3150 bootp, bootp_len, DHO_MESSAGE))) 3151 { 3152 logwarnx("%s: message: %s", ifp->name, msg); 3153 free(msg); 3154 } 3155 #ifdef IPV4LL 3156 if (state->state == DHS_DISCOVER && 3157 get_option_uint8(ifp->ctx, &tmp, bootp, bootp_len, 3158 DHO_AUTOCONFIGURE) == 0) 3159 { 3160 switch (tmp) { 3161 case 0: 3162 LOGDHCP(LOG_WARNING, "IPv4LL disabled from"); 3163 ipv4ll_drop(ifp); 3164 #ifdef ARP 3165 arp_drop(ifp); 3166 #endif 3167 break; 3168 case 1: 3169 LOGDHCP(LOG_WARNING, "IPv4LL enabled from"); 3170 ipv4ll_start(ifp); 3171 break; 3172 default: 3173 logerrx("%s: unknown auto configuration " 3174 "option %d", 3175 ifp->name, tmp); 3176 break; 3177 } 3178 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp); 3179 eloop_timeout_add_sec(ifp->ctx->eloop, 3180 DHCP_MAX, dhcp_discover, ifp); 3181 } 3182 #endif 3183 return; 3184 } 3185 3186 /* Ensure that the address offered is valid */ 3187 if ((type == 0 || type == DHCP_OFFER || type == DHCP_ACK) && 3188 (bootp->ciaddr == INADDR_ANY || bootp->ciaddr == INADDR_BROADCAST) 3189 && 3190 (bootp->yiaddr == INADDR_ANY || bootp->yiaddr == INADDR_BROADCAST)) 3191 { 3192 LOGDHCP(LOG_WARNING, "reject invalid address"); 3193 return; 3194 } 3195 3196 #ifdef IN_IFF_DUPLICATED 3197 ia = ipv4_iffindaddr(ifp, &lease->addr, NULL); 3198 if (ia && ia->addr_flags & IN_IFF_DUPLICATED) { 3199 LOGDHCP(LOG_WARNING, "declined duplicate address"); 3200 if (type) 3201 dhcp_decline(ifp); 3202 ipv4_deladdr(ia, 0); 3203 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp); 3204 eloop_timeout_add_sec(ifp->ctx->eloop, 3205 DHCP_RAND_MAX, dhcp_discover, ifp); 3206 return; 3207 } 3208 #endif 3209 3210 bootp_copied = false; 3211 if ((type == 0 || type == DHCP_OFFER) && state->state == DHS_DISCOVER) { 3212 lease->frominfo = 0; 3213 lease->addr.s_addr = bootp->yiaddr; 3214 memcpy(&lease->cookie, bootp->vend, sizeof(lease->cookie)); 3215 if (type == 0 || 3216 get_option_addr(ifp->ctx, 3217 &lease->server, bootp, bootp_len, DHO_SERVERID) != 0) 3218 lease->server.s_addr = INADDR_ANY; 3219 3220 /* Test for rapid commit in the OFFER */ 3221 if (!(ifp->ctx->options & DHCPCD_TEST) && 3222 has_option_mask(ifo->requestmask, DHO_RAPIDCOMMIT) && 3223 get_option(ifp->ctx, bootp, bootp_len, 3224 DHO_RAPIDCOMMIT, NULL)) 3225 { 3226 state->state = DHS_REQUEST; 3227 goto rapidcommit; 3228 } 3229 3230 LOGDHCP(LOG_INFO, "offered"); 3231 if (state->offer_len < bootp_len) { 3232 free(state->offer); 3233 if ((state->offer = malloc(bootp_len)) == NULL) { 3234 logerr(__func__); 3235 state->offer_len = 0; 3236 return; 3237 } 3238 } 3239 state->offer_len = bootp_len; 3240 memcpy(state->offer, bootp, bootp_len); 3241 bootp_copied = true; 3242 if (ifp->ctx->options & DHCPCD_TEST) { 3243 free(state->old); 3244 state->old = state->new; 3245 state->old_len = state->new_len; 3246 state->new = state->offer; 3247 state->new_len = state->offer_len; 3248 state->offer = NULL; 3249 state->offer_len = 0; 3250 state->reason = "TEST"; 3251 script_runreason(ifp, state->reason); 3252 eloop_exit(ifp->ctx->eloop, EXIT_SUCCESS); 3253 state->bpf->bpf_flags |= BPF_EOF; 3254 return; 3255 } 3256 eloop_timeout_delete(ifp->ctx->eloop, send_discover, ifp); 3257 /* We don't request BOOTP addresses */ 3258 if (type) { 3259 /* We used to ARP check here, but that seems to be in 3260 * violation of RFC2131 where it only describes 3261 * DECLINE after REQUEST. 3262 * It also seems that some MS DHCP servers actually 3263 * ignore DECLINE if no REQUEST, ie we decline a 3264 * DISCOVER. */ 3265 dhcp_request(ifp); 3266 return; 3267 } 3268 } 3269 3270 if (type) { 3271 if (type == DHCP_OFFER) { 3272 LOGDHCP(LOG_WARNING, "ignoring offer of"); 3273 return; 3274 } 3275 3276 /* We should only be dealing with acks */ 3277 if (type != DHCP_ACK) { 3278 LOGDHCP(LOG_ERR, "not ACK or OFFER"); 3279 return; 3280 } 3281 3282 if (state->state == DHS_DISCOVER) { 3283 /* We only allow ACK of rapid commit DISCOVER. */ 3284 if (has_option_mask(ifo->requestmask, 3285 DHO_RAPIDCOMMIT) && 3286 get_option(ifp->ctx, bootp, bootp_len, 3287 DHO_RAPIDCOMMIT, NULL)) 3288 state->state = DHS_REQUEST; 3289 else { 3290 LOGDHCP(LOG_DEBUG, "ignoring ack of"); 3291 return; 3292 } 3293 } 3294 3295 rapidcommit: 3296 if (!(ifo->options & DHCPCD_INFORM)) 3297 LOGDHCP(LOG_DEBUG, "acknowledged"); 3298 else 3299 ifo->options &= ~DHCPCD_STATIC; 3300 } 3301 3302 /* No NAK, so reset the backoff 3303 * We don't reset on an OFFER message because the server could 3304 * potentially NAK the REQUEST. */ 3305 state->nakoff = 0; 3306 3307 /* BOOTP could have already assigned this above. */ 3308 if (!bootp_copied) { 3309 if (state->offer_len < bootp_len) { 3310 free(state->offer); 3311 if ((state->offer = malloc(bootp_len)) == NULL) { 3312 logerr(__func__); 3313 state->offer_len = 0; 3314 return; 3315 } 3316 } 3317 state->offer_len = bootp_len; 3318 memcpy(state->offer, bootp, bootp_len); 3319 } 3320 3321 lease->frominfo = 0; 3322 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp); 3323 3324 #if defined(ARP) || defined(KERNEL_RFC5227) 3325 dhcp_arp_bind(ifp); 3326 #else 3327 dhcp_bind(ifp); 3328 #endif 3329 } 3330 3331 static void * 3332 get_udp_data(void *packet, size_t *len) 3333 { 3334 const struct ip *ip = packet; 3335 size_t ip_hl = (size_t)ip->ip_hl * 4; 3336 char *p = packet; 3337 3338 p += ip_hl + sizeof(struct udphdr); 3339 *len = (size_t)ntohs(ip->ip_len) - sizeof(struct udphdr) - ip_hl; 3340 return p; 3341 } 3342 3343 static bool 3344 is_packet_udp_bootp(void *packet, size_t plen) 3345 { 3346 struct ip *ip = packet; 3347 size_t ip_hlen; 3348 struct udphdr udp; 3349 3350 if (plen < sizeof(*ip)) 3351 return false; 3352 3353 if (ip->ip_v != IPVERSION || ip->ip_p != IPPROTO_UDP) 3354 return false; 3355 3356 /* Sanity. */ 3357 if (ntohs(ip->ip_len) > plen) 3358 return false; 3359 3360 ip_hlen = (size_t)ip->ip_hl * 4; 3361 if (ip_hlen < sizeof(*ip)) 3362 return false; 3363 3364 /* Check we have a UDP header and BOOTP. */ 3365 if (ip_hlen + sizeof(udp) + offsetof(struct bootp, vend) > plen) 3366 return false; 3367 3368 /* Sanity. */ 3369 memcpy(&udp, (char *)ip + ip_hlen, sizeof(udp)); 3370 if (ntohs(udp.uh_ulen) < sizeof(udp)) 3371 return false; 3372 if (ip_hlen + ntohs(udp.uh_ulen) > plen) 3373 return false; 3374 3375 /* Check it's to and from the right ports. */ 3376 if (udp.uh_dport != htons(BOOTPC) || udp.uh_sport != htons(BOOTPS)) 3377 return false; 3378 3379 return true; 3380 } 3381 3382 /* Lengths have already been checked. */ 3383 static bool 3384 checksums_valid(void *packet, 3385 struct in_addr *from, unsigned int flags) 3386 { 3387 struct ip *ip = packet; 3388 union pip { 3389 struct ip ip; 3390 uint16_t w[sizeof(struct ip) / 2]; 3391 } pip = { 3392 .ip = { 3393 .ip_p = IPPROTO_UDP, 3394 .ip_src = ip->ip_src, 3395 .ip_dst = ip->ip_dst, 3396 } 3397 }; 3398 size_t ip_hlen; 3399 struct udphdr udp; 3400 char *udpp, *uh_sump; 3401 uint32_t csum; 3402 3403 if (from != NULL) 3404 from->s_addr = ip->ip_src.s_addr; 3405 3406 ip_hlen = (size_t)ip->ip_hl * 4; 3407 if (in_cksum(ip, ip_hlen, NULL) != 0) 3408 return false; 3409 3410 if (flags & BPF_PARTIALCSUM) 3411 return true; 3412 3413 udpp = (char *)ip + ip_hlen; 3414 memcpy(&udp, udpp, sizeof(udp)); 3415 if (udp.uh_sum == 0) 3416 return true; 3417 3418 /* UDP checksum is based on a pseudo IP header alongside 3419 * the UDP header and payload. */ 3420 pip.ip.ip_len = udp.uh_ulen; 3421 csum = 0; 3422 3423 /* Need to zero the UDP sum in the packet for the checksum to work. */ 3424 uh_sump = udpp + offsetof(struct udphdr, uh_sum); 3425 memset(uh_sump, 0, sizeof(udp.uh_sum)); 3426 3427 /* Checksum pseudo header and then UDP + payload. */ 3428 in_cksum(pip.w, sizeof(pip.w), &csum); 3429 csum = in_cksum(udpp, ntohs(udp.uh_ulen), &csum); 3430 3431 #if 0 /* Not needed, just here for completeness. */ 3432 /* Put the checksum back. */ 3433 memcpy(uh_sump, &udp.uh_sum, sizeof(udp.uh_sum)); 3434 #endif 3435 3436 return csum == udp.uh_sum; 3437 } 3438 3439 static void 3440 dhcp_handlebootp(struct interface *ifp, struct bootp *bootp, size_t len, 3441 struct in_addr *from) 3442 { 3443 size_t v; 3444 3445 if (len < offsetof(struct bootp, vend)) { 3446 logerrx("%s: truncated packet (%zu) from %s", 3447 ifp->name, len, inet_ntoa(*from)); 3448 return; 3449 } 3450 3451 /* Unlikely, but appeases sanitizers. */ 3452 if (len > FRAMELEN_MAX) { 3453 logerrx("%s: packet exceeded frame length (%zu) from %s", 3454 ifp->name, len, inet_ntoa(*from)); 3455 return; 3456 } 3457 3458 /* To make our IS_DHCP macro easy, ensure the vendor 3459 * area has at least 4 octets. */ 3460 v = len - offsetof(struct bootp, vend); 3461 while (v < 4) { 3462 bootp->vend[v++] = '\0'; 3463 len++; 3464 } 3465 3466 dhcp_handledhcp(ifp, bootp, len, from); 3467 } 3468 3469 void 3470 dhcp_packet(struct interface *ifp, uint8_t *data, size_t len, 3471 unsigned int bpf_flags) 3472 { 3473 struct bootp *bootp; 3474 struct in_addr from; 3475 size_t udp_len; 3476 size_t fl = bpf_frame_header_len(ifp); 3477 #ifdef PRIVSEP 3478 const struct dhcp_state *state = D_CSTATE(ifp); 3479 3480 /* It's possible that an interface departs and arrives in short 3481 * order to receive a BPF frame out of order. 3482 * There is a similar check in ARP, but much lower down the stack. 3483 * It's not needed for other inet protocols because we send the 3484 * message as a whole and select the interface off that and then 3485 * check state. BPF on the other hand is very interface 3486 * specific and we do need this check. */ 3487 if (state == NULL) 3488 return; 3489 3490 /* Ignore double reads */ 3491 if (IN_PRIVSEP(ifp->ctx)) { 3492 switch (state->state) { 3493 case DHS_BOUND: /* FALLTHROUGH */ 3494 case DHS_RENEW: 3495 return; 3496 default: 3497 break; 3498 } 3499 } 3500 #endif 3501 3502 /* Trim frame header */ 3503 if (fl != 0) { 3504 if (len < fl) { 3505 logerrx("%s: %s: short frame header %zu", 3506 __func__, ifp->name, len); 3507 return; 3508 } 3509 len -= fl; 3510 /* Move the data to avoid alignment errors. */ 3511 memmove(data, data + fl, len); 3512 } 3513 3514 /* Validate filter. */ 3515 if (!is_packet_udp_bootp(data, len)) { 3516 #ifdef BPF_DEBUG 3517 logerrx("%s: DHCP BPF validation failure", ifp->name); 3518 #endif 3519 return; 3520 } 3521 3522 if (!checksums_valid(data, &from, bpf_flags)) { 3523 logerrx("%s: checksum failure from %s", 3524 ifp->name, inet_ntoa(from)); 3525 return; 3526 } 3527 3528 /* 3529 * DHCP has a variable option area rather than a fixed vendor area. 3530 * Because DHCP uses the BOOTP protocol it should still send BOOTP 3531 * sized packets to be RFC compliant. 3532 * However some servers send a truncated vendor area. 3533 * dhcpcd can work fine without the vendor area being sent. 3534 */ 3535 bootp = get_udp_data(data, &udp_len); 3536 dhcp_handlebootp(ifp, bootp, udp_len, &from); 3537 } 3538 3539 static void 3540 dhcp_readbpf(void *arg) 3541 { 3542 struct interface *ifp = arg; 3543 uint8_t buf[FRAMELEN_MAX]; 3544 ssize_t bytes; 3545 struct dhcp_state *state = D_STATE(ifp); 3546 struct bpf *bpf = state->bpf; 3547 3548 bpf->bpf_flags &= ~BPF_EOF; 3549 while (!(bpf->bpf_flags & BPF_EOF)) { 3550 bytes = bpf_read(bpf, buf, sizeof(buf)); 3551 if (bytes == -1) { 3552 if (state->state != DHS_NONE) { 3553 logerr("%s: %s", __func__, ifp->name); 3554 dhcp_close(ifp); 3555 } 3556 break; 3557 } 3558 dhcp_packet(ifp, buf, (size_t)bytes, bpf->bpf_flags); 3559 /* Check we still have a state after processing. */ 3560 if ((state = D_STATE(ifp)) == NULL) 3561 break; 3562 if ((bpf = state->bpf) == NULL) 3563 break; 3564 } 3565 } 3566 3567 void 3568 dhcp_recvmsg(struct dhcpcd_ctx *ctx, struct msghdr *msg) 3569 { 3570 struct sockaddr_in *from = (struct sockaddr_in *)msg->msg_name; 3571 struct iovec *iov = &msg->msg_iov[0]; 3572 struct interface *ifp; 3573 const struct dhcp_state *state; 3574 3575 ifp = if_findifpfromcmsg(ctx, msg, NULL); 3576 if (ifp == NULL) { 3577 logerr(__func__); 3578 return; 3579 } 3580 state = D_CSTATE(ifp); 3581 if (state == NULL) { 3582 /* Try re-directing it to another interface. */ 3583 dhcp_redirect_dhcp(ifp, (struct bootp *)iov->iov_base, 3584 iov->iov_len, &from->sin_addr); 3585 return; 3586 } 3587 3588 if (state->bpf != NULL) { 3589 /* Avoid a duplicate read if BPF is open for the interface. */ 3590 return; 3591 } 3592 #ifdef PRIVSEP 3593 if (IN_PRIVSEP(ctx)) { 3594 switch (state->state) { 3595 case DHS_BOUND: /* FALLTHROUGH */ 3596 case DHS_RENEW: 3597 break; 3598 default: 3599 /* Any other state we ignore it or will receive 3600 * via BPF. */ 3601 return; 3602 } 3603 } 3604 #endif 3605 3606 dhcp_handlebootp(ifp, iov->iov_base, iov->iov_len, 3607 &from->sin_addr); 3608 } 3609 3610 static void 3611 dhcp_readudp(struct dhcpcd_ctx *ctx, struct interface *ifp) 3612 { 3613 const struct dhcp_state *state; 3614 struct sockaddr_in from; 3615 union { 3616 struct bootp bootp; 3617 uint8_t buf[10 * 1024]; /* Maximum MTU */ 3618 } iovbuf; 3619 struct iovec iov = { 3620 .iov_base = iovbuf.buf, 3621 .iov_len = sizeof(iovbuf.buf), 3622 }; 3623 union { 3624 struct cmsghdr hdr; 3625 #ifdef IP_RECVIF 3626 uint8_t buf[CMSG_SPACE(sizeof(struct sockaddr_dl))]; 3627 #else 3628 uint8_t buf[CMSG_SPACE(sizeof(struct in_pktinfo))]; 3629 #endif 3630 } cmsgbuf = { .buf = { 0 } }; 3631 struct msghdr msg = { 3632 .msg_name = &from, .msg_namelen = sizeof(from), 3633 .msg_iov = &iov, .msg_iovlen = 1, 3634 .msg_control = cmsgbuf.buf, .msg_controllen = sizeof(cmsgbuf.buf), 3635 }; 3636 int s; 3637 ssize_t bytes; 3638 3639 if (ifp != NULL) { 3640 state = D_CSTATE(ifp); 3641 s = state->udp_rfd; 3642 } else 3643 s = ctx->udp_rfd; 3644 3645 bytes = recvmsg(s, &msg, 0); 3646 if (bytes == -1) { 3647 logerr(__func__); 3648 return; 3649 } 3650 3651 iov.iov_len = (size_t)bytes; 3652 dhcp_recvmsg(ctx, &msg); 3653 } 3654 3655 static void 3656 dhcp_handleudp(void *arg) 3657 { 3658 struct dhcpcd_ctx *ctx = arg; 3659 3660 dhcp_readudp(ctx, NULL); 3661 } 3662 3663 static void 3664 dhcp_handleifudp(void *arg) 3665 { 3666 struct interface *ifp = arg; 3667 3668 dhcp_readudp(ifp->ctx, ifp); 3669 } 3670 3671 static int 3672 dhcp_openbpf(struct interface *ifp) 3673 { 3674 struct dhcp_state *state; 3675 3676 state = D_STATE(ifp); 3677 3678 #ifdef PRIVSEP 3679 if (IN_PRIVSEP_SE(ifp->ctx)) { 3680 if (ps_bpf_openbootp(ifp) == -1) { 3681 logerr(__func__); 3682 return -1; 3683 } 3684 return 0; 3685 } 3686 #endif 3687 3688 if (state->bpf != NULL) 3689 return 0; 3690 3691 state->bpf = bpf_open(ifp, bpf_bootp, NULL); 3692 if (state->bpf == NULL) { 3693 if (errno == ENOENT) { 3694 logerrx("%s not found", bpf_name); 3695 /* May as well disable IPv4 entirely at 3696 * this point as we really need it. */ 3697 ifp->options->options &= ~DHCPCD_IPV4; 3698 } else 3699 logerr("%s: %s", __func__, ifp->name); 3700 return -1; 3701 } 3702 3703 eloop_event_add(ifp->ctx->eloop, 3704 state->bpf->bpf_fd, dhcp_readbpf, ifp); 3705 return 0; 3706 } 3707 3708 void 3709 dhcp_free(struct interface *ifp) 3710 { 3711 struct dhcp_state *state = D_STATE(ifp); 3712 struct dhcpcd_ctx *ctx; 3713 3714 dhcp_close(ifp); 3715 #ifdef ARP 3716 arp_drop(ifp); 3717 #endif 3718 if (state) { 3719 state->state = DHS_NONE; 3720 free(state->old); 3721 free(state->new); 3722 free(state->offer); 3723 free(state->clientid); 3724 free(state); 3725 } 3726 3727 ctx = ifp->ctx; 3728 /* If we don't have any more DHCP enabled interfaces, 3729 * close the global socket and release resources */ 3730 if (ctx->ifaces) { 3731 TAILQ_FOREACH(ifp, ctx->ifaces, next) { 3732 state = D_STATE(ifp); 3733 if (state != NULL && state->state != DHS_NONE) 3734 break; 3735 } 3736 } 3737 if (ifp == NULL) { 3738 if (ctx->udp_rfd != -1) { 3739 eloop_event_delete(ctx->eloop, ctx->udp_rfd); 3740 close(ctx->udp_rfd); 3741 ctx->udp_rfd = -1; 3742 } 3743 if (ctx->udp_wfd != -1) { 3744 close(ctx->udp_wfd); 3745 ctx->udp_wfd = -1; 3746 } 3747 3748 free(ctx->opt_buffer); 3749 ctx->opt_buffer = NULL; 3750 } 3751 } 3752 3753 static int 3754 dhcp_initstate(struct interface *ifp) 3755 { 3756 struct dhcp_state *state; 3757 3758 state = D_STATE(ifp); 3759 if (state != NULL) 3760 return 0; 3761 3762 ifp->if_data[IF_DATA_DHCP] = calloc(1, sizeof(*state)); 3763 state = D_STATE(ifp); 3764 if (state == NULL) 3765 return -1; 3766 3767 state->state = DHS_NONE; 3768 /* 0 is a valid fd, so init to -1 */ 3769 state->udp_rfd = -1; 3770 #ifdef ARPING 3771 state->arping_index = -1; 3772 #endif 3773 return 1; 3774 } 3775 3776 static int 3777 dhcp_init(struct interface *ifp) 3778 { 3779 struct dhcp_state *state; 3780 struct if_options *ifo; 3781 uint8_t len; 3782 char buf[(sizeof(ifo->clientid) - 1) * 3]; 3783 3784 if (dhcp_initstate(ifp) == -1) 3785 return -1; 3786 3787 state = D_STATE(ifp); 3788 state->state = DHS_INIT; 3789 state->reason = "PREINIT"; 3790 state->nakoff = 0; 3791 dhcp_set_leasefile(state->leasefile, sizeof(state->leasefile), 3792 AF_INET, ifp); 3793 3794 ifo = ifp->options; 3795 /* We need to drop the leasefile so that dhcp_start 3796 * doesn't load it. */ 3797 if (ifo->options & DHCPCD_REQUEST) 3798 dhcp_unlink(ifp->ctx, state->leasefile); 3799 3800 free(state->clientid); 3801 state->clientid = NULL; 3802 3803 if (ifo->options & DHCPCD_ANONYMOUS) { 3804 uint8_t duid[DUID_LEN]; 3805 uint8_t duid_len; 3806 3807 duid_len = (uint8_t)duid_make(duid, ifp, DUID_LL); 3808 if (duid_len != 0) { 3809 state->clientid = malloc((size_t)duid_len + 6); 3810 if (state->clientid == NULL) 3811 goto eexit; 3812 state->clientid[0] =(uint8_t)(duid_len + 5); 3813 state->clientid[1] = 255; /* RFC 4361 */ 3814 memcpy(state->clientid + 2, ifo->iaid, 4); 3815 memset(state->clientid + 2, 0, 4); /* IAID */ 3816 memcpy(state->clientid + 6, duid, duid_len); 3817 } 3818 } else if (*ifo->clientid) { 3819 state->clientid = malloc((size_t)(ifo->clientid[0] + 1)); 3820 if (state->clientid == NULL) 3821 goto eexit; 3822 memcpy(state->clientid, ifo->clientid, 3823 (size_t)(ifo->clientid[0]) + 1); 3824 } else if (ifo->options & DHCPCD_CLIENTID) { 3825 if (ifo->options & DHCPCD_DUID) { 3826 state->clientid = malloc(ifp->ctx->duid_len + 6); 3827 if (state->clientid == NULL) 3828 goto eexit; 3829 state->clientid[0] =(uint8_t)(ifp->ctx->duid_len + 5); 3830 state->clientid[1] = 255; /* RFC 4361 */ 3831 memcpy(state->clientid + 2, ifo->iaid, 4); 3832 memcpy(state->clientid + 6, ifp->ctx->duid, 3833 ifp->ctx->duid_len); 3834 } else { 3835 len = (uint8_t)(ifp->hwlen + 1); 3836 state->clientid = malloc((size_t)len + 1); 3837 if (state->clientid == NULL) 3838 goto eexit; 3839 state->clientid[0] = len; 3840 state->clientid[1] = (uint8_t)ifp->hwtype; 3841 memcpy(state->clientid + 2, ifp->hwaddr, 3842 ifp->hwlen); 3843 } 3844 } 3845 3846 if (ifo->options & DHCPCD_DUID) 3847 /* Don't bother logging as DUID and IAID are reported 3848 * at device start. */ 3849 return 0; 3850 3851 if (ifo->options & DHCPCD_CLIENTID && state->clientid != NULL) 3852 logdebugx("%s: using ClientID %s", ifp->name, 3853 hwaddr_ntoa(state->clientid + 1, state->clientid[0], 3854 buf, sizeof(buf))); 3855 else if (ifp->hwlen) 3856 logdebugx("%s: using hwaddr %s", ifp->name, 3857 hwaddr_ntoa(ifp->hwaddr, ifp->hwlen, buf, sizeof(buf))); 3858 return 0; 3859 3860 eexit: 3861 logerr(__func__); 3862 return -1; 3863 } 3864 3865 static void 3866 dhcp_start1(void *arg) 3867 { 3868 struct interface *ifp = arg; 3869 struct dhcpcd_ctx *ctx = ifp->ctx; 3870 struct if_options *ifo = ifp->options; 3871 struct dhcp_state *state; 3872 uint32_t l; 3873 int nolease; 3874 3875 if (!(ifo->options & DHCPCD_IPV4)) 3876 return; 3877 3878 /* Listen on *.*.*.*:bootpc so that the kernel never sends an 3879 * ICMP port unreachable message back to the DHCP server. 3880 * Only do this in master mode so we don't swallow messages 3881 * for dhcpcd running on another interface. */ 3882 if ((ctx->options & (DHCPCD_MASTER|DHCPCD_PRIVSEP)) == DHCPCD_MASTER 3883 && ctx->udp_rfd == -1) 3884 { 3885 ctx->udp_rfd = dhcp_openudp(NULL); 3886 if (ctx->udp_rfd == -1) { 3887 logerr(__func__); 3888 return; 3889 } 3890 eloop_event_add(ctx->eloop, ctx->udp_rfd, dhcp_handleudp, ctx); 3891 } 3892 if (!IN_PRIVSEP(ctx) && ctx->udp_wfd == -1) { 3893 ctx->udp_wfd = xsocket(PF_INET, SOCK_RAW|SOCK_CXNB,IPPROTO_UDP); 3894 if (ctx->udp_wfd == -1) { 3895 logerr(__func__); 3896 return; 3897 } 3898 } 3899 3900 if (dhcp_init(ifp) == -1) { 3901 logerr("%s: dhcp_init", ifp->name); 3902 return; 3903 } 3904 3905 state = D_STATE(ifp); 3906 clock_gettime(CLOCK_MONOTONIC, &state->started); 3907 state->interval = 0; 3908 free(state->offer); 3909 state->offer = NULL; 3910 state->offer_len = 0; 3911 3912 #ifdef ARPING 3913 if (ifo->arping_len && state->arping_index < ifo->arping_len) { 3914 dhcp_arping(ifp); 3915 return; 3916 } 3917 #endif 3918 3919 if (ifo->options & DHCPCD_STATIC) { 3920 dhcp_static(ifp); 3921 return; 3922 } 3923 3924 if (ifo->options & DHCPCD_INFORM) { 3925 dhcp_inform(ifp); 3926 return; 3927 } 3928 3929 /* We don't want to read the old lease if we NAK an old test */ 3930 nolease = state->offer && ifp->ctx->options & DHCPCD_TEST; 3931 if (!nolease && ifo->options & DHCPCD_DHCP) { 3932 state->offer_len = read_lease(ifp, &state->offer); 3933 /* Check the saved lease matches the type we want */ 3934 if (state->offer) { 3935 #ifdef IN_IFF_DUPLICATED 3936 struct in_addr addr; 3937 struct ipv4_addr *ia; 3938 3939 addr.s_addr = state->offer->yiaddr; 3940 ia = ipv4_iffindaddr(ifp, &addr, NULL); 3941 #endif 3942 3943 if ((!IS_DHCP(state->offer) && 3944 !(ifo->options & DHCPCD_BOOTP)) || 3945 #ifdef IN_IFF_DUPLICATED 3946 (ia && ia->addr_flags & IN_IFF_DUPLICATED) || 3947 #endif 3948 (IS_DHCP(state->offer) && 3949 ifo->options & DHCPCD_BOOTP)) 3950 { 3951 free(state->offer); 3952 state->offer = NULL; 3953 state->offer_len = 0; 3954 } 3955 } 3956 } 3957 if (state->offer) { 3958 struct ipv4_addr *ia; 3959 time_t mtime; 3960 3961 get_lease(ifp, &state->lease, state->offer, state->offer_len); 3962 state->lease.frominfo = 1; 3963 if (state->new == NULL && 3964 (ia = ipv4_iffindaddr(ifp, 3965 &state->lease.addr, &state->lease.mask)) != NULL) 3966 { 3967 /* We still have the IP address from the last lease. 3968 * Fake add the address and routes from it so the lease 3969 * can be cleaned up. */ 3970 state->new = malloc(state->offer_len); 3971 if (state->new) { 3972 memcpy(state->new, 3973 state->offer, state->offer_len); 3974 state->new_len = state->offer_len; 3975 state->addr = ia; 3976 state->added |= STATE_ADDED | STATE_FAKE; 3977 rt_build(ifp->ctx, AF_INET); 3978 } else 3979 logerr(__func__); 3980 } 3981 if (!IS_DHCP(state->offer)) { 3982 free(state->offer); 3983 state->offer = NULL; 3984 state->offer_len = 0; 3985 } else if (!(ifo->options & DHCPCD_LASTLEASE_EXTEND) && 3986 state->lease.leasetime != DHCP_INFINITE_LIFETIME && 3987 dhcp_filemtime(ifp->ctx, state->leasefile, &mtime) == 0) 3988 { 3989 time_t now; 3990 3991 /* Offset lease times and check expiry */ 3992 now = time(NULL); 3993 if (now == -1 || 3994 (time_t)state->lease.leasetime < now - mtime) 3995 { 3996 logdebugx("%s: discarding expired lease", 3997 ifp->name); 3998 free(state->offer); 3999 state->offer = NULL; 4000 state->offer_len = 0; 4001 state->lease.addr.s_addr = 0; 4002 /* Technically we should discard the lease 4003 * as it's expired, just as DHCPv6 addresses 4004 * would be by the kernel. 4005 * However, this may violate POLA so 4006 * we currently leave it be. 4007 * If we get a totally different lease from 4008 * the DHCP server we'll drop it anyway, as 4009 * we will on any other event which would 4010 * trigger a lease drop. 4011 * This should only happen if dhcpcd stops 4012 * running and the lease expires before 4013 * dhcpcd starts again. */ 4014 #if 0 4015 if (state->new) 4016 dhcp_drop(ifp, "EXPIRE"); 4017 #endif 4018 } else { 4019 l = (uint32_t)(now - mtime); 4020 state->lease.leasetime -= l; 4021 state->lease.renewaltime -= l; 4022 state->lease.rebindtime -= l; 4023 } 4024 } 4025 } 4026 4027 #ifdef IPV4LL 4028 if (!(ifo->options & DHCPCD_DHCP)) { 4029 if (ifo->options & DHCPCD_IPV4LL) 4030 ipv4ll_start(ifp); 4031 return; 4032 } 4033 #endif 4034 4035 if (state->offer == NULL || 4036 !IS_DHCP(state->offer) || 4037 ifo->options & DHCPCD_ANONYMOUS) 4038 dhcp_discover(ifp); 4039 else 4040 dhcp_reboot(ifp); 4041 } 4042 4043 void 4044 dhcp_start(struct interface *ifp) 4045 { 4046 unsigned int delay; 4047 #ifdef ARPING 4048 const struct dhcp_state *state; 4049 #endif 4050 4051 if (!(ifp->options->options & DHCPCD_IPV4)) 4052 return; 4053 4054 /* If we haven't been given a netmask for our requested address, 4055 * set it now. */ 4056 if (ifp->options->req_addr.s_addr != INADDR_ANY && 4057 ifp->options->req_mask.s_addr == INADDR_ANY) 4058 ifp->options->req_mask.s_addr = 4059 ipv4_getnetmask(ifp->options->req_addr.s_addr); 4060 4061 /* If we haven't specified a ClientID and our hardware address 4062 * length is greater than BOOTP CHADDR then we enforce a ClientID 4063 * of the hardware address type and the hardware address. 4064 * If there is no hardware address and no ClientID set, 4065 * force a DUID based ClientID. */ 4066 if (ifp->hwlen > 16) 4067 ifp->options->options |= DHCPCD_CLIENTID; 4068 else if (ifp->hwlen == 0 && !(ifp->options->options & DHCPCD_CLIENTID)) 4069 ifp->options->options |= DHCPCD_CLIENTID | DHCPCD_DUID; 4070 4071 /* Firewire and InfiniBand interfaces require ClientID and 4072 * the broadcast option being set. */ 4073 switch (ifp->hwtype) { 4074 case ARPHRD_IEEE1394: /* FALLTHROUGH */ 4075 case ARPHRD_INFINIBAND: 4076 ifp->options->options |= DHCPCD_CLIENTID | DHCPCD_BROADCAST; 4077 break; 4078 } 4079 4080 /* If we violate RFC2131 section 3.7 then require ARP 4081 * to detect if any other client wants our address. */ 4082 if (ifp->options->options & DHCPCD_LASTLEASE_EXTEND) 4083 ifp->options->options |= DHCPCD_ARP; 4084 4085 /* No point in delaying a static configuration */ 4086 if (ifp->options->options & DHCPCD_STATIC || 4087 !(ifp->options->options & DHCPCD_INITIAL_DELAY)) 4088 { 4089 dhcp_start1(ifp); 4090 return; 4091 } 4092 4093 #ifdef ARPING 4094 /* If we have arpinged then we have already delayed. */ 4095 state = D_CSTATE(ifp); 4096 if (state != NULL && state->arping_index != -1) { 4097 dhcp_start1(ifp); 4098 return; 4099 } 4100 #endif 4101 delay = MSEC_PER_SEC + 4102 (arc4random_uniform(MSEC_PER_SEC * 2) - MSEC_PER_SEC); 4103 logdebugx("%s: delaying IPv4 for %0.1f seconds", 4104 ifp->name, (float)delay / MSEC_PER_SEC); 4105 4106 eloop_timeout_add_msec(ifp->ctx->eloop, delay, dhcp_start1, ifp); 4107 } 4108 4109 void 4110 dhcp_abort(struct interface *ifp) 4111 { 4112 struct dhcp_state *state; 4113 4114 state = D_STATE(ifp); 4115 #ifdef ARPING 4116 if (state != NULL) 4117 state->arping_index = -1; 4118 #endif 4119 4120 eloop_timeout_delete(ifp->ctx->eloop, dhcp_start1, ifp); 4121 4122 if (state != NULL && state->added) { 4123 rt_build(ifp->ctx, AF_INET); 4124 #ifdef ARP 4125 if (ifp->options->options & DHCPCD_ARP) 4126 arp_announceaddr(ifp->ctx, &state->addr->addr); 4127 #endif 4128 } 4129 } 4130 4131 struct ipv4_addr * 4132 dhcp_handleifa(int cmd, struct ipv4_addr *ia, pid_t pid) 4133 { 4134 struct interface *ifp; 4135 struct dhcp_state *state; 4136 struct if_options *ifo; 4137 uint8_t i; 4138 4139 ifp = ia->iface; 4140 state = D_STATE(ifp); 4141 if (state == NULL || state->state == DHS_NONE) 4142 return ia; 4143 4144 if (cmd == RTM_DELADDR) { 4145 if (state->addr == ia) { 4146 loginfox("%s: pid %d deleted IP address %s", 4147 ifp->name, pid, ia->saddr); 4148 dhcp_close(ifp); 4149 state->addr = NULL; 4150 /* Don't clear the added state as we need 4151 * to drop the lease. */ 4152 dhcp_drop(ifp, "EXPIRE"); 4153 dhcp_start1(ifp); 4154 return ia; 4155 } 4156 } 4157 4158 if (cmd != RTM_NEWADDR) 4159 return ia; 4160 4161 #ifdef IN_IFF_NOTUSEABLE 4162 if (!(ia->addr_flags & IN_IFF_NOTUSEABLE)) 4163 dhcp_finish_dad(ifp, &ia->addr); 4164 else if (ia->addr_flags & IN_IFF_DUPLICATED) 4165 return dhcp_addr_duplicated(ifp, &ia->addr) ? NULL : ia; 4166 #endif 4167 4168 ifo = ifp->options; 4169 if (ifo->options & DHCPCD_INFORM) { 4170 if (state->state != DHS_INFORM) 4171 dhcp_inform(ifp); 4172 return ia; 4173 } 4174 4175 if (!(ifo->options & DHCPCD_STATIC)) 4176 return ia; 4177 if (ifo->req_addr.s_addr != INADDR_ANY) 4178 return ia; 4179 4180 free(state->old); 4181 state->old = state->new; 4182 state->new_len = dhcp_message_new(&state->new, &ia->addr, &ia->mask); 4183 if (state->new == NULL) 4184 return ia; 4185 if (ifp->flags & IFF_POINTOPOINT) { 4186 for (i = 1; i < 255; i++) 4187 if (i != DHO_ROUTER && has_option_mask(ifo->dstmask,i)) 4188 dhcp_message_add_addr(state->new, i, ia->brd); 4189 } 4190 state->reason = "STATIC"; 4191 rt_build(ifp->ctx, AF_INET); 4192 script_runreason(ifp, state->reason); 4193 if (ifo->options & DHCPCD_INFORM) { 4194 state->state = DHS_INFORM; 4195 dhcp_new_xid(ifp); 4196 state->lease.server.s_addr = INADDR_ANY; 4197 state->addr = ia; 4198 dhcp_inform(ifp); 4199 } 4200 4201 return ia; 4202 } 4203 4204 #ifndef SMALL 4205 int 4206 dhcp_dump(struct interface *ifp) 4207 { 4208 struct dhcp_state *state; 4209 4210 ifp->if_data[IF_DATA_DHCP] = state = calloc(1, sizeof(*state)); 4211 if (state == NULL) { 4212 logerr(__func__); 4213 return -1; 4214 } 4215 state->new_len = read_lease(ifp, &state->new); 4216 if (state->new == NULL) { 4217 logerr("read_lease"); 4218 return -1; 4219 } 4220 state->reason = "DUMP"; 4221 return script_runreason(ifp, state->reason); 4222 } 4223 #endif 4224