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)))) 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 || 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 (ifp->carrier <= LINK_DOWN) 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 (ifp->carrier <= LINK_DOWN) 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) && 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 (ifo->fallback) 1873 eloop_timeout_add_sec(ifp->ctx->eloop, 1874 ifo->reboot, dhcp_fallback, ifp); 1875 #ifdef IPV4LL 1876 else if (ifo->options & DHCPCD_IPV4LL) 1877 eloop_timeout_add_sec(ifp->ctx->eloop, 1878 ifo->reboot, ipv4ll_start, ifp); 1879 #endif 1880 if (ifo->options & DHCPCD_REQUEST) 1881 loginfox("%s: soliciting a DHCP lease (requesting %s)", 1882 ifp->name, inet_ntoa(ifo->req_addr)); 1883 else 1884 loginfox("%s: soliciting a %s lease", 1885 ifp->name, ifo->options & DHCPCD_BOOTP ? "BOOTP" : "DHCP"); 1886 send_discover(ifp); 1887 } 1888 1889 static void 1890 dhcp_request(void *arg) 1891 { 1892 struct interface *ifp = arg; 1893 struct dhcp_state *state = D_STATE(ifp); 1894 1895 state->state = DHS_REQUEST; 1896 send_request(ifp); 1897 } 1898 1899 static void 1900 dhcp_expire1(struct interface *ifp) 1901 { 1902 struct dhcp_state *state = D_STATE(ifp); 1903 1904 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp); 1905 dhcp_drop(ifp, "EXPIRE"); 1906 dhcp_unlink(ifp->ctx, state->leasefile); 1907 state->interval = 0; 1908 if (!(ifp->options->options & DHCPCD_LINK) || ifp->carrier > LINK_DOWN) 1909 dhcp_discover(ifp); 1910 } 1911 1912 static void 1913 dhcp_expire(void *arg) 1914 { 1915 struct interface *ifp = arg; 1916 1917 if (ifp->options->options & DHCPCD_LASTLEASE_EXTEND) { 1918 logwarnx("%s: DHCP lease expired, extending lease", ifp->name); 1919 return; 1920 } 1921 1922 logerrx("%s: DHCP lease expired", ifp->name); 1923 dhcp_expire1(ifp); 1924 } 1925 1926 #if defined(ARP) || defined(IN_IFF_DUPLICATED) 1927 static void 1928 dhcp_decline(struct interface *ifp) 1929 { 1930 1931 send_message(ifp, DHCP_DECLINE, NULL); 1932 } 1933 #endif 1934 1935 static void 1936 dhcp_startrenew(void *arg) 1937 { 1938 struct interface *ifp = arg; 1939 struct dhcp_state *state; 1940 struct dhcp_lease *lease; 1941 1942 if ((state = D_STATE(ifp)) == NULL) 1943 return; 1944 1945 /* Only renew in the bound or renew states */ 1946 if (state->state != DHS_BOUND && 1947 state->state != DHS_RENEW) 1948 return; 1949 1950 /* Remove the timeout as the renew may have been forced. */ 1951 eloop_timeout_delete(ifp->ctx->eloop, dhcp_startrenew, ifp); 1952 1953 lease = &state->lease; 1954 logdebugx("%s: renewing lease of %s", ifp->name, 1955 inet_ntoa(lease->addr)); 1956 state->state = DHS_RENEW; 1957 dhcp_new_xid(ifp); 1958 state->interval = 0; 1959 send_renew(ifp); 1960 } 1961 1962 void 1963 dhcp_renew(struct interface *ifp) 1964 { 1965 1966 dhcp_startrenew(ifp); 1967 } 1968 1969 static void 1970 dhcp_rebind(void *arg) 1971 { 1972 struct interface *ifp = arg; 1973 struct dhcp_state *state = D_STATE(ifp); 1974 struct dhcp_lease *lease = &state->lease; 1975 1976 logwarnx("%s: failed to renew DHCP, rebinding", ifp->name); 1977 logdebugx("%s: expire in %"PRIu32" seconds", 1978 ifp->name, lease->leasetime - lease->rebindtime); 1979 state->state = DHS_REBIND; 1980 eloop_timeout_delete(ifp->ctx->eloop, send_renew, ifp); 1981 state->lease.server.s_addr = INADDR_ANY; 1982 state->interval = 0; 1983 ifp->options->options &= ~(DHCPCD_CSR_WARNED | 1984 DHCPCD_ROUTER_HOST_ROUTE_WARNED); 1985 send_rebind(ifp); 1986 } 1987 1988 #if defined(ARP) || defined(IN_IFF_DUPLICATED) 1989 static void 1990 dhcp_finish_dad(struct interface *ifp, struct in_addr *ia) 1991 { 1992 struct dhcp_state *state = D_STATE(ifp); 1993 1994 if (state->state != DHS_PROBE) 1995 return; 1996 if (state->offer == NULL || state->offer->yiaddr != ia->s_addr) 1997 return; 1998 1999 logdebugx("%s: DAD completed for %s", ifp->name, inet_ntoa(*ia)); 2000 if (!(ifp->options->options & DHCPCD_INFORM)) 2001 dhcp_bind(ifp); 2002 #ifndef IN_IFF_DUPLICATED 2003 else { 2004 struct bootp *bootp; 2005 size_t len; 2006 2007 bootp = state->new; 2008 len = state->new_len; 2009 state->new = state->offer; 2010 state->new_len = state->offer_len; 2011 get_lease(ifp, &state->lease, state->new, state->new_len); 2012 ipv4_applyaddr(ifp); 2013 state->new = bootp; 2014 state->new_len = len; 2015 } 2016 #endif 2017 2018 #ifdef IPV4LL 2019 /* Stop IPv4LL now we have a working DHCP address */ 2020 ipv4ll_drop(ifp); 2021 #endif 2022 2023 if (ifp->options->options & DHCPCD_INFORM) 2024 dhcp_inform(ifp); 2025 } 2026 2027 2028 static bool 2029 dhcp_addr_duplicated(struct interface *ifp, struct in_addr *ia) 2030 { 2031 struct dhcp_state *state = D_STATE(ifp); 2032 unsigned long long opts = ifp->options->options; 2033 struct dhcpcd_ctx *ctx = ifp->ctx; 2034 bool deleted = false; 2035 #ifdef IN_IFF_DUPLICATED 2036 struct ipv4_addr *iap; 2037 #endif 2038 2039 if ((state->offer == NULL || state->offer->yiaddr != ia->s_addr) && 2040 !IN_ARE_ADDR_EQUAL(ia, &state->lease.addr)) 2041 return deleted; 2042 2043 /* RFC 2131 3.1.5, Client-server interaction */ 2044 logerrx("%s: DAD detected %s", ifp->name, inet_ntoa(*ia)); 2045 dhcp_unlink(ifp->ctx, state->leasefile); 2046 if (!(opts & DHCPCD_STATIC) && !state->lease.frominfo) 2047 dhcp_decline(ifp); 2048 #ifdef IN_IFF_DUPLICATED 2049 if ((iap = ipv4_iffindaddr(ifp, ia, NULL)) != NULL) { 2050 ipv4_deladdr(iap, 0); 2051 deleted = true; 2052 } 2053 #endif 2054 eloop_timeout_delete(ctx->eloop, NULL, ifp); 2055 if (opts & (DHCPCD_STATIC | DHCPCD_INFORM)) { 2056 state->reason = "EXPIRE"; 2057 script_runreason(ifp, state->reason); 2058 #define NOT_ONLY_SELF (DHCPCD_MASTER | DHCPCD_IPV6RS | DHCPCD_DHCP6) 2059 if (!(ctx->options & NOT_ONLY_SELF)) 2060 eloop_exit(ifp->ctx->eloop, EXIT_FAILURE); 2061 return deleted; 2062 } 2063 eloop_timeout_add_sec(ifp->ctx->eloop, 2064 DHCP_RAND_MAX, dhcp_discover, ifp); 2065 return deleted; 2066 } 2067 #endif 2068 2069 #ifdef ARP 2070 #ifdef KERNEL_RFC5227 2071 static void 2072 dhcp_arp_announced(struct arp_state *state) 2073 { 2074 2075 arp_free(state); 2076 } 2077 #else 2078 static void 2079 dhcp_arp_defend_failed(struct arp_state *astate) 2080 { 2081 struct interface *ifp = astate->iface; 2082 2083 dhcp_drop(ifp, "EXPIRED"); 2084 dhcp_start1(ifp); 2085 } 2086 #endif 2087 2088 #if !defined(KERNEL_RFC5227) || defined(ARPING) 2089 static void dhcp_arp_not_found(struct arp_state *); 2090 2091 static struct arp_state * 2092 dhcp_arp_new(struct interface *ifp, struct in_addr *addr) 2093 { 2094 struct arp_state *astate; 2095 2096 astate = arp_new(ifp, addr); 2097 if (astate == NULL) 2098 return NULL; 2099 2100 astate->found_cb = dhcp_arp_found; 2101 astate->not_found_cb = dhcp_arp_not_found; 2102 #ifdef KERNEL_RFC5227 2103 astate->announced_cb = dhcp_arp_announced; 2104 #else 2105 astate->announced_cb = NULL; 2106 astate->defend_failed_cb = dhcp_arp_defend_failed; 2107 #endif 2108 return astate; 2109 } 2110 #endif 2111 2112 #ifdef ARPING 2113 static int 2114 dhcp_arping(struct interface *ifp) 2115 { 2116 struct dhcp_state *state; 2117 struct if_options *ifo; 2118 struct arp_state *astate; 2119 struct in_addr addr; 2120 2121 state = D_STATE(ifp); 2122 ifo = ifp->options; 2123 2124 if (ifo->arping_len == 0 || state->arping_index > ifo->arping_len) 2125 return 0; 2126 2127 if (state->arping_index + 1 == ifo->arping_len) { 2128 state->arping_index++; 2129 dhcpcd_startinterface(ifp); 2130 return 1; 2131 } 2132 2133 addr.s_addr = ifo->arping[++state->arping_index]; 2134 astate = dhcp_arp_new(ifp, &addr); 2135 if (astate == NULL) { 2136 logerr(__func__); 2137 return -1; 2138 } 2139 arp_probe(astate); 2140 return 1; 2141 } 2142 #endif 2143 2144 #if !defined(KERNEL_RFC5227) || defined(ARPING) 2145 static void 2146 dhcp_arp_not_found(struct arp_state *astate) 2147 { 2148 struct interface *ifp; 2149 2150 ifp = astate->iface; 2151 #ifdef ARPING 2152 if (dhcp_arping(ifp) == 1) { 2153 arp_free(astate); 2154 return; 2155 } 2156 #endif 2157 2158 dhcp_finish_dad(ifp, &astate->addr); 2159 } 2160 2161 static void 2162 dhcp_arp_found(struct arp_state *astate, const struct arp_msg *amsg) 2163 { 2164 struct in_addr addr; 2165 struct interface *ifp = astate->iface; 2166 #ifdef ARPING 2167 struct dhcp_state *state; 2168 struct if_options *ifo; 2169 2170 state = D_STATE(ifp); 2171 2172 ifo = ifp->options; 2173 if (state->arping_index != -1 && 2174 state->arping_index < ifo->arping_len && 2175 amsg && 2176 amsg->sip.s_addr == ifo->arping[state->arping_index]) 2177 { 2178 char buf[HWADDR_LEN * 3]; 2179 2180 hwaddr_ntoa(amsg->sha, ifp->hwlen, buf, sizeof(buf)); 2181 if (dhcpcd_selectprofile(ifp, buf) == -1 && 2182 dhcpcd_selectprofile(ifp, inet_ntoa(amsg->sip)) == -1) 2183 { 2184 /* We didn't find a profile for this 2185 * address or hwaddr, so move to the next 2186 * arping profile */ 2187 dhcp_arp_not_found(astate); 2188 return; 2189 } 2190 arp_free(astate); 2191 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp); 2192 dhcpcd_startinterface(ifp); 2193 return; 2194 } 2195 #else 2196 UNUSED(amsg); 2197 #endif 2198 2199 addr = astate->addr; 2200 arp_free(astate); 2201 dhcp_addr_duplicated(ifp, &addr); 2202 } 2203 #endif 2204 2205 #endif /* ARP */ 2206 2207 void 2208 dhcp_bind(struct interface *ifp) 2209 { 2210 struct dhcpcd_ctx *ctx = ifp->ctx; 2211 struct dhcp_state *state = D_STATE(ifp); 2212 struct if_options *ifo = ifp->options; 2213 struct dhcp_lease *lease = &state->lease; 2214 uint8_t old_state; 2215 2216 state->reason = NULL; 2217 /* If we don't have an offer, we are re-binding a lease on preference, 2218 * normally when two interfaces have a lease matching IP addresses. */ 2219 if (state->offer) { 2220 free(state->old); 2221 state->old = state->new; 2222 state->old_len = state->new_len; 2223 state->new = state->offer; 2224 state->new_len = state->offer_len; 2225 state->offer = NULL; 2226 state->offer_len = 0; 2227 } 2228 get_lease(ifp, lease, state->new, state->new_len); 2229 if (ifo->options & DHCPCD_STATIC) { 2230 loginfox("%s: using static address %s/%d", 2231 ifp->name, inet_ntoa(lease->addr), 2232 inet_ntocidr(lease->mask)); 2233 lease->leasetime = DHCP_INFINITE_LIFETIME; 2234 state->reason = "STATIC"; 2235 } else if (ifo->options & DHCPCD_INFORM) { 2236 loginfox("%s: received approval for %s", 2237 ifp->name, inet_ntoa(lease->addr)); 2238 lease->leasetime = DHCP_INFINITE_LIFETIME; 2239 state->reason = "INFORM"; 2240 } else { 2241 if (lease->frominfo) 2242 state->reason = "TIMEOUT"; 2243 if (lease->leasetime == DHCP_INFINITE_LIFETIME) { 2244 lease->renewaltime = 2245 lease->rebindtime = 2246 lease->leasetime; 2247 loginfox("%s: leased %s for infinity", 2248 ifp->name, inet_ntoa(lease->addr)); 2249 } else { 2250 if (lease->leasetime < DHCP_MIN_LEASE) { 2251 logwarnx("%s: minimum lease is %d seconds", 2252 ifp->name, DHCP_MIN_LEASE); 2253 lease->leasetime = DHCP_MIN_LEASE; 2254 } 2255 if (lease->rebindtime == 0) 2256 lease->rebindtime = 2257 (uint32_t)(lease->leasetime * T2); 2258 else if (lease->rebindtime >= lease->leasetime) { 2259 lease->rebindtime = 2260 (uint32_t)(lease->leasetime * T2); 2261 logwarnx("%s: rebind time greater than lease " 2262 "time, forcing to %"PRIu32" seconds", 2263 ifp->name, lease->rebindtime); 2264 } 2265 if (lease->renewaltime == 0) 2266 lease->renewaltime = 2267 (uint32_t)(lease->leasetime * T1); 2268 else if (lease->renewaltime > lease->rebindtime) { 2269 lease->renewaltime = 2270 (uint32_t)(lease->leasetime * T1); 2271 logwarnx("%s: renewal time greater than " 2272 "rebind time, forcing to %"PRIu32" seconds", 2273 ifp->name, lease->renewaltime); 2274 } 2275 if (state->state == DHS_RENEW && state->addr && 2276 lease->addr.s_addr == state->addr->addr.s_addr && 2277 !(state->added & STATE_FAKE)) 2278 logdebugx("%s: leased %s for %"PRIu32" seconds", 2279 ifp->name, inet_ntoa(lease->addr), 2280 lease->leasetime); 2281 else 2282 loginfox("%s: leased %s for %"PRIu32" seconds", 2283 ifp->name, inet_ntoa(lease->addr), 2284 lease->leasetime); 2285 } 2286 } 2287 if (ctx->options & DHCPCD_TEST) { 2288 state->reason = "TEST"; 2289 script_runreason(ifp, state->reason); 2290 eloop_exit(ctx->eloop, EXIT_SUCCESS); 2291 return; 2292 } 2293 if (state->reason == NULL) { 2294 if (state->old && !(state->added & STATE_FAKE)) { 2295 if (state->old->yiaddr == state->new->yiaddr && 2296 lease->server.s_addr && 2297 state->state != DHS_REBIND) 2298 state->reason = "RENEW"; 2299 else 2300 state->reason = "REBIND"; 2301 } else if (state->state == DHS_REBOOT) 2302 state->reason = "REBOOT"; 2303 else 2304 state->reason = "BOUND"; 2305 } 2306 if (lease->leasetime == DHCP_INFINITE_LIFETIME) 2307 lease->renewaltime = lease->rebindtime = lease->leasetime; 2308 else { 2309 eloop_timeout_add_sec(ctx->eloop, 2310 lease->renewaltime, dhcp_startrenew, ifp); 2311 eloop_timeout_add_sec(ctx->eloop, 2312 lease->rebindtime, dhcp_rebind, ifp); 2313 eloop_timeout_add_sec(ctx->eloop, 2314 lease->leasetime, dhcp_expire, ifp); 2315 logdebugx("%s: renew in %"PRIu32" seconds, rebind in %"PRIu32 2316 " seconds", 2317 ifp->name, lease->renewaltime, lease->rebindtime); 2318 } 2319 state->state = DHS_BOUND; 2320 if (!state->lease.frominfo && 2321 !(ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC))) { 2322 logdebugx("%s: writing lease `%s'", 2323 ifp->name, state->leasefile); 2324 if (dhcp_writefile(ifp->ctx, state->leasefile, 0640, 2325 state->new, state->new_len) == -1) 2326 logerr("dhcp_writefile: %s", state->leasefile); 2327 } 2328 2329 /* Close the BPF filter as we can now receive DHCP messages 2330 * on a UDP socket. */ 2331 old_state = state->added; 2332 if (ctx->options & DHCPCD_MASTER || 2333 state->old == NULL || 2334 state->old->yiaddr != state->new->yiaddr || old_state & STATE_FAKE) 2335 dhcp_close(ifp); 2336 2337 ipv4_applyaddr(ifp); 2338 2339 /* If not in master mode, open an address specific socket. */ 2340 if (ctx->options & DHCPCD_MASTER || 2341 (state->old != NULL && 2342 state->old->yiaddr == state->new->yiaddr && 2343 old_state & STATE_ADDED && !(old_state & STATE_FAKE))) 2344 return; 2345 2346 #ifdef PRIVSEP 2347 if (IN_PRIVSEP_SE(ctx)) { 2348 if (ps_inet_openbootp(state->addr) == -1) 2349 logerr(__func__); 2350 return; 2351 } 2352 #endif 2353 2354 state->udp_rfd = dhcp_openudp(&state->addr->addr); 2355 if (state->udp_rfd == -1) { 2356 logerr(__func__); 2357 /* Address sharing without master mode is not supported. 2358 * It's also possible another DHCP client could be running, 2359 * which is even worse. 2360 * We still need to work, so re-open BPF. */ 2361 dhcp_openbpf(ifp); 2362 return; 2363 } 2364 eloop_event_add(ctx->eloop, state->udp_rfd, dhcp_handleifudp, ifp); 2365 } 2366 2367 static void 2368 dhcp_lastlease(void *arg) 2369 { 2370 struct interface *ifp = arg; 2371 struct dhcp_state *state = D_STATE(ifp); 2372 2373 loginfox("%s: timed out contacting a DHCP server, using last lease", 2374 ifp->name); 2375 dhcp_bind(ifp); 2376 state->interval = 0; 2377 dhcp_discover(ifp); 2378 } 2379 2380 static size_t 2381 dhcp_message_new(struct bootp **bootp, 2382 const struct in_addr *addr, const struct in_addr *mask) 2383 { 2384 uint8_t *p; 2385 uint32_t cookie; 2386 2387 if ((*bootp = calloc(1, sizeof(**bootp))) == NULL) 2388 return 0; 2389 2390 (*bootp)->yiaddr = addr->s_addr; 2391 p = (*bootp)->vend; 2392 2393 cookie = htonl(MAGIC_COOKIE); 2394 memcpy(p, &cookie, sizeof(cookie)); 2395 p += sizeof(cookie); 2396 2397 if (mask->s_addr != INADDR_ANY) { 2398 *p++ = DHO_SUBNETMASK; 2399 *p++ = sizeof(mask->s_addr); 2400 memcpy(p, &mask->s_addr, sizeof(mask->s_addr)); 2401 p+= sizeof(mask->s_addr); 2402 } 2403 2404 *p = DHO_END; 2405 return sizeof(**bootp); 2406 } 2407 2408 #if defined(ARP) || defined(KERNEL_RFC5227) 2409 static int 2410 dhcp_arp_address(struct interface *ifp) 2411 { 2412 struct dhcp_state *state; 2413 struct in_addr addr; 2414 struct ipv4_addr *ia; 2415 2416 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp); 2417 2418 state = D_STATE(ifp); 2419 addr.s_addr = state->offer->yiaddr == INADDR_ANY ? 2420 state->offer->ciaddr : state->offer->yiaddr; 2421 /* If the interface already has the address configured 2422 * then we can't ARP for duplicate detection. */ 2423 ia = ipv4_iffindaddr(ifp, &addr, NULL); 2424 #ifdef IN_IFF_NOTUSEABLE 2425 if (ia == NULL || ia->addr_flags & IN_IFF_NOTUSEABLE) { 2426 state->state = DHS_PROBE; 2427 if (ia == NULL) { 2428 struct dhcp_lease l; 2429 2430 get_lease(ifp, &l, state->offer, state->offer_len); 2431 /* Add the address now, let the kernel handle DAD. */ 2432 ipv4_addaddr(ifp, &l.addr, &l.mask, &l.brd, 2433 l.leasetime, l.rebindtime); 2434 } else if (ia->addr_flags & IN_IFF_DUPLICATED) 2435 dhcp_addr_duplicated(ifp, &ia->addr); 2436 else 2437 loginfox("%s: waiting for DAD on %s", 2438 ifp->name, inet_ntoa(addr)); 2439 return 0; 2440 } 2441 #else 2442 if (!(ifp->flags & IFF_NOARP) && 2443 ifp->options->options & DHCPCD_ARP) 2444 { 2445 struct arp_state *astate; 2446 struct dhcp_lease l; 2447 2448 /* Even if the address exists, we need to defend it. */ 2449 astate = dhcp_arp_new(ifp, &addr); 2450 if (astate == NULL) 2451 return -1; 2452 2453 if (ia == NULL) { 2454 state->state = DHS_PROBE; 2455 get_lease(ifp, &l, state->offer, state->offer_len); 2456 loginfox("%s: probing address %s/%d", 2457 ifp->name, inet_ntoa(l.addr), inet_ntocidr(l.mask)); 2458 /* We need to handle DAD. */ 2459 arp_probe(astate); 2460 return 0; 2461 } 2462 } 2463 #endif 2464 2465 return 1; 2466 } 2467 2468 static void 2469 dhcp_arp_bind(struct interface *ifp) 2470 { 2471 2472 if (ifp->ctx->options & DHCPCD_TEST || 2473 dhcp_arp_address(ifp) == 1) 2474 dhcp_bind(ifp); 2475 } 2476 #endif 2477 2478 static void 2479 dhcp_static(struct interface *ifp) 2480 { 2481 struct if_options *ifo; 2482 struct dhcp_state *state; 2483 struct ipv4_addr *ia; 2484 2485 state = D_STATE(ifp); 2486 ifo = ifp->options; 2487 2488 ia = NULL; 2489 if (ifo->req_addr.s_addr == INADDR_ANY && 2490 (ia = ipv4_iffindaddr(ifp, NULL, NULL)) == NULL) 2491 { 2492 loginfox("%s: waiting for 3rd party to " 2493 "configure IP address", ifp->name); 2494 state->reason = "3RDPARTY"; 2495 script_runreason(ifp, state->reason); 2496 return; 2497 } 2498 2499 state->offer_len = dhcp_message_new(&state->offer, 2500 ia ? &ia->addr : &ifo->req_addr, 2501 ia ? &ia->mask : &ifo->req_mask); 2502 if (state->offer_len) 2503 #if defined(ARP) || defined(KERNEL_RFC5227) 2504 dhcp_arp_bind(ifp); 2505 #else 2506 dhcp_bind(ifp); 2507 #endif 2508 } 2509 2510 void 2511 dhcp_inform(struct interface *ifp) 2512 { 2513 struct dhcp_state *state; 2514 struct if_options *ifo; 2515 struct ipv4_addr *ia; 2516 2517 state = D_STATE(ifp); 2518 ifo = ifp->options; 2519 2520 state->state = DHS_INFORM; 2521 free(state->offer); 2522 state->offer = NULL; 2523 state->offer_len = 0; 2524 2525 if (ifo->req_addr.s_addr == INADDR_ANY) { 2526 ia = ipv4_iffindaddr(ifp, NULL, NULL); 2527 if (ia == NULL) { 2528 loginfox("%s: waiting for 3rd party to " 2529 "configure IP address", 2530 ifp->name); 2531 if (!(ifp->ctx->options & DHCPCD_TEST)) { 2532 state->reason = "3RDPARTY"; 2533 script_runreason(ifp, state->reason); 2534 } 2535 return; 2536 } 2537 } else { 2538 ia = ipv4_iffindaddr(ifp, &ifo->req_addr, &ifo->req_mask); 2539 if (ia == NULL) { 2540 if (ifp->ctx->options & DHCPCD_TEST) { 2541 logerrx("%s: cannot add IP address in test mode", 2542 ifp->name); 2543 return; 2544 } 2545 ia = ipv4_iffindaddr(ifp, &ifo->req_addr, NULL); 2546 if (ia != NULL) 2547 /* Netmask must be different, delete it. */ 2548 ipv4_deladdr(ia, 1); 2549 state->offer_len = dhcp_message_new(&state->offer, 2550 &ifo->req_addr, &ifo->req_mask); 2551 #ifdef ARP 2552 if (dhcp_arp_address(ifp) != 1) 2553 return; 2554 #endif 2555 ia = ipv4_iffindaddr(ifp, 2556 &ifo->req_addr, &ifo->req_mask); 2557 assert(ia != NULL); 2558 } 2559 } 2560 2561 state->addr = ia; 2562 state->offer_len = dhcp_message_new(&state->offer, 2563 &ia->addr, &ia->mask); 2564 if (state->offer_len) { 2565 dhcp_new_xid(ifp); 2566 get_lease(ifp, &state->lease, state->offer, state->offer_len); 2567 send_inform(ifp); 2568 } 2569 } 2570 2571 void 2572 dhcp_reboot_newopts(struct interface *ifp, unsigned long long oldopts) 2573 { 2574 struct if_options *ifo; 2575 struct dhcp_state *state = D_STATE(ifp); 2576 2577 if (state == NULL || state->state == DHS_NONE) 2578 return; 2579 ifo = ifp->options; 2580 if ((ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC) && 2581 (state->addr == NULL || 2582 state->addr->addr.s_addr != ifo->req_addr.s_addr)) || 2583 (oldopts & (DHCPCD_INFORM | DHCPCD_STATIC) && 2584 !(ifo->options & (DHCPCD_INFORM | DHCPCD_STATIC)))) 2585 { 2586 dhcp_drop(ifp, "EXPIRE"); 2587 } 2588 } 2589 2590 #ifdef ARP 2591 static int 2592 dhcp_activeaddr(const struct interface *ifp, const struct in_addr *addr) 2593 { 2594 const struct interface *ifp1; 2595 const struct dhcp_state *state; 2596 2597 TAILQ_FOREACH(ifp1, ifp->ctx->ifaces, next) { 2598 if (ifp1 == ifp) 2599 continue; 2600 if ((state = D_CSTATE(ifp1)) == NULL) 2601 continue; 2602 switch(state->state) { 2603 case DHS_REBOOT: 2604 case DHS_RENEW: 2605 case DHS_REBIND: 2606 case DHS_BOUND: 2607 case DHS_INFORM: 2608 break; 2609 default: 2610 continue; 2611 } 2612 if (state->lease.addr.s_addr == addr->s_addr) 2613 return 1; 2614 } 2615 return 0; 2616 } 2617 #endif 2618 2619 static void 2620 dhcp_reboot(struct interface *ifp) 2621 { 2622 struct if_options *ifo; 2623 struct dhcp_state *state = D_STATE(ifp); 2624 #ifdef ARP 2625 struct ipv4_addr *ia; 2626 #endif 2627 2628 if (state == NULL || state->state == DHS_NONE) 2629 return; 2630 ifo = ifp->options; 2631 state->state = DHS_REBOOT; 2632 state->interval = 0; 2633 2634 if (ifo->options & DHCPCD_LINK && ifp->carrier <= LINK_DOWN) { 2635 loginfox("%s: waiting for carrier", ifp->name); 2636 return; 2637 } 2638 if (ifo->options & DHCPCD_STATIC) { 2639 dhcp_static(ifp); 2640 return; 2641 } 2642 if (ifo->options & DHCPCD_INFORM) { 2643 loginfox("%s: informing address of %s", 2644 ifp->name, inet_ntoa(state->lease.addr)); 2645 dhcp_inform(ifp); 2646 return; 2647 } 2648 if (ifo->reboot == 0 || state->offer == NULL) { 2649 dhcp_discover(ifp); 2650 return; 2651 } 2652 if (!IS_DHCP(state->offer)) 2653 return; 2654 2655 loginfox("%s: rebinding lease of %s", 2656 ifp->name, inet_ntoa(state->lease.addr)); 2657 2658 #ifdef ARP 2659 #ifndef KERNEL_RFC5227 2660 /* Create the DHCP ARP state so we can defend it. */ 2661 (void)dhcp_arp_new(ifp, &state->lease.addr); 2662 #endif 2663 2664 /* If the address exists on the interface and no other interface 2665 * is currently using it then announce it to ensure this 2666 * interface gets the reply. */ 2667 ia = ipv4_iffindaddr(ifp, &state->lease.addr, NULL); 2668 if (ia != NULL && 2669 !(ifp->ctx->options & DHCPCD_TEST) && 2670 #ifdef IN_IFF_NOTUSEABLE 2671 !(ia->addr_flags & IN_IFF_NOTUSEABLE) && 2672 #endif 2673 dhcp_activeaddr(ifp, &state->lease.addr) == 0) 2674 arp_ifannounceaddr(ifp, &state->lease.addr); 2675 #endif 2676 2677 dhcp_new_xid(ifp); 2678 state->lease.server.s_addr = INADDR_ANY; 2679 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp); 2680 2681 #ifdef IPV4LL 2682 /* Need to add this before dhcp_expire and friends. */ 2683 if (!ifo->fallback && ifo->options & DHCPCD_IPV4LL) 2684 eloop_timeout_add_sec(ifp->ctx->eloop, 2685 ifo->reboot, ipv4ll_start, ifp); 2686 #endif 2687 2688 if (ifo->options & DHCPCD_LASTLEASE && state->lease.frominfo) 2689 eloop_timeout_add_sec(ifp->ctx->eloop, 2690 ifo->reboot, dhcp_lastlease, ifp); 2691 else if (!(ifo->options & DHCPCD_INFORM)) 2692 eloop_timeout_add_sec(ifp->ctx->eloop, 2693 ifo->reboot, dhcp_expire, ifp); 2694 2695 /* Don't bother ARP checking as the server could NAK us first. 2696 * Don't call dhcp_request as that would change the state */ 2697 send_request(ifp); 2698 } 2699 2700 void 2701 dhcp_drop(struct interface *ifp, const char *reason) 2702 { 2703 struct dhcp_state *state; 2704 #ifdef RELEASE_SLOW 2705 struct timespec ts; 2706 #endif 2707 2708 state = D_STATE(ifp); 2709 /* dhcp_start may just have been called and we don't yet have a state 2710 * but we do have a timeout, so punt it. */ 2711 if (state == NULL || state->state == DHS_NONE) { 2712 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp); 2713 return; 2714 } 2715 2716 #ifdef ARP 2717 if (state->addr != NULL) 2718 arp_freeaddr(ifp, &state->addr->addr); 2719 #endif 2720 #ifdef ARPING 2721 state->arping_index = -1; 2722 #endif 2723 2724 if (ifp->options->options & DHCPCD_RELEASE && 2725 !(ifp->options->options & DHCPCD_INFORM)) 2726 { 2727 /* Failure to send the release may cause this function to 2728 * re-enter so guard by setting the state. */ 2729 if (state->state == DHS_RELEASE) 2730 return; 2731 state->state = DHS_RELEASE; 2732 2733 dhcp_unlink(ifp->ctx, state->leasefile); 2734 if (ifp->carrier > LINK_DOWN && 2735 state->new != NULL && 2736 state->lease.server.s_addr != INADDR_ANY) 2737 { 2738 loginfox("%s: releasing lease of %s", 2739 ifp->name, inet_ntoa(state->lease.addr)); 2740 dhcp_new_xid(ifp); 2741 send_message(ifp, DHCP_RELEASE, NULL); 2742 #ifdef RELEASE_SLOW 2743 /* Give the packet a chance to go */ 2744 ts.tv_sec = RELEASE_DELAY_S; 2745 ts.tv_nsec = RELEASE_DELAY_NS; 2746 nanosleep(&ts, NULL); 2747 #endif 2748 } 2749 } 2750 #ifdef AUTH 2751 else if (state->auth.reconf != NULL) { 2752 /* 2753 * Drop the lease as the token may only be present 2754 * in the initial reply message and not subsequent 2755 * renewals. 2756 * If dhcpcd is restarted, the token is lost. 2757 * XXX persist this in another file? 2758 */ 2759 dhcp_unlink(ifp->ctx, state->leasefile); 2760 } 2761 #endif 2762 2763 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp); 2764 #ifdef AUTH 2765 dhcp_auth_reset(&state->auth); 2766 #endif 2767 2768 /* Close DHCP ports so a changed interface family is picked 2769 * up by a new BPF state. */ 2770 dhcp_close(ifp); 2771 2772 state->state = DHS_NONE; 2773 free(state->offer); 2774 state->offer = NULL; 2775 state->offer_len = 0; 2776 free(state->old); 2777 state->old = state->new; 2778 state->old_len = state->new_len; 2779 state->new = NULL; 2780 state->new_len = 0; 2781 state->reason = reason; 2782 ipv4_applyaddr(ifp); 2783 free(state->old); 2784 state->old = NULL; 2785 state->old_len = 0; 2786 state->lease.addr.s_addr = 0; 2787 ifp->options->options &= ~(DHCPCD_CSR_WARNED | 2788 DHCPCD_ROUTER_HOST_ROUTE_WARNED); 2789 } 2790 2791 static int 2792 blacklisted_ip(const struct if_options *ifo, in_addr_t addr) 2793 { 2794 size_t i; 2795 2796 for (i = 0; i < ifo->blacklist_len; i += 2) 2797 if (ifo->blacklist[i] == (addr & ifo->blacklist[i + 1])) 2798 return 1; 2799 return 0; 2800 } 2801 2802 #define WHTLST_NONE 0 2803 #define WHTLST_MATCH 1 2804 #define WHTLST_NOMATCH 2 2805 static unsigned int 2806 whitelisted_ip(const struct if_options *ifo, in_addr_t addr) 2807 { 2808 size_t i; 2809 2810 if (ifo->whitelist_len == 0) 2811 return WHTLST_NONE; 2812 for (i = 0; i < ifo->whitelist_len; i += 2) 2813 if (ifo->whitelist[i] == (addr & ifo->whitelist[i + 1])) 2814 return WHTLST_MATCH; 2815 return WHTLST_NOMATCH; 2816 } 2817 2818 static void 2819 log_dhcp(int loglevel, const char *msg, 2820 const struct interface *ifp, const struct bootp *bootp, size_t bootp_len, 2821 const struct in_addr *from, int ad) 2822 { 2823 const char *tfrom; 2824 char *a, sname[sizeof(bootp->sname) * 4]; 2825 struct in_addr addr; 2826 int r; 2827 uint8_t overl; 2828 2829 if (strcmp(msg, "NAK:") == 0) { 2830 a = get_option_string(ifp->ctx, bootp, bootp_len, DHO_MESSAGE); 2831 if (a) { 2832 char *tmp; 2833 size_t al, tmpl; 2834 2835 al = strlen(a); 2836 tmpl = (al * 4) + 1; 2837 tmp = malloc(tmpl); 2838 if (tmp == NULL) { 2839 logerr(__func__); 2840 free(a); 2841 return; 2842 } 2843 print_string(tmp, tmpl, OT_STRING, (uint8_t *)a, al); 2844 free(a); 2845 a = tmp; 2846 } 2847 } else if (ad && bootp->yiaddr != 0) { 2848 addr.s_addr = bootp->yiaddr; 2849 a = strdup(inet_ntoa(addr)); 2850 if (a == NULL) { 2851 logerr(__func__); 2852 return; 2853 } 2854 } else 2855 a = NULL; 2856 2857 tfrom = "from"; 2858 r = get_option_addr(ifp->ctx, &addr, bootp, bootp_len, DHO_SERVERID); 2859 if (get_option_uint8(ifp->ctx, &overl, bootp, bootp_len, 2860 DHO_OPTSOVERLOADED) == -1) 2861 overl = 0; 2862 if (bootp->sname[0] && r == 0 && !(overl & 2)) { 2863 print_string(sname, sizeof(sname), OT_STRING | OT_DOMAIN, 2864 bootp->sname, sizeof(bootp->sname)); 2865 if (a == NULL) 2866 logmessage(loglevel, "%s: %s %s %s `%s'", 2867 ifp->name, msg, tfrom, inet_ntoa(addr), sname); 2868 else 2869 logmessage(loglevel, "%s: %s %s %s %s `%s'", 2870 ifp->name, msg, a, tfrom, inet_ntoa(addr), sname); 2871 } else { 2872 if (r != 0) { 2873 tfrom = "via"; 2874 addr = *from; 2875 } 2876 if (a == NULL) 2877 logmessage(loglevel, "%s: %s %s %s", 2878 ifp->name, msg, tfrom, inet_ntoa(addr)); 2879 else 2880 logmessage(loglevel, "%s: %s %s %s %s", 2881 ifp->name, msg, a, tfrom, inet_ntoa(addr)); 2882 } 2883 free(a); 2884 } 2885 2886 /* If we're sharing the same IP address with another interface on the 2887 * same network, we may receive the DHCP reply on the wrong interface. 2888 * Try and re-direct it here. */ 2889 static void 2890 dhcp_redirect_dhcp(struct interface *ifp, struct bootp *bootp, size_t bootp_len, 2891 const struct in_addr *from) 2892 { 2893 struct interface *ifn; 2894 const struct dhcp_state *state; 2895 uint32_t xid; 2896 2897 xid = ntohl(bootp->xid); 2898 TAILQ_FOREACH(ifn, ifp->ctx->ifaces, next) { 2899 if (ifn == ifp) 2900 continue; 2901 state = D_CSTATE(ifn); 2902 if (state == NULL || state->state == DHS_NONE) 2903 continue; 2904 if (state->xid != xid) 2905 continue; 2906 if (ifn->hwlen <= sizeof(bootp->chaddr) && 2907 memcmp(bootp->chaddr, ifn->hwaddr, ifn->hwlen)) 2908 continue; 2909 logdebugx("%s: redirecting DHCP message to %s", 2910 ifp->name, ifn->name); 2911 dhcp_handledhcp(ifn, bootp, bootp_len, from); 2912 } 2913 } 2914 2915 static void 2916 dhcp_handledhcp(struct interface *ifp, struct bootp *bootp, size_t bootp_len, 2917 const struct in_addr *from) 2918 { 2919 struct dhcp_state *state = D_STATE(ifp); 2920 struct if_options *ifo = ifp->options; 2921 struct dhcp_lease *lease = &state->lease; 2922 uint8_t type, tmp; 2923 struct in_addr addr; 2924 unsigned int i; 2925 char *msg; 2926 bool bootp_copied; 2927 #ifdef AUTH 2928 const uint8_t *auth; 2929 size_t auth_len; 2930 #endif 2931 #ifdef IN_IFF_DUPLICATED 2932 struct ipv4_addr *ia; 2933 #endif 2934 2935 #define LOGDHCP0(l, m) \ 2936 log_dhcp((l), (m), ifp, bootp, bootp_len, from, 0) 2937 #define LOGDHCP(l, m) \ 2938 log_dhcp((l), (m), ifp, bootp, bootp_len, from, 1) 2939 2940 #define IS_STATE_ACTIVE(s) ((s)-state != DHS_NONE && \ 2941 (s)->state != DHS_INIT && (s)->state != DHS_BOUND) 2942 2943 if (bootp->op != BOOTREPLY) { 2944 if (IS_STATE_ACTIVE(state)) 2945 logdebugx("%s: op (%d) is not BOOTREPLY", 2946 ifp->name, bootp->op); 2947 return; 2948 } 2949 2950 if (state->xid != ntohl(bootp->xid)) { 2951 if (IS_STATE_ACTIVE(state)) 2952 logdebugx("%s: wrong xid 0x%x (expecting 0x%x) from %s", 2953 ifp->name, ntohl(bootp->xid), state->xid, 2954 inet_ntoa(*from)); 2955 dhcp_redirect_dhcp(ifp, bootp, bootp_len, from); 2956 return; 2957 } 2958 2959 if (ifp->hwlen <= sizeof(bootp->chaddr) && 2960 memcmp(bootp->chaddr, ifp->hwaddr, ifp->hwlen)) 2961 { 2962 if (IS_STATE_ACTIVE(state)) { 2963 char buf[sizeof(bootp->chaddr) * 3]; 2964 2965 logdebugx("%s: xid 0x%x is for hwaddr %s", 2966 ifp->name, ntohl(bootp->xid), 2967 hwaddr_ntoa(bootp->chaddr, sizeof(bootp->chaddr), 2968 buf, sizeof(buf))); 2969 } 2970 dhcp_redirect_dhcp(ifp, bootp, bootp_len, from); 2971 return; 2972 } 2973 2974 if (!ifp->active) 2975 return; 2976 2977 i = whitelisted_ip(ifp->options, from->s_addr); 2978 switch (i) { 2979 case WHTLST_NOMATCH: 2980 logwarnx("%s: non whitelisted DHCP packet from %s", 2981 ifp->name, inet_ntoa(*from)); 2982 return; 2983 case WHTLST_MATCH: 2984 break; 2985 case WHTLST_NONE: 2986 if (blacklisted_ip(ifp->options, from->s_addr) == 1) { 2987 logwarnx("%s: blacklisted DHCP packet from %s", 2988 ifp->name, inet_ntoa(*from)); 2989 return; 2990 } 2991 } 2992 2993 /* We may have found a BOOTP server */ 2994 if (get_option_uint8(ifp->ctx, &type, 2995 bootp, bootp_len, DHO_MESSAGETYPE) == -1) 2996 type = 0; 2997 else if (ifo->options & DHCPCD_BOOTP) { 2998 logdebugx("%s: ignoring DHCP reply (expecting BOOTP)", 2999 ifp->name); 3000 return; 3001 } 3002 3003 #ifdef AUTH 3004 /* Authenticate the message */ 3005 auth = get_option(ifp->ctx, bootp, bootp_len, 3006 DHO_AUTHENTICATION, &auth_len); 3007 if (auth) { 3008 if (dhcp_auth_validate(&state->auth, &ifo->auth, 3009 (uint8_t *)bootp, bootp_len, 4, type, 3010 auth, auth_len) == NULL) 3011 { 3012 LOGDHCP0(LOG_ERR, "authentication failed"); 3013 return; 3014 } 3015 if (state->auth.token) 3016 logdebugx("%s: validated using 0x%08" PRIu32, 3017 ifp->name, state->auth.token->secretid); 3018 else 3019 loginfox("%s: accepted reconfigure key", ifp->name); 3020 } else if (ifo->auth.options & DHCPCD_AUTH_SEND) { 3021 if (ifo->auth.options & DHCPCD_AUTH_REQUIRE) { 3022 LOGDHCP0(LOG_ERR, "no authentication"); 3023 return; 3024 } 3025 LOGDHCP0(LOG_WARNING, "no authentication"); 3026 } 3027 #endif 3028 3029 /* RFC 3203 */ 3030 if (type == DHCP_FORCERENEW) { 3031 if (from->s_addr == INADDR_ANY || 3032 from->s_addr == INADDR_BROADCAST) 3033 { 3034 LOGDHCP(LOG_ERR, "discarding Force Renew"); 3035 return; 3036 } 3037 #ifdef AUTH 3038 if (auth == NULL) { 3039 LOGDHCP(LOG_ERR, "unauthenticated Force Renew"); 3040 if (ifo->auth.options & DHCPCD_AUTH_REQUIRE) 3041 return; 3042 } 3043 if (state->state != DHS_BOUND && state->state != DHS_INFORM) { 3044 LOGDHCP(LOG_DEBUG, "not bound, ignoring Force Renew"); 3045 return; 3046 } 3047 LOGDHCP(LOG_INFO, "Force Renew from"); 3048 /* The rebind and expire timings are still the same, we just 3049 * enter the renew state early */ 3050 if (state->state == DHS_BOUND) 3051 dhcp_renew(ifp); 3052 else { 3053 eloop_timeout_delete(ifp->ctx->eloop, 3054 send_inform, ifp); 3055 dhcp_inform(ifp); 3056 } 3057 #else 3058 LOGDHCP(LOG_ERR, "unauthenticated Force Renew"); 3059 #endif 3060 return; 3061 } 3062 3063 if (state->state == DHS_BOUND) { 3064 LOGDHCP(LOG_DEBUG, "bound, ignoring"); 3065 return; 3066 } 3067 3068 if (state->state == DHS_PROBE) { 3069 /* Ignore any DHCP messages whilst probing a lease to bind. */ 3070 LOGDHCP(LOG_DEBUG, "probing, ignoring"); 3071 return; 3072 } 3073 3074 /* reset the message counter */ 3075 state->interval = 0; 3076 3077 /* Ensure that no reject options are present */ 3078 for (i = 1; i < 255; i++) { 3079 if (has_option_mask(ifo->rejectmask, i) && 3080 get_option_uint8(ifp->ctx, &tmp, 3081 bootp, bootp_len, (uint8_t)i) == 0) 3082 { 3083 LOGDHCP(LOG_WARNING, "reject DHCP"); 3084 return; 3085 } 3086 } 3087 3088 if (type == DHCP_NAK) { 3089 /* For NAK, only check if we require the ServerID */ 3090 if (has_option_mask(ifo->requiremask, DHO_SERVERID) && 3091 get_option_addr(ifp->ctx, &addr, 3092 bootp, bootp_len, DHO_SERVERID) == -1) 3093 { 3094 LOGDHCP(LOG_WARNING, "reject NAK"); 3095 return; 3096 } 3097 3098 /* We should restart on a NAK */ 3099 LOGDHCP(LOG_WARNING, "NAK:"); 3100 if ((msg = get_option_string(ifp->ctx, 3101 bootp, bootp_len, DHO_MESSAGE))) 3102 { 3103 logwarnx("%s: message: %s", ifp->name, msg); 3104 free(msg); 3105 } 3106 if (state->state == DHS_INFORM) /* INFORM should not be NAKed */ 3107 return; 3108 if (!(ifp->ctx->options & DHCPCD_TEST)) { 3109 dhcp_drop(ifp, "NAK"); 3110 dhcp_unlink(ifp->ctx, state->leasefile); 3111 } 3112 3113 /* If we constantly get NAKS then we should slowly back off */ 3114 eloop_timeout_add_sec(ifp->ctx->eloop, 3115 state->nakoff, dhcp_discover, ifp); 3116 if (state->nakoff == 0) 3117 state->nakoff = 1; 3118 else { 3119 state->nakoff *= 2; 3120 if (state->nakoff > NAKOFF_MAX) 3121 state->nakoff = NAKOFF_MAX; 3122 } 3123 return; 3124 } 3125 3126 /* Ensure that all required options are present */ 3127 for (i = 1; i < 255; i++) { 3128 if (has_option_mask(ifo->requiremask, i) && 3129 get_option_uint8(ifp->ctx, &tmp, 3130 bootp, bootp_len, (uint8_t)i) != 0) 3131 { 3132 /* If we are BOOTP, then ignore the need for serverid. 3133 * To ignore BOOTP, require dhcp_message_type. 3134 * However, nothing really stops BOOTP from providing 3135 * DHCP style options as well so the above isn't 3136 * always true. */ 3137 if (type == 0 && i == DHO_SERVERID) 3138 continue; 3139 LOGDHCP(LOG_WARNING, "reject DHCP"); 3140 return; 3141 } 3142 } 3143 3144 /* DHCP Auto-Configure, RFC 2563 */ 3145 if (type == DHCP_OFFER && bootp->yiaddr == 0) { 3146 LOGDHCP(LOG_WARNING, "no address given"); 3147 if ((msg = get_option_string(ifp->ctx, 3148 bootp, bootp_len, DHO_MESSAGE))) 3149 { 3150 logwarnx("%s: message: %s", ifp->name, msg); 3151 free(msg); 3152 } 3153 #ifdef IPV4LL 3154 if (state->state == DHS_DISCOVER && 3155 get_option_uint8(ifp->ctx, &tmp, bootp, bootp_len, 3156 DHO_AUTOCONFIGURE) == 0) 3157 { 3158 switch (tmp) { 3159 case 0: 3160 LOGDHCP(LOG_WARNING, "IPv4LL disabled from"); 3161 ipv4ll_drop(ifp); 3162 #ifdef ARP 3163 arp_drop(ifp); 3164 #endif 3165 break; 3166 case 1: 3167 LOGDHCP(LOG_WARNING, "IPv4LL enabled from"); 3168 ipv4ll_start(ifp); 3169 break; 3170 default: 3171 logerrx("%s: unknown auto configuration " 3172 "option %d", 3173 ifp->name, tmp); 3174 break; 3175 } 3176 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp); 3177 eloop_timeout_add_sec(ifp->ctx->eloop, 3178 DHCP_MAX, dhcp_discover, ifp); 3179 } 3180 #endif 3181 return; 3182 } 3183 3184 /* Ensure that the address offered is valid */ 3185 if ((type == 0 || type == DHCP_OFFER || type == DHCP_ACK) && 3186 (bootp->ciaddr == INADDR_ANY || bootp->ciaddr == INADDR_BROADCAST) 3187 && 3188 (bootp->yiaddr == INADDR_ANY || bootp->yiaddr == INADDR_BROADCAST)) 3189 { 3190 LOGDHCP(LOG_WARNING, "reject invalid address"); 3191 return; 3192 } 3193 3194 #ifdef IN_IFF_DUPLICATED 3195 ia = ipv4_iffindaddr(ifp, &lease->addr, NULL); 3196 if (ia && ia->addr_flags & IN_IFF_DUPLICATED) { 3197 LOGDHCP(LOG_WARNING, "declined duplicate address"); 3198 if (type) 3199 dhcp_decline(ifp); 3200 ipv4_deladdr(ia, 0); 3201 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp); 3202 eloop_timeout_add_sec(ifp->ctx->eloop, 3203 DHCP_RAND_MAX, dhcp_discover, ifp); 3204 return; 3205 } 3206 #endif 3207 3208 bootp_copied = false; 3209 if ((type == 0 || type == DHCP_OFFER) && state->state == DHS_DISCOVER) { 3210 lease->frominfo = 0; 3211 lease->addr.s_addr = bootp->yiaddr; 3212 memcpy(&lease->cookie, bootp->vend, sizeof(lease->cookie)); 3213 if (type == 0 || 3214 get_option_addr(ifp->ctx, 3215 &lease->server, bootp, bootp_len, DHO_SERVERID) != 0) 3216 lease->server.s_addr = INADDR_ANY; 3217 3218 /* Test for rapid commit in the OFFER */ 3219 if (!(ifp->ctx->options & DHCPCD_TEST) && 3220 has_option_mask(ifo->requestmask, DHO_RAPIDCOMMIT) && 3221 get_option(ifp->ctx, bootp, bootp_len, 3222 DHO_RAPIDCOMMIT, NULL)) 3223 { 3224 state->state = DHS_REQUEST; 3225 goto rapidcommit; 3226 } 3227 3228 LOGDHCP(LOG_INFO, "offered"); 3229 if (state->offer_len < bootp_len) { 3230 free(state->offer); 3231 if ((state->offer = malloc(bootp_len)) == NULL) { 3232 logerr(__func__); 3233 state->offer_len = 0; 3234 return; 3235 } 3236 } 3237 state->offer_len = bootp_len; 3238 memcpy(state->offer, bootp, bootp_len); 3239 bootp_copied = true; 3240 if (ifp->ctx->options & DHCPCD_TEST) { 3241 free(state->old); 3242 state->old = state->new; 3243 state->old_len = state->new_len; 3244 state->new = state->offer; 3245 state->new_len = state->offer_len; 3246 state->offer = NULL; 3247 state->offer_len = 0; 3248 state->reason = "TEST"; 3249 script_runreason(ifp, state->reason); 3250 eloop_exit(ifp->ctx->eloop, EXIT_SUCCESS); 3251 state->bpf->bpf_flags |= BPF_EOF; 3252 return; 3253 } 3254 eloop_timeout_delete(ifp->ctx->eloop, send_discover, ifp); 3255 /* We don't request BOOTP addresses */ 3256 if (type) { 3257 /* We used to ARP check here, but that seems to be in 3258 * violation of RFC2131 where it only describes 3259 * DECLINE after REQUEST. 3260 * It also seems that some MS DHCP servers actually 3261 * ignore DECLINE if no REQUEST, ie we decline a 3262 * DISCOVER. */ 3263 dhcp_request(ifp); 3264 return; 3265 } 3266 } 3267 3268 if (type) { 3269 if (type == DHCP_OFFER) { 3270 LOGDHCP(LOG_WARNING, "ignoring offer of"); 3271 return; 3272 } 3273 3274 /* We should only be dealing with acks */ 3275 if (type != DHCP_ACK) { 3276 LOGDHCP(LOG_ERR, "not ACK or OFFER"); 3277 return; 3278 } 3279 3280 if (state->state == DHS_DISCOVER) { 3281 /* We only allow ACK of rapid commit DISCOVER. */ 3282 if (has_option_mask(ifo->requestmask, 3283 DHO_RAPIDCOMMIT) && 3284 get_option(ifp->ctx, bootp, bootp_len, 3285 DHO_RAPIDCOMMIT, NULL)) 3286 state->state = DHS_REQUEST; 3287 else { 3288 LOGDHCP(LOG_DEBUG, "ignoring ack of"); 3289 return; 3290 } 3291 } 3292 3293 rapidcommit: 3294 if (!(ifo->options & DHCPCD_INFORM)) 3295 LOGDHCP(LOG_DEBUG, "acknowledged"); 3296 else 3297 ifo->options &= ~DHCPCD_STATIC; 3298 } 3299 3300 /* No NAK, so reset the backoff 3301 * We don't reset on an OFFER message because the server could 3302 * potentially NAK the REQUEST. */ 3303 state->nakoff = 0; 3304 3305 /* BOOTP could have already assigned this above. */ 3306 if (!bootp_copied) { 3307 if (state->offer_len < bootp_len) { 3308 free(state->offer); 3309 if ((state->offer = malloc(bootp_len)) == NULL) { 3310 logerr(__func__); 3311 state->offer_len = 0; 3312 return; 3313 } 3314 } 3315 state->offer_len = bootp_len; 3316 memcpy(state->offer, bootp, bootp_len); 3317 } 3318 3319 lease->frominfo = 0; 3320 eloop_timeout_delete(ifp->ctx->eloop, NULL, ifp); 3321 3322 #if defined(ARP) || defined(KERNEL_RFC5227) 3323 dhcp_arp_bind(ifp); 3324 #else 3325 dhcp_bind(ifp); 3326 #endif 3327 } 3328 3329 static void * 3330 get_udp_data(void *packet, size_t *len) 3331 { 3332 const struct ip *ip = packet; 3333 size_t ip_hl = (size_t)ip->ip_hl * 4; 3334 char *p = packet; 3335 3336 p += ip_hl + sizeof(struct udphdr); 3337 *len = (size_t)ntohs(ip->ip_len) - sizeof(struct udphdr) - ip_hl; 3338 return p; 3339 } 3340 3341 static bool 3342 is_packet_udp_bootp(void *packet, size_t plen) 3343 { 3344 struct ip *ip = packet; 3345 size_t ip_hlen; 3346 struct udphdr udp; 3347 3348 if (plen < sizeof(*ip)) 3349 return false; 3350 3351 if (ip->ip_v != IPVERSION || ip->ip_p != IPPROTO_UDP) 3352 return false; 3353 3354 /* Sanity. */ 3355 if (ntohs(ip->ip_len) > plen) 3356 return false; 3357 3358 ip_hlen = (size_t)ip->ip_hl * 4; 3359 if (ip_hlen < sizeof(*ip)) 3360 return false; 3361 3362 /* Check we have a UDP header and BOOTP. */ 3363 if (ip_hlen + sizeof(udp) + offsetof(struct bootp, vend) > plen) 3364 return false; 3365 3366 /* Sanity. */ 3367 memcpy(&udp, (char *)ip + ip_hlen, sizeof(udp)); 3368 if (ntohs(udp.uh_ulen) < sizeof(udp)) 3369 return false; 3370 if (ip_hlen + ntohs(udp.uh_ulen) > plen) 3371 return false; 3372 3373 /* Check it's to and from the right ports. */ 3374 if (udp.uh_dport != htons(BOOTPC) || udp.uh_sport != htons(BOOTPS)) 3375 return false; 3376 3377 return true; 3378 } 3379 3380 /* Lengths have already been checked. */ 3381 static bool 3382 checksums_valid(void *packet, 3383 struct in_addr *from, unsigned int flags) 3384 { 3385 struct ip *ip = packet; 3386 union pip { 3387 struct ip ip; 3388 uint16_t w[sizeof(struct ip) / 2]; 3389 } pip = { 3390 .ip = { 3391 .ip_p = IPPROTO_UDP, 3392 .ip_src = ip->ip_src, 3393 .ip_dst = ip->ip_dst, 3394 } 3395 }; 3396 size_t ip_hlen; 3397 struct udphdr udp; 3398 char *udpp, *uh_sump; 3399 uint32_t csum; 3400 3401 if (from != NULL) 3402 from->s_addr = ip->ip_src.s_addr; 3403 3404 ip_hlen = (size_t)ip->ip_hl * 4; 3405 if (in_cksum(ip, ip_hlen, NULL) != 0) 3406 return false; 3407 3408 if (flags & BPF_PARTIALCSUM) 3409 return true; 3410 3411 udpp = (char *)ip + ip_hlen; 3412 memcpy(&udp, udpp, sizeof(udp)); 3413 if (udp.uh_sum == 0) 3414 return true; 3415 3416 /* UDP checksum is based on a pseudo IP header alongside 3417 * the UDP header and payload. */ 3418 pip.ip.ip_len = udp.uh_ulen; 3419 csum = 0; 3420 3421 /* Need to zero the UDP sum in the packet for the checksum to work. */ 3422 uh_sump = udpp + offsetof(struct udphdr, uh_sum); 3423 memset(uh_sump, 0, sizeof(udp.uh_sum)); 3424 3425 /* Checksum pseudo header and then UDP + payload. */ 3426 in_cksum(pip.w, sizeof(pip.w), &csum); 3427 csum = in_cksum(udpp, ntohs(udp.uh_ulen), &csum); 3428 3429 #if 0 /* Not needed, just here for completeness. */ 3430 /* Put the checksum back. */ 3431 memcpy(uh_sump, &udp.uh_sum, sizeof(udp.uh_sum)); 3432 #endif 3433 3434 return csum == udp.uh_sum; 3435 } 3436 3437 static void 3438 dhcp_handlebootp(struct interface *ifp, struct bootp *bootp, size_t len, 3439 struct in_addr *from) 3440 { 3441 size_t v; 3442 3443 if (len < offsetof(struct bootp, vend)) { 3444 logerrx("%s: truncated packet (%zu) from %s", 3445 ifp->name, len, inet_ntoa(*from)); 3446 return; 3447 } 3448 3449 /* Unlikely, but appeases sanitizers. */ 3450 if (len > FRAMELEN_MAX) { 3451 logerrx("%s: packet exceeded frame length (%zu) from %s", 3452 ifp->name, len, inet_ntoa(*from)); 3453 return; 3454 } 3455 3456 /* To make our IS_DHCP macro easy, ensure the vendor 3457 * area has at least 4 octets. */ 3458 v = len - offsetof(struct bootp, vend); 3459 while (v < 4) { 3460 bootp->vend[v++] = '\0'; 3461 len++; 3462 } 3463 3464 dhcp_handledhcp(ifp, bootp, len, from); 3465 } 3466 3467 void 3468 dhcp_packet(struct interface *ifp, uint8_t *data, size_t len, 3469 unsigned int bpf_flags) 3470 { 3471 struct bootp *bootp; 3472 struct in_addr from; 3473 size_t udp_len; 3474 size_t fl = bpf_frame_header_len(ifp); 3475 #ifdef PRIVSEP 3476 const struct dhcp_state *state = D_CSTATE(ifp); 3477 3478 /* Ignore double reads */ 3479 if (IN_PRIVSEP(ifp->ctx)) { 3480 switch (state->state) { 3481 case DHS_BOUND: /* FALLTHROUGH */ 3482 case DHS_RENEW: 3483 return; 3484 default: 3485 break; 3486 } 3487 } 3488 #endif 3489 3490 /* Trim frame header */ 3491 if (fl != 0) { 3492 if (len < fl) { 3493 logerrx("%s: %s: short frame header %zu", 3494 __func__, ifp->name, len); 3495 return; 3496 } 3497 len -= fl; 3498 /* Move the data to avoid alignment errors. */ 3499 memmove(data, data + fl, len); 3500 } 3501 3502 /* Validate filter. */ 3503 if (!is_packet_udp_bootp(data, len)) { 3504 #ifdef BPF_DEBUG 3505 logerrx("%s: DHCP BPF validation failure", ifp->name); 3506 #endif 3507 return; 3508 } 3509 3510 if (!checksums_valid(data, &from, bpf_flags)) { 3511 logerrx("%s: checksum failure from %s", 3512 ifp->name, inet_ntoa(from)); 3513 return; 3514 } 3515 3516 /* 3517 * DHCP has a variable option area rather than a fixed vendor area. 3518 * Because DHCP uses the BOOTP protocol it should still send BOOTP 3519 * sized packets to be RFC compliant. 3520 * However some servers send a truncated vendor area. 3521 * dhcpcd can work fine without the vendor area being sent. 3522 */ 3523 bootp = get_udp_data(data, &udp_len); 3524 dhcp_handlebootp(ifp, bootp, udp_len, &from); 3525 } 3526 3527 static void 3528 dhcp_readbpf(void *arg) 3529 { 3530 struct interface *ifp = arg; 3531 uint8_t buf[FRAMELEN_MAX]; 3532 ssize_t bytes; 3533 struct dhcp_state *state = D_STATE(ifp); 3534 struct bpf *bpf = state->bpf; 3535 3536 bpf->bpf_flags &= ~BPF_EOF; 3537 while (!(bpf->bpf_flags & BPF_EOF)) { 3538 bytes = bpf_read(bpf, buf, sizeof(buf)); 3539 if (bytes == -1) { 3540 if (state->state != DHS_NONE) { 3541 logerr("%s: %s", __func__, ifp->name); 3542 dhcp_close(ifp); 3543 } 3544 break; 3545 } 3546 dhcp_packet(ifp, buf, (size_t)bytes, bpf->bpf_flags); 3547 /* Check we still have a state after processing. */ 3548 if ((state = D_STATE(ifp)) == NULL) 3549 break; 3550 if ((bpf = state->bpf) == NULL) 3551 break; 3552 } 3553 } 3554 3555 void 3556 dhcp_recvmsg(struct dhcpcd_ctx *ctx, struct msghdr *msg) 3557 { 3558 struct sockaddr_in *from = (struct sockaddr_in *)msg->msg_name; 3559 struct iovec *iov = &msg->msg_iov[0]; 3560 struct interface *ifp; 3561 const struct dhcp_state *state; 3562 3563 ifp = if_findifpfromcmsg(ctx, msg, NULL); 3564 if (ifp == NULL) { 3565 logerr(__func__); 3566 return; 3567 } 3568 state = D_CSTATE(ifp); 3569 if (state == NULL) { 3570 /* Try re-directing it to another interface. */ 3571 dhcp_redirect_dhcp(ifp, (struct bootp *)iov->iov_base, 3572 iov->iov_len, &from->sin_addr); 3573 return; 3574 } 3575 3576 if (state->bpf != NULL) { 3577 /* Avoid a duplicate read if BPF is open for the interface. */ 3578 return; 3579 } 3580 #ifdef PRIVSEP 3581 if (IN_PRIVSEP(ctx)) { 3582 switch (state->state) { 3583 case DHS_BOUND: /* FALLTHROUGH */ 3584 case DHS_RENEW: 3585 break; 3586 default: 3587 /* Any other state we ignore it or will receive 3588 * via BPF. */ 3589 return; 3590 } 3591 } 3592 #endif 3593 3594 dhcp_handlebootp(ifp, iov->iov_base, iov->iov_len, 3595 &from->sin_addr); 3596 } 3597 3598 static void 3599 dhcp_readudp(struct dhcpcd_ctx *ctx, struct interface *ifp) 3600 { 3601 const struct dhcp_state *state; 3602 struct sockaddr_in from; 3603 union { 3604 struct bootp bootp; 3605 uint8_t buf[10 * 1024]; /* Maximum MTU */ 3606 } iovbuf; 3607 struct iovec iov = { 3608 .iov_base = iovbuf.buf, 3609 .iov_len = sizeof(iovbuf.buf), 3610 }; 3611 union { 3612 struct cmsghdr hdr; 3613 #ifdef IP_RECVIF 3614 uint8_t buf[CMSG_SPACE(sizeof(struct sockaddr_dl))]; 3615 #else 3616 uint8_t buf[CMSG_SPACE(sizeof(struct in_pktinfo))]; 3617 #endif 3618 } cmsgbuf = { .buf = { 0 } }; 3619 struct msghdr msg = { 3620 .msg_name = &from, .msg_namelen = sizeof(from), 3621 .msg_iov = &iov, .msg_iovlen = 1, 3622 .msg_control = cmsgbuf.buf, .msg_controllen = sizeof(cmsgbuf.buf), 3623 }; 3624 int s; 3625 ssize_t bytes; 3626 3627 if (ifp != NULL) { 3628 state = D_CSTATE(ifp); 3629 s = state->udp_rfd; 3630 } else 3631 s = ctx->udp_rfd; 3632 3633 bytes = recvmsg(s, &msg, 0); 3634 if (bytes == -1) { 3635 logerr(__func__); 3636 return; 3637 } 3638 3639 iov.iov_len = (size_t)bytes; 3640 dhcp_recvmsg(ctx, &msg); 3641 } 3642 3643 static void 3644 dhcp_handleudp(void *arg) 3645 { 3646 struct dhcpcd_ctx *ctx = arg; 3647 3648 dhcp_readudp(ctx, NULL); 3649 } 3650 3651 static void 3652 dhcp_handleifudp(void *arg) 3653 { 3654 struct interface *ifp = arg; 3655 3656 dhcp_readudp(ifp->ctx, ifp); 3657 } 3658 3659 static int 3660 dhcp_openbpf(struct interface *ifp) 3661 { 3662 struct dhcp_state *state; 3663 3664 state = D_STATE(ifp); 3665 3666 #ifdef PRIVSEP 3667 if (IN_PRIVSEP_SE(ifp->ctx)) { 3668 if (ps_bpf_openbootp(ifp) == -1) { 3669 logerr(__func__); 3670 return -1; 3671 } 3672 return 0; 3673 } 3674 #endif 3675 3676 if (state->bpf != NULL) 3677 return 0; 3678 3679 state->bpf = bpf_open(ifp, bpf_bootp, NULL); 3680 if (state->bpf == NULL) { 3681 if (errno == ENOENT) { 3682 logerrx("%s not found", bpf_name); 3683 /* May as well disable IPv4 entirely at 3684 * this point as we really need it. */ 3685 ifp->options->options &= ~DHCPCD_IPV4; 3686 } else 3687 logerr("%s: %s", __func__, ifp->name); 3688 return -1; 3689 } 3690 3691 eloop_event_add(ifp->ctx->eloop, 3692 state->bpf->bpf_fd, dhcp_readbpf, ifp); 3693 return 0; 3694 } 3695 3696 void 3697 dhcp_free(struct interface *ifp) 3698 { 3699 struct dhcp_state *state = D_STATE(ifp); 3700 struct dhcpcd_ctx *ctx; 3701 3702 dhcp_close(ifp); 3703 #ifdef ARP 3704 arp_drop(ifp); 3705 #endif 3706 if (state) { 3707 state->state = DHS_NONE; 3708 free(state->old); 3709 free(state->new); 3710 free(state->offer); 3711 free(state->clientid); 3712 free(state); 3713 } 3714 3715 ctx = ifp->ctx; 3716 /* If we don't have any more DHCP enabled interfaces, 3717 * close the global socket and release resources */ 3718 if (ctx->ifaces) { 3719 TAILQ_FOREACH(ifp, ctx->ifaces, next) { 3720 state = D_STATE(ifp); 3721 if (state != NULL && state->state != DHS_NONE) 3722 break; 3723 } 3724 } 3725 if (ifp == NULL) { 3726 if (ctx->udp_rfd != -1) { 3727 eloop_event_delete(ctx->eloop, ctx->udp_rfd); 3728 close(ctx->udp_rfd); 3729 ctx->udp_rfd = -1; 3730 } 3731 if (ctx->udp_wfd != -1) { 3732 close(ctx->udp_wfd); 3733 ctx->udp_wfd = -1; 3734 } 3735 3736 free(ctx->opt_buffer); 3737 ctx->opt_buffer = NULL; 3738 } 3739 } 3740 3741 static int 3742 dhcp_initstate(struct interface *ifp) 3743 { 3744 struct dhcp_state *state; 3745 3746 state = D_STATE(ifp); 3747 if (state != NULL) 3748 return 0; 3749 3750 ifp->if_data[IF_DATA_DHCP] = calloc(1, sizeof(*state)); 3751 state = D_STATE(ifp); 3752 if (state == NULL) 3753 return -1; 3754 3755 state->state = DHS_NONE; 3756 /* 0 is a valid fd, so init to -1 */ 3757 state->udp_rfd = -1; 3758 #ifdef ARPING 3759 state->arping_index = -1; 3760 #endif 3761 return 1; 3762 } 3763 3764 static int 3765 dhcp_init(struct interface *ifp) 3766 { 3767 struct dhcp_state *state; 3768 struct if_options *ifo; 3769 uint8_t len; 3770 char buf[(sizeof(ifo->clientid) - 1) * 3]; 3771 3772 if (dhcp_initstate(ifp) == -1) 3773 return -1; 3774 3775 state = D_STATE(ifp); 3776 state->state = DHS_INIT; 3777 state->reason = "PREINIT"; 3778 state->nakoff = 0; 3779 dhcp_set_leasefile(state->leasefile, sizeof(state->leasefile), 3780 AF_INET, ifp); 3781 3782 ifo = ifp->options; 3783 /* We need to drop the leasefile so that dhcp_start 3784 * doesn't load it. */ 3785 if (ifo->options & DHCPCD_REQUEST) 3786 dhcp_unlink(ifp->ctx, state->leasefile); 3787 3788 free(state->clientid); 3789 state->clientid = NULL; 3790 3791 if (ifo->options & DHCPCD_ANONYMOUS) { 3792 uint8_t duid[DUID_LEN]; 3793 uint8_t duid_len; 3794 3795 duid_len = (uint8_t)duid_make(duid, ifp, DUID_LL); 3796 if (duid_len != 0) { 3797 state->clientid = malloc((size_t)duid_len + 6); 3798 if (state->clientid == NULL) 3799 goto eexit; 3800 state->clientid[0] =(uint8_t)(duid_len + 5); 3801 state->clientid[1] = 255; /* RFC 4361 */ 3802 memcpy(state->clientid + 2, ifo->iaid, 4); 3803 memset(state->clientid + 2, 0, 4); /* IAID */ 3804 memcpy(state->clientid + 6, duid, duid_len); 3805 } 3806 } else if (*ifo->clientid) { 3807 state->clientid = malloc((size_t)(ifo->clientid[0] + 1)); 3808 if (state->clientid == NULL) 3809 goto eexit; 3810 memcpy(state->clientid, ifo->clientid, 3811 (size_t)(ifo->clientid[0]) + 1); 3812 } else if (ifo->options & DHCPCD_CLIENTID) { 3813 if (ifo->options & DHCPCD_DUID) { 3814 state->clientid = malloc(ifp->ctx->duid_len + 6); 3815 if (state->clientid == NULL) 3816 goto eexit; 3817 state->clientid[0] =(uint8_t)(ifp->ctx->duid_len + 5); 3818 state->clientid[1] = 255; /* RFC 4361 */ 3819 memcpy(state->clientid + 2, ifo->iaid, 4); 3820 memcpy(state->clientid + 6, ifp->ctx->duid, 3821 ifp->ctx->duid_len); 3822 } else { 3823 len = (uint8_t)(ifp->hwlen + 1); 3824 state->clientid = malloc((size_t)len + 1); 3825 if (state->clientid == NULL) 3826 goto eexit; 3827 state->clientid[0] = len; 3828 state->clientid[1] = (uint8_t)ifp->hwtype; 3829 memcpy(state->clientid + 2, ifp->hwaddr, 3830 ifp->hwlen); 3831 } 3832 } 3833 3834 if (ifo->options & DHCPCD_DUID) 3835 /* Don't bother logging as DUID and IAID are reported 3836 * at device start. */ 3837 return 0; 3838 3839 if (ifo->options & DHCPCD_CLIENTID && state->clientid != NULL) 3840 logdebugx("%s: using ClientID %s", ifp->name, 3841 hwaddr_ntoa(state->clientid + 1, state->clientid[0], 3842 buf, sizeof(buf))); 3843 else if (ifp->hwlen) 3844 logdebugx("%s: using hwaddr %s", ifp->name, 3845 hwaddr_ntoa(ifp->hwaddr, ifp->hwlen, buf, sizeof(buf))); 3846 return 0; 3847 3848 eexit: 3849 logerr(__func__); 3850 return -1; 3851 } 3852 3853 static void 3854 dhcp_start1(void *arg) 3855 { 3856 struct interface *ifp = arg; 3857 struct dhcpcd_ctx *ctx = ifp->ctx; 3858 struct if_options *ifo = ifp->options; 3859 struct dhcp_state *state; 3860 uint32_t l; 3861 int nolease; 3862 3863 if (!(ifo->options & DHCPCD_IPV4)) 3864 return; 3865 3866 /* Listen on *.*.*.*:bootpc so that the kernel never sends an 3867 * ICMP port unreachable message back to the DHCP server. 3868 * Only do this in master mode so we don't swallow messages 3869 * for dhcpcd running on another interface. */ 3870 if ((ctx->options & (DHCPCD_MASTER|DHCPCD_PRIVSEP)) == DHCPCD_MASTER 3871 && ctx->udp_rfd == -1) 3872 { 3873 ctx->udp_rfd = dhcp_openudp(NULL); 3874 if (ctx->udp_rfd == -1) { 3875 logerr(__func__); 3876 return; 3877 } 3878 eloop_event_add(ctx->eloop, ctx->udp_rfd, dhcp_handleudp, ctx); 3879 } 3880 if (!IN_PRIVSEP(ctx) && ctx->udp_wfd == -1) { 3881 ctx->udp_wfd = xsocket(PF_INET, SOCK_RAW|SOCK_CXNB,IPPROTO_UDP); 3882 if (ctx->udp_wfd == -1) { 3883 logerr(__func__); 3884 return; 3885 } 3886 } 3887 3888 if (dhcp_init(ifp) == -1) { 3889 logerr("%s: dhcp_init", ifp->name); 3890 return; 3891 } 3892 3893 state = D_STATE(ifp); 3894 clock_gettime(CLOCK_MONOTONIC, &state->started); 3895 state->interval = 0; 3896 free(state->offer); 3897 state->offer = NULL; 3898 state->offer_len = 0; 3899 3900 #ifdef ARPING 3901 if (ifo->arping_len && state->arping_index < ifo->arping_len) { 3902 dhcp_arping(ifp); 3903 return; 3904 } 3905 #endif 3906 3907 if (ifo->options & DHCPCD_STATIC) { 3908 dhcp_static(ifp); 3909 return; 3910 } 3911 3912 if (ifo->options & DHCPCD_INFORM) { 3913 dhcp_inform(ifp); 3914 return; 3915 } 3916 3917 /* We don't want to read the old lease if we NAK an old test */ 3918 nolease = state->offer && ifp->ctx->options & DHCPCD_TEST; 3919 if (!nolease && ifo->options & DHCPCD_DHCP) { 3920 state->offer_len = read_lease(ifp, &state->offer); 3921 /* Check the saved lease matches the type we want */ 3922 if (state->offer) { 3923 #ifdef IN_IFF_DUPLICATED 3924 struct in_addr addr; 3925 struct ipv4_addr *ia; 3926 3927 addr.s_addr = state->offer->yiaddr; 3928 ia = ipv4_iffindaddr(ifp, &addr, NULL); 3929 #endif 3930 3931 if ((!IS_DHCP(state->offer) && 3932 !(ifo->options & DHCPCD_BOOTP)) || 3933 #ifdef IN_IFF_DUPLICATED 3934 (ia && ia->addr_flags & IN_IFF_DUPLICATED) || 3935 #endif 3936 (IS_DHCP(state->offer) && 3937 ifo->options & DHCPCD_BOOTP)) 3938 { 3939 free(state->offer); 3940 state->offer = NULL; 3941 state->offer_len = 0; 3942 } 3943 } 3944 } 3945 if (state->offer) { 3946 struct ipv4_addr *ia; 3947 time_t mtime; 3948 3949 get_lease(ifp, &state->lease, state->offer, state->offer_len); 3950 state->lease.frominfo = 1; 3951 if (state->new == NULL && 3952 (ia = ipv4_iffindaddr(ifp, 3953 &state->lease.addr, &state->lease.mask)) != NULL) 3954 { 3955 /* We still have the IP address from the last lease. 3956 * Fake add the address and routes from it so the lease 3957 * can be cleaned up. */ 3958 state->new = malloc(state->offer_len); 3959 if (state->new) { 3960 memcpy(state->new, 3961 state->offer, state->offer_len); 3962 state->new_len = state->offer_len; 3963 state->addr = ia; 3964 state->added |= STATE_ADDED | STATE_FAKE; 3965 rt_build(ifp->ctx, AF_INET); 3966 } else 3967 logerr(__func__); 3968 } 3969 if (!IS_DHCP(state->offer)) { 3970 free(state->offer); 3971 state->offer = NULL; 3972 state->offer_len = 0; 3973 } else if (!(ifo->options & DHCPCD_LASTLEASE_EXTEND) && 3974 state->lease.leasetime != DHCP_INFINITE_LIFETIME && 3975 dhcp_filemtime(ifp->ctx, state->leasefile, &mtime) == 0) 3976 { 3977 time_t now; 3978 3979 /* Offset lease times and check expiry */ 3980 now = time(NULL); 3981 if (now == -1 || 3982 (time_t)state->lease.leasetime < now - mtime) 3983 { 3984 logdebugx("%s: discarding expired lease", 3985 ifp->name); 3986 free(state->offer); 3987 state->offer = NULL; 3988 state->offer_len = 0; 3989 state->lease.addr.s_addr = 0; 3990 /* Technically we should discard the lease 3991 * as it's expired, just as DHCPv6 addresses 3992 * would be by the kernel. 3993 * However, this may violate POLA so 3994 * we currently leave it be. 3995 * If we get a totally different lease from 3996 * the DHCP server we'll drop it anyway, as 3997 * we will on any other event which would 3998 * trigger a lease drop. 3999 * This should only happen if dhcpcd stops 4000 * running and the lease expires before 4001 * dhcpcd starts again. */ 4002 #if 0 4003 if (state->new) 4004 dhcp_drop(ifp, "EXPIRE"); 4005 #endif 4006 } else { 4007 l = (uint32_t)(now - mtime); 4008 state->lease.leasetime -= l; 4009 state->lease.renewaltime -= l; 4010 state->lease.rebindtime -= l; 4011 } 4012 } 4013 } 4014 4015 #ifdef IPV4LL 4016 if (!(ifo->options & DHCPCD_DHCP)) { 4017 if (ifo->options & DHCPCD_IPV4LL) 4018 ipv4ll_start(ifp); 4019 return; 4020 } 4021 #endif 4022 4023 if (state->offer == NULL || 4024 !IS_DHCP(state->offer) || 4025 ifo->options & DHCPCD_ANONYMOUS) 4026 dhcp_discover(ifp); 4027 else 4028 dhcp_reboot(ifp); 4029 } 4030 4031 void 4032 dhcp_start(struct interface *ifp) 4033 { 4034 unsigned int delay; 4035 #ifdef ARPING 4036 const struct dhcp_state *state; 4037 #endif 4038 4039 if (!(ifp->options->options & DHCPCD_IPV4)) 4040 return; 4041 4042 /* If we haven't been given a netmask for our requested address, 4043 * set it now. */ 4044 if (ifp->options->req_addr.s_addr != INADDR_ANY && 4045 ifp->options->req_mask.s_addr == INADDR_ANY) 4046 ifp->options->req_mask.s_addr = 4047 ipv4_getnetmask(ifp->options->req_addr.s_addr); 4048 4049 /* If we haven't specified a ClientID and our hardware address 4050 * length is greater than BOOTP CHADDR then we enforce a ClientID 4051 * of the hardware address type and the hardware address. 4052 * If there is no hardware address and no ClientID set, 4053 * force a DUID based ClientID. */ 4054 if (ifp->hwlen > 16) 4055 ifp->options->options |= DHCPCD_CLIENTID; 4056 else if (ifp->hwlen == 0 && !(ifp->options->options & DHCPCD_CLIENTID)) 4057 ifp->options->options |= DHCPCD_CLIENTID | DHCPCD_DUID; 4058 4059 /* Firewire and InfiniBand interfaces require ClientID and 4060 * the broadcast option being set. */ 4061 switch (ifp->hwtype) { 4062 case ARPHRD_IEEE1394: /* FALLTHROUGH */ 4063 case ARPHRD_INFINIBAND: 4064 ifp->options->options |= DHCPCD_CLIENTID | DHCPCD_BROADCAST; 4065 break; 4066 } 4067 4068 /* If we violate RFC2131 section 3.7 then require ARP 4069 * to detect if any other client wants our address. */ 4070 if (ifp->options->options & DHCPCD_LASTLEASE_EXTEND) 4071 ifp->options->options |= DHCPCD_ARP; 4072 4073 /* No point in delaying a static configuration */ 4074 if (ifp->options->options & DHCPCD_STATIC || 4075 !(ifp->options->options & DHCPCD_INITIAL_DELAY)) 4076 { 4077 dhcp_start1(ifp); 4078 return; 4079 } 4080 4081 #ifdef ARPING 4082 /* If we have arpinged then we have already delayed. */ 4083 state = D_CSTATE(ifp); 4084 if (state != NULL && state->arping_index != -1) { 4085 dhcp_start1(ifp); 4086 return; 4087 } 4088 #endif 4089 delay = MSEC_PER_SEC + 4090 (arc4random_uniform(MSEC_PER_SEC * 2) - MSEC_PER_SEC); 4091 logdebugx("%s: delaying IPv4 for %0.1f seconds", 4092 ifp->name, (float)delay / MSEC_PER_SEC); 4093 4094 eloop_timeout_add_msec(ifp->ctx->eloop, delay, dhcp_start1, ifp); 4095 } 4096 4097 void 4098 dhcp_abort(struct interface *ifp) 4099 { 4100 struct dhcp_state *state; 4101 4102 state = D_STATE(ifp); 4103 #ifdef ARPING 4104 if (state != NULL) 4105 state->arping_index = -1; 4106 #endif 4107 4108 eloop_timeout_delete(ifp->ctx->eloop, dhcp_start1, ifp); 4109 4110 if (state != NULL && state->added) { 4111 rt_build(ifp->ctx, AF_INET); 4112 #ifdef ARP 4113 if (ifp->options->options & DHCPCD_ARP) 4114 arp_announceaddr(ifp->ctx, &state->addr->addr); 4115 #endif 4116 } 4117 } 4118 4119 struct ipv4_addr * 4120 dhcp_handleifa(int cmd, struct ipv4_addr *ia, pid_t pid) 4121 { 4122 struct interface *ifp; 4123 struct dhcp_state *state; 4124 struct if_options *ifo; 4125 uint8_t i; 4126 4127 ifp = ia->iface; 4128 state = D_STATE(ifp); 4129 if (state == NULL || state->state == DHS_NONE) 4130 return ia; 4131 4132 if (cmd == RTM_DELADDR) { 4133 if (state->addr == ia) { 4134 loginfox("%s: pid %d deleted IP address %s", 4135 ifp->name, pid, ia->saddr); 4136 dhcp_close(ifp); 4137 state->addr = NULL; 4138 /* Don't clear the added state as we need 4139 * to drop the lease. */ 4140 dhcp_drop(ifp, "EXPIRE"); 4141 dhcp_start1(ifp); 4142 return ia; 4143 } 4144 } 4145 4146 if (cmd != RTM_NEWADDR) 4147 return ia; 4148 4149 #ifdef IN_IFF_NOTUSEABLE 4150 if (!(ia->addr_flags & IN_IFF_NOTUSEABLE)) 4151 dhcp_finish_dad(ifp, &ia->addr); 4152 else if (ia->addr_flags & IN_IFF_DUPLICATED) 4153 return dhcp_addr_duplicated(ifp, &ia->addr) ? NULL : ia; 4154 #endif 4155 4156 ifo = ifp->options; 4157 if (ifo->options & DHCPCD_INFORM) { 4158 if (state->state != DHS_INFORM) 4159 dhcp_inform(ifp); 4160 return ia; 4161 } 4162 4163 if (!(ifo->options & DHCPCD_STATIC)) 4164 return ia; 4165 if (ifo->req_addr.s_addr != INADDR_ANY) 4166 return ia; 4167 4168 free(state->old); 4169 state->old = state->new; 4170 state->new_len = dhcp_message_new(&state->new, &ia->addr, &ia->mask); 4171 if (state->new == NULL) 4172 return ia; 4173 if (ifp->flags & IFF_POINTOPOINT) { 4174 for (i = 1; i < 255; i++) 4175 if (i != DHO_ROUTER && has_option_mask(ifo->dstmask,i)) 4176 dhcp_message_add_addr(state->new, i, ia->brd); 4177 } 4178 state->reason = "STATIC"; 4179 rt_build(ifp->ctx, AF_INET); 4180 script_runreason(ifp, state->reason); 4181 if (ifo->options & DHCPCD_INFORM) { 4182 state->state = DHS_INFORM; 4183 dhcp_new_xid(ifp); 4184 state->lease.server.s_addr = INADDR_ANY; 4185 state->addr = ia; 4186 dhcp_inform(ifp); 4187 } 4188 4189 return ia; 4190 } 4191 4192 #ifndef SMALL 4193 int 4194 dhcp_dump(struct interface *ifp) 4195 { 4196 struct dhcp_state *state; 4197 4198 ifp->if_data[IF_DATA_DHCP] = state = calloc(1, sizeof(*state)); 4199 if (state == NULL) { 4200 logerr(__func__); 4201 return -1; 4202 } 4203 state->new_len = read_lease(ifp, &state->new); 4204 if (state->new == NULL) { 4205 logerr("read_lease"); 4206 return -1; 4207 } 4208 state->reason = "DUMP"; 4209 return script_runreason(ifp, state->reason); 4210 } 4211 #endif 4212