xref: /freebsd/sys/netinet/in_pcb.h (revision e46d47141338a644d751b14bbb194bed431e3748)
1 /*-
2  * Copyright (c) 1982, 1986, 1990, 1993
3  *	The Regents of the University of California.
4  * Copyright (c) 2010-2011 Juniper Networks, Inc.
5  * All rights reserved.
6  *
7  * Portions of this software were developed by Robert N. M. Watson under
8  * contract to Juniper Networks, Inc.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  * 3. Neither the name of the University nor the names of its contributors
19  *    may be used to endorse or promote products derived from this software
20  *    without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32  * SUCH DAMAGE.
33  *
34  *	@(#)in_pcb.h	8.1 (Berkeley) 6/10/93
35  * $FreeBSD$
36  */
37 
38 #ifndef _NETINET_IN_PCB_H_
39 #define _NETINET_IN_PCB_H_
40 
41 #include <sys/queue.h>
42 #include <sys/_lock.h>
43 #include <sys/_mutex.h>
44 #include <sys/_rwlock.h>
45 #include <net/route.h>
46 
47 #ifdef _KERNEL
48 #include <sys/lock.h>
49 #include <sys/rwlock.h>
50 #include <net/vnet.h>
51 #include <vm/uma.h>
52 #endif
53 
54 #define	in6pcb		inpcb	/* for KAME src sync over BSD*'s */
55 #define	in6p_sp		inp_sp	/* for KAME src sync over BSD*'s */
56 
57 /*
58  * struct inpcb is the common protocol control block structure used in most
59  * IP transport protocols.
60  *
61  * Pointers to local and foreign host table entries, local and foreign socket
62  * numbers, and pointers up (to a socket structure) and down (to a
63  * protocol-specific control block) are stored here.
64  */
65 LIST_HEAD(inpcbhead, inpcb);
66 LIST_HEAD(inpcbporthead, inpcbport);
67 typedef	uint64_t	inp_gen_t;
68 
69 /*
70  * PCB with AF_INET6 null bind'ed laddr can receive AF_INET input packet.
71  * So, AF_INET6 null laddr is also used as AF_INET null laddr, by utilizing
72  * the following structure.
73  */
74 struct in_addr_4in6 {
75 	u_int32_t	ia46_pad32[3];
76 	struct	in_addr	ia46_addr4;
77 };
78 
79 /*
80  * NOTE: ipv6 addrs should be 64-bit aligned, per RFC 2553.  in_conninfo has
81  * some extra padding to accomplish this.
82  * NOTE 2: tcp_syncache.c uses first 5 32-bit words, which identify fport,
83  * lport, faddr to generate hash, so these fields shouldn't be moved.
84  */
85 struct in_endpoints {
86 	u_int16_t	ie_fport;		/* foreign port */
87 	u_int16_t	ie_lport;		/* local port */
88 	/* protocol dependent part, local and foreign addr */
89 	union {
90 		/* foreign host table entry */
91 		struct	in_addr_4in6 ie46_foreign;
92 		struct	in6_addr ie6_foreign;
93 	} ie_dependfaddr;
94 	union {
95 		/* local host table entry */
96 		struct	in_addr_4in6 ie46_local;
97 		struct	in6_addr ie6_local;
98 	} ie_dependladdr;
99 	u_int32_t	ie6_zoneid;		/* scope zone id */
100 };
101 #define	ie_faddr	ie_dependfaddr.ie46_foreign.ia46_addr4
102 #define	ie_laddr	ie_dependladdr.ie46_local.ia46_addr4
103 #define	ie6_faddr	ie_dependfaddr.ie6_foreign
104 #define	ie6_laddr	ie_dependladdr.ie6_local
105 
106 /*
107  * XXX The defines for inc_* are hacks and should be changed to direct
108  * references.
109  */
110 struct in_conninfo {
111 	u_int8_t	inc_flags;
112 	u_int8_t	inc_len;
113 	u_int16_t	inc_fibnum;	/* XXX was pad, 16 bits is plenty */
114 	/* protocol dependent part */
115 	struct	in_endpoints inc_ie;
116 };
117 
118 /*
119  * Flags for inc_flags.
120  */
121 #define	INC_ISIPV6	0x01
122 
123 #define	inc_isipv6	inc_flags	/* temp compatibility */
124 #define	inc_fport	inc_ie.ie_fport
125 #define	inc_lport	inc_ie.ie_lport
126 #define	inc_faddr	inc_ie.ie_faddr
127 #define	inc_laddr	inc_ie.ie_laddr
128 #define	inc6_faddr	inc_ie.ie6_faddr
129 #define	inc6_laddr	inc_ie.ie6_laddr
130 #define	inc6_zoneid	inc_ie.ie6_zoneid
131 
132 #if defined(_KERNEL) || defined(_WANT_INPCB)
133 /*
134  * struct inpcb captures the network layer state for TCP, UDP, and raw IPv4 and
135  * IPv6 sockets.  In the case of TCP and UDP, further per-connection state is
136  * hung off of inp_ppcb most of the time.  Almost all fields of struct inpcb
137  * are static after creation or protected by a per-inpcb rwlock, inp_lock.  A
138  * few fields are protected by multiple locks as indicated in the locking notes
139  * below.  For these fields, all of the listed locks must be write-locked for
140  * any modifications.  However, these fields can be safely read while any one of
141  * the listed locks are read-locked.  This model can permit greater concurrency
142  * for read operations.  For example, connections can be looked up while only
143  * holding a read lock on the global pcblist lock.  This is important for
144  * performance when attempting to find the connection for a packet given its IP
145  * and port tuple.
146  *
147  * One noteworthy exception is that the global pcbinfo lock follows a different
148  * set of rules in relation to the inp_list field.  Rather than being
149  * write-locked for modifications and read-locked for list iterations, it must
150  * be read-locked during modifications and write-locked during list iterations.
151  * This ensures that the relatively rare global list iterations safely walk a
152  * stable snapshot of connections while allowing more common list modifications
153  * to safely grab the pcblist lock just while adding or removing a connection
154  * from the global list.
155  *
156  * Key:
157  * (c) - Constant after initialization
158  * (g) - Protected by the pcbgroup lock
159  * (i) - Protected by the inpcb lock
160  * (p) - Protected by the pcbinfo lock for the inpcb
161  * (l) - Protected by the pcblist lock for the inpcb
162  * (h) - Protected by the pcbhash lock for the inpcb
163  * (s) - Protected by another subsystem's locks
164  * (x) - Undefined locking
165  *
166  * A few other notes:
167  *
168  * When a read lock is held, stability of the field is guaranteed; to write
169  * to a field, a write lock must generally be held.
170  *
171  * netinet/netinet6-layer code should not assume that the inp_socket pointer
172  * is safe to dereference without inp_lock being held, even for protocols
173  * other than TCP (where the inpcb persists during TIMEWAIT even after the
174  * socket has been freed), or there may be close(2)-related races.
175  *
176  * The inp_vflag field is overloaded, and would otherwise ideally be (c).
177  *
178  * TODO:  Currently only the TCP stack is leveraging the global pcbinfo lock
179  * read-lock usage during modification, this model can be applied to other
180  * protocols (especially SCTP).
181  */
182 struct icmp6_filter;
183 struct inpcbpolicy;
184 struct m_snd_tag;
185 struct inpcb {
186 	LIST_ENTRY(inpcb) inp_hash;	/* (h/i) hash list */
187 	LIST_ENTRY(inpcb) inp_pcbgrouphash;	/* (g/i) hash list */
188 	LIST_ENTRY(inpcb) inp_list;	/* (p/l) list for all PCBs for proto */
189 	                                /* (p[w]) for list iteration */
190 	                                /* (p[r]/l) for addition/removal */
191 	void	*inp_ppcb;		/* (i) pointer to per-protocol pcb */
192 	struct	inpcbinfo *inp_pcbinfo;	/* (c) PCB list info */
193 	struct	inpcbgroup *inp_pcbgroup; /* (g/i) PCB group list */
194 	LIST_ENTRY(inpcb) inp_pcbgroup_wild; /* (g/i/h) group wildcard entry */
195 	struct	socket *inp_socket;	/* (i) back pointer to socket */
196 	struct	ucred	*inp_cred;	/* (c) cache of socket cred */
197 	u_int32_t inp_flow;		/* (i) IPv6 flow information */
198 	int	inp_flags;		/* (i) generic IP/datagram flags */
199 	int	inp_flags2;		/* (i) generic IP/datagram flags #2*/
200 	u_char	inp_vflag;		/* (i) IP version flag (v4/v6) */
201 	u_char	inp_ip_ttl;		/* (i) time to live proto */
202 	u_char	inp_ip_p;		/* (c) protocol proto */
203 	u_char	inp_ip_minttl;		/* (i) minimum TTL or drop */
204 	uint32_t inp_flowid;		/* (x) flow id / queue id */
205 	u_int	inp_refcount;		/* (i) refcount */
206 	struct m_snd_tag *inp_snd_tag;	/* (i) send tag for outgoing mbufs */
207 	uint32_t inp_flowtype;		/* (x) M_HASHTYPE value */
208 	uint32_t inp_rss_listen_bucket;	/* (x) overridden RSS listen bucket */
209 
210 	/* Local and foreign ports, local and foreign addr. */
211 	struct	in_conninfo inp_inc;	/* (i) list for PCB's local port */
212 
213 	/* MAC and IPSEC policy information. */
214 	struct	label *inp_label;	/* (i) MAC label */
215 	struct	inpcbpolicy *inp_sp;    /* (s) for IPSEC */
216 
217 	/* Protocol-dependent part; options. */
218 	struct {
219 		u_char	inp_ip_tos;		/* (i) type of service proto */
220 		struct mbuf		*inp_options;	/* (i) IP options */
221 		struct ip_moptions	*inp_moptions;	/* (i) mcast options */
222 	};
223 	struct {
224 		/* (i) IP options */
225 		struct mbuf		*in6p_options;
226 		/* (i) IP6 options for outgoing packets */
227 		struct ip6_pktopts	*in6p_outputopts;
228 		/* (i) IP multicast options */
229 		struct ip6_moptions	*in6p_moptions;
230 		/* (i) ICMPv6 code type filter */
231 		struct icmp6_filter	*in6p_icmp6filt;
232 		/* (i) IPV6_CHECKSUM setsockopt */
233 		int	in6p_cksum;
234 		short	in6p_hops;
235 	};
236 	LIST_ENTRY(inpcb) inp_portlist;	/* (i/h) */
237 	struct	inpcbport *inp_phd;	/* (i/h) head of this list */
238 #define inp_zero_size offsetof(struct inpcb, inp_gencnt)
239 	inp_gen_t	inp_gencnt;	/* (c) generation count */
240 	struct llentry	*inp_lle;	/* cached L2 information */
241 	struct rwlock	inp_lock;
242 	rt_gen_t	inp_rt_cookie;	/* generation for route entry */
243 	union {				/* cached L3 information */
244 		struct route inpu_route;
245 		struct route_in6 inpu_route6;
246 	} inp_rtu;
247 #define inp_route inp_rtu.inpu_route
248 #define inp_route6 inp_rtu.inpu_route6
249 };
250 #endif	/* _KERNEL */
251 
252 #define	inp_fport	inp_inc.inc_fport
253 #define	inp_lport	inp_inc.inc_lport
254 #define	inp_faddr	inp_inc.inc_faddr
255 #define	inp_laddr	inp_inc.inc_laddr
256 
257 #define	in6p_faddr	inp_inc.inc6_faddr
258 #define	in6p_laddr	inp_inc.inc6_laddr
259 #define	in6p_zoneid	inp_inc.inc6_zoneid
260 #define	in6p_flowinfo	inp_flow
261 
262 #define	inp_vnet	inp_pcbinfo->ipi_vnet
263 
264 /*
265  * The range of the generation count, as used in this implementation, is 9e19.
266  * We would have to create 300 billion connections per second for this number
267  * to roll over in a year.  This seems sufficiently unlikely that we simply
268  * don't concern ourselves with that possibility.
269  */
270 
271 /*
272  * Interface exported to userland by various protocols which use inpcbs.  Hack
273  * alert -- only define if struct xsocket is in scope.
274  * Fields prefixed with "xi_" are unique to this structure, and the rest
275  * match fields in the struct inpcb, to ease coding and porting.
276  *
277  * Legend:
278  * (s) - used by userland utilities in src
279  * (p) - used by utilities in ports
280  * (3) - is known to be used by third party software not in ports
281  * (n) - no known usage
282  */
283 #ifdef _SYS_SOCKETVAR_H_
284 struct xinpcb {
285 	size_t		xi_len;		/* length of this structure */
286 	struct xsocket	xi_socket;		/* (s,p) */
287 	struct in_conninfo inp_inc;		/* (s,p) */
288 	uint64_t	inp_gencnt;		/* (s,p) */
289 	union {
290 		void	*inp_ppcb;		/* (s) netstat(1) */
291 		int64_t	ph_ppcb;
292 	};
293 	int64_t		inp_spare64[4];
294 	uint32_t	inp_flow;		/* (s) */
295 	uint32_t	inp_flowid;		/* (s) */
296 	uint32_t	inp_flowtype;		/* (s) */
297 	int32_t		inp_flags;		/* (s,p) */
298 	int32_t		inp_flags2;		/* (s) */
299 	int32_t		inp_rss_listen_bucket;	/* (n) */
300 	int32_t		in6p_cksum;		/* (n) */
301 	int32_t		inp_spare32[4];
302 	uint16_t	in6p_hops;		/* (n) */
303 	uint8_t		inp_ip_tos;		/* (n) */
304 	int8_t		pad8;
305 	uint8_t		inp_vflag;		/* (s,p) */
306 	uint8_t		inp_ip_ttl;		/* (n) */
307 	uint8_t		inp_ip_p;		/* (n) */
308 	uint8_t		inp_ip_minttl;		/* (n) */
309 	int8_t		inp_spare8[4];
310 } __aligned(8);
311 
312 struct xinpgen {
313 	size_t		xig_len;	/* length of this structure */
314 	u_int		xig_count;	/* number of PCBs at this time */
315 	inp_gen_t	xig_gen;	/* generation count at this time */
316 	so_gen_t	xig_sogen;	/* socket generation count this time */
317 } __aligned(8);
318 #ifdef	_KERNEL
319 void	in_pcbtoxinpcb(const struct inpcb *, struct xinpcb *);
320 #endif
321 #endif /* _SYS_SOCKETVAR_H_ */
322 
323 struct inpcbport {
324 	LIST_ENTRY(inpcbport) phd_hash;
325 	struct inpcbhead phd_pcblist;
326 	u_short phd_port;
327 };
328 
329 /*-
330  * Global data structure for each high-level protocol (UDP, TCP, ...) in both
331  * IPv4 and IPv6.  Holds inpcb lists and information for managing them.
332  *
333  * Each pcbinfo is protected by three locks: ipi_lock, ipi_hash_lock and
334  * ipi_list_lock:
335  *  - ipi_lock covering the global pcb list stability during loop iteration,
336  *  - ipi_hash_lock covering the hashed lookup tables,
337  *  - ipi_list_lock covering mutable global fields (such as the global
338  *    pcb list)
339  *
340  * The lock order is:
341  *
342  *    ipi_lock (before)
343  *        inpcb locks (before)
344  *            ipi_list locks (before)
345  *                {ipi_hash_lock, pcbgroup locks}
346  *
347  * Locking key:
348  *
349  * (c) Constant or nearly constant after initialisation
350  * (g) Locked by ipi_lock
351  * (l) Locked by ipi_list_lock
352  * (h) Read using either ipi_hash_lock or inpcb lock; write requires both
353  * (p) Protected by one or more pcbgroup locks
354  * (x) Synchronisation properties poorly defined
355  */
356 struct inpcbinfo {
357 	/*
358 	 * Global lock protecting full inpcb list traversal
359 	 */
360 	struct rwlock		 ipi_lock;
361 
362 	/*
363 	 * Global list of inpcbs on the protocol.
364 	 */
365 	struct inpcbhead	*ipi_listhead;		/* (g/l) */
366 	u_int			 ipi_count;		/* (l) */
367 
368 	/*
369 	 * Generation count -- incremented each time a connection is allocated
370 	 * or freed.
371 	 */
372 	u_quad_t		 ipi_gencnt;		/* (l) */
373 
374 	/*
375 	 * Fields associated with port lookup and allocation.
376 	 */
377 	u_short			 ipi_lastport;		/* (x) */
378 	u_short			 ipi_lastlow;		/* (x) */
379 	u_short			 ipi_lasthi;		/* (x) */
380 
381 	/*
382 	 * UMA zone from which inpcbs are allocated for this protocol.
383 	 */
384 	struct	uma_zone	*ipi_zone;		/* (c) */
385 
386 	/*
387 	 * Connection groups associated with this protocol.  These fields are
388 	 * constant, but pcbgroup structures themselves are protected by
389 	 * per-pcbgroup locks.
390 	 */
391 	struct inpcbgroup	*ipi_pcbgroups;		/* (c) */
392 	u_int			 ipi_npcbgroups;	/* (c) */
393 	u_int			 ipi_hashfields;	/* (c) */
394 
395 	/*
396 	 * Global lock protecting non-pcbgroup hash lookup tables.
397 	 */
398 	struct rwlock		 ipi_hash_lock;
399 
400 	/*
401 	 * Global hash of inpcbs, hashed by local and foreign addresses and
402 	 * port numbers.
403 	 */
404 	struct inpcbhead	*ipi_hashbase;		/* (h) */
405 	u_long			 ipi_hashmask;		/* (h) */
406 
407 	/*
408 	 * Global hash of inpcbs, hashed by only local port number.
409 	 */
410 	struct inpcbporthead	*ipi_porthashbase;	/* (h) */
411 	u_long			 ipi_porthashmask;	/* (h) */
412 
413 	/*
414 	 * List of wildcard inpcbs for use with pcbgroups.  In the past, was
415 	 * per-pcbgroup but is now global.  All pcbgroup locks must be held
416 	 * to modify the list, so any is sufficient to read it.
417 	 */
418 	struct inpcbhead	*ipi_wildbase;		/* (p) */
419 	u_long			 ipi_wildmask;		/* (p) */
420 
421 	/*
422 	 * Pointer to network stack instance
423 	 */
424 	struct vnet		*ipi_vnet;		/* (c) */
425 
426 	/*
427 	 * general use 2
428 	 */
429 	void 			*ipi_pspare[2];
430 
431 	/*
432 	 * Global lock protecting global inpcb list, inpcb count, etc.
433 	 */
434 	struct rwlock		 ipi_list_lock;
435 };
436 
437 #ifdef _KERNEL
438 /*
439  * Connection groups hold sets of connections that have similar CPU/thread
440  * affinity.  Each connection belongs to exactly one connection group.
441  */
442 struct inpcbgroup {
443 	/*
444 	 * Per-connection group hash of inpcbs, hashed by local and foreign
445 	 * addresses and port numbers.
446 	 */
447 	struct inpcbhead	*ipg_hashbase;		/* (c) */
448 	u_long			 ipg_hashmask;		/* (c) */
449 
450 	/*
451 	 * Notional affinity of this pcbgroup.
452 	 */
453 	u_int			 ipg_cpu;		/* (p) */
454 
455 	/*
456 	 * Per-connection group lock, not to be confused with ipi_lock.
457 	 * Protects the hash table hung off the group, but also the global
458 	 * wildcard list in inpcbinfo.
459 	 */
460 	struct mtx		 ipg_lock;
461 } __aligned(CACHE_LINE_SIZE);
462 
463 #define INP_LOCK_INIT(inp, d, t) \
464 	rw_init_flags(&(inp)->inp_lock, (t), RW_RECURSE |  RW_DUPOK)
465 #define INP_LOCK_DESTROY(inp)	rw_destroy(&(inp)->inp_lock)
466 #define INP_RLOCK(inp)		rw_rlock(&(inp)->inp_lock)
467 #define INP_WLOCK(inp)		rw_wlock(&(inp)->inp_lock)
468 #define INP_TRY_RLOCK(inp)	rw_try_rlock(&(inp)->inp_lock)
469 #define INP_TRY_WLOCK(inp)	rw_try_wlock(&(inp)->inp_lock)
470 #define INP_RUNLOCK(inp)	rw_runlock(&(inp)->inp_lock)
471 #define INP_WUNLOCK(inp)	rw_wunlock(&(inp)->inp_lock)
472 #define	INP_TRY_UPGRADE(inp)	rw_try_upgrade(&(inp)->inp_lock)
473 #define	INP_DOWNGRADE(inp)	rw_downgrade(&(inp)->inp_lock)
474 #define	INP_WLOCKED(inp)	rw_wowned(&(inp)->inp_lock)
475 #define	INP_LOCK_ASSERT(inp)	rw_assert(&(inp)->inp_lock, RA_LOCKED)
476 #define	INP_RLOCK_ASSERT(inp)	rw_assert(&(inp)->inp_lock, RA_RLOCKED)
477 #define	INP_WLOCK_ASSERT(inp)	rw_assert(&(inp)->inp_lock, RA_WLOCKED)
478 #define	INP_UNLOCK_ASSERT(inp)	rw_assert(&(inp)->inp_lock, RA_UNLOCKED)
479 
480 /*
481  * These locking functions are for inpcb consumers outside of sys/netinet,
482  * more specifically, they were added for the benefit of TOE drivers. The
483  * macros are reserved for use by the stack.
484  */
485 void inp_wlock(struct inpcb *);
486 void inp_wunlock(struct inpcb *);
487 void inp_rlock(struct inpcb *);
488 void inp_runlock(struct inpcb *);
489 
490 #ifdef INVARIANT_SUPPORT
491 void inp_lock_assert(struct inpcb *);
492 void inp_unlock_assert(struct inpcb *);
493 #else
494 #define	inp_lock_assert(inp)	do {} while (0)
495 #define	inp_unlock_assert(inp)	do {} while (0)
496 #endif
497 
498 void	inp_apply_all(void (*func)(struct inpcb *, void *), void *arg);
499 int 	inp_ip_tos_get(const struct inpcb *inp);
500 void 	inp_ip_tos_set(struct inpcb *inp, int val);
501 struct socket *
502 	inp_inpcbtosocket(struct inpcb *inp);
503 struct tcpcb *
504 	inp_inpcbtotcpcb(struct inpcb *inp);
505 void 	inp_4tuple_get(struct inpcb *inp, uint32_t *laddr, uint16_t *lp,
506 		uint32_t *faddr, uint16_t *fp);
507 short	inp_so_options(const struct inpcb *inp);
508 
509 #endif /* _KERNEL */
510 
511 #define INP_INFO_LOCK_INIT(ipi, d) \
512 	rw_init_flags(&(ipi)->ipi_lock, (d), RW_RECURSE)
513 #define INP_INFO_LOCK_DESTROY(ipi)  rw_destroy(&(ipi)->ipi_lock)
514 #define INP_INFO_RLOCK(ipi)	rw_rlock(&(ipi)->ipi_lock)
515 #define INP_INFO_WLOCK(ipi)	rw_wlock(&(ipi)->ipi_lock)
516 #define INP_INFO_TRY_RLOCK(ipi)	rw_try_rlock(&(ipi)->ipi_lock)
517 #define INP_INFO_TRY_WLOCK(ipi)	rw_try_wlock(&(ipi)->ipi_lock)
518 #define INP_INFO_TRY_UPGRADE(ipi)	rw_try_upgrade(&(ipi)->ipi_lock)
519 #define INP_INFO_WLOCKED(ipi)	rw_wowned(&(ipi)->ipi_lock)
520 #define INP_INFO_RUNLOCK(ipi)	rw_runlock(&(ipi)->ipi_lock)
521 #define INP_INFO_WUNLOCK(ipi)	rw_wunlock(&(ipi)->ipi_lock)
522 #define	INP_INFO_LOCK_ASSERT(ipi)	rw_assert(&(ipi)->ipi_lock, RA_LOCKED)
523 #define INP_INFO_RLOCK_ASSERT(ipi)	rw_assert(&(ipi)->ipi_lock, RA_RLOCKED)
524 #define INP_INFO_WLOCK_ASSERT(ipi)	rw_assert(&(ipi)->ipi_lock, RA_WLOCKED)
525 #define INP_INFO_UNLOCK_ASSERT(ipi)	rw_assert(&(ipi)->ipi_lock, RA_UNLOCKED)
526 
527 #define INP_LIST_LOCK_INIT(ipi, d) \
528         rw_init_flags(&(ipi)->ipi_list_lock, (d), 0)
529 #define INP_LIST_LOCK_DESTROY(ipi)  rw_destroy(&(ipi)->ipi_list_lock)
530 #define INP_LIST_RLOCK(ipi)     rw_rlock(&(ipi)->ipi_list_lock)
531 #define INP_LIST_WLOCK(ipi)     rw_wlock(&(ipi)->ipi_list_lock)
532 #define INP_LIST_TRY_RLOCK(ipi) rw_try_rlock(&(ipi)->ipi_list_lock)
533 #define INP_LIST_TRY_WLOCK(ipi) rw_try_wlock(&(ipi)->ipi_list_lock)
534 #define INP_LIST_TRY_UPGRADE(ipi)       rw_try_upgrade(&(ipi)->ipi_list_lock)
535 #define INP_LIST_RUNLOCK(ipi)   rw_runlock(&(ipi)->ipi_list_lock)
536 #define INP_LIST_WUNLOCK(ipi)   rw_wunlock(&(ipi)->ipi_list_lock)
537 #define INP_LIST_LOCK_ASSERT(ipi) \
538 	rw_assert(&(ipi)->ipi_list_lock, RA_LOCKED)
539 #define INP_LIST_RLOCK_ASSERT(ipi) \
540 	rw_assert(&(ipi)->ipi_list_lock, RA_RLOCKED)
541 #define INP_LIST_WLOCK_ASSERT(ipi) \
542 	rw_assert(&(ipi)->ipi_list_lock, RA_WLOCKED)
543 #define INP_LIST_UNLOCK_ASSERT(ipi) \
544 	rw_assert(&(ipi)->ipi_list_lock, RA_UNLOCKED)
545 
546 #define	INP_HASH_LOCK_INIT(ipi, d) \
547 	rw_init_flags(&(ipi)->ipi_hash_lock, (d), 0)
548 #define	INP_HASH_LOCK_DESTROY(ipi)	rw_destroy(&(ipi)->ipi_hash_lock)
549 #define	INP_HASH_RLOCK(ipi)		rw_rlock(&(ipi)->ipi_hash_lock)
550 #define	INP_HASH_WLOCK(ipi)		rw_wlock(&(ipi)->ipi_hash_lock)
551 #define	INP_HASH_RUNLOCK(ipi)		rw_runlock(&(ipi)->ipi_hash_lock)
552 #define	INP_HASH_WUNLOCK(ipi)		rw_wunlock(&(ipi)->ipi_hash_lock)
553 #define	INP_HASH_LOCK_ASSERT(ipi)	rw_assert(&(ipi)->ipi_hash_lock, \
554 					    RA_LOCKED)
555 #define	INP_HASH_WLOCK_ASSERT(ipi)	rw_assert(&(ipi)->ipi_hash_lock, \
556 					    RA_WLOCKED)
557 
558 #define	INP_GROUP_LOCK_INIT(ipg, d)	mtx_init(&(ipg)->ipg_lock, (d), NULL, \
559 					    MTX_DEF | MTX_DUPOK)
560 #define	INP_GROUP_LOCK_DESTROY(ipg)	mtx_destroy(&(ipg)->ipg_lock)
561 
562 #define	INP_GROUP_LOCK(ipg)		mtx_lock(&(ipg)->ipg_lock)
563 #define	INP_GROUP_LOCK_ASSERT(ipg)	mtx_assert(&(ipg)->ipg_lock, MA_OWNED)
564 #define	INP_GROUP_UNLOCK(ipg)		mtx_unlock(&(ipg)->ipg_lock)
565 
566 #define INP_PCBHASH(faddr, lport, fport, mask) \
567 	(((faddr) ^ ((faddr) >> 16) ^ ntohs((lport) ^ (fport))) & (mask))
568 #define INP_PCBPORTHASH(lport, mask) \
569 	(ntohs((lport)) & (mask))
570 #define	INP6_PCBHASHKEY(faddr)	((faddr)->s6_addr32[3])
571 
572 /*
573  * Flags for inp_vflags -- historically version flags only
574  */
575 #define	INP_IPV4	0x1
576 #define	INP_IPV6	0x2
577 #define	INP_IPV6PROTO	0x4		/* opened under IPv6 protocol */
578 
579 /*
580  * Flags for inp_flags.
581  */
582 #define	INP_RECVOPTS		0x00000001 /* receive incoming IP options */
583 #define	INP_RECVRETOPTS		0x00000002 /* receive IP options for reply */
584 #define	INP_RECVDSTADDR		0x00000004 /* receive IP dst address */
585 #define	INP_HDRINCL		0x00000008 /* user supplies entire IP header */
586 #define	INP_HIGHPORT		0x00000010 /* user wants "high" port binding */
587 #define	INP_LOWPORT		0x00000020 /* user wants "low" port binding */
588 #define	INP_ANONPORT		0x00000040 /* port chosen for user */
589 #define	INP_RECVIF		0x00000080 /* receive incoming interface */
590 #define	INP_MTUDISC		0x00000100 /* user can do MTU discovery */
591 				   	   /* 0x000200 unused: was INP_FAITH */
592 #define	INP_RECVTTL		0x00000400 /* receive incoming IP TTL */
593 #define	INP_DONTFRAG		0x00000800 /* don't fragment packet */
594 #define	INP_BINDANY		0x00001000 /* allow bind to any address */
595 #define	INP_INHASHLIST		0x00002000 /* in_pcbinshash() has been called */
596 #define	INP_RECVTOS		0x00004000 /* receive incoming IP TOS */
597 #define	IN6P_IPV6_V6ONLY	0x00008000 /* restrict AF_INET6 socket for v6 */
598 #define	IN6P_PKTINFO		0x00010000 /* receive IP6 dst and I/F */
599 #define	IN6P_HOPLIMIT		0x00020000 /* receive hoplimit */
600 #define	IN6P_HOPOPTS		0x00040000 /* receive hop-by-hop options */
601 #define	IN6P_DSTOPTS		0x00080000 /* receive dst options after rthdr */
602 #define	IN6P_RTHDR		0x00100000 /* receive routing header */
603 #define	IN6P_RTHDRDSTOPTS	0x00200000 /* receive dstoptions before rthdr */
604 #define	IN6P_TCLASS		0x00400000 /* receive traffic class value */
605 #define	IN6P_AUTOFLOWLABEL	0x00800000 /* attach flowlabel automatically */
606 #define	INP_TIMEWAIT		0x01000000 /* in TIMEWAIT, ppcb is tcptw */
607 #define	INP_ONESBCAST		0x02000000 /* send all-ones broadcast */
608 #define	INP_DROPPED		0x04000000 /* protocol drop flag */
609 #define	INP_SOCKREF		0x08000000 /* strong socket reference */
610 #define	INP_RESERVED_0          0x10000000 /* reserved field */
611 #define	INP_RESERVED_1          0x20000000 /* reserved field */
612 #define	IN6P_RFC2292		0x40000000 /* used RFC2292 API on the socket */
613 #define	IN6P_MTU		0x80000000 /* receive path MTU */
614 
615 #define	INP_CONTROLOPTS		(INP_RECVOPTS|INP_RECVRETOPTS|INP_RECVDSTADDR|\
616 				 INP_RECVIF|INP_RECVTTL|INP_RECVTOS|\
617 				 IN6P_PKTINFO|IN6P_HOPLIMIT|IN6P_HOPOPTS|\
618 				 IN6P_DSTOPTS|IN6P_RTHDR|IN6P_RTHDRDSTOPTS|\
619 				 IN6P_TCLASS|IN6P_AUTOFLOWLABEL|IN6P_RFC2292|\
620 				 IN6P_MTU)
621 
622 /*
623  * Flags for inp_flags2.
624  */
625 #define	INP_LLE_VALID		0x00000001 /* cached lle is valid */
626 #define	INP_RT_VALID		0x00000002 /* cached rtentry is valid */
627 #define	INP_PCBGROUPWILD	0x00000004 /* in pcbgroup wildcard list */
628 #define	INP_REUSEPORT		0x00000008 /* SO_REUSEPORT option is set */
629 #define	INP_FREED		0x00000010 /* inp itself is not valid */
630 #define	INP_REUSEADDR		0x00000020 /* SO_REUSEADDR option is set */
631 #define	INP_BINDMULTI		0x00000040 /* IP_BINDMULTI option is set */
632 #define	INP_RSS_BUCKET_SET	0x00000080 /* IP_RSS_LISTEN_BUCKET is set */
633 #define	INP_RECVFLOWID		0x00000100 /* populate recv datagram with flow info */
634 #define	INP_RECVRSSBUCKETID	0x00000200 /* populate recv datagram with bucket id */
635 #define	INP_RATE_LIMIT_CHANGED	0x00000400 /* rate limit needs attention */
636 #define	INP_ORIGDSTADDR		0x00000800 /* receive IP dst address/port */
637 
638 /*
639  * Flags passed to in_pcblookup*() functions.
640  */
641 #define	INPLOOKUP_WILDCARD	0x00000001	/* Allow wildcard sockets. */
642 #define	INPLOOKUP_RLOCKPCB	0x00000002	/* Return inpcb read-locked. */
643 #define	INPLOOKUP_WLOCKPCB	0x00000004	/* Return inpcb write-locked. */
644 
645 #define	INPLOOKUP_MASK	(INPLOOKUP_WILDCARD | INPLOOKUP_RLOCKPCB | \
646 			    INPLOOKUP_WLOCKPCB)
647 
648 #define	sotoinpcb(so)	((struct inpcb *)(so)->so_pcb)
649 #define	sotoin6pcb(so)	sotoinpcb(so) /* for KAME src sync over BSD*'s */
650 
651 #define	INP_SOCKAF(so) so->so_proto->pr_domain->dom_family
652 
653 #define	INP_CHECK_SOCKAF(so, af)	(INP_SOCKAF(so) == af)
654 
655 /*
656  * Constants for pcbinfo.ipi_hashfields.
657  */
658 #define	IPI_HASHFIELDS_NONE	0
659 #define	IPI_HASHFIELDS_2TUPLE	1
660 #define	IPI_HASHFIELDS_4TUPLE	2
661 
662 #ifdef _KERNEL
663 VNET_DECLARE(int, ipport_reservedhigh);
664 VNET_DECLARE(int, ipport_reservedlow);
665 VNET_DECLARE(int, ipport_lowfirstauto);
666 VNET_DECLARE(int, ipport_lowlastauto);
667 VNET_DECLARE(int, ipport_firstauto);
668 VNET_DECLARE(int, ipport_lastauto);
669 VNET_DECLARE(int, ipport_hifirstauto);
670 VNET_DECLARE(int, ipport_hilastauto);
671 VNET_DECLARE(int, ipport_randomized);
672 VNET_DECLARE(int, ipport_randomcps);
673 VNET_DECLARE(int, ipport_randomtime);
674 VNET_DECLARE(int, ipport_stoprandom);
675 VNET_DECLARE(int, ipport_tcpallocs);
676 
677 #define	V_ipport_reservedhigh	VNET(ipport_reservedhigh)
678 #define	V_ipport_reservedlow	VNET(ipport_reservedlow)
679 #define	V_ipport_lowfirstauto	VNET(ipport_lowfirstauto)
680 #define	V_ipport_lowlastauto	VNET(ipport_lowlastauto)
681 #define	V_ipport_firstauto	VNET(ipport_firstauto)
682 #define	V_ipport_lastauto	VNET(ipport_lastauto)
683 #define	V_ipport_hifirstauto	VNET(ipport_hifirstauto)
684 #define	V_ipport_hilastauto	VNET(ipport_hilastauto)
685 #define	V_ipport_randomized	VNET(ipport_randomized)
686 #define	V_ipport_randomcps	VNET(ipport_randomcps)
687 #define	V_ipport_randomtime	VNET(ipport_randomtime)
688 #define	V_ipport_stoprandom	VNET(ipport_stoprandom)
689 #define	V_ipport_tcpallocs	VNET(ipport_tcpallocs)
690 
691 void	in_pcbinfo_destroy(struct inpcbinfo *);
692 void	in_pcbinfo_init(struct inpcbinfo *, const char *, struct inpcbhead *,
693 	    int, int, char *, uma_init, uma_fini, uint32_t, u_int);
694 
695 int	in_pcbbind_check_bindmulti(const struct inpcb *ni,
696 	    const struct inpcb *oi);
697 
698 struct inpcbgroup *
699 	in_pcbgroup_byhash(struct inpcbinfo *, u_int, uint32_t);
700 struct inpcbgroup *
701 	in_pcbgroup_byinpcb(struct inpcb *);
702 struct inpcbgroup *
703 	in_pcbgroup_bytuple(struct inpcbinfo *, struct in_addr, u_short,
704 	    struct in_addr, u_short);
705 void	in_pcbgroup_destroy(struct inpcbinfo *);
706 int	in_pcbgroup_enabled(struct inpcbinfo *);
707 void	in_pcbgroup_init(struct inpcbinfo *, u_int, int);
708 void	in_pcbgroup_remove(struct inpcb *);
709 void	in_pcbgroup_update(struct inpcb *);
710 void	in_pcbgroup_update_mbuf(struct inpcb *, struct mbuf *);
711 
712 void	in_pcbpurgeif0(struct inpcbinfo *, struct ifnet *);
713 int	in_pcballoc(struct socket *, struct inpcbinfo *);
714 int	in_pcbbind(struct inpcb *, struct sockaddr *, struct ucred *);
715 int	in_pcb_lport(struct inpcb *, struct in_addr *, u_short *,
716 	    struct ucred *, int);
717 int	in_pcbbind_setup(struct inpcb *, struct sockaddr *, in_addr_t *,
718 	    u_short *, struct ucred *);
719 int	in_pcbconnect(struct inpcb *, struct sockaddr *, struct ucred *);
720 int	in_pcbconnect_mbuf(struct inpcb *, struct sockaddr *, struct ucred *,
721 	    struct mbuf *);
722 int	in_pcbconnect_setup(struct inpcb *, struct sockaddr *, in_addr_t *,
723 	    u_short *, in_addr_t *, u_short *, struct inpcb **,
724 	    struct ucred *);
725 void	in_pcbdetach(struct inpcb *);
726 void	in_pcbdisconnect(struct inpcb *);
727 void	in_pcbdrop(struct inpcb *);
728 void	in_pcbfree(struct inpcb *);
729 int	in_pcbinshash(struct inpcb *);
730 int	in_pcbinshash_nopcbgroup(struct inpcb *);
731 int	in_pcbladdr(struct inpcb *, struct in_addr *, struct in_addr *,
732 	    struct ucred *);
733 struct inpcb *
734 	in_pcblookup_local(struct inpcbinfo *,
735 	    struct in_addr, u_short, int, struct ucred *);
736 struct inpcb *
737 	in_pcblookup(struct inpcbinfo *, struct in_addr, u_int,
738 	    struct in_addr, u_int, int, struct ifnet *);
739 struct inpcb *
740 	in_pcblookup_mbuf(struct inpcbinfo *, struct in_addr, u_int,
741 	    struct in_addr, u_int, int, struct ifnet *, struct mbuf *);
742 void	in_pcbnotifyall(struct inpcbinfo *pcbinfo, struct in_addr,
743 	    int, struct inpcb *(*)(struct inpcb *, int));
744 void	in_pcbref(struct inpcb *);
745 void	in_pcbrehash(struct inpcb *);
746 void	in_pcbrehash_mbuf(struct inpcb *, struct mbuf *);
747 int	in_pcbrele(struct inpcb *);
748 int	in_pcbrele_rlocked(struct inpcb *);
749 int	in_pcbrele_wlocked(struct inpcb *);
750 void	in_losing(struct inpcb *);
751 void	in_pcbsetsolabel(struct socket *so);
752 int	in_getpeeraddr(struct socket *so, struct sockaddr **nam);
753 int	in_getsockaddr(struct socket *so, struct sockaddr **nam);
754 struct sockaddr *
755 	in_sockaddr(in_port_t port, struct in_addr *addr);
756 void	in_pcbsosetlabel(struct socket *so);
757 #ifdef RATELIMIT
758 int	in_pcbattach_txrtlmt(struct inpcb *, struct ifnet *, uint32_t, uint32_t, uint32_t);
759 void	in_pcbdetach_txrtlmt(struct inpcb *);
760 int	in_pcbmodify_txrtlmt(struct inpcb *, uint32_t);
761 int	in_pcbquery_txrtlmt(struct inpcb *, uint32_t *);
762 void	in_pcboutput_txrtlmt(struct inpcb *, struct ifnet *, struct mbuf *);
763 void	in_pcboutput_eagain(struct inpcb *);
764 #endif
765 #endif /* _KERNEL */
766 
767 #endif /* !_NETINET_IN_PCB_H_ */
768