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  * 4. 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 
46 #ifdef _KERNEL
47 #include <sys/lock.h>
48 #include <sys/rwlock.h>
49 #include <net/vnet.h>
50 #include <vm/uma.h>
51 #endif
52 
53 #define	in6pcb		inpcb	/* for KAME src sync over BSD*'s */
54 #define	in6p_sp		inp_sp	/* for KAME src sync over BSD*'s */
55 struct inpcbpolicy;
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	u_quad_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 compatability */
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 struct	icmp6_filter;
133 
134 /*-
135  * struct inpcb captures the network layer state for TCP, UDP, and raw IPv4 and
136  * IPv6 sockets.  In the case of TCP and UDP, further per-connection state is
137  * hung off of inp_ppcb most of the time.  Almost all fields of struct inpcb
138  * are static after creation or protected by a per-inpcb rwlock, inp_lock.  A
139  * few fields are protected by multiple locks as indicated in the locking notes
140  * below.  For these fields, all of the listed locks must be write-locked for
141  * any modifications.  However, these fields can be safely read while any one of
142  * the listed locks are read-locked.  This model can permit greater concurrency
143  * for read operations.  For example, connections can be looked up while only
144  * holding a read lock on the global pcblist lock.  This is important for
145  * performance when attempting to find the connection for a packet given its IP
146  * and port tuple.
147  *
148  * One noteworthy exception is that the global pcbinfo lock follows a different
149  * set of rules in relation to the inp_list field.  Rather than being
150  * write-locked for modifications and read-locked for list iterations, it must
151  * be read-locked during modifications and write-locked during list iterations.
152  * This ensures that the relatively rare global list iterations safely walk a
153  * stable snapshot of connections while allowing more common list modifications
154  * to safely grab the pcblist lock just while adding or removing a connection
155  * from the global list.
156  *
157  * Key:
158  * (c) - Constant after initialization
159  * (g) - Protected by the pcbgroup lock
160  * (i) - Protected by the inpcb lock
161  * (p) - Protected by the pcbinfo lock for the inpcb
162  * (l) - Protected by the pcblist lock for the inpcb
163  * (h) - Protected by the pcbhash lock for the inpcb
164  * (s) - Protected by another subsystem's locks
165  * (x) - Undefined locking
166  *
167  * A few other notes:
168  *
169  * When a read lock is held, stability of the field is guaranteed; to write
170  * to a field, a write lock must generally be held.
171  *
172  * netinet/netinet6-layer code should not assume that the inp_socket pointer
173  * is safe to dereference without inp_lock being held, even for protocols
174  * other than TCP (where the inpcb persists during TIMEWAIT even after the
175  * socket has been freed), or there may be close(2)-related races.
176  *
177  * The inp_vflag field is overloaded, and would otherwise ideally be (c).
178  *
179  * TODO:  Currently only the TCP stack is leveraging the global pcbinfo lock
180  * read-lock usage during modification, this model can be applied to other
181  * protocols (especially SCTP).
182  */
183 struct inpcb {
184 	LIST_ENTRY(inpcb) inp_hash;	/* (h/i) hash list */
185 	LIST_ENTRY(inpcb) inp_pcbgrouphash;	/* (g/i) hash list */
186 	LIST_ENTRY(inpcb) inp_list;	/* (p/l) list for all PCBs for proto */
187 	                                /* (p[w]) for list iteration */
188 	                                /* (p[r]/l) for addition/removal */
189 	void	*inp_ppcb;		/* (i) pointer to per-protocol pcb */
190 	struct	inpcbinfo *inp_pcbinfo;	/* (c) PCB list info */
191 	struct	inpcbgroup *inp_pcbgroup; /* (g/i) PCB group list */
192 	LIST_ENTRY(inpcb) inp_pcbgroup_wild; /* (g/i/h) group wildcard entry */
193 	struct	socket *inp_socket;	/* (i) back pointer to socket */
194 	struct	ucred	*inp_cred;	/* (c) cache of socket cred */
195 	u_int32_t inp_flow;		/* (i) IPv6 flow information */
196 	int	inp_flags;		/* (i) generic IP/datagram flags */
197 	int	inp_flags2;		/* (i) generic IP/datagram flags #2*/
198 	u_char	inp_vflag;		/* (i) IP version flag (v4/v6) */
199 	u_char	inp_ip_ttl;		/* (i) time to live proto */
200 	u_char	inp_ip_p;		/* (c) protocol proto */
201 	u_char	inp_ip_minttl;		/* (i) minimum TTL or drop */
202 	uint32_t inp_flowid;		/* (x) flow id / queue id */
203 	u_int	inp_refcount;		/* (i) refcount */
204 	void	*inp_pspare[5];		/* (x) route caching / general use */
205 	uint32_t inp_flowtype;		/* (x) M_HASHTYPE value */
206 	uint32_t inp_rss_listen_bucket;	/* (x) overridden RSS listen bucket */
207 	u_int	inp_ispare[4];		/* (x) route caching / user cookie /
208 					 *     general use */
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	inp4_ip_tos;		/* (i) type of service proto */
220 		struct	mbuf *inp4_options;	/* (i) IP options */
221 		struct	ip_moptions *inp4_moptions; /* (i) IP mcast options */
222 	} inp_depend4;
223 	struct {
224 		/* (i) IP options */
225 		struct	mbuf *inp6_options;
226 		/* (i) IP6 options for outgoing packets */
227 		struct	ip6_pktopts *inp6_outputopts;
228 		/* (i) IP multicast options */
229 		struct	ip6_moptions *inp6_moptions;
230 		/* (i) ICMPv6 code type filter */
231 		struct	icmp6_filter *inp6_icmp6filt;
232 		/* (i) IPV6_CHECKSUM setsockopt */
233 		int	inp6_cksum;
234 		short	inp6_hops;
235 	} inp_depend6;
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 rtentry	*inp_rt;	/* cached L3 information */
242 	struct rwlock	inp_lock;
243 };
244 #define	inp_fport	inp_inc.inc_fport
245 #define	inp_lport	inp_inc.inc_lport
246 #define	inp_faddr	inp_inc.inc_faddr
247 #define	inp_laddr	inp_inc.inc_laddr
248 #define	inp_ip_tos	inp_depend4.inp4_ip_tos
249 #define	inp_options	inp_depend4.inp4_options
250 #define	inp_moptions	inp_depend4.inp4_moptions
251 
252 #define	in6p_faddr	inp_inc.inc6_faddr
253 #define	in6p_laddr	inp_inc.inc6_laddr
254 #define	in6p_zoneid	inp_inc.inc6_zoneid
255 #define	in6p_hops	inp_depend6.inp6_hops	/* default hop limit */
256 #define	in6p_flowinfo	inp_flow
257 #define	in6p_options	inp_depend6.inp6_options
258 #define	in6p_outputopts	inp_depend6.inp6_outputopts
259 #define	in6p_moptions	inp_depend6.inp6_moptions
260 #define	in6p_icmp6filt	inp_depend6.inp6_icmp6filt
261 #define	in6p_cksum	inp_depend6.inp6_cksum
262 
263 #define	inp_vnet	inp_pcbinfo->ipi_vnet
264 
265 /*
266  * The range of the generation count, as used in this implementation, is 9e19.
267  * We would have to create 300 billion connections per second for this number
268  * to roll over in a year.  This seems sufficiently unlikely that we simply
269  * don't concern ourselves with that possibility.
270  */
271 
272 /*
273  * Interface exported to userland by various protocols which use inpcbs.  Hack
274  * alert -- only define if struct xsocket is in scope.
275  */
276 #ifdef _SYS_SOCKETVAR_H_
277 struct	xinpcb {
278 	size_t	xi_len;		/* length of this structure */
279 	struct	inpcb xi_inp;
280 	struct	xsocket xi_socket;
281 	u_quad_t	xi_alignment_hack;
282 };
283 
284 struct	xinpgen {
285 	size_t	xig_len;	/* length of this structure */
286 	u_int	xig_count;	/* number of PCBs at this time */
287 	inp_gen_t xig_gen;	/* generation count at this time */
288 	so_gen_t xig_sogen;	/* socket generation count at this time */
289 };
290 #endif /* _SYS_SOCKETVAR_H_ */
291 
292 struct inpcbport {
293 	LIST_ENTRY(inpcbport) phd_hash;
294 	struct inpcbhead phd_pcblist;
295 	u_short phd_port;
296 };
297 
298 /*-
299  * Global data structure for each high-level protocol (UDP, TCP, ...) in both
300  * IPv4 and IPv6.  Holds inpcb lists and information for managing them.
301  *
302  * Each pcbinfo is protected by three locks: ipi_lock, ipi_hash_lock and
303  * ipi_list_lock:
304  *  - ipi_lock covering the global pcb list stability during loop iteration,
305  *  - ipi_hash_lock covering the hashed lookup tables,
306  *  - ipi_list_lock covering mutable global fields (such as the global
307  *    pcb list)
308  *
309  * The lock order is:
310  *
311  *    ipi_lock (before)
312  *        inpcb locks (before)
313  *            ipi_list locks (before)
314  *                {ipi_hash_lock, pcbgroup locks}
315  *
316  * Locking key:
317  *
318  * (c) Constant or nearly constant after initialisation
319  * (g) Locked by ipi_lock
320  * (l) Locked by ipi_list_lock
321  * (h) Read using either ipi_hash_lock or inpcb lock; write requires both
322  * (p) Protected by one or more pcbgroup locks
323  * (x) Synchronisation properties poorly defined
324  */
325 struct inpcbinfo {
326 	/*
327 	 * Global lock protecting full inpcb list traversal
328 	 */
329 	struct rwlock		 ipi_lock;
330 
331 	/*
332 	 * Global list of inpcbs on the protocol.
333 	 */
334 	struct inpcbhead	*ipi_listhead;		/* (g/l) */
335 	u_int			 ipi_count;		/* (l) */
336 
337 	/*
338 	 * Generation count -- incremented each time a connection is allocated
339 	 * or freed.
340 	 */
341 	u_quad_t		 ipi_gencnt;		/* (l) */
342 
343 	/*
344 	 * Fields associated with port lookup and allocation.
345 	 */
346 	u_short			 ipi_lastport;		/* (x) */
347 	u_short			 ipi_lastlow;		/* (x) */
348 	u_short			 ipi_lasthi;		/* (x) */
349 
350 	/*
351 	 * UMA zone from which inpcbs are allocated for this protocol.
352 	 */
353 	struct	uma_zone	*ipi_zone;		/* (c) */
354 
355 	/*
356 	 * Connection groups associated with this protocol.  These fields are
357 	 * constant, but pcbgroup structures themselves are protected by
358 	 * per-pcbgroup locks.
359 	 */
360 	struct inpcbgroup	*ipi_pcbgroups;		/* (c) */
361 	u_int			 ipi_npcbgroups;	/* (c) */
362 	u_int			 ipi_hashfields;	/* (c) */
363 
364 	/*
365 	 * Global lock protecting non-pcbgroup hash lookup tables.
366 	 */
367 	struct rwlock		 ipi_hash_lock;
368 
369 	/*
370 	 * Global hash of inpcbs, hashed by local and foreign addresses and
371 	 * port numbers.
372 	 */
373 	struct inpcbhead	*ipi_hashbase;		/* (h) */
374 	u_long			 ipi_hashmask;		/* (h) */
375 
376 	/*
377 	 * Global hash of inpcbs, hashed by only local port number.
378 	 */
379 	struct inpcbporthead	*ipi_porthashbase;	/* (h) */
380 	u_long			 ipi_porthashmask;	/* (h) */
381 
382 	/*
383 	 * List of wildcard inpcbs for use with pcbgroups.  In the past, was
384 	 * per-pcbgroup but is now global.  All pcbgroup locks must be held
385 	 * to modify the list, so any is sufficient to read it.
386 	 */
387 	struct inpcbhead	*ipi_wildbase;		/* (p) */
388 	u_long			 ipi_wildmask;		/* (p) */
389 
390 	/*
391 	 * Pointer to network stack instance
392 	 */
393 	struct vnet		*ipi_vnet;		/* (c) */
394 
395 	/*
396 	 * general use 2
397 	 */
398 	void 			*ipi_pspare[2];
399 
400 	/*
401 	 * Global lock protecting global inpcb list, inpcb count, etc.
402 	 */
403 	struct rwlock		 ipi_list_lock;
404 };
405 
406 #ifdef _KERNEL
407 /*
408  * Connection groups hold sets of connections that have similar CPU/thread
409  * affinity.  Each connection belongs to exactly one connection group.
410  */
411 struct inpcbgroup {
412 	/*
413 	 * Per-connection group hash of inpcbs, hashed by local and foreign
414 	 * addresses and port numbers.
415 	 */
416 	struct inpcbhead	*ipg_hashbase;		/* (c) */
417 	u_long			 ipg_hashmask;		/* (c) */
418 
419 	/*
420 	 * Notional affinity of this pcbgroup.
421 	 */
422 	u_int			 ipg_cpu;		/* (p) */
423 
424 	/*
425 	 * Per-connection group lock, not to be confused with ipi_lock.
426 	 * Protects the hash table hung off the group, but also the global
427 	 * wildcard list in inpcbinfo.
428 	 */
429 	struct mtx		 ipg_lock;
430 } __aligned(CACHE_LINE_SIZE);
431 
432 #define INP_LOCK_INIT(inp, d, t) \
433 	rw_init_flags(&(inp)->inp_lock, (t), RW_RECURSE |  RW_DUPOK)
434 #define INP_LOCK_DESTROY(inp)	rw_destroy(&(inp)->inp_lock)
435 #define INP_RLOCK(inp)		rw_rlock(&(inp)->inp_lock)
436 #define INP_WLOCK(inp)		rw_wlock(&(inp)->inp_lock)
437 #define INP_TRY_RLOCK(inp)	rw_try_rlock(&(inp)->inp_lock)
438 #define INP_TRY_WLOCK(inp)	rw_try_wlock(&(inp)->inp_lock)
439 #define INP_RUNLOCK(inp)	rw_runlock(&(inp)->inp_lock)
440 #define INP_WUNLOCK(inp)	rw_wunlock(&(inp)->inp_lock)
441 #define	INP_TRY_UPGRADE(inp)	rw_try_upgrade(&(inp)->inp_lock)
442 #define	INP_DOWNGRADE(inp)	rw_downgrade(&(inp)->inp_lock)
443 #define	INP_WLOCKED(inp)	rw_wowned(&(inp)->inp_lock)
444 #define	INP_LOCK_ASSERT(inp)	rw_assert(&(inp)->inp_lock, RA_LOCKED)
445 #define	INP_RLOCK_ASSERT(inp)	rw_assert(&(inp)->inp_lock, RA_RLOCKED)
446 #define	INP_WLOCK_ASSERT(inp)	rw_assert(&(inp)->inp_lock, RA_WLOCKED)
447 #define	INP_UNLOCK_ASSERT(inp)	rw_assert(&(inp)->inp_lock, RA_UNLOCKED)
448 
449 /*
450  * These locking functions are for inpcb consumers outside of sys/netinet,
451  * more specifically, they were added for the benefit of TOE drivers. The
452  * macros are reserved for use by the stack.
453  */
454 void inp_wlock(struct inpcb *);
455 void inp_wunlock(struct inpcb *);
456 void inp_rlock(struct inpcb *);
457 void inp_runlock(struct inpcb *);
458 
459 #ifdef INVARIANTS
460 void inp_lock_assert(struct inpcb *);
461 void inp_unlock_assert(struct inpcb *);
462 #else
463 static __inline void
inp_lock_assert(struct inpcb * inp __unused)464 inp_lock_assert(struct inpcb *inp __unused)
465 {
466 }
467 
468 static __inline void
inp_unlock_assert(struct inpcb * inp __unused)469 inp_unlock_assert(struct inpcb *inp __unused)
470 {
471 }
472 
473 #endif
474 
475 void	inp_apply_all(void (*func)(struct inpcb *, void *), void *arg);
476 int 	inp_ip_tos_get(const struct inpcb *inp);
477 void 	inp_ip_tos_set(struct inpcb *inp, int val);
478 struct socket *
479 	inp_inpcbtosocket(struct inpcb *inp);
480 struct tcpcb *
481 	inp_inpcbtotcpcb(struct inpcb *inp);
482 void 	inp_4tuple_get(struct inpcb *inp, uint32_t *laddr, uint16_t *lp,
483 		uint32_t *faddr, uint16_t *fp);
484 short	inp_so_options(const struct inpcb *inp);
485 
486 #endif /* _KERNEL */
487 
488 #define INP_INFO_LOCK_INIT(ipi, d) \
489 	rw_init_flags(&(ipi)->ipi_lock, (d), RW_RECURSE)
490 #define INP_INFO_LOCK_DESTROY(ipi)  rw_destroy(&(ipi)->ipi_lock)
491 #define INP_INFO_RLOCK(ipi)	rw_rlock(&(ipi)->ipi_lock)
492 #define INP_INFO_WLOCK(ipi)	rw_wlock(&(ipi)->ipi_lock)
493 #define INP_INFO_TRY_RLOCK(ipi)	rw_try_rlock(&(ipi)->ipi_lock)
494 #define INP_INFO_TRY_WLOCK(ipi)	rw_try_wlock(&(ipi)->ipi_lock)
495 #define INP_INFO_TRY_UPGRADE(ipi)	rw_try_upgrade(&(ipi)->ipi_lock)
496 #define INP_INFO_WLOCKED(ipi)	rw_wowned(&(ipi)->ipi_lock)
497 #define INP_INFO_RUNLOCK(ipi)	rw_runlock(&(ipi)->ipi_lock)
498 #define INP_INFO_WUNLOCK(ipi)	rw_wunlock(&(ipi)->ipi_lock)
499 #define	INP_INFO_LOCK_ASSERT(ipi)	rw_assert(&(ipi)->ipi_lock, RA_LOCKED)
500 #define INP_INFO_RLOCK_ASSERT(ipi)	rw_assert(&(ipi)->ipi_lock, RA_RLOCKED)
501 #define INP_INFO_WLOCK_ASSERT(ipi)	rw_assert(&(ipi)->ipi_lock, RA_WLOCKED)
502 #define INP_INFO_UNLOCK_ASSERT(ipi)	rw_assert(&(ipi)->ipi_lock, RA_UNLOCKED)
503 
504 #define INP_LIST_LOCK_INIT(ipi, d) \
505         rw_init_flags(&(ipi)->ipi_list_lock, (d), 0)
506 #define INP_LIST_LOCK_DESTROY(ipi)  rw_destroy(&(ipi)->ipi_list_lock)
507 #define INP_LIST_RLOCK(ipi)     rw_rlock(&(ipi)->ipi_list_lock)
508 #define INP_LIST_WLOCK(ipi)     rw_wlock(&(ipi)->ipi_list_lock)
509 #define INP_LIST_TRY_RLOCK(ipi) rw_try_rlock(&(ipi)->ipi_list_lock)
510 #define INP_LIST_TRY_WLOCK(ipi) rw_try_wlock(&(ipi)->ipi_list_lock)
511 #define INP_LIST_TRY_UPGRADE(ipi)       rw_try_upgrade(&(ipi)->ipi_list_lock)
512 #define INP_LIST_RUNLOCK(ipi)   rw_runlock(&(ipi)->ipi_list_lock)
513 #define INP_LIST_WUNLOCK(ipi)   rw_wunlock(&(ipi)->ipi_list_lock)
514 #define INP_LIST_LOCK_ASSERT(ipi) \
515 	rw_assert(&(ipi)->ipi_list_lock, RA_LOCKED)
516 #define INP_LIST_RLOCK_ASSERT(ipi) \
517 	rw_assert(&(ipi)->ipi_list_lock, RA_RLOCKED)
518 #define INP_LIST_WLOCK_ASSERT(ipi) \
519 	rw_assert(&(ipi)->ipi_list_lock, RA_WLOCKED)
520 #define INP_LIST_UNLOCK_ASSERT(ipi) \
521 	rw_assert(&(ipi)->ipi_list_lock, RA_UNLOCKED)
522 
523 #define	INP_HASH_LOCK_INIT(ipi, d) \
524 	rw_init_flags(&(ipi)->ipi_hash_lock, (d), 0)
525 #define	INP_HASH_LOCK_DESTROY(ipi)	rw_destroy(&(ipi)->ipi_hash_lock)
526 #define	INP_HASH_RLOCK(ipi)		rw_rlock(&(ipi)->ipi_hash_lock)
527 #define	INP_HASH_WLOCK(ipi)		rw_wlock(&(ipi)->ipi_hash_lock)
528 #define	INP_HASH_RUNLOCK(ipi)		rw_runlock(&(ipi)->ipi_hash_lock)
529 #define	INP_HASH_WUNLOCK(ipi)		rw_wunlock(&(ipi)->ipi_hash_lock)
530 #define	INP_HASH_LOCK_ASSERT(ipi)	rw_assert(&(ipi)->ipi_hash_lock, \
531 					    RA_LOCKED)
532 #define	INP_HASH_WLOCK_ASSERT(ipi)	rw_assert(&(ipi)->ipi_hash_lock, \
533 					    RA_WLOCKED)
534 
535 #define	INP_GROUP_LOCK_INIT(ipg, d)	mtx_init(&(ipg)->ipg_lock, (d), NULL, \
536 					    MTX_DEF | MTX_DUPOK)
537 #define	INP_GROUP_LOCK_DESTROY(ipg)	mtx_destroy(&(ipg)->ipg_lock)
538 
539 #define	INP_GROUP_LOCK(ipg)		mtx_lock(&(ipg)->ipg_lock)
540 #define	INP_GROUP_LOCK_ASSERT(ipg)	mtx_assert(&(ipg)->ipg_lock, MA_OWNED)
541 #define	INP_GROUP_UNLOCK(ipg)		mtx_unlock(&(ipg)->ipg_lock)
542 
543 #define INP_PCBHASH(faddr, lport, fport, mask) \
544 	(((faddr) ^ ((faddr) >> 16) ^ ntohs((lport) ^ (fport))) & (mask))
545 #define INP_PCBPORTHASH(lport, mask) \
546 	(ntohs((lport)) & (mask))
547 #define	INP6_PCBHASHKEY(faddr)	((faddr)->s6_addr32[3])
548 
549 /*
550  * Flags for inp_vflags -- historically version flags only
551  */
552 #define	INP_IPV4	0x1
553 #define	INP_IPV6	0x2
554 #define	INP_IPV6PROTO	0x4		/* opened under IPv6 protocol */
555 
556 /*
557  * Flags for inp_flags.
558  */
559 #define	INP_RECVOPTS		0x00000001 /* receive incoming IP options */
560 #define	INP_RECVRETOPTS		0x00000002 /* receive IP options for reply */
561 #define	INP_RECVDSTADDR		0x00000004 /* receive IP dst address */
562 #define	INP_HDRINCL		0x00000008 /* user supplies entire IP header */
563 #define	INP_HIGHPORT		0x00000010 /* user wants "high" port binding */
564 #define	INP_LOWPORT		0x00000020 /* user wants "low" port binding */
565 #define	INP_ANONPORT		0x00000040 /* port chosen for user */
566 #define	INP_RECVIF		0x00000080 /* receive incoming interface */
567 #define	INP_MTUDISC		0x00000100 /* user can do MTU discovery */
568 				   	   /* 0x000200 unused: was INP_FAITH */
569 #define	INP_RECVTTL		0x00000400 /* receive incoming IP TTL */
570 #define	INP_DONTFRAG		0x00000800 /* don't fragment packet */
571 #define	INP_BINDANY		0x00001000 /* allow bind to any address */
572 #define	INP_INHASHLIST		0x00002000 /* in_pcbinshash() has been called */
573 #define	INP_RECVTOS		0x00004000 /* receive incoming IP TOS */
574 #define	IN6P_IPV6_V6ONLY	0x00008000 /* restrict AF_INET6 socket for v6 */
575 #define	IN6P_PKTINFO		0x00010000 /* receive IP6 dst and I/F */
576 #define	IN6P_HOPLIMIT		0x00020000 /* receive hoplimit */
577 #define	IN6P_HOPOPTS		0x00040000 /* receive hop-by-hop options */
578 #define	IN6P_DSTOPTS		0x00080000 /* receive dst options after rthdr */
579 #define	IN6P_RTHDR		0x00100000 /* receive routing header */
580 #define	IN6P_RTHDRDSTOPTS	0x00200000 /* receive dstoptions before rthdr */
581 #define	IN6P_TCLASS		0x00400000 /* receive traffic class value */
582 #define	IN6P_AUTOFLOWLABEL	0x00800000 /* attach flowlabel automatically */
583 #define	INP_TIMEWAIT		0x01000000 /* in TIMEWAIT, ppcb is tcptw */
584 #define	INP_ONESBCAST		0x02000000 /* send all-ones broadcast */
585 #define	INP_DROPPED		0x04000000 /* protocol drop flag */
586 #define	INP_SOCKREF		0x08000000 /* strong socket reference */
587 #define	INP_RESERVED_0          0x10000000 /* reserved field */
588 #define	INP_RESERVED_1          0x20000000 /* reserved field */
589 #define	IN6P_RFC2292		0x40000000 /* used RFC2292 API on the socket */
590 #define	IN6P_MTU		0x80000000 /* receive path MTU */
591 
592 #define	INP_CONTROLOPTS		(INP_RECVOPTS|INP_RECVRETOPTS|INP_RECVDSTADDR|\
593 				 INP_RECVIF|INP_RECVTTL|INP_RECVTOS|\
594 				 IN6P_PKTINFO|IN6P_HOPLIMIT|IN6P_HOPOPTS|\
595 				 IN6P_DSTOPTS|IN6P_RTHDR|IN6P_RTHDRDSTOPTS|\
596 				 IN6P_TCLASS|IN6P_AUTOFLOWLABEL|IN6P_RFC2292|\
597 				 IN6P_MTU)
598 
599 /*
600  * Flags for inp_flags2.
601  */
602 #define	INP_LLE_VALID		0x00000001 /* cached lle is valid */
603 #define	INP_RT_VALID		0x00000002 /* cached rtentry is valid */
604 #define	INP_PCBGROUPWILD	0x00000004 /* in pcbgroup wildcard list */
605 #define	INP_REUSEPORT		0x00000008 /* SO_REUSEPORT option is set */
606 #define	INP_FREED		0x00000010 /* inp itself is not valid */
607 #define	INP_REUSEADDR		0x00000020 /* SO_REUSEADDR option is set */
608 #define	INP_BINDMULTI		0x00000040 /* IP_BINDMULTI option is set */
609 #define	INP_RSS_BUCKET_SET	0x00000080 /* IP_RSS_LISTEN_BUCKET is set */
610 #define	INP_RECVFLOWID		0x00000100 /* populate recv datagram with flow info */
611 #define	INP_RECVRSSBUCKETID	0x00000200 /* populate recv datagram with bucket id */
612 
613 /*
614  * Flags passed to in_pcblookup*() functions.
615  */
616 #define	INPLOOKUP_WILDCARD	0x00000001	/* Allow wildcard sockets. */
617 #define	INPLOOKUP_RLOCKPCB	0x00000002	/* Return inpcb read-locked. */
618 #define	INPLOOKUP_WLOCKPCB	0x00000004	/* Return inpcb write-locked. */
619 
620 #define	INPLOOKUP_MASK	(INPLOOKUP_WILDCARD | INPLOOKUP_RLOCKPCB | \
621 			    INPLOOKUP_WLOCKPCB)
622 
623 #define	sotoinpcb(so)	((struct inpcb *)(so)->so_pcb)
624 #define	sotoin6pcb(so)	sotoinpcb(so) /* for KAME src sync over BSD*'s */
625 
626 #define	INP_SOCKAF(so) so->so_proto->pr_domain->dom_family
627 
628 #define	INP_CHECK_SOCKAF(so, af)	(INP_SOCKAF(so) == af)
629 
630 /*
631  * Constants for pcbinfo.ipi_hashfields.
632  */
633 #define	IPI_HASHFIELDS_NONE	0
634 #define	IPI_HASHFIELDS_2TUPLE	1
635 #define	IPI_HASHFIELDS_4TUPLE	2
636 
637 #ifdef _KERNEL
638 VNET_DECLARE(int, ipport_reservedhigh);
639 VNET_DECLARE(int, ipport_reservedlow);
640 VNET_DECLARE(int, ipport_lowfirstauto);
641 VNET_DECLARE(int, ipport_lowlastauto);
642 VNET_DECLARE(int, ipport_firstauto);
643 VNET_DECLARE(int, ipport_lastauto);
644 VNET_DECLARE(int, ipport_hifirstauto);
645 VNET_DECLARE(int, ipport_hilastauto);
646 VNET_DECLARE(int, ipport_randomized);
647 VNET_DECLARE(int, ipport_randomcps);
648 VNET_DECLARE(int, ipport_randomtime);
649 VNET_DECLARE(int, ipport_stoprandom);
650 VNET_DECLARE(int, ipport_tcpallocs);
651 
652 #define	V_ipport_reservedhigh	VNET(ipport_reservedhigh)
653 #define	V_ipport_reservedlow	VNET(ipport_reservedlow)
654 #define	V_ipport_lowfirstauto	VNET(ipport_lowfirstauto)
655 #define	V_ipport_lowlastauto	VNET(ipport_lowlastauto)
656 #define	V_ipport_firstauto	VNET(ipport_firstauto)
657 #define	V_ipport_lastauto	VNET(ipport_lastauto)
658 #define	V_ipport_hifirstauto	VNET(ipport_hifirstauto)
659 #define	V_ipport_hilastauto	VNET(ipport_hilastauto)
660 #define	V_ipport_randomized	VNET(ipport_randomized)
661 #define	V_ipport_randomcps	VNET(ipport_randomcps)
662 #define	V_ipport_randomtime	VNET(ipport_randomtime)
663 #define	V_ipport_stoprandom	VNET(ipport_stoprandom)
664 #define	V_ipport_tcpallocs	VNET(ipport_tcpallocs)
665 
666 void	in_pcbinfo_destroy(struct inpcbinfo *);
667 void	in_pcbinfo_init(struct inpcbinfo *, const char *, struct inpcbhead *,
668 	    int, int, char *, uma_init, uma_fini, uint32_t, u_int);
669 
670 int	in_pcbbind_check_bindmulti(const struct inpcb *ni,
671 	    const struct inpcb *oi);
672 
673 struct inpcbgroup *
674 	in_pcbgroup_byhash(struct inpcbinfo *, u_int, uint32_t);
675 struct inpcbgroup *
676 	in_pcbgroup_byinpcb(struct inpcb *);
677 struct inpcbgroup *
678 	in_pcbgroup_bytuple(struct inpcbinfo *, struct in_addr, u_short,
679 	    struct in_addr, u_short);
680 void	in_pcbgroup_destroy(struct inpcbinfo *);
681 int	in_pcbgroup_enabled(struct inpcbinfo *);
682 void	in_pcbgroup_init(struct inpcbinfo *, u_int, int);
683 void	in_pcbgroup_remove(struct inpcb *);
684 void	in_pcbgroup_update(struct inpcb *);
685 void	in_pcbgroup_update_mbuf(struct inpcb *, struct mbuf *);
686 
687 void	in_pcbpurgeif0(struct inpcbinfo *, struct ifnet *);
688 int	in_pcballoc(struct socket *, struct inpcbinfo *);
689 int	in_pcbbind(struct inpcb *, struct sockaddr *, struct ucred *);
690 int	in_pcb_lport(struct inpcb *, struct in_addr *, u_short *,
691 	    struct ucred *, int);
692 int	in_pcbbind_setup(struct inpcb *, struct sockaddr *, in_addr_t *,
693 	    u_short *, struct ucred *);
694 int	in_pcbconnect(struct inpcb *, struct sockaddr *, struct ucred *);
695 int	in_pcbconnect_mbuf(struct inpcb *, struct sockaddr *, struct ucred *,
696 	    struct mbuf *);
697 int	in_pcbconnect_setup(struct inpcb *, struct sockaddr *, in_addr_t *,
698 	    u_short *, in_addr_t *, u_short *, struct inpcb **,
699 	    struct ucred *);
700 void	in_pcbdetach(struct inpcb *);
701 void	in_pcbdisconnect(struct inpcb *);
702 void	in_pcbdrop(struct inpcb *);
703 void	in_pcbfree(struct inpcb *);
704 int	in_pcbinshash(struct inpcb *);
705 int	in_pcbinshash_nopcbgroup(struct inpcb *);
706 int	in_pcbladdr(struct inpcb *, struct in_addr *, struct in_addr *,
707 	    struct ucred *);
708 struct inpcb *
709 	in_pcblookup_local(struct inpcbinfo *,
710 	    struct in_addr, u_short, int, struct ucred *);
711 struct inpcb *
712 	in_pcblookup(struct inpcbinfo *, struct in_addr, u_int,
713 	    struct in_addr, u_int, int, struct ifnet *);
714 struct inpcb *
715 	in_pcblookup_mbuf(struct inpcbinfo *, struct in_addr, u_int,
716 	    struct in_addr, u_int, int, struct ifnet *, struct mbuf *);
717 void	in_pcbnotifyall(struct inpcbinfo *pcbinfo, struct in_addr,
718 	    int, struct inpcb *(*)(struct inpcb *, int));
719 void	in_pcbref(struct inpcb *);
720 void	in_pcbrehash(struct inpcb *);
721 void	in_pcbrehash_mbuf(struct inpcb *, struct mbuf *);
722 int	in_pcbrele(struct inpcb *);
723 int	in_pcbrele_rlocked(struct inpcb *);
724 int	in_pcbrele_wlocked(struct inpcb *);
725 void	in_pcbsetsolabel(struct socket *so);
726 int	in_getpeeraddr(struct socket *so, struct sockaddr **nam);
727 int	in_getsockaddr(struct socket *so, struct sockaddr **nam);
728 struct sockaddr *
729 	in_sockaddr(in_port_t port, struct in_addr *addr);
730 void	in_pcbsosetlabel(struct socket *so);
731 #endif /* _KERNEL */
732 
733 #endif /* !_NETINET_IN_PCB_H_ */
734