Print this page
dccp: conn_t
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/inet/ipclassifier.h
+++ new/usr/src/uts/common/inet/ipclassifier.h
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
23 23 * Use is subject to license terms.
24 24 */
25 25
26 26 #ifndef _INET_IPCLASSIFIER_H
27 27 #define _INET_IPCLASSIFIER_H
28 28
29 29 #ifdef __cplusplus
30 30 extern "C" {
31 31 #endif
32 32
33 33 #include <inet/common.h>
34 34 #include <inet/ip.h>
35 35 #include <inet/mi.h>
36 36 #include <inet/tcp.h>
37 37 #include <inet/ip6.h>
38 38 #include <netinet/in.h> /* for IPPROTO_* constants */
39 39 #include <sys/sdt.h>
40 40 #include <sys/socket_proto.h>
41 41 #include <sys/sunddi.h>
42 42 #include <sys/sunldi.h>
43 43
44 44 typedef void (*edesc_rpf)(void *, mblk_t *, void *, ip_recv_attr_t *);
45 45 struct icmph_s;
46 46 struct icmp6_hdr;
47 47 typedef boolean_t (*edesc_vpf)(conn_t *, void *, struct icmph_s *,
48 48 struct icmp6_hdr *, ip_recv_attr_t *);
49 49
50 50 /*
51 51 * ==============================
52 52 * = The CONNECTION =
53 53 * ==============================
54 54 */
55 55
56 56 /*
57 57 * The connection structure contains the common information/flags/ref needed.
58 58 * Implementation will keep the connection struct, the layers (with their
59 59 * respective data for event i.e. tcp_t if event was tcp_input_data) all in one
60 60 * contiguous memory location.
61 61 */
62 62
63 63 /* Conn Flags */
64 64 /* Unused 0x00020000 */
65 65 /* Unused 0x00040000 */
66 66 #define IPCL_FULLY_BOUND 0x00080000 /* Bound to correct squeue */
67 67 /* Unused 0x00100000 */
68 68 /* Unused 0x00200000 */
69 69 /* Unused 0x00400000 */
70 70 #define IPCL_CL_LISTENER 0x00800000 /* Cluster listener */
71 71 /* Unused 0x01000000 */
72 72 /* Unused 0x02000000 */
73 73 /* Unused 0x04000000 */
74 74 /* Unused 0x08000000 */
75 75 /* Unused 0x10000000 */
76 76 /* Unused 0x20000000 */
|
↓ open down ↓ |
76 lines elided |
↑ open up ↑ |
77 77 #define IPCL_CONNECTED 0x40000000 /* Conn in connected table */
78 78 #define IPCL_BOUND 0x80000000 /* Conn in bind table */
79 79
80 80 /* Flags identifying the type of conn */
81 81 #define IPCL_TCPCONN 0x00000001 /* From tcp_conn_cache */
82 82 #define IPCL_SCTPCONN 0x00000002 /* From sctp_conn_cache */
83 83 #define IPCL_IPCCONN 0x00000004 /* From ip_conn_cache */
84 84 #define IPCL_UDPCONN 0x00000008 /* From udp_conn_cache */
85 85 #define IPCL_RAWIPCONN 0x00000010 /* From rawip_conn_cache */
86 86 #define IPCL_RTSCONN 0x00000020 /* From rts_conn_cache */
87 -/* Unused 0x00000040 */
87 +#define IPCL_DCCPCONN 0x00000040 /* From dccp_conn_cache */
88 88 #define IPCL_IPTUN 0x00000080 /* iptun module above us */
89 89
90 90 #define IPCL_NONSTR 0x00001000 /* A non-STREAMS socket */
91 91 /* Unused 0x10000000 */
92 92
93 93 #define IPCL_REMOVED 0x00000100
94 94 #define IPCL_REUSED 0x00000200
95 95
96 96 #define IPCL_IS_CONNECTED(connp) \
97 97 ((connp)->conn_flags & IPCL_CONNECTED)
98 98
99 99 #define IPCL_IS_BOUND(connp) \
100 100 ((connp)->conn_flags & IPCL_BOUND)
101 101
102 102 /*
103 103 * Can't use conn_proto since we need to tell difference
104 104 * between a real TCP socket and a SOCK_RAW, IPPROTO_TCP.
105 105 */
106 106 #define IPCL_IS_TCP(connp) \
107 107 ((connp)->conn_flags & IPCL_TCPCONN)
108 108
109 109 #define IPCL_IS_SCTP(connp) \
110 110 ((connp)->conn_flags & IPCL_SCTPCONN)
111 111
112 112 #define IPCL_IS_UDP(connp) \
113 113 ((connp)->conn_flags & IPCL_UDPCONN)
|
↓ open down ↓ |
16 lines elided |
↑ open up ↑ |
114 114
115 115 #define IPCL_IS_RAWIP(connp) \
116 116 ((connp)->conn_flags & IPCL_RAWIPCONN)
117 117
118 118 #define IPCL_IS_RTS(connp) \
119 119 ((connp)->conn_flags & IPCL_RTSCONN)
120 120
121 121 #define IPCL_IS_IPTUN(connp) \
122 122 ((connp)->conn_flags & IPCL_IPTUN)
123 123
124 +#define IPCL_IS_DCCP(connp) \
125 + ((connp)->conn_flags & IPCL_DCCPCONN)
126 +
124 127 #define IPCL_IS_NONSTR(connp) ((connp)->conn_flags & IPCL_NONSTR)
125 128
126 129 typedef struct connf_s connf_t;
127 130
128 131 typedef struct
129 132 {
130 133 int ctb_depth;
131 134 #define CONN_STACK_DEPTH 15
132 135 pc_t ctb_stack[CONN_STACK_DEPTH];
133 136 } conn_trace_t;
134 137
135 138 typedef struct ip_helper_minor_info_s {
136 139 dev_t ip_minfo_dev; /* Device */
137 140 vmem_t *ip_minfo_arena; /* Arena */
138 141 } ip_helper_minfo_t;
139 142
140 143 /*
141 144 * ip helper stream info
142 145 */
143 146 typedef struct ip_helper_stream_info_s {
144 147 ldi_handle_t iphs_handle;
145 148 queue_t *iphs_rq;
146 149 queue_t *iphs_wq;
147 150 ip_helper_minfo_t *iphs_minfo;
148 151 } ip_helper_stream_info_t;
149 152
150 153 /*
151 154 * Mandatory Access Control mode, in conn_t's conn_mac_mode field.
152 155 * CONN_MAC_DEFAULT: strict enforcement of MAC.
153 156 * CONN_MAC_AWARE: allows communications between unlabeled systems
154 157 * and privileged daemons
155 158 * CONN_MAC_IMPLICIT: allows communications without explicit labels
156 159 * on the wire with privileged daemons.
157 160 *
158 161 * CONN_MAC_IMPLICIT is intended specifically for labeled IPsec key management
159 162 * in networks which don't pass CIPSO-labeled packets.
160 163 */
161 164 #define CONN_MAC_DEFAULT 0
162 165 #define CONN_MAC_AWARE 1
163 166 #define CONN_MAC_IMPLICIT 2
164 167
165 168 /*
166 169 * conn receive ancillary definition.
167 170 *
168 171 * These are the set of socket options that make the receive side
169 172 * potentially pass up ancillary data items.
170 173 * We have a union with an integer so that we can quickly check whether
171 174 * any ancillary data items need to be added.
172 175 */
173 176 typedef struct crb_s {
174 177 union {
175 178 uint32_t crbu_all;
176 179 struct {
177 180 uint32_t
178 181 crbb_recvdstaddr : 1, /* IP_RECVDSTADDR option */
179 182 crbb_recvopts : 1, /* IP_RECVOPTS option */
180 183 crbb_recvif : 1, /* IP_RECVIF option */
181 184 crbb_recvslla : 1, /* IP_RECVSLLA option */
182 185
183 186 crbb_recvttl : 1, /* IP_RECVTTL option */
184 187 crbb_ip_recvpktinfo : 1, /* IP*_RECVPKTINFO option */
185 188 crbb_ipv6_recvhoplimit : 1, /* IPV6_RECVHOPLIMIT option */
186 189 crbb_ipv6_recvhopopts : 1, /* IPV6_RECVHOPOPTS option */
187 190
188 191 crbb_ipv6_recvdstopts : 1, /* IPV6_RECVDSTOPTS option */
189 192 crbb_ipv6_recvrthdr : 1, /* IPV6_RECVRTHDR option */
190 193 crbb_old_ipv6_recvdstopts : 1, /* old form of IPV6_DSTOPTS */
191 194 crbb_ipv6_recvrthdrdstopts : 1, /* IPV6_RECVRTHDRDSTOPTS */
192 195
193 196 crbb_ipv6_recvtclass : 1, /* IPV6_RECVTCLASS */
194 197 crbb_recvucred : 1, /* IP_RECVUCRED option */
195 198 crbb_timestamp : 1; /* SO_TIMESTAMP "socket" option */
196 199
197 200 } crbb;
198 201 } crbu;
199 202 } crb_t;
200 203
201 204 #define crb_all crbu.crbu_all
202 205 #define crb_recvdstaddr crbu.crbb.crbb_recvdstaddr
203 206 #define crb_recvopts crbu.crbb.crbb_recvopts
204 207 #define crb_recvif crbu.crbb.crbb_recvif
205 208 #define crb_recvslla crbu.crbb.crbb_recvslla
206 209 #define crb_recvttl crbu.crbb.crbb_recvttl
207 210 #define crb_ip_recvpktinfo crbu.crbb.crbb_ip_recvpktinfo
208 211 #define crb_ipv6_recvhoplimit crbu.crbb.crbb_ipv6_recvhoplimit
209 212 #define crb_ipv6_recvhopopts crbu.crbb.crbb_ipv6_recvhopopts
210 213 #define crb_ipv6_recvdstopts crbu.crbb.crbb_ipv6_recvdstopts
211 214 #define crb_ipv6_recvrthdr crbu.crbb.crbb_ipv6_recvrthdr
212 215 #define crb_old_ipv6_recvdstopts crbu.crbb.crbb_old_ipv6_recvdstopts
213 216 #define crb_ipv6_recvrthdrdstopts crbu.crbb.crbb_ipv6_recvrthdrdstopts
214 217 #define crb_ipv6_recvtclass crbu.crbb.crbb_ipv6_recvtclass
215 218 #define crb_recvucred crbu.crbb.crbb_recvucred
216 219 #define crb_timestamp crbu.crbb.crbb_timestamp
217 220
218 221 /*
219 222 * The initial fields in the conn_t are setup by the kmem_cache constructor,
220 223 * and are preserved when it is freed. Fields after that are bzero'ed when
221 224 * the conn_t is freed.
222 225 *
223 226 * Much of the conn_t is protected by conn_lock.
224 227 *
225 228 * conn_lock is also used by some ULPs (like UDP and RAWIP) to protect
226 229 * their state.
227 230 */
228 231 struct conn_s {
229 232 kmutex_t conn_lock;
|
↓ open down ↓ |
96 lines elided |
↑ open up ↑ |
230 233 uint32_t conn_ref; /* Reference counter */
231 234 uint32_t conn_flags; /* Conn Flags */
232 235
233 236 union {
234 237 tcp_t *cp_tcp; /* Pointer to the tcp struct */
235 238 struct udp_s *cp_udp; /* Pointer to the udp struct */
236 239 struct icmp_s *cp_icmp; /* Pointer to rawip struct */
237 240 struct rts_s *cp_rts; /* Pointer to rts struct */
238 241 struct iptun_s *cp_iptun; /* Pointer to iptun_t */
239 242 struct sctp_s *cp_sctp; /* For IPCL_SCTPCONN */
243 + struct dccp_s *cp_dccp; /* Pointer to dccp struct */
240 244 void *cp_priv;
241 245 } conn_proto_priv;
242 246 #define conn_tcp conn_proto_priv.cp_tcp
243 247 #define conn_udp conn_proto_priv.cp_udp
244 248 #define conn_icmp conn_proto_priv.cp_icmp
245 249 #define conn_rts conn_proto_priv.cp_rts
246 250 #define conn_iptun conn_proto_priv.cp_iptun
247 251 #define conn_sctp conn_proto_priv.cp_sctp
252 +#define conn_dccp conn_proto_priv.cp_dccp
248 253 #define conn_priv conn_proto_priv.cp_priv
249 254
250 255 kcondvar_t conn_cv;
251 256 uint8_t conn_proto; /* protocol type */
252 257
253 258 edesc_rpf conn_recv; /* Pointer to recv routine */
254 259 edesc_rpf conn_recvicmp; /* For ICMP error */
255 260 edesc_vpf conn_verifyicmp; /* Verify ICMP error */
256 261
257 262 ip_xmit_attr_t *conn_ixa; /* Options if no ancil data */
258 263
259 264 /* Fields after this are bzero'ed when the conn_t is freed. */
260 265 #define conn_start_clr conn_recv_ancillary
261 266
262 267 /* Options for receive-side ancillary data */
263 268 crb_t conn_recv_ancillary;
264 269
265 270 squeue_t *conn_sqp; /* Squeue for processing */
266 271 uint_t conn_state_flags; /* IP state flags */
267 272
268 273 int conn_lingertime; /* linger time (in seconds) */
269 274
270 275 unsigned int
271 276 conn_on_sqp : 1, /* Conn is being processed */
272 277 conn_linger : 1, /* SO_LINGER state */
273 278 conn_useloopback : 1, /* SO_USELOOPBACK state */
274 279 conn_broadcast : 1, /* SO_BROADCAST state */
275 280
276 281 conn_reuseaddr : 1, /* SO_REUSEADDR state */
277 282 conn_keepalive : 1, /* SO_KEEPALIVE state */
278 283 conn_multi_router : 1, /* Wants all multicast pkts */
279 284 conn_unspec_src : 1, /* IP_UNSPEC_SRC */
280 285
281 286 conn_policy_cached : 1, /* Is policy cached/latched ? */
282 287 conn_in_enforce_policy : 1, /* Enforce Policy on inbound */
283 288 conn_out_enforce_policy : 1, /* Enforce Policy on outbound */
284 289 conn_debug : 1, /* SO_DEBUG */
285 290
286 291 conn_ipv6_v6only : 1, /* IPV6_V6ONLY */
287 292 conn_oobinline : 1, /* SO_OOBINLINE state */
288 293 conn_dgram_errind : 1, /* SO_DGRAM_ERRIND state */
289 294 conn_exclbind : 1, /* SO_EXCLBIND state */
290 295
291 296 conn_mdt_ok : 1, /* MDT is permitted */
292 297 conn_allzones : 1, /* SO_ALLZONES */
293 298 conn_ipv6_recvpathmtu : 1, /* IPV6_RECVPATHMTU */
294 299 conn_mcbc_bind : 1, /* Bound to multi/broadcast */
295 300
296 301 conn_pad_to_bit_31 : 12;
297 302
298 303 boolean_t conn_blocked; /* conn is flow-controlled */
299 304
300 305 squeue_t *conn_initial_sqp; /* Squeue at open time */
301 306 squeue_t *conn_final_sqp; /* Squeue after connect */
302 307 ill_t *conn_dhcpinit_ill; /* IP_DHCPINIT_IF */
303 308 ipsec_latch_t *conn_latch; /* latched IDS */
304 309 struct ipsec_policy_s *conn_latch_in_policy; /* latched policy (in) */
305 310 struct ipsec_action_s *conn_latch_in_action; /* latched action (in) */
306 311 uint_t conn_bound_if; /* IP*_BOUND_IF */
307 312 queue_t *conn_rq; /* Read queue */
308 313 queue_t *conn_wq; /* Write queue */
309 314 dev_t conn_dev; /* Minor number */
310 315 vmem_t *conn_minor_arena; /* Minor arena */
311 316 ip_helper_stream_info_t *conn_helper_info;
312 317
313 318 cred_t *conn_cred; /* Credentials */
314 319 pid_t conn_cpid; /* pid from open/connect */
315 320 uint64_t conn_open_time; /* time when this was opened */
316 321
317 322 connf_t *conn_g_fanout; /* Global Hash bucket head */
318 323 struct conn_s *conn_g_next; /* Global Hash chain next */
319 324 struct conn_s *conn_g_prev; /* Global Hash chain prev */
320 325 struct ipsec_policy_head_s *conn_policy; /* Configured policy */
321 326 in6_addr_t conn_bound_addr_v6; /* Address in bind() */
322 327 #define conn_bound_addr_v4 V4_PART_OF_V6(conn_bound_addr_v6)
323 328 connf_t *conn_fanout; /* Hash bucket we're part of */
324 329 struct conn_s *conn_next; /* Hash chain next */
325 330 struct conn_s *conn_prev; /* Hash chain prev */
326 331
327 332 struct {
328 333 in6_addr_t connua_laddr; /* Local address - match */
329 334 in6_addr_t connua_faddr; /* Remote address */
330 335 } connua_v6addr;
331 336 #define conn_laddr_v4 V4_PART_OF_V6(connua_v6addr.connua_laddr)
332 337 #define conn_faddr_v4 V4_PART_OF_V6(connua_v6addr.connua_faddr)
333 338 #define conn_laddr_v6 connua_v6addr.connua_laddr
334 339 #define conn_faddr_v6 connua_v6addr.connua_faddr
335 340 in6_addr_t conn_saddr_v6; /* Local address - source */
336 341 #define conn_saddr_v4 V4_PART_OF_V6(conn_saddr_v6)
337 342
338 343 union {
339 344 /* Used for classifier match performance */
340 345 uint32_t connu_ports2;
341 346 struct {
342 347 in_port_t connu_fport; /* Remote port */
343 348 in_port_t connu_lport; /* Local port */
344 349 } connu_ports;
345 350 } u_port;
346 351 #define conn_fport u_port.connu_ports.connu_fport
347 352 #define conn_lport u_port.connu_ports.connu_lport
348 353 #define conn_ports u_port.connu_ports2
349 354
350 355 uint_t conn_incoming_ifindex; /* IP{,V6}_BOUND_IF, scopeid */
351 356 ill_t *conn_oper_pending_ill; /* pending shared ioctl */
352 357
353 358 krwlock_t conn_ilg_lock; /* Protects conn_ilg_* */
354 359 ilg_t *conn_ilg; /* Group memberships */
355 360
356 361 kcondvar_t conn_refcv; /* For conn_oper_pending_ill */
357 362
358 363 struct conn_s *conn_drain_next; /* Next conn in drain list */
359 364 struct conn_s *conn_drain_prev; /* Prev conn in drain list */
360 365 idl_t *conn_idl; /* Ptr to the drain list head */
361 366 mblk_t *conn_ipsec_opt_mp; /* ipsec option mblk */
362 367 zoneid_t conn_zoneid; /* zone connection is in */
363 368 int conn_rtaware; /* RT_AWARE sockopt value */
364 369 kcondvar_t conn_sq_cv; /* For non-STREAMS socket IO */
365 370 sock_upcalls_t *conn_upcalls; /* Upcalls to sockfs */
366 371 sock_upper_handle_t conn_upper_handle; /* Upper handle: sonode * */
367 372
368 373 unsigned int
369 374 conn_mlp_type : 2, /* mlp_type_t; tsol/tndb.h */
370 375 conn_anon_mlp : 1, /* user wants anon MLP */
371 376 conn_anon_port : 1, /* user bound anonymously */
372 377
373 378 conn_mac_mode : 2, /* normal/loose/implicit MAC */
374 379 conn_anon_priv_bind : 1, /* *_ANON_PRIV_BIND state */
375 380 conn_zone_is_global : 1, /* GLOBAL_ZONEID */
376 381 conn_isvrrp : 1, /* VRRP control socket */
377 382 conn_spare : 23;
378 383
379 384 boolean_t conn_flow_cntrld;
380 385 netstack_t *conn_netstack; /* Corresponds to a netstack_hold */
381 386
382 387 /*
383 388 * IP format that packets received for this struct should use.
384 389 * Value can be IP4_VERSION or IPV6_VERSION.
385 390 * The sending version is encoded using IXAF_IS_IPV4.
386 391 */
387 392 ushort_t conn_ipversion;
388 393
389 394 /* Written to only once at the time of opening the endpoint */
390 395 sa_family_t conn_family; /* Family from socket() call */
391 396 uint_t conn_so_type; /* Type from socket() call */
392 397
393 398 uint_t conn_sndbuf; /* SO_SNDBUF state */
394 399 uint_t conn_rcvbuf; /* SO_RCVBUF state */
395 400 uint_t conn_wroff; /* Current write offset */
396 401
397 402 uint_t conn_sndlowat; /* Send buffer low water mark */
398 403 uint_t conn_rcvlowat; /* Recv buffer low water mark */
399 404
400 405 uint8_t conn_default_ttl; /* Default TTL/hoplimit */
401 406
402 407 uint32_t conn_flowinfo; /* Connected flow id and tclass */
403 408
404 409 /*
405 410 * The most recent address for sendto. Initially set to zero
406 411 * which is always different than then the destination address
407 412 * since the send interprets zero as the loopback address.
408 413 */
409 414 in6_addr_t conn_v6lastdst;
410 415 #define conn_v4lastdst V4_PART_OF_V6(conn_v6lastdst)
411 416 ushort_t conn_lastipversion;
412 417 in_port_t conn_lastdstport;
413 418 uint32_t conn_lastflowinfo; /* IPv6-only */
414 419 uint_t conn_lastscopeid; /* IPv6-only */
415 420 uint_t conn_lastsrcid; /* Only for AF_INET6 */
416 421 /*
417 422 * When we are not connected conn_saddr might be unspecified.
418 423 * We track the source that was used with conn_v6lastdst here.
419 424 */
420 425 in6_addr_t conn_v6lastsrc;
421 426 #define conn_v4lastsrc V4_PART_OF_V6(conn_v6lastsrc)
422 427
423 428 /* Templates for transmitting packets */
424 429 ip_pkt_t conn_xmit_ipp; /* Options if no ancil data */
425 430
426 431 /*
427 432 * Header template - conn_ht_ulp is a pointer into conn_ht_iphc.
428 433 * Note that ixa_ip_hdr_length indicates the offset of ht_ulp in
429 434 * ht_iphc
430 435 *
431 436 * The header template is maintained for connected endpoints (and
432 437 * updated when sticky options are changed) and also for the lastdst.
433 438 * There is no conflict between those usages since SOCK_DGRAM and
434 439 * SOCK_RAW can not be used to specify a destination address (with
435 440 * sendto/sendmsg) if the socket has been connected.
436 441 */
437 442 uint8_t *conn_ht_iphc; /* Start of IP header */
438 443 uint_t conn_ht_iphc_allocated; /* Allocated buffer size */
439 444 uint_t conn_ht_iphc_len; /* IP+ULP size */
440 445 uint8_t *conn_ht_ulp; /* Upper-layer header */
441 446 uint_t conn_ht_ulp_len; /* ULP header len */
442 447
443 448 /* Checksum to compensate for source routed packets. Host byte order */
444 449 uint32_t conn_sum;
445 450
446 451 uint32_t conn_ioctlref; /* ioctl ref count */
447 452 #ifdef CONN_DEBUG
448 453 #define CONN_TRACE_MAX 10
449 454 int conn_trace_last; /* ndx of last used tracebuf */
450 455 conn_trace_t conn_trace_buf[CONN_TRACE_MAX];
451 456 #endif
452 457 };
453 458
454 459 /*
455 460 * connf_t - connection fanout data.
456 461 *
457 462 * The hash tables and their linkage (conn_t.{hashnextp, hashprevp} are
458 463 * protected by the per-bucket lock. Each conn_t inserted in the list
459 464 * points back at the connf_t that heads the bucket.
460 465 */
461 466 struct connf_s {
462 467 struct conn_s *connf_head;
463 468 kmutex_t connf_lock;
464 469 };
465 470
466 471 #define CONN_INC_REF(connp) { \
467 472 mutex_enter(&(connp)->conn_lock); \
468 473 DTRACE_PROBE1(conn__inc__ref, conn_t *, connp); \
469 474 ASSERT(conn_trace_ref(connp)); \
470 475 (connp)->conn_ref++; \
471 476 ASSERT((connp)->conn_ref != 0); \
472 477 mutex_exit(&(connp)->conn_lock); \
473 478 }
474 479
475 480 #define CONN_INC_REF_LOCKED(connp) { \
476 481 DTRACE_PROBE1(conn__inc__ref, conn_t *, connp); \
477 482 ASSERT(MUTEX_HELD(&(connp)->conn_lock)); \
478 483 ASSERT(conn_trace_ref(connp)); \
479 484 (connp)->conn_ref++; \
480 485 ASSERT((connp)->conn_ref != 0); \
481 486 }
482 487
483 488 #define CONN_DEC_REF(connp) { \
484 489 mutex_enter(&(connp)->conn_lock); \
485 490 DTRACE_PROBE1(conn__dec__ref, conn_t *, connp); \
486 491 /* \
487 492 * The squeue framework always does a CONN_DEC_REF after return \
488 493 * from TCP. Hence the refcnt must be at least 2 if conn_on_sqp \
489 494 * is B_TRUE and conn_ref is being decremented. This is to \
490 495 * account for the mblk being currently processed. \
491 496 */ \
492 497 if ((connp)->conn_ref == 0 || \
493 498 ((connp)->conn_ref == 1 && (connp)->conn_on_sqp)) \
494 499 cmn_err(CE_PANIC, "CONN_DEC_REF: connp(%p) has ref " \
495 500 "= %d\n", (void *)(connp), (connp)->conn_ref); \
496 501 ASSERT(conn_untrace_ref(connp)); \
497 502 (connp)->conn_ref--; \
498 503 if ((connp)->conn_ref == 0) { \
499 504 /* Refcnt can't increase again, safe to drop lock */ \
500 505 mutex_exit(&(connp)->conn_lock); \
501 506 ipcl_conn_destroy(connp); \
502 507 } else { \
503 508 cv_broadcast(&(connp)->conn_cv); \
504 509 mutex_exit(&(connp)->conn_lock); \
505 510 } \
506 511 }
507 512
508 513 /*
509 514 * For use with subsystems within ip which use ALL_ZONES as a wildcard
510 515 */
511 516 #define IPCL_ZONEID(connp) \
512 517 ((connp)->conn_allzones ? ALL_ZONES : (connp)->conn_zoneid)
513 518
514 519 /*
515 520 * For matching between a conn_t and a zoneid.
516 521 */
517 522 #define IPCL_ZONE_MATCH(connp, zoneid) \
518 523 (((connp)->conn_allzones) || \
519 524 ((zoneid) == ALL_ZONES) || \
520 525 (connp)->conn_zoneid == (zoneid))
521 526
522 527 /*
523 528 * On a labeled system, we must treat bindings to ports
524 529 * on shared IP addresses by sockets with MAC exemption
525 530 * privilege as being in all zones, as there's
526 531 * otherwise no way to identify the right receiver.
527 532 */
528 533
529 534 #define IPCL_CONNS_MAC(conn1, conn2) \
530 535 (((conn1)->conn_mac_mode != CONN_MAC_DEFAULT) || \
531 536 ((conn2)->conn_mac_mode != CONN_MAC_DEFAULT))
532 537
533 538 #define IPCL_BIND_ZONE_MATCH(conn1, conn2) \
534 539 (IPCL_CONNS_MAC(conn1, conn2) || \
535 540 IPCL_ZONE_MATCH(conn1, conn2->conn_zoneid) || \
536 541 IPCL_ZONE_MATCH(conn2, conn1->conn_zoneid))
537 542
538 543
539 544 #define _IPCL_V4_MATCH(v6addr, v4addr) \
540 545 (V4_PART_OF_V6((v6addr)) == (v4addr) && IN6_IS_ADDR_V4MAPPED(&(v6addr)))
541 546
542 547 #define _IPCL_V4_MATCH_ANY(addr) \
543 548 (IN6_IS_ADDR_V4MAPPED_ANY(&(addr)) || IN6_IS_ADDR_UNSPECIFIED(&(addr)))
544 549
545 550
546 551 /*
547 552 * IPCL_PROTO_MATCH() and IPCL_PROTO_MATCH_V6() only matches conns with
548 553 * the specified ira_zoneid or conn_allzones by calling conn_wantpacket.
549 554 */
550 555 #define IPCL_PROTO_MATCH(connp, ira, ipha) \
551 556 ((((connp)->conn_laddr_v4 == INADDR_ANY) || \
552 557 (((connp)->conn_laddr_v4 == ((ipha)->ipha_dst)) && \
553 558 (((connp)->conn_faddr_v4 == INADDR_ANY) || \
554 559 ((connp)->conn_faddr_v4 == ((ipha)->ipha_src))))) && \
555 560 conn_wantpacket((connp), (ira), (ipha)))
556 561
557 562 #define IPCL_PROTO_MATCH_V6(connp, ira, ip6h) \
558 563 ((IN6_IS_ADDR_UNSPECIFIED(&(connp)->conn_laddr_v6) || \
559 564 (IN6_ARE_ADDR_EQUAL(&(connp)->conn_laddr_v6, &((ip6h)->ip6_dst)) && \
560 565 (IN6_IS_ADDR_UNSPECIFIED(&(connp)->conn_faddr_v6) || \
561 566 IN6_ARE_ADDR_EQUAL(&(connp)->conn_faddr_v6, &((ip6h)->ip6_src))))) && \
562 567 (conn_wantpacket_v6((connp), (ira), (ip6h))))
563 568
564 569 #define IPCL_CONN_HASH(src, ports, ipst) \
565 570 ((unsigned)(ntohl((src)) ^ ((ports) >> 24) ^ ((ports) >> 16) ^ \
566 571 ((ports) >> 8) ^ (ports)) % (ipst)->ips_ipcl_conn_fanout_size)
567 572
568 573 #define IPCL_CONN_HASH_V6(src, ports, ipst) \
569 574 IPCL_CONN_HASH(V4_PART_OF_V6((src)), (ports), (ipst))
570 575
571 576 #define IPCL_CONN_MATCH(connp, proto, src, dst, ports) \
572 577 ((connp)->conn_proto == (proto) && \
573 578 (connp)->conn_ports == (ports) && \
574 579 _IPCL_V4_MATCH((connp)->conn_faddr_v6, (src)) && \
575 580 _IPCL_V4_MATCH((connp)->conn_laddr_v6, (dst)) && \
576 581 !(connp)->conn_ipv6_v6only)
577 582
578 583 #define IPCL_CONN_MATCH_V6(connp, proto, src, dst, ports) \
579 584 ((connp)->conn_proto == (proto) && \
580 585 (connp)->conn_ports == (ports) && \
581 586 IN6_ARE_ADDR_EQUAL(&(connp)->conn_faddr_v6, &(src)) && \
582 587 IN6_ARE_ADDR_EQUAL(&(connp)->conn_laddr_v6, &(dst)))
583 588
584 589 #define IPCL_PORT_HASH(port, size) \
585 590 ((((port) >> 8) ^ (port)) & ((size) - 1))
586 591
587 592 #define IPCL_BIND_HASH(lport, ipst) \
588 593 ((unsigned)(((lport) >> 8) ^ (lport)) % \
589 594 (ipst)->ips_ipcl_bind_fanout_size)
590 595
591 596 #define IPCL_BIND_MATCH(connp, proto, laddr, lport) \
592 597 ((connp)->conn_proto == (proto) && \
593 598 (connp)->conn_lport == (lport) && \
594 599 (_IPCL_V4_MATCH_ANY((connp)->conn_laddr_v6) || \
595 600 _IPCL_V4_MATCH((connp)->conn_laddr_v6, (laddr))) && \
596 601 !(connp)->conn_ipv6_v6only)
597 602
598 603 #define IPCL_BIND_MATCH_V6(connp, proto, laddr, lport) \
599 604 ((connp)->conn_proto == (proto) && \
600 605 (connp)->conn_lport == (lport) && \
601 606 (IN6_ARE_ADDR_EQUAL(&(connp)->conn_laddr_v6, &(laddr)) || \
602 607 IN6_IS_ADDR_UNSPECIFIED(&(connp)->conn_laddr_v6)))
603 608
604 609 /*
605 610 * We compare conn_laddr since it captures both connected and a bind to
606 611 * a multicast or broadcast address.
607 612 * The caller needs to match the zoneid and also call conn_wantpacket
608 613 * for multicast, broadcast, or when conn_incoming_ifindex is set.
609 614 */
610 615 #define IPCL_UDP_MATCH(connp, lport, laddr, fport, faddr) \
611 616 (((connp)->conn_lport == (lport)) && \
612 617 ((_IPCL_V4_MATCH_ANY((connp)->conn_laddr_v6) || \
613 618 (_IPCL_V4_MATCH((connp)->conn_laddr_v6, (laddr)) && \
614 619 (_IPCL_V4_MATCH_ANY((connp)->conn_faddr_v6) || \
615 620 (_IPCL_V4_MATCH((connp)->conn_faddr_v6, (faddr)) && \
616 621 (connp)->conn_fport == (fport)))))) && \
617 622 !(connp)->conn_ipv6_v6only)
618 623
619 624 /*
620 625 * We compare conn_laddr since it captures both connected and a bind to
621 626 * a multicast or broadcast address.
622 627 * The caller needs to match the zoneid and also call conn_wantpacket_v6
623 628 * for multicast or when conn_incoming_ifindex is set.
624 629 */
625 630 #define IPCL_UDP_MATCH_V6(connp, lport, laddr, fport, faddr) \
626 631 (((connp)->conn_lport == (lport)) && \
627 632 (IN6_IS_ADDR_UNSPECIFIED(&(connp)->conn_laddr_v6) || \
628 633 (IN6_ARE_ADDR_EQUAL(&(connp)->conn_laddr_v6, &(laddr)) && \
629 634 (IN6_IS_ADDR_UNSPECIFIED(&(connp)->conn_faddr_v6) || \
630 635 (IN6_ARE_ADDR_EQUAL(&(connp)->conn_faddr_v6, &(faddr)) && \
631 636 (connp)->conn_fport == (fport))))))
632 637
633 638 #define IPCL_IPTUN_HASH(laddr, faddr) \
634 639 ((ntohl(laddr) ^ ((ntohl(faddr) << 24) | (ntohl(faddr) >> 8))) % \
635 640 ipcl_iptun_fanout_size)
636 641
637 642 #define IPCL_IPTUN_HASH_V6(laddr, faddr) \
638 643 IPCL_IPTUN_HASH((laddr)->s6_addr32[0] ^ (laddr)->s6_addr32[1] ^ \
639 644 (faddr)->s6_addr32[2] ^ (faddr)->s6_addr32[3], \
640 645 (faddr)->s6_addr32[0] ^ (faddr)->s6_addr32[1] ^ \
641 646 (laddr)->s6_addr32[2] ^ (laddr)->s6_addr32[3])
642 647
643 648 #define IPCL_IPTUN_MATCH(connp, laddr, faddr) \
|
↓ open down ↓ |
386 lines elided |
↑ open up ↑ |
644 649 (_IPCL_V4_MATCH((connp)->conn_laddr_v6, (laddr)) && \
645 650 _IPCL_V4_MATCH((connp)->conn_faddr_v6, (faddr)))
646 651
647 652 #define IPCL_IPTUN_MATCH_V6(connp, laddr, faddr) \
648 653 (IN6_ARE_ADDR_EQUAL(&(connp)->conn_laddr_v6, (laddr)) && \
649 654 IN6_ARE_ADDR_EQUAL(&(connp)->conn_faddr_v6, (faddr)))
650 655
651 656 #define IPCL_UDP_HASH(lport, ipst) \
652 657 IPCL_PORT_HASH(lport, (ipst)->ips_ipcl_udp_fanout_size)
653 658
659 +#define IPCL_DCCP_CONN_HASH(src, ports, ipst) \
660 + ((unsigned)(ntohl((src)) ^ ((ports) >> 24) ^ ((ports) >> 16) ^ \
661 + ((ports) >> 8) ^ (ports)) % (ipst)->ips_ipcl_dccp_conn_fanout_size)
662 +
663 +#define IPCL_DCCP_CONN_HASH_V6(src, ports, ipst) \
664 + IPCL_DCCP_CONN_HASH(V4_PART_OF_V6((src)), (ports), (ipst))
665 +
666 +#define IPCL_DCCP_BIND_HASH(lport, ipst) \
667 + ((unsigned)(((lport) >> 8) ^ (lport)) % \
668 + (ipst)->ips_ipcl_dccp_bind_fanout_size)
669 +
670 +
654 671 #define CONN_G_HASH_SIZE 1024
655 672
656 673 /* Raw socket hash function. */
657 674 #define IPCL_RAW_HASH(lport, ipst) \
658 675 IPCL_PORT_HASH(lport, (ipst)->ips_ipcl_raw_fanout_size)
659 676
660 677 /*
661 678 * This is similar to IPCL_BIND_MATCH except that the local port check
662 679 * is changed to a wildcard port check.
663 680 * We compare conn_laddr since it captures both connected and a bind to
664 681 * a multicast or broadcast address.
665 682 */
666 683 #define IPCL_RAW_MATCH(connp, proto, laddr) \
667 684 ((connp)->conn_proto == (proto) && \
668 685 (connp)->conn_lport == 0 && \
669 686 (_IPCL_V4_MATCH_ANY((connp)->conn_laddr_v6) || \
670 687 _IPCL_V4_MATCH((connp)->conn_laddr_v6, (laddr))))
671 688
672 689 #define IPCL_RAW_MATCH_V6(connp, proto, laddr) \
673 690 ((connp)->conn_proto == (proto) && \
674 691 (connp)->conn_lport == 0 && \
675 692 (IN6_IS_ADDR_UNSPECIFIED(&(connp)->conn_laddr_v6) || \
676 693 IN6_ARE_ADDR_EQUAL(&(connp)->conn_laddr_v6, &(laddr))))
677 694
678 695 /* Function prototypes */
679 696 extern void ipcl_g_init(void);
680 697 extern void ipcl_init(ip_stack_t *);
681 698 extern void ipcl_g_destroy(void);
682 699 extern void ipcl_destroy(ip_stack_t *);
683 700 extern conn_t *ipcl_conn_create(uint32_t, int, netstack_t *);
684 701 extern void ipcl_conn_destroy(conn_t *);
685 702
686 703 void ipcl_hash_insert_wildcard(connf_t *, conn_t *);
687 704 void ipcl_hash_remove(conn_t *);
688 705 void ipcl_hash_remove_locked(conn_t *connp, connf_t *connfp);
689 706
690 707 extern int ipcl_bind_insert(conn_t *);
691 708 extern int ipcl_bind_insert_v4(conn_t *);
692 709 extern int ipcl_bind_insert_v6(conn_t *);
693 710 extern int ipcl_conn_insert(conn_t *);
694 711 extern int ipcl_conn_insert_v4(conn_t *);
695 712 extern int ipcl_conn_insert_v6(conn_t *);
696 713 extern conn_t *ipcl_get_next_conn(connf_t *, conn_t *, uint32_t);
697 714
698 715 conn_t *ipcl_classify_v4(mblk_t *, uint8_t, uint_t, ip_recv_attr_t *,
699 716 ip_stack_t *);
700 717 conn_t *ipcl_classify_v6(mblk_t *, uint8_t, uint_t, ip_recv_attr_t *,
701 718 ip_stack_t *);
702 719 conn_t *ipcl_classify(mblk_t *, ip_recv_attr_t *, ip_stack_t *);
703 720 conn_t *ipcl_classify_raw(mblk_t *, uint8_t, uint32_t, ipha_t *,
704 721 ip6_t *, ip_recv_attr_t *, ip_stack_t *);
705 722 conn_t *ipcl_iptun_classify_v4(ipaddr_t *, ipaddr_t *, ip_stack_t *);
706 723 conn_t *ipcl_iptun_classify_v6(in6_addr_t *, in6_addr_t *, ip_stack_t *);
707 724 void ipcl_globalhash_insert(conn_t *);
708 725 void ipcl_globalhash_remove(conn_t *);
709 726 void ipcl_walk(pfv_t, void *, ip_stack_t *);
710 727 conn_t *ipcl_tcp_lookup_reversed_ipv4(ipha_t *, tcpha_t *, int, ip_stack_t *);
711 728 conn_t *ipcl_tcp_lookup_reversed_ipv6(ip6_t *, tcpha_t *, int, uint_t,
712 729 ip_stack_t *);
713 730 conn_t *ipcl_lookup_listener_v4(uint16_t, ipaddr_t, zoneid_t, ip_stack_t *);
714 731 conn_t *ipcl_lookup_listener_v6(uint16_t, in6_addr_t *, uint_t, zoneid_t,
715 732 ip_stack_t *);
716 733 int conn_trace_ref(conn_t *);
717 734 int conn_untrace_ref(conn_t *);
718 735 void ipcl_conn_cleanup(conn_t *);
719 736 extern uint_t conn_recvancillary_size(conn_t *, crb_t, ip_recv_attr_t *,
720 737 mblk_t *, ip_pkt_t *);
721 738 extern void conn_recvancillary_add(conn_t *, crb_t, ip_recv_attr_t *,
722 739 ip_pkt_t *, uchar_t *, uint_t);
723 740 conn_t *ipcl_conn_tcp_lookup_reversed_ipv4(conn_t *, ipha_t *, tcpha_t *,
724 741 ip_stack_t *);
725 742 conn_t *ipcl_conn_tcp_lookup_reversed_ipv6(conn_t *, ip6_t *, tcpha_t *,
726 743 ip_stack_t *);
727 744
728 745 extern int ip_create_helper_stream(conn_t *, ldi_ident_t);
729 746 extern void ip_free_helper_stream(conn_t *);
730 747 extern int ip_helper_stream_setup(queue_t *, dev_t *, int, int,
731 748 cred_t *, boolean_t);
732 749
733 750 #ifdef __cplusplus
734 751 }
735 752 #endif
736 753
737 754 #endif /* _INET_IPCLASSIFIER_H */
|
↓ open down ↓ |
74 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX