Annotation of embedaddon/choparp/choparp.c, revision 1.1
1.1 ! misho 1: /*
! 2: choparp - cheap & omitted proxy arp
! 3:
! 4: Copyright (c) 1997 Takamichi Tateoka (tree@mma.club.uec.ac.jp)
! 5: Copyright (c) 2002 Thomas Quinot (thomas@cuivre.fr.eu.org)
! 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: 3. Neither the name of the authors nor the names of their contributors
! 16: may be used to endorse or promote products derived from this software
! 17: without specific prior written permission.
! 18:
! 19: THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
! 20: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 21: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 22: ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 23: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 24: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 25: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 26: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 27: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 28: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 29: SUCH DAMAGE.
! 30:
! 31:
! 32: History:
! 33: 17 Jun 1997 Creation (tate)
! 34: 7 Oct 1997 fix some comments (tate)
! 35: 19 Jun 1998 fix read result as ssize_t (tate / pointed by msaitoh)
! 36:
! 37: */
! 38:
! 39: #include <stdio.h>
! 40: #include <unistd.h>
! 41: #include <stdlib.h>
! 42: #include <string.h>
! 43: #include <sys/types.h>
! 44: #include <fcntl.h>
! 45: #include <sys/event.h>
! 46: #include <sys/time.h>
! 47: #include <sys/ioctl.h>
! 48: #include <net/bpf.h>
! 49: #include <sys/socket.h>
! 50: #include <net/if.h>
! 51: #include <netinet/in.h>
! 52: /* #include <net/if_arp.h> */
! 53: #if (__FreeBSD__ >= 3)
! 54: #include <net/if_var.h>
! 55: #endif
! 56: #include <netinet/if_ether.h>
! 57: #include <sys/param.h>
! 58: #include <errno.h>
! 59: #include <ifaddrs.h>
! 60: #include <net/if_dl.h>
! 61:
! 62: #ifdef DEBUG
! 63: #include <arpa/inet.h>
! 64: #endif
! 65:
! 66: #define BPFFILENAME "/dev/bpf%d" /* bpf file template */
! 67: #ifndef NBPFILTER /* number of available bpf */
! 68: # define NBPFILTER (16)
! 69: #endif
! 70:
! 71: struct cidr {
! 72: struct cidr *next;
! 73: u_int32_t addr; /* addr and mask are host order */
! 74: u_int32_t mask;
! 75: };
! 76:
! 77: struct cidr *targets = NULL, *excludes = NULL;
! 78: u_char target_mac[ETHER_ADDR_LEN]; /* target MAC address */
! 79: int verbose = 0;
! 80:
! 81: /*
! 82: ARP filter program
! 83: */
! 84: struct bpf_insn bpf_filter_arp[] = {
! 85: /* check Ethernet Encapsulation (RFC894) first */
! 86: BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 12), /* load frame type */
! 87: BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, ETHERTYPE_ARP, 0, 3), /* check it */
! 88: BPF_STMT(BPF_LD+BPF_H+BPF_ABS, 20), /* load OP code */
! 89: BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, ARPOP_REQUEST, 0, 1), /* check it */
! 90: BPF_STMT(BPF_RET+BPF_K, 14+28), /* return Ethernet encap ARP req. */
! 91: /* XXX: IEEE 802.2/802.3 Encap (RFC1042) should be available... */
! 92: BPF_STMT(BPF_RET+BPF_K, 0), /* discard */
! 93: };
! 94:
! 95: /*
! 96: openbpf:
! 97:
! 98: open bpf & set ARP filter program for named interface &
! 99: allocate enough buffer for BPF.
! 100: return file descripter or -1 for error
! 101: */
! 102: int
! 103: openbpf(char *ifname, char **bufp, size_t *buflen){
! 104: char bpffile[sizeof(BPFFILENAME)+5]; /* XXX: */
! 105: int fd = -1;
! 106: int n;
! 107: struct bpf_version bpf_version;
! 108: struct ifreq bpf_ifreq;
! 109: u_int ui;
! 110: struct bpf_program bpf_program;
! 111:
! 112: /* open BPF file */
! 113: for (n=0; n<NBPFILTER; n++){
! 114: sprintf(bpffile, BPFFILENAME, n);
! 115: if ((fd = open(bpffile, O_RDWR, 0)) >= 0)
! 116: break;
! 117: }
! 118: if (fd < 0){
! 119: fprintf(stderr,"openbpf: Can't open BPF\n");
! 120: return(-1); /* error */
! 121: }
! 122:
! 123: /* check version number */
! 124: if ((ioctl(fd, BIOCVERSION, &bpf_version) == -1) ||
! 125: bpf_version.bv_major != BPF_MAJOR_VERSION ||
! 126: bpf_version.bv_minor < BPF_MINOR_VERSION){
! 127: fprintf(stderr,"openbpf: incorrect BPF version\n");
! 128: close(fd);
! 129: return(-1);
! 130: }
! 131:
! 132: /* set interface name */
! 133: strncpy(bpf_ifreq.ifr_name, ifname, IFNAMSIZ);
! 134: bpf_ifreq.ifr_name[IFNAMSIZ-1] = '\0'; /* paranoia */
! 135: if (ioctl(fd, BIOCSETIF, &bpf_ifreq) == -1){
! 136: fprintf(stderr,"openbpf: BIOCSETIF failed for interface <%s>\n",
! 137: ifname);
! 138: close(fd);
! 139: return(-1);
! 140: }
! 141:
! 142: /* set BPF immediate mode */
! 143: ui = 1;
! 144: if (ioctl(fd, BIOCIMMEDIATE, &ui) == -1){
! 145: fprintf(stderr,"openbpf: BIOCIMMEDIATE failed.\n");
! 146: close(fd);
! 147: return(-1);
! 148: }
! 149:
! 150: /* set ARP request filter */
! 151: bpf_program.bf_len = sizeof(bpf_filter_arp) / sizeof(struct bpf_insn);
! 152: bpf_program.bf_insns = bpf_filter_arp;
! 153: if (ioctl(fd, BIOCSETF, &bpf_program) == -1){
! 154: fprintf(stderr,"openbpf: BIOCSETF failed.\n");
! 155: close(fd);
! 156: return(-1);
! 157: }
! 158:
! 159: /* allocate reasonable size & alimented buffer */
! 160: if (ioctl(fd, BIOCGBLEN, &ui) == -1){
! 161: fprintf(stderr,"openbpf: BIOCGBLEN failed.\n");
! 162: close(fd);
! 163: return(-1);
! 164: }
! 165: *buflen = (size_t)ui;
! 166: if ((*bufp = (char *)malloc((size_t) ui)) == NULL){
! 167: fprintf(stderr,"openbpf: malloc failed.\n");
! 168: close(fd);
! 169: return(-1);
! 170: }
! 171:
! 172: return(fd);
! 173: }
! 174:
! 175: /*
! 176: get ARP datalink frame pointer
! 177:
! 178: NULL if no more ARP frame
! 179: */
! 180: char *
! 181: getarp(char *bpfframe, ssize_t bpfflen, char **next, ssize_t *nextlen){
! 182: int bias;
! 183: char *p;
! 184:
! 185: if (bpfframe == NULL || bpfflen == 0)
! 186: return(NULL);
! 187:
! 188: bias = BPF_WORDALIGN(((struct bpf_hdr *)bpfframe)->bh_hdrlen +
! 189: ((struct bpf_hdr *)bpfframe)->bh_caplen);
! 190: if (bias < bpfflen){
! 191: /* there is another packet packed into same bpf frame */
! 192: *next = bpfframe + bias;
! 193: *nextlen = (size_t) bpfflen - bias;
! 194: } else {
! 195: /* no more packet */
! 196: *next = NULL;
! 197: *nextlen = 0;
! 198: }
! 199:
! 200: /* cut off BPF header */
! 201: p = bpfframe + ((struct bpf_hdr *)bpfframe)->bh_hdrlen;
! 202: return(p);
! 203: }
! 204:
! 205: /*
! 206: match
! 207:
! 208: match an IP address against a list of address/netmask pairs
! 209: */
! 210:
! 211: static int
! 212: match (u_int32_t addr, struct cidr *list) {
! 213: while (list) {
! 214: if ((addr & list->mask) == list->addr)
! 215: return 1;
! 216: list = list->next;
! 217: }
! 218: return 0;
! 219: }
! 220:
! 221: /*
! 222: checkarp
! 223:
! 224: check responsibility of the ARP request
! 225: return true if responsible
! 226:
! 227: arpbuf is pointing top of link-level frame
! 228: */
! 229:
! 230: static int
! 231: checkarp(char *arpbuf){
! 232: struct ether_arp *arp;
! 233: u_int32_t target_ip;
! 234:
! 235: arp = (struct ether_arp *)(arpbuf + 14); /* skip ethernet header */
! 236: if (ntohs(arp->arp_hrd) != ARPHRD_ETHER ||
! 237: /* XXX: ARPHRD_802 */
! 238: ntohs(arp->arp_pro) != ETHERTYPE_IP ||
! 239: (int) (arp->arp_hln) != ETHER_ADDR_LEN || /* length of ethernet addr */
! 240: (int) (arp->arp_pln) != 4){ /* length of protocol addr */
! 241: fprintf(stderr,"checkarp: WARNING: received unknown type ARP request.\n");
! 242: return(0);
! 243: }
! 244: if (ntohl(*(u_int32_t *)(arp->arp_tpa)) == ntohl(*(u_int32_t *)(arp->arp_spa))) {
! 245: if (verbose != 0)
! 246: fprintf(stderr,"checkarp: WARNING: sender equal dest.\n");
! 247: return(0);
! 248: }
! 249: if (0 == ntohl(*(u_int32_t *)(arp->arp_spa))) {
! 250: if (verbose != 0)
! 251: fprintf(stderr,"checkarp: WARNING: zero sender address.\n");
! 252: return(0);
! 253: }
! 254: target_ip = ntohl(*(u_int32_t *)(arp->arp_tpa));
! 255: return match(target_ip, targets) && !match(target_ip, excludes);
! 256: }
! 257:
! 258: /*
! 259: genarpreply
! 260:
! 261: generate arp reply link level frame
! 262: arpbuf is pointing top of link-level frame
! 263: this routine overwrite arpbuf
! 264:
! 265: return reply buffer & its length
! 266: */
! 267: char *
! 268: gen_arpreply(char *arpbuf, size_t *rlen){
! 269: struct ether_arp *arp;
! 270: u_char ipbuf[4]; /* sender IP */
! 271:
! 272: /* set ethernet dst/src address */
! 273: memcpy(arpbuf, arpbuf+ETHER_ADDR_LEN, ETHER_ADDR_LEN);
! 274: memcpy(arpbuf+ETHER_ADDR_LEN, target_mac, ETHER_ADDR_LEN);
! 275: /* set result of ARP request */
! 276: arp = (struct ether_arp *)(arpbuf + 14); /* skip ethernet header */
! 277: memcpy(ipbuf, arp->arp_tpa, 4); /* save protocol addr */
! 278: memcpy(arp->arp_tha, arp->arp_sha, 10); /* set target hard/proto addr */
! 279: memcpy(arp->arp_spa, ipbuf, 4); /* set source protocol addr */
! 280: memcpy(arp->arp_sha, target_mac, ETHER_ADDR_LEN); /* set source hard addr */
! 281: arp->arp_op = htons(ARPOP_REPLY);
! 282:
! 283: *rlen = 14 + 28; /* ethernet header & arp reply */
! 284: return(arpbuf);
! 285: }
! 286:
! 287: void
! 288: loop(int fd, char *buf, size_t buflen){
! 289: ssize_t rlen;
! 290: char *p, *nextp;
! 291: ssize_t nextlen;
! 292: char *rframe;
! 293: char *sframe;
! 294: size_t frame_len;
! 295: int kq;
! 296: struct kevent kev;
! 297:
! 298: if ((kq = kqueue()) < 0) {
! 299: perror("kqueue");
! 300: return;
! 301: }
! 302:
! 303: EV_SET(&kev, fd, EVFILT_READ, EV_ADD, 0, 0, NULL);
! 304: if (kevent(kq, &kev, 1, NULL, 0, NULL) < 0 ) {
! 305: perror("kevent");
! 306: return;
! 307: }
! 308:
! 309: for(;;){
! 310: int r = kevent(kq, NULL, 0, &kev, 1, NULL);
! 311:
! 312: if (r < 0) {
! 313: if (errno == EINTR)
! 314: continue;
! 315: perror("select");
! 316: return;
! 317: }
! 318:
! 319: rlen = read(kev.ident, buf, buflen);
! 320: if (rlen < 0) {
! 321: if (errno == EINTR)
! 322: continue;
! 323: perror("read");
! 324: return;
! 325: }
! 326:
! 327: p = buf;
! 328: while((rframe = getarp(p, rlen, &nextp, &nextlen)) != NULL){
! 329: if (checkarp(rframe)){
! 330: sframe = gen_arpreply(rframe, &frame_len);
! 331: write(kev.ident, sframe, frame_len);
! 332: }
! 333: p = nextp;
! 334: rlen = nextlen;
! 335: }
! 336: }
! 337: /* not reach */
! 338: }
! 339:
! 340: int
! 341: setmac(char *addr, char *ifname){
! 342: u_int m0, m1, m2, m3, m4, m5;
! 343:
! 344: if (!strcmp (addr, "auto")) {
! 345: struct ifaddrs *ifas, *ifa;
! 346:
! 347: getifaddrs (&ifas);
! 348: for (ifa = ifas; ifa != NULL; ifa = ifa->ifa_next) {
! 349: #define SDL ((struct sockaddr_dl *)ifa->ifa_addr)
! 350: if (strcmp (ifa->ifa_name, ifname)
! 351: || SDL->sdl_family != AF_LINK
! 352: || SDL->sdl_alen != 6)
! 353: continue;
! 354: memcpy (target_mac, SDL->sdl_data + SDL->sdl_nlen, 6);
! 355: return 0;
! 356: }
! 357: return -1;
! 358: }
! 359: if (sscanf(addr, "%x:%x:%x:%x:%x:%x", &m0, &m1, &m2, &m3, &m4, &m5) < 6)
! 360: return(-1);
! 361: target_mac[0] = (u_char )m0;
! 362: target_mac[1] = (u_char )m1;
! 363: target_mac[2] = (u_char )m2;
! 364: target_mac[3] = (u_char )m3;
! 365: target_mac[4] = (u_char )m4;
! 366: target_mac[5] = (u_char )m5;
! 367: return(0);
! 368: }
! 369:
! 370: int
! 371: atoip(char *buf, u_int32_t *ip_addr){
! 372: u_int i0, i1, i2, i3;
! 373:
! 374: if (sscanf(buf, "%u.%u.%u.%u", &i0, &i1, &i2, &i3) == 4){
! 375: *ip_addr = (i0 << 24) + (i1 << 16) + (i2 << 8) + i3;
! 376: return(0);
! 377: }
! 378: if (sscanf(buf, "0x%lx", ip_addr) == 1)
! 379: return(0);
! 380:
! 381: return(-1);
! 382: }
! 383:
! 384: void
! 385: usage(void){
! 386: fprintf(stderr,"usage: choparp [-v] if_name mac_addr [-]addr/mask...\n");
! 387: exit(-1);
! 388: }
! 389:
! 390: int
! 391: main(int argc, char **argv){
! 392: int ch, fd;
! 393: char *buf, *ifname;
! 394: struct cidr **targets_tail = &targets, **excludes_tail = &excludes;
! 395: #define APPEND(LIST,ADDR,MASK) \
! 396: do { \
! 397: *(LIST ## _tail) = malloc(sizeof (struct cidr)); \
! 398: (*(LIST ## _tail))->addr = ADDR; \
! 399: (*(LIST ## _tail))->mask = MASK; \
! 400: (*(LIST ## _tail))->next = NULL; \
! 401: (LIST ## _tail) = &(*(LIST ## _tail))->next; \
! 402: } while (0)
! 403: size_t buflen;
! 404:
! 405: while ((ch = getopt(argc, argv, "v")) != -1)
! 406: switch (ch) {
! 407: case 'v':
! 408: verbose++;
! 409: break;
! 410: default:
! 411: usage();
! 412: }
! 413: argc -= optind;
! 414: argv += optind;
! 415:
! 416: if (argc < 3)
! 417: usage();
! 418:
! 419: ifname = argv[0];
! 420: if (setmac(argv[1], ifname))
! 421: usage();
! 422: argv += 2; argc -= 2;
! 423:
! 424: while (argc > 0) {
! 425: u_int32_t addr, mask = ~0;
! 426: char *slash = strchr (*argv, '/');
! 427: int exclude = 0;
! 428:
! 429: if (**argv == '-') {
! 430: (*argv)++;
! 431: exclude = 1;
! 432: }
! 433: if (slash != NULL)
! 434: *(slash++) = '\0';
! 435: if (atoip (*argv, &addr))
! 436: usage();
! 437: if (slash != NULL) {
! 438: char *end;
! 439: u_int32_t len = strtol (slash, &end, 10);
! 440: if (*end == '\0')
! 441: mask <<= (32 - len);
! 442: else if (atoip (slash, &mask))
! 443: usage();
! 444: }
! 445: if (exclude)
! 446: APPEND(excludes, addr, mask);
! 447: else
! 448: APPEND(targets, addr, mask);
! 449: argv++, argc--;
! 450: }
! 451:
! 452: #ifdef DEBUG
! 453: #define SHOW(LIST) \
! 454: do { \
! 455: struct cidr *t; \
! 456: printf (#LIST ":\n"); \
! 457: for (t = LIST; t; t = t->next) { \
! 458: u_int32_t x; \
! 459: x = htonl (t->addr); \
! 460: printf (" %s", inet_ntoa (*(struct in_addr *)&x)); \
! 461: x = htonl (t->mask); \
! 462: printf ("/%s\n", inet_ntoa (*(struct in_addr *)&x)); \
! 463: } \
! 464: } while (0)
! 465:
! 466: SHOW(targets);
! 467: SHOW(excludes);
! 468: exit (0);
! 469: #endif
! 470: if ((fd = openbpf(ifname, &buf, &buflen)) < 0)
! 471: return(-1);
! 472: #ifndef DEBUG
! 473: daemon(0, 0);
! 474: #endif
! 475: loop(fd, buf, buflen);
! 476: return(-1);
! 477: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to choparp.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / choparp