![[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 [Apple XNU] / XNU / bsd / kern|
Return to uipc_socket.c CVS log | Up to [Apple XNU] / XNU / bsd / kern |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /* Copyright (c) 1998, 1999 Apple Computer, Inc. All Rights Reserved */
23: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
24: /*
25: * Copyright (c) 1982, 1986, 1988, 1990, 1993
26: * The Regents of the University of California. All rights reserved.
27: *
28: * Redistribution and use in source and binary forms, with or without
29: * modification, are permitted provided that the following conditions
30: * are met:
31: * 1. Redistributions of source code must retain the above copyright
32: * notice, this list of conditions and the following disclaimer.
33: * 2. Redistributions in binary form must reproduce the above copyright
34: * notice, this list of conditions and the following disclaimer in the
35: * documentation and/or other materials provided with the distribution.
36: * 3. All advertising materials mentioning features or use of this software
37: * must display the following acknowledgement:
38: * This product includes software developed by the University of
39: * California, Berkeley and its contributors.
40: * 4. Neither the name of the University nor the names of its contributors
41: * may be used to endorse or promote products derived from this software
42: * without specific prior written permission.
43: *
44: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
45: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
46: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
47: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
48: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
49: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
50: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
51: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
52: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
53: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
54: * SUCH DAMAGE.
55: *
56: * @(#)uipc_socket.c 8.6 (Berkeley) 5/2/95
57: */
58:
59: #include <sys/param.h>
60: #include <sys/systm.h>
61: #include <sys/proc.h>
62: #include <sys/fcntl.h>
63: #include <sys/malloc.h>
64: #include <sys/mbuf.h>
65: #include <sys/domain.h>
66: #include <sys/kernel.h>
67: #include <sys/poll.h>
68: #include <sys/protosw.h>
69: #include <sys/socket.h>
70: #include <sys/socketvar.h>
71: #include <sys/resourcevar.h>
72: #include <sys/signalvar.h>
73: #include <sys/sysctl.h>
74: #include <sys/uio.h>
75: #include <sys/ev.h>
76: #include <sys/kdebug.h>
77:
78: #if ISFB31
79: #include <vm/vm_zone.h>
80: #else
81: #include <kern/zalloc.h>
82: #endif
83:
84: #include <machine/limits.h>
85:
86: int socket_debug = 0;
87: int socket_zone = M_SOCKET;
88: so_gen_t so_gencnt; /* generation count for sockets */
89:
90: MALLOC_DEFINE(M_SONAME, "soname", "socket name");
91: MALLOC_DEFINE(M_PCB, "pcb", "protocol control block");
92:
93: #if KDEBUG
94: #define DBG_LAYER_IN_BEG NETDBG_CODE(DBG_NETSOCK, 0)
95: #define DBG_LAYER_IN_END NETDBG_CODE(DBG_NETSOCK, 2)
96: #define DBG_LAYER_OUT_BEG NETDBG_CODE(DBG_NETSOCK, 1)
97: #define DBG_LAYER_OUT_END NETDBG_CODE(DBG_NETSOCK, 3)
98: #define DBG_FNC_SOSEND NETDBG_CODE(DBG_NETSOCK, (4 << 8) | 1)
99: #define DBG_FNC_SORECEIVE NETDBG_CODE(DBG_NETSOCK, (8 << 8))
100: #endif
101:
102: SYSCTL_DECL(_kern_ipc);
103:
104: static int somaxconn = SOMAXCONN;
105: SYSCTL_INT(_kern_ipc, KIPC_SOMAXCONN, somaxconn, CTLFLAG_RW, &somaxconn,
106: 0, "");
107:
108: /*
109: * Socket operation routines.
110: * These routines are called by the routines in
111: * sys_socket.c or from a system process, and
112: * implement the semantics of socket operations by
113: * switching out to the protocol specific routines.
114: */
115:
116: void socketinit()
117: {
118: }
119:
120:
121: /*
122: * Get a socket structure from our zone, and initialize it.
123: * We don't implement `waitok' yet (see comments in uipc_domain.c).
124: * Note that it would probably be better to allocate socket
125: * and PCB at the same time, but I'm not convinced that all
126: * the protocols can be easily modified to do this.
127: */
128: struct socket *
129: soalloc(waitok)
130: int waitok;
131: {
132: struct socket *so;
133:
134: so = _MALLOC_ZONE(sizeof(*so), socket_zone, M_WAITOK);
135: if (so) {
136: /* XXX race condition for reentrant kernel */
137: bzero(so, sizeof *so);
138: so->so_gencnt = ++so_gencnt;
139: so->so_zone = socket_zone;
140: }
141: return so;
142: }
143:
144: int
145: socreate(dom, aso, type, proto)
146: int dom;
147: struct socket **aso;
148: register int type;
149: int proto;
150:
151: {
152: struct proc *p = current_proc();
153: register struct protosw *prp;
154: struct socket *so;
155: register int error = 0;
156:
157: if (proto)
158: prp = pffindproto(dom, proto, type);
159: else
160: prp = pffindtype(dom, type);
161: if (prp == 0 || prp->pr_usrreqs->pru_attach == 0)
162: return (EPROTONOSUPPORT);
163: if (prp->pr_type != type)
164: return (EPROTOTYPE);
165: so = soalloc(p != 0);
166: if (so == 0)
167: return (ENOBUFS);
168:
169: TAILQ_INIT(&so->so_incomp);
170: TAILQ_INIT(&so->so_comp);
171: so->so_type = type;
172:
173: if (p != 0) {
174: if (p->p_ucred->cr_uid == 0)
175: so->so_state = SS_PRIV;
176:
177: so->so_uid = p->p_ucred->cr_uid;
178: }
179:
180: so->so_proto = prp;
181: so->so_rcv.sb_flags |= SB_RECV; /* XXX */
182: if (prp->pr_sfilter.tqh_first)
183: error = sfilter_init(so);
184: if (error == 0)
185: error = (*prp->pr_usrreqs->pru_attach)(so, proto, p);
186:
187: if (error) {
188: so->so_state |= SS_NOFDREF;
189: sofree(so);
190: return (error);
191: }
192: prp->pr_domain->dom_refs++;
193: so->so_rcv.sb_so = so->so_snd.sb_so = so;
194: TAILQ_INIT(&so->so_evlist);
195: *aso = so;
196: return (0);
197: }
198:
199: int
200: sobind(so, nam)
201: struct socket *so;
202: struct sockaddr *nam;
203:
204: {
205: struct proc *p = current_proc();
206: int error;
207: struct kextcb *kp;
208: int s = splnet();
209:
210: error = (*so->so_proto->pr_usrreqs->pru_bind)(so, nam, p);
211: if (error == 0) /* ??? */
212: { kp = sotokextcb(so);
213: while (kp)
214: { if (kp->e_soif && kp->e_soif->sf_sobind)
215: { error = (*kp->e_soif->sf_sobind)(so, nam, kp);
216: if (error)
217: { if (error == EJUSTRETURN)
218: break;
219: splx(s);
220: return(error);
221: }
222: }
223: kp = kp->e_next;
224: }
225: }
226: splx(s);
227: return (error);
228: }
229:
230: void
231: sodealloc(so)
232: struct socket *so;
233: {
234: so->so_gencnt = ++so_gencnt;
235: _FREE_ZONE(so, sizeof(*so), so->so_zone);
236: }
237:
238: int
239: solisten(so, backlog)
240: register struct socket *so;
241: int backlog;
242:
243: {
244: struct kextcb *kp;
245: struct proc *p = current_proc();
246: int s, error;
247:
248: s = splnet();
249: error = (*so->so_proto->pr_usrreqs->pru_listen)(so, p);
250: if (error) {
251: splx(s);
252: return (error);
253: }
254: if (so->so_comp.tqh_first == NULL)
255: so->so_options |= SO_ACCEPTCONN;
256: if (backlog < 0 || backlog > somaxconn)
257: backlog = somaxconn;
258: so->so_qlimit = backlog;
259: kp = sotokextcb(so);
260: while (kp)
261: {
262: if (kp->e_soif && kp->e_soif->sf_solisten)
263: { error = (*kp->e_soif->sf_solisten)(so, kp);
264: if (error)
265: { if (error == EJUSTRETURN)
266: break;
267: splx(s);
268: return(error);
269: }
270: }
271: kp = kp->e_next;
272: }
273:
274: splx(s);
275: return (0);
276: }
277:
278:
279: void
280: sofree(so)
281: register struct socket *so;
282: { int error;
283: struct kextcb *kp;
284: struct socket *head = so->so_head;
285:
286: kp = sotokextcb(so);
287: while (kp)
288: { if (kp->e_soif && kp->e_soif->sf_sofree)
289: { error = (*kp->e_soif->sf_sofree)(so, kp);
290: if (error)
291: return; /* void fn */
292: }
293: kp = kp->e_next;
294: }
295:
296: if (so->so_pcb || (so->so_state & SS_NOFDREF) == 0)
297: return;
298: if (head != NULL) {
299: if (so->so_state & SS_INCOMP) {
300: TAILQ_REMOVE(&head->so_incomp, so, so_list);
301: head->so_incqlen--;
302: } else if (so->so_state & SS_COMP) {
303: TAILQ_REMOVE(&head->so_comp, so, so_list);
304: } else {
305: panic("sofree: not queued");
306: }
307: head->so_qlen--;
308: so->so_state &= ~(SS_INCOMP|SS_COMP);
309: so->so_head = NULL;
310: }
311:
312: sbrelease(&so->so_snd);
313: sorflush(so);
314: sfilter_term(so);
315: sodealloc(so);
316: }
317:
318: /*
319: * Close a socket on last file table reference removal.
320: * Initiate disconnect if connected.
321: * Free socket when disconnect complete.
322: */
323: int
324: soclose(so)
325: register struct socket *so;
326: {
327: int s = splnet(); /* conservative */
328: int error = 0;
329: struct kextcb *kp;
330:
331: #if FB31SIG
332: funsetown(so->so_pgid);
333: #endif
334: kp = sotokextcb(so);
335: while (kp)
336: { if (kp->e_soif && kp->e_soif->sf_soclose)
337: { error = (*kp->e_soif->sf_soclose)(so, kp);
338: if (error)
339: { splx(s);
340: return((error == EJUSTRETURN) ? 0 : error);
341: }
342: }
343: kp = kp->e_next;
344: }
345:
346: if (so->so_options & SO_ACCEPTCONN) {
347: struct socket *sp, *sonext;
348:
349: for (sp = so->so_incomp.tqh_first; sp != NULL; sp = sonext) {
350: sonext = sp->so_list.tqe_next;
351: (void) soabort(sp);
352: }
353: for (sp = so->so_comp.tqh_first; sp != NULL; sp = sonext) {
354: sonext = sp->so_list.tqe_next;
355: (void) soabort(sp);
356: }
357: }
358: if (so->so_pcb == 0)
359: goto discard;
360: if (so->so_state & SS_ISCONNECTED) {
361: if ((so->so_state & SS_ISDISCONNECTING) == 0) {
362: error = sodisconnect(so);
363: if (error)
364: goto drop;
365: }
366: if (so->so_options & SO_LINGER) {
367: if ((so->so_state & SS_ISDISCONNECTING) &&
368: (so->so_state & SS_NBIO))
369: goto drop;
370: while (so->so_state & SS_ISCONNECTED) {
371: error = tsleep((caddr_t)&so->so_timeo,
372: PSOCK | PCATCH, "soclos", so->so_linger);
373: if (error)
374: break;
375: }
376: }
377: }
378: drop:
379: if (so->so_pcb) {
380: int error2 = (*so->so_proto->pr_usrreqs->pru_detach)(so);
381: if (error == 0)
382: error = error2;
383: }
384: discard:
385: if (so->so_state & SS_NOFDREF)
386: panic("soclose: NOFDREF");
387: so->so_state |= SS_NOFDREF;
388: so->so_proto->pr_domain->dom_refs--;
389: evsofree(so);
390: sofree(so);
391: splx(s);
392: return (error);
393: }
394:
395: /*
396: * Must be called at splnet...
397: */
398: int
399: soabort(so)
400: struct socket *so;
401: {
402:
403: return (*so->so_proto->pr_usrreqs->pru_abort)(so);
404: }
405:
406: int
407: soaccept(so, nam)
408: register struct socket *so;
409: struct sockaddr **nam;
410: { int s = splnet();
411: int error;
412: struct kextcb *kp;
413:
414: if ((so->so_state & SS_NOFDREF) == 0)
415: panic("soaccept: !NOFDREF");
416: so->so_state &= ~SS_NOFDREF;
417: error = (*so->so_proto->pr_usrreqs->pru_accept)(so, nam);
418: if (error == 0)
419: { kp = sotokextcb(so);
420: while (kp) {
421: if (kp->e_soif && kp->e_soif->sf_soaccept)
422: { error = (*kp->e_soif->sf_soaccept)(so, nam, kp);
423: if (error)
424: { if (error == EJUSTRETURN)
425: break;
426: splx(s);
427: return(error);
428: }
429: }
430: kp = kp->e_next;
431: }
432: }
433:
434:
435: splx(s);
436: return (error);
437: }
438:
439: int
440: soconnect(so, nam)
441: register struct socket *so;
442: struct sockaddr *nam;
443:
444: {
445: int s;
446: int error;
447: struct proc *p = current_proc();
448: struct kextcb *kp;
449:
450: if (so->so_options & SO_ACCEPTCONN)
451: return (EOPNOTSUPP);
452: s = splnet();
453: /*
454: * If protocol is connection-based, can only connect once.
455: * Otherwise, if connected, try to disconnect first.
456: * This allows user to disconnect by connecting to, e.g.,
457: * a null address.
458: */
459: if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING) &&
460: ((so->so_proto->pr_flags & PR_CONNREQUIRED) ||
461: (error = sodisconnect(so))))
462: error = EISCONN;
463: else {
464: error = (*so->so_proto->pr_usrreqs->pru_connect)(so, nam, p);
465: if (error == 0)
466: {
467: kp = sotokextcb(so);
468: while (kp)
469: {
470: if (kp->e_soif && kp->e_soif->sf_soconnect)
471: { error = (*kp->e_soif->sf_soconnect)(so, nam, kp);
472: if (error)
473: { if (error == EJUSTRETURN)
474: break;
475: splx(s);
476: return(error);
477: }
478: }
479: kp = kp->e_next;
480: }
481: }
482: }
483:
484: splx(s);
485: return (error);
486: }
487:
488: int
489: soconnect2(so1, so2)
490: register struct socket *so1;
491: struct socket *so2;
492: {
493: int s = splnet();
494: int error;
495: struct kextcb *kp;
496:
497: error = (*so1->so_proto->pr_usrreqs->pru_connect2)(so1, so2);
498: if (error == 0)
499: { kp = sotokextcb(so1);
500: while (kp)
501: { if (kp->e_soif && kp->e_soif->sf_soconnect2)
502: { error = (*kp->e_soif->sf_soconnect2)(so1, so2, kp);
503: if (error)
504: { if (error == EJUSTRETURN)
505: break;
506: splx(s);
507: return(error);
508: }
509: }
510: kp = kp->e_next;
511: }
512: }
513: splx(s);
514: return (error);
515: }
516:
517: int
518: sodisconnect(so)
519: register struct socket *so;
520: {
521: int s = splnet();
522: int error;
523: struct kextcb *kp;
524:
525: if ((so->so_state & SS_ISCONNECTED) == 0) {
526: error = ENOTCONN;
527: goto bad;
528: }
529: if (so->so_state & SS_ISDISCONNECTING) {
530: error = EALREADY;
531: goto bad;
532: }
533: error = (*so->so_proto->pr_usrreqs->pru_disconnect)(so);
534:
535: if (error == 0)
536: { kp = sotokextcb(so);
537: while (kp)
538: { if (kp->e_soif && kp->e_soif->sf_sodisconnect)
539: { error = (*kp->e_soif->sf_sodisconnect)(so, kp);
540: if (error)
541: { if (error == EJUSTRETURN)
542: break;
543: splx(s);
544: return(error);
545: }
546: }
547: kp = kp->e_next;
548: }
549: }
550:
551: bad:
552: splx(s);
553: return (error);
554: }
555:
556: #define SBLOCKWAIT(f) (((f) & MSG_DONTWAIT) ? M_DONTWAIT : M_WAIT)
557: /*
558: * Send on a socket.
559: * If send must go all at once and message is larger than
560: * send buffering, then hard error.
561: * Lock against other senders.
562: * If must go all at once and not enough room now, then
563: * inform user that this would block and do nothing.
564: * Otherwise, if nonblocking, send as much as possible.
565: * The data to be sent is described by "uio" if nonzero,
566: * otherwise by the mbuf chain "top" (which must be null
567: * if uio is not). Data provided in mbuf chain must be small
568: * enough to send all at once.
569: *
570: * Returns nonzero on error, timeout or signal; callers
571: * must check for short counts if EINTR/ERESTART are returned.
572: * Data and control buffers are freed on return.
573: * Experiment:
574: * MSG_HOLD: go thru most of sosend(), but just enqueue the mbuf
575: * MSG_SEND: go thru as for MSG_HOLD on current fragment, then
576: * point at the mbuf chain being constructed and go from there.
577: */
578: int
579: sosend(so, addr, uio, top, control, flags)
580: register struct socket *so;
581: struct sockaddr *addr;
582: struct uio *uio;
583: struct mbuf *top;
584: struct mbuf *control;
585: int flags;
586:
587: {
588: struct mbuf **mp;
589: register struct mbuf *m;
590: register long space, len, resid;
591: int clen = 0, error, s, dontroute, mlen, sendflags;
592: int atomic = sosendallatonce(so) || top;
593: struct proc *p = current_proc();
594: struct kextcb *kp;
595:
596: if (uio)
597: resid = uio->uio_resid;
598: else
599: resid = top->m_pkthdr.len;
600:
601: KERNEL_DEBUG((DBG_FNC_SOSEND | DBG_FUNC_START),
602: so,
603: resid,
604: so->so_snd.sb_cc,
605: so->so_snd.sb_lowat,
606: so->so_snd.sb_hiwat);
607:
608: /*
609: * In theory resid should be unsigned.
610: * However, space must be signed, as it might be less than 0
611: * if we over-committed, and we must use a signed comparison
612: * of space and resid. On the other hand, a negative resid
613: * causes us to loop sending 0-length segments to the protocol.
614: *
615: * Also check to make sure that MSG_EOR isn't used on SOCK_STREAM
616: * type sockets since that's an error.
617: */
618: if (resid < 0 || so->so_type == SOCK_STREAM && (flags & MSG_EOR)) {
619: error = EINVAL;
620: goto out;
621: }
622:
623: dontroute =
624: (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 &&
625: (so->so_proto->pr_flags & PR_ATOMIC);
626: if (p)
627: p->p_stats->p_ru.ru_msgsnd++;
628: if (control)
629: clen = control->m_len;
630: #define snderr(errno) { error = errno; splx(s); goto release; }
631:
632: restart:
633: error = sblock(&so->so_snd, SBLOCKWAIT(flags));
634: if (error)
635: goto out;
636: do {
637: s = splnet();
638: if (so->so_state & SS_CANTSENDMORE)
639: snderr(EPIPE);
640: if (so->so_error) {
641: error = so->so_error;
642: so->so_error = 0;
643: splx(s);
644: goto release;
645: }
646: if ((so->so_state & SS_ISCONNECTED) == 0) {
647: /*
648: * `sendto' and `sendmsg' is allowed on a connection-
649: * based socket if it supports implied connect.
650: * Return ENOTCONN if not connected and no address is
651: * supplied.
652: */
653: if ((so->so_proto->pr_flags & PR_CONNREQUIRED) &&
654: (so->so_proto->pr_flags & PR_IMPLOPCL) == 0) {
655: if ((so->so_state & SS_ISCONFIRMING) == 0 &&
656: !(resid == 0 && clen != 0))
657: snderr(ENOTCONN);
658: } else if (addr == 0 && !(flags&MSG_HOLD))
659: snderr(so->so_proto->pr_flags & PR_CONNREQUIRED ?
660: ENOTCONN : EDESTADDRREQ);
661: }
662: space = sbspace(&so->so_snd);
663: if (flags & MSG_OOB)
664: space += 1024;
665: if ((atomic && resid > so->so_snd.sb_hiwat) ||
666: clen > so->so_snd.sb_hiwat)
667: snderr(EMSGSIZE);
668: if (space < resid + clen && uio &&
669: (atomic || space < so->so_snd.sb_lowat || space < clen)) {
670: if (so->so_state & SS_NBIO)
671: snderr(EWOULDBLOCK);
672: sbunlock(&so->so_snd);
673: error = sbwait(&so->so_snd);
674: splx(s);
675: if (error)
676: goto out;
677: goto restart;
678: }
679: splx(s);
680: mp = ⊤
681: space -= clen;
682: do {
683: if (uio == NULL) {
684: /*
685: * Data is prepackaged in "top".
686: */
687: resid = 0;
688: if (flags & MSG_EOR)
689: top->m_flags |= M_EOR;
690: } else do {
691: KERNEL_DEBUG(DBG_FNC_SOSEND | DBG_FUNC_NONE, -1, 0, 0, 0, 0);
692: if (top == 0) {
693: MGETHDR(m, M_WAIT, MT_DATA);
694: mlen = MHLEN;
695: m->m_pkthdr.len = 0;
696: m->m_pkthdr.rcvif = (struct ifnet *)0;
697: } else {
698: MGET(m, M_WAIT, MT_DATA);
699: mlen = MLEN;
700: }
701: if (resid >= MINCLSIZE) {
702: MCLGET(m, M_WAIT);
703: if ((m->m_flags & M_EXT) == 0)
704: goto nopages;
705: mlen = MCLBYTES;
706: len = min(min(mlen, resid), space);
707: } else {
708: nopages:
709: len = min(min(mlen, resid), space);
710: /*
711: * For datagram protocols, leave room
712: * for protocol headers in first mbuf.
713: */
714: if (atomic && top == 0 && len < mlen)
715: MH_ALIGN(m, len);
716: }
717: KERNEL_DEBUG(DBG_FNC_SOSEND | DBG_FUNC_NONE, -1, 0, 0, 0, 0);
718: space -= len;
719: error = uiomove(mtod(m, caddr_t), (int)len, uio);
720: resid = uio->uio_resid;
721:
722: m->m_len = len;
723: *mp = m;
724: top->m_pkthdr.len += len;
725: if (error)
726: goto release;
727: mp = &m->m_next;
728: if (resid <= 0) {
729: if (flags & MSG_EOR)
730: top->m_flags |= M_EOR;
731: break;
732: }
733: } while (space > 0 && (atomic || resid < MINCLSIZE));
734:
735: if (flags & (MSG_HOLD|MSG_SEND))
736: { /* Enqueue for later, go away if HOLD */
737: register struct mbuf *mb1;
738: if (so->so_temp && (flags & MSG_FLUSH))
739: { m_freem(so->so_temp);
740: so->so_temp = NULL;
741: }
742: if (so->so_temp)
743: so->so_tail->m_next = top;
744: else
745: so->so_temp = top;
746: mb1 = top;
747: while (mb1->m_next)
748: mb1 = mb1->m_next;
749: so->so_tail = mb1;
750: if (flags&MSG_HOLD)
751: { top = NULL;
752: goto release;
753: }
754: top = so->so_temp;
755: }
756: if (dontroute)
757: so->so_options |= SO_DONTROUTE;
758: s = splnet(); /* XXX */
759: kp = sotokextcb(so);
760: /* Compute flags here, for pru_send and NKEs */
761: sendflags = (flags & MSG_OOB) ? PRUS_OOB :
762: /*
763: * If the user set MSG_EOF, the protocol
764: * understands this flag and nothing left to
765: * send then use PRU_SEND_EOF instead of PRU_SEND.
766: */
767: ((flags & MSG_EOF) &&
768: (so->so_proto->pr_flags & PR_IMPLOPCL) &&
769: (resid <= 0)) ?
770: PRUS_EOF :
771: /* If there is more to send set PRUS_MORETOCOME */
772: (resid > 0 && space > 0) ? PRUS_MORETOCOME : 0;
773: while (kp)
774: { if (kp->e_soif && kp->e_soif->sf_sosend)
775: { error = (*kp->e_soif->sf_sosend)(so, &addr,
776: &uio, &top,
777: &control,
778: &sendflags,
779: kp);
780: if (error)
781: { if (error == EJUSTRETURN)
782: { sbunlock(&so->so_snd);
783: return(0);
784: }
785: goto release;
786: }
787: }
788: kp = kp->e_next;
789: }
790:
791: error = (*so->so_proto->pr_usrreqs->pru_send)(so,
792: sendflags, top, addr, control, p);
793: splx(s);
794: if (flags & MSG_SEND)
795: so->so_temp = NULL;
796:
797: if (dontroute)
798: so->so_options &= ~SO_DONTROUTE;
799: clen = 0;
800: control = 0;
801: top = 0;
802: mp = ⊤
803: if (error)
804: goto release;
805: } while (resid && space > 0);
806: } while (resid);
807:
808: release:
809: sbunlock(&so->so_snd);
810: out:
811: if (top)
812: m_freem(top);
813: if (control)
814: m_freem(control);
815:
816: KERNEL_DEBUG(DBG_FNC_SOSEND | DBG_FUNC_END,
817: so,
818: resid,
819: so->so_snd.sb_cc,
820: space,
821: error);
822:
823: return (error);
824: }
825:
826: /*
827: * Implement receive operations on a socket.
828: * We depend on the way that records are added to the sockbuf
829: * by sbappend*. In particular, each record (mbufs linked through m_next)
830: * must begin with an address if the protocol so specifies,
831: * followed by an optional mbuf or mbufs containing ancillary data,
832: * and then zero or more mbufs of data.
833: * In order to avoid blocking network interrupts for the entire time here,
834: * we splx() while doing the actual copy to user space.
835: * Although the sockbuf is locked, new data may still be appended,
836: * and thus we must maintain consistency of the sockbuf during that time.
837: *
838: * The caller may receive the data as a single mbuf chain by supplying
839: * an mbuf **mp0 for use in returning the chain. The uio is then used
840: * only for the count in uio_resid.
841: */
842: int
843: soreceive(so, psa, uio, mp0, controlp, flagsp)
844: register struct socket *so;
845: struct sockaddr **psa;
846: struct uio *uio;
847: struct mbuf **mp0;
848: struct mbuf **controlp;
849: int *flagsp;
850: {
851: register struct mbuf *m, **mp;
852: register int flags, len, error, s, offset;
853: struct protosw *pr = so->so_proto;
854: struct mbuf *nextrecord;
855: int moff, type = 0;
856: int orig_resid = uio->uio_resid;
857: struct kextcb *kp;
858:
859: KERNEL_DEBUG(DBG_FNC_SORECEIVE | DBG_FUNC_START,
860: so,
861: uio->uio_resid,
862: so->so_rcv.sb_cc,
863: so->so_rcv.sb_lowat,
864: so->so_rcv.sb_hiwat);
865:
866: kp = sotokextcb(so);
867: while (kp)
868: { if (kp->e_soif && kp->e_soif->sf_soreceive)
869: { error = (*kp->e_soif->sf_soreceive)(so, psa, &uio,
870: mp0, controlp,
871: flagsp, kp);
872: if (error)
873: return((error == EJUSTRETURN) ? 0 : error);
874: }
875: kp = kp->e_next;
876: }
877:
878: mp = mp0;
879: if (psa)
880: *psa = 0;
881: if (controlp)
882: *controlp = 0;
883: if (flagsp)
884: flags = *flagsp &~ MSG_EOR;
885: else
886: flags = 0;
887: if (flags & MSG_OOB) {
888: m = m_get(M_WAIT, MT_DATA);
889: error = (*pr->pr_usrreqs->pru_rcvoob)(so, m, flags & MSG_PEEK);
890: if (error)
891: goto bad;
892: do {
893: error = uiomove(mtod(m, caddr_t),
894: (int) min(uio->uio_resid, m->m_len), uio);
895: m = m_free(m);
896: } while (uio->uio_resid && error == 0 && m);
897: bad:
898: if (m)
899: m_freem(m);
900:
901: KERNEL_DEBUG(DBG_FNC_SORECEIVE | DBG_FUNC_END, error,0,0,0,0);
902: return (error);
903: }
904: if (mp)
905: *mp = (struct mbuf *)0;
906: if (so->so_state & SS_ISCONFIRMING && uio->uio_resid)
907: (*pr->pr_usrreqs->pru_rcvd)(so, 0);
908:
909: restart:
910: if (error = sblock(&so->so_rcv, SBLOCKWAIT(flags)))
911: {
912: KERNEL_DEBUG(DBG_FNC_SORECEIVE | DBG_FUNC_END, error,0,0,0,0);
913: return (error);
914: }
915: s = splnet();
916:
917: m = so->so_rcv.sb_mb;
918: /*
919: * If we have less data than requested, block awaiting more
920: * (subject to any timeout) if:
921: * 1. the current count is less than the low water mark, or
922: * 2. MSG_WAITALL is set, and it is possible to do the entire
923: * receive operation at once if we block (resid <= hiwat).
924: * 3. MSG_DONTWAIT is not set
925: * If MSG_WAITALL is set but resid is larger than the receive buffer,
926: * we have to do the receive in sections, and thus risk returning
927: * a short count if a timeout or signal occurs after we start.
928: */
929: if (m == 0 || (((flags & MSG_DONTWAIT) == 0 &&
930: so->so_rcv.sb_cc < uio->uio_resid) &&
931: (so->so_rcv.sb_cc < so->so_rcv.sb_lowat ||
932: ((flags & MSG_WAITALL) && uio->uio_resid <= so->so_rcv.sb_hiwat)) &&
933: m->m_nextpkt == 0 && (pr->pr_flags & PR_ATOMIC) == 0)) {
934: KASSERT(m != 0 || !so->so_rcv.sb_cc, ("receive 1"));
935: if (so->so_error) {
936: if (m)
937: goto dontblock;
938: error = so->so_error;
939: if ((flags & MSG_PEEK) == 0)
940: so->so_error = 0;
941: goto release;
942: }
943: if (so->so_state & SS_CANTRCVMORE) {
944: if (m)
945: goto dontblock;
946: else
947: goto release;
948: }
949: for (; m; m = m->m_next)
950: if (m->m_type == MT_OOBDATA || (m->m_flags & M_EOR)) {
951: m = so->so_rcv.sb_mb;
952: goto dontblock;
953: }
954: if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 &&
955: (so->so_proto->pr_flags & PR_CONNREQUIRED)) {
956: error = ENOTCONN;
957: goto release;
958: }
959: if (uio->uio_resid == 0)
960: goto release;
961: if ((so->so_state & SS_NBIO) || (flags & MSG_DONTWAIT)) {
962: error = EWOULDBLOCK;
963: goto release;
964: }
965: sbunlock(&so->so_rcv);
966: if (socket_debug)
967: printf("Waiting for socket data\n");
968: error = sbwait(&so->so_rcv);
969: if (socket_debug)
970: printf("SORECEIVE - sbwait returned %d\n", error);
971: splx(s);
972: if (error)
973: {
974: KERNEL_DEBUG(DBG_FNC_SORECEIVE | DBG_FUNC_END, error,0,0,0,0);
975: return (error);
976: }
977: goto restart;
978: }
979: dontblock:
980: #ifdef notyet /* XXXX */
981: if (uio->uio_procp)
982: uio->uio_procp->p_stats->p_ru.ru_msgrcv++;
983: #endif
984: nextrecord = m->m_nextpkt;
985: if ((pr->pr_flags & PR_ADDR) && m->m_type == MT_SONAME) {
986: KASSERT(m->m_type == MT_SONAME, ("receive 1a"));
987: orig_resid = 0;
988: if (psa)
989: *psa = dup_sockaddr(mtod(m, struct sockaddr *),
990: mp0 == 0);
991: if (flags & MSG_PEEK) {
992: m = m->m_next;
993: } else {
994: sbfree(&so->so_rcv, m);
995: MFREE(m, so->so_rcv.sb_mb);
996: m = so->so_rcv.sb_mb;
997: }
998: }
999: while (m && m->m_type == MT_CONTROL && error == 0) {
1000: if (flags & MSG_PEEK) {
1001: if (controlp)
1002: *controlp = m_copy(m, 0, m->m_len);
1003: m = m->m_next;
1004: } else {
1005: sbfree(&so->so_rcv, m);
1006: if (controlp) {
1007: if (pr->pr_domain->dom_externalize &&
1008: mtod(m, struct cmsghdr *)->cmsg_type ==
1009: SCM_RIGHTS)
1010: error = (*pr->pr_domain->dom_externalize)(m);
1011: *controlp = m;
1012: so->so_rcv.sb_mb = m->m_next;
1013: m->m_next = 0;
1014: m = so->so_rcv.sb_mb;
1015: } else {
1016: MFREE(m, so->so_rcv.sb_mb);
1017: m = so->so_rcv.sb_mb;
1018: }
1019: }
1020: if (controlp) {
1021: orig_resid = 0;
1022: controlp = &(*controlp)->m_next;
1023: }
1024: }
1025: if (m) {
1026: if ((flags & MSG_PEEK) == 0)
1027: m->m_nextpkt = nextrecord;
1028: type = m->m_type;
1029: if (type == MT_OOBDATA)
1030: flags |= MSG_OOB;
1031: }
1032: moff = 0;
1033: offset = 0;
1034: while (m && uio->uio_resid > 0 && error == 0) {
1035: if (m->m_type == MT_OOBDATA) {
1036: if (type != MT_OOBDATA)
1037: break;
1038: } else if (type == MT_OOBDATA)
1039: break;
1040: #if 0
1041: /*
1042: * This assertion needs rework. The trouble is Appletalk is uses many
1043: * mbuf types (NOT listed in mbuf.h!) which will trigger this panic.
1044: * For now just remove the assertion... CSM 9/98
1045: */
1046: else
1047: KASSERT(m->m_type == MT_DATA || m->m_type == MT_HEADER,
1048: ("receive 3"));
1049: #endif
1050: so->so_state &= ~SS_RCVATMARK;
1051: len = uio->uio_resid;
1052: if (so->so_oobmark && len > so->so_oobmark - offset)
1053: len = so->so_oobmark - offset;
1054: if (len > m->m_len - moff)
1055: len = m->m_len - moff;
1056: /*
1057: * If mp is set, just pass back the mbufs.
1058: * Otherwise copy them out via the uio, then free.
1059: * Sockbuf must be consistent here (points to current mbuf,
1060: * it points to next record) when we drop priority;
1061: * we must note any additions to the sockbuf when we
1062: * block interrupts again.
1063: */
1064: if (mp == 0) {
1065: splx(s);
1066: error = uiomove(mtod(m, caddr_t) + moff, (int)len, uio);
1067: s = splnet();
1068: if (error)
1069: goto release;
1070: } else
1071: uio->uio_resid -= len;
1072: if (len == m->m_len - moff) {
1073: if (m->m_flags & M_EOR)
1074: flags |= MSG_EOR;
1075: if (flags & MSG_PEEK) {
1076: m = m->m_next;
1077: moff = 0;
1078: } else {
1079: nextrecord = m->m_nextpkt;
1080: sbfree(&so->so_rcv, m);
1081: if (mp) {
1082: *mp = m;
1083: mp = &m->m_next;
1084: so->so_rcv.sb_mb = m = m->m_next;
1085: *mp = (struct mbuf *)0;
1086: } else {
1087: MFREE(m, so->so_rcv.sb_mb);
1088: m = so->so_rcv.sb_mb;
1089: }
1090: if (m)
1091: m->m_nextpkt = nextrecord;
1092: }
1093: } else {
1094: if (flags & MSG_PEEK)
1095: moff += len;
1096: else {
1097: if (mp)
1098: *mp = m_copym(m, 0, len, M_WAIT);
1099: m->m_data += len;
1100: m->m_len -= len;
1101: so->so_rcv.sb_cc -= len;
1102: }
1103: }
1104: if (so->so_oobmark) {
1105: if ((flags & MSG_PEEK) == 0) {
1106: so->so_oobmark -= len;
1107: if (so->so_oobmark == 0) {
1108: so->so_state |= SS_RCVATMARK;
1109: postevent(so, 0, EV_OOB);
1110: break;
1111: }
1112: } else {
1113: offset += len;
1114: if (offset == so->so_oobmark)
1115: break;
1116: }
1117: }
1118: if (flags & MSG_EOR)
1119: break;
1120: /*
1121: * If the MSG_WAITALL flag is set (for non-atomic socket),
1122: * we must not quit until "uio->uio_resid == 0" or an error
1123: * termination. If a signal/timeout occurs, return
1124: * with a short count but without error.
1125: * Keep sockbuf locked against other readers.
1126: */
1127: while (flags & MSG_WAITALL && m == 0 && uio->uio_resid > 0 &&
1128: !sosendallatonce(so) && !nextrecord) {
1129: if (so->so_error || so->so_state & SS_CANTRCVMORE)
1130: break;
1131: error = sbwait(&so->so_rcv);
1132: if (error) {
1133: sbunlock(&so->so_rcv);
1134: splx(s);
1135: KERNEL_DEBUG(DBG_FNC_SORECEIVE | DBG_FUNC_END, 0,0,0,0,0);
1136: return (0);
1137: }
1138: m = so->so_rcv.sb_mb;
1139: if (m)
1140: nextrecord = m->m_nextpkt;
1141: }
1142: }
1143:
1144: if (m && pr->pr_flags & PR_ATOMIC) {
1145: if (so->so_options & SO_DONTTRUNC)
1146: flags |= MSG_RCVMORE;
1147: else
1148: { flags |= MSG_TRUNC;
1149: if ((flags & MSG_PEEK) == 0)
1150: (void) sbdroprecord(&so->so_rcv);
1151: }
1152: }
1153: if ((flags & MSG_PEEK) == 0) {
1154: if (m == 0)
1155: so->so_rcv.sb_mb = nextrecord;
1156: if (pr->pr_flags & PR_WANTRCVD && so->so_pcb)
1157: (*pr->pr_usrreqs->pru_rcvd)(so, flags);
1158: }
1159: if ((so->so_options & SO_WANTMORE) && so->so_rcv.sb_cc > 0)
1160: flags |= MSG_HAVEMORE;
1161: if (orig_resid == uio->uio_resid && orig_resid &&
1162: (flags & MSG_EOR) == 0 && (so->so_state & SS_CANTRCVMORE) == 0) {
1163: sbunlock(&so->so_rcv);
1164: splx(s);
1165: goto restart;
1166: }
1167:
1168: if (flagsp)
1169: *flagsp |= flags;
1170: release:
1171: sbunlock(&so->so_rcv);
1172: splx(s);
1173:
1174: KERNEL_DEBUG(DBG_FNC_SORECEIVE | DBG_FUNC_END,
1175: so,
1176: uio->uio_resid,
1177: so->so_rcv.sb_cc,
1178: 0,
1179: error);
1180:
1181: return (error);
1182: }
1183:
1184: int
1185: soshutdown(so, how)
1186: register struct socket *so;
1187: register int how;
1188: {
1189: register struct protosw *pr = so->so_proto;
1190: struct kextcb *kp;
1191: int ret;
1192:
1193: kp = sotokextcb(so);
1194: while (kp)
1195: { if (kp->e_soif && kp->e_soif->sf_soshutdown)
1196: { ret = (*kp->e_soif->sf_soshutdown)(so, how, kp);
1197: if (ret)
1198: return((ret == EJUSTRETURN) ? 0 : ret);
1199: }
1200: kp = kp->e_next;
1201: }
1202:
1203: how++;
1204: if (how & FREAD) {
1205: sorflush(so);
1206: postevent(so, 0, EV_RCLOSED);
1207: }
1208: if (how & FWRITE) {
1209: ret = ((*pr->pr_usrreqs->pru_shutdown)(so));
1210: postevent(so, 0, EV_WCLOSED);
1211: return(ret);
1212: }
1213: return (0);
1214: }
1215:
1216: void
1217: sorflush(so)
1218: register struct socket *so;
1219: {
1220: register struct sockbuf *sb = &so->so_rcv;
1221: register struct protosw *pr = so->so_proto;
1222: register int s, error;
1223: struct sockbuf asb;
1224: struct kextcb *kp;
1225:
1226: kp = sotokextcb(so);
1227: while (kp)
1228: { if (kp->e_soif && kp->e_soif->sf_sorflush)
1229: { if ((*kp->e_soif->sf_sorflush)(so, kp))
1230: return;
1231: }
1232: kp = kp->e_next;
1233: }
1234:
1235: sb->sb_flags |= SB_NOINTR;
1236: (void) sblock(sb, M_WAIT);
1237: s = splimp();
1238: socantrcvmore(so);
1239: sbunlock(sb);
1240: asb = *sb;
1241: bzero((caddr_t)sb, sizeof (*sb));
1242: splx(s);
1243: if (pr->pr_flags & PR_RIGHTS && pr->pr_domain->dom_dispose)
1244: (*pr->pr_domain->dom_dispose)(asb.sb_mb);
1245: sbrelease(&asb);
1246: }
1247:
1248: /*
1249: * Perhaps this routine, and sooptcopyout(), below, ought to come in
1250: * an additional variant to handle the case where the option value needs
1251: * to be some kind of integer, but not a specific size.
1252: * In addition to their use here, these functions are also called by the
1253: * protocol-level pr_ctloutput() routines.
1254: */
1255: int
1256: sooptcopyin(sopt, buf, len, minlen)
1257: struct sockopt *sopt;
1258: void *buf;
1259: size_t len;
1260: size_t minlen;
1261: {
1262: size_t valsize;
1263:
1264: /*
1265: * If the user gives us more than we wanted, we ignore it,
1266: * but if we don't get the minimum length the caller
1267: * wants, we return EINVAL. On success, sopt->sopt_valsize
1268: * is set to however much we actually retrieved.
1269: */
1270: if ((valsize = sopt->sopt_valsize) < minlen)
1271: return EINVAL;
1272: if (valsize > len)
1273: sopt->sopt_valsize = valsize = len;
1274:
1275: if (sopt->sopt_p != 0)
1276: return (copyin(sopt->sopt_val, buf, valsize));
1277:
1278: bcopy(sopt->sopt_val, buf, valsize);
1279: return 0;
1280: }
1281:
1282: int
1283: sosetopt(so, sopt)
1284: struct socket *so;
1285: struct sockopt *sopt;
1286: {
1287: int error, optval;
1288: struct linger l;
1289: struct timeval tv;
1290: short val;
1291: struct kextcb *kp;
1292:
1293: kp = sotokextcb(so);
1294: while (kp)
1295: { if (kp->e_soif && kp->e_soif->sf_socontrol)
1296: { error = (*kp->e_soif->sf_socontrol)(so, sopt, kp);
1297: if (error)
1298: return((error == EJUSTRETURN) ? 0 : error);
1299: }
1300: kp = kp->e_next;
1301: }
1302:
1303: error = 0;
1304: if (sopt->sopt_level != SOL_SOCKET) {
1305: if (so->so_proto && so->so_proto->pr_ctloutput)
1306: return ((*so->so_proto->pr_ctloutput)
1307: (so, sopt));
1308: error = ENOPROTOOPT;
1309: } else {
1310: switch (sopt->sopt_name) {
1311: case SO_LINGER:
1312: error = sooptcopyin(sopt, &l, sizeof l, sizeof l);
1313: if (error)
1314: goto bad;
1315:
1316: so->so_linger = l.l_linger;
1317: if (l.l_onoff)
1318: so->so_options |= SO_LINGER;
1319: else
1320: so->so_options &= ~SO_LINGER;
1321: break;
1322:
1323: case SO_DEBUG:
1324: case SO_KEEPALIVE:
1325: case SO_DONTROUTE:
1326: case SO_USELOOPBACK:
1327: case SO_BROADCAST:
1328: case SO_REUSEADDR:
1329: case SO_REUSEPORT:
1330: case SO_OOBINLINE:
1331: case SO_TIMESTAMP:
1332: case SO_DONTTRUNC:
1333: case SO_WANTMORE:
1334: error = sooptcopyin(sopt, &optval, sizeof optval,
1335: sizeof optval);
1336: if (error)
1337: goto bad;
1338: if (optval)
1339: so->so_options |= sopt->sopt_name;
1340: else
1341: so->so_options &= ~sopt->sopt_name;
1342: break;
1343:
1344: case SO_SNDBUF:
1345: case SO_RCVBUF:
1346: case SO_SNDLOWAT:
1347: case SO_RCVLOWAT:
1348: error = sooptcopyin(sopt, &optval, sizeof optval,
1349: sizeof optval);
1350: if (error)
1351: goto bad;
1352:
1353: /*
1354: * Values < 1 make no sense for any of these
1355: * options, so disallow them.
1356: */
1357: if (optval < 1) {
1358: error = EINVAL;
1359: goto bad;
1360: }
1361:
1362: switch (sopt->sopt_name) {
1363: case SO_SNDBUF:
1364: case SO_RCVBUF:
1365: if (sbreserve(sopt->sopt_name == SO_SNDBUF ?
1366: &so->so_snd : &so->so_rcv,
1367: (u_long) optval) == 0) {
1368: error = ENOBUFS;
1369: goto bad;
1370: }
1371: break;
1372:
1373: /*
1374: * Make sure the low-water is never greater than
1375: * the high-water.
1376: */
1377: case SO_SNDLOWAT:
1378: so->so_snd.sb_lowat =
1379: (optval > so->so_snd.sb_hiwat) ?
1380: so->so_snd.sb_hiwat : optval;
1381: break;
1382: case SO_RCVLOWAT:
1383: so->so_rcv.sb_lowat =
1384: (optval > so->so_rcv.sb_hiwat) ?
1385: so->so_rcv.sb_hiwat : optval;
1386: break;
1387: }
1388: break;
1389:
1390: case SO_SNDTIMEO:
1391: case SO_RCVTIMEO:
1392: error = sooptcopyin(sopt, &tv, sizeof tv,
1393: sizeof tv);
1394: if (error)
1395: goto bad;
1396:
1397: if (tv.tv_sec > SHRT_MAX / hz - hz) {
1398: error = EDOM;
1399: goto bad;
1400: }
1401: val = tv.tv_sec * hz + tv.tv_usec / tick;
1402:
1403: switch (sopt->sopt_name) {
1404: case SO_SNDTIMEO:
1405: so->so_snd.sb_timeo = val;
1406: break;
1407: case SO_RCVTIMEO:
1408: so->so_rcv.sb_timeo = val;
1409: break;
1410: }
1411: break;
1412:
1413: case SO_NKE:
1414: { struct so_nke nke;
1415: struct NFDescriptor *nf1, *nf2 = NULL;
1416:
1417: error = sooptcopyin(sopt, &nke,
1418: sizeof nke, sizeof nke);
1419: if (error)
1420: goto bad;
1421:
1422: error = nke_insert(so, &nke);
1423: break;
1424: }
1425:
1426: default:
1427: error = ENOPROTOOPT;
1428: break;
1429: }
1430: if (error == 0 && so->so_proto && so->so_proto->pr_ctloutput) {
1431: (void) ((*so->so_proto->pr_ctloutput)
1432: (so, sopt));
1433: }
1434: }
1435: bad:
1436: return (error);
1437: }
1438:
1439: /* Helper routine for getsockopt */
1440: int
1441: sooptcopyout(sopt, buf, len)
1442: struct sockopt *sopt;
1443: void *buf;
1444: size_t len;
1445: {
1446: int error;
1447: size_t valsize;
1448:
1449: error = 0;
1450:
1451: /*
1452: * Documented get behavior is that we always return a value,
1453: * possibly truncated to fit in the user's buffer.
1454: * Traditional behavior is that we always tell the user
1455: * precisely how much we copied, rather than something useful
1456: * like the total amount we had available for her.
1457: * Note that this interface is not idempotent; the entire answer must
1458: * generated ahead of time.
1459: */
1460: valsize = min(len, sopt->sopt_valsize);
1461: sopt->sopt_valsize = valsize;
1462: if (sopt->sopt_val != 0) {
1463: if (sopt->sopt_p != 0)
1464: error = copyout(buf, sopt->sopt_val, valsize);
1465: else
1466: bcopy(buf, sopt->sopt_val, valsize);
1467: }
1468: return error;
1469: }
1470:
1471: int
1472: sogetopt(so, sopt)
1473: struct socket *so;
1474: struct sockopt *sopt;
1475: {
1476: int error, optval;
1477: struct linger l;
1478: struct timeval tv;
1479: struct mbuf *m;
1480: struct kextcb *kp;
1481:
1482: kp = sotokextcb(so);
1483: while (kp)
1484: { if (kp->e_soif && kp->e_soif->sf_socontrol)
1485: { error = (*kp->e_soif->sf_socontrol)(so, sopt, kp);
1486: if (error)
1487: return((error == EJUSTRETURN) ? 0 : error);
1488: }
1489: kp = kp->e_next;
1490: }
1491:
1492: error = 0;
1493: if (sopt->sopt_level != SOL_SOCKET) {
1494: if (so->so_proto && so->so_proto->pr_ctloutput) {
1495: return ((*so->so_proto->pr_ctloutput)
1496: (so, sopt));
1497: } else
1498: return (ENOPROTOOPT);
1499: } else {
1500: switch (sopt->sopt_name) {
1501: case SO_LINGER:
1502: l.l_onoff = so->so_options & SO_LINGER;
1503: l.l_linger = so->so_linger;
1504: error = sooptcopyout(sopt, &l, sizeof l);
1505: break;
1506:
1507: case SO_USELOOPBACK:
1508: case SO_DONTROUTE:
1509: case SO_DEBUG:
1510: case SO_KEEPALIVE:
1511: case SO_REUSEADDR:
1512: case SO_REUSEPORT:
1513: case SO_BROADCAST:
1514: case SO_OOBINLINE:
1515: case SO_TIMESTAMP:
1516: case SO_DONTTRUNC:
1517: case SO_WANTMORE:
1518: optval = so->so_options & sopt->sopt_name;
1519: integer:
1520: error = sooptcopyout(sopt, &optval, sizeof optval);
1521: break;
1522:
1523: case SO_TYPE:
1524: optval = so->so_type;
1525: goto integer;
1526:
1527: case SO_NREAD:
1528: { int pkt_total;
1529: struct mbuf *m1;
1530:
1531: pkt_total = 0;
1532: m1 = so->so_rcv.sb_mb;
1533: if (so->so_proto->pr_flags & PR_ATOMIC)
1534: {
1535: #if 0
1536: kprintf("SKT CC: %d\n", so->so_rcv.sb_cc);
1537: #endif
1538: while (m1)
1539: { if (m1->m_type == MT_DATA)
1540: pkt_total += m1->m_len;
1541: #if 0
1542: kprintf("CNT: %d/%d\n", m1->m_len, pkt_total);
1543: #endif
1544: m1 = m1->m_next;
1545: }
1546: optval = pkt_total;
1547: } else
1548: optval = so->so_rcv.sb_cc;
1549: #if 0
1550: kprintf("RTN: %d\n", optval);
1551: #endif
1552: goto integer;
1553: }
1554: case SO_ERROR:
1555: optval = so->so_error;
1556: so->so_error = 0;
1557: goto integer;
1558:
1559: case SO_SNDBUF:
1560: optval = so->so_snd.sb_hiwat;
1561: goto integer;
1562:
1563: case SO_RCVBUF:
1564: optval = so->so_rcv.sb_hiwat;
1565: goto integer;
1566:
1567: case SO_SNDLOWAT:
1568: optval = so->so_snd.sb_lowat;
1569: goto integer;
1570:
1571: case SO_RCVLOWAT:
1572: optval = so->so_rcv.sb_lowat;
1573: goto integer;
1574:
1575: case SO_SNDTIMEO:
1576: case SO_RCVTIMEO:
1577: optval = (sopt->sopt_name == SO_SNDTIMEO ?
1578: so->so_snd.sb_timeo : so->so_rcv.sb_timeo);
1579:
1580: tv.tv_sec = optval / hz;
1581: tv.tv_usec = (optval % hz) * tick;
1582: error = sooptcopyout(sopt, &tv, sizeof tv);
1583: break;
1584:
1585: default:
1586: error = ENOPROTOOPT;
1587: break;
1588: }
1589: return (error);
1590: }
1591: }
1592:
1593: void
1594: sohasoutofband(so)
1595: register struct socket *so;
1596: {
1597: struct proc *p;
1598:
1599: struct kextcb *kp;
1600:
1601: kp = sotokextcb(so);
1602: while (kp)
1603: { if (kp->e_soif && kp->e_soif->sf_sohasoutofband)
1604: { if ((*kp->e_soif->sf_sohasoutofband)(so, kp))
1605: return;
1606: }
1607: kp = kp->e_next;
1608: }
1609: if (so->so_pgid < 0)
1610: gsignal(-so->so_pgid, SIGURG);
1611: else if (so->so_pgid > 0 && (p = pfind(so->so_pgid)) != 0)
1612: psignal(p, SIGURG);
1613: selwakeup(&so->so_rcv.sb_sel);
1614: }
1615:
1616: /*
1617: * Network filter support
1618: */
1619: /* Run the list of filters, creating extension control blocks */
1620: sfilter_init(register struct socket *so)
1621: { struct kextcb *kp, **kpp;
1622: struct protosw *prp;
1623: struct NFDescriptor *nfp;
1624:
1625: prp = so->so_proto;
1626: nfp = prp->pr_sfilter.tqh_first; /* non-null */
1627: kpp = &so->so_ext;
1628: kp = NULL;
1629: while (nfp)
1630: { MALLOC(kp, struct kextcb *, sizeof(*kp),
1631: M_TEMP, M_WAITOK);
1632: if (kp == NULL)
1633: return(ENOBUFS); /* so_free will clean up */
1634: *kpp = kp;
1635: kpp = &kp->e_next;
1636: kp->e_next = NULL;
1637: kp->e_fcb = NULL;
1638: kp->e_nfd = nfp;
1639: kp->e_soif = nfp->nf_soif;
1640: kp->e_sout = nfp->nf_soutil;
1641: /*
1642: * Ignore return value for create
1643: * Everyone gets a chance at startup
1644: */
1645: if (kp->e_soif && kp->e_soif->sf_socreate)
1646: (*kp->e_soif->sf_socreate)(so, prp, kp);
1647: nfp = nfp->nf_next.tqe_next;
1648: }
1649: return(0);
1650: }
1651:
1652:
1653: /*
1654: * Run the list of filters, freeing extension control blocks
1655: * Assumes the soif/soutil blocks have been handled.
1656: */
1657: sfilter_term(struct socket *so)
1658: { struct kextcb *kp, *kp1;
1659:
1660: kp = so->so_ext;
1661: while (kp)
1662: { kp1 = kp->e_next;
1663: /*
1664: * Ignore return code on termination; everyone must
1665: * get terminated.
1666: */
1667: if (kp->e_soif && kp->e_soif->sf_sofree)
1668: kp->e_soif->sf_sofree(so, kp);
1669: FREE(kp, M_TEMP);
1670: kp = kp1;
1671: }
1672: return(0);
1673: }
1674:
1675:
1676: int
1677: sopoll(struct socket *so, int events, struct ucred *cred)
1678: {
1679: struct proc *p = current_proc();
1680: int revents = 0;
1681: int s = splnet();
1682:
1683: if (events & (POLLIN | POLLRDNORM))
1684: if (soreadable(so))
1685: revents |= events & (POLLIN | POLLRDNORM);
1686:
1687: if (events & (POLLOUT | POLLWRNORM))
1688: if (sowriteable(so))
1689: revents |= events & (POLLOUT | POLLWRNORM);
1690:
1691: if (events & (POLLPRI | POLLRDBAND))
1692: if (so->so_oobmark || (so->so_state & SS_RCVATMARK))
1693: revents |= events & (POLLPRI | POLLRDBAND);
1694:
1695: if (revents == 0) {
1696: if (events & (POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND)) {
1697: selrecord(p, &so->so_rcv.sb_sel);
1698: so->so_rcv.sb_flags |= SB_SEL;
1699: }
1700:
1701: if (events & (POLLOUT | POLLWRNORM)) {
1702: selrecord(p, &so->so_snd.sb_sel);
1703: so->so_snd.sb_flags |= SB_SEL;
1704: }
1705: }
1706:
1707: splx(s);
1708: return (revents);
1709: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.