/*-
 * SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright (c) 1982, 1986, 1990, 1993
 *	The Regents of the University of California.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#ifndef _SYS_SOCKETVAR_H_
#define _SYS_SOCKETVAR_H_

/*
 * Socket generation count type.  Also used in xinpcb, xtcpcb, xunpcb.
 */
typedef uint64_t so_gen_t;

#if defined(_KERNEL) || defined(_WANT_SOCKET)
#include <sys/queue.h>			/* for TAILQ macros */
#include <sys/selinfo.h>		/* for struct selinfo */
#include <sys/_lock.h>
#include <sys/_mutex.h>
#include <sys/osd.h>
#include <sys/_sx.h>
#include <sys/sockbuf.h>
#include <sys/_task.h>
#ifdef _KERNEL
#include <sys/caprights.h>
#include <sys/sockopt.h>
#else
#include <stdbool.h>
#endif

struct vnet;

/*
 * Kernel structure per socket.
 * Contains send and receive buffer queues,
 * handle on protocol and pointer to protocol
 * private data and error information.
 */
typedef	int so_upcall_t(struct socket *, void *, int);
typedef	void so_dtor_t(struct socket *);

struct socket;

enum socket_qstate {
	SQ_NONE = 0,
	SQ_INCOMP = 0x0800,	/* on sol_incomp */
	SQ_COMP = 0x1000,	/* on sol_comp */
};


struct so_splice {
	struct socket *src;
	struct socket *dst;
	off_t max;		/* maximum bytes to splice, or -1 */
	struct mtx mtx;
	unsigned int wq_index;
	enum so_splice_state {
		SPLICE_INIT,	/* embryonic state, don't queue work yet */
		SPLICE_IDLE,	/* waiting for work to arrive */
		SPLICE_QUEUED,	/* a wakeup has queued some work */
		SPLICE_RUNNING,	/* currently transferring data */
		SPLICE_CLOSING,	/* waiting for work to drain */
		SPLICE_CLOSED,	/* unsplicing, terminal state */
		SPLICE_EXCEPTION, /* I/O error or limit, implicit unsplice */
	} state;
	struct timeout_task timeout;
	STAILQ_ENTRY(so_splice) next;
};

/*-
 * Locking key to struct socket:
 * (a) constant after allocation, no locking required.
 * (b) locked by SOCK_LOCK(so).
 * (cr) locked by SOCK_RECVBUF_LOCK(so)
 * (cs) locked by SOCK_SENDBUF_LOCK(so)
 * (e) locked by SOLISTEN_LOCK() of corresponding listening socket.
 * (f) not locked since integer reads/writes are atomic.
 * (g) used only as a sleep/wakeup address, no value.
 * (h) locked by global mutex so_global_mtx.
 * (ir,is) locked by recv or send I/O locks.
 * (k) locked by KTLS workqueue mutex
 */
TAILQ_HEAD(accept_queue, socket);
struct socket {
	struct mtx	so_lock;
	volatile u_int	so_count;	/* (b / refcount) */
	struct selinfo	so_rdsel;	/* (b/cr) for so_rcv/so_comp */
	struct selinfo	so_wrsel;	/* (b/cs) for so_snd */
	int	so_options;		/* (b) from socket call, see socket.h */
	short	so_type;		/* (a) generic type, see socket.h */
	short	so_state;		/* (b) internal state flags SS_* */
	void	*so_pcb;		/* protocol control block */
	struct	vnet *so_vnet;		/* (a) network stack instance */
	struct	protosw *so_proto;	/* (a) protocol handle */
	short	so_linger;		/* time to linger close(2) */
	short	so_timeo;		/* (g) connection timeout */
	u_short	so_error;		/* (f) error affecting connection */
	u_short so_rerror;		/* (f) error affecting connection */
	struct	sigio *so_sigio;	/* [sg] information for async I/O or
					   out of band data (SIGURG) */
	struct	ucred *so_cred;		/* (a) user credentials */
	struct	label *so_label;	/* (b) MAC label for socket */
	/* NB: generation count must not be first. */
	so_gen_t so_gencnt;		/* (h) generation count */
	void	*so_emuldata;		/* (b) private data for emulators */
	so_dtor_t *so_dtor;		/* (b) optional destructor */
	struct	osd	osd;		/* Object Specific extensions */
	/*
	 * so_fibnum, so_user_cookie and friends can be used to attach
	 * some user-specified metadata to a socket, which then can be
	 * used by the kernel for various actions.
	 * so_user_cookie is used by ipfw/dummynet.
	 */
	int so_fibnum;		/* routing domain for this socket */
	uint32_t so_user_cookie;

