xref: /dragonfly/sys/sys/protosw.h (revision ad9f8794)
1 /*-
2  * Copyright (c) 1982, 1986, 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  *	@(#)protosw.h	8.1 (Berkeley) 6/2/93
34  * $FreeBSD: src/sys/sys/protosw.h,v 1.28.2.2 2001/07/03 11:02:01 ume Exp $
35  * $DragonFly: src/sys/sys/protosw.h,v 1.24 2008/10/27 02:56:30 sephe Exp $
36  */
37 
38 #ifndef _SYS_PROTOSW_H_
39 #define _SYS_PROTOSW_H_
40 
41 #ifndef _SYS_TYPES_H_
42 #include <sys/types.h>
43 #endif
44 
45 /* Forward declare these structures referenced from prototypes below. */
46 struct mbuf;
47 struct thread;
48 struct sockaddr;
49 struct socket;
50 struct sockopt;
51 
52 struct pr_output_info {
53 	pid_t	p_pid;
54 };
55 
56 #if defined(_KERNEL) || defined(_KERNEL_STRUCTURES)
57 
58 /*
59  * netmsg_t union of possible netmsgs typically sent to protocol threads.
60  */
61 typedef union netmsg *netmsg_t;
62 
63 /*
64  * Protocol switch table.
65  *
66  * Each protocol has a handle initializing one of these structures,
67  * which is used for protocol-protocol and system-protocol communication.
68  *
69  * A protocol is called through the pr_init entry before any other.
70  * Thereafter it is called every 200ms through the pr_fasttimo entry and
71  * every 500ms through the pr_slowtimo for timer based actions.
72  * The system will call the pr_drain entry if it is low on space and
73  * this should throw away any non-critical data.
74  *
75  * Protocols pass data between themselves as chains of mbufs using
76  * the pr_input and pr_output hooks.  Pr_input passes data up (towards
77  * the users) and pr_output passes it down (towards the interfaces); control
78  * information passes up and down on pr_ctlinput and pr_ctloutput.
79  * The protocol is responsible for the space occupied by any the
80  * arguments to these entries and must dispose it.
81  *
82  * In retrospect, it would be a lot nicer to use an interface
83  * similar to the vnode VOP interface.
84  */
85 struct protosw {
86 	short	pr_type;		/* socket type used for */
87 	const struct domain *pr_domain; /* domain protocol a member of */
88 	short	pr_protocol;		/* protocol number */
89 	short	pr_flags;		/* see below */
90 
91 	/*
92 	 * Protocol hooks.  These are typically called directly within the
93 	 * context of a protocol thread based on the toeplitz hash.
94 	 *
95 	 * pr_input() is called using the port supplied by the toeplitz
96 	 *	      hash via the netisr port function.
97 	 *
98 	 * pr_ctlinput() is called using the port supplied by pr_ctlport
99 	 *
100 	 * pr_ctloutput() and pr_output() are typically called
101 	 */
102 	int	(*pr_input)(struct mbuf **, int *, int);
103 					/* input to protocol (from below) */
104 	int	(*pr_output)(struct mbuf *, struct socket *, ...);
105 					/* output to protocol (from above) */
106 	void	(*pr_ctlinput)(union netmsg *);
107 					/* control input (from below) */
108 	void	(*pr_ctloutput)(union netmsg *);
109 					/* control output (from above) */
110 	struct lwkt_port *(*pr_ctlport)(int, struct sockaddr *, void *);
111 
112 	/*
113 	 * Utility hooks, not called with any particular context.
114 	 */
115 	void	(*pr_init) (void);	/* initialization hook */
116 	void	(*pr_fasttimo) (void);	/* fast timeout (200ms) */
117 	void	(*pr_slowtimo) (void);	/* slow timeout (500ms) */
118 	void	(*pr_drain) (void);	/* flush any excess space possible */
119 
120 	struct	pr_usrreqs *pr_usrreqs;	/* messaged requests to proto thread */
121 };
122 
123 #endif
124 
125 #define	PR_SLOWHZ	2		/* 2 slow timeouts per second */
126 #define	PR_FASTHZ	5		/* 5 fast timeouts per second */
127 
128 /*
129  * Values for pr_flags.
130  * PR_ADDR requires PR_ATOMIC;
131  * PR_ADDR and PR_CONNREQUIRED are mutually exclusive.
132  * PR_IMPLOPCL means that the protocol allows sendto without prior connect,
133  *	and the protocol understands the MSG_EOF flag.  The first property is
134  *	is only relevant if PR_CONNREQUIRED is set (otherwise sendto is allowed
135  *	anyhow).
136  */
137 #define	PR_ATOMIC	0x01		/* exchange atomic messages only */
138 #define	PR_ADDR		0x02		/* addresses given with messages */
139 #define	PR_CONNREQUIRED	0x04		/* connection required by protocol */
140 #define	PR_WANTRCVD	0x08		/* want PRU_RCVD calls */
141 #define	PR_RIGHTS	0x10		/* passes capabilities */
142 #define	PR_IMPLOPCL	0x20		/* implied open/close */
143 #define	PR_LASTHDR	0x40		/* enforce ipsec policy; last header */
144 #define	PR_ADDR_OPT	0x80		/* allow addresses during delivery */
145 #define PR_MPSAFE	0x0100		/* protocal is MPSAFE */
146 #define PR_SYNC_PORT	0x0200		/* synchronous port (no proto thrds) */
147 
148 /*
149  * The arguments to usrreq are:
150  *	(*protosw[].pr_usrreq)(up, req, m, nam, opt);
151  * where up is a (struct socket *), req is one of these requests,
152  * m is a optional mbuf chain containing a message,
153  * nam is an optional mbuf chain containing an address,
154  * and opt is a pointer to a socketopt structure or nil.
155  * The protocol is responsible for disposal of the mbuf chain m,
156  * the caller is responsible for any space held by nam and opt.
157  * A non-zero return from usrreq gives an
158  * UNIX error number which should be passed to higher level software.
159  */
160 #define	PRU_ATTACH		0	/* attach protocol to up */
161 #define	PRU_DETACH		1	/* detach protocol from up */
162 #define	PRU_BIND		2	/* bind socket to address */
163 #define	PRU_LISTEN		3	/* listen for connection */
164 #define	PRU_CONNECT		4	/* establish connection to peer */
165 #define	PRU_ACCEPT		5	/* accept connection from peer */
166 #define	PRU_DISCONNECT		6	/* disconnect from peer */
167 #define	PRU_SHUTDOWN		7	/* won't send any more data */
168 #define	PRU_RCVD		8	/* have taken data; more room now */
169 #define	PRU_SEND		9	/* send this data */
170 #define	PRU_ABORT		10	/* abort (fast DISCONNECT, DETATCH) */
171 #define	PRU_CONTROL		11	/* control operations on protocol */
172 #define	PRU_SENSE		12	/* return status into m */
173 #define	PRU_RCVOOB		13	/* retrieve out of band data */
174 #define	PRU_SENDOOB		14	/* send out of band data */
175 #define	PRU_SOCKADDR		15	/* fetch socket's address */
176 #define	PRU_PEERADDR		16	/* fetch peer's address */
177 #define	PRU_CONNECT2		17	/* connect two sockets */
178 #define PRU_RESERVED1		18	/* formerly PRU_SOPOLL */
179 /* begin for protocols internal use */
180 #define	PRU_FASTTIMO		19	/* 200ms timeout */
181 #define	PRU_SLOWTIMO		20	/* 500ms timeout */
182 #define	PRU_PROTORCV		21	/* receive from below */
183 #define	PRU_PROTOSEND		22	/* send to below */
184 /* end for protocol's internal use */
185 #define PRU_SEND_EOF		23	/* send and close */
186 #define	PRU_PRED		24
187 #define PRU_CTLOUTPUT		25	/* get/set opts */
188 #define PRU_NREQ		26
189 
190 #ifdef PRUREQUESTS
191 const char *prurequests[] = {
192 	"ATTACH",	"DETACH",	"BIND",		"LISTEN",
193 	"CONNECT",	"ACCEPT",	"DISCONNECT",	"SHUTDOWN",
194 	"RCVD",		"SEND",		"ABORT",	"CONTROL",
195 	"SENSE",	"RCVOOB",	"SENDOOB",	"SOCKADDR",
196 	"PEERADDR",	"CONNECT2",	"",
197 	"FASTTIMO",	"SLOWTIMO",	"PROTORCV",	"PROTOSEND",
198 	"SEND_EOF",	"PREDICATE"
199 };
200 #endif
201 
202 #if defined(_KERNEL) || defined(_KERNEL_STRUCTURES)
203 
204 struct ifnet;
205 struct stat;
206 struct ucred;
207 struct uio;
208 struct sockbuf;
209 
210 struct pru_attach_info {
211 	struct rlimit *sb_rlimit;
212 	struct ucred *p_ucred;
213 	struct vnode *fd_rdir;
214 };
215 
216 /*
217  * These are netmsg'd requests almost universally in the context of the
218  * appropriate protocol thread.  Exceptions:
219  *
220  *	pru_accept() - called synchronously from user context
221  *
222  *	pru_sosend() - called synchronously from user context, typically
223  *		       runs generic kernel code and then messages via
224  *		       pru_send().
225  *
226  *	pru_soreceive() - called synchronously from user context.  Typically
227  *			  runs generic kernel code and remains synchronous.
228  */
229 struct pr_usrreqs {
230 	void	(*pru_abort) (netmsg_t msg);
231 	void	(*pru_accept) (netmsg_t msg);	/* synchronous call */
232 	void	(*pru_attach) (netmsg_t msg);
233 	void	(*pru_bind) (netmsg_t msg);
234 	void	(*pru_connect) (netmsg_t msg);
235 	void	(*pru_connect2) (netmsg_t msg);
236 	void	(*pru_control) (netmsg_t msg);
237 	void	(*pru_detach) (netmsg_t msg);
238 	void	(*pru_disconnect) (netmsg_t msg);
239 	void	(*pru_listen) (netmsg_t msg);
240 	void	(*pru_peeraddr) (netmsg_t msg);
241 	void	(*pru_rcvd) (netmsg_t msg);
242 	void	(*pru_rcvoob) (netmsg_t msg);
243 	void	(*pru_send) (netmsg_t msg);
244 	void	(*pru_sense) (netmsg_t msg);
245 	void	(*pru_shutdown) (netmsg_t msg);
246 	void	(*pru_sockaddr) (netmsg_t msg);
247 
248 	/*
249 	 * These are direct calls.  Note that sosend() will sometimes
250 	 * be converted into an implied connect (pru_connect) with the
251 	 * mbufs and flags forwarded in pru_connect's netmsg.  It is
252 	 * otherwise typically converted to a send (pru_send).
253 	 *
254 	 * soreceive() typically remains synchronous in the user's context.
255 	 *
256 	 * Any converted calls are netmsg's to the socket's protocol thread.
257 	 */
258 	int	(*pru_sosend) (struct socket *so, struct sockaddr *addr,
259 				   struct uio *uio, struct mbuf *top,
260 				   struct mbuf *control, int flags,
261 				   struct thread *td);
262 	int	(*pru_soreceive) (struct socket *so,
263 				      struct sockaddr **paddr,
264 				      struct uio *uio,
265 				      struct sockbuf *sio,
266 				      struct mbuf **controlp, int *flagsp);
267 };
268 
269 typedef int (*pru_sosend_fn_t) (struct socket *so, struct sockaddr *addr,
270 					struct uio *uio, struct mbuf *top,
271 					struct mbuf *control, int flags,
272 					struct thread *td);
273 typedef int (*pru_soreceive_fn_t) (struct socket *so, struct sockaddr **paddr,
274 					struct uio *uio,
275 					struct sockbuf *sio,
276 					struct mbuf **controlp,
277 					int *flagsp);
278 
279 void	pr_generic_notsupp(netmsg_t msg);
280 void	pru_sense_null(netmsg_t msg);
281 
282 int	pru_sosend_notsupp(struct socket *so, struct sockaddr *addr,
283 				struct uio *uio, struct mbuf *top,
284 				struct mbuf *control, int flags,
285 				struct thread *td);
286 int	pru_soreceive_notsupp(struct socket *so,
287 				struct sockaddr **paddr,
288 				struct uio *uio,
289 				struct sockbuf *sio,
290 				struct mbuf **controlp, int *flagsp);
291 
292 struct lwkt_port *cpu0_soport(struct socket *, struct sockaddr *,
293 			      struct mbuf **);
294 struct lwkt_port *cpu0_ctlport(int, struct sockaddr *, void *);
295 
296 #endif /* _KERNEL || _KERNEL_STRUCTURES */
297 
298 /*
299  * The arguments to the ctlinput routine are
300  *	(*protosw[].pr_ctlinput)(cmd, sa, arg);
301  * where cmd is one of the commands below, sa is a pointer to a sockaddr,
302  * and arg is a `void *' argument used within a protocol family.
303  */
304 #define	PRC_IFDOWN		0	/* interface transition */
305 #define	PRC_ROUTEDEAD		1	/* select new route if possible ??? */
306 #define	PRC_IFUP		2	/* interface has come back up */
307 #define	PRC_QUENCH2		3	/* DEC congestion bit says slow down */
308 #define	PRC_QUENCH		4	/* some one said to slow down */
309 #define	PRC_MSGSIZE		5	/* message size forced drop */
310 #define	PRC_HOSTDEAD		6	/* host appears to be down */
311 #define	PRC_HOSTUNREACH		7	/* deprecated (use PRC_UNREACH_HOST) */
312 #define	PRC_UNREACH_NET		8	/* no route to network */
313 #define	PRC_UNREACH_HOST	9	/* no route to host */
314 #define	PRC_UNREACH_PROTOCOL	10	/* dst says bad protocol */
315 #define	PRC_UNREACH_PORT	11	/* bad port # */
316 /* was	PRC_UNREACH_NEEDFRAG	12	   (use PRC_MSGSIZE) */
317 #define	PRC_UNREACH_SRCFAIL	13	/* source route failed */
318 #define	PRC_REDIRECT_NET	14	/* net routing redirect */
319 #define	PRC_REDIRECT_HOST	15	/* host routing redirect */
320 #define	PRC_REDIRECT_TOSNET	16	/* redirect for type of service & net */
321 #define	PRC_REDIRECT_TOSHOST	17	/* redirect for tos & host */
322 #define	PRC_TIMXCEED_INTRANS	18	/* packet lifetime expired in transit */
323 #define	PRC_TIMXCEED_REASS	19	/* lifetime expired on reass q */
324 #define	PRC_PARAMPROB		20	/* header incorrect */
325 #define	PRC_UNREACH_ADMIN_PROHIB	21	/* packet administrativly prohibited */
326 
327 #define	PRC_NCMDS		22
328 
329 #define	PRC_IS_REDIRECT(cmd)	\
330 	((cmd) >= PRC_REDIRECT_NET && (cmd) <= PRC_REDIRECT_TOSHOST)
331 
332 #ifdef PRCREQUESTS
333 const char *prcrequests[] = {
334 	"IFDOWN", "ROUTEDEAD", "IFUP", "DEC-BIT-QUENCH2",
335 	"QUENCH", "MSGSIZE", "HOSTDEAD", "#7",
336 	"NET-UNREACH", "HOST-UNREACH", "PROTO-UNREACH", "PORT-UNREACH",
337 	"#12", "SRCFAIL-UNREACH", "NET-REDIRECT", "HOST-REDIRECT",
338 	"TOSNET-REDIRECT", "TOSHOST-REDIRECT", "TX-INTRANS", "TX-REASS",
339 	"PARAMPROB", "ADMIN-UNREACH"
340 };
341 #endif
342 
343 /*
344  * The arguments to ctloutput are:
345  *	(*protosw[].pr_ctloutput)(req, so, level, optname, optval, p);
346  * req is one of the actions listed below, so is a (struct socket *),
347  * level is an indication of which protocol layer the option is intended.
348  * optname is a protocol dependent socket option request,
349  * optval is a pointer to a mbuf-chain pointer, for value-return results.
350  * The protocol is responsible for disposal of the mbuf chain *optval
351  * if supplied,
352  * the caller is responsible for any space held by *optval, when returned.
353  * A non-zero return from usrreq gives an
354  * UNIX error number which should be passed to higher level software.
355  */
356 #define	PRCO_GETOPT	0
357 #define	PRCO_SETOPT	1
358 
359 #define	PRCO_NCMDS	2
360 
361 #ifdef PRCOREQUESTS
362 const char *prcorequests[] = {
363 	"GETOPT", "SETOPT",
364 };
365 #endif
366 
367 /*
368  * Kernel prototypes
369  */
370 #ifdef _KERNEL
371 
372 void	kpfctlinput (int, struct sockaddr *);
373 void	kpfctlinput2 (int, struct sockaddr *, void *);
374 struct protosw *pffindproto (int family, int protocol, int type);
375 struct protosw *pffindtype (int family, int type);
376 
377 #define PR_GET_MPLOCK(_pr) \
378 do { \
379 	if (((_pr)->pr_flags & PR_MPSAFE) == 0) \
380 		get_mplock(); \
381 } while (0)
382 
383 #define PR_REL_MPLOCK(_pr) \
384 do { \
385 	if (((_pr)->pr_flags & PR_MPSAFE) == 0) \
386 		rel_mplock(); \
387 } while (0)
388 
389 #endif	/* _KERNEL */
390 
391 #endif	/* _SYS_PROTOSW_H_ */
392