![[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 Darwin 0.x] / kernel / bsd / net|
Return to if_blue.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / net |
1.1 ! root 1: /* ! 2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved. ! 3: * ! 4: * @APPLE_LICENSE_HEADER_START@ ! 5: * ! 6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights ! 7: * Reserved. This file contains Original Code and/or Modifications of ! 8: * Original Code as defined in and that are subject to the Apple Public ! 9: * Source License Version 1.1 (the "License"). You may not use this file ! 10: * except in compliance with the License. Please obtain a copy of the ! 11: * License at http://www.apple.com/publicsource and read it before using ! 12: * this file. ! 13: * ! 14: * The Original Code and all software distributed under the License are ! 15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER ! 16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, ! 17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, ! 18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the ! 19: * License for the specific language governing rights and limitations ! 20: * under the License. ! 21: * ! 22: * @APPLE_LICENSE_HEADER_END@ ! 23: */ ! 24: ! 25: /* Copyright (c) 1997, 1998 Apple Computer, Inc. All Rights Reserved */ ! 26: /* ! 27: * ! 28: * @(#)if_blue.c 1.1 (Rhapsody) 6/10/97 ! 29: * Justin Walker, 9970520 ! 30: * First wave - splitter and notification support for the Blue Box ! 31: * 980130 - Second wave - Performance improvements, reorg and cleanup ! 32: */ ! 33: ! 34: #include <kern/kdebug.h> ! 35: #if KDEBUG ! 36: ! 37: #define DBG_SPLT_BFCHK DRVDBG_CODE(DBG_DRVSPLT, 0) ! 38: #define DBG_SPLT_APPND DRVDBG_CODE(DBG_DRVSPLT, 1) ! 39: #define DBG_SPLT_MBUF DRVDBG_CODE(DBG_DRVSPLT, 2) ! 40: #define DBG_SPLT_DUP DRVDBG_CODE(DBG_DRVSPLT, 3) ! 41: #define DBG_SPLT_PAD DRVDBG_CODE(DBG_DRVSPLT, 4) ! 42: ! 43: #endif ! 44: ! 45: ! 46: #include <sys/param.h> ! 47: #include <sys/systm.h> ! 48: #include <sys/kernel.h> ! 49: #include <sys/malloc.h> ! 50: #include <sys/mbuf.h> ! 51: #include <sys/protosw.h> ! 52: #include <sys/socket.h> ! 53: #include <sys/socketvar.h> ! 54: #include <sys/ioctl.h> ! 55: #include <sys/errno.h> ! 56: #include <sys/syslog.h> ! 57: #include <sys/proc.h> ! 58: ! 59: #include <machine/cpu.h> ! 60: ! 61: #include <net/if.h> ! 62: #include <net/netisr.h> ! 63: #include <net/route.h> ! 64: #include <net/if_llc.h> ! 65: #include <net/if_dl.h> ! 66: #include <net/if_types.h> ! 67: #include "if_blue.h" ! 68: #include "ndrv.h" ! 69: ! 70: #if INET ! 71: #include <netinet/in.h> ! 72: #include <netinet/in_var.h> ! 73: #endif ! 74: #include <netinet/if_ether.h> ! 75: ! 76: #if NS ! 77: #include <netns/ns.h> ! 78: #include <netns/ns_if.h> ! 79: #endif ! 80: ! 81: #if ISO ! 82: #include <netiso/argo_debug.h> ! 83: #include <netiso/iso.h> ! 84: #include <netiso/iso_var.h> ! 85: #include <netiso/iso_snpac.h> ! 86: #endif ! 87: ! 88: #if LLC ! 89: #include <netccitt/dll.h> ! 90: #include <netccitt/llc_var.h> ! 91: #endif ! 92: ! 93: #include <sys/systm.h> ! 94: #include <machine/spl.h> ! 95: ! 96: /* Dummy IFs to differentiate source of looped packets */ ! 97: struct ifnet rhap_if_s; ! 98: struct ifnet *rhap_if = &rhap_if_s; ! 99: struct ifnet_blue *blue_if; ! 100: struct sockaddr_dl ndrvsrc = {sizeof (struct sockaddr_dl), AF_NDRV}; ! 101: ! 102: struct ifqueue blueq; ! 103: ! 104: extern int if_register(register struct BlueFilter *f ! 105: #ifdef BF_if ! 106: , ! 107: register struct ifnet *ifp ! 108: #endif ! 109: ); ! 110: ! 111: /* ! 112: * Blue Box support: ! 113: * 1st cut: the Y splitter ! 114: * A process turns on the splitter by opening the "raw" device ! 115: * (socket() for AF_NDRV) and issuing an SIOCSSPLITTER ioctl. ! 116: * Incoming packets are routed into Rhapsody as well as to the requesting ! 117: * interface. ! 118: * Outbound packets are sent, and are examined to see if they should go ! 119: * back up (loopback, sort of). Packets that are looped back include: ! 120: * broadcast ! 121: * multicast ! 122: */ ! 123: int ! 124: new_splitter(register struct socket *so) ! 125: { register struct ifnet_blue *ifb; ! 126: register struct ndrv_cb *np; ! 127: register struct ifnet *ifp; ! 128: struct BlueFilter filter; ! 129: int retval; ! 130: ! 131: if ((ifb = _MALLOC(sizeof (struct ifnet_blue), M_PCB, M_WAITOK)) ! 132: == NULL) ! 133: { ! 134: #if 0 ! 135: kprintf("Can't create new splitter\n"); ! 136: #endif ! 137: return(ENOBUFS); ! 138: } ! 139: bzero(ifb, sizeof(struct ifnet_blue)); ! 140: np = (struct ndrv_cb *)so->so_pcb; ! 141: #if 0 ! 142: printf("NEW SPLT: %x, %x\n", so, np); ! 143: if (np) ! 144: printf("SIG: %x, ifp: %x\n", np->nd_signature, np->nd_if); ! 145: #endif ! 146: if (np == NULL) ! 147: return(EINVAL); /* XXX */ ! 148: if (np->nd_signature != NDRV_SIGNATURE) ! 149: return(EINVAL); /* XXX */ ! 150: if ((ifp = np->nd_if) == NULL) ! 151: return(EINVAL); /* XXX */ ! 152: if (ifp->if_flags & IFF_SPLITTER) ! 153: return(EBUSY); ! 154: if ((ifp->if_flags&IFF_UP) == 0) ! 155: return(ENXIO); ! 156: /* ! 157: * Bump the receive sockbuf size - need a big buffer ! 158: * to offset the scheduling latencies of the system ! 159: * Try to get something if our grandiose design fails. ! 160: */ ! 161: if (sbreserve(&so->so_rcv, 131072) == 0) ! 162: { if (sbreserve(&so->so_rcv, 65536) == 0 && ! 163: sbreserve(&so->so_rcv, 32768) == 0 && ! 164: sbreserve(&so->so_rcv, 16384) == 0) ! 165: return(ENOBUFS); ! 166: } ! 167: ifp->if_flags |= IFF_SPLITTER; ! 168: /* ! 169: * Register each IP address associated with this ifnet ! 170: * This takes care of addresses registered prior to startup ! 171: * of the BlueBox. ! 172: * TODO: Appletalk sockaddrs ! 173: */ ! 174: #define IFA2IN(ifa) \ ! 175: ((struct in_addr) \ ! 176: ((struct sockaddr_in *)(ifa->ifa_addr))->sin_addr).s_addr ! 177: { struct ifaddr *ifa; ! 178: for (ifa = ifp->if_addrlist; (ifa = ifa->ifa_next);) ! 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 0 ! 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 0 ! 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 = current_thread()->task->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, Rhapsody 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 Rhapsody */ ! 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 0 ! 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 0 ! 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 0 ! 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: ! 482: if ((ifb = np->nd_if->if_Y) == NULL) ! 483: return(ENXIO); ! 484: ! 485: if (cmd == SIOCSSPLTFILT) ! 486: { ! 487: #if 0 ! 488: kprintf("Filter: %s, %x, %x, %x\n", bf->ifr_name, bf->BF_flags, bf->BF_address, ! 489: bf->BF_node); ! 490: #endif ! 491: if (bf->BF_flags & BF_ATALK) ! 492: bf1 = &ifb->filter[BFS_ATALK]; ! 493: else if (bf->BF_flags & BF_IP) ! 494: bf1 = &ifb->filter[BFS_IP]; ! 495: else ! 496: return(EINVAL); ! 497: if (bf->BF_flags&BF_ALLOC) ! 498: { if ((bf1->BF_flags&(BF_ALLOC|BF_VALID)) == ! 499: (BF_ALLOC|BF_VALID)) ! 500: return(EBUSY); ! 501: *bf1 = *bf; ! 502: bf1->BF_flags |= BF_VALID; ! 503: } else if (bf->BF_flags&BF_DEALLOC) ! 504: { if (bf1->BF_flags&BF_ALLOC) ! 505: bf1->BF_flags = 0; ! 506: else ! 507: return(EINVAL); ! 508: } ! 509: } else if (cmd == SIOCZSPLTSTAT) ! 510: { ifb->pkts_up = 0; ! 511: ifb->pkts_out = 0; ! 512: ifb->pkts_looped_r2b = 0; ! 513: ifb->pkts_looped_b2r = 0; ! 514: ifb->no_bufs1 = 0; ! 515: ifb->no_bufs2 = 0; ! 516: ifb->full_sockbuf = 0; ! 517: } else if (cmd == SIOCGSPLTSTAT) ! 518: { register struct Ystats *ys = (struct Ystats *)data; ! 519: ys->YS_blue_pid = ifb->blue_pid; ! 520: ys->YS_filter[BFS_ATALK] = ifb->filter[BFS_ATALK]; ! 521: ys->YS_filter[BFS_IP] = ifb->filter[BFS_IP]; ! 522: ys->YS_pkts_up = ifb->pkts_up; ! 523: ys->YS_pkts_out = ifb->pkts_out; ! 524: ys->YS_pkts_looped_b2r = ifb->pkts_looped_b2r; ! 525: ys->YS_pkts_looped_r2b = ifb->pkts_looped_r2b; ! 526: ys->YS_no_bufs1 = ifb->no_bufs1; ! 527: ys->YS_no_bufs2 = ifb->no_bufs2; ! 528: ys->YS_full_sockbuf = ifb->full_sockbuf; ! 529: } else ! 530: return(EINVAL); ! 531: return(0); ! 532: } ! 533: ! 534: void ! 535: splitter_close(register struct ndrv_cb *np) ! 536: { extern struct ifnet_blue *blue_if; ! 537: extern void ndrv_flushq(struct ifqueue *); ! 538: ! 539: if (blue_if) ! 540: { /* If we're the guy holding the Y-adapter, clean it up */ ! 541: if (blue_if->blue_pid == current_thread()->task->proc->p_pid) ! 542: { if (np->nd_if) ! 543: { np->nd_if->if_flags &= ~IFF_SPLITTER; ! 544: np->nd_if->if_Y = 0; ! 545: } ! 546: ! 547: BFIx = 0; ! 548: /* Clean out the filter supply */ ! 549: bzero(RhapFilter, ! 550: sizeof(struct BlueFilter) * BFCount); ! 551: blue_if->ifb_so = 0; ! 552: blue_if->filter[0].BF_flags = 0; ! 553: blue_if->filter[1].BF_flags = 0; ! 554: ndrv_flushq(&blueq); ! 555: if (np->nd_laddr) ! 556: { m_freem(dtom(np->nd_laddr)); ! 557: np->nd_laddr = 0; ! 558: } ! 559: } ! 560: } ! 561: remque((queue_t)np); ! 562: _FREE((caddr_t)np, M_PCB); ! 563: } ! 564: ! 565: /* ! 566: * Dup the mbuf chain passed in. The whole thing. No cute additional cruft. ! 567: * And really copy the thing. That way, we don't "precompute" checksums ! 568: * for unsuspecting consumers. ! 569: * Assumption: m->m_nextpkt == 0. ! 570: * Trick: for small packets, don't dup into a cluster. That way received ! 571: * packets don't take up too much room in the sockbuf (cf. sbspace()). ! 572: */ ! 573: int MDFail; ! 574: ! 575: struct mbuf * ! 576: m_dup(register struct mbuf *m, int how) ! 577: { register struct mbuf *n, **np; ! 578: struct mbuf *top; ! 579: int copyhdr = 0; ! 580: ! 581: KERNEL_DEBUG(DBG_SPLT_DUP | DBG_FUNC_START, m->m_flags, m->m_len, ! 582: m->m_pkthdr.len, 0, 0 ); ! 583: np = ⊤ ! 584: top = 0; ! 585: if (m->m_flags & M_PKTHDR) ! 586: copyhdr = 1; ! 587: ! 588: /* ! 589: * Quick check: if we have one mbuf and its data fits in an ! 590: * mbuf with packet header, just copy and go. ! 591: */ ! 592: if (m->m_next == NULL) ! 593: { /* Then just move the data into an mbuf and be done... */ ! 594: if (copyhdr) ! 595: { if (m->m_pkthdr.len <= MHLEN) ! 596: { n = m_gethdr(how, m->m_type); ! 597: bcopy(m->m_data, n->m_data, m->m_pkthdr.len); ! 598: n->m_pkthdr.len = m->m_pkthdr.len; ! 599: n->m_len = m->m_len; ! 600: KERNEL_DEBUG(DBG_SPLT_DUP | DBG_FUNC_END, 2, ! 601: m->m_pkthdr.len, m->m_flags, ! 602: n->m_flags, 0 ); ! 603: return(n); ! 604: } ! 605: } else if (m->m_len <= MLEN) ! 606: { n = m_get(how, m->m_type); ! 607: bcopy(m->m_data, n->m_data, m->m_len); ! 608: n->m_len = m->m_len; ! 609: KERNEL_DEBUG(DBG_SPLT_DUP | DBG_FUNC_END, 3, m->m_len, ! 610: m->m_flags, n->m_flags, 0 ); ! 611: return(n); ! 612: } ! 613: } ! 614: while (m) ! 615: { ! 616: #if 0 ! 617: kprintf("<%x: %x, %x, %x\n", m, m->m_flags, m->m_len, ! 618: m->m_data); ! 619: #endif ! 620: if (copyhdr) ! 621: n = m_gethdr(how, m->m_type); ! 622: else ! 623: n = m_get(how, m->m_type); ! 624: if (n == 0) ! 625: goto nospace; ! 626: if (m->m_flags & M_EXT) ! 627: { MCLGET(n, how); ! 628: if ((n->m_flags & M_EXT) == 0) ! 629: goto nospace; ! 630: } ! 631: *np = n; ! 632: if (copyhdr) ! 633: { /* Don't use M_COPY_PKTHDR: preserve m_data */ ! 634: n->m_pkthdr = m->m_pkthdr; ! 635: n->m_flags |= (m->m_flags & M_COPYFLAGS); ! 636: copyhdr = 0; ! 637: if ((n->m_flags & M_EXT) == 0) ! 638: n->m_data = n->m_pktdat; ! 639: } ! 640: n->m_len = m->m_len; ! 641: /* ! 642: * Get the dup on the same bdry as the original ! 643: * Assume that the two mbufs have the same offset to data area ! 644: * (up to word bdries) ! 645: */ ! 646: bcopy(mtod(m, caddr_t), mtod(n, caddr_t), (unsigned)n->m_len); ! 647: m = m->m_next; ! 648: np = &n->m_next; ! 649: #if 0 ! 650: kprintf(">%x: %x, %x, %x\n", n, n->m_flags, n->m_len, ! 651: n->m_data); ! 652: #endif ! 653: } ! 654: ! 655: if (top == 0) ! 656: MDFail++; ! 657: KERNEL_DEBUG(DBG_SPLT_DUP | DBG_FUNC_END, 0, (int)top, 0, 0, 0 ); ! 658: return (top); ! 659: nospace: ! 660: m_freem(top); ! 661: MDFail++; ! 662: KERNEL_DEBUG(DBG_SPLT_DUP | DBG_FUNC_END, 1, 0, 0, 0, 0 ); ! 663: return (0); ! 664: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.