	int so_ts_clock;	/* type of the clock used for timestamps */
	uint32_t so_max_pacing_rate;	/* (f) TX rate limit in bytes/s */
	struct so_splice *so_splice;	/* (b) splice state for sink */
	struct so_splice *so_splice_back; /* (b) splice state for source */
	off_t so_splice_sent;	/* (ir) splice bytes sent so far */

	/*
	 * Mutexes to prevent interleaving of socket I/O.  These have to be
	 * outside of the socket buffers in order to interlock with listen(2).
	 */
	struct sx so_snd_sx __aligned(CACHE_LINE_SIZE);
	struct mtx so_snd_mtx;

	struct sx so_rcv_sx __aligned(CACHE_LINE_SIZE);
	struct mtx so_rcv_mtx;

	union {
		/* Regular (data flow) socket. */
		struct {
			/* (cr, cs) Receive and send buffers. */
			struct sockbuf		so_rcv, so_snd;

			/* (e) Our place on accept queue. */
			TAILQ_ENTRY(socket)	so_list;
			struct socket		*so_listen;	/* (b) */
			enum socket_qstate so_qstate;		/* (b) */
			/* (b) cached MAC label for peer */
			struct	label		*so_peerlabel;
			u_long	so_oobmark;	/* chars to oob mark */

			/* (k) Our place on KTLS RX work queue. */
			STAILQ_ENTRY(socket)	so_ktls_rx_list;
		};
		/*
		 * Listening socket, where accepts occur, is so_listen in all
		 * subsidiary sockets.  If so_listen is NULL, socket is not
		 * related to an accept.  For a listening socket itself
		 * sol_incomp queues partially completed connections, while
		 * sol_comp is a queue of connections ready to be accepted.
		 * If a connection is aborted and it has so_listen set, then
		 * it has to be pulled out of either sol_incomp or sol_comp.
		 * We allow connections to queue up based on current queue
		 * lengths and limit on number of queued connections for this
		 * socket.
		 */
		struct {
			/* (e) queue of partial unaccepted connections */
			struct accept_queue	sol_incomp;
			/* (e) queue of complete unaccepted connections */
			struct accept_queue	sol_comp;
			u_int	sol_qlen;    /* (e) sol_comp length */
			u_int	sol_incqlen; /* (e) sol_incomp length */
			u_int	sol_qlimit;  /* (e) queue limit */

			/* accept_filter(9) optional data */
			struct	accept_filter	*sol_accept_filter;
			void	*sol_accept_filter_arg;	/* saved filter args */
			char	*sol_accept_filter_str;	/* saved user args */

			/* Optional upcall, for kernel socket. */
			so_upcall_t	*sol_upcall;	/* (e) */
			void		*sol_upcallarg;	/* (e) */

			/* Socket buffer parameters, to be copied to
			 * dataflow sockets, accepted from this one. */
			int		sol_sbrcv_lowat;
			int		sol_sbsnd_lowat;
			u_int		sol_sbrcv_hiwat;
			u_int		sol_sbsnd_hiwat;
			short		sol_sbrcv_flags;
			short		sol_sbsnd_flags;
			sbintime_t	sol_sbrcv_timeo;
			sbintime_t	sol_sbsnd_timeo;

