![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uipc_socket.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / kern|
Return to uipc_socket.c CVS log | Up to [Net/2] / Net2 / kern |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986, 1988, 1990 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms, with or without ! 6: * modification, are permitted provided that the following conditions ! 7: * are met: ! 8: * 1. Redistributions of source code must retain the above copyright ! 9: * notice, this list of conditions and the following disclaimer. ! 10: * 2. Redistributions in binary form must reproduce the above copyright ! 11: * notice, this list of conditions and the following disclaimer in the ! 12: * documentation and/or other materials provided with the distribution. ! 13: * 3. All advertising materials mentioning features or use of this software ! 14: * must display the following acknowledgement: ! 15: * This product includes software developed by the University of ! 16: * California, Berkeley and its contributors. ! 17: * 4. Neither the name of the University nor the names of its contributors ! 18: * may be used to endorse or promote products derived from this software ! 19: * without specific prior written permission. ! 20: * ! 21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 31: * SUCH DAMAGE. ! 32: * ! 33: * @(#)uipc_socket.c 7.28 (Berkeley) 5/4/91 ! 34: */ ! 35: ! 36: #include "param.h" ! 37: #include "proc.h" ! 38: #include "file.h" ! 39: #include "malloc.h" ! 40: #include "mbuf.h" ! 41: #include "domain.h" ! 42: #include "kernel.h" ! 43: #include "protosw.h" ! 44: #include "socket.h" ! 45: #include "socketvar.h" ! 46: #include "resourcevar.h" ! 47: ! 48: /* ! 49: * Socket operation routines. ! 50: * These routines are called by the routines in ! 51: * sys_socket.c or from a system process, and ! 52: * implement the semantics of socket operations by ! 53: * switching out to the protocol specific routines. ! 54: */ ! 55: /*ARGSUSED*/ ! 56: socreate(dom, aso, type, proto) ! 57: struct socket **aso; ! 58: register int type; ! 59: int proto; ! 60: { ! 61: struct proc *p = curproc; /* XXX */ ! 62: register struct protosw *prp; ! 63: register struct socket *so; ! 64: register int error; ! 65: ! 66: if (proto) ! 67: prp = pffindproto(dom, proto, type); ! 68: else ! 69: prp = pffindtype(dom, type); ! 70: if (prp == 0) ! 71: return (EPROTONOSUPPORT); ! 72: if (prp->pr_type != type) ! 73: return (EPROTOTYPE); ! 74: MALLOC(so, struct socket *, sizeof(*so), M_SOCKET, M_WAIT); ! 75: bzero((caddr_t)so, sizeof(*so)); ! 76: so->so_type = type; ! 77: if (p->p_ucred->cr_uid == 0) ! 78: so->so_state = SS_PRIV; ! 79: so->so_proto = prp; ! 80: error = ! 81: (*prp->pr_usrreq)(so, PRU_ATTACH, ! 82: (struct mbuf *)0, (struct mbuf *)proto, (struct mbuf *)0); ! 83: if (error) { ! 84: so->so_state |= SS_NOFDREF; ! 85: sofree(so); ! 86: return (error); ! 87: } ! 88: *aso = so; ! 89: return (0); ! 90: } ! 91: ! 92: sobind(so, nam) ! 93: struct socket *so; ! 94: struct mbuf *nam; ! 95: { ! 96: int s = splnet(); ! 97: int error; ! 98: ! 99: error = ! 100: (*so->so_proto->pr_usrreq)(so, PRU_BIND, ! 101: (struct mbuf *)0, nam, (struct mbuf *)0); ! 102: splx(s); ! 103: return (error); ! 104: } ! 105: ! 106: solisten(so, backlog) ! 107: register struct socket *so; ! 108: int backlog; ! 109: { ! 110: int s = splnet(), error; ! 111: ! 112: error = ! 113: (*so->so_proto->pr_usrreq)(so, PRU_LISTEN, ! 114: (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0); ! 115: if (error) { ! 116: splx(s); ! 117: return (error); ! 118: } ! 119: if (so->so_q == 0) ! 120: so->so_options |= SO_ACCEPTCONN; ! 121: if (backlog < 0) ! 122: backlog = 0; ! 123: so->so_qlimit = min(backlog, SOMAXCONN); ! 124: splx(s); ! 125: return (0); ! 126: } ! 127: ! 128: sofree(so) ! 129: register struct socket *so; ! 130: { ! 131: ! 132: if (so->so_pcb || (so->so_state & SS_NOFDREF) == 0) ! 133: return; ! 134: if (so->so_head) { ! 135: if (!soqremque(so, 0) && !soqremque(so, 1)) ! 136: panic("sofree dq"); ! 137: so->so_head = 0; ! 138: } ! 139: sbrelease(&so->so_snd); ! 140: sorflush(so); ! 141: FREE(so, M_SOCKET); ! 142: } ! 143: ! 144: /* ! 145: * Close a socket on last file table reference removal. ! 146: * Initiate disconnect if connected. ! 147: * Free socket when disconnect complete. ! 148: */ ! 149: soclose(so) ! 150: register struct socket *so; ! 151: { ! 152: int s = splnet(); /* conservative */ ! 153: int error = 0; ! 154: ! 155: if (so->so_options & SO_ACCEPTCONN) { ! 156: while (so->so_q0) ! 157: (void) soabort(so->so_q0); ! 158: while (so->so_q) ! 159: (void) soabort(so->so_q); ! 160: } ! 161: if (so->so_pcb == 0) ! 162: goto discard; ! 163: if (so->so_state & SS_ISCONNECTED) { ! 164: if ((so->so_state & SS_ISDISCONNECTING) == 0) { ! 165: error = sodisconnect(so); ! 166: if (error) ! 167: goto drop; ! 168: } ! 169: if (so->so_options & SO_LINGER) { ! 170: if ((so->so_state & SS_ISDISCONNECTING) && ! 171: (so->so_state & SS_NBIO)) ! 172: goto drop; ! 173: while (so->so_state & SS_ISCONNECTED) ! 174: if (error = tsleep((caddr_t)&so->so_timeo, ! 175: PSOCK | PCATCH, netcls, so->so_linger)) ! 176: break; ! 177: } ! 178: } ! 179: drop: ! 180: if (so->so_pcb) { ! 181: int error2 = ! 182: (*so->so_proto->pr_usrreq)(so, PRU_DETACH, ! 183: (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0); ! 184: if (error == 0) ! 185: error = error2; ! 186: } ! 187: discard: ! 188: if (so->so_state & SS_NOFDREF) ! 189: panic("soclose: NOFDREF"); ! 190: so->so_state |= SS_NOFDREF; ! 191: sofree(so); ! 192: splx(s); ! 193: return (error); ! 194: } ! 195: ! 196: /* ! 197: * Must be called at splnet... ! 198: */ ! 199: soabort(so) ! 200: struct socket *so; ! 201: { ! 202: ! 203: return ( ! 204: (*so->so_proto->pr_usrreq)(so, PRU_ABORT, ! 205: (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0)); ! 206: } ! 207: ! 208: soaccept(so, nam) ! 209: register struct socket *so; ! 210: struct mbuf *nam; ! 211: { ! 212: int s = splnet(); ! 213: int error; ! 214: ! 215: if ((so->so_state & SS_NOFDREF) == 0) ! 216: panic("soaccept: !NOFDREF"); ! 217: so->so_state &= ~SS_NOFDREF; ! 218: error = (*so->so_proto->pr_usrreq)(so, PRU_ACCEPT, ! 219: (struct mbuf *)0, nam, (struct mbuf *)0); ! 220: splx(s); ! 221: return (error); ! 222: } ! 223: ! 224: soconnect(so, nam) ! 225: register struct socket *so; ! 226: struct mbuf *nam; ! 227: { ! 228: int s; ! 229: int error; ! 230: ! 231: if (so->so_options & SO_ACCEPTCONN) ! 232: return (EOPNOTSUPP); ! 233: s = splnet(); ! 234: /* ! 235: * If protocol is connection-based, can only connect once. ! 236: * Otherwise, if connected, try to disconnect first. ! 237: * This allows user to disconnect by connecting to, e.g., ! 238: * a null address. ! 239: */ ! 240: if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING) && ! 241: ((so->so_proto->pr_flags & PR_CONNREQUIRED) || ! 242: (error = sodisconnect(so)))) ! 243: error = EISCONN; ! 244: else ! 245: error = (*so->so_proto->pr_usrreq)(so, PRU_CONNECT, ! 246: (struct mbuf *)0, nam, (struct mbuf *)0); ! 247: splx(s); ! 248: return (error); ! 249: } ! 250: ! 251: soconnect2(so1, so2) ! 252: register struct socket *so1; ! 253: struct socket *so2; ! 254: { ! 255: int s = splnet(); ! 256: int error; ! 257: ! 258: error = (*so1->so_proto->pr_usrreq)(so1, PRU_CONNECT2, ! 259: (struct mbuf *)0, (struct mbuf *)so2, (struct mbuf *)0); ! 260: splx(s); ! 261: return (error); ! 262: } ! 263: ! 264: sodisconnect(so) ! 265: register struct socket *so; ! 266: { ! 267: int s = splnet(); ! 268: int error; ! 269: ! 270: if ((so->so_state & SS_ISCONNECTED) == 0) { ! 271: error = ENOTCONN; ! 272: goto bad; ! 273: } ! 274: if (so->so_state & SS_ISDISCONNECTING) { ! 275: error = EALREADY; ! 276: goto bad; ! 277: } ! 278: error = (*so->so_proto->pr_usrreq)(so, PRU_DISCONNECT, ! 279: (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0); ! 280: bad: ! 281: splx(s); ! 282: return (error); ! 283: } ! 284: ! 285: /* ! 286: * Send on a socket. ! 287: * If send must go all at once and message is larger than ! 288: * send buffering, then hard error. ! 289: * Lock against other senders. ! 290: * If must go all at once and not enough room now, then ! 291: * inform user that this would block and do nothing. ! 292: * Otherwise, if nonblocking, send as much as possible. ! 293: * The data to be sent is described by "uio" if nonzero, ! 294: * otherwise by the mbuf chain "top" (which must be null ! 295: * if uio is not). Data provided in mbuf chain must be small ! 296: * enough to send all at once. ! 297: * ! 298: * Returns nonzero on error, timeout or signal; callers ! 299: * must check for short counts if EINTR/ERESTART are returned. ! 300: * Data and control buffers are freed on return. ! 301: */ ! 302: sosend(so, addr, uio, top, control, flags) ! 303: register struct socket *so; ! 304: struct mbuf *addr; ! 305: struct uio *uio; ! 306: struct mbuf *top; ! 307: struct mbuf *control; ! 308: int flags; ! 309: { ! 310: struct proc *p = curproc; /* XXX */ ! 311: struct mbuf **mp; ! 312: register struct mbuf *m; ! 313: register long space, len, resid; ! 314: int clen = 0, error, s, dontroute, mlen; ! 315: int atomic = sosendallatonce(so) || top; ! 316: ! 317: if (uio) ! 318: resid = uio->uio_resid; ! 319: else ! 320: resid = top->m_pkthdr.len; ! 321: dontroute = ! 322: (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 && ! 323: (so->so_proto->pr_flags & PR_ATOMIC); ! 324: p->p_stats->p_ru.ru_msgsnd++; ! 325: if (control) ! 326: clen = control->m_len; ! 327: #define snderr(errno) { error = errno; splx(s); goto release; } ! 328: ! 329: restart: ! 330: if (error = sblock(&so->so_snd)) ! 331: goto out; ! 332: do { ! 333: s = splnet(); ! 334: if (so->so_state & SS_CANTSENDMORE) ! 335: snderr(EPIPE); ! 336: if (so->so_error) ! 337: snderr(so->so_error); ! 338: if ((so->so_state & SS_ISCONNECTED) == 0) { ! 339: if (so->so_proto->pr_flags & PR_CONNREQUIRED) { ! 340: if ((so->so_state & SS_ISCONFIRMING) == 0 && ! 341: !(resid == 0 && clen != 0)) ! 342: snderr(ENOTCONN); ! 343: } else if (addr == 0) ! 344: snderr(EDESTADDRREQ); ! 345: } ! 346: space = sbspace(&so->so_snd); ! 347: if (flags & MSG_OOB) ! 348: space += 1024; ! 349: if (space < resid + clen && ! 350: (atomic || space < so->so_snd.sb_lowat || space < clen)) { ! 351: if (atomic && resid > so->so_snd.sb_hiwat || ! 352: clen > so->so_snd.sb_hiwat) ! 353: snderr(EMSGSIZE); ! 354: if (so->so_state & SS_NBIO) ! 355: snderr(EWOULDBLOCK); ! 356: sbunlock(&so->so_snd); ! 357: error = sbwait(&so->so_snd); ! 358: splx(s); ! 359: if (error) ! 360: goto out; ! 361: goto restart; ! 362: } ! 363: splx(s); ! 364: mp = ⊤ ! 365: space -= clen; ! 366: do { ! 367: if (uio == NULL) { ! 368: /* ! 369: * Data is prepackaged in "top". ! 370: */ ! 371: resid = 0; ! 372: if (flags & MSG_EOR) ! 373: top->m_flags |= M_EOR; ! 374: } else do { ! 375: if (top == 0) { ! 376: MGETHDR(m, M_WAIT, MT_DATA); ! 377: mlen = MHLEN; ! 378: m->m_pkthdr.len = 0; ! 379: m->m_pkthdr.rcvif = (struct ifnet *)0; ! 380: } else { ! 381: MGET(m, M_WAIT, MT_DATA); ! 382: mlen = MLEN; ! 383: } ! 384: if (resid >= MINCLSIZE && space >= MCLBYTES) { ! 385: MCLGET(m, M_WAIT); ! 386: if ((m->m_flags & M_EXT) == 0) ! 387: goto nopages; ! 388: mlen = MCLBYTES; ! 389: #ifdef MAPPED_MBUFS ! 390: len = min(MCLBYTES, resid); ! 391: #else ! 392: if (top == 0) { ! 393: len = min(MCLBYTES - max_hdr, resid); ! 394: m->m_data += max_hdr; ! 395: } else ! 396: len = min(MCLBYTES, resid); ! 397: #endif ! 398: space -= MCLBYTES; ! 399: } else { ! 400: nopages: ! 401: len = min(min(mlen, resid), space); ! 402: space -= len; ! 403: /* ! 404: * For datagram protocols, leave room ! 405: * for protocol headers in first mbuf. ! 406: */ ! 407: if (atomic && top == 0 && len < mlen) ! 408: MH_ALIGN(m, len); ! 409: } ! 410: error = uiomove(mtod(m, caddr_t), (int)len, uio); ! 411: resid = uio->uio_resid; ! 412: m->m_len = len; ! 413: *mp = m; ! 414: top->m_pkthdr.len += len; ! 415: if (error) ! 416: goto release; ! 417: mp = &m->m_next; ! 418: if (resid <= 0) { ! 419: if (flags & MSG_EOR) ! 420: top->m_flags |= M_EOR; ! 421: break; ! 422: } ! 423: } while (space > 0 && atomic); ! 424: if (dontroute) ! 425: so->so_options |= SO_DONTROUTE; ! 426: s = splnet(); /* XXX */ ! 427: error = (*so->so_proto->pr_usrreq)(so, ! 428: (flags & MSG_OOB) ? PRU_SENDOOB : PRU_SEND, ! 429: top, addr, control); ! 430: splx(s); ! 431: if (dontroute) ! 432: so->so_options &= ~SO_DONTROUTE; ! 433: clen = 0; ! 434: control = 0; ! 435: top = 0; ! 436: mp = ⊤ ! 437: if (error) ! 438: goto release; ! 439: } while (resid && space > 0); ! 440: } while (resid); ! 441: ! 442: release: ! 443: sbunlock(&so->so_snd); ! 444: out: ! 445: if (top) ! 446: m_freem(top); ! 447: if (control) ! 448: m_freem(control); ! 449: return (error); ! 450: } ! 451: ! 452: /* ! 453: * Implement receive operations on a socket. ! 454: * We depend on the way that records are added to the sockbuf ! 455: * by sbappend*. In particular, each record (mbufs linked through m_next) ! 456: * must begin with an address if the protocol so specifies, ! 457: * followed by an optional mbuf or mbufs containing ancillary data, ! 458: * and then zero or more mbufs of data. ! 459: * In order to avoid blocking network interrupts for the entire time here, ! 460: * we splx() while doing the actual copy to user space. ! 461: * Although the sockbuf is locked, new data may still be appended, ! 462: * and thus we must maintain consistency of the sockbuf during that time. ! 463: * ! 464: * The caller may receive the data as a single mbuf chain by supplying ! 465: * an mbuf **mp0 for use in returning the chain. The uio is then used ! 466: * only for the count in uio_resid. ! 467: */ ! 468: soreceive(so, paddr, uio, mp0, controlp, flagsp) ! 469: register struct socket *so; ! 470: struct mbuf **paddr; ! 471: struct uio *uio; ! 472: struct mbuf **mp0; ! 473: struct mbuf **controlp; ! 474: int *flagsp; ! 475: { ! 476: struct proc *p = curproc; /* XXX */ ! 477: register struct mbuf *m, **mp; ! 478: register int flags, len, error, s, offset; ! 479: struct protosw *pr = so->so_proto; ! 480: struct mbuf *nextrecord; ! 481: int moff, type; ! 482: ! 483: mp = mp0; ! 484: if (paddr) ! 485: *paddr = 0; ! 486: if (controlp) ! 487: *controlp = 0; ! 488: if (flagsp) ! 489: flags = *flagsp &~ MSG_EOR; ! 490: else ! 491: flags = 0; ! 492: if (flags & MSG_OOB) { ! 493: m = m_get(M_WAIT, MT_DATA); ! 494: error = (*pr->pr_usrreq)(so, PRU_RCVOOB, ! 495: m, (struct mbuf *)(flags & MSG_PEEK), (struct mbuf *)0); ! 496: if (error) ! 497: goto bad; ! 498: do { ! 499: error = uiomove(mtod(m, caddr_t), ! 500: (int) min(uio->uio_resid, m->m_len), uio); ! 501: m = m_free(m); ! 502: } while (uio->uio_resid && error == 0 && m); ! 503: bad: ! 504: if (m) ! 505: m_freem(m); ! 506: return (error); ! 507: } ! 508: if (mp) ! 509: *mp = (struct mbuf *)0; ! 510: if (so->so_state & SS_ISCONFIRMING && uio->uio_resid) ! 511: (*pr->pr_usrreq)(so, PRU_RCVD, (struct mbuf *)0, ! 512: (struct mbuf *)0, (struct mbuf *)0); ! 513: ! 514: restart: ! 515: if (error = sblock(&so->so_rcv)) ! 516: return (error); ! 517: s = splnet(); ! 518: ! 519: m = so->so_rcv.sb_mb; ! 520: /* ! 521: * If we have less data than requested, block awaiting more ! 522: * (subject to any timeout) if: ! 523: * 1. the current count is less than the low water mark, or ! 524: * 2. MSG_WAITALL is set, and it is possible to do the entire ! 525: * receive operation at once if we block (resid <= hiwat). ! 526: * If MSG_WAITALL is set but resid is larger than the receive buffer, ! 527: * we have to do the receive in sections, and thus risk returning ! 528: * a short count if a timeout or signal occurs after we start. ! 529: */ ! 530: while (m == 0 || so->so_rcv.sb_cc < uio->uio_resid && ! 531: (so->so_rcv.sb_cc < so->so_rcv.sb_lowat || ! 532: ((flags & MSG_WAITALL) && uio->uio_resid <= so->so_rcv.sb_hiwat)) && ! 533: m->m_nextpkt == 0) { ! 534: #ifdef DIAGNOSTIC ! 535: if (m == 0 && so->so_rcv.sb_cc) ! 536: panic("receive 1"); ! 537: #endif ! 538: if (so->so_error) { ! 539: if (m) ! 540: break; ! 541: error = so->so_error; ! 542: if ((flags & MSG_PEEK) == 0) ! 543: so->so_error = 0; ! 544: goto release; ! 545: } ! 546: if (so->so_state & SS_CANTRCVMORE) { ! 547: if (m) ! 548: break; ! 549: else ! 550: goto release; ! 551: } ! 552: for (; m; m = m->m_next) ! 553: if (m->m_type == MT_OOBDATA || (m->m_flags & M_EOR)) { ! 554: m = so->so_rcv.sb_mb; ! 555: goto dontblock; ! 556: } ! 557: if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 && ! 558: (so->so_proto->pr_flags & PR_CONNREQUIRED)) { ! 559: error = ENOTCONN; ! 560: goto release; ! 561: } ! 562: if (uio->uio_resid == 0) ! 563: goto release; ! 564: if (so->so_state & SS_NBIO) { ! 565: error = EWOULDBLOCK; ! 566: goto release; ! 567: } ! 568: sbunlock(&so->so_rcv); ! 569: error = sbwait(&so->so_rcv); ! 570: splx(s); ! 571: if (error) ! 572: return (error); ! 573: goto restart; ! 574: } ! 575: dontblock: ! 576: p->p_stats->p_ru.ru_msgrcv++; ! 577: nextrecord = m->m_nextpkt; ! 578: if (pr->pr_flags & PR_ADDR) { ! 579: #ifdef DIAGNOSTIC ! 580: if (m->m_type != MT_SONAME) ! 581: panic("receive 1a"); ! 582: #endif ! 583: if (flags & MSG_PEEK) { ! 584: if (paddr) ! 585: *paddr = m_copy(m, 0, m->m_len); ! 586: m = m->m_next; ! 587: } else { ! 588: sbfree(&so->so_rcv, m); ! 589: if (paddr) { ! 590: *paddr = m; ! 591: so->so_rcv.sb_mb = m->m_next; ! 592: m->m_next = 0; ! 593: m = so->so_rcv.sb_mb; ! 594: } else { ! 595: MFREE(m, so->so_rcv.sb_mb); ! 596: m = so->so_rcv.sb_mb; ! 597: } ! 598: } ! 599: } ! 600: while (m && m->m_type == MT_CONTROL && error == 0) { ! 601: if (flags & MSG_PEEK) { ! 602: if (controlp) ! 603: *controlp = m_copy(m, 0, m->m_len); ! 604: m = m->m_next; ! 605: } else { ! 606: sbfree(&so->so_rcv, m); ! 607: if (controlp) { ! 608: if (pr->pr_domain->dom_externalize && ! 609: mtod(m, struct cmsghdr *)->cmsg_type == ! 610: SCM_RIGHTS) ! 611: error = (*pr->pr_domain->dom_externalize)(m); ! 612: *controlp = m; ! 613: so->so_rcv.sb_mb = m->m_next; ! 614: m->m_next = 0; ! 615: m = so->so_rcv.sb_mb; ! 616: } else { ! 617: MFREE(m, so->so_rcv.sb_mb); ! 618: m = so->so_rcv.sb_mb; ! 619: } ! 620: } ! 621: if (controlp) ! 622: controlp = &(*controlp)->m_next; ! 623: } ! 624: if (m) { ! 625: if ((flags & MSG_PEEK) == 0) ! 626: m->m_nextpkt = nextrecord; ! 627: type = m->m_type; ! 628: if (type == MT_OOBDATA) ! 629: flags |= MSG_OOB; ! 630: } ! 631: moff = 0; ! 632: offset = 0; ! 633: while (m && uio->uio_resid > 0 && error == 0) { ! 634: if (m->m_type == MT_OOBDATA) { ! 635: if (type != MT_OOBDATA) ! 636: break; ! 637: } else if (type == MT_OOBDATA) ! 638: break; ! 639: #ifdef DIAGNOSTIC ! 640: else if (m->m_type != MT_DATA && m->m_type != MT_HEADER) ! 641: panic("receive 3"); ! 642: #endif ! 643: so->so_state &= ~SS_RCVATMARK; ! 644: len = uio->uio_resid; ! 645: if (so->so_oobmark && len > so->so_oobmark - offset) ! 646: len = so->so_oobmark - offset; ! 647: if (len > m->m_len - moff) ! 648: len = m->m_len - moff; ! 649: /* ! 650: * If mp is set, just pass back the mbufs. ! 651: * Otherwise copy them out via the uio, then free. ! 652: * Sockbuf must be consistent here (points to current mbuf, ! 653: * it points to next record) when we drop priority; ! 654: * we must note any additions to the sockbuf when we ! 655: * block interrupts again. ! 656: */ ! 657: if (mp == 0) { ! 658: splx(s); ! 659: error = uiomove(mtod(m, caddr_t) + moff, (int)len, uio); ! 660: s = splnet(); ! 661: } else ! 662: uio->uio_resid -= len; ! 663: if (len == m->m_len - moff) { ! 664: if (m->m_flags & M_EOR) ! 665: flags |= MSG_EOR; ! 666: if (flags & MSG_PEEK) { ! 667: m = m->m_next; ! 668: moff = 0; ! 669: } else { ! 670: nextrecord = m->m_nextpkt; ! 671: sbfree(&so->so_rcv, m); ! 672: if (mp) { ! 673: *mp = m; ! 674: mp = &m->m_next; ! 675: so->so_rcv.sb_mb = m = m->m_next; ! 676: *mp = (struct mbuf *)0; ! 677: } else { ! 678: MFREE(m, so->so_rcv.sb_mb); ! 679: m = so->so_rcv.sb_mb; ! 680: } ! 681: if (m) ! 682: m->m_nextpkt = nextrecord; ! 683: } ! 684: } else { ! 685: if (flags & MSG_PEEK) ! 686: moff += len; ! 687: else { ! 688: if (mp) ! 689: *mp = m_copym(m, 0, len, M_WAIT); ! 690: m->m_data += len; ! 691: m->m_len -= len; ! 692: so->so_rcv.sb_cc -= len; ! 693: } ! 694: } ! 695: if (so->so_oobmark) { ! 696: if ((flags & MSG_PEEK) == 0) { ! 697: so->so_oobmark -= len; ! 698: if (so->so_oobmark == 0) { ! 699: so->so_state |= SS_RCVATMARK; ! 700: break; ! 701: } ! 702: } else ! 703: offset += len; ! 704: } ! 705: if (flags & MSG_EOR) ! 706: break; ! 707: /* ! 708: * If the MSG_WAITALL flag is set (for non-atomic socket), ! 709: * we must not quit until "uio->uio_resid == 0" or an error ! 710: * termination. If a signal/timeout occurs, return ! 711: * with a short count but without error. ! 712: * Keep sockbuf locked against other readers. ! 713: */ ! 714: while (flags & MSG_WAITALL && m == 0 && uio->uio_resid > 0 && ! 715: !sosendallatonce(so)) { ! 716: if (so->so_error || so->so_state & SS_CANTRCVMORE) ! 717: break; ! 718: error = sbwait(&so->so_rcv); ! 719: if (error) { ! 720: sbunlock(&so->so_rcv); ! 721: splx(s); ! 722: return (0); ! 723: } ! 724: if (m = so->so_rcv.sb_mb) ! 725: nextrecord = m->m_nextpkt; ! 726: } ! 727: } ! 728: if ((flags & MSG_PEEK) == 0) { ! 729: if (m == 0) ! 730: so->so_rcv.sb_mb = nextrecord; ! 731: else if (pr->pr_flags & PR_ATOMIC) { ! 732: flags |= MSG_TRUNC; ! 733: (void) sbdroprecord(&so->so_rcv); ! 734: } ! 735: if (pr->pr_flags & PR_WANTRCVD && so->so_pcb) ! 736: (*pr->pr_usrreq)(so, PRU_RCVD, (struct mbuf *)0, ! 737: (struct mbuf *)flags, (struct mbuf *)0, ! 738: (struct mbuf *)0); ! 739: } ! 740: if (flagsp) ! 741: *flagsp |= flags; ! 742: release: ! 743: sbunlock(&so->so_rcv); ! 744: splx(s); ! 745: return (error); ! 746: } ! 747: ! 748: soshutdown(so, how) ! 749: register struct socket *so; ! 750: register int how; ! 751: { ! 752: register struct protosw *pr = so->so_proto; ! 753: ! 754: how++; ! 755: if (how & FREAD) ! 756: sorflush(so); ! 757: if (how & FWRITE) ! 758: return ((*pr->pr_usrreq)(so, PRU_SHUTDOWN, ! 759: (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0)); ! 760: return (0); ! 761: } ! 762: ! 763: sorflush(so) ! 764: register struct socket *so; ! 765: { ! 766: register struct sockbuf *sb = &so->so_rcv; ! 767: register struct protosw *pr = so->so_proto; ! 768: register int s; ! 769: struct sockbuf asb; ! 770: ! 771: sb->sb_flags |= SB_NOINTR; ! 772: (void) sblock(sb); ! 773: s = splimp(); ! 774: socantrcvmore(so); ! 775: sbunlock(sb); ! 776: asb = *sb; ! 777: bzero((caddr_t)sb, sizeof (*sb)); ! 778: splx(s); ! 779: if (pr->pr_flags & PR_RIGHTS && pr->pr_domain->dom_dispose) ! 780: (*pr->pr_domain->dom_dispose)(asb.sb_mb); ! 781: sbrelease(&asb); ! 782: } ! 783: ! 784: sosetopt(so, level, optname, m0) ! 785: register struct socket *so; ! 786: int level, optname; ! 787: struct mbuf *m0; ! 788: { ! 789: int error = 0; ! 790: register struct mbuf *m = m0; ! 791: ! 792: if (level != SOL_SOCKET) { ! 793: if (so->so_proto && so->so_proto->pr_ctloutput) ! 794: return ((*so->so_proto->pr_ctloutput) ! 795: (PRCO_SETOPT, so, level, optname, &m0)); ! 796: error = ENOPROTOOPT; ! 797: } else { ! 798: switch (optname) { ! 799: ! 800: case SO_LINGER: ! 801: if (m == NULL || m->m_len != sizeof (struct linger)) { ! 802: error = EINVAL; ! 803: goto bad; ! 804: } ! 805: so->so_linger = mtod(m, struct linger *)->l_linger; ! 806: /* fall thru... */ ! 807: ! 808: case SO_DEBUG: ! 809: case SO_KEEPALIVE: ! 810: case SO_DONTROUTE: ! 811: case SO_USELOOPBACK: ! 812: case SO_BROADCAST: ! 813: case SO_REUSEADDR: ! 814: case SO_OOBINLINE: ! 815: if (m == NULL || m->m_len < sizeof (int)) { ! 816: error = EINVAL; ! 817: goto bad; ! 818: } ! 819: if (*mtod(m, int *)) ! 820: so->so_options |= optname; ! 821: else ! 822: so->so_options &= ~optname; ! 823: break; ! 824: ! 825: case SO_SNDBUF: ! 826: case SO_RCVBUF: ! 827: case SO_SNDLOWAT: ! 828: case SO_RCVLOWAT: ! 829: if (m == NULL || m->m_len < sizeof (int)) { ! 830: error = EINVAL; ! 831: goto bad; ! 832: } ! 833: switch (optname) { ! 834: ! 835: case SO_SNDBUF: ! 836: case SO_RCVBUF: ! 837: if (sbreserve(optname == SO_SNDBUF ? ! 838: &so->so_snd : &so->so_rcv, ! 839: (u_long) *mtod(m, int *)) == 0) { ! 840: error = ENOBUFS; ! 841: goto bad; ! 842: } ! 843: break; ! 844: ! 845: case SO_SNDLOWAT: ! 846: so->so_snd.sb_lowat = *mtod(m, int *); ! 847: break; ! 848: case SO_RCVLOWAT: ! 849: so->so_rcv.sb_lowat = *mtod(m, int *); ! 850: break; ! 851: } ! 852: break; ! 853: ! 854: case SO_SNDTIMEO: ! 855: case SO_RCVTIMEO: ! 856: { ! 857: struct timeval *tv; ! 858: short val; ! 859: ! 860: if (m == NULL || m->m_len < sizeof (*tv)) { ! 861: error = EINVAL; ! 862: goto bad; ! 863: } ! 864: tv = mtod(m, struct timeval *); ! 865: if (tv->tv_sec > SHRT_MAX / hz - hz) { ! 866: error = EDOM; ! 867: goto bad; ! 868: } ! 869: val = tv->tv_sec * hz + tv->tv_usec / tick; ! 870: ! 871: switch (optname) { ! 872: ! 873: case SO_SNDTIMEO: ! 874: so->so_snd.sb_timeo = val; ! 875: break; ! 876: case SO_RCVTIMEO: ! 877: so->so_rcv.sb_timeo = val; ! 878: break; ! 879: } ! 880: break; ! 881: } ! 882: ! 883: default: ! 884: error = ENOPROTOOPT; ! 885: break; ! 886: } ! 887: } ! 888: bad: ! 889: if (m) ! 890: (void) m_free(m); ! 891: return (error); ! 892: } ! 893: ! 894: sogetopt(so, level, optname, mp) ! 895: register struct socket *so; ! 896: int level, optname; ! 897: struct mbuf **mp; ! 898: { ! 899: register struct mbuf *m; ! 900: ! 901: if (level != SOL_SOCKET) { ! 902: if (so->so_proto && so->so_proto->pr_ctloutput) { ! 903: return ((*so->so_proto->pr_ctloutput) ! 904: (PRCO_GETOPT, so, level, optname, mp)); ! 905: } else ! 906: return (ENOPROTOOPT); ! 907: } else { ! 908: m = m_get(M_WAIT, MT_SOOPTS); ! 909: m->m_len = sizeof (int); ! 910: ! 911: switch (optname) { ! 912: ! 913: case SO_LINGER: ! 914: m->m_len = sizeof (struct linger); ! 915: mtod(m, struct linger *)->l_onoff = ! 916: so->so_options & SO_LINGER; ! 917: mtod(m, struct linger *)->l_linger = so->so_linger; ! 918: break; ! 919: ! 920: case SO_USELOOPBACK: ! 921: case SO_DONTROUTE: ! 922: case SO_DEBUG: ! 923: case SO_KEEPALIVE: ! 924: case SO_REUSEADDR: ! 925: case SO_BROADCAST: ! 926: case SO_OOBINLINE: ! 927: *mtod(m, int *) = so->so_options & optname; ! 928: break; ! 929: ! 930: case SO_TYPE: ! 931: *mtod(m, int *) = so->so_type; ! 932: break; ! 933: ! 934: case SO_ERROR: ! 935: *mtod(m, int *) = so->so_error; ! 936: so->so_error = 0; ! 937: break; ! 938: ! 939: case SO_SNDBUF: ! 940: *mtod(m, int *) = so->so_snd.sb_hiwat; ! 941: break; ! 942: ! 943: case SO_RCVBUF: ! 944: *mtod(m, int *) = so->so_rcv.sb_hiwat; ! 945: break; ! 946: ! 947: case SO_SNDLOWAT: ! 948: *mtod(m, int *) = so->so_snd.sb_lowat; ! 949: break; ! 950: ! 951: case SO_RCVLOWAT: ! 952: *mtod(m, int *) = so->so_rcv.sb_lowat; ! 953: break; ! 954: ! 955: case SO_SNDTIMEO: ! 956: case SO_RCVTIMEO: ! 957: { ! 958: int val = (optname == SO_SNDTIMEO ? ! 959: so->so_snd.sb_timeo : so->so_rcv.sb_timeo); ! 960: ! 961: m->m_len = sizeof(struct timeval); ! 962: mtod(m, struct timeval *)->tv_sec = val / hz; ! 963: mtod(m, struct timeval *)->tv_usec = ! 964: (val % hz) / tick; ! 965: break; ! 966: } ! 967: ! 968: default: ! 969: (void)m_free(m); ! 970: return (ENOPROTOOPT); ! 971: } ! 972: *mp = m; ! 973: return (0); ! 974: } ! 975: } ! 976: ! 977: sohasoutofband(so) ! 978: register struct socket *so; ! 979: { ! 980: struct proc *p; ! 981: ! 982: if (so->so_pgid < 0) ! 983: gsignal(-so->so_pgid, SIGURG); ! 984: else if (so->so_pgid > 0 && (p = pfind(so->so_pgid)) != 0) ! 985: psignal(p, SIGURG); ! 986: if (so->so_rcv.sb_sel) { ! 987: selwakeup(so->so_rcv.sb_sel, so->so_rcv.sb_flags & SB_COLL); ! 988: so->so_rcv.sb_sel = 0; ! 989: so->so_rcv.sb_flags &= ~SB_COLL; ! 990: } ! 991: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.