123421Smckusick /* 241908Skarels * Copyright (c) 1982, 1986, 1988, 1990 Regents of the University of California. 333185Sbostic * All rights reserved. 423421Smckusick * 544450Sbostic * %sccs.include.redist.c% 633185Sbostic * 7*56517Sbostic * @(#)uipc_socket.c 7.37 (Berkeley) 10/11/92 823421Smckusick */ 94786Swnj 10*56517Sbostic #include <sys/param.h> 11*56517Sbostic #include <sys/systm.h> 12*56517Sbostic #include <sys/proc.h> 13*56517Sbostic #include <sys/file.h> 14*56517Sbostic #include <sys/malloc.h> 15*56517Sbostic #include <sys/mbuf.h> 16*56517Sbostic #include <sys/domain.h> 17*56517Sbostic #include <sys/kernel.h> 18*56517Sbostic #include <sys/protosw.h> 19*56517Sbostic #include <sys/socket.h> 20*56517Sbostic #include <sys/socketvar.h> 21*56517Sbostic #include <sys/resourcevar.h> 224786Swnj 234786Swnj /* 248300Sroot * Socket operation routines. 258300Sroot * These routines are called by the routines in 268300Sroot * sys_socket.c or from a system process, and 278300Sroot * implement the semantics of socket operations by 288300Sroot * switching out to the protocol specific routines. 294786Swnj */ 308594Sroot /*ARGSUSED*/ 3110267Ssam socreate(dom, aso, type, proto) 3252482Storek int dom; 334786Swnj struct socket **aso; 3412757Ssam register int type; 3512757Ssam int proto; 364786Swnj { 3750942Ssklower struct proc *p = curproc; /* XXX */ 384786Swnj register struct protosw *prp; 394786Swnj register struct socket *so; 4012757Ssam register int error; 414786Swnj 424890Swnj if (proto) 4321767Skarels prp = pffindproto(dom, proto, type); 444890Swnj else 459168Ssam prp = pffindtype(dom, type); 464890Swnj if (prp == 0) 474890Swnj return (EPROTONOSUPPORT); 488300Sroot if (prp->pr_type != type) 498300Sroot return (EPROTOTYPE); 5037478Ssklower MALLOC(so, struct socket *, sizeof(*so), M_SOCKET, M_WAIT); 5137478Ssklower bzero((caddr_t)so, sizeof(*so)); 529168Ssam so->so_type = type; 5350942Ssklower if (p->p_ucred->cr_uid == 0) 546214Swnj so->so_state = SS_PRIV; 554786Swnj so->so_proto = prp; 5612757Ssam error = 5712757Ssam (*prp->pr_usrreq)(so, PRU_ATTACH, 5821767Skarels (struct mbuf *)0, (struct mbuf *)proto, (struct mbuf *)0); 594979Swnj if (error) { 607507Sroot so->so_state |= SS_NOFDREF; 617180Swnj sofree(so); 624890Swnj return (error); 634786Swnj } 644786Swnj *aso = so; 654786Swnj return (0); 664786Swnj } 674786Swnj 6810267Ssam sobind(so, nam) 698300Sroot struct socket *so; 708300Sroot struct mbuf *nam; 718300Sroot { 728300Sroot int s = splnet(); 738300Sroot int error; 748300Sroot 7541908Skarels error = 7641908Skarels (*so->so_proto->pr_usrreq)(so, PRU_BIND, 7712757Ssam (struct mbuf *)0, nam, (struct mbuf *)0); 788300Sroot splx(s); 798300Sroot return (error); 808300Sroot } 818300Sroot 828300Sroot solisten(so, backlog) 8312757Ssam register struct socket *so; 848300Sroot int backlog; 858300Sroot { 8612757Ssam int s = splnet(), error; 878300Sroot 8812757Ssam error = 8912757Ssam (*so->so_proto->pr_usrreq)(so, PRU_LISTEN, 9012757Ssam (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0); 918300Sroot if (error) { 928300Sroot splx(s); 938300Sroot return (error); 948300Sroot } 9538584Skarels if (so->so_q == 0) 968300Sroot so->so_options |= SO_ACCEPTCONN; 978300Sroot if (backlog < 0) 988300Sroot backlog = 0; 9935384Skarels so->so_qlimit = min(backlog, SOMAXCONN); 10012493Ssam splx(s); 1018300Sroot return (0); 1028300Sroot } 1038300Sroot 1044916Swnj sofree(so) 10512757Ssam register struct socket *so; 1064916Swnj { 1074916Swnj 10831810Skarels if (so->so_pcb || (so->so_state & SS_NOFDREF) == 0) 10931810Skarels return; 1107507Sroot if (so->so_head) { 1117507Sroot if (!soqremque(so, 0) && !soqremque(so, 1)) 1127507Sroot panic("sofree dq"); 1137507Sroot so->so_head = 0; 1147507Sroot } 1154950Swnj sbrelease(&so->so_snd); 11612757Ssam sorflush(so); 11737478Ssklower FREE(so, M_SOCKET); 1184916Swnj } 1194916Swnj 1204786Swnj /* 1214890Swnj * Close a socket on last file table reference removal. 1224890Swnj * Initiate disconnect if connected. 1234890Swnj * Free socket when disconnect complete. 1244829Swnj */ 12512757Ssam soclose(so) 1264829Swnj register struct socket *so; 1274829Swnj { 1284890Swnj int s = splnet(); /* conservative */ 12933372Sbostic int error = 0; 1304829Swnj 1317507Sroot if (so->so_options & SO_ACCEPTCONN) { 13238584Skarels while (so->so_q0) 13310399Ssam (void) soabort(so->so_q0); 13438584Skarels while (so->so_q) 13510399Ssam (void) soabort(so->so_q); 1367507Sroot } 1374890Swnj if (so->so_pcb == 0) 1384890Swnj goto discard; 1394890Swnj if (so->so_state & SS_ISCONNECTED) { 1404890Swnj if ((so->so_state & SS_ISDISCONNECTING) == 0) { 14126245Skarels error = sodisconnect(so); 14212757Ssam if (error) 14312757Ssam goto drop; 1444890Swnj } 14510267Ssam if (so->so_options & SO_LINGER) { 1465281Sroot if ((so->so_state & SS_ISDISCONNECTING) && 14712757Ssam (so->so_state & SS_NBIO)) 14812757Ssam goto drop; 1495281Sroot while (so->so_state & SS_ISCONNECTED) 15040706Skarels if (error = tsleep((caddr_t)&so->so_timeo, 15140706Skarels PSOCK | PCATCH, netcls, so->so_linger)) 15240706Skarels break; 1534890Swnj } 1544890Swnj } 1555580Sroot drop: 1566880Ssam if (so->so_pcb) { 15712757Ssam int error2 = 15812757Ssam (*so->so_proto->pr_usrreq)(so, PRU_DETACH, 15912757Ssam (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0); 16012757Ssam if (error == 0) 16112757Ssam error = error2; 1626880Ssam } 1634890Swnj discard: 16410399Ssam if (so->so_state & SS_NOFDREF) 16510399Ssam panic("soclose: NOFDREF"); 1667507Sroot so->so_state |= SS_NOFDREF; 1674950Swnj sofree(so); 1684890Swnj splx(s); 16912757Ssam return (error); 1704829Swnj } 1714829Swnj 17210399Ssam /* 17310399Ssam * Must be called at splnet... 17410399Ssam */ 17510399Ssam soabort(so) 17610399Ssam struct socket *so; 17710399Ssam { 17810399Ssam 17912757Ssam return ( 18012757Ssam (*so->so_proto->pr_usrreq)(so, PRU_ABORT, 18112757Ssam (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0)); 18210399Ssam } 18310399Ssam 18410267Ssam soaccept(so, nam) 18512757Ssam register struct socket *so; 1868300Sroot struct mbuf *nam; 1874927Swnj { 1884927Swnj int s = splnet(); 1894927Swnj int error; 1904927Swnj 19110399Ssam if ((so->so_state & SS_NOFDREF) == 0) 19210399Ssam panic("soaccept: !NOFDREF"); 19310267Ssam so->so_state &= ~SS_NOFDREF; 1948300Sroot error = (*so->so_proto->pr_usrreq)(so, PRU_ACCEPT, 19512757Ssam (struct mbuf *)0, nam, (struct mbuf *)0); 1964927Swnj splx(s); 1974927Swnj return (error); 1984927Swnj } 1994927Swnj 20010267Ssam soconnect(so, nam) 20112757Ssam register struct socket *so; 2028300Sroot struct mbuf *nam; 2034786Swnj { 20430414Skarels int s; 2054890Swnj int error; 2064786Swnj 20730414Skarels if (so->so_options & SO_ACCEPTCONN) 20830414Skarels return (EOPNOTSUPP); 20930414Skarels s = splnet(); 21024768Skarels /* 21124768Skarels * If protocol is connection-based, can only connect once. 21224768Skarels * Otherwise, if connected, try to disconnect first. 21324768Skarels * This allows user to disconnect by connecting to, e.g., 21424768Skarels * a null address. 21524768Skarels */ 21624768Skarels if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING) && 21724768Skarels ((so->so_proto->pr_flags & PR_CONNREQUIRED) || 21824768Skarels (error = sodisconnect(so)))) 2194890Swnj error = EISCONN; 22024768Skarels else 22124768Skarels error = (*so->so_proto->pr_usrreq)(so, PRU_CONNECT, 22224768Skarels (struct mbuf *)0, nam, (struct mbuf *)0); 2234890Swnj splx(s); 2244890Swnj return (error); 2254786Swnj } 2264786Swnj 22712757Ssam soconnect2(so1, so2) 22812757Ssam register struct socket *so1; 22912757Ssam struct socket *so2; 23012757Ssam { 23112757Ssam int s = splnet(); 23212757Ssam int error; 23312757Ssam 23413113Ssam error = (*so1->so_proto->pr_usrreq)(so1, PRU_CONNECT2, 23513113Ssam (struct mbuf *)0, (struct mbuf *)so2, (struct mbuf *)0); 23612757Ssam splx(s); 23712757Ssam return (error); 23812757Ssam } 23912757Ssam 24026245Skarels sodisconnect(so) 24112757Ssam register struct socket *so; 2424786Swnj { 2434890Swnj int s = splnet(); 2444890Swnj int error; 2454786Swnj 2464890Swnj if ((so->so_state & SS_ISCONNECTED) == 0) { 2474890Swnj error = ENOTCONN; 2484890Swnj goto bad; 2494890Swnj } 2504890Swnj if (so->so_state & SS_ISDISCONNECTING) { 2514890Swnj error = EALREADY; 2524890Swnj goto bad; 2534890Swnj } 2548300Sroot error = (*so->so_proto->pr_usrreq)(so, PRU_DISCONNECT, 25526245Skarels (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0); 2564890Swnj bad: 2574890Swnj splx(s); 2584890Swnj return (error); 2594786Swnj } 2604786Swnj 26151755Smckusick #define SBLOCKWAIT(f) (((f) & MSG_DONTWAIT) ? M_NOWAIT : M_WAITOK) 2624786Swnj /* 2634890Swnj * Send on a socket. 2644890Swnj * If send must go all at once and message is larger than 2654890Swnj * send buffering, then hard error. 2664890Swnj * Lock against other senders. 2674890Swnj * If must go all at once and not enough room now, then 2684890Swnj * inform user that this would block and do nothing. 26916412Skarels * Otherwise, if nonblocking, send as much as possible. 27041908Skarels * The data to be sent is described by "uio" if nonzero, 27141908Skarels * otherwise by the mbuf chain "top" (which must be null 27241908Skarels * if uio is not). Data provided in mbuf chain must be small 27341908Skarels * enough to send all at once. 27441908Skarels * 27541908Skarels * Returns nonzero on error, timeout or signal; callers 27641908Skarels * must check for short counts if EINTR/ERESTART are returned. 27741908Skarels * Data and control buffers are freed on return. 2784786Swnj */ 27943417Skarels sosend(so, addr, uio, top, control, flags) 2804786Swnj register struct socket *so; 28141908Skarels struct mbuf *addr; 28241908Skarels struct uio *uio; 28341908Skarels struct mbuf *top; 28441908Skarels struct mbuf *control; 2858319Sroot int flags; 2864786Swnj { 28750942Ssklower struct proc *p = curproc; /* XXX */ 28841908Skarels struct mbuf **mp; 28935384Skarels register struct mbuf *m; 29041908Skarels register long space, len, resid; 29141908Skarels int clen = 0, error, s, dontroute, mlen; 29241908Skarels int atomic = sosendallatonce(so) || top; 2934786Swnj 29441908Skarels if (uio) 29541908Skarels resid = uio->uio_resid; 29641908Skarels else 29741908Skarels resid = top->m_pkthdr.len; 29812757Ssam dontroute = 29912757Ssam (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 && 30012757Ssam (so->so_proto->pr_flags & PR_ATOMIC); 30150942Ssklower p->p_stats->p_ru.ru_msgsnd++; 30240632Skarels if (control) 30341908Skarels clen = control->m_len; 30416412Skarels #define snderr(errno) { error = errno; splx(s); goto release; } 30516412Skarels 3066419Sroot restart: 30751755Smckusick if (error = sblock(&so->so_snd, SBLOCKWAIT(flags))) 30841908Skarels goto out; 30916412Skarels do { 31016412Skarels s = splnet(); 31121108Skarels if (so->so_state & SS_CANTSENDMORE) 31216412Skarels snderr(EPIPE); 31337478Ssklower if (so->so_error) 31437478Ssklower snderr(so->so_error); 31516412Skarels if ((so->so_state & SS_ISCONNECTED) == 0) { 31637478Ssklower if (so->so_proto->pr_flags & PR_CONNREQUIRED) { 31749059Ssklower if ((so->so_state & SS_ISCONFIRMING) == 0 && 31849059Ssklower !(resid == 0 && clen != 0)) 31937478Ssklower snderr(ENOTCONN); 32041908Skarels } else if (addr == 0) 32116412Skarels snderr(EDESTADDRREQ); 32216412Skarels } 32341908Skarels space = sbspace(&so->so_snd); 32416412Skarels if (flags & MSG_OOB) 32541908Skarels space += 1024; 32651755Smckusick if (atomic && resid > so->so_snd.sb_hiwat || 32751755Smckusick clen > so->so_snd.sb_hiwat) 32851755Smckusick snderr(EMSGSIZE); 32951755Smckusick if (space < resid + clen && uio && 33041908Skarels (atomic || space < so->so_snd.sb_lowat || space < clen)) { 33141908Skarels if (so->so_state & SS_NBIO) 33241908Skarels snderr(EWOULDBLOCK); 33341908Skarels sbunlock(&so->so_snd); 33443417Skarels error = sbwait(&so->so_snd); 33541908Skarels splx(s); 33641908Skarels if (error) 33741908Skarels goto out; 33841908Skarels goto restart; 33916412Skarels } 34016412Skarels splx(s); 34116412Skarels mp = ⊤ 34241908Skarels space -= clen; 34343417Skarels do { 34443417Skarels if (uio == NULL) { 34541908Skarels /* 34641908Skarels * Data is prepackaged in "top". 34741908Skarels */ 34841908Skarels resid = 0; 34941908Skarels if (flags & MSG_EOR) 35041908Skarels top->m_flags |= M_EOR; 35143417Skarels } else do { 35235384Skarels if (top == 0) { 35335384Skarels MGETHDR(m, M_WAIT, MT_DATA); 35435384Skarels mlen = MHLEN; 35535384Skarels m->m_pkthdr.len = 0; 35635384Skarels m->m_pkthdr.rcvif = (struct ifnet *)0; 35735384Skarels } else { 35835384Skarels MGET(m, M_WAIT, MT_DATA); 35935384Skarels mlen = MLEN; 36035384Skarels } 36141908Skarels if (resid >= MINCLSIZE && space >= MCLBYTES) { 36235384Skarels MCLGET(m, M_WAIT); 36335384Skarels if ((m->m_flags & M_EXT) == 0) 36416412Skarels goto nopages; 36535384Skarels mlen = MCLBYTES; 36635384Skarels #ifdef MAPPED_MBUFS 36741908Skarels len = min(MCLBYTES, resid); 36841908Skarels #else 36941908Skarels if (top == 0) { 37041908Skarels len = min(MCLBYTES - max_hdr, resid); 37135384Skarels m->m_data += max_hdr; 37246452Ssklower } else 37346452Ssklower len = min(MCLBYTES, resid); 37435384Skarels #endif 37535384Skarels space -= MCLBYTES; 37616412Skarels } else { 37716412Skarels nopages: 37841908Skarels len = min(min(mlen, resid), space); 37921767Skarels space -= len; 38035384Skarels /* 38135384Skarels * For datagram protocols, leave room 38235384Skarels * for protocol headers in first mbuf. 38335384Skarels */ 38435391Skarels if (atomic && top == 0 && len < mlen) 38535384Skarels MH_ALIGN(m, len); 38616412Skarels } 38745515Skarels error = uiomove(mtod(m, caddr_t), (int)len, uio); 38841908Skarels resid = uio->uio_resid; 38916412Skarels m->m_len = len; 39016412Skarels *mp = m; 39135384Skarels top->m_pkthdr.len += len; 39216412Skarels if (error) 39316412Skarels goto release; 39416412Skarels mp = &m->m_next; 39541908Skarels if (resid <= 0) { 39641908Skarels if (flags & MSG_EOR) 39735384Skarels top->m_flags |= M_EOR; 39821108Skarels break; 39935384Skarels } 40035384Skarels } while (space > 0 && atomic); 40135384Skarels if (dontroute) 40235384Skarels so->so_options |= SO_DONTROUTE; 40335384Skarels s = splnet(); /* XXX */ 40435384Skarels error = (*so->so_proto->pr_usrreq)(so, 40535384Skarels (flags & MSG_OOB) ? PRU_SENDOOB : PRU_SEND, 40641908Skarels top, addr, control); 40735384Skarels splx(s); 40835384Skarels if (dontroute) 40935384Skarels so->so_options &= ~SO_DONTROUTE; 41041908Skarels clen = 0; 41141908Skarels control = 0; 41235384Skarels top = 0; 41335384Skarels mp = ⊤ 41435384Skarels if (error) 41535384Skarels goto release; 41641908Skarels } while (resid && space > 0); 41741908Skarels } while (resid); 4184890Swnj 4194786Swnj release: 4204890Swnj sbunlock(&so->so_snd); 42141908Skarels out: 4226419Sroot if (top) 4236419Sroot m_freem(top); 42441908Skarels if (control) 42541908Skarels m_freem(control); 4264786Swnj return (error); 4274786Swnj } 4284786Swnj 42925629Skarels /* 43025629Skarels * Implement receive operations on a socket. 43125629Skarels * We depend on the way that records are added to the sockbuf 43225629Skarels * by sbappend*. In particular, each record (mbufs linked through m_next) 43325629Skarels * must begin with an address if the protocol so specifies, 43441908Skarels * followed by an optional mbuf or mbufs containing ancillary data, 43541908Skarels * and then zero or more mbufs of data. 43625629Skarels * In order to avoid blocking network interrupts for the entire time here, 43725629Skarels * we splx() while doing the actual copy to user space. 43825629Skarels * Although the sockbuf is locked, new data may still be appended, 43925629Skarels * and thus we must maintain consistency of the sockbuf during that time. 44045515Skarels * 44141908Skarels * The caller may receive the data as a single mbuf chain by supplying 44243417Skarels * an mbuf **mp0 for use in returning the chain. The uio is then used 44341908Skarels * only for the count in uio_resid. 44425629Skarels */ 44543417Skarels soreceive(so, paddr, uio, mp0, controlp, flagsp) 4464786Swnj register struct socket *so; 44741908Skarels struct mbuf **paddr; 44841908Skarels struct uio *uio; 44943417Skarels struct mbuf **mp0; 45041908Skarels struct mbuf **controlp; 45135384Skarels int *flagsp; 4524786Swnj { 45343417Skarels register struct mbuf *m, **mp; 45443417Skarels register int flags, len, error, s, offset; 45512757Ssam struct protosw *pr = so->so_proto; 45641908Skarels struct mbuf *nextrecord; 45741908Skarels int moff, type; 4584786Swnj 45943417Skarels mp = mp0; 46041908Skarels if (paddr) 46141908Skarels *paddr = 0; 46235384Skarels if (controlp) 46335384Skarels *controlp = 0; 46435384Skarels if (flagsp) 46535384Skarels flags = *flagsp &~ MSG_EOR; 46645515Skarels else 46735384Skarels flags = 0; 46812757Ssam if (flags & MSG_OOB) { 4699635Ssam m = m_get(M_WAIT, MT_DATA); 47012757Ssam error = (*pr->pr_usrreq)(so, PRU_RCVOOB, 47124768Skarels m, (struct mbuf *)(flags & MSG_PEEK), (struct mbuf *)0); 4728594Sroot if (error) 47310137Ssam goto bad; 4748319Sroot do { 47541908Skarels error = uiomove(mtod(m, caddr_t), 47641908Skarels (int) min(uio->uio_resid, m->m_len), uio); 4778319Sroot m = m_free(m); 4788594Sroot } while (uio->uio_resid && error == 0 && m); 47910137Ssam bad: 4808319Sroot if (m) 4818771Sroot m_freem(m); 4828594Sroot return (error); 4838319Sroot } 48441908Skarels if (mp) 48541908Skarels *mp = (struct mbuf *)0; 48643417Skarels if (so->so_state & SS_ISCONFIRMING && uio->uio_resid) 48735384Skarels (*pr->pr_usrreq)(so, PRU_RCVD, (struct mbuf *)0, 48835384Skarels (struct mbuf *)0, (struct mbuf *)0); 4898319Sroot 4904890Swnj restart: 49151755Smckusick if (error = sblock(&so->so_rcv, SBLOCKWAIT(flags))) 49240706Skarels return (error); 4938835Sroot s = splnet(); 4944890Swnj 49537478Ssklower m = so->so_rcv.sb_mb; 49644383Skarels /* 49744383Skarels * If we have less data than requested, block awaiting more 49844383Skarels * (subject to any timeout) if: 49944383Skarels * 1. the current count is less than the low water mark, or 50044383Skarels * 2. MSG_WAITALL is set, and it is possible to do the entire 50144383Skarels * receive operation at once if we block (resid <= hiwat). 50251755Smckusick * 3. MSG_DONTWAIT is not set 50344383Skarels * If MSG_WAITALL is set but resid is larger than the receive buffer, 50444383Skarels * we have to do the receive in sections, and thus risk returning 50544383Skarels * a short count if a timeout or signal occurs after we start. 50644383Skarels */ 50751755Smckusick if (m == 0 || ((flags & MSG_DONTWAIT) == 0 && 50851755Smckusick so->so_rcv.sb_cc < uio->uio_resid) && 50944383Skarels (so->so_rcv.sb_cc < so->so_rcv.sb_lowat || 51050942Ssklower ((flags & MSG_WAITALL) && uio->uio_resid <= so->so_rcv.sb_hiwat)) && 51150942Ssklower m->m_nextpkt == 0) { 51241908Skarels #ifdef DIAGNOSTIC 51341908Skarels if (m == 0 && so->so_rcv.sb_cc) 51437478Ssklower panic("receive 1"); 51541908Skarels #endif 5165168Swnj if (so->so_error) { 51746479Skarels if (m) 51851022Ssklower goto dontblock; 5195168Swnj error = so->so_error; 52046479Skarels if ((flags & MSG_PEEK) == 0) 52146479Skarels so->so_error = 0; 5225168Swnj goto release; 5235168Swnj } 52446479Skarels if (so->so_state & SS_CANTRCVMORE) { 52546479Skarels if (m) 52651022Ssklower goto dontblock; 52746479Skarels else 52846479Skarels goto release; 52946479Skarels } 53050942Ssklower for (; m; m = m->m_next) 53150942Ssklower if (m->m_type == MT_OOBDATA || (m->m_flags & M_EOR)) { 53250942Ssklower m = so->so_rcv.sb_mb; 53350942Ssklower goto dontblock; 53450942Ssklower } 53538584Skarels if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 && 53632567Sbostic (so->so_proto->pr_flags & PR_CONNREQUIRED)) { 53732567Sbostic error = ENOTCONN; 53832567Sbostic goto release; 5394890Swnj } 54043417Skarels if (uio->uio_resid == 0) 54125629Skarels goto release; 54251755Smckusick if ((so->so_state & SS_NBIO) || (flags & MSG_DONTWAIT)) { 54332567Sbostic error = EWOULDBLOCK; 54432567Sbostic goto release; 54532567Sbostic } 5464890Swnj sbunlock(&so->so_rcv); 54743417Skarels error = sbwait(&so->so_rcv); 5485012Swnj splx(s); 54941908Skarels if (error) 55041908Skarels return (error); 5514890Swnj goto restart; 5524786Swnj } 55350942Ssklower dontblock: 55452926Smckusick if (uio->uio_procp) 55552926Smckusick uio->uio_procp->p_stats->p_ru.ru_msgrcv++; 55635384Skarels nextrecord = m->m_nextpkt; 55712757Ssam if (pr->pr_flags & PR_ADDR) { 55841908Skarels #ifdef DIAGNOSTIC 55925629Skarels if (m->m_type != MT_SONAME) 56016993Skarels panic("receive 1a"); 56141908Skarels #endif 56216993Skarels if (flags & MSG_PEEK) { 56341908Skarels if (paddr) 56441908Skarels *paddr = m_copy(m, 0, m->m_len); 56525629Skarels m = m->m_next; 56616993Skarels } else { 56725629Skarels sbfree(&so->so_rcv, m); 56841908Skarels if (paddr) { 56941908Skarels *paddr = m; 57035384Skarels so->so_rcv.sb_mb = m->m_next; 57135384Skarels m->m_next = 0; 57235384Skarels m = so->so_rcv.sb_mb; 57325629Skarels } else { 57426958Skarels MFREE(m, so->so_rcv.sb_mb); 57526958Skarels m = so->so_rcv.sb_mb; 57625629Skarels } 57716993Skarels } 57816993Skarels } 57941908Skarels while (m && m->m_type == MT_CONTROL && error == 0) { 58016993Skarels if (flags & MSG_PEEK) { 58135384Skarels if (controlp) 58235384Skarels *controlp = m_copy(m, 0, m->m_len); 58335384Skarels m = m->m_next; 58435384Skarels } else { 58535384Skarels sbfree(&so->so_rcv, m); 58635384Skarels if (controlp) { 58743097Ssklower if (pr->pr_domain->dom_externalize && 58843097Ssklower mtod(m, struct cmsghdr *)->cmsg_type == 58943097Ssklower SCM_RIGHTS) 59041908Skarels error = (*pr->pr_domain->dom_externalize)(m); 59135384Skarels *controlp = m; 59235384Skarels so->so_rcv.sb_mb = m->m_next; 59335384Skarels m->m_next = 0; 59435384Skarels m = so->so_rcv.sb_mb; 59535384Skarels } else { 59635384Skarels MFREE(m, so->so_rcv.sb_mb); 59735384Skarels m = so->so_rcv.sb_mb; 59835384Skarels } 59935384Skarels } 60041908Skarels if (controlp) 60141908Skarels controlp = &(*controlp)->m_next; 60235384Skarels } 60341908Skarels if (m) { 60444383Skarels if ((flags & MSG_PEEK) == 0) 60544383Skarels m->m_nextpkt = nextrecord; 60641908Skarels type = m->m_type; 60746452Ssklower if (type == MT_OOBDATA) 60846452Ssklower flags |= MSG_OOB; 60941908Skarels } 6108319Sroot moff = 0; 61132092Skarels offset = 0; 61246452Ssklower while (m && uio->uio_resid > 0 && error == 0) { 61346452Ssklower if (m->m_type == MT_OOBDATA) { 61446452Ssklower if (type != MT_OOBDATA) 61546452Ssklower break; 61646452Ssklower } else if (type == MT_OOBDATA) 61746452Ssklower break; 61841908Skarels #ifdef DIAGNOSTIC 61935384Skarels else if (m->m_type != MT_DATA && m->m_type != MT_HEADER) 62025629Skarels panic("receive 3"); 62141908Skarels #endif 6227747Sroot so->so_state &= ~SS_RCVATMARK; 62343417Skarels len = uio->uio_resid; 62432092Skarels if (so->so_oobmark && len > so->so_oobmark - offset) 62532092Skarels len = so->so_oobmark - offset; 62621767Skarels if (len > m->m_len - moff) 6278319Sroot len = m->m_len - moff; 62841908Skarels /* 62941908Skarels * If mp is set, just pass back the mbufs. 63041908Skarels * Otherwise copy them out via the uio, then free. 63141908Skarels * Sockbuf must be consistent here (points to current mbuf, 63241908Skarels * it points to next record) when we drop priority; 63341908Skarels * we must note any additions to the sockbuf when we 63441908Skarels * block interrupts again. 63541908Skarels */ 63641908Skarels if (mp == 0) { 63741908Skarels splx(s); 63841908Skarels error = uiomove(mtod(m, caddr_t) + moff, (int)len, uio); 63941908Skarels s = splnet(); 64043417Skarels } else 64143417Skarels uio->uio_resid -= len; 64221767Skarels if (len == m->m_len - moff) { 64350942Ssklower if (m->m_flags & M_EOR) 64450942Ssklower flags |= MSG_EOR; 64525629Skarels if (flags & MSG_PEEK) { 64625629Skarels m = m->m_next; 64725629Skarels moff = 0; 64825629Skarels } else { 64935384Skarels nextrecord = m->m_nextpkt; 65025629Skarels sbfree(&so->so_rcv, m); 65141908Skarels if (mp) { 65241908Skarels *mp = m; 65341908Skarels mp = &m->m_next; 65443417Skarels so->so_rcv.sb_mb = m = m->m_next; 65543417Skarels *mp = (struct mbuf *)0; 65641908Skarels } else { 65741908Skarels MFREE(m, so->so_rcv.sb_mb); 65841908Skarels m = so->so_rcv.sb_mb; 65941908Skarels } 66026958Skarels if (m) 66135384Skarels m->m_nextpkt = nextrecord; 66225629Skarels } 6634786Swnj } else { 66412757Ssam if (flags & MSG_PEEK) 6658319Sroot moff += len; 6668319Sroot else { 66743417Skarels if (mp) 66843417Skarels *mp = m_copym(m, 0, len, M_WAIT); 66935384Skarels m->m_data += len; 6708319Sroot m->m_len -= len; 6718319Sroot so->so_rcv.sb_cc -= len; 6728319Sroot } 6734786Swnj } 67432092Skarels if (so->so_oobmark) { 67532092Skarels if ((flags & MSG_PEEK) == 0) { 67632092Skarels so->so_oobmark -= len; 67732092Skarels if (so->so_oobmark == 0) { 67832092Skarels so->so_state |= SS_RCVATMARK; 67932092Skarels break; 68032092Skarels } 68132092Skarels } else 68232092Skarels offset += len; 6837747Sroot } 68450942Ssklower if (flags & MSG_EOR) 68540632Skarels break; 68641908Skarels /* 68741908Skarels * If the MSG_WAITALL flag is set (for non-atomic socket), 68843417Skarels * we must not quit until "uio->uio_resid == 0" or an error 68941908Skarels * termination. If a signal/timeout occurs, return 69043417Skarels * with a short count but without error. 69141908Skarels * Keep sockbuf locked against other readers. 69241908Skarels */ 69343417Skarels while (flags & MSG_WAITALL && m == 0 && uio->uio_resid > 0 && 69450942Ssklower !sosendallatonce(so)) { 69546479Skarels if (so->so_error || so->so_state & SS_CANTRCVMORE) 69646479Skarels break; 69741908Skarels error = sbwait(&so->so_rcv); 69841908Skarels if (error) { 69941908Skarels sbunlock(&so->so_rcv); 70041908Skarels splx(s); 70141908Skarels return (0); 70241908Skarels } 70350942Ssklower if (m = so->so_rcv.sb_mb) 70441908Skarels nextrecord = m->m_nextpkt; 70541908Skarels } 70616993Skarels } 70716993Skarels if ((flags & MSG_PEEK) == 0) { 70826500Skarels if (m == 0) 70916993Skarels so->so_rcv.sb_mb = nextrecord; 71035384Skarels else if (pr->pr_flags & PR_ATOMIC) { 71135384Skarels flags |= MSG_TRUNC; 71226958Skarels (void) sbdroprecord(&so->so_rcv); 71335384Skarels } 71416993Skarels if (pr->pr_flags & PR_WANTRCVD && so->so_pcb) 71516993Skarels (*pr->pr_usrreq)(so, PRU_RCVD, (struct mbuf *)0, 71637478Ssklower (struct mbuf *)flags, (struct mbuf *)0, 71737478Ssklower (struct mbuf *)0); 71816993Skarels } 71935384Skarels if (flagsp) 72035384Skarels *flagsp |= flags; 7214890Swnj release: 7224916Swnj sbunlock(&so->so_rcv); 7234890Swnj splx(s); 7244916Swnj return (error); 7254786Swnj } 7264786Swnj 72710267Ssam soshutdown(so, how) 72812757Ssam register struct socket *so; 72912757Ssam register int how; 73010267Ssam { 73112757Ssam register struct protosw *pr = so->so_proto; 73210267Ssam 73310267Ssam how++; 73412757Ssam if (how & FREAD) 73512757Ssam sorflush(so); 73610267Ssam if (how & FWRITE) 73712757Ssam return ((*pr->pr_usrreq)(so, PRU_SHUTDOWN, 73812757Ssam (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0)); 73910267Ssam return (0); 74010267Ssam } 74110267Ssam 74212757Ssam sorflush(so) 74312757Ssam register struct socket *so; 74412757Ssam { 74512757Ssam register struct sockbuf *sb = &so->so_rcv; 74612757Ssam register struct protosw *pr = so->so_proto; 74712757Ssam register int s; 74812757Ssam struct sockbuf asb; 74912757Ssam 75040706Skarels sb->sb_flags |= SB_NOINTR; 75151755Smckusick (void) sblock(sb, M_WAITOK); 75212757Ssam s = splimp(); 75312757Ssam socantrcvmore(so); 75412757Ssam sbunlock(sb); 75512757Ssam asb = *sb; 75612757Ssam bzero((caddr_t)sb, sizeof (*sb)); 75712757Ssam splx(s); 75816993Skarels if (pr->pr_flags & PR_RIGHTS && pr->pr_domain->dom_dispose) 75916993Skarels (*pr->pr_domain->dom_dispose)(asb.sb_mb); 76012757Ssam sbrelease(&asb); 76112757Ssam } 76212757Ssam 76318553Skarels sosetopt(so, level, optname, m0) 76412757Ssam register struct socket *so; 76510267Ssam int level, optname; 76618553Skarels struct mbuf *m0; 76710267Ssam { 76817158Ssam int error = 0; 76918553Skarels register struct mbuf *m = m0; 77010267Ssam 77117158Ssam if (level != SOL_SOCKET) { 77218369Skarels if (so->so_proto && so->so_proto->pr_ctloutput) 77318369Skarels return ((*so->so_proto->pr_ctloutput) 77418553Skarels (PRCO_SETOPT, so, level, optname, &m0)); 77518369Skarels error = ENOPROTOOPT; 77618369Skarels } else { 77718369Skarels switch (optname) { 77810267Ssam 77918369Skarels case SO_LINGER: 78018369Skarels if (m == NULL || m->m_len != sizeof (struct linger)) { 78118369Skarels error = EINVAL; 78218369Skarels goto bad; 78318369Skarels } 78418369Skarels so->so_linger = mtod(m, struct linger *)->l_linger; 78518369Skarels /* fall thru... */ 78617158Ssam 78718369Skarels case SO_DEBUG: 78818369Skarels case SO_KEEPALIVE: 78918369Skarels case SO_DONTROUTE: 79018369Skarels case SO_USELOOPBACK: 79118369Skarels case SO_BROADCAST: 79218369Skarels case SO_REUSEADDR: 79355349Ssklower case SO_REUSEPORT: 79427191Skarels case SO_OOBINLINE: 79518369Skarels if (m == NULL || m->m_len < sizeof (int)) { 79618369Skarels error = EINVAL; 79718369Skarels goto bad; 79818369Skarels } 79918369Skarels if (*mtod(m, int *)) 80018369Skarels so->so_options |= optname; 80118369Skarels else 80218369Skarels so->so_options &= ~optname; 80318369Skarels break; 80418369Skarels 80518369Skarels case SO_SNDBUF: 80641908Skarels case SO_RCVBUF: 80740706Skarels case SO_SNDLOWAT: 80841908Skarels case SO_RCVLOWAT: 80918369Skarels if (m == NULL || m->m_len < sizeof (int)) { 81018369Skarels error = EINVAL; 81118369Skarels goto bad; 81218369Skarels } 81318369Skarels switch (optname) { 81418369Skarels 81518369Skarels case SO_SNDBUF: 81618369Skarels case SO_RCVBUF: 81741908Skarels if (sbreserve(optname == SO_SNDBUF ? 81841908Skarels &so->so_snd : &so->so_rcv, 81941908Skarels (u_long) *mtod(m, int *)) == 0) { 82018369Skarels error = ENOBUFS; 82118369Skarels goto bad; 82218369Skarels } 82318369Skarels break; 82418369Skarels 82518369Skarels case SO_SNDLOWAT: 82641908Skarels so->so_snd.sb_lowat = *mtod(m, int *); 82741908Skarels break; 82818369Skarels case SO_RCVLOWAT: 82941908Skarels so->so_rcv.sb_lowat = *mtod(m, int *); 83018369Skarels break; 83144721Skarels } 83244721Skarels break; 83344721Skarels 83444721Skarels case SO_SNDTIMEO: 83544721Skarels case SO_RCVTIMEO: 83644721Skarels { 83744721Skarels struct timeval *tv; 83844721Skarels short val; 83944721Skarels 84044721Skarels if (m == NULL || m->m_len < sizeof (*tv)) { 84144721Skarels error = EINVAL; 84244721Skarels goto bad; 84344721Skarels } 84444721Skarels tv = mtod(m, struct timeval *); 84544721Skarels if (tv->tv_sec > SHRT_MAX / hz - hz) { 84644721Skarels error = EDOM; 84744721Skarels goto bad; 84844721Skarels } 84944721Skarels val = tv->tv_sec * hz + tv->tv_usec / tick; 85044721Skarels 85144721Skarels switch (optname) { 85244721Skarels 85318369Skarels case SO_SNDTIMEO: 85444721Skarels so->so_snd.sb_timeo = val; 85541908Skarels break; 85618369Skarels case SO_RCVTIMEO: 85744721Skarels so->so_rcv.sb_timeo = val; 85818369Skarels break; 85918369Skarels } 86018369Skarels break; 86144721Skarels } 86218369Skarels 86318369Skarels default: 86418369Skarels error = ENOPROTOOPT; 86518369Skarels break; 86617158Ssam } 86751022Ssklower m = 0; 86850942Ssklower if (error == 0 && so->so_proto && so->so_proto->pr_ctloutput) 86950942Ssklower (void) ((*so->so_proto->pr_ctloutput) 87050942Ssklower (PRCO_SETOPT, so, level, optname, &m0)); 87110267Ssam } 87217158Ssam bad: 87317158Ssam if (m) 87417158Ssam (void) m_free(m); 87517158Ssam return (error); 87610267Ssam } 87710267Ssam 87817158Ssam sogetopt(so, level, optname, mp) 87912757Ssam register struct socket *so; 88010267Ssam int level, optname; 88117158Ssam struct mbuf **mp; 88217158Ssam { 88312757Ssam register struct mbuf *m; 88410267Ssam 88518369Skarels if (level != SOL_SOCKET) { 88618369Skarels if (so->so_proto && so->so_proto->pr_ctloutput) { 88718369Skarels return ((*so->so_proto->pr_ctloutput) 88818369Skarels (PRCO_GETOPT, so, level, optname, mp)); 88945515Skarels } else 89018369Skarels return (ENOPROTOOPT); 89118369Skarels } else { 89217158Ssam m = m_get(M_WAIT, MT_SOOPTS); 89325502Skarels m->m_len = sizeof (int); 89425502Skarels 89518369Skarels switch (optname) { 89617158Ssam 89718369Skarels case SO_LINGER: 89818369Skarels m->m_len = sizeof (struct linger); 89918369Skarels mtod(m, struct linger *)->l_onoff = 90018369Skarels so->so_options & SO_LINGER; 90118369Skarels mtod(m, struct linger *)->l_linger = so->so_linger; 90218369Skarels break; 90310267Ssam 90418369Skarels case SO_USELOOPBACK: 90518369Skarels case SO_DONTROUTE: 90618369Skarels case SO_DEBUG: 90718369Skarels case SO_KEEPALIVE: 90818369Skarels case SO_REUSEADDR: 90955349Ssklower case SO_REUSEPORT: 91018369Skarels case SO_BROADCAST: 91127191Skarels case SO_OOBINLINE: 91218369Skarels *mtod(m, int *) = so->so_options & optname; 91318369Skarels break; 91418369Skarels 91525502Skarels case SO_TYPE: 91625502Skarels *mtod(m, int *) = so->so_type; 91725502Skarels break; 91825502Skarels 91924768Skarels case SO_ERROR: 92024768Skarels *mtod(m, int *) = so->so_error; 92124768Skarels so->so_error = 0; 92224768Skarels break; 92324768Skarels 92418369Skarels case SO_SNDBUF: 92518369Skarels *mtod(m, int *) = so->so_snd.sb_hiwat; 92618369Skarels break; 92718369Skarels 92818369Skarels case SO_RCVBUF: 92918369Skarels *mtod(m, int *) = so->so_rcv.sb_hiwat; 93018369Skarels break; 93118369Skarels 93218369Skarels case SO_SNDLOWAT: 93318369Skarels *mtod(m, int *) = so->so_snd.sb_lowat; 93418369Skarels break; 93518369Skarels 93618369Skarels case SO_RCVLOWAT: 93718369Skarels *mtod(m, int *) = so->so_rcv.sb_lowat; 93818369Skarels break; 93918369Skarels 94018369Skarels case SO_SNDTIMEO: 94144721Skarels case SO_RCVTIMEO: 94244721Skarels { 94344721Skarels int val = (optname == SO_SNDTIMEO ? 94444721Skarels so->so_snd.sb_timeo : so->so_rcv.sb_timeo); 94518369Skarels 94644721Skarels m->m_len = sizeof(struct timeval); 94744721Skarels mtod(m, struct timeval *)->tv_sec = val / hz; 94844721Skarels mtod(m, struct timeval *)->tv_usec = 94944721Skarels (val % hz) / tick; 95018369Skarels break; 95144721Skarels } 95218369Skarels 95318369Skarels default: 95426362Skarels (void)m_free(m); 95518369Skarels return (ENOPROTOOPT); 95618369Skarels } 95718369Skarels *mp = m; 95818369Skarels return (0); 95910267Ssam } 96010267Ssam } 96110267Ssam 9625423Swnj sohasoutofband(so) 96312757Ssam register struct socket *so; 9645423Swnj { 96523233Skarels struct proc *p; 9665423Swnj 96737478Ssklower if (so->so_pgid < 0) 96837478Ssklower gsignal(-so->so_pgid, SIGURG); 96937478Ssklower else if (so->so_pgid > 0 && (p = pfind(so->so_pgid)) != 0) 97023233Skarels psignal(p, SIGURG); 97152526Smckusick selwakeup(&so->so_rcv.sb_sel); 9725423Swnj } 973