			/* Information tracking listen queue overflows. */
			struct timeval	sol_lastover;	/* (e) */
			int		sol_overcount;	/* (e) */
		};
	};
};
#endif	/* defined(_KERNEL) || defined(_WANT_SOCKET) */

/*
 * Socket state bits.
 *
 * Historically, these bits were all kept in the so_state field.
 * They are now split into separate, lock-specific fields.
 * so_state maintains basic socket state protected by the socket lock.
 * so_qstate holds information about the socket accept queues.
 * Each socket buffer also has a state field holding information
 * relevant to that socket buffer (can't send, rcv).
 * Many fields will be read without locks to improve performance and avoid
 * lock order issues.  However, this approach must be used with caution.
 */
#define	SS_ISCONNECTED		0x0002	/* socket connected to a peer */
#define	SS_ISCONNECTING		0x0004	/* in process of connecting to peer */
#define	SS_ISDISCONNECTING	0x0008	/* in process of disconnecting */
#define	SS_NBIO			0x0100	/* non-blocking ops */
#define	SS_ASYNC		0x0200	/* async i/o notify */
/* was	SS_ISCONFIRMING		0x0400	*/
#define	SS_ISDISCONNECTED	0x2000	/* socket disconnected from peer */

#ifdef _KERNEL

#define	SOCK_MTX(so)		(&(so)->so_lock)
#define	SOCK_LOCK(so)		mtx_lock(&(so)->so_lock)
#define	SOCK_OWNED(so)		mtx_owned(&(so)->so_lock)
#define	SOCK_UNLOCK(so)		mtx_unlock(&(so)->so_lock)
#define	SOCK_LOCK_ASSERT(so)	mtx_assert(&(so)->so_lock, MA_OWNED)
#define	SOCK_UNLOCK_ASSERT(so)	mtx_assert(&(so)->so_lock, MA_NOTOWNED)

#define	SOLISTENING(sol)	(((sol)->so_options & SO_ACCEPTCONN) != 0)
#define	SOLISTEN_LOCK(sol)	do {					\
	mtx_lock(&(sol)->so_lock);					\
	KASSERT(SOLISTENING(sol),					\
	    ("%s: %p not listening", __func__, (sol)));			\
} while (0)
#define	SOLISTEN_TRYLOCK(sol)	mtx_trylock(&(sol)->so_lock)
#define	SOLISTEN_UNLOCK(sol)	do {					\
	KASSERT(SOLISTENING(sol),					\
	    ("%s: %p not listening", __func__, (sol)));			\
	mtx_unlock(&(sol)->so_lock);					\
} while (0)
#define	SOLISTEN_LOCK_ASSERT(sol)	do {				\
	mtx_assert(&(sol)->so_lock, MA_OWNED);				\
	KASSERT(SOLISTENING(sol),					\
	    ("%s: %p not listening", __func__, (sol)));			\
} while (0)
#define	SOLISTEN_UNLOCK_ASSERT(sol)	do {				\
	mtx_assert(&(sol)->so_lock, MA_NOTOWNED);			\
	KASSERT(SOLISTENING(sol),					\
	    ("%s: %p not listening", __func__, (sol)));			\
} while (0)

/*
 * Socket buffer locks.  These are strongly preferred over SOCKBUF_LOCK(sb)
 * macros, as we are moving towards protocol specific socket buffers.
 */
#define	SOCK_RECVBUF_MTX(so)						\
	(&(so)->so_rcv_mtx)
#define	SOCK_RECVBUF_LOCK(so)						\
	mtx_lock(SOCK_RECVBUF_MTX(so))
#define	SOCK_RECVBUF_UNLOCK(so)						\
	mtx_unlock(SOCK_RECVBUF_MTX(so))
#define	SOCK_RECVBUF_LOCK_ASSERT(so)					\
	mtx_assert(SOCK_RECVBUF_MTX(so), MA_OWNED)
#define	SOCK_RECVBUF_UNLOCK_ASSERT(so)					\
	mtx_assert(SOCK_RECVBUF_MTX(so), MA_NOTOWNED)

#define	SOCK_SENDBUF_MTX(so)						\
	(&(so)->so_snd_mtx)
#define	SOCK_SENDBUF_LOCK(so)						\
	mtx_lock(SOCK_SENDBUF_MTX(so))
#define	SOCK_SENDBUF_UNLOCK(so)						\
	mtx_unlock(SOCK_SENDBUF_MTX(so))
#define	SOCK_SENDBUF_LOCK_ASSERT(so)					\
	mtx_assert(SOCK_SENDBUF_MTX(so), MA_OWNED)
#define	SOCK_SENDBUF_UNLOCK_ASSERT(so)					\
	mtx_assert(SOCK_SENDBUF_MTX(so), MA_NOTOWNED)

#define	SOCK_BUF_LOCK(so, which)					\
	mtx_lock(soeventmtx(so, which))
#define	SOCK_BUF_UNLOCK(so, which)					\
	mtx_unlock(soeventmtx(so, which))
#define	SOCK_BUF_LOCK_ASSERT(so, which)					\
	mtx_assert(soeventmtx(so, which), MA_OWNED)
#define	SOCK_BUF_UNLOCK_ASSERT(so, which)				\
	mtx_assert(soeventmtx(so, which), MA_NOTOWNED)

static inline struct sockbuf *
sobuf(struct socket *so, const sb_which which)
{
	return (which == SO_RCV ? &so->so_rcv : &so->so_snd);
}

static inline struct mtx *
soeventmtx(struct socket *so, const sb_which which)
{
	return (which == SO_RCV ? SOCK_RECVBUF_MTX(so) : SOCK_SENDBUF_MTX(so));
}

/*
 * Macros for sockets and socket buffering.
 */


#define	isspliced(so)		((so->so_splice != NULL &&		\
					so->so_splice->src != NULL))
#define	issplicedback(so)	((so->so_splice_back != NULL &&		\
					so->so_splice_back->dst != NULL))
/*
 * Flags to soiolock().
 */
#define	SBL_WAIT	0x00000001	/* Wait if not immediately available. */
#define	SBL_NOINTR	0x00000002	/* Force non-interruptible sleep. */
#define	SBL_VALID	(SBL_WAIT | SBL_NOINTR)

#define	SBLOCKWAIT(f)	(((f) & MSG_DONTWAIT) ? 0 : SBL_WAIT)

#define	SOCK_IO_SEND_LOCK(so, flags)					\
	soiolock((so), &(so)->so_snd_sx, (flags))
#define	SOCK_IO_SEND_UNLOCK(so)						\
	soiounlock(&(so)->so_snd_sx)
#define	SOCK_IO_SEND_ASSERT_LOCKED(so)					\
	sx_assert(&(so)->so_snd_sx, SA_LOCKED)
#define	SOCK_IO_RECV_LOCK(so, flags)					\
	soiolock((so), &(so)->so_rcv_sx, (flags))
#define	SOCK_IO_RECV_UNLOCK(so)						\
	soiounlock(&(so)->so_rcv_sx)
#define	SOCK_IO_RECV_ASSERT_LOCKED(so)					\
	sx_assert(&(so)->so_rcv_sx, SA_LOCKED)

/* do we have to send all at once on a socket? */
#define	sosendallatonce(so) \
    ((so)->so_proto->pr_flags & PR_ATOMIC)

/* can we read something from so? */
#define	soreadabledata(so) \
	(sbavail(&(so)->so_rcv) >= (so)->so_rcv.sb_lowat || \
	(so)->so_error || (so)->so_rerror)
#define	_soreadable(so) \
	(soreadabledata(so) || ((so)->so_rcv.sb_state & SBS_CANTRCVMORE))

static inline bool
soreadable(struct socket *so)
{
       if (isspliced(so))
               return (false);
       return (_soreadable(so));
}

