![[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: }