2 * Copyright (c) 2004 Jeffrey M. Hsu. All rights reserved.
3 * Copyright (c) 2004 The DragonFly Project. All rights reserved.
5 * This code is derived from software contributed to The DragonFly Project
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of The DragonFly Project nor the names of its
17 * contributors may be used to endorse or promote products derived
18 * from this software without specific, prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
24 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
26 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
27 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
28 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
30 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * Copyright (c) 1982, 1986, 1988, 1990, 1993
36 * The Regents of the University of California. All rights reserved.
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
41 * 1. Redistributions of source code must retain the above copyright
42 * notice, this list of conditions and the following disclaimer.
43 * 2. Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in the
45 * documentation and/or other materials provided with the distribution.
46 * 3. All advertising materials mentioning features or use of this software
47 * must display the following acknowledgement:
48 * This product includes software developed by the University of
49 * California, Berkeley and its contributors.
50 * 4. Neither the name of the University nor the names of its contributors
51 * may be used to endorse or promote products derived from this software
52 * without specific prior written permission.
54 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
55 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
56 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
57 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
58 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
59 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
60 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
61 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
62 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
63 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
66 * @(#)uipc_socket.c 8.3 (Berkeley) 4/15/94
67 * $FreeBSD: src/sys/kern/uipc_socket.c,v 1.68.2.24 2003/11/11 17:18:18 silby Exp $
68 * $DragonFly: src/sys/kern/uipc_socket.c,v 1.55 2008/09/02 16:17:52 dillon Exp $
74 #include <sys/param.h>
75 #include <sys/systm.h>
76 #include <sys/fcntl.h>
77 #include <sys/malloc.h>
79 #include <sys/domain.h>
80 #include <sys/file.h> /* for struct knote */
81 #include <sys/kernel.h>
82 #include <sys/malloc.h>
83 #include <sys/event.h>
86 #include <sys/protosw.h>
87 #include <sys/socket.h>
88 #include <sys/socketvar.h>
89 #include <sys/socketops.h>
90 #include <sys/resourcevar.h>
91 #include <sys/signalvar.h>
92 #include <sys/sysctl.h>
95 #include <vm/vm_zone.h>
98 #include <sys/thread2.h>
99 #include <sys/socketvar2.h>
101 #include <machine/limits.h>
104 static int do_setopt_accept_filter(struct socket
*so
, struct sockopt
*sopt
);
107 static void filt_sordetach(struct knote
*kn
);
108 static int filt_soread(struct knote
*kn
, long hint
);
109 static void filt_sowdetach(struct knote
*kn
);
110 static int filt_sowrite(struct knote
*kn
, long hint
);
111 static int filt_solisten(struct knote
*kn
, long hint
);
113 static struct filterops solisten_filtops
=
114 { 1, NULL
, filt_sordetach
, filt_solisten
};
115 static struct filterops soread_filtops
=
116 { 1, NULL
, filt_sordetach
, filt_soread
};
117 static struct filterops sowrite_filtops
=
118 { 1, NULL
, filt_sowdetach
, filt_sowrite
};
120 MALLOC_DEFINE(M_SOCKET
, "socket", "socket struct");
121 MALLOC_DEFINE(M_SONAME
, "soname", "socket name");
122 MALLOC_DEFINE(M_PCB
, "pcb", "protocol control block");
125 static int somaxconn
= SOMAXCONN
;
126 SYSCTL_INT(_kern_ipc
, KIPC_SOMAXCONN
, somaxconn
, CTLFLAG_RW
,
127 &somaxconn
, 0, "Maximum pending socket connection queue size");
130 * Socket operation routines.
131 * These routines are called by the routines in
132 * sys_socket.c or from a system process, and
133 * implement the semantics of socket operations by
134 * switching out to the protocol specific routines.
138 * Get a socket structure, and initialize it.
139 * Note that it would probably be better to allocate socket
140 * and PCB at the same time, but I'm not convinced that all
141 * the protocols can be easily modified to do this.
149 waitmask
= waitok
? M_WAITOK
: M_NOWAIT
;
150 so
= kmalloc(sizeof(struct socket
), M_SOCKET
, M_ZERO
|waitmask
);
152 /* XXX race condition for reentrant kernel */
153 TAILQ_INIT(&so
->so_aiojobq
);
154 TAILQ_INIT(&so
->so_rcv
.ssb_sel
.si_mlist
);
155 TAILQ_INIT(&so
->so_snd
.ssb_sel
.si_mlist
);
161 socreate(int dom
, struct socket
**aso
, int type
,
162 int proto
, struct thread
*td
)
164 struct proc
*p
= td
->td_proc
;
167 struct pru_attach_info ai
;
171 prp
= pffindproto(dom
, proto
, type
);
173 prp
= pffindtype(dom
, type
);
175 if (prp
== 0 || prp
->pr_usrreqs
->pru_attach
== 0)
176 return (EPROTONOSUPPORT
);
178 if (p
->p_ucred
->cr_prison
&& jail_socket_unixiproute_only
&&
179 prp
->pr_domain
->dom_family
!= PF_LOCAL
&&
180 prp
->pr_domain
->dom_family
!= PF_INET
&&
181 prp
->pr_domain
->dom_family
!= PF_INET6
&&
182 prp
->pr_domain
->dom_family
!= PF_ROUTE
) {
183 return (EPROTONOSUPPORT
);
186 if (prp
->pr_type
!= type
)
188 so
= soalloc(p
!= 0);
193 * Set a default port for protocol processing. No action will occur
194 * on the socket on this port until an inpcb is attached to it and
195 * is able to match incoming packets, or until the socket becomes
196 * available to userland.
198 so
->so_port
= cpu0_soport(so
, NULL
, NULL
);
200 TAILQ_INIT(&so
->so_incomp
);
201 TAILQ_INIT(&so
->so_comp
);
203 so
->so_cred
= crhold(p
->p_ucred
);
205 ai
.sb_rlimit
= &p
->p_rlimit
[RLIMIT_SBSIZE
];
206 ai
.p_ucred
= p
->p_ucred
;
207 ai
.fd_rdir
= p
->p_fd
->fd_rdir
;
210 * Auto-sizing of socket buffers is managed by the protocols and
211 * the appropriate flags must be set in the pru_attach function.
213 error
= so_pru_attach(so
, proto
, &ai
);
215 so
->so_state
|= SS_NOFDREF
;
225 sobind(struct socket
*so
, struct sockaddr
*nam
, struct thread
*td
)
230 error
= so_pru_bind(so
, nam
, td
);
236 sodealloc(struct socket
*so
)
238 if (so
->so_rcv
.ssb_hiwat
)
239 (void)chgsbsize(so
->so_cred
->cr_uidinfo
,
240 &so
->so_rcv
.ssb_hiwat
, 0, RLIM_INFINITY
);
241 if (so
->so_snd
.ssb_hiwat
)
242 (void)chgsbsize(so
->so_cred
->cr_uidinfo
,
243 &so
->so_snd
.ssb_hiwat
, 0, RLIM_INFINITY
);
245 /* remove accept filter if present */
246 if (so
->so_accf
!= NULL
)
247 do_setopt_accept_filter(so
, NULL
);
254 solisten(struct socket
*so
, int backlog
, struct thread
*td
)
258 short oldopt
, oldqlimit
;
262 if (so
->so_state
& (SS_ISCONNECTED
| SS_ISCONNECTING
)) {
268 oldopt
= so
->so_options
;
269 oldqlimit
= so
->so_qlimit
;
272 if (TAILQ_EMPTY(&so
->so_comp
))
273 so
->so_options
|= SO_ACCEPTCONN
;
274 if (backlog
< 0 || backlog
> somaxconn
)
276 so
->so_qlimit
= backlog
;
277 /* SCTP needs to look at tweak both the inbound backlog parameter AND
278 * the so_options (UDP model both connect's and gets inbound
279 * connections .. implicitly).
281 error
= so_pru_listen(so
, td
);
284 /* Restore the params */
285 so
->so_options
= oldopt
;
286 so
->so_qlimit
= oldqlimit
;
296 * Destroy a disconnected socket. This routine is a NOP if entities
297 * still have a reference on the socket:
299 * so_pcb - The protocol stack still has a reference
300 * SS_NOFDREF - There is no longer a file pointer reference
301 * SS_ABORTING - An abort netmsg is in-flight
304 sofree(struct socket
*so
)
306 struct socket
*head
= so
->so_head
;
308 if (so
->so_pcb
|| (so
->so_state
& SS_NOFDREF
) == 0)
310 if (so
->so_state
& SS_ABORTING
)
313 if (so
->so_state
& SS_INCOMP
) {
314 TAILQ_REMOVE(&head
->so_incomp
, so
, so_list
);
316 } else if (so
->so_state
& SS_COMP
) {
318 * We must not decommission a socket that's
319 * on the accept(2) queue. If we do, then
320 * accept(2) may hang after select(2) indicated
321 * that the listening socket was ready.
325 panic("sofree: not queued");
327 so
->so_state
&= ~SS_INCOMP
;
330 ssb_release(&so
->so_snd
, so
);
336 * Close a socket on last file table reference removal.
337 * Initiate disconnect if connected.
338 * Free socket when disconnect complete.
341 soclose(struct socket
*so
, int fflag
)
346 funsetown(so
->so_sigio
);
347 if (so
->so_pcb
== NULL
)
349 if (so
->so_state
& SS_ISCONNECTED
) {
350 if ((so
->so_state
& SS_ISDISCONNECTING
) == 0) {
351 error
= sodisconnect(so
);
355 if (so
->so_options
& SO_LINGER
) {
356 if ((so
->so_state
& SS_ISDISCONNECTING
) &&
359 while (so
->so_state
& SS_ISCONNECTED
) {
360 error
= tsleep((caddr_t
)&so
->so_timeo
,
361 PCATCH
, "soclos", so
->so_linger
* hz
);
371 error2
= so_pru_detach(so
);
376 if (so
->so_options
& SO_ACCEPTCONN
) {
379 while ((sp
= TAILQ_FIRST(&so
->so_incomp
)) != NULL
) {
380 TAILQ_REMOVE(&so
->so_incomp
, sp
, so_list
);
381 sp
->so_state
&= ~SS_INCOMP
;
386 while ((sp
= TAILQ_FIRST(&so
->so_comp
)) != NULL
) {
387 TAILQ_REMOVE(&so
->so_comp
, sp
, so_list
);
388 sp
->so_state
&= ~SS_COMP
;
394 if (so
->so_state
& SS_NOFDREF
)
395 panic("soclose: NOFDREF");
396 so
->so_state
|= SS_NOFDREF
;
403 * Abort and destroy a socket. Only one abort can be in progress
404 * at any given moment.
407 soabort(struct socket
*so
)
409 if ((so
->so_state
& SS_ABORTING
) == 0) {
410 so
->so_state
|= SS_ABORTING
;
416 soaborta(struct socket
*so
)
418 if ((so
->so_state
& SS_ABORTING
) == 0) {
419 so
->so_state
|= SS_ABORTING
;
425 soabort_oncpu(struct socket
*so
)
427 if ((so
->so_state
& SS_ABORTING
) == 0) {
428 so
->so_state
|= SS_ABORTING
;
429 so_pru_abort_oncpu(so
);
434 soaccept(struct socket
*so
, struct sockaddr
**nam
)
439 if ((so
->so_state
& SS_NOFDREF
) == 0)
440 panic("soaccept: !NOFDREF");
441 so
->so_state
&= ~SS_NOFDREF
;
442 error
= so_pru_accept(so
, nam
);
448 soconnect(struct socket
*so
, struct sockaddr
*nam
, struct thread
*td
)
452 if (so
->so_options
& SO_ACCEPTCONN
)
456 * If protocol is connection-based, can only connect once.
457 * Otherwise, if connected, try to disconnect first.
458 * This allows user to disconnect by connecting to, e.g.,
461 if (so
->so_state
& (SS_ISCONNECTED
|SS_ISCONNECTING
) &&
462 ((so
->so_proto
->pr_flags
& PR_CONNREQUIRED
) ||
463 (error
= sodisconnect(so
)))) {
467 * Prevent accumulated error from previous connection
471 error
= so_pru_connect(so
, nam
, td
);
478 soconnect2(struct socket
*so1
, struct socket
*so2
)
483 error
= so_pru_connect2(so1
, so2
);
489 sodisconnect(struct socket
*so
)
494 if ((so
->so_state
& SS_ISCONNECTED
) == 0) {
498 if (so
->so_state
& SS_ISDISCONNECTING
) {
502 error
= so_pru_disconnect(so
);
508 #define SBLOCKWAIT(f) (((f) & MSG_DONTWAIT) ? M_NOWAIT : M_WAITOK)
511 * If send must go all at once and message is larger than
512 * send buffering, then hard error.
513 * Lock against other senders.
514 * If must go all at once and not enough room now, then
515 * inform user that this would block and do nothing.
516 * Otherwise, if nonblocking, send as much as possible.
517 * The data to be sent is described by "uio" if nonzero,
518 * otherwise by the mbuf chain "top" (which must be null
519 * if uio is not). Data provided in mbuf chain must be small
520 * enough to send all at once.
522 * Returns nonzero on error, timeout or signal; callers
523 * must check for short counts if EINTR/ERESTART are returned.
524 * Data and control buffers are freed on return.
527 sosend(struct socket
*so
, struct sockaddr
*addr
, struct uio
*uio
,
528 struct mbuf
*top
, struct mbuf
*control
, int flags
,
535 int clen
= 0, error
, dontroute
, mlen
;
536 int atomic
= sosendallatonce(so
) || top
;
540 resid
= uio
->uio_resid
;
542 resid
= (size_t)top
->m_pkthdr
.len
;
545 * WARNING! resid is unsigned, space and len are signed. space
546 * can wind up negative if the sockbuf is overcommitted.
548 * Also check to make sure that MSG_EOR isn't used on SOCK_STREAM
549 * type sockets since that's an error.
551 if (so
->so_type
== SOCK_STREAM
&& (flags
& MSG_EOR
)) {
557 (flags
& MSG_DONTROUTE
) && (so
->so_options
& SO_DONTROUTE
) == 0 &&
558 (so
->so_proto
->pr_flags
& PR_ATOMIC
);
559 if (td
->td_lwp
!= NULL
)
560 td
->td_lwp
->lwp_ru
.ru_msgsnd
++;
562 clen
= control
->m_len
;
563 #define gotoerr(errcode) { error = errcode; crit_exit(); goto release; }
566 error
= ssb_lock(&so
->so_snd
, SBLOCKWAIT(flags
));
572 if (so
->so_state
& SS_CANTSENDMORE
)
575 error
= so
->so_error
;
580 if ((so
->so_state
& SS_ISCONNECTED
) == 0) {
582 * `sendto' and `sendmsg' is allowed on a connection-
583 * based socket if it supports implied connect.
584 * Return ENOTCONN if not connected and no address is
587 if ((so
->so_proto
->pr_flags
& PR_CONNREQUIRED
) &&
588 (so
->so_proto
->pr_flags
& PR_IMPLOPCL
) == 0) {
589 if ((so
->so_state
& SS_ISCONFIRMING
) == 0 &&
590 !(resid
== 0 && clen
!= 0))
592 } else if (addr
== 0)
593 gotoerr(so
->so_proto
->pr_flags
& PR_CONNREQUIRED
?
594 ENOTCONN
: EDESTADDRREQ
);
596 if ((atomic
&& resid
> so
->so_snd
.ssb_hiwat
) ||
597 clen
> so
->so_snd
.ssb_hiwat
) {
600 space
= ssb_space(&so
->so_snd
);
603 if ((space
< 0 || (size_t)space
< resid
+ clen
) && uio
&&
604 (atomic
|| space
< so
->so_snd
.ssb_lowat
|| space
< clen
)) {
605 if (flags
& (MSG_FNONBLOCKING
|MSG_DONTWAIT
))
606 gotoerr(EWOULDBLOCK
);
607 ssb_unlock(&so
->so_snd
);
608 error
= ssb_wait(&so
->so_snd
);
620 * Data is prepackaged in "top".
624 top
->m_flags
|= M_EOR
;
628 m
= m_getl((int)resid
, MB_WAIT
, MT_DATA
,
629 top
== NULL
? M_PKTHDR
: 0, &mlen
);
632 m
->m_pkthdr
.rcvif
= NULL
;
634 len
= imin((int)szmin(mlen
, resid
), space
);
635 if (resid
< MINCLSIZE
) {
637 * For datagram protocols, leave room
638 * for protocol headers in first mbuf.
640 if (atomic
&& top
== 0 && len
< mlen
)
644 error
= uiomove(mtod(m
, caddr_t
), (size_t)len
, uio
);
645 resid
= uio
->uio_resid
;
648 top
->m_pkthdr
.len
+= len
;
654 top
->m_flags
|= M_EOR
;
657 } while (space
> 0 && atomic
);
659 so
->so_options
|= SO_DONTROUTE
;
660 if (flags
& MSG_OOB
) {
661 pru_flags
= PRUS_OOB
;
662 } else if ((flags
& MSG_EOF
) &&
663 (so
->so_proto
->pr_flags
& PR_IMPLOPCL
) &&
666 * If the user set MSG_EOF, the protocol
667 * understands this flag and nothing left to
668 * send then use PRU_SEND_EOF instead of PRU_SEND.
670 pru_flags
= PRUS_EOF
;
671 } else if (resid
> 0 && space
> 0) {
672 /* If there is more to send, set PRUS_MORETOCOME */
673 pru_flags
= PRUS_MORETOCOME
;
679 * XXX all the SS_CANTSENDMORE checks previously
680 * done could be out of date. We could have recieved
681 * a reset packet in an interrupt or maybe we slept
682 * while doing page faults in uiomove() etc. We could
683 * probably recheck again inside the splnet() protection
684 * here, but there are probably other places that this
685 * also happens. We must rethink this.
687 error
= so_pru_send(so
, pru_flags
, top
, addr
, control
, td
);
690 so
->so_options
&= ~SO_DONTROUTE
;
697 } while (resid
&& space
> 0);
701 ssb_unlock(&so
->so_snd
);
711 * A specialization of sosend() for UDP based on protocol-specific knowledge:
712 * so->so_proto->pr_flags has the PR_ATOMIC field set. This means that
713 * sosendallatonce() returns true,
714 * the "atomic" variable is true,
715 * and sosendudp() blocks until space is available for the entire send.
716 * so->so_proto->pr_flags does not have the PR_CONNREQUIRED or
717 * PR_IMPLOPCL flags set.
718 * UDP has no out-of-band data.
719 * UDP has no control data.
720 * UDP does not support MSG_EOR.
723 sosendudp(struct socket
*so
, struct sockaddr
*addr
, struct uio
*uio
,
724 struct mbuf
*top
, struct mbuf
*control
, int flags
, struct thread
*td
)
726 boolean_t dontroute
; /* temporary SO_DONTROUTE setting */
731 if (td
->td_lwp
!= NULL
)
732 td
->td_lwp
->lwp_ru
.ru_msgsnd
++;
736 KASSERT((uio
&& !top
) || (top
&& !uio
), ("bad arguments to sosendudp"));
737 resid
= uio
? uio
->uio_resid
: (size_t)top
->m_pkthdr
.len
;
740 error
= ssb_lock(&so
->so_snd
, SBLOCKWAIT(flags
));
745 if (so
->so_state
& SS_CANTSENDMORE
)
748 error
= so
->so_error
;
753 if (!(so
->so_state
& SS_ISCONNECTED
) && addr
== NULL
)
754 gotoerr(EDESTADDRREQ
);
755 if (resid
> so
->so_snd
.ssb_hiwat
)
757 space
= ssb_space(&so
->so_snd
);
758 if (uio
&& (space
< 0 || (size_t)space
< resid
)) {
759 if (flags
& (MSG_FNONBLOCKING
|MSG_DONTWAIT
))
760 gotoerr(EWOULDBLOCK
);
761 ssb_unlock(&so
->so_snd
);
762 error
= ssb_wait(&so
->so_snd
);
771 top
= m_uiomove(uio
);
776 dontroute
= (flags
& MSG_DONTROUTE
) && !(so
->so_options
& SO_DONTROUTE
);
778 so
->so_options
|= SO_DONTROUTE
;
780 error
= so_pru_send(so
, 0, top
, addr
, NULL
, td
);
781 top
= NULL
; /* sent or freed in lower layer */
784 so
->so_options
&= ~SO_DONTROUTE
;
787 ssb_unlock(&so
->so_snd
);
795 * Implement receive operations on a socket.
796 * We depend on the way that records are added to the signalsockbuf
797 * by sbappend*. In particular, each record (mbufs linked through m_next)
798 * must begin with an address if the protocol so specifies,
799 * followed by an optional mbuf or mbufs containing ancillary data,
800 * and then zero or more mbufs of data.
801 * In order to avoid blocking network interrupts for the entire time here,
802 * we exit the critical section while doing the actual copy to user space.
803 * Although the signalsockbuf is locked, new data may still be appended,
804 * and thus we must maintain consistency of the signalsockbuf during that time.
806 * The caller may receive the data as a single mbuf chain by supplying
807 * an mbuf **mp0 for use in returning the chain. The uio is then used
808 * only for the count in uio_resid.
811 soreceive(struct socket
*so
, struct sockaddr
**psa
, struct uio
*uio
,
812 struct sockbuf
*sio
, struct mbuf
**controlp
, int *flagsp
)
815 struct mbuf
*free_chain
= NULL
;
816 int flags
, len
, error
, offset
;
817 struct protosw
*pr
= so
->so_proto
;
819 size_t resid
, orig_resid
;
822 resid
= uio
->uio_resid
;
824 resid
= (size_t)(sio
->sb_climit
- sio
->sb_cc
);
832 flags
= *flagsp
&~ MSG_EOR
;
835 if (flags
& MSG_OOB
) {
836 m
= m_get(MB_WAIT
, MT_DATA
);
839 error
= so_pru_rcvoob(so
, m
, flags
& MSG_PEEK
);
845 KKASSERT(resid
>= (size_t)m
->m_len
);
846 resid
-= (size_t)m
->m_len
;
847 } while (resid
> 0 && m
);
850 uio
->uio_resid
= resid
;
851 error
= uiomove(mtod(m
, caddr_t
),
852 (int)szmin(resid
, m
->m_len
),
854 resid
= uio
->uio_resid
;
856 } while (uio
->uio_resid
&& error
== 0 && m
);
863 if ((so
->so_state
& SS_ISCONFIRMING
) && resid
)
868 error
= ssb_lock(&so
->so_rcv
, SBLOCKWAIT(flags
));
872 m
= so
->so_rcv
.ssb_mb
;
874 * If we have less data than requested, block awaiting more
875 * (subject to any timeout) if:
876 * 1. the current count is less than the low water mark, or
877 * 2. MSG_WAITALL is set, and it is possible to do the entire
878 * receive operation at once if we block (resid <= hiwat).
879 * 3. MSG_DONTWAIT is not set
880 * If MSG_WAITALL is set but resid is larger than the receive buffer,
881 * we have to do the receive in sections, and thus risk returning
882 * a short count if a timeout or signal occurs after we start.
884 if (m
== NULL
|| (((flags
& MSG_DONTWAIT
) == 0 &&
885 (size_t)so
->so_rcv
.ssb_cc
< resid
) &&
886 (so
->so_rcv
.ssb_cc
< so
->so_rcv
.ssb_lowat
||
887 ((flags
& MSG_WAITALL
) && resid
<= (size_t)so
->so_rcv
.ssb_hiwat
)) &&
888 m
->m_nextpkt
== 0 && (pr
->pr_flags
& PR_ATOMIC
) == 0)) {
889 KASSERT(m
!= NULL
|| !so
->so_rcv
.ssb_cc
, ("receive 1"));
893 error
= so
->so_error
;
894 if ((flags
& MSG_PEEK
) == 0)
898 if (so
->so_state
& SS_CANTRCVMORE
) {
904 for (; m
; m
= m
->m_next
) {
905 if (m
->m_type
== MT_OOBDATA
|| (m
->m_flags
& M_EOR
)) {
906 m
= so
->so_rcv
.ssb_mb
;
910 if ((so
->so_state
& (SS_ISCONNECTED
|SS_ISCONNECTING
)) == 0 &&
911 (pr
->pr_flags
& PR_CONNREQUIRED
)) {
917 if (flags
& (MSG_FNONBLOCKING
|MSG_DONTWAIT
)) {
921 ssb_unlock(&so
->so_rcv
);
922 error
= ssb_wait(&so
->so_rcv
);
929 if (uio
&& uio
->uio_td
&& uio
->uio_td
->td_proc
)
930 uio
->uio_td
->td_lwp
->lwp_ru
.ru_msgrcv
++;
933 * note: m should be == sb_mb here. Cache the next record while
934 * cleaning up. Note that calling m_free*() will break out critical
937 KKASSERT(m
== so
->so_rcv
.ssb_mb
);
940 * Skip any address mbufs prepending the record.
942 if (pr
->pr_flags
& PR_ADDR
) {
943 KASSERT(m
->m_type
== MT_SONAME
, ("receive 1a"));
946 *psa
= dup_sockaddr(mtod(m
, struct sockaddr
*));
947 if (flags
& MSG_PEEK
)
950 m
= sbunlinkmbuf(&so
->so_rcv
.sb
, m
, &free_chain
);
954 * Skip any control mbufs prepending the record.
957 if (pr
->pr_flags
& PR_ADDR_OPT
) {
959 * For SCTP we may be getting a
960 * whole message OR a partial delivery.
962 if (m
&& m
->m_type
== MT_SONAME
) {
965 *psa
= dup_sockaddr(mtod(m
, struct sockaddr
*));
966 if (flags
& MSG_PEEK
)
969 m
= sbunlinkmbuf(&so
->so_rcv
.sb
, m
, &free_chain
);
973 while (m
&& m
->m_type
== MT_CONTROL
&& error
== 0) {
974 if (flags
& MSG_PEEK
) {
976 *controlp
= m_copy(m
, 0, m
->m_len
);
977 m
= m
->m_next
; /* XXX race */
980 n
= sbunlinkmbuf(&so
->so_rcv
.sb
, m
, NULL
);
981 if (pr
->pr_domain
->dom_externalize
&&
982 mtod(m
, struct cmsghdr
*)->cmsg_type
==
984 error
= (*pr
->pr_domain
->dom_externalize
)(m
);
988 m
= sbunlinkmbuf(&so
->so_rcv
.sb
, m
, &free_chain
);
991 if (controlp
&& *controlp
) {
993 controlp
= &(*controlp
)->m_next
;
1002 if (type
== MT_OOBDATA
)
1007 * Copy to the UIO or mbuf return chain (*mp).
1011 while (m
&& resid
> 0 && error
== 0) {
1012 if (m
->m_type
== MT_OOBDATA
) {
1013 if (type
!= MT_OOBDATA
)
1015 } else if (type
== MT_OOBDATA
)
1018 KASSERT(m
->m_type
== MT_DATA
|| m
->m_type
== MT_HEADER
,
1020 so
->so_state
&= ~SS_RCVATMARK
;
1021 len
= (resid
> INT_MAX
) ? INT_MAX
: resid
;
1022 if (so
->so_oobmark
&& len
> so
->so_oobmark
- offset
)
1023 len
= so
->so_oobmark
- offset
;
1024 if (len
> m
->m_len
- moff
)
1025 len
= m
->m_len
- moff
;
1028 * Copy out to the UIO or pass the mbufs back to the SIO.
1029 * The SIO is dealt with when we eat the mbuf, but deal
1030 * with the resid here either way.
1034 uio
->uio_resid
= resid
;
1035 error
= uiomove(mtod(m
, caddr_t
) + moff
, len
, uio
);
1036 resid
= uio
->uio_resid
;
1041 resid
-= (size_t)len
;
1045 * Eat the entire mbuf or just a piece of it
1047 if (len
== m
->m_len
- moff
) {
1048 if (m
->m_flags
& M_EOR
)
1051 if (m
->m_flags
& M_NOTIFICATION
)
1052 flags
|= MSG_NOTIFICATION
;
1054 if (flags
& MSG_PEEK
) {
1059 n
= sbunlinkmbuf(&so
->so_rcv
.sb
, m
, NULL
);
1063 m
= sbunlinkmbuf(&so
->so_rcv
.sb
, m
, &free_chain
);
1067 if (flags
& MSG_PEEK
) {
1071 n
= m_copym(m
, 0, len
, MB_WAIT
);
1077 so
->so_rcv
.ssb_cc
-= len
;
1080 if (so
->so_oobmark
) {
1081 if ((flags
& MSG_PEEK
) == 0) {
1082 so
->so_oobmark
-= len
;
1083 if (so
->so_oobmark
== 0) {
1084 so
->so_state
|= SS_RCVATMARK
;
1089 if (offset
== so
->so_oobmark
)
1093 if (flags
& MSG_EOR
)
1096 * If the MSG_WAITALL flag is set (for non-atomic socket),
1097 * we must not quit until resid == 0 or an error
1098 * termination. If a signal/timeout occurs, return
1099 * with a short count but without error.
1100 * Keep signalsockbuf locked against other readers.
1102 while ((flags
& MSG_WAITALL
) && m
== NULL
&&
1103 resid
> 0 && !sosendallatonce(so
) &&
1104 so
->so_rcv
.ssb_mb
== NULL
) {
1105 if (so
->so_error
|| so
->so_state
& SS_CANTRCVMORE
)
1108 * The window might have closed to zero, make
1109 * sure we send an ack now that we've drained
1110 * the buffer or we might end up blocking until
1111 * the idle takes over (5 seconds).
1113 if (pr
->pr_flags
& PR_WANTRCVD
&& so
->so_pcb
)
1114 so_pru_rcvd(so
, flags
);
1115 error
= ssb_wait(&so
->so_rcv
);
1117 ssb_unlock(&so
->so_rcv
);
1121 m
= so
->so_rcv
.ssb_mb
;
1126 * If an atomic read was requested but unread data still remains
1127 * in the record, set MSG_TRUNC.
1129 if (m
&& pr
->pr_flags
& PR_ATOMIC
)
1133 * Cleanup. If an atomic read was requested drop any unread data.
1135 if ((flags
& MSG_PEEK
) == 0) {
1136 if (m
&& (pr
->pr_flags
& PR_ATOMIC
))
1137 sbdroprecord(&so
->so_rcv
.sb
);
1138 if ((pr
->pr_flags
& PR_WANTRCVD
) && so
->so_pcb
)
1139 so_pru_rcvd(so
, flags
);
1142 if (orig_resid
== resid
&& orig_resid
&&
1143 (flags
& MSG_EOR
) == 0 && (so
->so_state
& SS_CANTRCVMORE
) == 0) {
1144 ssb_unlock(&so
->so_rcv
);
1152 ssb_unlock(&so
->so_rcv
);
1156 m_freem(free_chain
);
1161 soshutdown(struct socket
*so
, int how
)
1163 if (!(how
== SHUT_RD
|| how
== SHUT_WR
|| how
== SHUT_RDWR
))
1169 return (so_pru_shutdown(so
));
1174 sorflush(struct socket
*so
)
1176 struct signalsockbuf
*ssb
= &so
->so_rcv
;
1177 struct protosw
*pr
= so
->so_proto
;
1178 struct signalsockbuf asb
;
1180 ssb
->ssb_flags
|= SSB_NOINTR
;
1181 (void) ssb_lock(ssb
, M_WAITOK
);
1187 bzero((caddr_t
)ssb
, sizeof (*ssb
));
1188 if (asb
.ssb_flags
& SSB_KNOTE
) {
1189 ssb
->ssb_sel
.si_note
= asb
.ssb_sel
.si_note
;
1190 ssb
->ssb_flags
= SSB_KNOTE
;
1194 if (pr
->pr_flags
& PR_RIGHTS
&& pr
->pr_domain
->dom_dispose
)
1195 (*pr
->pr_domain
->dom_dispose
)(asb
.ssb_mb
);
1196 ssb_release(&asb
, so
);
1201 do_setopt_accept_filter(struct socket
*so
, struct sockopt
*sopt
)
1203 struct accept_filter_arg
*afap
= NULL
;
1204 struct accept_filter
*afp
;
1205 struct so_accf
*af
= so
->so_accf
;
1208 /* do not set/remove accept filters on non listen sockets */
1209 if ((so
->so_options
& SO_ACCEPTCONN
) == 0) {
1214 /* removing the filter */
1217 if (af
->so_accept_filter
!= NULL
&&
1218 af
->so_accept_filter
->accf_destroy
!= NULL
) {
1219 af
->so_accept_filter
->accf_destroy(so
);
1221 if (af
->so_accept_filter_str
!= NULL
) {
1222 FREE(af
->so_accept_filter_str
, M_ACCF
);
1227 so
->so_options
&= ~SO_ACCEPTFILTER
;
1230 /* adding a filter */
1231 /* must remove previous filter first */
1236 /* don't put large objects on the kernel stack */
1237 MALLOC(afap
, struct accept_filter_arg
*, sizeof(*afap
), M_TEMP
, M_WAITOK
);
1238 error
= sooptcopyin(sopt
, afap
, sizeof *afap
, sizeof *afap
);
1239 afap
->af_name
[sizeof(afap
->af_name
)-1] = '\0';
1240 afap
->af_arg
[sizeof(afap
->af_arg
)-1] = '\0';
1243 afp
= accept_filt_get(afap
->af_name
);
1248 MALLOC(af
, struct so_accf
*, sizeof(*af
), M_ACCF
, M_WAITOK
| M_ZERO
);
1249 if (afp
->accf_create
!= NULL
) {
1250 if (afap
->af_name
[0] != '\0') {
1251 int len
= strlen(afap
->af_name
) + 1;
1253 MALLOC(af
->so_accept_filter_str
, char *, len
, M_ACCF
, M_WAITOK
);
1254 strcpy(af
->so_accept_filter_str
, afap
->af_name
);
1256 af
->so_accept_filter_arg
= afp
->accf_create(so
, afap
->af_arg
);
1257 if (af
->so_accept_filter_arg
== NULL
) {
1258 FREE(af
->so_accept_filter_str
, M_ACCF
);
1265 af
->so_accept_filter
= afp
;
1267 so
->so_options
|= SO_ACCEPTFILTER
;
1276 * Perhaps this routine, and sooptcopyout(), below, ought to come in
1277 * an additional variant to handle the case where the option value needs
1278 * to be some kind of integer, but not a specific size.
1279 * In addition to their use here, these functions are also called by the
1280 * protocol-level pr_ctloutput() routines.
1283 sooptcopyin(struct sockopt
*sopt
, void *buf
, size_t len
, size_t minlen
)
1285 return soopt_to_kbuf(sopt
, buf
, len
, minlen
);
1289 soopt_to_kbuf(struct sockopt
*sopt
, void *buf
, size_t len
, size_t minlen
)
1293 KKASSERT(!sopt
->sopt_val
|| kva_p(sopt
->sopt_val
));
1294 KKASSERT(kva_p(buf
));
1297 * If the user gives us more than we wanted, we ignore it,
1298 * but if we don't get the minimum length the caller
1299 * wants, we return EINVAL. On success, sopt->sopt_valsize
1300 * is set to however much we actually retrieved.
1302 if ((valsize
= sopt
->sopt_valsize
) < minlen
)
1305 sopt
->sopt_valsize
= valsize
= len
;
1307 bcopy(sopt
->sopt_val
, buf
, valsize
);
1313 sosetopt(struct socket
*so
, struct sockopt
*sopt
)
1321 sopt
->sopt_dir
= SOPT_SET
;
1322 if (sopt
->sopt_level
!= SOL_SOCKET
) {
1323 if (so
->so_proto
&& so
->so_proto
->pr_ctloutput
) {
1324 return (so_pru_ctloutput(so
, sopt
));
1326 error
= ENOPROTOOPT
;
1328 switch (sopt
->sopt_name
) {
1330 case SO_ACCEPTFILTER
:
1331 error
= do_setopt_accept_filter(so
, sopt
);
1337 error
= sooptcopyin(sopt
, &l
, sizeof l
, sizeof l
);
1341 so
->so_linger
= l
.l_linger
;
1343 so
->so_options
|= SO_LINGER
;
1345 so
->so_options
&= ~SO_LINGER
;
1351 case SO_USELOOPBACK
:
1357 error
= sooptcopyin(sopt
, &optval
, sizeof optval
,
1362 so
->so_options
|= sopt
->sopt_name
;
1364 so
->so_options
&= ~sopt
->sopt_name
;
1371 error
= sooptcopyin(sopt
, &optval
, sizeof optval
,
1377 * Values < 1 make no sense for any of these
1378 * options, so disallow them.
1385 switch (sopt
->sopt_name
) {
1388 if (ssb_reserve(sopt
->sopt_name
== SO_SNDBUF
?
1389 &so
->so_snd
: &so
->so_rcv
, (u_long
)optval
,
1391 &curproc
->p_rlimit
[RLIMIT_SBSIZE
]) == 0) {
1395 (sopt
->sopt_name
== SO_SNDBUF
? &so
->so_snd
:
1396 &so
->so_rcv
)->ssb_flags
&= ~SSB_AUTOSIZE
;
1400 * Make sure the low-water is never greater than
1404 so
->so_snd
.ssb_lowat
=
1405 (optval
> so
->so_snd
.ssb_hiwat
) ?
1406 so
->so_snd
.ssb_hiwat
: optval
;
1407 so
->so_snd
.ssb_flags
&= ~SSB_AUTOLOWAT
;
1410 so
->so_rcv
.ssb_lowat
=
1411 (optval
> so
->so_rcv
.ssb_hiwat
) ?
1412 so
->so_rcv
.ssb_hiwat
: optval
;
1413 so
->so_rcv
.ssb_flags
&= ~SSB_AUTOLOWAT
;
1420 error
= sooptcopyin(sopt
, &tv
, sizeof tv
,
1425 /* assert(hz > 0); */
1426 if (tv
.tv_sec
< 0 || tv
.tv_sec
> SHRT_MAX
/ hz
||
1427 tv
.tv_usec
< 0 || tv
.tv_usec
>= 1000000) {
1431 /* assert(tick > 0); */
1432 /* assert(ULONG_MAX - SHRT_MAX >= 1000000); */
1433 val
= (u_long
)(tv
.tv_sec
* hz
) + tv
.tv_usec
/ tick
;
1434 if (val
> SHRT_MAX
) {
1438 if (val
== 0 && tv
.tv_usec
!= 0)
1441 switch (sopt
->sopt_name
) {
1443 so
->so_snd
.ssb_timeo
= val
;
1446 so
->so_rcv
.ssb_timeo
= val
;
1451 error
= ENOPROTOOPT
;
1454 if (error
== 0 && so
->so_proto
&& so
->so_proto
->pr_ctloutput
) {
1455 (void) so_pru_ctloutput(so
, sopt
);
1462 /* Helper routine for getsockopt */
1464 sooptcopyout(struct sockopt
*sopt
, const void *buf
, size_t len
)
1466 soopt_from_kbuf(sopt
, buf
, len
);
1471 soopt_from_kbuf(struct sockopt
*sopt
, const void *buf
, size_t len
)
1476 sopt
->sopt_valsize
= 0;
1480 KKASSERT(!sopt
->sopt_val
|| kva_p(sopt
->sopt_val
));
1481 KKASSERT(kva_p(buf
));
1484 * Documented get behavior is that we always return a value,
1485 * possibly truncated to fit in the user's buffer.
1486 * Traditional behavior is that we always tell the user
1487 * precisely how much we copied, rather than something useful
1488 * like the total amount we had available for her.
1489 * Note that this interface is not idempotent; the entire answer must
1490 * generated ahead of time.
1492 valsize
= szmin(len
, sopt
->sopt_valsize
);
1493 sopt
->sopt_valsize
= valsize
;
1494 if (sopt
->sopt_val
!= 0) {
1495 bcopy(buf
, sopt
->sopt_val
, valsize
);
1500 sogetopt(struct socket
*so
, struct sockopt
*sopt
)
1506 struct accept_filter_arg
*afap
;
1510 sopt
->sopt_dir
= SOPT_GET
;
1511 if (sopt
->sopt_level
!= SOL_SOCKET
) {
1512 if (so
->so_proto
&& so
->so_proto
->pr_ctloutput
) {
1513 return (so_pru_ctloutput(so
, sopt
));
1515 return (ENOPROTOOPT
);
1517 switch (sopt
->sopt_name
) {
1519 case SO_ACCEPTFILTER
:
1520 if ((so
->so_options
& SO_ACCEPTCONN
) == 0)
1522 MALLOC(afap
, struct accept_filter_arg
*, sizeof(*afap
),
1523 M_TEMP
, M_WAITOK
| M_ZERO
);
1524 if ((so
->so_options
& SO_ACCEPTFILTER
) != 0) {
1525 strcpy(afap
->af_name
, so
->so_accf
->so_accept_filter
->accf_name
);
1526 if (so
->so_accf
->so_accept_filter_str
!= NULL
)
1527 strcpy(afap
->af_arg
, so
->so_accf
->so_accept_filter_str
);
1529 error
= sooptcopyout(sopt
, afap
, sizeof(*afap
));
1535 l
.l_onoff
= so
->so_options
& SO_LINGER
;
1536 l
.l_linger
= so
->so_linger
;
1537 error
= sooptcopyout(sopt
, &l
, sizeof l
);
1540 case SO_USELOOPBACK
:
1549 optval
= so
->so_options
& sopt
->sopt_name
;
1551 error
= sooptcopyout(sopt
, &optval
, sizeof optval
);
1555 optval
= so
->so_type
;
1559 optval
= so
->so_error
;
1564 optval
= so
->so_snd
.ssb_hiwat
;
1568 optval
= so
->so_rcv
.ssb_hiwat
;
1572 optval
= so
->so_snd
.ssb_lowat
;
1576 optval
= so
->so_rcv
.ssb_lowat
;
1581 optval
= (sopt
->sopt_name
== SO_SNDTIMEO
?
1582 so
->so_snd
.ssb_timeo
: so
->so_rcv
.ssb_timeo
);
1584 tv
.tv_sec
= optval
/ hz
;
1585 tv
.tv_usec
= (optval
% hz
) * tick
;
1586 error
= sooptcopyout(sopt
, &tv
, sizeof tv
);
1590 error
= ENOPROTOOPT
;
1597 /* XXX; prepare mbuf for (__FreeBSD__ < 3) routines. */
1599 soopt_getm(struct sockopt
*sopt
, struct mbuf
**mp
)
1601 struct mbuf
*m
, *m_prev
;
1602 int sopt_size
= sopt
->sopt_valsize
, msize
;
1604 m
= m_getl(sopt_size
, sopt
->sopt_td
? MB_WAIT
: MB_DONTWAIT
, MT_DATA
,
1608 m
->m_len
= min(msize
, sopt_size
);
1609 sopt_size
-= m
->m_len
;
1613 while (sopt_size
> 0) {
1614 m
= m_getl(sopt_size
, sopt
->sopt_td
? MB_WAIT
: MB_DONTWAIT
,
1615 MT_DATA
, 0, &msize
);
1620 m
->m_len
= min(msize
, sopt_size
);
1621 sopt_size
-= m
->m_len
;
1628 /* XXX; copyin sopt data into mbuf chain for (__FreeBSD__ < 3) routines. */
1630 soopt_mcopyin(struct sockopt
*sopt
, struct mbuf
*m
)
1632 soopt_to_mbuf(sopt
, m
);
1637 soopt_to_mbuf(struct sockopt
*sopt
, struct mbuf
*m
)
1642 KKASSERT(!sopt
->sopt_val
|| kva_p(sopt
->sopt_val
));
1644 if (sopt
->sopt_val
== NULL
)
1646 val
= sopt
->sopt_val
;
1647 valsize
= sopt
->sopt_valsize
;
1648 while (m
!= NULL
&& valsize
>= m
->m_len
) {
1649 bcopy(val
, mtod(m
, char *), m
->m_len
);
1650 valsize
-= m
->m_len
;
1651 val
= (caddr_t
)val
+ m
->m_len
;
1654 if (m
!= NULL
) /* should be allocated enoughly at ip6_sooptmcopyin() */
1655 panic("ip6_sooptmcopyin");
1658 /* XXX; copyout mbuf chain data into soopt for (__FreeBSD__ < 3) routines. */
1660 soopt_mcopyout(struct sockopt
*sopt
, struct mbuf
*m
)
1662 return soopt_from_mbuf(sopt
, m
);
1666 soopt_from_mbuf(struct sockopt
*sopt
, struct mbuf
*m
)
1668 struct mbuf
*m0
= m
;
1673 KKASSERT(!sopt
->sopt_val
|| kva_p(sopt
->sopt_val
));
1675 if (sopt
->sopt_val
== NULL
)
1677 val
= sopt
->sopt_val
;
1678 maxsize
= sopt
->sopt_valsize
;
1679 while (m
!= NULL
&& maxsize
>= m
->m_len
) {
1680 bcopy(mtod(m
, char *), val
, m
->m_len
);
1681 maxsize
-= m
->m_len
;
1682 val
= (caddr_t
)val
+ m
->m_len
;
1683 valsize
+= m
->m_len
;
1687 /* enough soopt buffer should be given from user-land */
1691 sopt
->sopt_valsize
= valsize
;
1696 sohasoutofband(struct socket
*so
)
1698 if (so
->so_sigio
!= NULL
)
1699 pgsigio(so
->so_sigio
, SIGURG
, 0);
1700 selwakeup(&so
->so_rcv
.ssb_sel
);
1704 sopoll(struct socket
*so
, int events
, struct ucred
*cred
, struct thread
*td
)
1710 if (events
& (POLLIN
| POLLRDNORM
))
1712 revents
|= events
& (POLLIN
| POLLRDNORM
);
1714 if (events
& POLLINIGNEOF
)
1715 if (so
->so_rcv
.ssb_cc
>= so
->so_rcv
.ssb_lowat
||
1716 !TAILQ_EMPTY(&so
->so_comp
) || so
->so_error
)
1717 revents
|= POLLINIGNEOF
;
1719 if (events
& (POLLOUT
| POLLWRNORM
))
1720 if (sowriteable(so
))
1721 revents
|= events
& (POLLOUT
| POLLWRNORM
);
1723 if (events
& (POLLPRI
| POLLRDBAND
))
1724 if (so
->so_oobmark
|| (so
->so_state
& SS_RCVATMARK
))
1725 revents
|= events
& (POLLPRI
| POLLRDBAND
);
1729 (POLLIN
| POLLINIGNEOF
| POLLPRI
| POLLRDNORM
|
1731 selrecord(td
, &so
->so_rcv
.ssb_sel
);
1732 so
->so_rcv
.ssb_flags
|= SSB_SEL
;
1735 if (events
& (POLLOUT
| POLLWRNORM
)) {
1736 selrecord(td
, &so
->so_snd
.ssb_sel
);
1737 so
->so_snd
.ssb_flags
|= SSB_SEL
;
1746 sokqfilter(struct file
*fp
, struct knote
*kn
)
1748 struct socket
*so
= (struct socket
*)kn
->kn_fp
->f_data
;
1749 struct signalsockbuf
*ssb
;
1751 switch (kn
->kn_filter
) {
1753 if (so
->so_options
& SO_ACCEPTCONN
)
1754 kn
->kn_fop
= &solisten_filtops
;
1756 kn
->kn_fop
= &soread_filtops
;
1760 kn
->kn_fop
= &sowrite_filtops
;
1768 SLIST_INSERT_HEAD(&ssb
->ssb_sel
.si_note
, kn
, kn_selnext
);
1769 ssb
->ssb_flags
|= SSB_KNOTE
;
1775 filt_sordetach(struct knote
*kn
)
1777 struct socket
*so
= (struct socket
*)kn
->kn_fp
->f_data
;
1780 SLIST_REMOVE(&so
->so_rcv
.ssb_sel
.si_note
, kn
, knote
, kn_selnext
);
1781 if (SLIST_EMPTY(&so
->so_rcv
.ssb_sel
.si_note
))
1782 so
->so_rcv
.ssb_flags
&= ~SSB_KNOTE
;
1788 filt_soread(struct knote
*kn
, long hint
)
1790 struct socket
*so
= (struct socket
*)kn
->kn_fp
->f_data
;
1792 kn
->kn_data
= so
->so_rcv
.ssb_cc
;
1793 if (so
->so_state
& SS_CANTRCVMORE
) {
1794 kn
->kn_flags
|= EV_EOF
;
1795 kn
->kn_fflags
= so
->so_error
;
1798 if (so
->so_error
) /* temporary udp error */
1800 if (kn
->kn_sfflags
& NOTE_LOWAT
)
1801 return (kn
->kn_data
>= kn
->kn_sdata
);
1802 return (kn
->kn_data
>= so
->so_rcv
.ssb_lowat
);
1806 filt_sowdetach(struct knote
*kn
)
1808 struct socket
*so
= (struct socket
*)kn
->kn_fp
->f_data
;
1811 SLIST_REMOVE(&so
->so_snd
.ssb_sel
.si_note
, kn
, knote
, kn_selnext
);
1812 if (SLIST_EMPTY(&so
->so_snd
.ssb_sel
.si_note
))
1813 so
->so_snd
.ssb_flags
&= ~SSB_KNOTE
;
1819 filt_sowrite(struct knote
*kn
, long hint
)
1821 struct socket
*so
= (struct socket
*)kn
->kn_fp
->f_data
;
1823 kn
->kn_data
= ssb_space(&so
->so_snd
);
1824 if (so
->so_state
& SS_CANTSENDMORE
) {
1825 kn
->kn_flags
|= EV_EOF
;
1826 kn
->kn_fflags
= so
->so_error
;
1829 if (so
->so_error
) /* temporary udp error */
1831 if (((so
->so_state
& SS_ISCONNECTED
) == 0) &&
1832 (so
->so_proto
->pr_flags
& PR_CONNREQUIRED
))
1834 if (kn
->kn_sfflags
& NOTE_LOWAT
)
1835 return (kn
->kn_data
>= kn
->kn_sdata
);
1836 return (kn
->kn_data
>= so
->so_snd
.ssb_lowat
);
1841 filt_solisten(struct knote
*kn
, long hint
)
1843 struct socket
*so
= (struct socket
*)kn
->kn_fp
->f_data
;
1845 kn
->kn_data
= so
->so_qlen
;
1846 return (! TAILQ_EMPTY(&so
->so_comp
));