/* can we write something to so? */
#define	sowriteable(so) \
    ((sbspace(&(so)->so_snd) >= (so)->so_snd.sb_lowat && \
	(((so)->so_state&SS_ISCONNECTED) || \
	  ((so)->so_proto->pr_flags&PR_CONNREQUIRED)==0)) || \
     ((so)->so_snd.sb_state & SBS_CANTSENDMORE) || \
     (so)->so_error)

/*
 * soref()/sorele() ref-count the socket structure.
 * soref() may be called without owning socket lock, but in that case a
 * caller must own something that holds socket, and so_count must be not 0.
 * Note that you must still explicitly close the socket, but the last ref
 * count will free the structure.
 */
#define	soref(so)	refcount_acquire(&(so)->so_count)
#define	sorele(so) do {							\
	SOCK_UNLOCK_ASSERT(so);						\
	if (!refcount_release_if_not_last(&(so)->so_count)) {		\
		SOCK_LOCK(so);						\
		sorele_locked(so);					\
	}								\
} while (0)

/*
 * In sorwakeup() and sowwakeup(), acquire the socket buffer lock to
 * avoid a non-atomic test-and-wakeup.  However, sowakeup is
 * responsible for releasing the lock if it is called.  We unlock only
 * if we don't call into sowakeup.  If any code is introduced that
 * directly invokes the underlying sowakeup() primitives, it must
 * maintain the same semantics.
 */
#define	sorwakeup(so) do {						\
	SOCK_RECVBUF_LOCK(so);						\
	sorwakeup_locked(so);						\
} while (0)

#define	sowwakeup(so) do {						\
	SOCK_SENDBUF_LOCK(so);						\
	sowwakeup_locked(so);						\
} while (0)

struct accept_filter {
	char	accf_name[16];
	int	(*accf_callback)
		(struct socket *so, void *arg, int waitflag);
	void *	(*accf_create)
		(struct socket *so, char *arg);
	void	(*accf_destroy)
		(struct socket *so);
	SLIST_ENTRY(accept_filter) accf_next;
};

#define	ACCEPT_FILTER_DEFINE(modname, filtname, cb, create, destroy, ver) \
	static struct accept_filter modname##_filter = {		\
		.accf_name = filtname,					\
		.accf_callback = cb,					\
		.accf_create = create,					\
		.accf_destroy = destroy,				\
	};								\
	static moduledata_t modname##_mod = {				\
		.name = __XSTRING(modname),				\
		.evhand = accept_filt_generic_mod_event,		\
		.priv = &modname##_filter,				\
	};								\
	DECLARE_MODULE(modname, modname##_mod, SI_SUB_DRIVERS,		\
	    SI_ORDER_MIDDLE);						\
	MODULE_VERSION(modname, ver)

#ifdef MALLOC_DECLARE
MALLOC_DECLARE(M_ACCF);
MALLOC_DECLARE(M_PCB);
MALLOC_DECLARE(M_SONAME);
#endif

/*
 * Socket specific helper hook point identifiers
 * Do not leave holes in the sequence, hook registration is a loop.
 */
#define HHOOK_SOCKET_OPT		0
#define HHOOK_SOCKET_CREATE		1
#define HHOOK_SOCKET_RCV 		2
#define HHOOK_SOCKET_SND		3
#define HHOOK_FILT_SOREAD		4
#define HHOOK_FILT_SOWRITE		5
#define HHOOK_SOCKET_CLOSE		6
#define HHOOK_SOCKET_NEWCONN		7
#define HHOOK_SOCKET_LAST		HHOOK_SOCKET_NEWCONN

struct socket_hhook_data {
	struct socket	*so;
	struct mbuf	*m;
	void		*hctx;		/* hook point specific data*/
	int		status;
};

extern int	maxsockets;
extern u_long	sb_max;
extern so_gen_t so_gencnt;

struct file;
struct filecaps;
struct filedesc;
struct mbuf;
struct sockaddr;
struct ucred;
struct uio;
enum shutdown_how;

/* Return values for socket upcalls. */
#define	SU_OK		0
#define	SU_ISCONNECTED	1

