1 /* $NetBSD: rarpd.c,v 1.61 2023/03/26 19:10:34 andvar Exp $ */ 2 3 /* 4 * Copyright (c) 1990 The Regents of the University of California. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that: (1) source code distributions 9 * retain the above copyright notice and this paragraph in its entirety, (2) 10 * distributions including binary code include the above copyright notice and 11 * this paragraph in its entirety in the documentation or other materials 12 * provided with the distribution. Neither the name of 13 * the University nor the names of its contributors may be used to endorse 14 * or promote products derived from this software without specific prior 15 * written permission. 16 * 17 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED 18 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF 19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. 20 */ 21 #include <sys/cdefs.h> 22 #ifndef lint 23 __COPYRIGHT("@(#) Copyright (c) 1990\ 24 The Regents of the University of California. All rights reserved."); 25 #endif /* not lint */ 26 27 #ifndef lint 28 __RCSID("$NetBSD: rarpd.c,v 1.61 2023/03/26 19:10:34 andvar Exp $"); 29 #endif 30 31 32 /* 33 * rarpd - Reverse ARP Daemon 34 * 35 * Usage: rarpd -a [-d|-f] [-l] 36 * rarpd [-d|-f] [-l] interface [...] 37 */ 38 39 #include <sys/param.h> 40 #include <sys/file.h> 41 #include <sys/time.h> 42 #include <sys/socket.h> 43 #include <sys/ioctl.h> 44 45 #include <net/bpf.h> 46 #include <net/if.h> 47 #include <net/if_dl.h> 48 #ifdef __NetBSD__ 49 #include <net/if_ether.h> 50 #endif 51 #include <net/if_types.h> 52 #include <netinet/in.h> 53 #ifdef __NetBSD__ 54 #include <netinet/if_inarp.h> 55 #else 56 #include <netinet/if_ether.h> 57 #endif 58 59 #include <arpa/inet.h> 60 61 #include <errno.h> 62 #include <dirent.h> 63 #include <paths.h> 64 #include <netdb.h> 65 #include <stdio.h> 66 #include <stdlib.h> 67 #include <string.h> 68 #include <syslog.h> 69 #include <unistd.h> 70 #include <util.h> 71 #include <ifaddrs.h> 72 73 #define FATAL 1 /* fatal error occurred */ 74 #define NONFATAL 0 /* non fatal error occurred */ 75 76 /* 77 * The structure for each interface. 78 */ 79 struct if_info { 80 int ii_fd; /* BPF file descriptor */ 81 u_char ii_eaddr[6]; /* Ethernet address of this interface */ 82 u_int32_t ii_ipaddr; /* IP address of this interface */ 83 u_int32_t ii_netmask; /* subnet or net mask */ 84 char *ii_name; /* interface name */ 85 struct if_info *ii_alias; 86 struct if_info *ii_next; 87 }; 88 /* 89 * The list of all interfaces that are being listened to. rarp_loop() 90 * "selects" on the descriptors in this list. 91 */ 92 static struct if_info *iflist; 93 94 static u_int32_t choose_ipaddr(u_int32_t **, u_int32_t, u_int32_t); 95 static void debug(const char *,...) __printflike(1, 2); 96 static void init_some(char *name); 97 static void init_one(char *, u_int32_t); 98 static u_int32_t ipaddrtonetmask(u_int32_t); 99 static void lookup_eaddr(char *, u_char *); 100 static void lookup_ipaddr(char *, u_int32_t *, u_int32_t *); 101 static void rarp_loop(void) __dead; 102 static int rarp_open(char *); 103 static void rarp_process(struct if_info *, u_char *); 104 static void rarp_reply(struct if_info *, struct ether_header *, u_int32_t, 105 struct hostent *); 106 static void rarperr(int, const char *,...) __printflike(2, 3); 107 108 #if defined(__NetBSD__) 109 #include "mkarp.h" 110 #else 111 static void update_arptab(u_char *, u_int32_t); 112 #endif 113 114 __dead static void usage(void); 115 116 static int bpf_open(void); 117 static int rarp_check(u_char *, int); 118 119 #ifdef REQUIRE_TFTPBOOT 120 static int rarp_bootable(u_int32_t); 121 #endif 122 123 static int aflag = 0; /* listen on "all" interfaces */ 124 static int dflag = 0; /* print debugging messages */ 125 static int fflag = 0; /* don't fork */ 126 static int lflag = 0; /* log all replies */ 127 128 int 129 main(int argc, char **argv) 130 { 131 int op; 132 133 setprogname(*argv); 134 /* All error reporting is done through syslogs. */ 135 openlog(getprogname(), LOG_PID, LOG_DAEMON); 136 137 opterr = 0; 138 while ((op = getopt(argc, argv, "adfl")) != -1) { 139 switch (op) { 140 case 'a': 141 ++aflag; 142 break; 143 144 case 'd': 145 ++dflag; 146 break; 147 148 case 'f': 149 ++fflag; 150 break; 151 152 case 'l': 153 ++lflag; 154 break; 155 156 default: 157 usage(); 158 /* NOTREACHED */ 159 } 160 } 161 argc -= optind; 162 argv += optind; 163 164 if ((aflag && argc != 0) || (!aflag && argc == 0)) 165 usage(); 166 167 if ((!fflag) && (!dflag)) { 168 if (daemon(0, 0)) 169 rarperr(FATAL, "daemon"); 170 pidfile(NULL); 171 } 172 173 if (aflag) 174 init_some(NULL); 175 else { 176 while (argc--) 177 init_some(*argv++); 178 } 179 180 rarp_loop(); 181 /* NOTREACHED */ 182 return (0); 183 } 184 185 /* 186 * Add 'ifname' to the interface list. Lookup its IP address and network 187 * mask and Ethernet address, and open a BPF file for it. 188 */ 189 static void 190 init_one(char *ifname, u_int32_t ipaddr) 191 { 192 struct if_info *h; 193 struct if_info *p; 194 int fd; 195 196 for (h = iflist; h != NULL; h = h->ii_next) { 197 if (!strcmp(h->ii_name, ifname)) 198 break; 199 } 200 if (h == NULL) { 201 fd = rarp_open(ifname); 202 if (fd < 0) 203 return; 204 } else { 205 fd = h->ii_fd; 206 } 207 208 p = (struct if_info *)malloc(sizeof(*p)); 209 if (p == 0) { 210 rarperr(FATAL, "malloc: %s", strerror(errno)); 211 /* NOTREACHED */ 212 } 213 p->ii_name = strdup(ifname); 214 if (p->ii_name == 0) { 215 rarperr(FATAL, "malloc: %s", strerror(errno)); 216 /* NOTREACHED */ 217 } 218 if (h != NULL) { 219 p->ii_alias = h->ii_alias; 220 h->ii_alias = p; 221 } else { 222 p->ii_next = iflist; 223 iflist = p; 224 } 225 226 p->ii_fd = fd; 227 p->ii_ipaddr = ipaddr; 228 lookup_eaddr(ifname, p->ii_eaddr); 229 lookup_ipaddr(ifname, &p->ii_ipaddr, &p->ii_netmask); 230 } 231 232 /* 233 * Initialize all "candidate" interfaces that are in the system 234 * configuration list. A "candidate" is up, not loopback and not 235 * point to point. 236 */ 237 static void 238 init_some(char *name) 239 { 240 struct ifaddrs *ifap, *ifa, *p; 241 242 if (getifaddrs(&ifap) != 0) { 243 rarperr(FATAL, "getifaddrs: %s", strerror(errno)); 244 /* NOTREACHED */ 245 } 246 247 p = NULL; 248 for (ifa = ifap; ifa; ifa = ifa->ifa_next) { 249 #define SIN(s) ((struct sockaddr_in *) (s)) 250 if (ifa->ifa_addr->sa_family != AF_INET) 251 continue; 252 if (name && strcmp(name, ifa->ifa_name)) 253 continue; 254 if (p && !strcmp(p->ifa_name, ifa->ifa_name) && 255 SIN(p->ifa_addr)->sin_addr.s_addr == SIN(ifa->ifa_addr)->sin_addr.s_addr) 256 continue; 257 p = ifa; 258 if ((ifa->ifa_flags & 259 (IFF_UP | IFF_LOOPBACK | IFF_POINTOPOINT)) != IFF_UP) 260 continue; 261 init_one(ifa->ifa_name, SIN(ifa->ifa_addr)->sin_addr.s_addr); 262 #undef SIN 263 } 264 freeifaddrs(ifap); 265 } 266 267 static void 268 usage(void) 269 { 270 (void) fprintf(stderr, "Usage: %s -a [-d|-f] [-l]\n", getprogname()); 271 (void) fprintf(stderr, "\t%s [-d|-f] [-l] interface [...]\n", 272 getprogname()); 273 exit(1); 274 } 275 276 static int 277 bpf_open(void) 278 { 279 int fd; 280 const char *device = _PATH_BPF; 281 fd = open(device, O_RDWR); 282 283 if (fd < 0) { 284 rarperr(FATAL, "%s: %s", device, strerror(errno)); 285 /* NOTREACHED */ 286 } 287 return fd; 288 } 289 /* 290 * Open a BPF file and attach it to the interface named 'device'. 291 * Set immediate mode, and set a filter that accepts only RARP requests. 292 */ 293 static int 294 rarp_open(char *device) 295 { 296 int fd; 297 struct ifreq ifr; 298 u_int dlt; 299 int immediate; 300 u_int bufsize; 301 302 static struct bpf_insn insns[] = { 303 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 12), 304 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, ETHERTYPE_REVARP, 0, 3), 305 BPF_STMT(BPF_LD | BPF_H | BPF_ABS, 20), 306 BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, ARPOP_REVREQUEST, 0, 1), 307 BPF_STMT(BPF_RET | BPF_K, 308 sizeof(struct arphdr) + 309 2 * ETHER_ADDR_LEN + 2 * sizeof(struct in_addr) + 310 sizeof(struct ether_header)), 311 BPF_STMT(BPF_RET | BPF_K, 0), 312 }; 313 static struct bpf_program filter = { 314 sizeof insns / sizeof(insns[0]), 315 insns 316 }; 317 318 fd = bpf_open(); 319 320 /* Set immediate mode so packets are processed as they arrive. */ 321 immediate = 1; 322 if (ioctl(fd, BIOCIMMEDIATE, &immediate) < 0) { 323 rarperr(FATAL, "BIOCIMMEDIATE: %s", strerror(errno)); 324 /* NOTREACHED */ 325 } 326 /* Set a 32k buffer size for kernel use */ 327 bufsize = 32768; 328 if (ioctl(fd, BIOCSBLEN, &bufsize) < 0) { 329 rarperr(NONFATAL, "BIOCSBLEN:%d: %s", bufsize, strerror(errno)); 330 } 331 (void)strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name)); 332 if (ioctl(fd, BIOCSETIF, (caddr_t) & ifr) < 0) { 333 if (aflag) { /* for -a skip non-ethernet interfaces */ 334 close(fd); 335 return(-1); 336 } 337 rarperr(FATAL, "BIOCSETIF: %s", strerror(errno)); 338 /* NOTREACHED */ 339 } 340 /* Check that the data link layer is an Ethernet; this code won't work 341 * with anything else. */ 342 if (ioctl(fd, BIOCGDLT, (caddr_t) & dlt) < 0) { 343 rarperr(FATAL, "BIOCGDLT: %s", strerror(errno)); 344 /* NOTREACHED */ 345 } 346 if (dlt != DLT_EN10MB) { 347 if (aflag) { /* for -a skip non-ethernet interfaces */ 348 close(fd); 349 return(-1); 350 } 351 rarperr(FATAL, "%s is not an ethernet", device); 352 /* NOTREACHED */ 353 } 354 /* Set filter program. */ 355 if (ioctl(fd, BIOCSETF, (caddr_t) & filter) < 0) { 356 rarperr(FATAL, "BIOCSETF: %s", strerror(errno)); 357 /* NOTREACHED */ 358 } 359 return fd; 360 } 361 /* 362 * Perform various sanity checks on the RARP request packet. Return 363 * false on failure and log the reason. 364 */ 365 static int 366 rarp_check(u_char *p, int len) 367 { 368 struct ether_header *ep = (struct ether_header *) p; 369 #ifdef __NetBSD__ 370 struct arphdr *ap = (struct arphdr *) (p + sizeof(*ep)); 371 #else 372 struct ether_arp *ap = (struct ether_arp *) (p + sizeof(*ep)); 373 #endif 374 375 if (len < (int)(sizeof(*ep) + sizeof(*ap))) { 376 rarperr(NONFATAL, "truncated request"); 377 return 0; 378 } 379 #ifdef __NetBSD__ 380 /* now that we know the fixed part of the ARP hdr is there: */ 381 if (len < (int)(sizeof(*ap) + 2 * ap->ar_hln + 2 * ap->ar_pln)) { 382 rarperr(NONFATAL, "truncated request"); 383 return 0; 384 } 385 #endif 386 /* XXX This test might be better off broken out... */ 387 #ifdef __FreeBSD__ 388 /* BPF (incorrectly) returns this in host order. */ 389 if (ep->ether_type != ETHERTYPE_REVARP || 390 #else 391 if (ntohs (ep->ether_type) != ETHERTYPE_REVARP || 392 #endif 393 #ifdef __NetBSD__ 394 ntohs (ap->ar_hrd) != ARPHRD_ETHER || 395 ntohs (ap->ar_op) != ARPOP_REVREQUEST || 396 ntohs (ap->ar_pro) != ETHERTYPE_IP || 397 ap->ar_hln != 6 || ap->ar_pln != 4) { 398 #else 399 ntohs (ap->arp_hrd) != ARPHRD_ETHER || 400 ntohs (ap->arp_op) != ARPOP_REVREQUEST || 401 ntohs (ap->arp_pro) != ETHERTYPE_IP || 402 ap->arp_hln != 6 || ap->arp_pln != 4) { 403 #endif 404 rarperr(NONFATAL, "request fails sanity check"); 405 return 0; 406 } 407 #ifdef __NetBSD__ 408 if (memcmp((char *) &ep->ether_shost, ar_sha(ap), 6) != 0) { 409 #else 410 if (memcmp((char *) &ep->ether_shost, ap->arp_sha, 6) != 0) { 411 #endif 412 rarperr(NONFATAL, "ether/arp sender address mismatch"); 413 return 0; 414 } 415 { 416 #ifdef __NetBSD__ 417 uint8_t *tha = ar_tha(ap); 418 419 if (!tha || memcmp(ar_sha(ap), tha, 6) != 0) { 420 #else 421 if (memcmp((char *) &ap->arp_sha, (char *) &ap->arp_tha, 6) != 0) { 422 #endif 423 rarperr(NONFATAL, "ether/arp target address mismatch"); 424 return 0; 425 } 426 } 427 return 1; 428 } 429 430 /* 431 * Loop indefinitely listening for RARP requests on the 432 * interfaces in 'iflist'. 433 */ 434 static void 435 rarp_loop(void) 436 { 437 u_char *buf, *bp, *ep; 438 int cc, fd; 439 fd_set fds, listeners; 440 int bufsize, maxfd = 0; 441 struct if_info *ii; 442 443 if (iflist == 0) { 444 rarperr(FATAL, "no interfaces"); 445 /* NOTREACHED */ 446 } 447 if (ioctl(iflist->ii_fd, BIOCGBLEN, (caddr_t) & bufsize) < 0) { 448 rarperr(FATAL, "BIOCGBLEN: %s", strerror(errno)); 449 /* NOTREACHED */ 450 } 451 buf = (u_char *) malloc((unsigned) bufsize); 452 if (buf == 0) { 453 rarperr(FATAL, "malloc: %s", strerror(errno)); 454 /* NOTREACHED */ 455 } 456 /* 457 * Find the highest numbered file descriptor for select(). 458 * Initialize the set of descriptors to listen to. 459 */ 460 FD_ZERO(&fds); 461 for (ii = iflist; ii; ii = ii->ii_next) { 462 FD_SET(ii->ii_fd, &fds); 463 if (ii->ii_fd > maxfd) 464 maxfd = ii->ii_fd; 465 } 466 while (1) { 467 listeners = fds; 468 if (select(maxfd + 1, &listeners, (struct fd_set *) 0, 469 (struct fd_set *) 0, (struct timeval *) 0) < 0) { 470 rarperr(FATAL, "select: %s", strerror(errno)); 471 /* NOTREACHED */ 472 } 473 for (ii = iflist; ii; ii = ii->ii_next) { 474 fd = ii->ii_fd; 475 if (!FD_ISSET(fd, &listeners)) 476 continue; 477 again: 478 cc = read(fd, (char *) buf, bufsize); 479 /* Don't choke when we get ptraced */ 480 if (cc < 0 && errno == EINTR) 481 goto again; 482 /* Due to a SunOS bug, after 2^31 bytes, the file 483 * offset overflows and read fails with EINVAL. The 484 * lseek() to 0 will fix things. */ 485 if (cc < 0) { 486 if (errno == EINVAL && 487 (lseek(fd, 0, SEEK_CUR) + bufsize) < 0) { 488 (void)lseek(fd, 0, 0); 489 goto again; 490 } 491 rarperr(FATAL, "read: %s", strerror(errno)); 492 /* NOTREACHED */ 493 } 494 /* Loop through the packet(s) */ 495 #define bhp ((struct bpf_hdr *)bp) 496 bp = buf; 497 ep = bp + cc; 498 while (bp < ep) { 499 int caplen, hdrlen; 500 501 caplen = bhp->bh_caplen; 502 hdrlen = bhp->bh_hdrlen; 503 debug("received packet on %s", ii->ii_name); 504 505 if (rarp_check(bp + hdrlen, caplen)) 506 rarp_process(ii, bp + hdrlen); 507 bp += BPF_WORDALIGN(hdrlen + caplen); 508 } 509 } 510 } 511 } 512 513 #ifdef REQUIRE_TFTPBOOT 514 515 #ifndef TFTP_DIR 516 #define TFTP_DIR "/tftpboot" 517 #endif 518 519 /* 520 * True if this server can boot the host whose IP address is 'addr'. 521 * This check is made by looking in the tftp directory for the 522 * configuration file. 523 */ 524 static int 525 rarp_bootable(u_int32_t addr) 526 { 527 struct dirent *dent; 528 DIR *d; 529 char ipname[9]; 530 static DIR *dd = 0; 531 532 (void)snprintf(ipname, sizeof(ipname), "%08X", addr); 533 /* If directory is already open, rewind it. Otherwise, open it. */ 534 if (d = dd) 535 rewinddir(d); 536 else { 537 if (chdir(TFTP_DIR) == -1) { 538 rarperr(FATAL, "chdir: %s", strerror(errno)); 539 /* NOTREACHED */ 540 } 541 d = opendir("."); 542 if (d == 0) { 543 rarperr(FATAL, "opendir: %s", strerror(errno)); 544 /* NOTREACHED */ 545 } 546 dd = d; 547 } 548 while (dent = readdir(d)) 549 if (strncmp(dent->d_name, ipname, 8) == 0) 550 return 1; 551 return 0; 552 } 553 #endif /* REQUIRE_TFTPBOOT */ 554 555 /* 556 * Given a list of IP addresses, 'alist', return the first address that 557 * is on network 'net'; 'netmask' is a mask indicating the network portion 558 * of the address. 559 */ 560 static u_int32_t 561 choose_ipaddr(u_int32_t **alist, u_int32_t net, u_int32_t netmask) 562 { 563 564 for (; *alist; ++alist) { 565 if ((**alist & netmask) == net) 566 return **alist; 567 } 568 return 0; 569 } 570 /* 571 * Answer the RARP request in 'pkt', on the interface 'ii'. 'pkt' has 572 * already been checked for validity. The reply is overlaid on the request. 573 */ 574 static void 575 rarp_process(struct if_info *ii, u_char *pkt) 576 { 577 struct ether_header *ep; 578 struct hostent *hp; 579 u_int32_t target_ipaddr = 0; 580 char ename[MAXHOSTNAMELEN + 1]; 581 struct in_addr in; 582 583 ep = (struct ether_header *) pkt; 584 585 if (ether_ntohost(ename, (struct ether_addr *)&ep->ether_shost) != 0) { 586 debug("no IP address for %s", 587 ether_ntoa((struct ether_addr *)&ep->ether_shost)); 588 return; 589 } 590 ename[sizeof(ename)-1] = '\0'; 591 592 if ((hp = gethostbyname(ename)) == 0) { 593 debug("gethostbyname(%s) failed: %s", ename, 594 hstrerror(h_errno)); 595 return; 596 } 597 598 /* Choose correct address from list. */ 599 if (hp->h_addrtype != AF_INET) { 600 rarperr(FATAL, "cannot handle non IP addresses"); 601 /* NOTREACHED */ 602 } 603 for (;; ii = ii->ii_alias) { 604 target_ipaddr = choose_ipaddr((u_int32_t **) hp->h_addr_list, 605 ii->ii_ipaddr & ii->ii_netmask, ii->ii_netmask); 606 if (target_ipaddr != 0) 607 break; 608 if (ii->ii_alias == NULL) 609 break; 610 } 611 612 if (target_ipaddr == 0) { 613 in.s_addr = ii->ii_ipaddr & ii->ii_netmask; 614 rarperr(NONFATAL, "cannot find %s on net %s", 615 ename, inet_ntoa(in)); 616 return; 617 } 618 #ifdef REQUIRE_TFTPBOOT 619 if (rarp_bootable(htonl(target_ipaddr))) 620 #endif 621 rarp_reply(ii, ep, target_ipaddr, hp); 622 #ifdef REQUIRE_TFTPBOOT 623 else 624 debug("%08X not bootable", htonl(target_ipaddr)); 625 #endif 626 } 627 /* 628 * Lookup the ethernet address of the interface attached to the BPF 629 * file descriptor 'fd'; return it in 'eaddr'. 630 */ 631 static void 632 lookup_eaddr(char *ifname, u_char *eaddr) 633 { 634 struct ifaddrs *ifap, *ifa; 635 struct sockaddr_dl *sdl; 636 637 if (getifaddrs(&ifap) != 0) { 638 rarperr(FATAL, "getifaddrs: %s", strerror(errno)); 639 /* NOTREACHED */ 640 } 641 642 for (ifa = ifap; ifa; ifa = ifa->ifa_next) { 643 sdl = (struct sockaddr_dl *)ifa->ifa_addr; 644 if (sdl->sdl_family != AF_LINK || sdl->sdl_type != IFT_ETHER || 645 sdl->sdl_alen != 6) 646 continue; 647 if (!strcmp(ifa->ifa_name, ifname)) { 648 memmove((caddr_t)eaddr, (caddr_t)LLADDR(sdl), 6); 649 debug("%s: %x:%x:%x:%x:%x:%x", 650 ifa->ifa_name, eaddr[0], eaddr[1], 651 eaddr[2], eaddr[3], eaddr[4], eaddr[5]); 652 freeifaddrs(ifap); 653 return; 654 } 655 } 656 rarperr(FATAL, "lookup_eaddr: Never saw interface `%s'!", ifname); 657 freeifaddrs(ifap); 658 } 659 /* 660 * Lookup the IP address and network mask of the interface named 'ifname'. 661 */ 662 static void 663 lookup_ipaddr(char *ifname, u_int32_t *addrp, u_int32_t *netmaskp) 664 { 665 int fd; 666 667 /* Use datagram socket to get IP address. */ 668 if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) { 669 rarperr(FATAL, "socket: %s", strerror(errno)); 670 /* NOTREACHED */ 671 } 672 if (*addrp == INADDR_ANY) { 673 struct ifreq ifr; 674 memset(&ifr, 0, sizeof(ifr)); 675 (void)strncpy(ifr.ifr_name, ifname, sizeof ifr.ifr_name); 676 if (ioctl(fd, SIOCGIFADDR, (char *) &ifr) < 0) { 677 rarperr(FATAL, "SIOCGIFADDR: %s", strerror(errno)); 678 /* NOTREACHED */ 679 } 680 *addrp = ((struct sockaddr_in *) & ifr.ifr_addr)->sin_addr.s_addr; 681 if (ioctl(fd, SIOCGIFNETMASK, (char *) &ifr) < 0) { 682 perror("SIOCGIFNETMASK"); 683 exit(1); 684 } 685 *netmaskp = ((struct sockaddr_in *) & ifr.ifr_addr)->sin_addr.s_addr; 686 } else { 687 struct ifaliasreq ifra; 688 memset(&ifra, 0, sizeof(ifra)); 689 (void)strncpy(ifra.ifra_name, ifname, sizeof ifra.ifra_name); 690 ((struct sockaddr_in *) & ifra.ifra_addr)->sin_family = AF_INET; 691 ((struct sockaddr_in *) & ifra.ifra_addr)->sin_addr.s_addr = *addrp; 692 if (ioctl(fd, SIOCGIFALIAS, (char *) &ifra) < 0) { 693 rarperr(FATAL, "SIOCGIFALIAS: %s", strerror(errno)); 694 /* NOTREACHED */ 695 } 696 *addrp = ((struct sockaddr_in *) & ifra.ifra_addr)->sin_addr.s_addr; 697 *netmaskp = ((struct sockaddr_in *) & ifra.ifra_mask)->sin_addr.s_addr; 698 } 699 /* If SIOCGIFNETMASK didn't work, figure out a mask from the IP 700 * address class. */ 701 if (*netmaskp == 0) 702 *netmaskp = ipaddrtonetmask(*addrp); 703 704 (void)close(fd); 705 } 706 /* 707 * Poke the kernel arp tables with the ethernet/ip address combination 708 * given. When processing a reply, we must do this so that the booting 709 * host (i.e. the guy running rarpd), won't try to ARP for the hardware 710 * address of the guy being booted (he cannot answer the ARP). 711 */ 712 #ifndef __NetBSD__ 713 static void 714 update_arptab(u_char *ep, u_int32_t ipaddr) 715 { 716 struct arpreq request; 717 struct sockaddr_in *sin; 718 719 request.arp_flags = 0; 720 sin = (struct sockaddr_in *) & request.arp_pa; 721 sin->sin_family = AF_INET; 722 sin->sin_addr.s_addr = ipaddr; 723 request.arp_ha.sa_family = AF_UNSPEC; 724 /* This is needed #if defined(COMPAT_43) && BYTE_ORDER != BIG_ENDIAN, 725 because AF_UNSPEC is zero and the kernel assumes that a zero 726 sa_family means that the real sa_family value is in sa_len. */ 727 request.arp_ha.sa_len = 16; /* XXX */ 728 memmove((char *) request.arp_ha.sa_data, (char *)ep, 6); 729 730 #if 0 731 s = socket(AF_INET, SOCK_DGRAM, 0); 732 if (ioctl(s, SIOCSARP, (caddr_t) & request) < 0) { 733 rarperr(NONFATAL, "SIOCSARP: %s", strerror(errno)); 734 } 735 (void)close(s); 736 #endif 737 } 738 #endif 739 740 /* 741 * Build a reverse ARP packet and sent it out on the interface. 742 * 'ep' points to a valid ARPOP_REVREQUEST. The ARPOP_REVREPLY is built 743 * on top of the request, then written to the network. 744 * 745 * RFC 903 defines the ether_arp fields as follows. The following comments 746 * are taken (more or less) straight from this document. 747 * 748 * ARPOP_REVREQUEST 749 * 750 * arp_sha is the hardware address of the sender of the packet. 751 * arp_spa is undefined. 752 * arp_tha is the 'target' hardware address. 753 * In the case where the sender wishes to determine his own 754 * protocol address, this, like arp_sha, will be the hardware 755 * address of the sender. 756 * arp_tpa is undefined. 757 * 758 * ARPOP_REVREPLY 759 * 760 * arp_sha is the hardware address of the responder (the sender of the 761 * reply packet). 762 * arp_spa is the protocol address of the responder (see the note below). 763 * arp_tha is the hardware address of the target, and should be the same as 764 * that which was given in the request. 765 * arp_tpa is the protocol address of the target, that is, the desired address. 766 * 767 * Note that the requirement that arp_spa be filled in with the responder's 768 * protocol is purely for convenience. For instance, if a system were to use 769 * both ARP and RARP, then the inclusion of the valid protocol-hardware 770 * address pair (arp_spa, arp_sha) may eliminate the need for a subsequent 771 * ARP request. 772 */ 773 static void 774 rarp_reply(struct if_info *ii, struct ether_header *ep, u_int32_t ipaddr, 775 struct hostent *hp) 776 { 777 int n; 778 #ifdef __NetBSD__ 779 struct arphdr *ap = (struct arphdr *) (ep + 1); 780 #else 781 struct ether_arp *ap = (struct ether_arp *) (ep + 1); 782 #endif 783 784 int len; 785 786 #ifdef __NetBSD__ 787 (void)mkarp((u_int8_t *)ar_sha(ap), ipaddr); 788 #else 789 update_arptab((u_char *) & ap->arp_sha, ipaddr); 790 #endif 791 792 /* Build the rarp reply by modifying the rarp request in place. */ 793 #ifdef __FreeBSD__ 794 /* BPF (incorrectly) wants this in host order. */ 795 ep->ether_type = ETHERTYPE_REVARP; 796 #else 797 ep->ether_type = htons(ETHERTYPE_REVARP); 798 #endif 799 #ifdef __NetBSD__ 800 ap->ar_hrd = htons(ARPHRD_ETHER); 801 ap->ar_pro = htons(ETHERTYPE_IP); 802 ap->ar_op = htons(ARPOP_REVREPLY); 803 804 memmove((char *) &ep->ether_dhost, ar_sha(ap), 6); 805 memmove((char *) &ep->ether_shost, (char *) ii->ii_eaddr, 6); 806 memmove(ar_sha(ap), (char *) ii->ii_eaddr, 6); 807 808 memmove(ar_tpa(ap), (char *) &ipaddr, 4); 809 /* Target hardware is unchanged. */ 810 memmove(ar_spa(ap), (char *) &ii->ii_ipaddr, 4); 811 812 len = sizeof(*ep) + sizeof(*ap) + 813 2 * ap->ar_pln + 2 * ap->ar_hln; 814 #else 815 ap->ea_hdr.ar_hrd = htons(ARPHRD_ETHER); 816 ap->ea_hdr.ar_pro = htons(ETHERTYPE_IP); 817 ap->arp_op = htons(ARPOP_REVREPLY); 818 819 memmove((char *) &ep->ether_dhost, (char *) &ap->arp_sha, 6); 820 memmove((char *) &ep->ether_shost, (char *) ii->ii_eaddr, 6); 821 memmove((char *) &ap->arp_sha, (char *) ii->ii_eaddr, 6); 822 823 memmove((char *) ap->arp_tpa, (char *) &ipaddr, 4); 824 /* Target hardware is unchanged. */ 825 memmove((char *) ap->arp_spa, (char *) &ii->ii_ipaddr, 4); 826 827 len = sizeof(*ep) + sizeof(*ap); 828 #endif 829 830 debug("%s asked; %s replied", 831 ether_ntoa((struct ether_addr *)ar_tha(ap)), hp->h_name); 832 if (lflag) 833 syslog(LOG_INFO, "%s asked; %s replied", 834 ether_ntoa((struct ether_addr *)ar_tha(ap)), hp->h_name); 835 n = write(ii->ii_fd, (char *) ep, len); 836 if (n != len) { 837 rarperr(NONFATAL, "write: only %d of %d bytes written", n, len); 838 } 839 } 840 /* 841 * Get the netmask of an IP address. This routine is used if 842 * SIOCGIFNETMASK doesn't work. 843 */ 844 static u_int32_t 845 ipaddrtonetmask(u_int32_t addr) 846 { 847 848 if (IN_CLASSA(addr)) 849 return IN_CLASSA_NET; 850 if (IN_CLASSB(addr)) 851 return IN_CLASSB_NET; 852 if (IN_CLASSC(addr)) 853 return IN_CLASSC_NET; 854 rarperr(FATAL, "unknown IP address class: %08X", addr); 855 /* NOTREACHED */ 856 return(-1); 857 } 858 859 #include <stdarg.h> 860 861 static void 862 rarperr(int fatal, const char *fmt,...) 863 { 864 va_list ap; 865 866 va_start(ap, fmt); 867 if (dflag) { 868 if (fatal) 869 (void)fprintf(stderr, "%s: error: ", getprogname()); 870 else 871 (void)fprintf(stderr, "%s: warning: ", getprogname()); 872 (void)vfprintf(stderr, fmt, ap); 873 va_end(ap); 874 va_start(ap, fmt); 875 (void)fprintf(stderr, "\n"); 876 } 877 vsyslog(LOG_ERR, fmt, ap); 878 va_end(ap); 879 if (fatal) 880 exit(1); 881 /* NOTREACHED */ 882 } 883 884 static void 885 debug(const char *fmt,...) 886 { 887 va_list ap; 888 889 va_start(ap, fmt); 890 if (dflag) { 891 (void)fprintf(stderr, "%s: ", getprogname()); 892 (void)vfprintf(stderr, fmt, ap); 893 va_end(ap); 894 va_start(ap, fmt); 895 (void)fprintf(stderr, "\n"); 896 } 897 vsyslog(LOG_WARNING, fmt, ap); 898 va_end(ap); 899 } 900
Indexes created Mon Sep 22 13:09:51 GMT 2025