1 /* 2 * Copyright (c) 1990, 1991, 1992, 1993, 1996 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that: (1) source code distributions 7 * retain the above copyright notice and this paragraph in its entirety, (2) 8 * distributions including binary code include the above copyright notice and 9 * this paragraph in its entirety in the documentation or other materials 10 * provided with the distribution 11 * 12 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED 13 * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF 14 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. 15 * 16 * @(#) Copyright (c) 1990, 1991, 1992, 1993, 1996 The Regents of the University of California. All rights reserved. 17 * $FreeBSD: src/usr.sbin/rarpd/rarpd.c,v 1.41 2004/08/07 04:28:54 imp Exp $ 18 * $DragonFly: src/usr.sbin/rarpd/rarpd.c,v 1.4 2004/12/18 22:48:05 swildner Exp $ 19 */ 20 21 /* 22 * rarpd - Reverse ARP Daemon 23 * 24 * Usage: rarpd -a [-dfsv] [-t directory] [hostname] 25 * rarpd [-dfsv] [-t directory] interface [hostname] 26 * 27 * 'hostname' is optional solely for backwards compatibility with Sun's rarpd. 28 * Currently, the argument is ignored. 29 */ 30 #include <sys/param.h> 31 #include <sys/file.h> 32 #include <sys/ioctl.h> 33 #include <sys/socket.h> 34 #include <sys/time.h> 35 36 #include <net/bpf.h> 37 #include <net/ethernet.h> 38 #include <net/if.h> 39 #include <net/if_types.h> 40 #include <net/if_dl.h> 41 #include <net/route.h> 42 43 #include <netinet/in.h> 44 #include <netinet/if_ether.h> 45 46 #include <arpa/inet.h> 47 48 #include <dirent.h> 49 #include <errno.h> 50 #include <ifaddrs.h> 51 #include <netdb.h> 52 #include <stdarg.h> 53 #include <stdio.h> 54 #include <string.h> 55 #include <syslog.h> 56 #include <stdlib.h> 57 #include <unistd.h> 58 59 /* Cast a struct sockaddr to a struct sockaddr_in */ 60 #define SATOSIN(sa) ((struct sockaddr_in *)(sa)) 61 62 #ifndef TFTP_DIR 63 #define TFTP_DIR "/tftpboot" 64 #endif 65 66 #define ARPSECS (20 * 60) /* as per code in netinet/if_ether.c */ 67 #define REVARP_REQUEST ARPOP_REVREQUEST 68 #define REVARP_REPLY ARPOP_REVREPLY 69 70 /* 71 * The structure for each interface. 72 */ 73 struct if_info { 74 struct if_info *ii_next; 75 int ii_fd; /* BPF file descriptor */ 76 in_addr_t ii_ipaddr; /* IP address */ 77 in_addr_t ii_netmask; /* subnet or net mask */ 78 u_char ii_eaddr[ETHER_ADDR_LEN]; /* ethernet address */ 79 char ii_ifname[IF_NAMESIZE]; 80 }; 81 82 /* 83 * The list of all interfaces that are being listened to. rarp_loop() 84 * "selects" on the descriptors in this list. 85 */ 86 struct if_info *iflist; 87 88 int verbose; /* verbose messages */ 89 const char *tftp_dir = TFTP_DIR; /* tftp directory */ 90 91 int dflag; /* messages to stdout/stderr, not syslog(3) */ 92 int sflag; /* ignore /tftpboot */ 93 94 static u_char zero[6]; 95 96 static int bpf_open(void); 97 static in_addr_t choose_ipaddr(in_addr_t **, in_addr_t, in_addr_t); 98 static char *eatoa(u_char *); 99 static int expand_syslog_m(const char *fmt, char **newfmt); 100 static void init(char *); 101 static void init_one(struct ifaddrs *, char *, int); 102 static char *intoa(in_addr_t); 103 static in_addr_t ipaddrtonetmask(in_addr_t); 104 static void logmsg(int, const char *, ...) __printflike(2, 3); 105 static int rarp_bootable(in_addr_t); 106 static int rarp_check(u_char *, u_int); 107 static void rarp_loop(void); 108 static int rarp_open(char *); 109 static void rarp_process(struct if_info *, u_char *, u_int); 110 static void rarp_reply(struct if_info *, struct ether_header *, 111 in_addr_t, u_int); 112 static void update_arptab(u_char *, in_addr_t); 113 static void usage(void); 114 115 int 116 main(int argc, char *argv[]) 117 { 118 int op; 119 char *ifname, *hostname, *name; 120 121 int aflag = 0; /* listen on "all" interfaces */ 122 int fflag = 0; /* don't fork */ 123 124 if ((name = strrchr(argv[0], '/')) != NULL) 125 ++name; 126 else 127 name = argv[0]; 128 if (*name == '-') 129 ++name; 130 131 /* 132 * All error reporting is done through syslog, unless -d is specified 133 */ 134 openlog(name, LOG_PID | LOG_CONS, LOG_DAEMON); 135 136 opterr = 0; 137 while ((op = getopt(argc, argv, "adfst:v")) != -1) 138 switch (op) { 139 case 'a': 140 ++aflag; 141 break; 142 143 case 'd': 144 ++dflag; 145 break; 146 147 case 'f': 148 ++fflag; 149 break; 150 151 case 's': 152 ++sflag; 153 break; 154 155 case 't': 156 tftp_dir = optarg; 157 break; 158 159 case 'v': 160 ++verbose; 161 break; 162 163 default: 164 usage(); 165 /* NOTREACHED */ 166 } 167 argc -= optind; 168 argv += optind; 169 170 ifname = (aflag == 0) ? argv[0] : NULL; 171 hostname = ifname ? argv[1] : argv[0]; 172 173 if ((aflag && ifname) || (!aflag && ifname == NULL)) 174 usage(); 175 176 init(ifname); 177 178 if (!fflag) { 179 if (daemon(0,0)) { 180 logmsg(LOG_ERR, "cannot fork"); 181 exit(1); 182 } 183 } 184 rarp_loop(); 185 return(0); 186 } 187 188 /* 189 * Add to the interface list. 190 */ 191 static void 192 init_one(struct ifaddrs *ifa, char *target, int pass1) 193 { 194 struct if_info *ii, *ii2; 195 struct sockaddr_dl *ll; 196 int family; 197 198 family = ifa->ifa_addr->sa_family; 199 switch (family) { 200 case AF_INET: 201 if (pass1) 202 /* Consider only AF_LINK during pass1. */ 203 return; 204 /* FALLTHROUGH */ 205 case AF_LINK: 206 if (!(ifa->ifa_flags & IFF_UP) || 207 (ifa->ifa_flags & (IFF_LOOPBACK | IFF_POINTOPOINT))) 208 return; 209 break; 210 default: 211 return; 212 } 213 214 /* Don't bother going any further if not the target interface */ 215 if (target != NULL && strcmp(ifa->ifa_name, target) != 0) 216 return; 217 218 /* Look for interface in list */ 219 for (ii = iflist; ii != NULL; ii = ii->ii_next) 220 if (strcmp(ifa->ifa_name, ii->ii_ifname) == 0) 221 break; 222 223 if (pass1 && ii != NULL) 224 /* We've already seen that interface once. */ 225 return; 226 227 /* Allocate a new one if not found */ 228 if (ii == NULL) { 229 ii = (struct if_info *)malloc(sizeof(*ii)); 230 if (ii == NULL) { 231 logmsg(LOG_ERR, "malloc: %m"); 232 exit(1); 233 } 234 bzero(ii, sizeof(*ii)); 235 ii->ii_fd = -1; 236 strlcpy(ii->ii_ifname, ifa->ifa_name, sizeof(ii->ii_ifname)); 237 ii->ii_next = iflist; 238 iflist = ii; 239 } else if (!pass1 && ii->ii_ipaddr != 0) { 240 /* 241 * Second AF_INET definition for that interface: clone 242 * the existing one, and work on that cloned one. 243 * This must be another IP address for this interface, 244 * so avoid killing the previous configuration. 245 */ 246 ii2 = (struct if_info *)malloc(sizeof(*ii2)); 247 if (ii2 == NULL) { 248 logmsg(LOG_ERR, "malloc: %m"); 249 exit(1); 250 } 251 memcpy(ii2, ii, sizeof(*ii2)); 252 ii2->ii_fd = -1; 253 ii2->ii_next = iflist; 254 iflist = ii2; 255 256 ii = ii2; 257 } 258 259 switch (family) { 260 case AF_INET: 261 ii->ii_ipaddr = SATOSIN(ifa->ifa_addr)->sin_addr.s_addr; 262 ii->ii_netmask = SATOSIN(ifa->ifa_netmask)->sin_addr.s_addr; 263 if (ii->ii_netmask == 0) 264 ii->ii_netmask = ipaddrtonetmask(ii->ii_ipaddr); 265 if (ii->ii_fd < 0) 266 ii->ii_fd = rarp_open(ii->ii_ifname); 267 break; 268 269 case AF_LINK: 270 ll = (struct sockaddr_dl *)ifa->ifa_addr; 271 if (ll->sdl_type == IFT_ETHER) 272 bcopy(LLADDR(ll), ii->ii_eaddr, 6); 273 break; 274 } 275 } 276 /* 277 * Initialize all "candidate" interfaces that are in the system 278 * configuration list. A "candidate" is up, not loopback and not 279 * point to point. 280 */ 281 static void 282 init(char *target) 283 { 284 struct if_info *ii, *nii, *lii; 285 struct ifaddrs *ifhead, *ifa; 286 int error; 287 288 error = getifaddrs(&ifhead); 289 if (error) { 290 logmsg(LOG_ERR, "getifaddrs: %m"); 291 exit(1); 292 } 293 /* 294 * We make two passes over the list we have got. In the first 295 * one, we only collect AF_LINK interfaces, and initialize our 296 * list of interfaces from them. In the second pass, we 297 * collect the actual IP addresses from the AF_INET 298 * interfaces, and allow for the same interface name to appear 299 * multiple times (in case of more than one IP address). 300 */ 301 for (ifa = ifhead; ifa != NULL; ifa = ifa->ifa_next) 302 init_one(ifa, target, 1); 303 for (ifa = ifhead; ifa != NULL; ifa = ifa->ifa_next) 304 init_one(ifa, target, 0); 305 freeifaddrs(ifhead); 306 307 /* Throw away incomplete interfaces */ 308 lii = NULL; 309 for (ii = iflist; ii != NULL; ii = nii) { 310 nii = ii->ii_next; 311 if (ii->ii_ipaddr == 0 || 312 bcmp(ii->ii_eaddr, zero, 6) == 0) { 313 if (lii == NULL) 314 iflist = nii; 315 else 316 lii->ii_next = nii; 317 if (ii->ii_fd >= 0) 318 close(ii->ii_fd); 319 free(ii); 320 continue; 321 } 322 lii = ii; 323 } 324 325 /* Verbose stuff */ 326 if (verbose) 327 for (ii = iflist; ii != NULL; ii = ii->ii_next) 328 logmsg(LOG_DEBUG, "%s %s 0x%08x %s", 329 ii->ii_ifname, intoa(ntohl(ii->ii_ipaddr)), 330 (in_addr_t)ntohl(ii->ii_netmask), eatoa(ii->ii_eaddr)); 331 } 332 333 static void 334 usage(void) 335 { 336 fprintf(stderr, "%s\n%s\n", 337 "usage: rarpd -a [-dfsv] [-t directory]", 338 " rarpd [-dfsv] [-t directory] interface"); 339 exit(1); 340 } 341 342 static int 343 bpf_open(void) 344 { 345 int fd; 346 int n = 0; 347 char device[sizeof "/dev/bpf000"]; 348 349 /* 350 * Go through all the minors and find one that isn't in use. 351 */ 352 do { 353 sprintf(device, "/dev/bpf%d", n++); 354 fd = open(device, O_RDWR); 355 } while ((fd == -1) && (errno == EBUSY)); 356 357 if (fd == -1) { 358 logmsg(LOG_ERR, "%s: %m", device); 359 exit(1); 360 } 361 return fd; 362 } 363 364 /* 365 * Open a BPF file and attach it to the interface named 'device'. 366 * Set immediate mode, and set a filter that accepts only RARP requests. 367 */ 368 static int 369 rarp_open(char *device) 370 { 371 int fd; 372 struct ifreq ifr; 373 u_int dlt; 374 int immediate; 375 376 static struct bpf_insn insns[] = { 377 BPF_STMT(BPF_LD|BPF_H|BPF_ABS, 12), 378 BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, ETHERTYPE_REVARP, 0, 3), 379 BPF_STMT(BPF_LD|BPF_H|BPF_ABS, 20), 380 BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, REVARP_REQUEST, 0, 1), 381 BPF_STMT(BPF_RET|BPF_K, sizeof(struct ether_arp) + 382 sizeof(struct ether_header)), 383 BPF_STMT(BPF_RET|BPF_K, 0), 384 }; 385 static struct bpf_program filter = { 386 sizeof insns / sizeof(insns[0]), 387 insns 388 }; 389 390 fd = bpf_open(); 391 /* 392 * Set immediate mode so packets are processed as they arrive. 393 */ 394 immediate = 1; 395 if (ioctl(fd, BIOCIMMEDIATE, &immediate) == -1) { 396 logmsg(LOG_ERR, "BIOCIMMEDIATE: %m"); 397 exit(1); 398 } 399 strlcpy(ifr.ifr_name, device, sizeof(ifr.ifr_name)); 400 if (ioctl(fd, BIOCSETIF, (caddr_t)&ifr) == -1) { 401 logmsg(LOG_ERR, "BIOCSETIF: %m"); 402 exit(1); 403 } 404 /* 405 * Check that the data link layer is an Ethernet; this code won't 406 * work with anything else. 407 */ 408 if (ioctl(fd, BIOCGDLT, (caddr_t)&dlt) == -1) { 409 logmsg(LOG_ERR, "BIOCGDLT: %m"); 410 exit(1); 411 } 412 if (dlt != DLT_EN10MB) { 413 logmsg(LOG_ERR, "%s is not an ethernet", device); 414 exit(1); 415 } 416 /* 417 * Set filter program. 418 */ 419 if (ioctl(fd, BIOCSETF, (caddr_t)&filter) == -1) { 420 logmsg(LOG_ERR, "BIOCSETF: %m"); 421 exit(1); 422 } 423 return fd; 424 } 425 426 /* 427 * Perform various sanity checks on the RARP request packet. Return 428 * false on failure and log the reason. 429 */ 430 static int 431 rarp_check(u_char *p, u_int len) 432 { 433 struct ether_header *ep = (struct ether_header *)p; 434 struct ether_arp *ap = (struct ether_arp *)(p + sizeof(*ep)); 435 436 if (len < sizeof(*ep) + sizeof(*ap)) { 437 logmsg(LOG_ERR, "truncated request, got %u, expected %lu", 438 len, (u_long)(sizeof(*ep) + sizeof(*ap))); 439 return 0; 440 } 441 /* 442 * XXX This test might be better off broken out... 443 */ 444 if (ntohs(ep->ether_type) != ETHERTYPE_REVARP || 445 ntohs(ap->arp_hrd) != ARPHRD_ETHER || 446 ntohs(ap->arp_op) != REVARP_REQUEST || 447 ntohs(ap->arp_pro) != ETHERTYPE_IP || 448 ap->arp_hln != 6 || ap->arp_pln != 4) { 449 logmsg(LOG_DEBUG, "request fails sanity check"); 450 return 0; 451 } 452 if (bcmp((char *)&ep->ether_shost, (char *)&ap->arp_sha, 6) != 0) { 453 logmsg(LOG_DEBUG, "ether/arp sender address mismatch"); 454 return 0; 455 } 456 if (bcmp((char *)&ap->arp_sha, (char *)&ap->arp_tha, 6) != 0) { 457 logmsg(LOG_DEBUG, "ether/arp target address mismatch"); 458 return 0; 459 } 460 return 1; 461 } 462 463 /* 464 * Loop indefinitely listening for RARP requests on the 465 * interfaces in 'iflist'. 466 */ 467 static void 468 rarp_loop(void) 469 { 470 u_char *buf, *bp, *ep; 471 int cc, fd; 472 fd_set fds, listeners; 473 int bufsize, maxfd = 0; 474 struct if_info *ii; 475 476 if (iflist == NULL) { 477 logmsg(LOG_ERR, "no interfaces"); 478 exit(1); 479 } 480 if (ioctl(iflist->ii_fd, BIOCGBLEN, (caddr_t)&bufsize) == -1) { 481 logmsg(LOG_ERR, "BIOCGBLEN: %m"); 482 exit(1); 483 } 484 buf = malloc(bufsize); 485 if (buf == NULL) { 486 logmsg(LOG_ERR, "malloc: %m"); 487 exit(1); 488 } 489 490 while (1) { 491 /* 492 * Find the highest numbered file descriptor for select(). 493 * Initialize the set of descriptors to listen to. 494 */ 495 FD_ZERO(&fds); 496 for (ii = iflist; ii != NULL; ii = ii->ii_next) { 497 FD_SET(ii->ii_fd, &fds); 498 if (ii->ii_fd > maxfd) 499 maxfd = ii->ii_fd; 500 } 501 listeners = fds; 502 if (select(maxfd + 1, &listeners, NULL, NULL, NULL) == -1) { 503 /* Don't choke when we get ptraced */ 504 if (errno == EINTR) 505 continue; 506 logmsg(LOG_ERR, "select: %m"); 507 exit(1); 508 } 509 for (ii = iflist; ii != NULL; ii = ii->ii_next) { 510 fd = ii->ii_fd; 511 if (!FD_ISSET(fd, &listeners)) 512 continue; 513 again: 514 cc = read(fd, (char *)buf, bufsize); 515 /* Don't choke when we get ptraced */ 516 if ((cc == -1) && (errno == EINTR)) 517 goto again; 518 519 /* Loop through the packet(s) */ 520 #define bhp ((struct bpf_hdr *)bp) 521 bp = buf; 522 ep = bp + cc; 523 while (bp < ep) { 524 u_int caplen, hdrlen; 525 526 caplen = bhp->bh_caplen; 527 hdrlen = bhp->bh_hdrlen; 528 if (rarp_check(bp + hdrlen, caplen)) 529 rarp_process(ii, bp + hdrlen, caplen); 530 bp += BPF_WORDALIGN(hdrlen + caplen); 531 } 532 } 533 } 534 #undef bhp 535 } 536 537 /* 538 * True if this server can boot the host whose IP address is 'addr'. 539 * This check is made by looking in the tftp directory for the 540 * configuration file. 541 */ 542 static int 543 rarp_bootable(in_addr_t addr) 544 { 545 struct dirent *dent; 546 DIR *d; 547 char ipname[9]; 548 static DIR *dd = NULL; 549 550 sprintf(ipname, "%08X", (in_addr_t)ntohl(addr)); 551 552 /* 553 * If directory is already open, rewind it. Otherwise, open it. 554 */ 555 if ((d = dd) != NULL) 556 rewinddir(d); 557 else { 558 if (chdir(tftp_dir) == -1) { 559 logmsg(LOG_ERR, "chdir: %s: %m", tftp_dir); 560 exit(1); 561 } 562 d = opendir("."); 563 if (d == NULL) { 564 logmsg(LOG_ERR, "opendir: %m"); 565 exit(1); 566 } 567 dd = d; 568 } 569 while ((dent = readdir(d)) != NULL) 570 if (strncmp(dent->d_name, ipname, 8) == 0) 571 return 1; 572 return 0; 573 } 574 575 /* 576 * Given a list of IP addresses, 'alist', return the first address that 577 * is on network 'net'; 'netmask' is a mask indicating the network portion 578 * of the address. 579 */ 580 static in_addr_t 581 choose_ipaddr(in_addr_t **alist, in_addr_t net, in_addr_t netmask) 582 { 583 for (; *alist; ++alist) 584 if ((**alist & netmask) == net) 585 return **alist; 586 return 0; 587 } 588 589 /* 590 * Answer the RARP request in 'pkt', on the interface 'ii'. 'pkt' has 591 * already been checked for validity. The reply is overlaid on the request. 592 */ 593 static void 594 rarp_process(struct if_info *ii, u_char *pkt, u_int len) 595 { 596 struct ether_header *ep; 597 struct hostent *hp; 598 in_addr_t target_ipaddr; 599 char ename[256]; 600 601 ep = (struct ether_header *)pkt; 602 /* should this be arp_tha? */ 603 if (ether_ntohost(ename, (struct ether_addr *)&ep->ether_shost) != 0) { 604 logmsg(LOG_ERR, "cannot map %s to name", 605 eatoa(ep->ether_shost)); 606 return; 607 } 608 609 if ((hp = gethostbyname(ename)) == NULL) { 610 logmsg(LOG_ERR, "cannot map %s to IP address", ename); 611 return; 612 } 613 614 /* 615 * Choose correct address from list. 616 */ 617 if (hp->h_addrtype != AF_INET) { 618 logmsg(LOG_ERR, "cannot handle non IP addresses for %s", 619 ename); 620 return; 621 } 622 target_ipaddr = choose_ipaddr((in_addr_t **)hp->h_addr_list, 623 ii->ii_ipaddr & ii->ii_netmask, 624 ii->ii_netmask); 625 if (target_ipaddr == 0) { 626 logmsg(LOG_ERR, "cannot find %s on net %s", 627 ename, intoa(ntohl(ii->ii_ipaddr & ii->ii_netmask))); 628 return; 629 } 630 if (sflag || rarp_bootable(target_ipaddr)) 631 rarp_reply(ii, ep, target_ipaddr, len); 632 else if (verbose > 1) 633 logmsg(LOG_INFO, "%s %s at %s DENIED (not bootable)", 634 ii->ii_ifname, 635 eatoa(ep->ether_shost), 636 intoa(ntohl(target_ipaddr))); 637 } 638 639 /* 640 * Poke the kernel arp tables with the ethernet/ip address combinataion 641 * given. When processing a reply, we must do this so that the booting 642 * host (i.e. the guy running rarpd), won't try to ARP for the hardware 643 * address of the guy being booted (he cannot answer the ARP). 644 */ 645 struct sockaddr_inarp sin_inarp = { 646 sizeof(struct sockaddr_inarp), AF_INET, 0, 647 {0}, 648 {0}, 649 0, 0 650 }; 651 struct sockaddr_dl sin_dl = { 652 sizeof(struct sockaddr_dl), AF_LINK, 0, IFT_ETHER, 0, 6, 653 0, "" 654 }; 655 struct { 656 struct rt_msghdr rthdr; 657 char rtspace[512]; 658 } rtmsg; 659 660 static void 661 update_arptab(u_char *ep, in_addr_t ipaddr) 662 { 663 int cc; 664 struct sockaddr_inarp *ar, *ar2; 665 struct sockaddr_dl *ll, *ll2; 666 struct rt_msghdr *rt; 667 int xtype, xindex; 668 static pid_t pid; 669 int r; 670 static int seq; 671 672 r = socket(PF_ROUTE, SOCK_RAW, 0); 673 if (r == -1) { 674 logmsg(LOG_ERR, "raw route socket: %m"); 675 exit(1); 676 } 677 pid = getpid(); 678 679 ar = &sin_inarp; 680 ar->sin_addr.s_addr = ipaddr; 681 ll = &sin_dl; 682 bcopy(ep, LLADDR(ll), 6); 683 684 /* Get the type and interface index */ 685 rt = &rtmsg.rthdr; 686 bzero(rt, sizeof(rtmsg)); 687 rt->rtm_version = RTM_VERSION; 688 rt->rtm_addrs = RTA_DST; 689 rt->rtm_type = RTM_GET; 690 rt->rtm_seq = ++seq; 691 ar2 = (struct sockaddr_inarp *)rtmsg.rtspace; 692 bcopy(ar, ar2, sizeof(*ar)); 693 rt->rtm_msglen = sizeof(*rt) + sizeof(*ar); 694 errno = 0; 695 if ((write(r, rt, rt->rtm_msglen) == -1) && (errno != ESRCH)) { 696 logmsg(LOG_ERR, "rtmsg get write: %m"); 697 close(r); 698 return; 699 } 700 do { 701 cc = read(r, rt, sizeof(rtmsg)); 702 } while (cc > 0 && (rt->rtm_seq != seq || rt->rtm_pid != pid)); 703 if (cc == -1) { 704 logmsg(LOG_ERR, "rtmsg get read: %m"); 705 close(r); 706 return; 707 } 708 ll2 = (struct sockaddr_dl *)((u_char *)ar2 + ar2->sin_len); 709 if (ll2->sdl_family != AF_LINK) { 710 /* 711 * XXX I think this means the ip address is not on a 712 * directly connected network (the family is AF_INET in 713 * this case). 714 */ 715 logmsg(LOG_ERR, "bogus link family (%d) wrong net for %08X?\n", 716 ll2->sdl_family, ipaddr); 717 close(r); 718 return; 719 } 720 xtype = ll2->sdl_type; 721 xindex = ll2->sdl_index; 722 723 /* Set the new arp entry */ 724 bzero(rt, sizeof(rtmsg)); 725 rt->rtm_version = RTM_VERSION; 726 rt->rtm_addrs = RTA_DST | RTA_GATEWAY; 727 rt->rtm_inits = RTV_EXPIRE; 728 rt->rtm_rmx.rmx_expire = time(0) + ARPSECS; 729 rt->rtm_flags = RTF_HOST | RTF_STATIC; 730 rt->rtm_type = RTM_ADD; 731 rt->rtm_seq = ++seq; 732 733 bcopy(ar, ar2, sizeof(*ar)); 734 735 ll2 = (struct sockaddr_dl *)((u_char *)ar2 + sizeof(*ar2)); 736 bcopy(ll, ll2, sizeof(*ll)); 737 ll2->sdl_type = xtype; 738 ll2->sdl_index = xindex; 739 740 rt->rtm_msglen = sizeof(*rt) + sizeof(*ar2) + sizeof(*ll2); 741 errno = 0; 742 if ((write(r, rt, rt->rtm_msglen) == -1) && (errno != EEXIST)) { 743 logmsg(LOG_ERR, "rtmsg add write: %m"); 744 close(r); 745 return; 746 } 747 do { 748 cc = read(r, rt, sizeof(rtmsg)); 749 } while (cc > 0 && (rt->rtm_seq != seq || rt->rtm_pid != pid)); 750 close(r); 751 if (cc == -1) { 752 logmsg(LOG_ERR, "rtmsg add read: %m"); 753 return; 754 } 755 } 756 757 /* 758 * Build a reverse ARP packet and sent it out on the interface. 759 * 'ep' points to a valid REVARP_REQUEST. The REVARP_REPLY is built 760 * on top of the request, then written to the network. 761 * 762 * RFC 903 defines the ether_arp fields as follows. The following comments 763 * are taken (more or less) straight from this document. 764 * 765 * REVARP_REQUEST 766 * 767 * arp_sha is the hardware address of the sender of the packet. 768 * arp_spa is undefined. 769 * arp_tha is the 'target' hardware address. 770 * In the case where the sender wishes to determine his own 771 * protocol address, this, like arp_sha, will be the hardware 772 * address of the sender. 773 * arp_tpa is undefined. 774 * 775 * REVARP_REPLY 776 * 777 * arp_sha is the hardware address of the responder (the sender of the 778 * reply packet). 779 * arp_spa is the protocol address of the responder (see the note below). 780 * arp_tha is the hardware address of the target, and should be the same as 781 * that which was given in the request. 782 * arp_tpa is the protocol address of the target, that is, the desired address. 783 * 784 * Note that the requirement that arp_spa be filled in with the responder's 785 * protocol is purely for convenience. For instance, if a system were to use 786 * both ARP and RARP, then the inclusion of the valid protocol-hardware 787 * address pair (arp_spa, arp_sha) may eliminate the need for a subsequent 788 * ARP request. 789 */ 790 static void 791 rarp_reply(struct if_info *ii, struct ether_header *ep, in_addr_t ipaddr, 792 u_int len) 793 { 794 u_int n; 795 struct ether_arp *ap = (struct ether_arp *)(ep + 1); 796 797 update_arptab((u_char *)&ap->arp_sha, ipaddr); 798 799 /* 800 * Build the rarp reply by modifying the rarp request in place. 801 */ 802 ap->arp_op = htons(REVARP_REPLY); 803 804 #ifdef BROKEN_BPF 805 ep->ether_type = ETHERTYPE_REVARP; 806 #endif 807 bcopy((char *)&ap->arp_sha, (char *)&ep->ether_dhost, 6); 808 bcopy((char *)ii->ii_eaddr, (char *)&ep->ether_shost, 6); 809 bcopy((char *)ii->ii_eaddr, (char *)&ap->arp_sha, 6); 810 811 bcopy((char *)&ipaddr, (char *)ap->arp_tpa, 4); 812 /* Target hardware is unchanged. */ 813 bcopy((char *)&ii->ii_ipaddr, (char *)ap->arp_spa, 4); 814 815 /* Zero possible garbage after packet. */ 816 bzero((char *)ep + (sizeof(*ep) + sizeof(*ap)), 817 len - (sizeof(*ep) + sizeof(*ap))); 818 n = write(ii->ii_fd, (char *)ep, len); 819 if (n != len) 820 logmsg(LOG_ERR, "write: only %d of %d bytes written", n, len); 821 if (verbose) 822 logmsg(LOG_INFO, "%s %s at %s REPLIED", ii->ii_ifname, 823 eatoa(ap->arp_tha), 824 intoa(ntohl(ipaddr))); 825 } 826 827 /* 828 * Get the netmask of an IP address. This routine is used if 829 * SIOCGIFNETMASK doesn't work. 830 */ 831 static in_addr_t 832 ipaddrtonetmask(in_addr_t addr) 833 { 834 addr = ntohl(addr); 835 if (IN_CLASSA(addr)) 836 return htonl(IN_CLASSA_NET); 837 if (IN_CLASSB(addr)) 838 return htonl(IN_CLASSB_NET); 839 if (IN_CLASSC(addr)) 840 return htonl(IN_CLASSC_NET); 841 logmsg(LOG_DEBUG, "unknown IP address class: %08X", addr); 842 return htonl(0xffffffff); 843 } 844 845 /* 846 * A faster replacement for inet_ntoa(). 847 */ 848 static char * 849 intoa(in_addr_t addr) 850 { 851 char *cp; 852 u_int byte; 853 int n; 854 static char buf[sizeof(".xxx.xxx.xxx.xxx")]; 855 856 cp = &buf[sizeof buf]; 857 *--cp = '\0'; 858 859 n = 4; 860 do { 861 byte = addr & 0xff; 862 *--cp = byte % 10 + '0'; 863 byte /= 10; 864 if (byte > 0) { 865 *--cp = byte % 10 + '0'; 866 byte /= 10; 867 if (byte > 0) 868 *--cp = byte + '0'; 869 } 870 *--cp = '.'; 871 addr >>= 8; 872 } while (--n > 0); 873 874 return cp + 1; 875 } 876 877 static char * 878 eatoa(u_char *ea) 879 { 880 static char buf[sizeof("xx:xx:xx:xx:xx:xx")]; 881 882 sprintf(buf, "%x:%x:%x:%x:%x:%x", 883 ea[0], ea[1], ea[2], ea[3], ea[4], ea[5]); 884 return (buf); 885 } 886 887 static void 888 logmsg(int pri, const char *fmt, ...) 889 { 890 va_list v; 891 FILE *fp; 892 char *newfmt; 893 894 va_start(v, fmt); 895 if (dflag) { 896 if (pri == LOG_ERR) 897 fp = stderr; 898 else 899 fp = stdout; 900 if (expand_syslog_m(fmt, &newfmt) == -1) { 901 vfprintf(fp, fmt, v); 902 } else { 903 vfprintf(fp, newfmt, v); 904 free(newfmt); 905 } 906 fputs("\n", fp); 907 fflush(fp); 908 } else { 909 vsyslog(pri, fmt, v); 910 } 911 va_end(v); 912 } 913 914 static int 915 expand_syslog_m(const char *fmt, char **newfmt) 916 { 917 const char *str, *m; 918 char *p, *np; 919 920 p = strdup(""); 921 str = fmt; 922 while ((m = strstr(str, "%m")) != NULL) { 923 asprintf(&np, "%s%.*s%s", p, (int)(m - str), 924 str, strerror(errno)); 925 free(p); 926 if (np == NULL) { 927 errno = ENOMEM; 928 return (-1); 929 } 930 p = np; 931 str = m + 2; 932 } 933 934 if (*str != '\0') { 935 asprintf(&np, "%s%s", p, str); 936 free(p); 937 if (np == NULL) { 938 errno = ENOMEM; 939 return (-1); 940 } 941 p = np; 942 } 943 944 *newfmt = p; 945 return (0); 946 } 947