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