/*
 * From uipc_socket and friends
 */
int	getsockaddr(struct sockaddr **namp, const struct sockaddr *uaddr,
	    size_t len);
int	getsock_cap(struct thread *td, int fd, const cap_rights_t *rightsp,
	    struct file **fpp, struct filecaps *havecaps);
int	getsock(struct thread *td, int fd, const cap_rights_t *rightsp,
	    struct file **fpp);
void	soabort(struct socket *so);
int	soaccept(struct socket *so, struct sockaddr *sa);
int	sopeeraddr(struct socket *so, struct sockaddr *sa);
int	sosockaddr(struct socket *so, struct sockaddr *sa);
void	soaio_enqueue(struct task *task);
void	soaio_rcv(void *context, int pending);
void	soaio_snd(void *context, int pending);
int	socheckuid(struct socket *so, uid_t uid);
int	sobind(struct socket *so, struct sockaddr *nam, struct thread *td);
int	sobindat(int fd, struct socket *so, struct sockaddr *nam,
	    struct thread *td);
int	soclose(struct socket *so);
int	soconnect(struct socket *so, struct sockaddr *nam, struct thread *td);
int	soconnectat(int fd, struct socket *so, struct sockaddr *nam,
	    struct thread *td);
int	soconnect2(struct socket *so1, struct socket *so2);
int	socreate(int dom, struct socket **aso, int type, int proto,
	    struct ucred *cred, struct thread *td);
int	sodisconnect(struct socket *so);
void	sodtor_set(struct socket *, so_dtor_t *);
struct	sockaddr *sodupsockaddr(const struct sockaddr *sa, int mflags);
void	sohasoutofband(struct socket *so);
int	solisten(struct socket *so, int backlog, struct thread *td);
void	solisten_proto(struct socket *so, int backlog);
void	solisten_proto_abort(struct socket *so);
int	solisten_proto_check(struct socket *so);
bool	solisten_enqueue(struct socket *, int);
int	solisten_dequeue(struct socket *, struct socket **, int);
struct socket *
	solisten_clone(struct socket *);
struct socket *
	sonewconn(struct socket *head, int connstatus);
struct socket *
	sopeeloff(struct socket *);
int	sopoll_generic(struct socket *so, int events, struct thread *td);
int	sokqfilter_generic(struct socket *so, struct knote *kn);
int	soaio_queue_generic(struct socket *so, struct kaiocb *job);
int	soreceive(struct socket *so, struct sockaddr **paddr, struct uio *uio,
	    struct mbuf **mp0, struct mbuf **controlp, int *flagsp);
int	soreceive_stream(struct socket *so, struct sockaddr **paddr,
	    struct uio *uio, struct mbuf **mp0, struct mbuf **controlp,
	    int *flagsp);
int	soreceive_dgram(struct socket *so, struct sockaddr **paddr,
	    struct uio *uio, struct mbuf **mp0, struct mbuf **controlp,
	    int *flagsp);
int	soreceive_generic(struct socket *so, struct sockaddr **paddr,
	    struct uio *uio, struct mbuf **mp0, struct mbuf **controlp,
	    int *flagsp);
void	sorele_locked(struct socket *so);
void	sodealloc(struct socket *);
int	soreserve(struct socket *so, u_long sndcc, u_long rcvcc);
void	sorflush(struct socket *so);
int	sosend(struct socket *so, struct sockaddr *addr, struct uio *uio,
	    struct mbuf *top, struct mbuf *control, int flags,
	    struct thread *td);
int	sousrsend(struct socket *so, struct sockaddr *addr, struct uio *uio,
	    struct mbuf *control, int flags, struct proc *);
int	sosend_dgram(struct socket *so, struct sockaddr *addr,
	    struct uio *uio, struct mbuf *top, struct mbuf *control,
	    int flags, struct thread *td);
int	sosend_generic(struct socket *so, struct sockaddr *addr,
	    struct uio *uio, struct mbuf *top, struct mbuf *control,
	    int flags, struct thread *td);
