![[BACK]](/icons/back.gif){kind=icon}
Return to uipc_socket.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / sys / kern|
Return to uipc_socket.c CVS log | Up to [cvs.NetBSD.org] / src / sys / kern |
1.1 ! cgd 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: }