![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to if_blue.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / XNU / bsd / net|
Return to if_blue.c CVS log | Up to [Apple XNU] / XNU / bsd / net |
1.1 ! root 1: /* ! 2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * The contents of this file constitute Original Code as defined in and ! 7: * are subject to the Apple Public Source License Version 1.1 (the ! 8: * "License"). You may not use this file except in compliance with the ! 9: * License. Please obtain a copy of the License at ! 10: * http://www.apple.com/publicsource and read it before using this file. ! 11: * ! 12: * This Original Code and all software distributed under the License are ! 13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 17: * License for the specific language governing rights and limitations ! 18: * under the License. ! 19: * ! 20: * @APPLE_LICENSE_HEADER_END@ ! 21: */ ! 22: /* Copyright (c) 1997, 1998 Apple Computer, Inc. All Rights Reserved */ ! 23: /* ! 24: * @(#)if_blue.c 1.1 (MacOSX) 6/10/43 ! 25: * Justin Walker, 9970520 ! 26: * First wave - splitter and notification support for the Blue Box ! 27: * 980130 - Second wave - Performance improvements, reorg and cleanup ! 28: */ ! 29: ! 30: #include <sys/kdebug.h> ! 31: #if KDEBUG ! 32: ! 33: #define DBG_SPLT_BFCHK DRVDBG_CODE(DBG_DRVSPLT, 0) ! 34: #define DBG_SPLT_APPND DRVDBG_CODE(DBG_DRVSPLT, 1) ! 35: #define DBG_SPLT_MBUF DRVDBG_CODE(DBG_DRVSPLT, 2) ! 36: #define DBG_SPLT_DUP DRVDBG_CODE(DBG_DRVSPLT, 3) ! 37: #define DBG_SPLT_PAD DRVDBG_CODE(DBG_DRVSPLT, 4) ! 38: ! 39: #endif ! 40: ! 41: ! 42: #include <sys/param.h> ! 43: #include <sys/systm.h> ! 44: #include <sys/kernel.h> ! 45: #include <sys/malloc.h> ! 46: #include <sys/mbuf.h> ! 47: #include <sys/protosw.h> ! 48: #include <sys/socket.h> ! 49: #include <sys/socketvar.h> ! 50: #include <sys/ioctl.h> ! 51: #include <sys/errno.h> ! 52: #include <sys/syslog.h> ! 53: #include <sys/proc.h> ! 54: #include <sys/vm.h> ! 55: ! 56: #include <kern/cpu_number.h> ! 57: ! 58: #include <net/if.h> ! 59: #include <net/netisr.h> ! 60: #include <net/route.h> ! 61: #include <net/if_llc.h> ! 62: #include <net/if_dl.h> ! 63: #include <net/if_types.h> ! 64: #include "if_blue.h" ! 65: #include "ndrv.h" ! 66: ! 67: #if INET ! 68: #include <netinet/in.h> ! 69: #include <netinet/in_var.h> ! 70: #endif ! 71: #include <netinet/if_ether.h> ! 72: ! 73: #if NS ! 74: #include <netns/ns.h> ! 75: #include <netns/ns_if.h> ! 76: #endif ! 77: ! 78: #if ISO ! 79: #include <netiso/argo_debug.h> ! 80: #include <netiso/iso.h> ! 81: #include <netiso/iso_var.h> ! 82: #include <netiso/iso_snpac.h> ! 83: #endif ! 84: ! 85: #if LLC ! 86: #include <netccitt/dll.h> ! 87: #include <netccitt/llc_var.h> ! 88: #endif ! 89: ! 90: #include <sys/systm.h> ! 91: #include <machine/spl.h> ! 92: #include <kern/thread.h> ! 93: #include <kern/queue.h> ! 94: ! 95: /* Dummy IFs to differentiate source of looped packets */ ! 96: struct ifnet rhap_if_s; ! 97: struct ifnet *rhap_if = &rhap_if_s; ! 98: struct ifnet_blue *blue_if; ! 99: struct sockaddr_dl ndrvsrc = {sizeof (struct sockaddr_dl), AF_NDRV}; ! 100: ! 101: struct ifqueue blueq; ! 102: ! 103: extern int if_register(register struct BlueFilter *f ! 104: #ifdef BF_if ! 105: , ! 106: register struct ifnet *ifp ! 107: #endif ! 108: ); ! 109: ! 110: /* ! 111: * Blue Box support: ! 112: * 1st cut: the Y splitter ! 113: * A process turns on the splitter by opening the "raw" device ! 114: * (socket() for AF_NDRV) and issuing an SIOCSSPLITTER ioctl. ! 115: * Incoming packets are routed into MacOSX as well as to the requesting ! 116: * interface. ! 117: * Outbound packets are sent, and are examined to see if they should go ! 118: * back up (loopback, sort of). Packets that are looped back include: ! 119: * broadcast ! 120: * multicast ! 121: */ ! 122: int ! 123: new_splitter(register struct socket *so) ! 124: { register struct ifnet_blue *ifb; ! 125: register struct ndrv_cb *np; ! 126: register struct ifnet *ifp; ! 127: struct BlueFilter filter; ! 128: int retval; ! 129: ! 130: if ((ifb = _MALLOC(sizeof (struct ifnet_blue), M_PCB, M_WAITOK)) ! 131: == NULL) ! 132: { ! 133: #if BLUE_DEBUG ! 134: kprintf("Can't create new splitter\n"); ! 135: #endif ! 136: return(ENOBUFS); ! 137: } ! 138: bzero(ifb, sizeof(struct ifnet_blue)); ! 139: np = (struct ndrv_cb *)so->so_pcb; ! 140: #if BLUE_DEBUG ! 141: kprintf("NEW SPLT: %x, %x\n", so, np); ! 142: if (np) ! 143: printf("SIG: %x, ifp: %x\n", np->nd_signature, np->nd_if); ! 144: #endif ! 145: if (np == NULL) ! 146: return(EINVAL); /* XXX */ ! 147: if (np->nd_signature != NDRV_SIGNATURE) ! 148: return(EINVAL); /* XXX */ ! 149: if ((ifp = np->nd_if) == NULL) ! 150: return(EINVAL); /* XXX */ ! 151: if (ifp->if_flags & IFF_SPLITTER) ! 152: return(EBUSY); ! 153: if ((ifp->if_flags&IFF_UP) == 0) ! 154: return(ENXIO); ! 155: /* ! 156: * Bump the receive sockbuf size - need a big buffer ! 157: * to offset the scheduling latencies of the system ! 158: * Try to get something if our grandiose design fails. ! 159: */ ! 160: if (sbreserve(&so->so_rcv, 131072) == 0) ! 161: { if (sbreserve(&so->so_rcv, 65536) == 0 && ! 162: sbreserve(&so->so_rcv, 32768) == 0 && ! 163: sbreserve(&so->so_rcv, 16384) == 0) ! 164: return(ENOBUFS); ! 165: } ! 166: ifp->if_flags |= IFF_SPLITTER; ! 167: /* ! 168: * Register each IP address associated with this ifnet ! 169: * This takes care of addresses registered prior to startup ! 170: * of the BlueBox. ! 171: * TODO: Appletalk sockaddrs ! 172: */ ! 173: #define IFA2IN(ifa) \ ! 174: ((struct in_addr) \ ! 175: ((struct sockaddr_in *)(ifa->ifa_addr))->sin_addr).s_addr ! 176: { struct ifaddr *ifa; ! 177: ! 178: TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) ! 179: { if (ifa->ifa_addr->sa_family == AF_INET) ! 180: { filter.BF_flags = (BF_ALLOC|BF_IP); ! 181: filter.BF_address = IFA2IN(ifa); ! 182: #if BLUE_DEBUG ! 183: kprintf("[1] IP registering [%x] %x\n", ! 184: filter.BF_flags, ! 185: (unsigned int)filter.BF_address); ! 186: #endif ! 187: retval = if_register(&filter); ! 188: #if BLUE_DEBUG ! 189: if (retval) ! 190: kprintf("if_register(IP) returns %d\n", ! 191: retval); ! 192: #endif ! 193: } ! 194: } ! 195: } ! 196: ! 197: blue_if = (struct ifnet_blue *)ifb; ! 198: ifb->blue_pid = ((struct proc *)current_proc())->p_pid; ! 199: ifb->ifb_so = so; ! 200: ifp->if_Y = (void *)ifb; ! 201: return(0); ! 202: } ! 203: ! 204: /* ! 205: * Determine if destined for BlueBox or not. Called from ether_output() ! 206: * and ether_input(). ! 207: * Returns NULL if we ate the packet, otherwise, the mbuf to continue with. ! 208: */ ! 209: struct mbuf * ! 210: splitter_input(register struct mbuf *m, register struct ifnet *ifp) ! 211: { register struct ifnet_blue *ifb; ! 212: #if 0 ! 213: register int s, flags; ! 214: #else ! 215: register int flags; ! 216: #endif ! 217: int rv; ! 218: register struct mbuf *m0 = NULL; ! 219: struct mbuf *m1; ! 220: extern struct mbuf *m_dup(struct mbuf *, int); ! 221: extern int BlueFilter_check(struct mbuf **, struct ifnet_blue *); ! 222: extern void blue_notify(struct mbuf *); ! 223: extern int blue_notify1(struct mbuf *); ! 224: ! 225: if ((ifb = (struct ifnet_blue *)ifp->if_Y) == NULL) ! 226: { ifp->if_flags &= ~IFF_SPLITTER; ! 227: return(m); ! 228: } ! 229: flags = m->m_flags; ! 230: m1 = m; ! 231: /* Check filters */ ! 232: if ((rv = BlueFilter_check(&m1, ifb)) == -1) ! 233: return(m1); /* Not for BB, MacOSX will want to see it. */ ! 234: m = m1; ! 235: if (rv == 0) /* It's for both - dup the packet */ ! 236: { m0 = m_dup(m, M_DONTWAIT); ! 237: if (m0 == NULL) ! 238: { blue_if->no_bufs1++; ! 239: return(m); /* Give it to MacOSX */ ! 240: } ! 241: } else ! 242: { /* Oy, veh! The depths to which we stoop! */ ! 243: /* We'll just assume M_PKTHDR is set */ ! 244: if (m->m_next == 0 && (m->m_flags & M_EXT) ! 245: && m->m_pkthdr.len <= MHLEN) ! 246: { m0 = m_dup(m, M_DONTWAIT); ! 247: if (m0) ! 248: { m_freem(m); ! 249: m = NULL; ! 250: } else ! 251: m0 = m; ! 252: } else ! 253: m0 = m; ! 254: } ! 255: if (flags & 0x10) ! 256: blue_if->pkts_looped_r2b++; ! 257: ! 258: #if 0 ! 259: schednetisr(NETISR_BLUE); ! 260: s = splimp(); ! 261: if (IF_QFULL(&blueq)) { ! 262: IF_DROP(&blueq); ! 263: m_freem(m0); ! 264: } else ! 265: IF_ENQUEUE(&blueq, m0); ! 266: splx(s); ! 267: #else ! 268: blue_notify1(m0); ! 269: sorwakeup(blue_if->ifb_so); ! 270: blue_if->sig_sent++; ! 271: #endif ! 272: /* If we eat the packet (rv==1) return NULL */ ! 273: return(rv == 0 ? m : NULL); ! 274: } ! 275: ! 276: void ! 277: blue_notify() ! 278: { register int do_notify = 0; ! 279: register int s; ! 280: register struct mbuf *m; ! 281: extern int blue_notify1(struct mbuf *); ! 282: ! 283: /* ! 284: * Move the packets from the blue queue to the indicated socket ! 285: * If we haven't told anyone yet, send a signal. ! 286: */ ! 287: for (;;) ! 288: { s = splimp(); ! 289: IF_DEQUEUE(&blueq, m); ! 290: splx(s); ! 291: if (m == 0) ! 292: break; ! 293: ! 294: do_notify = blue_notify1(m); ! 295: } ! 296: if (do_notify) ! 297: sorwakeup(blue_if->ifb_so); /* Start by using SIGIO */ ! 298: } ! 299: ! 300: int ! 301: blue_notify1(register struct mbuf *m) ! 302: { register int rv; ! 303: ! 304: /* move packet from if queue to socket */ ! 305: /* !!!Fix this to work generically!!! */ ! 306: ndrvsrc.sdl_type = IFT_ETHER; ! 307: ndrvsrc.sdl_nlen = 0; ! 308: ndrvsrc.sdl_alen = 6; ! 309: ndrvsrc.sdl_slen = 0; ! 310: bcopy(m->m_data+6, &ndrvsrc.sdl_data, 6); ! 311: ! 312: if (sbappendaddr(&(blue_if->ifb_so->so_rcv), ! 313: (struct sockaddr *)&ndrvsrc, m, ! 314: (struct mbuf *)0) == 0) ! 315: { register struct mbuf *n; ! 316: ! 317: KERNEL_DEBUG(DBG_SPLT_APPND | DBG_FUNC_NONE, ! 318: blue_if->ifb_so->so_rcv.sb_cc, ! 319: blue_if->ifb_so->so_rcv.sb_hiwat, ! 320: blue_if->ifb_so->so_rcv.sb_mbcnt, ! 321: blue_if->ifb_so->so_rcv.sb_mbmax, ! 322: blue_if->ifb_so->so_rcv.sb_lowat ); ! 323: if (m->m_flags & M_PKTHDR) ! 324: KERNEL_DEBUG(DBG_SPLT_MBUF, 0, m->m_pkthdr.len, ! 325: m->m_flags, 0, 0); ! 326: for (n = m; n; n = n->m_next) ! 327: KERNEL_DEBUG(DBG_SPLT_MBUF, 1, ! 328: (int)n, (int)n->m_next, n->m_len, ! 329: n->m_flags); ! 330: m_freem(m); ! 331: blue_if->full_sockbuf++; ! 332: rv = 1; ! 333: } else ! 334: { register struct mbuf *n; ! 335: ! 336: KERNEL_DEBUG(DBG_SPLT_APPND | DBG_FUNC_NONE, ! 337: blue_if->ifb_so->so_rcv.sb_cc, ! 338: blue_if->ifb_so->so_rcv.sb_hiwat, ! 339: blue_if->ifb_so->so_rcv.sb_mbcnt, ! 340: blue_if->ifb_so->so_rcv.sb_mbmax, ! 341: blue_if->ifb_so->so_rcv.sb_lowat ); ! 342: if (m->m_flags & M_PKTHDR) ! 343: KERNEL_DEBUG(DBG_SPLT_MBUF, 2, m->m_pkthdr.len, ! 344: m->m_flags, 0, 0); ! 345: for (n = m; n; n = n->m_next) ! 346: KERNEL_DEBUG(DBG_SPLT_MBUF, 3, ! 347: (int)n, (int)n->m_next, n->m_len, ! 348: n->m_flags); ! 349: blue_if->pkts_up++; ! 350: rv = 0; ! 351: } ! 352: return(rv); ! 353: } ! 354: ! 355: /* ! 356: * Check the incoming packet against the registered filters ! 357: * Rules (the rules are subtly different for input to the ! 358: * y-adapter customer and the "real" stacks): ! 359: * For BB: return 1 ! 360: * For Both: return 0 ! 361: * Not For BB: return -1 ! 362: * Multicast/Broadcast => For Both ! 363: * Hack: ! 364: * if no registered filters, For Both ! 365: * Atalk filter registered ! 366: * filter matches => For BB else Not For BB ! 367: * IP filter registered ! 368: * filter matches => For BB else Not For BB ! 369: * Not For BB ! 370: * WARNING: this is a big-endian routine. ! 371: * WARNING 2: m_pullup can give you a new mbuf! ! 372: */ ! 373: int ! 374: BlueFilter_check(struct mbuf **m0, register struct ifnet_blue *ifb) ! 375: { register struct BlueFilter *bf; ! 376: register unsigned char *p; ! 377: register unsigned short *s; ! 378: register unsigned long *l; ! 379: int total, flags; ! 380: register struct mbuf *m; ! 381: extern struct mbuf *m_pullup(struct mbuf *, int); ! 382: #define FILTER_LEN 32 ! 383: ! 384: KERNEL_DEBUG(DBG_SPLT_BFCHK | DBG_FUNC_START, 0, 0, 0, 0, 0 ); ! 385: ! 386: m = *m0; ! 387: if (FILTER_LEN > m->m_pkthdr.len) ! 388: { KERNEL_DEBUG(DBG_SPLT_BFCHK | DBG_FUNC_END, 0, 0, 0, 0, 0 ); ! 389: return(-1); ! 390: } ! 391: flags = m->m_flags; ! 392: while ((FILTER_LEN > m->m_len) && m->m_next) { ! 393: total = m->m_len + (m->m_next)->m_len; ! 394: if ((m = m_pullup(m, min(FILTER_LEN, total))) == 0) ! 395: { KERNEL_DEBUG(DBG_SPLT_BFCHK | DBG_FUNC_END, 1, flags, total, 0, 0); ! 396: return(-1); ! 397: } ! 398: } ! 399: *m0 = m; /* Update, just in case */ ! 400: ! 401: p = mtod(m, unsigned char *); /* Point to destination media addr */ ! 402: if (p[0] & 0x01) /* Multicast/broadcast */ ! 403: { KERNEL_DEBUG(DBG_SPLT_BFCHK | DBG_FUNC_END, 2, 0, 0, 0, 0 ); ! 404: return(0); ! 405: } ! 406: s = (unsigned short *)p; ! 407: bf = &ifb->filter[BFS_ATALK]; ! 408: if (!bf->BF_flags && !bf[1].BF_flags) /* Hack for Developer Release Blue Box */ ! 409: { KERNEL_DEBUG(DBG_SPLT_BFCHK | DBG_FUNC_END, 3, 0, 0, 0, 0 ); ! 410: return(0); ! 411: } ! 412: #if BLUE_DEBUG ! 413: kprintf("PKT: %x, %x, %x\n", s[6], s[7], s[8]); ! 414: #endif ! 415: if (bf->BF_flags) /* Filtering Appletalk */ ! 416: { l = (unsigned long *)&s[8]; ! 417: #if BLUE_DEBUG ! 418: kprintf("AT: %x, %x, %x, %x, %x, %x\n", s[6], s[7], ! 419: *l, s[10], s[13], p[30]); ! 420: #endif ! 421: if (s[6] <= ETHERMTU) ! 422: { if (s[7] == 0xaaaa) /* Could be Atalk */ ! 423: { /* Verify SNAP header */ ! 424: if (*l == 0x03080007 && s[10] == 0x809b) ! 425: { if ((bf->BF_flags&BF_VALID) == 0 || ! 426: (s[13] == bf->BF_address && ! 427: p[30] == bf->BF_node)) ! 428: { KERNEL_DEBUG(DBG_SPLT_BFCHK | DBG_FUNC_END, 4, ! 429: s[13], p[30], 0, 0 ); ! 430: return(1); ! 431: } ! 432: } else if (*l == 0x03000000 && s[10] == 0x80f3) ! 433: /* AARP pkts aren't net-addressed */ ! 434: { KERNEL_DEBUG(DBG_SPLT_BFCHK | DBG_FUNC_END, 5, 0, 0, 0, 0 ); ! 435: return(0); ! 436: } ! 437: /* Not for us */ ! 438: KERNEL_DEBUG(DBG_SPLT_BFCHK | DBG_FUNC_END, 6, s[13], p[30], 0, 0 ); ! 439: return(-1); ! 440: } else /* Not for us? */ ! 441: { KERNEL_DEBUG(DBG_SPLT_BFCHK | DBG_FUNC_END, 7, s[7], 0, 0, 0 ); ! 442: return(-1); ! 443: } ! 444: } /* Fall through */ ! 445: } /* Fall through */ ! 446: bf++; /* Look for IP next */ ! 447: if (bf->BF_flags) /* Filtering IP */ ! 448: { ! 449: l = (unsigned long *)&s[15]; ! 450: #if BLUE_DEBUG ! 451: kprintf("IP: %x, %x\n", s[6], *l); ! 452: #endif ! 453: if (s[6] > ETHERMTU) ! 454: { if (s[6] == 0x800) /* Is IP */ ! 455: { /* Verify IP address */ ! 456: if ((bf->BF_flags&BF_VALID) == 0 || ! 457: *l == bf->BF_address) ! 458: { KERNEL_DEBUG(DBG_SPLT_BFCHK | DBG_FUNC_END, 8, *l, 0, 0, 0 ); ! 459: return(1); ! 460: } else /* Not for us */ ! 461: { KERNEL_DEBUG(DBG_SPLT_BFCHK | DBG_FUNC_END, 9, *l, 0, 0, 0 ); ! 462: return(-1); ! 463: } ! 464: } else if (s[6] == 0x806) ! 465: { /* ARP pkts aren't net-addressed */ ! 466: KERNEL_DEBUG(DBG_SPLT_BFCHK | DBG_FUNC_END, 10, 0, 0, 0, 0 ); ! 467: return(0); ! 468: } ! 469: } ! 470: } ! 471: KERNEL_DEBUG(DBG_SPLT_BFCHK | DBG_FUNC_END, 11, s[6], 0, 0, 0 ); ! 472: return(-1); ! 473: } ! 474: ! 475: int ! 476: splitter_ctl(register struct socket *so, register int cmd, ! 477: register caddr_t data, register struct ifnet *ifp) ! 478: { register struct ndrv_cb *np = sotondrvcb(so); ! 479: register struct ifnet_blue *ifb; ! 480: register struct BlueFilter *bf = (struct BlueFilter *)data, *bf1; ! 481: u_long at_dl_tag; ! 482: int error=0; ! 483: ! 484: if ((ifb = np->nd_if->if_Y) == NULL) ! 485: return(ENXIO); ! 486: ! 487: if (cmd == SIOCSSPLTFILT) ! 488: { ! 489: #if BLUE_DEBUG ! 490: kprintf("Filter: %s, %x, %x, %x\n", bf->ifr_name, bf->BF_flags, bf->BF_address, ! 491: bf->BF_node); ! 492: #endif ! 493: if (bf->BF_flags & BF_ATALK) ! 494: bf1 = &ifb->filter[BFS_ATALK]; ! 495: else if (bf->BF_flags & BF_IP) ! 496: bf1 = &ifb->filter[BFS_IP]; ! 497: else ! 498: return(EINVAL); ! 499: if (bf->BF_flags&BF_ALLOC) ! 500: { if ((bf1->BF_flags&(BF_ALLOC|BF_VALID)) == ! 501: (BF_ALLOC|BF_VALID)) ! 502: return(EBUSY); ! 503: *bf1 = *bf; ! 504: bf1->BF_flags |= BF_VALID; ! 505: } else if (bf->BF_flags&BF_DEALLOC) ! 506: { if (bf1->BF_flags&BF_ALLOC) ! 507: bf1->BF_flags = 0; ! 508: else ! 509: return(EINVAL); ! 510: } ! 511: /* Register AppleTalk Tags if not registered */ ! 512: ! 513: /* Check if a tag was already registered for AppleTalk */ ! 514: error = dlil_find_dltag(ifp->if_family, ifp->if_unit, ! 515: PF_APPLETALK, &at_dl_tag); ! 516: ! 517: #if BLUE_DEBUG ! 518: kprintf("splitter_ctl: ifp=%s%u find_dltag returns=%d dl_tag=%d\n", ! 519: ifp->if_name, ifp->if_unit, error, at_dl_tag); ! 520: #endif ! 521: ! 522: if (error == EPROTONOSUPPORT) { ! 523: ether_attach_at(ifp, &at_dl_tag, ! 524: &at_dl_tag); ! 525: error = 0; ! 526: } ! 527: ! 528: } else if (cmd == SIOCZSPLTSTAT) ! 529: { ifb->pkts_up = 0; ! 530: ifb->pkts_out = 0; ! 531: ifb->pkts_looped_r2b = 0; ! 532: ifb->pkts_looped_b2r = 0; ! 533: ifb->no_bufs1 = 0; ! 534: ifb->no_bufs2 = 0; ! 535: ifb->full_sockbuf = 0; ! 536: } else if (cmd == SIOCGSPLTSTAT) ! 537: { register struct Ystats *ys = (struct Ystats *)data; ! 538: ys->YS_blue_pid = ifb->blue_pid; ! 539: ys->YS_filter[BFS_ATALK] = ifb->filter[BFS_ATALK]; ! 540: ys->YS_filter[BFS_IP] = ifb->filter[BFS_IP]; ! 541: ys->YS_pkts_up = ifb->pkts_up; ! 542: ys->YS_pkts_out = ifb->pkts_out; ! 543: ys->YS_pkts_looped_b2r = ifb->pkts_looped_b2r; ! 544: ys->YS_pkts_looped_r2b = ifb->pkts_looped_r2b; ! 545: ys->YS_no_bufs1 = ifb->no_bufs1; ! 546: ys->YS_no_bufs2 = ifb->no_bufs2; ! 547: ys->YS_full_sockbuf = ifb->full_sockbuf; ! 548: } else ! 549: return(EINVAL); ! 550: return(0); ! 551: } ! 552: ! 553: void ! 554: splitter_close(register struct ndrv_cb *np) ! 555: { extern struct ifnet_blue *blue_if; ! 556: extern void ndrv_flushq(struct ifqueue *); ! 557: ! 558: if (blue_if) ! 559: { /* If we're the guy holding the Y-adapter, clean it up */ ! 560: if (blue_if->blue_pid == ! 561: ((struct proc *)current_proc())->p_pid) ! 562: { if (np->nd_if) ! 563: { np->nd_if->if_flags &= ~IFF_SPLITTER; ! 564: np->nd_if->if_Y = 0; ! 565: } ! 566: ! 567: BFIx = 0; ! 568: /* Clean out the filter supply */ ! 569: bzero(RhapFilter, ! 570: sizeof(struct BlueFilter) * BFCount); ! 571: blue_if->ifb_so = 0; ! 572: blue_if->filter[0].BF_flags = 0; ! 573: blue_if->filter[1].BF_flags = 0; ! 574: ndrv_flushq(&blueq); ! 575: if (np->nd_laddr) ! 576: { FREE((caddr_t) np->nd_laddr, M_IFADDR); ! 577: np->nd_laddr = 0; ! 578: } ! 579: } ! 580: } ! 581: remque((queue_t)np); ! 582: FREE((caddr_t)np, M_PCB); ! 583: } ! 584: ! 585: /* ! 586: * Dup the mbuf chain passed in. The whole thing. No cute additional cruft. ! 587: * And really copy the thing. That way, we don't "precompute" checksums ! 588: * for unsuspecting consumers. ! 589: * Assumption: m->m_nextpkt == 0. ! 590: * Trick: for small packets, don't dup into a cluster. That way received ! 591: * packets don't take up too much room in the sockbuf (cf. sbspace()). ! 592: */ ! 593: int MDFail; ! 594: ! 595: struct mbuf * ! 596: m_dup(register struct mbuf *m, int how) ! 597: { register struct mbuf *n, **np; ! 598: struct mbuf *top; ! 599: int copyhdr = 0; ! 600: ! 601: KERNEL_DEBUG(DBG_SPLT_DUP | DBG_FUNC_START, m->m_flags, m->m_len, ! 602: m->m_pkthdr.len, 0, 0 ); ! 603: np = ⊤ ! 604: top = 0; ! 605: if (m->m_flags & M_PKTHDR) ! 606: copyhdr = 1; ! 607: ! 608: /* ! 609: * Quick check: if we have one mbuf and its data fits in an ! 610: * mbuf with packet header, just copy and go. ! 611: */ ! 612: if (m->m_next == NULL) ! 613: { /* Then just move the data into an mbuf and be done... */ ! 614: if (copyhdr) ! 615: { if (m->m_pkthdr.len <= MHLEN) ! 616: { if ((n = m_gethdr(how, m->m_type)) == NULL) ! 617: return(NULL); ! 618: bcopy(m->m_data, n->m_data, m->m_pkthdr.len); ! 619: n->m_pkthdr.len = m->m_pkthdr.len; ! 620: n->m_len = m->m_len; ! 621: KERNEL_DEBUG(DBG_SPLT_DUP | DBG_FUNC_END, 2, ! 622: m->m_pkthdr.len, m->m_flags, ! 623: n->m_flags, 0 ); ! 624: return(n); ! 625: } ! 626: } else if (m->m_len <= MLEN) ! 627: { if ((n = m_get(how, m->m_type)) == NULL) ! 628: return(NULL); ! 629: bcopy(m->m_data, n->m_data, m->m_len); ! 630: n->m_len = m->m_len; ! 631: KERNEL_DEBUG(DBG_SPLT_DUP | DBG_FUNC_END, 3, m->m_len, ! 632: m->m_flags, n->m_flags, 0 ); ! 633: return(n); ! 634: } ! 635: } ! 636: while (m) ! 637: { ! 638: #if BLUE_DEBUG ! 639: kprintf("<%x: %x, %x, %x\n", m, m->m_flags, m->m_len, ! 640: m->m_data); ! 641: #endif ! 642: if (copyhdr) ! 643: n = m_gethdr(how, m->m_type); ! 644: else ! 645: n = m_get(how, m->m_type); ! 646: if (n == 0) ! 647: goto nospace; ! 648: if (m->m_flags & M_EXT) ! 649: { MCLGET(n, how); ! 650: if ((n->m_flags & M_EXT) == 0) ! 651: goto nospace; ! 652: } ! 653: *np = n; ! 654: if (copyhdr) ! 655: { /* Don't use M_COPY_PKTHDR: preserve m_data */ ! 656: n->m_pkthdr = m->m_pkthdr; ! 657: n->m_flags |= (m->m_flags & M_COPYFLAGS); ! 658: copyhdr = 0; ! 659: if ((n->m_flags & M_EXT) == 0) ! 660: n->m_data = n->m_pktdat; ! 661: } ! 662: n->m_len = m->m_len; ! 663: /* ! 664: * Get the dup on the same bdry as the original ! 665: * Assume that the two mbufs have the same offset to data area ! 666: * (up to word bdries) ! 667: */ ! 668: bcopy(mtod(m, caddr_t), mtod(n, caddr_t), (unsigned)n->m_len); ! 669: m = m->m_next; ! 670: np = &n->m_next; ! 671: #if BLUE_DEBUG ! 672: kprintf(">%x: %x, %x, %x\n", n, n->m_flags, n->m_len, ! 673: n->m_data); ! 674: #endif ! 675: } ! 676: ! 677: if (top == 0) ! 678: MDFail++; ! 679: KERNEL_DEBUG(DBG_SPLT_DUP | DBG_FUNC_END, 0, (int)top, 0, 0, 0 ); ! 680: return (top); ! 681: nospace: ! 682: m_freem(top); ! 683: MDFail++; ! 684: KERNEL_DEBUG(DBG_SPLT_DUP | DBG_FUNC_END, 1, 0, 0, 0, 0 ); ! 685: return (0); ! 686: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.