int	sendfile_wait_generic(struct socket *so, off_t need, int *space);
int	sosetfib(struct socket *so, int fibnum);
int	soshutdown(struct socket *so, enum shutdown_how);
void	soupcall_clear(struct socket *, sb_which);
void	soupcall_set(struct socket *, sb_which, so_upcall_t, void *);
void	solisten_upcall_set(struct socket *, so_upcall_t, void *);
void	sorwakeup_locked(struct socket *);
void	sowwakeup_locked(struct socket *);
void	sowakeup_aio(struct socket *, sb_which);
void	solisten_wakeup(struct socket *);
int	selsocket(struct socket *so, int events, struct timeval *tv,
	    struct thread *td);
void	soisconnected(struct socket *so);
void	soisconnecting(struct socket *so);
void	soisdisconnected(struct socket *so);
void	soisdisconnecting(struct socket *so);
void	socantrcvmore(struct socket *so);
void	socantrcvmore_locked(struct socket *so);
void	socantsendmore(struct socket *so);
void	socantsendmore_locked(struct socket *so);
void	soroverflow(struct socket *so);
void	soroverflow_locked(struct socket *so);
int	soiolock(struct socket *so, struct sx *sx, int flags);
void	soiounlock(struct sx *sx);

/*
 * Socket splicing routines.
 */
void	so_splice_dispatch(struct so_splice *sp);

/*
 * Accept filter functions (duh).
 */
int	accept_filt_add(struct accept_filter *filt);
int	accept_filt_del(char *name);
struct	accept_filter *accept_filt_get(char *name);
#ifdef ACCEPT_FILTER_MOD
#ifdef SYSCTL_DECL
SYSCTL_DECL(_net_inet_accf);
#endif
int	accept_filt_generic_mod_event(module_t mod, int event, void *data);
#endif

int	pr_listen_notsupp(struct socket *so, int backlog, struct thread *td);

#endif /* _KERNEL */

/*
 * Structure to export socket from kernel to utilities, via sysctl(3).
 */
struct xsocket {
	ksize_t		xso_len;	/* length of this structure */
	kvaddr_t	xso_so;		/* kernel address of struct socket */
	kvaddr_t	so_pcb;		/* kernel address of struct inpcb */
	uint64_t	so_oobmark;
	kvaddr_t	so_splice_so;	/* kernel address of spliced socket */
	int64_t		so_spare64[7];
	int32_t		xso_protocol;
	int32_t		xso_family;
	uint32_t	so_qlen;
	uint32_t	so_incqlen;
	uint32_t	so_qlimit;
	pid_t		so_pgid;
	uid_t		so_uid;
	int32_t		so_fibnum;
	int32_t		so_spare32[7];
	int16_t		so_type;
	int16_t		so_options;
	int16_t		so_linger;
	int16_t		so_state;
	int16_t		so_timeo;
	uint16_t	so_error;
	struct xsockbuf {
		uint32_t	sb_cc;
		uint32_t	sb_hiwat;
		uint32_t	sb_mbcnt;
		uint32_t	sb_spare0;	/* was sb_mcnt */
		uint32_t	sb_spare1;	/* was sb_ccnt */
		uint32_t	sb_mbmax;
		int32_t		sb_lowat;
		int32_t		sb_timeo;
		int16_t		sb_flags;
	} so_rcv, so_snd;
};

#ifdef _KERNEL
void	sotoxsocket(struct socket *so, struct xsocket *xso);
void	sbtoxsockbuf(struct sockbuf *sb, struct xsockbuf *xsb);
#endif

/*
 * Socket buffer state bits.  Exported via libprocstat(3).
 */
#define	SBS_CANTSENDMORE	0x0010	/* can't send more data to peer */
#define	SBS_CANTRCVMORE		0x0020	/* can't receive more data from peer */
#define	SBS_RCVATMARK		0x0040	/* at mark on input */

#endif /* !_SYS_SOCKETVAR_H_ */