![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bsd-bpf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / host / bsd|
Return to bsd-bpf.c CVS log | Up to [The Machine Emulator] / tme / host / bsd |
1.1 ! root 1: /* $Id: bsd-bpf.c,v 1.3 2003/05/18 00:06:06 fredette Exp $ */ ! 2: ! 3: /* host/bsd/bsd-bpf.c - BSD Berkeley Packet Filter Ethernet support: */ ! 4: ! 5: /* ! 6: * Copyright (c) 2001, 2003 Matt Fredette ! 7: * All rights reserved. ! 8: * ! 9: * Redistribution and use in source and binary forms, with or without ! 10: * modification, are permitted provided that the following conditions ! 11: * are met: ! 12: * 1. Redistributions of source code must retain the above copyright ! 13: * notice, this list of conditions and the following disclaimer. ! 14: * 2. Redistributions in binary form must reproduce the above copyright ! 15: * notice, this list of conditions and the following disclaimer in the ! 16: * documentation and/or other materials provided with the distribution. ! 17: * 3. All advertising materials mentioning features or use of this software ! 18: * must display the following acknowledgement: ! 19: * This product includes software developed by Matt Fredette. ! 20: * 4. The name of the author may not be used to endorse or promote products ! 21: * derived from this software without specific prior written permission. ! 22: * ! 23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR ! 24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED ! 25: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE ! 26: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, ! 27: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ! 28: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR ! 29: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ! 31: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ! 32: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ! 33: * POSSIBILITY OF SUCH DAMAGE. ! 34: */ ! 35: ! 36: #include <tme/common.h> ! 37: _TME_RCSID("$Id: bsd-bpf.c,v 1.3 2003/05/18 00:06:06 fredette Exp $"); ! 38: ! 39: /* includes: */ ! 40: #include "bsd-impl.h" ! 41: #include <tme/generic/ethernet.h> ! 42: #include <stdio.h> ! 43: #include <string.h> ! 44: #include <errno.h> ! 45: #include <fcntl.h> ! 46: #include <netdb.h> ! 47: #include <sys/param.h> ! 48: #include <sys/socket.h> ! 49: #include <sys/stat.h> ! 50: #include <net/if.h> ! 51: #include <netinet/in_systm.h> ! 52: #include <netinet/in.h> ! 53: #if defined(HAVE_SYS_SOCKIO_H) ! 54: #include <sys/sockio.h> ! 55: #elif defined(HAVE_SYS_SOCKETIO_H) ! 56: #include <sys/socketio.h> ! 57: #endif /* HAVE_SYS_SOCKETIO_H */ ! 58: #include <sys/ioctl.h> ! 59: #ifdef HAVE_IOCTLS_H ! 60: #include <ioctls.h> ! 61: #endif /* HAVE_IOCTLS_H */ ! 62: #ifdef HAVE_NET_IF_ETHER_H ! 63: #include <net/if_ether.h> ! 64: #endif /* HAVE_NET_IF_ETHER_H */ ! 65: #ifdef HAVE_NET_ETHERNET_H ! 66: #include <net/ethernet.h> ! 67: #endif /* HAVE_NET_ETHERNET_H */ ! 68: #include <netinet/ip.h> ! 69: #ifdef HAVE_NET_IF_DL_H ! 70: #include <net/if_dl.h> ! 71: #endif /* HAVE_NET_IF_DL_H */ ! 72: #include <arpa/inet.h> ! 73: #include <net/bpf.h> ! 74: ! 75: /* macros: */ ! 76: ! 77: /* the callout flags: */ ! 78: #define TME_BSD_BPF_CALLOUT_CHECK (0) ! 79: #define TME_BSD_BPF_CALLOUT_RUNNING TME_BIT(0) ! 80: #define TME_BSD_BPF_CALLOUTS_MASK (-2) ! 81: #define TME_BSD_BPF_CALLOUT_CTRL TME_BIT(1) ! 82: #define TME_BSD_BPF_CALLOUT_READ TME_BIT(2) ! 83: ! 84: /* structures: */ ! 85: ! 86: /* our internal data structure: */ ! 87: struct tme_bsd_bpf { ! 88: ! 89: /* backpointer to our element: */ ! 90: struct tme_element *tme_bsd_bpf_element; ! 91: ! 92: /* our mutex: */ ! 93: tme_mutex_t tme_bsd_bpf_mutex; ! 94: ! 95: /* our reader and writer conditions: */ ! 96: tme_cond_t tme_bsd_bpf_cond_reader; ! 97: tme_cond_t tme_bsd_bpf_cond_writer; ! 98: ! 99: /* the callout flags: */ ! 100: unsigned int tme_bsd_bpf_callout_flags; ! 101: ! 102: /* our Ethernet connection: */ ! 103: struct tme_ethernet_connection *tme_bsd_bpf_eth_connection; ! 104: ! 105: /* the BPF file descriptor: */ ! 106: int tme_bsd_bpf_fd; ! 107: ! 108: /* the size of the packet buffer for the interface: */ ! 109: size_t tme_bsd_bpf_buffer_size; ! 110: ! 111: /* the packet buffer for the interface: */ ! 112: tme_uint8_t *tme_bsd_bpf_buffer; ! 113: ! 114: /* the next offset within the packet buffer, and the end of the data ! 115: in the packet buffer: */ ! 116: size_t tme_bsd_bpf_buffer_offset; ! 117: size_t tme_bsd_bpf_buffer_end; ! 118: }; ! 119: ! 120: /* the accept and reject packet insns: */ ! 121: static const struct bpf_insn _tme_bsd_bpf_insn_accept = BPF_STMT(BPF_RET + BPF_K, (u_int) -1); ! 122: static const struct bpf_insn _tme_bsd_bpf_insn_reject = BPF_STMT(BPF_RET + BPF_K, 0); ! 123: ! 124: /* this creates a BPF filter that accepts Ethernet packets with ! 125: destination addresses in the configured set. the broadcast address ! 126: must be in this set, it isn't accepted automatically: */ ! 127: static int ! 128: _tme_bsd_bpf_filter(struct tme_ethernet_config *config, ! 129: const tme_uint8_t *prefix, ! 130: unsigned int prefix_len, ! 131: struct bpf_insn *bpf_filter, ! 132: int bpf_filter_size, ! 133: int *_first_pc) ! 134: { ! 135: unsigned int addr_i; ! 136: tme_uint8_t byte; ! 137: tme_uint8_t byte_bitmap[(1 << (8 * sizeof(byte))) >> 3]; ! 138: int match_pc, miss_pc, this_pc; ! 139: ! 140: /* clear the byte bitmap: */ ! 141: memset(byte_bitmap, 0, sizeof(byte_bitmap)); ! 142: ! 143: /* the last instruction jumps to the reject insn when it fails: */ ! 144: miss_pc = bpf_filter_size - 1; ! 145: ! 146: /* loop over all of the addresses: */ ! 147: for (addr_i = 0; ! 148: addr_i < config->tme_ethernet_config_addr_count; ! 149: addr_i++) { ! 150: ! 151: /* skip this address if it doesn't match the prefix: */ ! 152: if (prefix_len > 0 ! 153: && memcmp(config->tme_ethernet_config_addrs[addr_i], ! 154: prefix, ! 155: prefix_len)) { ! 156: continue; ! 157: } ! 158: ! 159: /* get the next byte, and skip this address if this byte has ! 160: already been done: */ ! 161: byte = config->tme_ethernet_config_addrs[addr_i][prefix_len]; ! 162: if (byte_bitmap[byte >> 3] & TME_BIT(byte & 7)) { ! 163: continue; ! 164: } ! 165: byte_bitmap[byte >> 3] |= TME_BIT(byte & 7); ! 166: ! 167: /* get the PC of the instruction to branch to if this byte ! 168: matches. if this is the last byte of the address, the branch ! 169: target is the accept insn, otherwise recurse and get the first ! 170: insn of the rest of the matcher: */ ! 171: match_pc = ((prefix_len == (TME_ETHERNET_ADDR_SIZE - 1)) ! 172: ? bpf_filter_size - 2 ! 173: : _tme_bsd_bpf_filter(config, ! 174: config->tme_ethernet_config_addrs[addr_i], ! 175: prefix_len + 1, ! 176: bpf_filter, ! 177: bpf_filter_size, ! 178: _first_pc)); ! 179: ! 180: /* add this testing instruction: */ ! 181: this_pc = --(*_first_pc); ! 182: assert(this_pc >= 0); ! 183: bpf_filter[this_pc].code = BPF_JMP + BPF_JEQ + BPF_K; ! 184: bpf_filter[this_pc].jt = match_pc - (this_pc + 1); ! 185: bpf_filter[this_pc].jf = miss_pc - (this_pc + 1); ! 186: bpf_filter[this_pc].k = byte; ! 187: ! 188: /* update the miss pc: */ ! 189: miss_pc = this_pc; ! 190: } ! 191: ! 192: /* add this load instruction: */ ! 193: this_pc = --(*_first_pc); ! 194: assert(this_pc >= 0); ! 195: bpf_filter[this_pc].code = BPF_LD + BPF_B + BPF_ABS; ! 196: bpf_filter[this_pc].k = prefix_len; ! 197: ! 198: /* return our pc: */ ! 199: return (this_pc); ! 200: } ! 201: ! 202: /* this dumps a BPF filter. not all insns are supported, just ! 203: those used by our address matching filters: */ ! 204: void ! 205: _tme_bsd_bpf_dump_filter(const struct bpf_program *program) ! 206: { ! 207: int pc; ! 208: FILE *fp; ! 209: const struct bpf_insn *insn; ! 210: char ldsize; ! 211: const char *opc; ! 212: ! 213: fp = stderr; ! 214: for (pc = 0, insn = program->bf_insns; ! 215: pc < program->bf_len; ! 216: pc++, insn++) { ! 217: ! 218: /* the PC: */ ! 219: fprintf(fp, "%d:\t", pc); ! 220: ! 221: /* dispatch on the instruction class: */ ! 222: switch (BPF_CLASS(insn->code)) { ! 223: ! 224: case BPF_LD: ! 225: ! 226: switch (BPF_SIZE(insn->code)) { ! 227: case BPF_B: ldsize = 'b'; break; ! 228: case BPF_H: ldsize = 'w'; break; ! 229: case BPF_W: ldsize = 'l'; break; ! 230: default: ldsize = '?'; break; ! 231: } ! 232: fprintf(fp, "ld.%c ", ldsize); ! 233: ! 234: switch (BPF_MODE(insn->code)) { ! 235: case BPF_ABS: fprintf(fp, "0x%x", insn->k); break; ! 236: default: fprintf(fp, "??"); ! 237: } ! 238: ! 239: break; ! 240: ! 241: case BPF_JMP: ! 242: ! 243: switch (BPF_OP(insn->code)) { ! 244: case BPF_JEQ: opc = "jeq"; break; ! 245: default: opc = "??"; break; ! 246: } ! 247: fprintf(fp, "%s ", opc); ! 248: ! 249: switch (BPF_SRC(insn->code)) { ! 250: case BPF_K: fprintf(fp, "#0x%x", insn->k); break; ! 251: case BPF_X: fprintf(fp, "x"); break; ! 252: default: fprintf(fp, "??"); break; ! 253: } ! 254: ! 255: fprintf(fp, ", %d, %d", pc + 1 + insn->jt, pc + 1 + insn->jf); ! 256: break; ! 257: ! 258: case BPF_RET: ! 259: switch (BPF_RVAL(insn->code)) { ! 260: case BPF_A: fprintf(fp, "ret a"); break; ! 261: case BPF_X: fprintf(fp, "ret x"); break; ! 262: case BPF_K: fprintf(fp, "ret #0x%x", insn->k); break; ! 263: default: fprintf(fp, "ret ??"); break; ! 264: } ! 265: break; ! 266: ! 267: default: ! 268: fprintf(fp, "??"); ! 269: break; ! 270: } ! 271: ! 272: putc('\n', fp); ! 273: } ! 274: } ! 275: ! 276: /* the bpf callout function. it must be called with the mutex locked: */ ! 277: static void ! 278: _tme_bsd_bpf_callout(struct tme_bsd_bpf *bpf, int new_callouts) ! 279: { ! 280: struct tme_ethernet_connection *conn_eth; ! 281: int callouts, later_callouts; ! 282: unsigned int ctrl; ! 283: int rc; ! 284: tme_ethernet_fid_t frame_id; ! 285: struct tme_ethernet_frame_chunk frame_chunk_buffer; ! 286: tme_uint8_t frame[TME_ETHERNET_FRAME_MAX]; ! 287: ! 288: /* add in any new callouts: */ ! 289: bpf->tme_bsd_bpf_callout_flags |= new_callouts; ! 290: ! 291: /* if this function is already running in another thread, simply ! 292: return now. the other thread will do our work: */ ! 293: if (bpf->tme_bsd_bpf_callout_flags & TME_BSD_BPF_CALLOUT_RUNNING) { ! 294: return; ! 295: } ! 296: ! 297: /* callouts are now running: */ ! 298: bpf->tme_bsd_bpf_callout_flags |= TME_BSD_BPF_CALLOUT_RUNNING; ! 299: ! 300: /* assume that we won't need any later callouts: */ ! 301: later_callouts = 0; ! 302: ! 303: /* loop while callouts are needed: */ ! 304: for (; (callouts = bpf->tme_bsd_bpf_callout_flags) & TME_BSD_BPF_CALLOUTS_MASK; ) { ! 305: ! 306: /* clear the needed callouts: */ ! 307: bpf->tme_bsd_bpf_callout_flags = callouts & ~TME_BSD_BPF_CALLOUTS_MASK; ! 308: callouts &= TME_BSD_BPF_CALLOUTS_MASK; ! 309: ! 310: /* get our Ethernet connection: */ ! 311: conn_eth = bpf->tme_bsd_bpf_eth_connection; ! 312: ! 313: /* if we need to call out new control information: */ ! 314: if (callouts & TME_BSD_BPF_CALLOUT_CTRL) { ! 315: ! 316: /* form the new ctrl: */ ! 317: ctrl = 0; ! 318: if (bpf->tme_bsd_bpf_buffer_offset ! 319: < bpf->tme_bsd_bpf_buffer_end) { ! 320: ctrl |= TME_ETHERNET_CTRL_OK_READ; ! 321: } ! 322: ! 323: /* unlock the mutex: */ ! 324: tme_mutex_unlock(&bpf->tme_bsd_bpf_mutex); ! 325: ! 326: /* do the callout: */ ! 327: rc = (conn_eth != NULL ! 328: ? ((*conn_eth->tme_ethernet_connection_ctrl) ! 329: (conn_eth, ! 330: ctrl)) ! 331: : TME_OK); ! 332: ! 333: /* lock the mutex: */ ! 334: tme_mutex_lock(&bpf->tme_bsd_bpf_mutex); ! 335: ! 336: /* if the callout was unsuccessful, remember that at some later ! 337: time this callout should be attempted again: */ ! 338: if (rc != TME_OK) { ! 339: later_callouts |= TME_BSD_BPF_CALLOUT_CTRL; ! 340: } ! 341: } ! 342: ! 343: /* if the Ethernet is readable: */ ! 344: if (callouts & TME_BSD_BPF_CALLOUT_READ) { ! 345: ! 346: /* unlock the mutex: */ ! 347: tme_mutex_unlock(&bpf->tme_bsd_bpf_mutex); ! 348: ! 349: /* make a frame chunk to receive this frame: */ ! 350: frame_chunk_buffer.tme_ethernet_frame_chunk_next = NULL; ! 351: frame_chunk_buffer.tme_ethernet_frame_chunk_bytes = frame; ! 352: frame_chunk_buffer.tme_ethernet_frame_chunk_bytes_count ! 353: = sizeof(frame); ! 354: ! 355: /* do the callout: */ ! 356: rc = (conn_eth == NULL ! 357: ? TME_OK ! 358: : ((*conn_eth->tme_ethernet_connection_read) ! 359: (conn_eth, ! 360: &frame_id, ! 361: &frame_chunk_buffer, ! 362: TME_ETHERNET_READ_NEXT))); ! 363: ! 364: /* lock the mutex: */ ! 365: tme_mutex_lock(&bpf->tme_bsd_bpf_mutex); ! 366: ! 367: /* if the read was successful: */ ! 368: if (rc > 0) { ! 369: ! 370: /* do the write: */ ! 371: tme_thread_write(bpf->tme_bsd_bpf_fd, frame, rc); ! 372: ! 373: /* mark that we need to loop to callout to read more frames: */ ! 374: bpf->tme_bsd_bpf_callout_flags |= TME_BSD_BPF_CALLOUT_READ; ! 375: } ! 376: ! 377: /* otherwise, the read failed. convention dictates that we ! 378: forget that the connection was readable, which we already ! 379: have done by clearing the CALLOUT_READ flag: */ ! 380: } ! 381: ! 382: } ! 383: ! 384: /* put in any later callouts, and clear that callouts are running: */ ! 385: bpf->tme_bsd_bpf_callout_flags = later_callouts; ! 386: } ! 387: ! 388: /* the BPF reader thread: */ ! 389: static void ! 390: _tme_bsd_bpf_th_reader(struct tme_bsd_bpf *bpf) ! 391: { ! 392: ssize_t buffer_end; ! 393: ! 394: /* lock the mutex: */ ! 395: tme_mutex_lock(&bpf->tme_bsd_bpf_mutex); ! 396: ! 397: /* loop forever: */ ! 398: for (;;) { ! 399: ! 400: /* if the buffer is not empty, wait until it is: */ ! 401: if (bpf->tme_bsd_bpf_buffer_offset ! 402: < bpf->tme_bsd_bpf_buffer_end) { ! 403: tme_cond_wait_yield(&bpf->tme_bsd_bpf_cond_reader, ! 404: &bpf->tme_bsd_bpf_mutex); ! 405: } ! 406: ! 407: /* unlock the mutex: */ ! 408: tme_mutex_unlock(&bpf->tme_bsd_bpf_mutex); ! 409: ! 410: /* read the BPF socket: */ ! 411: tme_log(&bpf->tme_bsd_bpf_element->tme_element_log_handle, 1, TME_OK, ! 412: (&bpf->tme_bsd_bpf_element->tme_element_log_handle, ! 413: _("calling read"))); ! 414: buffer_end = ! 415: tme_thread_read_yield(bpf->tme_bsd_bpf_fd, ! 416: bpf->tme_bsd_bpf_buffer, ! 417: bpf->tme_bsd_bpf_buffer_size); ! 418: ! 419: /* lock the mutex: */ ! 420: tme_mutex_lock(&bpf->tme_bsd_bpf_mutex); ! 421: ! 422: /* if the read failed: */ ! 423: if (buffer_end <= 0) { ! 424: tme_log(&bpf->tme_bsd_bpf_element->tme_element_log_handle, 1, errno, ! 425: (&bpf->tme_bsd_bpf_element->tme_element_log_handle, ! 426: _("failed to read packets"))); ! 427: continue; ! 428: } ! 429: ! 430: /* the read succeeded: */ ! 431: tme_log(&bpf->tme_bsd_bpf_element->tme_element_log_handle, 1, TME_OK, ! 432: (&bpf->tme_bsd_bpf_element->tme_element_log_handle, ! 433: _("read %ld bytes of packets"), (long) buffer_end)); ! 434: bpf->tme_bsd_bpf_buffer_offset = 0; ! 435: bpf->tme_bsd_bpf_buffer_end = buffer_end; ! 436: ! 437: /* call out that we can be read again: */ ! 438: _tme_bsd_bpf_callout(bpf, TME_BSD_BPF_CALLOUT_CTRL); ! 439: } ! 440: /* NOTREACHED */ ! 441: } ! 442: ! 443: /* this is called when the ethernet configuration changes: */ ! 444: static int ! 445: _tme_bsd_bpf_config(struct tme_ethernet_connection *conn_eth, ! 446: struct tme_ethernet_config *config) ! 447: { ! 448: struct tme_bsd_bpf *bpf; ! 449: struct bpf_insn *bpf_filter; ! 450: struct bpf_program program; ! 451: int bpf_filter_size, first_pc; ! 452: int rc; ! 453: ! 454: /* recover our data structures: */ ! 455: bpf = conn_eth->tme_ethernet_connection.tme_connection_element->tme_element_private; ! 456: ! 457: /* assume we will succeed: */ ! 458: rc = TME_OK; ! 459: ! 460: /* lock the mutex: */ ! 461: tme_mutex_lock(&bpf->tme_bsd_bpf_mutex); ! 462: ! 463: /* allocate space for the worst-case filter: one insn for the packet ! 464: accept, one insn for the packet reject, and TME_ETHERNET_ADDR_SIZE ! 465: * 2 insns for each address - one insn to load an address byte and ! 466: one insn to test it and branch: */ ! 467: bpf_filter_size = (1 ! 468: + 1 ! 469: + ((1 + 1) ! 470: * TME_ETHERNET_ADDR_SIZE ! 471: * config->tme_ethernet_config_addr_count)); ! 472: bpf_filter = tme_new(struct bpf_insn, bpf_filter_size); ! 473: first_pc = bpf_filter_size; ! 474: ! 475: /* if this Ethernet is promiscuous, we will accept all packets: */ ! 476: if (config->tme_ethernet_config_flags & TME_ETHERNET_CONFIG_PROMISC) { ! 477: bpf_filter[--first_pc] = _tme_bsd_bpf_insn_accept; ! 478: } ! 479: ! 480: /* if this Ethernet does have a set of addresses, we will accept all ! 481: packets for one of those addresses: */ ! 482: else if (config->tme_ethernet_config_addr_count > 0) { ! 483: ! 484: /* the last insn in the filter is always the packet reject, ! 485: and the next-to-last insn in the filter is always the ! 486: packet accept. _tme_bsd_bpf_filter depends on this: */ ! 487: bpf_filter[--first_pc] = _tme_bsd_bpf_insn_reject; ! 488: bpf_filter[--first_pc] = _tme_bsd_bpf_insn_accept; ! 489: ! 490: /* make the address filter: */ ! 491: _tme_bsd_bpf_filter(config, ! 492: NULL, ! 493: 0, ! 494: bpf_filter, ! 495: bpf_filter_size, ! 496: &first_pc); ! 497: } ! 498: ! 499: /* otherwise this filter doesn't need to accept any packets: */ ! 500: else { ! 501: bpf_filter[--first_pc] = _tme_bsd_bpf_insn_reject; ! 502: } ! 503: ! 504: /* set the filter on the BPF device: */ ! 505: program.bf_len = bpf_filter_size - first_pc; ! 506: program.bf_insns = bpf_filter + first_pc; ! 507: if (ioctl(bpf->tme_bsd_bpf_fd, BIOCSETF, &program) < 0) { ! 508: tme_log(&bpf->tme_bsd_bpf_element->tme_element_log_handle, 1, errno, ! 509: (&bpf->tme_bsd_bpf_element->tme_element_log_handle, ! 510: _("failed to set the filter"))); ! 511: rc = errno; ! 512: } ! 513: ! 514: /* free the filter: */ ! 515: tme_free(bpf_filter); ! 516: ! 517: /* unlock the mutex: */ ! 518: tme_mutex_unlock(&bpf->tme_bsd_bpf_mutex); ! 519: ! 520: /* done: */ ! 521: return (rc); ! 522: } ! 523: ! 524: /* this is called when control lines change: */ ! 525: static int ! 526: _tme_bsd_bpf_ctrl(struct tme_ethernet_connection *conn_eth, ! 527: unsigned int ctrl) ! 528: { ! 529: struct tme_bsd_bpf *bpf; ! 530: int new_callouts; ! 531: ! 532: /* recover our data structures: */ ! 533: bpf = conn_eth->tme_ethernet_connection.tme_connection_element->tme_element_private; ! 534: ! 535: /* assume that we won't need any new callouts: */ ! 536: new_callouts = 0; ! 537: ! 538: /* lock the mutex: */ ! 539: tme_mutex_lock(&bpf->tme_bsd_bpf_mutex); ! 540: ! 541: /* if this connection is readable, call out a read: */ ! 542: if (ctrl & TME_ETHERNET_CTRL_OK_READ) { ! 543: new_callouts |= TME_BSD_BPF_CALLOUT_READ; ! 544: } ! 545: ! 546: /* make any new callouts: */ ! 547: _tme_bsd_bpf_callout(bpf, new_callouts); ! 548: ! 549: /* unlock the mutex: */ ! 550: tme_mutex_unlock(&bpf->tme_bsd_bpf_mutex); ! 551: ! 552: return (TME_OK); ! 553: } ! 554: ! 555: /* this is called to read a frame: */ ! 556: static int ! 557: _tme_bsd_bpf_read(struct tme_ethernet_connection *conn_eth, ! 558: tme_ethernet_fid_t *_frame_id, ! 559: struct tme_ethernet_frame_chunk *frame_chunks, ! 560: unsigned int flags) ! 561: { ! 562: struct tme_bsd_bpf *bpf; ! 563: struct bpf_hdr the_bpf_header; ! 564: struct tme_ethernet_frame_chunk frame_chunk_buffer; ! 565: unsigned int count; ! 566: int rc; ! 567: ! 568: /* recover our data structure: */ ! 569: bpf = conn_eth->tme_ethernet_connection.tme_connection_element->tme_element_private; ! 570: ! 571: /* lock our mutex: */ ! 572: tme_mutex_lock(&bpf->tme_bsd_bpf_mutex); ! 573: ! 574: /* assume that we won't be able to return a packet: */ ! 575: rc = -ENOENT; ! 576: ! 577: /* loop until we have a good captured packet or until we ! 578: exhaust the buffer: */ ! 579: for (;;) { ! 580: ! 581: /* if there's not enough for a BPF header, flush the buffer: */ ! 582: if ((bpf->tme_bsd_bpf_buffer_offset ! 583: + sizeof(the_bpf_header)) ! 584: > bpf->tme_bsd_bpf_buffer_end) { ! 585: tme_log(&bpf->tme_bsd_bpf_element->tme_element_log_handle, 1, TME_OK, ! 586: (&bpf->tme_bsd_bpf_element->tme_element_log_handle, ! 587: _("flushed garbage BPF header bytes"))); ! 588: bpf->tme_bsd_bpf_buffer_end = 0; ! 589: break; ! 590: } ! 591: ! 592: /* get the BPF header and check it: */ ! 593: memcpy(&the_bpf_header, ! 594: bpf->tme_bsd_bpf_buffer ! 595: + bpf->tme_bsd_bpf_buffer_offset, ! 596: sizeof(the_bpf_header)); ! 597: bpf->tme_bsd_bpf_buffer_offset += the_bpf_header.bh_hdrlen; ! 598: ! 599: /* if we're missing some part of the packet: */ ! 600: if (the_bpf_header.bh_caplen != the_bpf_header.bh_datalen ! 601: || ((bpf->tme_bsd_bpf_buffer_offset + the_bpf_header.bh_datalen) ! 602: > bpf->tme_bsd_bpf_buffer_end)) { ! 603: tme_log(&bpf->tme_bsd_bpf_element->tme_element_log_handle, 1, TME_OK, ! 604: (&bpf->tme_bsd_bpf_element->tme_element_log_handle, ! 605: _("flushed truncated BPF packet"))); ! 606: bpf->tme_bsd_bpf_buffer_offset += the_bpf_header.bh_datalen; ! 607: continue; ! 608: } ! 609: ! 610: /* if this packet isn't big enough to even have an Ethernet header: */ ! 611: if (the_bpf_header.bh_datalen < sizeof(struct tme_ethernet_header)) { ! 612: tme_log(&bpf->tme_bsd_bpf_element->tme_element_log_handle, 1, TME_OK, ! 613: (&bpf->tme_bsd_bpf_element->tme_element_log_handle, ! 614: _("flushed short BPF packet"))); ! 615: bpf->tme_bsd_bpf_buffer_offset += the_bpf_header.bh_datalen; ! 616: continue; ! 617: } ! 618: ! 619: /* form the single frame chunk: */ ! 620: frame_chunk_buffer.tme_ethernet_frame_chunk_next = NULL; ! 621: frame_chunk_buffer.tme_ethernet_frame_chunk_bytes ! 622: = bpf->tme_bsd_bpf_buffer + bpf->tme_bsd_bpf_buffer_offset; ! 623: frame_chunk_buffer.tme_ethernet_frame_chunk_bytes_count ! 624: = the_bpf_header.bh_datalen; ! 625: ! 626: /* copy out the frame: */ ! 627: count = tme_ethernet_chunks_copy(frame_chunks, &frame_chunk_buffer); ! 628: ! 629: /* if this isn't a peek: */ ! 630: if (!(flags & TME_ETHERNET_READ_PEEK)) { ! 631: ! 632: /* update the buffer pointer: */ ! 633: bpf->tme_bsd_bpf_buffer_offset += the_bpf_header.bh_datalen; ! 634: } ! 635: ! 636: /* success: */ ! 637: rc = count; ! 638: break; ! 639: } ! 640: ! 641: /* if the buffer is empty, notify the reader that we need more data: */ ! 642: if (bpf->tme_bsd_bpf_buffer_offset ! 643: >= bpf->tme_bsd_bpf_buffer_end) { ! 644: tme_cond_notify(&bpf->tme_bsd_bpf_cond_reader, TRUE); ! 645: } ! 646: ! 647: /* unlock our mutex: */ ! 648: tme_mutex_unlock(&bpf->tme_bsd_bpf_mutex); ! 649: ! 650: /* done: */ ! 651: return (rc); ! 652: } ! 653: ! 654: /* this makes a new Ethernet connection: */ ! 655: static int ! 656: _tme_bsd_bpf_connection_make(struct tme_connection *conn, unsigned int state) ! 657: { ! 658: struct tme_bsd_bpf *bpf; ! 659: struct tme_ethernet_connection *conn_eth; ! 660: struct tme_ethernet_connection *conn_eth_other; ! 661: ! 662: /* recover our data structures: */ ! 663: bpf = conn->tme_connection_element->tme_element_private; ! 664: conn_eth = (struct tme_ethernet_connection *) conn; ! 665: conn_eth_other = (struct tme_ethernet_connection *) conn->tme_connection_other; ! 666: ! 667: /* both sides must be Ethernet connections: */ ! 668: assert(conn->tme_connection_type == TME_CONNECTION_ETHERNET); ! 669: assert(conn->tme_connection_other->tme_connection_type == TME_CONNECTION_ETHERNET); ! 670: ! 671: /* we're always set up to answer calls across the connection, so we ! 672: only have to do work when the connection has gone full, namely ! 673: taking the other side of the connection: */ ! 674: if (state == TME_CONNECTION_FULL) { ! 675: ! 676: /* lock our mutex: */ ! 677: tme_mutex_lock(&bpf->tme_bsd_bpf_mutex); ! 678: ! 679: /* save our connection: */ ! 680: bpf->tme_bsd_bpf_eth_connection = conn_eth_other; ! 681: ! 682: /* unlock our mutex: */ ! 683: tme_mutex_unlock(&bpf->tme_bsd_bpf_mutex); ! 684: } ! 685: ! 686: return (TME_OK); ! 687: } ! 688: ! 689: /* this breaks a connection: */ ! 690: static int ! 691: _tme_bsd_bpf_connection_break(struct tme_connection *conn, unsigned int state) ! 692: { ! 693: abort(); ! 694: } ! 695: ! 696: /* this makes a new connection side for a BPF: */ ! 697: static int ! 698: _tme_bsd_bpf_connections_new(struct tme_element *element, ! 699: const char * const *args, ! 700: struct tme_connection **_conns, ! 701: char **_output) ! 702: { ! 703: struct tme_bsd_bpf *bpf; ! 704: struct tme_ethernet_connection *conn_eth; ! 705: struct tme_connection *conn; ! 706: ! 707: /* recover our data structure: */ ! 708: bpf = (struct tme_bsd_bpf *) element->tme_element_private; ! 709: ! 710: /* if we already have an Ethernet connection, do nothing: */ ! 711: if (bpf->tme_bsd_bpf_eth_connection != NULL) { ! 712: return (TME_OK); ! 713: } ! 714: ! 715: /* allocate the new Ethernet connection: */ ! 716: conn_eth = tme_new0(struct tme_ethernet_connection, 1); ! 717: conn = &conn_eth->tme_ethernet_connection; ! 718: ! 719: /* fill in the generic connection: */ ! 720: conn->tme_connection_next = *_conns; ! 721: conn->tme_connection_type = TME_CONNECTION_ETHERNET; ! 722: conn->tme_connection_score = tme_ethernet_connection_score; ! 723: conn->tme_connection_make = _tme_bsd_bpf_connection_make; ! 724: conn->tme_connection_break = _tme_bsd_bpf_connection_break; ! 725: ! 726: /* fill in the Ethernet connection: */ ! 727: conn_eth->tme_ethernet_connection_config = _tme_bsd_bpf_config; ! 728: conn_eth->tme_ethernet_connection_ctrl = _tme_bsd_bpf_ctrl; ! 729: conn_eth->tme_ethernet_connection_read = _tme_bsd_bpf_read; ! 730: ! 731: /* return the connection side possibility: */ ! 732: *_conns = conn; ! 733: ! 734: /* done: */ ! 735: return (TME_OK); ! 736: } ! 737: ! 738: /* the new BPF function: */ ! 739: TME_ELEMENT_SUB_NEW_DECL(tme_host_bsd,bpf) { ! 740: struct tme_bsd_bpf *bpf; ! 741: int bpf_fd; ! 742: #define DEV_BPF_FORMAT "/dev/bpf%d" ! 743: char dev_bpf_filename[sizeof(DEV_BPF_FORMAT) + (sizeof(int) * 3) + 1]; ! 744: int minor; ! 745: int saved_errno; ! 746: u_int bpf_opt; ! 747: struct bpf_version version; ! 748: u_int packet_buffer_size; ! 749: const char *ifr_name_user; ! 750: struct ifreq *ifr; ! 751: int arg_i; ! 752: int usage; ! 753: int rc; ! 754: ! 755: /* check our arguments: */ ! 756: usage = 0; ! 757: ifr_name_user = NULL; ! 758: arg_i = 1; ! 759: for (;;) { ! 760: ! 761: /* the interface we're supposed to use: */ ! 762: if (TME_ARG_IS(args[arg_i + 0], "interface") ! 763: && args[arg_i + 1] != NULL) { ! 764: ifr_name_user = args[arg_i + 1]; ! 765: arg_i += 2; ! 766: } ! 767: ! 768: /* if we ran out of arguments: */ ! 769: else if (args[arg_i + 0] == NULL) { ! 770: break; ! 771: } ! 772: ! 773: /* otherwise this is a bad argument: */ ! 774: else { ! 775: tme_output_append_error(_output, ! 776: "%s %s", ! 777: args[arg_i], ! 778: _("unexpected")); ! 779: usage = TRUE; ! 780: break; ! 781: } ! 782: } ! 783: ! 784: if (usage) { ! 785: tme_output_append_error(_output, ! 786: "%s %s [ interface %s ]", ! 787: _("usage:"), ! 788: args[0], ! 789: _("INTERFACE")); ! 790: return (EINVAL); ! 791: } ! 792: ! 793: /* find the interface we will use: */ ! 794: rc = tme_bsd_if_find(ifr_name_user, &ifr, NULL, NULL); ! 795: if (rc != TME_OK) { ! 796: tme_output_append_error(_output, _("couldn't find an interface")); ! 797: return (ENOENT); ! 798: } ! 799: tme_log(&element->tme_element_log_handle, 1, TME_OK, ! 800: (&element->tme_element_log_handle, ! 801: "using interface %s", ! 802: ifr->ifr_name)); ! 803: ! 804: /* loop trying to open a /dev/bpf device: */ ! 805: for (minor = 0;; minor++) { ! 806: ! 807: /* form the name of the next device to try, then try opening ! 808: it. if we succeed, we're done: */ ! 809: sprintf(dev_bpf_filename, DEV_BPF_FORMAT, minor); ! 810: tme_log(&element->tme_element_log_handle, 1, TME_OK, ! 811: (&element->tme_element_log_handle, ! 812: "trying %s", ! 813: dev_bpf_filename)); ! 814: if ((bpf_fd = open(dev_bpf_filename, O_RDWR)) >= 0) { ! 815: tme_log(&element->tme_element_log_handle, 1, TME_OK, ! 816: (&element->tme_element_log_handle, ! 817: "opened %s", ! 818: dev_bpf_filename)); ! 819: break; ! 820: } ! 821: ! 822: /* we failed to open this device. if this device was simply ! 823: busy, loop: */ ! 824: saved_errno = errno; ! 825: tme_log(&element->tme_element_log_handle, 1, saved_errno, ! 826: (&element->tme_element_log_handle, ! 827: "%s", dev_bpf_filename)); ! 828: if (saved_errno == EBUSY ! 829: || saved_errno == EACCES) { ! 830: continue; ! 831: } ! 832: ! 833: /* otherwise, we have failed: */ ! 834: return (saved_errno); ! 835: } ! 836: ! 837: /* this macro helps in closing the BPF socket on error: */ ! 838: #define _TME_BPF_RAW_OPEN_ERROR(x) saved_errno = errno; x; errno = saved_errno ! 839: ! 840: /* check the BPF version: */ ! 841: if (ioctl(bpf_fd, BIOCVERSION, &version) < 0) { ! 842: tme_log(&element->tme_element_log_handle, 1, errno, ! 843: (&element->tme_element_log_handle, ! 844: _("failed to get the BPF version on %s"), ! 845: dev_bpf_filename)); ! 846: _TME_BPF_RAW_OPEN_ERROR(close(bpf_fd)); ! 847: return (errno); ! 848: } ! 849: if (version.bv_major != BPF_MAJOR_VERSION ! 850: || version.bv_minor < BPF_MINOR_VERSION) { ! 851: tme_log(&element->tme_element_log_handle, 1, errno, ! 852: (&element->tme_element_log_handle, ! 853: _("kernel BPF version is %d.%d, my BPF version is %d.%d"), ! 854: version.bv_major, version.bv_minor, ! 855: BPF_MAJOR_VERSION, BPF_MINOR_VERSION)); ! 856: close(bpf_fd); ! 857: return (ENXIO); ! 858: } ! 859: ! 860: /* put the BPF device into immediate mode: */ ! 861: bpf_opt = TRUE; ! 862: if (ioctl(bpf_fd, BIOCIMMEDIATE, &bpf_opt) < 0) { ! 863: tme_log(&element->tme_element_log_handle, 1, errno, ! 864: (&element->tme_element_log_handle, ! 865: _("failed to put %s into immediate mode"), ! 866: dev_bpf_filename)); ! 867: _TME_BPF_RAW_OPEN_ERROR(close(bpf_fd)); ! 868: return (errno); ! 869: } ! 870: ! 871: /* tell the BPF device we're providing complete Ethernet headers: */ ! 872: bpf_opt = TRUE; ! 873: if (ioctl(bpf_fd, BIOCSHDRCMPLT, &bpf_opt) < 0) { ! 874: tme_log(&element->tme_element_log_handle, 1, errno, ! 875: (&element->tme_element_log_handle, ! 876: _("failed to put %s into complete-headers mode"), ! 877: dev_bpf_filename)); ! 878: _TME_BPF_RAW_OPEN_ERROR(close(bpf_fd)); ! 879: return (errno); ! 880: } ! 881: ! 882: /* point the BPF device at the interface we're using: */ ! 883: if (ioctl(bpf_fd, BIOCSETIF, ifr) < 0) { ! 884: tme_log(&element->tme_element_log_handle, 1, errno, ! 885: (&element->tme_element_log_handle, ! 886: _("failed to point BPF socket at %s"), ! 887: ifr->ifr_name)); ! 888: saved_errno = errno; ! 889: close(bpf_fd); ! 890: errno = saved_errno; ! 891: return (errno); ! 892: } ! 893: ! 894: /* get the BPF read buffer size: */ ! 895: if (ioctl(bpf_fd, BIOCGBLEN, &packet_buffer_size) < 0) { ! 896: tme_log(&element->tme_element_log_handle, 1, errno, ! 897: (&element->tme_element_log_handle, ! 898: _("failed to read the buffer size for %s"), ! 899: dev_bpf_filename)); ! 900: _TME_BPF_RAW_OPEN_ERROR(close(bpf_fd)); ! 901: return (errno); ! 902: } ! 903: tme_log(&element->tme_element_log_handle, 1, errno, ! 904: (&element->tme_element_log_handle, ! 905: _("buffer size for %s is %u"), ! 906: dev_bpf_filename, packet_buffer_size)); ! 907: ! 908: /* set the interface into promiscuous mode: */ ! 909: if (ioctl(bpf_fd, BIOCPROMISC) < 0) { ! 910: tme_log(&element->tme_element_log_handle, 1, errno, ! 911: (&element->tme_element_log_handle, ! 912: _("failed to set promiscuous mode on %s"), ! 913: dev_bpf_filename)); ! 914: _TME_BPF_RAW_OPEN_ERROR(close(bpf_fd)); ! 915: return (errno); ! 916: } ! 917: ! 918: /* start our data structure: */ ! 919: bpf = tme_new0(struct tme_bsd_bpf, 1); ! 920: bpf->tme_bsd_bpf_element = element; ! 921: bpf->tme_bsd_bpf_fd = bpf_fd; ! 922: bpf->tme_bsd_bpf_buffer_size = packet_buffer_size; ! 923: bpf->tme_bsd_bpf_buffer = tme_new(tme_uint8_t, packet_buffer_size); ! 924: ! 925: /* start the threads: */ ! 926: tme_mutex_init(&bpf->tme_bsd_bpf_mutex); ! 927: tme_cond_init(&bpf->tme_bsd_bpf_cond_writer); ! 928: tme_thread_create((tme_thread_t) _tme_bsd_bpf_th_reader, bpf); ! 929: ! 930: /* fill the element: */ ! 931: element->tme_element_private = bpf; ! 932: element->tme_element_connections_new = _tme_bsd_bpf_connections_new; ! 933: ! 934: return (TME_OK); ! 935: #undef _TME_BPF_RAW_OPEN_ERROR ! 936: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.