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