![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uipc_socket2.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 / kern|
Return to uipc_socket2.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / kern |
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) 1995 NeXT Computer, Inc. All Rights Reserved */ ! 26: /* ! 27: * Copyright (c) 1982, 1986, 1988, 1990, 1993 ! 28: * The Regents of the University of California. All rights reserved. ! 29: * ! 30: * Redistribution and use in source and binary forms, with or without ! 31: * modification, are permitted provided that the following conditions ! 32: * are met: ! 33: * 1. Redistributions of source code must retain the above copyright ! 34: * notice, this list of conditions and the following disclaimer. ! 35: * 2. Redistributions in binary form must reproduce the above copyright ! 36: * notice, this list of conditions and the following disclaimer in the ! 37: * documentation and/or other materials provided with the distribution. ! 38: * 3. All advertising materials mentioning features or use of this software ! 39: * must display the following acknowledgement: ! 40: * This product includes software developed by the University of ! 41: * California, Berkeley and its contributors. ! 42: * 4. Neither the name of the University nor the names of its contributors ! 43: * may be used to endorse or promote products derived from this software ! 44: * without specific prior written permission. ! 45: * ! 46: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 47: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 48: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 49: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 50: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 51: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 52: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 53: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 54: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 55: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 56: * SUCH DAMAGE. ! 57: * ! 58: * @(#)uipc_socket2.c 8.2 (Berkeley) 2/14/95 ! 59: */ ! 60: ! 61: #include <sys/param.h> ! 62: #include <sys/systm.h> ! 63: #include <sys/proc.h> ! 64: #include <sys/file.h> ! 65: #include <sys/buf.h> ! 66: #include <sys/malloc.h> ! 67: #include <sys/mbuf.h> ! 68: #include <sys/protosw.h> ! 69: #include <sys/socket.h> ! 70: #include <sys/socketvar.h> ! 71: #include <sys/ev.h> ! 72: ! 73: /* ! 74: * Primitive routines for operating on sockets and socket buffers ! 75: */ ! 76: ! 77: /* strings for sleep message: */ ! 78: char netio[] = "netio"; ! 79: char netcon[] = "netcon"; ! 80: char netcls[] = "netcls"; ! 81: ! 82: u_long sb_max = SB_MAX; /* patchable */ ! 83: ! 84: /* ! 85: * Procedures to manipulate state flags of socket ! 86: * and do appropriate wakeups. Normal sequence from the ! 87: * active (originating) side is that soisconnecting() is ! 88: * called during processing of connect() call, ! 89: * resulting in an eventual call to soisconnected() if/when the ! 90: * connection is established. When the connection is torn down ! 91: * soisdisconnecting() is called during processing of disconnect() call, ! 92: * and soisdisconnected() is called when the connection to the peer ! 93: * is totally severed. The semantics of these routines are such that ! 94: * connectionless protocols can call soisconnected() and soisdisconnected() ! 95: * only, bypassing the in-progress calls when setting up a ``connection'' ! 96: * takes no time. ! 97: * ! 98: * From the passive side, a socket is created with ! 99: * two queues of sockets: so_q0 for connections in progress ! 100: * and so_q for connections already made and awaiting user acceptance. ! 101: * As a protocol is preparing incoming connections, it creates a socket ! 102: * structure queued on so_q0 by calling sonewconn(). When the connection ! 103: * is established, soisconnected() is called, and transfers the ! 104: * socket structure to so_q, making it available to accept(). ! 105: * ! 106: * If a socket is closed with sockets on either ! 107: * so_q0 or so_q, these sockets are dropped. ! 108: * ! 109: * If higher level protocols are implemented in ! 110: * the kernel, the wakeups done here will sometimes ! 111: * cause software-interrupt process scheduling. ! 112: */ ! 113: ! 114: void ! 115: soisconnecting(so) ! 116: register struct socket *so; ! 117: { ! 118: ! 119: so->so_state &= ~(SS_ISCONNECTED|SS_ISDISCONNECTING); ! 120: so->so_state |= SS_ISCONNECTING; ! 121: } ! 122: ! 123: void ! 124: soisconnected(so) ! 125: register struct socket *so; ! 126: { ! 127: register struct socket *head = so->so_head; ! 128: ! 129: so->so_state &= ~(SS_ISCONNECTING|SS_ISDISCONNECTING|SS_ISCONFIRMING); ! 130: so->so_state |= SS_ISCONNECTED; ! 131: if (head && soqremque(so, 0)) { ! 132: postevent(head,0,EV_RCONN); ! 133: soqinsque(head, so, 1); ! 134: sorwakeup(head); ! 135: wakeup((caddr_t)&head->so_timeo); ! 136: } else { ! 137: postevent(so,0,EV_WCONN); ! 138: wakeup((caddr_t)&so->so_timeo); ! 139: sorwakeup(so); ! 140: sowwakeup(so); ! 141: } ! 142: } ! 143: ! 144: void ! 145: soisdisconnecting(so) ! 146: register struct socket *so; ! 147: { ! 148: ! 149: so->so_state &= ~SS_ISCONNECTING; ! 150: so->so_state |= (SS_ISDISCONNECTING|SS_CANTRCVMORE|SS_CANTSENDMORE); ! 151: wakeup((caddr_t)&so->so_timeo); ! 152: sowwakeup(so); ! 153: sorwakeup(so); ! 154: } ! 155: ! 156: void ! 157: soisdisconnected(so) ! 158: register struct socket *so; ! 159: { ! 160: ! 161: so->so_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING); ! 162: so->so_state |= (SS_CANTRCVMORE|SS_CANTSENDMORE); ! 163: wakeup((caddr_t)&so->so_timeo); ! 164: sowwakeup(so); ! 165: sorwakeup(so); ! 166: } ! 167: ! 168: /* ! 169: * When an attempt at a new connection is noted on a socket ! 170: * which accepts connections, sonewconn is called. If the ! 171: * connection is possible (subject to space constraints, etc.) ! 172: * then we allocate a new structure, propoerly linked into the ! 173: * data structure of the original socket, and return this. ! 174: * Connstatus may be 0, or SO_ISCONFIRMING, or SO_ISCONNECTED. ! 175: * ! 176: * Currently, sonewconn() is defined as sonewconn1() in socketvar.h ! 177: * to catch calls that are missing the (new) second parameter. ! 178: */ ! 179: struct socket * ! 180: sonewconn1(head, connstatus) ! 181: register struct socket *head; ! 182: int connstatus; ! 183: { ! 184: register struct socket *so; ! 185: int soqueue = connstatus ? 1 : 0; ! 186: ! 187: if (head->so_qlen + head->so_q0len > 3 * head->so_qlimit / 2) ! 188: return ((struct socket *)0); ! 189: ! 190: #ifdef SOCKET_CACHE_ON ! 191: cached_sock_alloc(&so); ! 192: #else ! 193: MALLOC_ZONE(so, struct socket *, sizeof(*so), M_SOCKET, M_WAITOK); ! 194: bzero((caddr_t)so, sizeof(*so)); ! 195: #endif ! 196: ! 197: if (so == NULL) ! 198: return ((struct socket *)0); ! 199: so->so_type = head->so_type; ! 200: so->so_options = head->so_options &~ SO_ACCEPTCONN; ! 201: so->so_linger = head->so_linger; ! 202: so->so_state = head->so_state | SS_NOFDREF; ! 203: so->so_proto = head->so_proto; ! 204: so->so_timeo = head->so_timeo; ! 205: so->so_pgid = head->so_pgid; ! 206: (void) soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat); ! 207: soqinsque(head, so, soqueue); ! 208: if ((*so->so_proto->pr_usrreq)(so, PRU_ATTACH, ! 209: (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0)) { ! 210: (void) soqremque(so, soqueue); ! 211: ! 212: #ifdef SOCKET_CACHE_ON ! 213: cached_sock_free(so); ! 214: #else ! 215: (void) _FREE_ZONE((caddr_t)so, sizeof *so, M_SOCKET); ! 216: #endif ! 217: return ((struct socket *)0); ! 218: } ! 219: if (connstatus) { ! 220: sorwakeup(head); ! 221: wakeup((caddr_t)&head->so_timeo); ! 222: so->so_state |= connstatus; ! 223: } ! 224: so->so_rcv.sb_flags |= SB_RECV; ! 225: so->so_rcv.sb_so = so->so_snd.sb_so = so; ! 226: TAILQ_INIT(&so->so_evlist); ! 227: return (so); ! 228: } ! 229: ! 230: void ! 231: soqinsque(head, so, q) ! 232: register struct socket *head, *so; ! 233: int q; ! 234: { ! 235: ! 236: register struct socket **prev; ! 237: so->so_head = head; ! 238: if (q == 0) { ! 239: head->so_q0len++; ! 240: so->so_q0 = 0; ! 241: for (prev = &(head->so_q0); *prev; ) ! 242: prev = &((*prev)->so_q0); ! 243: } else { ! 244: head->so_qlen++; ! 245: so->so_q = 0; ! 246: for (prev = &(head->so_q); *prev; ) ! 247: prev = &((*prev)->so_q); ! 248: } ! 249: *prev = so; ! 250: } ! 251: ! 252: int ! 253: soqremque(so, q) ! 254: register struct socket *so; ! 255: int q; ! 256: { ! 257: register struct socket *head, *prev, *next; ! 258: ! 259: head = so->so_head; ! 260: prev = head; ! 261: for (;;) { ! 262: next = q ? prev->so_q : prev->so_q0; ! 263: if (next == so) ! 264: break; ! 265: if (next == 0) ! 266: return (0); ! 267: prev = next; ! 268: } ! 269: if (q == 0) { ! 270: prev->so_q0 = next->so_q0; ! 271: head->so_q0len--; ! 272: } else { ! 273: prev->so_q = next->so_q; ! 274: head->so_qlen--; ! 275: } ! 276: next->so_q0 = next->so_q = 0; ! 277: next->so_head = 0; ! 278: return (1); ! 279: } ! 280: ! 281: /* ! 282: * Socantsendmore indicates that no more data will be sent on the ! 283: * socket; it would normally be applied to a socket when the user ! 284: * informs the system that no more data is to be sent, by the protocol ! 285: * code (in case PRU_SHUTDOWN). Socantrcvmore indicates that no more data ! 286: * will be received, and will normally be applied to the socket by a ! 287: * protocol when it detects that the peer will send no more data. ! 288: * Data queued for reading in the socket may yet be read. ! 289: */ ! 290: ! 291: void ! 292: socantsendmore(so) ! 293: struct socket *so; ! 294: { ! 295: ! 296: so->so_state |= SS_CANTSENDMORE; ! 297: sowwakeup(so); ! 298: } ! 299: ! 300: void ! 301: socantrcvmore(so) ! 302: struct socket *so; ! 303: { ! 304: ! 305: so->so_state |= SS_CANTRCVMORE; ! 306: sorwakeup(so); ! 307: } ! 308: ! 309: /* ! 310: * Wait for data to arrive at/drain from a socket buffer. ! 311: */ ! 312: int ! 313: sbwait(sb) ! 314: struct sockbuf *sb; ! 315: { ! 316: ! 317: sb->sb_flags |= SB_WAIT; ! 318: return (tsleep((caddr_t)&sb->sb_cc, ! 319: (sb->sb_flags & SB_NOINTR) ? PSOCK : PSOCK | PCATCH, netio, ! 320: sb->sb_timeo)); ! 321: } ! 322: ! 323: /* ! 324: * Lock a sockbuf already known to be locked; ! 325: * return any error returned from sleep (EINTR). ! 326: */ ! 327: int ! 328: sb_lock(sb) ! 329: register struct sockbuf *sb; ! 330: { ! 331: int error; ! 332: ! 333: while (sb->sb_flags & SB_LOCK) { ! 334: sb->sb_flags |= SB_WANT; ! 335: if (error = tsleep((caddr_t)&sb->sb_flags, ! 336: (sb->sb_flags & SB_NOINTR) ? PSOCK : PSOCK|PCATCH, ! 337: netio, 0)) ! 338: return (error); ! 339: } ! 340: sb->sb_flags |= SB_LOCK; ! 341: return (0); ! 342: } ! 343: ! 344: /* ! 345: * Wakeup processes waiting on a socket buffer. ! 346: * Do asynchronous notification via SIGIO ! 347: * if the socket has the SS_ASYNC flag set. ! 348: */ ! 349: void ! 350: sowakeup(so, sb) ! 351: register struct socket *so; ! 352: register struct sockbuf *sb; ! 353: { ! 354: struct proc *p; ! 355: ! 356: selwakeup(&sb->sb_sel); ! 357: sb->sb_flags &= ~SB_SEL; ! 358: if (sb->sb_flags & SB_WAIT) { ! 359: sb->sb_flags &= ~SB_WAIT; ! 360: wakeup((caddr_t)&sb->sb_cc); ! 361: } ! 362: if (so->so_state & SS_ASYNC) { ! 363: if (so->so_pgid < 0) ! 364: gsignal(-so->so_pgid, SIGIO); ! 365: else if (so->so_pgid > 0 && (p = pfind(so->so_pgid)) != 0) ! 366: psignal(p, SIGIO); ! 367: } ! 368: } ! 369: ! 370: /* ! 371: * Socket buffer (struct sockbuf) utility routines. ! 372: * ! 373: * Each socket contains two socket buffers: one for sending data and ! 374: * one for receiving data. Each buffer contains a queue of mbufs, ! 375: * information about the number of mbufs and amount of data in the ! 376: * queue, and other fields allowing select() statements and notification ! 377: * on data availability to be implemented. ! 378: * ! 379: * Data stored in a socket buffer is maintained as a list of records. ! 380: * Each record is a list of mbufs chained together with the m_next ! 381: * field. Records are chained together with the m_nextpkt field. The upper ! 382: * level routine soreceive() expects the following conventions to be ! 383: * observed when placing information in the receive buffer: ! 384: * ! 385: * 1. If the protocol requires each message be preceded by the sender's ! 386: * name, then a record containing that name must be present before ! 387: * any associated data (mbuf's must be of type MT_SONAME). ! 388: * 2. If the protocol supports the exchange of ``access rights'' (really ! 389: * just additional data associated with the message), and there are ! 390: * ``rights'' to be received, then a record containing this data ! 391: * should be present (mbuf's must be of type MT_RIGHTS). ! 392: * 3. If a name or rights record exists, then it must be followed by ! 393: * a data record, perhaps of zero length. ! 394: * ! 395: * Before using a new socket structure it is first necessary to reserve ! 396: * buffer space to the socket, by calling sbreserve(). This should commit ! 397: * some of the available buffer space in the system buffer pool for the ! 398: * socket (currently, it does nothing but enforce limits). The space ! 399: * should be released by calling sbrelease() when the socket is destroyed. ! 400: */ ! 401: ! 402: int ! 403: soreserve(so, sndcc, rcvcc) ! 404: register struct socket *so; ! 405: u_long sndcc, rcvcc; ! 406: { ! 407: ! 408: if (sbreserve(&so->so_snd, sndcc) == 0) ! 409: goto bad; ! 410: if (sbreserve(&so->so_rcv, rcvcc) == 0) ! 411: goto bad2; ! 412: if (so->so_rcv.sb_lowat == 0) ! 413: so->so_rcv.sb_lowat = 1; ! 414: if (so->so_snd.sb_lowat == 0) ! 415: so->so_snd.sb_lowat = MCLBYTES; ! 416: if (so->so_snd.sb_lowat > so->so_snd.sb_hiwat) ! 417: so->so_snd.sb_lowat = so->so_snd.sb_hiwat; ! 418: return (0); ! 419: bad2: ! 420: sbrelease(&so->so_snd); ! 421: bad: ! 422: return (ENOBUFS); ! 423: } ! 424: ! 425: /* ! 426: * Allot mbufs to a sockbuf. ! 427: * Attempt to scale mbmax so that mbcnt doesn't become limiting ! 428: * if buffering efficiency is near the normal case. ! 429: */ ! 430: int ! 431: sbreserve(sb, cc) ! 432: struct sockbuf *sb; ! 433: u_long cc; ! 434: { ! 435: ! 436: if (cc > sb_max * MCLBYTES / (MSIZE + MCLBYTES)) ! 437: return (0); ! 438: sb->sb_hiwat = cc; ! 439: sb->sb_mbmax = min(cc * 2, sb_max); ! 440: if (sb->sb_lowat > sb->sb_hiwat) ! 441: sb->sb_lowat = sb->sb_hiwat; ! 442: return (1); ! 443: } ! 444: ! 445: /* ! 446: * Free mbufs held by a socket, and reserved mbuf space. ! 447: */ ! 448: void ! 449: sbrelease(sb) ! 450: struct sockbuf *sb; ! 451: { ! 452: ! 453: sbflush(sb); ! 454: sb->sb_hiwat = sb->sb_mbmax = 0; ! 455: ! 456: { ! 457: int oldpri = splimp(); ! 458: selthreadclear(&sb->sb_sel); ! 459: splx(oldpri); ! 460: } ! 461: } ! 462: ! 463: /* ! 464: * Routines to add and remove ! 465: * data from an mbuf queue. ! 466: * ! 467: * The routines sbappend() or sbappendrecord() are normally called to ! 468: * append new mbufs to a socket buffer, after checking that adequate ! 469: * space is available, comparing the function sbspace() with the amount ! 470: * of data to be added. sbappendrecord() differs from sbappend() in ! 471: * that data supplied is treated as the beginning of a new record. ! 472: * To place a sender's address, optional access rights, and data in a ! 473: * socket receive buffer, sbappendaddr() should be used. To place ! 474: * access rights and data in a socket receive buffer, sbappendrights() ! 475: * should be used. In either case, the new data begins a new record. ! 476: * Note that unlike sbappend() and sbappendrecord(), these routines check ! 477: * for the caller that there will be enough space to store the data. ! 478: * Each fails if there is not enough space, or if it cannot find mbufs ! 479: * to store additional information in. ! 480: * ! 481: * Reliable protocols may use the socket send buffer to hold data ! 482: * awaiting acknowledgement. Data is normally copied from a socket ! 483: * send buffer in a protocol with m_copy for output to a peer, ! 484: * and then removing the data from the socket buffer with sbdrop() ! 485: * or sbdroprecord() when the data is acknowledged by the peer. ! 486: */ ! 487: ! 488: /* ! 489: * Append mbuf chain m to the last record in the ! 490: * socket buffer sb. The additional space associated ! 491: * the mbuf chain is recorded in sb. Empty mbufs are ! 492: * discarded and mbufs are compacted where possible. ! 493: */ ! 494: void ! 495: sbappend(sb, m) ! 496: struct sockbuf *sb; ! 497: struct mbuf *m; ! 498: { ! 499: register struct mbuf *n; ! 500: ! 501: if (m == 0) ! 502: return; ! 503: if (n = sb->sb_mb) { ! 504: while (n->m_nextpkt) ! 505: n = n->m_nextpkt; ! 506: do { ! 507: if (n->m_flags & M_EOR) { ! 508: sbappendrecord(sb, m); /* XXXXXX!!!! */ ! 509: return; ! 510: } ! 511: } while (n->m_next && (n = n->m_next)); ! 512: } ! 513: sbcompress(sb, m, n); ! 514: } ! 515: ! 516: #ifdef SOCKBUF_DEBUG ! 517: void ! 518: sbcheck(sb) ! 519: register struct sockbuf *sb; ! 520: { ! 521: register struct mbuf *m; ! 522: register int len = 0, mbcnt = 0; ! 523: ! 524: for (m = sb->sb_mb; m; m = m->m_next) { ! 525: len += m->m_len; ! 526: mbcnt += MSIZE; ! 527: if (m->m_flags & M_EXT) ! 528: mbcnt += m->m_ext.ext_size; ! 529: if (m->m_nextpkt) ! 530: panic("sbcheck nextpkt"); ! 531: } ! 532: if (len != sb->sb_cc || mbcnt != sb->sb_mbcnt) { ! 533: printf("cc %d != %d || mbcnt %d != %d\n", len, sb->sb_cc, ! 534: mbcnt, sb->sb_mbcnt); ! 535: panic("sbcheck"); ! 536: } ! 537: } ! 538: #endif ! 539: ! 540: /* ! 541: * As above, except the mbuf chain ! 542: * begins a new record. ! 543: */ ! 544: void ! 545: sbappendrecord(sb, m0) ! 546: register struct sockbuf *sb; ! 547: register struct mbuf *m0; ! 548: { ! 549: register struct mbuf *m; ! 550: ! 551: if (m0 == 0) ! 552: return; ! 553: if (m = sb->sb_mb) ! 554: while (m->m_nextpkt) ! 555: m = m->m_nextpkt; ! 556: /* ! 557: * Put the first mbuf on the queue. ! 558: * Note this permits zero length records. ! 559: */ ! 560: sballoc(sb, m0); ! 561: if (m) ! 562: m->m_nextpkt = m0; ! 563: else ! 564: sb->sb_mb = m0; ! 565: m = m0->m_next; ! 566: m0->m_next = 0; ! 567: if (m && (m0->m_flags & M_EOR)) { ! 568: m0->m_flags &= ~M_EOR; ! 569: m->m_flags |= M_EOR; ! 570: } ! 571: sbcompress(sb, m, m0); ! 572: } ! 573: ! 574: /* ! 575: * As above except that OOB data ! 576: * is inserted at the beginning of the sockbuf, ! 577: * but after any other OOB data. ! 578: */ ! 579: void ! 580: sbinsertoob(sb, m0) ! 581: register struct sockbuf *sb; ! 582: register struct mbuf *m0; ! 583: { ! 584: register struct mbuf *m; ! 585: register struct mbuf **mp; ! 586: ! 587: if (m0 == 0) ! 588: return; ! 589: for (mp = &sb->sb_mb; m = *mp; mp = &((*mp)->m_nextpkt)) { ! 590: again: ! 591: switch (m->m_type) { ! 592: ! 593: case MT_OOBDATA: ! 594: continue; /* WANT next train */ ! 595: ! 596: case MT_CONTROL: ! 597: if (m = m->m_next) ! 598: goto again; /* inspect THIS train further */ ! 599: } ! 600: break; ! 601: } ! 602: /* ! 603: * Put the first mbuf on the queue. ! 604: * Note this permits zero length records. ! 605: */ ! 606: sballoc(sb, m0); ! 607: m0->m_nextpkt = *mp; ! 608: *mp = m0; ! 609: m = m0->m_next; ! 610: m0->m_next = 0; ! 611: if (m && (m0->m_flags & M_EOR)) { ! 612: m0->m_flags &= ~M_EOR; ! 613: m->m_flags |= M_EOR; ! 614: } ! 615: sbcompress(sb, m, m0); ! 616: } ! 617: ! 618: /* ! 619: * Append address and data, and optionally, control (ancillary) data ! 620: * to the receive queue of a socket. If present, ! 621: * m0 must include a packet header with total length. ! 622: * Returns 0 if no space in sockbuf or insufficient mbufs. ! 623: */ ! 624: int ! 625: sbappendaddr(sb, asa, m0, control) ! 626: register struct sockbuf *sb; ! 627: struct sockaddr *asa; ! 628: struct mbuf *m0, *control; ! 629: { ! 630: register struct mbuf *m, *n; ! 631: int space = asa->sa_len; ! 632: ! 633: if (m0 && (m0->m_flags & M_PKTHDR) == 0) ! 634: panic("sbappendaddr"); ! 635: if (m0) ! 636: space += m0->m_pkthdr.len; ! 637: for (n = control; n; n = n->m_next) { ! 638: space += n->m_len; ! 639: if (n->m_next == 0) /* keep pointer to last control buf */ ! 640: break; ! 641: } ! 642: if (space > sbspace(sb)) ! 643: return (0); ! 644: if (asa->sa_len > MLEN) ! 645: return (0); ! 646: MGET(m, M_DONTWAIT, MT_SONAME); ! 647: if (m == 0) ! 648: return (0); ! 649: m->m_len = asa->sa_len; ! 650: bcopy((caddr_t)asa, mtod(m, caddr_t), asa->sa_len); ! 651: if (n) ! 652: n->m_next = m0; /* concatenate data to control */ ! 653: else ! 654: control = m0; ! 655: m->m_next = control; ! 656: for (n = m; n; n = n->m_next) ! 657: sballoc(sb, n); ! 658: if (n = sb->sb_mb) { ! 659: while (n->m_nextpkt) ! 660: n = n->m_nextpkt; ! 661: n->m_nextpkt = m; ! 662: } else ! 663: sb->sb_mb = m; ! 664: postevent(0,sb,EV_RWBYTES); ! 665: return (1); ! 666: } ! 667: ! 668: int ! 669: sbappendcontrol(sb, m0, control) ! 670: struct sockbuf *sb; ! 671: struct mbuf *m0, *control; ! 672: { ! 673: register struct mbuf *m, *n; ! 674: int space = 0; ! 675: ! 676: if (control == 0) ! 677: panic("sbappendcontrol"); ! 678: for (m = control; ; m = m->m_next) { ! 679: space += m->m_len; ! 680: if (m->m_next == 0) ! 681: break; ! 682: } ! 683: n = m; /* save pointer to last control buffer */ ! 684: for (m = m0; m; m = m->m_next) ! 685: space += m->m_len; ! 686: if (space > sbspace(sb)) ! 687: return (0); ! 688: n->m_next = m0; /* concatenate data to control */ ! 689: for (m = control; m; m = m->m_next) ! 690: sballoc(sb, m); ! 691: if (n = sb->sb_mb) { ! 692: while (n->m_nextpkt) ! 693: n = n->m_nextpkt; ! 694: n->m_nextpkt = control; ! 695: } else ! 696: sb->sb_mb = control; ! 697: postevent(0,sb,EV_RWBYTES); ! 698: return (1); ! 699: } ! 700: ! 701: /* ! 702: * Compress mbuf chain m into the socket ! 703: * buffer sb following mbuf n. If n ! 704: * is null, the buffer is presumed empty. ! 705: */ ! 706: void ! 707: sbcompress(sb, m, n) ! 708: register struct sockbuf *sb; ! 709: register struct mbuf *m, *n; ! 710: { ! 711: register int eor = 0; ! 712: register struct mbuf *o; ! 713: ! 714: while (m) { ! 715: eor |= m->m_flags & M_EOR; ! 716: if (m->m_len == 0 && ! 717: (eor == 0 || ! 718: (((o = m->m_next) || (o = n)) && ! 719: o->m_type == m->m_type))) { ! 720: m = m_free(m); ! 721: continue; ! 722: } ! 723: if (n && (n->m_flags & (M_EXT | M_EOR)) == 0 && ! 724: (n->m_data + n->m_len + m->m_len) < &n->m_dat[MLEN] && ! 725: n->m_type == m->m_type) { ! 726: bcopy(mtod(m, caddr_t), mtod(n, caddr_t) + n->m_len, ! 727: (unsigned)m->m_len); ! 728: n->m_len += m->m_len; ! 729: sb->sb_cc += m->m_len; ! 730: m = m_free(m); ! 731: continue; ! 732: } ! 733: if (n) ! 734: n->m_next = m; ! 735: else ! 736: sb->sb_mb = m; ! 737: sballoc(sb, m); ! 738: n = m; ! 739: m->m_flags &= ~M_EOR; ! 740: m = m->m_next; ! 741: n->m_next = 0; ! 742: } ! 743: if (eor) { ! 744: if (n) ! 745: n->m_flags |= eor; ! 746: else ! 747: printf("semi-panic: sbcompress\n"); ! 748: } ! 749: postevent(0,sb, EV_RWBYTES); ! 750: } ! 751: ! 752: /* ! 753: * Free all mbufs in a sockbuf. ! 754: * Check that all resources are reclaimed. ! 755: */ ! 756: void ! 757: sbflush(sb) ! 758: register struct sockbuf *sb; ! 759: { ! 760: ! 761: if (sb->sb_flags & SB_LOCK) ! 762: panic("sbflush"); ! 763: while (sb->sb_mbcnt) ! 764: sbdrop(sb, (int)sb->sb_cc); ! 765: if (sb->sb_cc || sb->sb_mb) ! 766: panic("sbflush 2"); ! 767: postevent(0, sb, EV_RWBYTES); ! 768: } ! 769: ! 770: /* ! 771: * Drop data from (the front of) a sockbuf. ! 772: */ ! 773: void ! 774: sbdrop(sb, len) ! 775: register struct sockbuf *sb; ! 776: register int len; ! 777: { ! 778: register struct mbuf *m, *mn; ! 779: struct mbuf *next; ! 780: ! 781: next = (m = sb->sb_mb) ? m->m_nextpkt : 0; ! 782: while (len > 0) { ! 783: if (m == 0) { ! 784: if (next == 0) ! 785: panic("sbdrop"); ! 786: m = next; ! 787: next = m->m_nextpkt; ! 788: continue; ! 789: } ! 790: if (m->m_len > len) { ! 791: m->m_len -= len; ! 792: m->m_data += len; ! 793: sb->sb_cc -= len; ! 794: break; ! 795: } ! 796: len -= m->m_len; ! 797: sbfree(sb, m); ! 798: MFREE(m, mn); ! 799: m = mn; ! 800: } ! 801: while (m && m->m_len == 0) { ! 802: sbfree(sb, m); ! 803: MFREE(m, mn); ! 804: m = mn; ! 805: } ! 806: if (m) { ! 807: sb->sb_mb = m; ! 808: m->m_nextpkt = next; ! 809: } else ! 810: sb->sb_mb = next; ! 811: postevent(0, sb, EV_RWBYTES); ! 812: } ! 813: ! 814: /* ! 815: * Drop a record off the front of a sockbuf ! 816: * and move the next record to the front. ! 817: */ ! 818: void ! 819: sbdroprecord(sb) ! 820: register struct sockbuf *sb; ! 821: { ! 822: register struct mbuf *m, *mn; ! 823: ! 824: m = sb->sb_mb; ! 825: if (m) { ! 826: sb->sb_mb = m->m_nextpkt; ! 827: do { ! 828: sbfree(sb, m); ! 829: MFREE(m, mn); ! 830: } while (m = mn); ! 831: } ! 832: postevent(0, sb, EV_RWBYTES); ! 833: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.