File:  [DragonFly] / src / sys / sys / socketvar.h
Revision 1.12: download - view: text, annotated - select for diffs
Sat Apr 10 00:48:06 2004 UTC (10 years, 3 months ago) by hsu
Branches: MAIN
CVS tags: HEAD
Add predicate message facility.

    1: /*-
    2:  * Copyright (c) 1982, 1986, 1990, 1993
    3:  *	The Regents of the University of California.  All rights reserved.
    4:  *
    5:  * Redistribution and use in source and binary forms, with or without
    6:  * modification, are permitted provided that the following conditions
    7:  * are met:
    8:  * 1. Redistributions of source code must retain the above copyright
    9:  *    notice, this list of conditions and the following disclaimer.
   10:  * 2. Redistributions in binary form must reproduce the above copyright
   11:  *    notice, this list of conditions and the following disclaimer in the
   12:  *    documentation and/or other materials provided with the distribution.
   13:  * 3. All advertising materials mentioning features or use of this software
   14:  *    must display the following acknowledgement:
   15:  *	This product includes software developed by the University of
   16:  *	California, Berkeley and its contributors.
   17:  * 4. Neither the name of the University nor the names of its contributors
   18:  *    may be used to endorse or promote products derived from this software
   19:  *    without specific prior written permission.
   20:  *
   21:  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   22:  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   23:  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   24:  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   25:  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   26:  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   27:  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   28:  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   29:  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   30:  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   31:  * SUCH DAMAGE.
   32:  *
   33:  *	@(#)socketvar.h	8.3 (Berkeley) 2/19/95
   34:  * $FreeBSD: src/sys/sys/socketvar.h,v 1.46.2.10 2003/08/24 08:24:39 hsu Exp $
   35:  * $DragonFly: src/sys/sys/socketvar.h,v 1.12 2004/04/10 00:48:06 hsu Exp $
   36:  */
   37: 
   38: #ifndef _SYS_SOCKETVAR_H_
   39: #define _SYS_SOCKETVAR_H_
   40: 
   41: #include <sys/queue.h>			/* for TAILQ macros */
   42: #include <sys/select.h>			/* for struct selinfo */
   43: 
   44: /*
   45:  * Kernel structure per socket.
   46:  * Contains send and receive buffer queues,
   47:  * handle on protocol and pointer to protocol
   48:  * private data and error information.
   49:  */
   50: typedef	u_quad_t so_gen_t;
   51: 
   52: struct accept_filter;
   53: 
   54: struct socket {
   55: 	short	so_type;		/* generic type, see socket.h */
   56: 	short	so_options;		/* from socket call, see socket.h */
   57: 	short	so_linger;		/* time to linger while closing */
   58: 	short	so_state;		/* internal state flags SS_*, below */
   59: 	caddr_t	so_pcb;			/* protocol control block */
   60: 	struct	protosw *so_proto;	/* protocol handle */
   61: /*
   62:  * Variables for connection queuing.
   63:  * Socket where accepts occur is so_head in all subsidiary sockets.
   64:  * If so_head is 0, socket is not related to an accept.
   65:  * For head socket so_incomp queues partially completed connections,
   66:  * while so_comp is a queue of connections ready to be accepted.
   67:  * If a connection is aborted and it has so_head set, then
   68:  * it has to be pulled out of either so_incomp or so_comp.
   69:  * We allow connections to queue up based on current queue lengths
   70:  * and limit on number of queued connections for this socket.
   71:  */
   72: 	struct	socket *so_head;	/* back pointer to accept socket */
   73: 	TAILQ_HEAD(, socket) so_incomp;	/* queue of partial unaccepted connections */
   74: 	TAILQ_HEAD(, socket) so_comp;	/* queue of complete unaccepted connections */
   75: 	TAILQ_ENTRY(socket) so_list;	/* list of unaccepted connections */
   76: 	short	so_qlen;		/* number of unaccepted connections */
   77: 	short	so_incqlen;		/* number of unaccepted incomplete
   78: 					   connections */
   79: 	short	so_qlimit;		/* max number queued connections */
   80: 	short	so_timeo;		/* connection timeout */
   81: 	u_short	so_error;		/* error affecting connection */
   82: 	struct  sigio *so_sigio;	/* information for async I/O or
   83: 					   out of band data (SIGURG) */
   84: 	u_long	so_oobmark;		/* chars to oob mark */
   85: 	TAILQ_HEAD(, aiocblist) so_aiojobq; /* AIO ops waiting on socket */
   86: /*
   87:  * Variables for socket buffering.
   88:  */
   89: 	struct	sockbuf {
   90: 		u_long	sb_cc;		/* actual chars in buffer */
   91: 		u_long	sb_hiwat;	/* max actual char count */
   92: 		u_long	sb_mbcnt;	/* chars of mbufs used */
   93: 		u_long	sb_mbmax;	/* max chars of mbufs to use */
   94: 		long	sb_lowat;	/* low water mark */
   95: 		struct	mbuf *sb_mb;	/* the mbuf chain */
   96: 		struct	selinfo sb_sel;	/* process selecting read/write */
   97: 		short	sb_flags;	/* flags, see below */
   98: 		short	sb_timeo;	/* timeout for read/write */
   99: 	} so_rcv, so_snd;
  100: #define	SB_MAX		(256*1024)	/* default for max chars in sockbuf */
  101: #define	SB_LOCK		0x01		/* lock on data queue */
  102: #define	SB_WANT		0x02		/* someone is waiting to lock */
  103: #define	SB_WAIT		0x04		/* someone is waiting for data/space */
  104: #define	SB_SEL		0x08		/* someone is selecting */
  105: #define	SB_ASYNC	0x10		/* ASYNC I/O, need signals */
  106: #define	SB_UPCALL	0x20		/* someone wants an upcall */
  107: #define	SB_NOINTR	0x40		/* operations not interruptible */
  108: #define SB_AIO		0x80		/* AIO operations queued */
  109: #define SB_KNOTE	0x100		/* kernel note attached */
  110: #define SB_MEVENT	0x200		/* need message event notification */
  111: 
  112: 	void	(*so_upcall) (struct socket *, void *, int);
  113: 	void	*so_upcallarg;
  114: 	struct	ucred *so_cred;		/* user credentials */
  115: 	/* NB: generation count must not be first; easiest to make it last. */
  116: 	so_gen_t so_gencnt;		/* generation count */
  117: 	void	*so_emuldata;		/* private data for emulators */
  118: 	struct	so_accf { 
  119: 		struct	accept_filter *so_accept_filter;
  120: 		void	*so_accept_filter_arg;	/* saved filter args */
  121: 		char	*so_accept_filter_str;	/* saved user args */
  122: 	} *so_accf;
  123: };
  124: 
  125: /*
  126:  * Socket state bits.
  127:  */
  128: #define	SS_NOFDREF		0x0001	/* no file table ref any more */
  129: #define	SS_ISCONNECTED		0x0002	/* socket connected to a peer */
  130: #define	SS_ISCONNECTING		0x0004	/* in process of connecting to peer */
  131: #define	SS_ISDISCONNECTING	0x0008	/* in process of disconnecting */
  132: #define	SS_CANTSENDMORE		0x0010	/* can't send more data to peer */
  133: #define	SS_CANTRCVMORE		0x0020	/* can't receive more data from peer */
  134: #define	SS_RCVATMARK		0x0040	/* at mark on input */
  135: 
  136: #define	SS_NBIO			0x0100	/* non-blocking ops */
  137: #define	SS_ASYNC		0x0200	/* async i/o notify */
  138: #define	SS_ISCONFIRMING		0x0400	/* deciding to accept connection req */
  139: 
  140: #define	SS_INCOMP		0x0800	/* unaccepted, incomplete connection */
  141: #define	SS_COMP			0x1000	/* unaccepted, complete connection */
  142: #define	SS_ISDISCONNECTED	0x2000	/* socket disconnected from peer */
  143: 
  144: /*
  145:  * Externalized form of struct socket used by the sysctl(3) interface.
  146:  */
  147: struct	xsocket {
  148: 	size_t	xso_len;	/* length of this structure */
  149: 	struct	socket *xso_so;	/* makes a convenient handle sometimes */
  150: 	short	so_type;
  151: 	short	so_options;
  152: 	short	so_linger;
  153: 	short	so_state;
  154: 	caddr_t	so_pcb;		/* another convenient handle */
  155: 	int	xso_protocol;
  156: 	int	xso_family;
  157: 	short	so_qlen;
  158: 	short	so_incqlen;
  159: 	short	so_qlimit;
  160: 	short	so_timeo;
  161: 	u_short	so_error;
  162: 	pid_t	so_pgid;
  163: 	u_long	so_oobmark;
  164: 	struct	xsockbuf {
  165: 		u_long	sb_cc;
  166: 		u_long	sb_hiwat;
  167: 		u_long	sb_mbcnt;
  168: 		u_long	sb_mbmax;
  169: 		long	sb_lowat;
  170: 		short	sb_flags;
  171: 		short	sb_timeo;
  172: 	} so_rcv, so_snd;
  173: 	uid_t	so_uid;		/* XXX */
  174: };
  175: 
  176: /*
  177:  * Macros for sockets and socket buffering.
  178:  */
  179: 
  180: /*
  181:  * Do we need to notify the other side when I/O is possible?
  182:  */
  183: #define	sb_notify(sb)						\
  184: (((sb)->sb_flags &						\
  185:  (SB_WAIT | SB_SEL | SB_ASYNC | SB_UPCALL | SB_AIO | SB_KNOTE | SB_MEVENT)))
  186: 
  187: /*
  188:  * How much space is there in a socket buffer (so->so_snd or so->so_rcv)?
  189:  * This is problematical if the fields are unsigned, as the space might
  190:  * still be negative (cc > hiwat or mbcnt > mbmax).  Should detect
  191:  * overflow and return 0.  Should use "lmin" but it doesn't exist now.
  192:  */
  193: #define	sbspace(sb) \
  194:     ((long) imin((int)((sb)->sb_hiwat - (sb)->sb_cc), \
  195: 	 (int)((sb)->sb_mbmax - (sb)->sb_mbcnt)))
  196: 
  197: /* do we have to send all at once on a socket? */
  198: #define	sosendallatonce(so) \
  199:     ((so)->so_proto->pr_flags & PR_ATOMIC)
  200: 
  201: /* can we read something from so? */
  202: #define	soreadable(so) \
  203:     ((so)->so_rcv.sb_cc >= (so)->so_rcv.sb_lowat || \
  204: 	((so)->so_state & SS_CANTRCVMORE) || \
  205: 	(so)->so_comp.tqh_first || (so)->so_error)
  206: 
  207: /* can we write something to so? */
  208: #define	sowriteable(so) \
  209:     ((sbspace(&(so)->so_snd) >= (so)->so_snd.sb_lowat && \
  210: 	(((so)->so_state&SS_ISCONNECTED) || \
  211: 	  ((so)->so_proto->pr_flags&PR_CONNREQUIRED)==0)) || \
  212:      ((so)->so_state & SS_CANTSENDMORE) || \
  213:      (so)->so_error)
  214: 
  215: /* adjust counters in sb reflecting allocation of m */
  216: #define	sballoc(sb, m) { \
  217: 	(sb)->sb_cc += (m)->m_len; \
  218: 	(sb)->sb_mbcnt += MSIZE; \
  219: 	if ((m)->m_flags & M_EXT) \
  220: 		(sb)->sb_mbcnt += (m)->m_ext.ext_size; \
  221: }
  222: 
  223: /* adjust counters in sb reflecting freeing of m */
  224: #define	sbfree(sb, m) { \
  225: 	(sb)->sb_cc -= (m)->m_len; \
  226: 	(sb)->sb_mbcnt -= MSIZE; \
  227: 	if ((m)->m_flags & M_EXT) \
  228: 		(sb)->sb_mbcnt -= (m)->m_ext.ext_size; \
  229: }
  230: 
  231: /*
  232:  * Set lock on sockbuf sb; sleep if lock is already held.
  233:  * Unless SB_NOINTR is set on sockbuf, sleep is interruptible.
  234:  * Returns error without lock if sleep is interrupted.
  235:  */
  236: #define sblock(sb, wf) ((sb)->sb_flags & SB_LOCK ? \
  237: 		(((wf) == M_WAITOK) ? sb_lock(sb) : EWOULDBLOCK) : \
  238: 		((sb)->sb_flags |= SB_LOCK), 0)
  239: 
  240: /* release lock on sockbuf sb */
  241: #define	sbunlock(sb) { \
  242: 	(sb)->sb_flags &= ~SB_LOCK; \
  243: 	if ((sb)->sb_flags & SB_WANT) { \
  244: 		(sb)->sb_flags &= ~SB_WANT; \
  245: 		wakeup((caddr_t)&(sb)->sb_flags); \
  246: 	} \
  247: }
  248: 
  249: #define	sorwakeup(so)	do { \
  250: 			  if (sb_notify(&(so)->so_rcv)) \
  251: 			    sowakeup((so), &(so)->so_rcv); \
  252: 			} while (0)
  253: 
  254: #define	sowwakeup(so)	do { \
  255: 			  if (sb_notify(&(so)->so_snd)) \
  256: 			    sowakeup((so), &(so)->so_snd); \
  257: 			} while (0)
  258: 
  259: #ifdef _KERNEL
  260: 
  261: /*
  262:  * Argument structure for sosetopt et seq.  This is in the KERNEL
  263:  * section because it will never be visible to user code.
  264:  */
  265: enum sopt_dir { SOPT_GET, SOPT_SET };
  266: struct sockopt {
  267: 	enum	sopt_dir sopt_dir; /* is this a get or a set? */
  268: 	int	sopt_level;	/* second arg of [gs]etsockopt */
  269: 	int	sopt_name;	/* third arg of [gs]etsockopt */
  270: 	void   *sopt_val;	/* fourth arg of [gs]etsockopt */
  271: 	size_t	sopt_valsize;	/* (almost) fifth arg of [gs]etsockopt */
  272: 	struct	thread *sopt_td; /* calling thread or null if kernel */
  273: };
  274: 
  275: struct accept_filter {
  276: 	char	accf_name[16];
  277: 	void	(*accf_callback)
  278: 		(struct socket *so, void *arg, int waitflag);
  279: 	void *	(*accf_create)
  280: 		(struct socket *so, char *arg);
  281: 	void	(*accf_destroy)
  282: 		(struct socket *so);
  283: 	SLIST_ENTRY(accept_filter) accf_next;	/* next on the list */
  284: };
  285: 
  286: #ifdef MALLOC_DECLARE
  287: MALLOC_DECLARE(M_PCB);
  288: MALLOC_DECLARE(M_SONAME);
  289: MALLOC_DECLARE(M_ACCF);
  290: #endif
  291: 
  292: extern int	maxsockets;
  293: extern u_long	sb_max;		/* nominal limit */
  294: extern u_long	sb_max_adj;	/* actual limit used by sbreserve() */
  295: extern struct	vm_zone *socket_zone;
  296: extern so_gen_t so_gencnt;
  297: 
  298: struct file;
  299: struct filedesc;
  300: struct mbuf;
  301: struct rlimit;
  302: struct sockaddr;
  303: struct stat;
  304: struct ucred;
  305: struct uio;
  306: struct knote;
  307: 
  308: /*
  309:  * File operations on sockets.
  310:  */
  311: int	soo_read (struct file *fp, struct uio *uio, struct ucred *cred,
  312: 	    int flags, struct thread *td);
  313: int	soo_write (struct file *fp, struct uio *uio, struct ucred *cred,
  314: 	    int flags, struct thread *td);
  315: int	soo_close (struct file *fp, struct thread *td);
  316: int	soo_ioctl (struct file *fp, u_long cmd, caddr_t data,
  317: 	    struct thread *td);
  318: int	soo_poll (struct file *fp, int events, struct ucred *cred,
  319: 	    struct thread *td);
  320: int	soo_stat (struct file *fp, struct stat *ub, struct thread *td);
  321: int	sokqfilter (struct file *fp, struct knote *kn);
  322: 
  323: /*
  324:  * From uipc_socket and friends
  325:  */
  326: struct	sockaddr *dup_sockaddr (struct sockaddr *sa, int canwait);
  327: int	holdsock (struct filedesc *fdp, int fdes, struct file **fpp);
  328: int	getsockaddr (struct sockaddr **namp, caddr_t uaddr, size_t len);
  329: void	sbappend (struct sockbuf *sb, struct mbuf *m);
  330: int	sbappendaddr (struct sockbuf *sb, struct sockaddr *asa,
  331: 	    struct mbuf *m0, struct mbuf *control);
  332: int	sbappendcontrol (struct sockbuf *sb, struct mbuf *m0,
  333: 	    struct mbuf *control);
  334: void	sbappendrecord (struct sockbuf *sb, struct mbuf *m0);
  335: void	sbcheck (struct sockbuf *sb);
  336: void	sbcompress (struct sockbuf *sb, struct mbuf *m, struct mbuf *n);
  337: struct mbuf *
  338: 	sbcreatecontrol (caddr_t p, int size, int type, int level);
  339: void	sbdrop (struct sockbuf *sb, int len);
  340: void	sbdroprecord (struct sockbuf *sb);
  341: void	sbflush (struct sockbuf *sb);
  342: void	sbinsertoob (struct sockbuf *sb, struct mbuf *m0);
  343: void	sbrelease (struct sockbuf *sb, struct socket *so);
  344: int	sbreserve (struct sockbuf *sb, u_long cc, struct socket *so,
  345: 		   struct rlimit *rl);
  346: void	sbtoxsockbuf (struct sockbuf *sb, struct xsockbuf *xsb);
  347: int	sbwait (struct sockbuf *sb);
  348: int	sb_lock (struct sockbuf *sb);
  349: int	soabort (struct socket *so);
  350: int	soaccept (struct socket *so, struct sockaddr **nam);
  351: struct	socket *soalloc (int waitok);
  352: int	sobind (struct socket *so, struct sockaddr *nam, struct thread *td);
  353: void	socantrcvmore (struct socket *so);
  354: void	socantsendmore (struct socket *so);
  355: int	soclose (struct socket *so);
  356: int	soconnect (struct socket *so, struct sockaddr *nam, struct thread *td);
  357: int	soconnect2 (struct socket *so1, struct socket *so2);
  358: int	socreate (int dom, struct socket **aso, int type, int proto,
  359: 	    struct thread *td);
  360: void	sodealloc (struct socket *so);
  361: int	sodisconnect (struct socket *so);
  362: void	sofree (struct socket *so);
  363: int	sogetopt (struct socket *so, struct sockopt *sopt);
  364: void	sohasoutofband (struct socket *so);
  365: void	soisconnected (struct socket *so);
  366: void	soisconnecting (struct socket *so);
  367: void	soisdisconnected (struct socket *so);
  368: void	soisdisconnecting (struct socket *so);
  369: int	solisten (struct socket *so, int backlog, struct thread *td);
  370: struct socket *sonewconn (struct socket *head, int connstatus);
  371: int	sooptcopyin (struct sockopt *sopt, void *buf, size_t len,
  372: 			 size_t minlen);
  373: int	sooptcopyout (struct sockopt *sopt, const void *buf, size_t len);
  374: 
  375: /* XXX; prepare mbuf for (__FreeBSD__ < 3) routines. */
  376: int	soopt_getm (struct sockopt *sopt, struct mbuf **mp);
  377: int	soopt_mcopyin (struct sockopt *sopt, struct mbuf *m);
  378: int	soopt_mcopyout (struct sockopt *sopt, struct mbuf *m);
  379: 
  380: int	sopoll (struct socket *so, int events, struct ucred *cred,
  381: 		    struct thread *td);
  382: int	soreceive (struct socket *so, struct sockaddr **paddr,
  383: 		       struct uio *uio, struct mbuf **mp0,
  384: 		       struct mbuf **controlp, int *flagsp);
  385: int	soreserve (struct socket *so, u_long sndcc, u_long rcvcc,
  386: 		   struct rlimit *rl);
  387: void	sorflush (struct socket *so);
  388: int	sosend (struct socket *so, struct sockaddr *addr, struct uio *uio,
  389: 		    struct mbuf *top, struct mbuf *control, int flags,
  390: 		    struct thread *td);
  391: int	sosendudp (struct socket *so, struct sockaddr *addr, struct uio *uio,
  392: 		    struct mbuf *top, struct mbuf *control, int flags,
  393: 		    struct thread *td);
  394: int	sosetopt (struct socket *so, struct sockopt *sopt);
  395: int	soshutdown (struct socket *so, int how);
  396: void	sotoxsocket (struct socket *so, struct xsocket *xso);
  397: void	sowakeup (struct socket *so, struct sockbuf *sb);
  398: 
  399: /* accept filter functions */
  400: int	accept_filt_add (struct accept_filter *filt);
  401: int	accept_filt_del (char *name);
  402: struct accept_filter *	accept_filt_get (char *name);
  403: #ifdef ACCEPT_FILTER_MOD
  404: int accept_filt_generic_mod_event (module_t mod, int event, void *data);
  405: SYSCTL_DECL(_net_inet_accf);
  406: #endif /* ACCEPT_FILTER_MOD */
  407: 
  408: #endif /* _KERNEL */
  409: 
  410: #endif /* !_SYS_SOCKETVAR_H_ */