Print this page
4838 Fix for 4596 has some inverted booleans
Reviewed by: Josef 'Jeff' Sipek <jeffpc@josefsipek.net>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/uts/common/inet/udp/udp.c
+++ new/usr/src/uts/common/inet/udp/udp.c
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 (c) 1991, 2010, Oracle and/or its affiliates. All rights reserved.
23 23 * Copyright 2013 Nexenta Systems, Inc. All rights reserved.
24 24 * Copyright 2014, OmniTI Computer Consulting, Inc. All rights reserved.
25 25 */
26 26 /* Copyright (c) 1990 Mentat Inc. */
27 27
28 28 #include <sys/types.h>
29 29 #include <sys/stream.h>
30 30 #include <sys/stropts.h>
31 31 #include <sys/strlog.h>
32 32 #include <sys/strsun.h>
33 33 #define _SUN_TPI_VERSION 2
34 34 #include <sys/tihdr.h>
35 35 #include <sys/timod.h>
36 36 #include <sys/ddi.h>
37 37 #include <sys/sunddi.h>
38 38 #include <sys/strsubr.h>
39 39 #include <sys/suntpi.h>
40 40 #include <sys/xti_inet.h>
41 41 #include <sys/kmem.h>
42 42 #include <sys/cred_impl.h>
43 43 #include <sys/policy.h>
44 44 #include <sys/priv.h>
45 45 #include <sys/ucred.h>
46 46 #include <sys/zone.h>
47 47
48 48 #include <sys/socket.h>
49 49 #include <sys/socketvar.h>
50 50 #include <sys/sockio.h>
51 51 #include <sys/vtrace.h>
52 52 #include <sys/sdt.h>
53 53 #include <sys/debug.h>
54 54 #include <sys/isa_defs.h>
55 55 #include <sys/random.h>
56 56 #include <netinet/in.h>
57 57 #include <netinet/ip6.h>
58 58 #include <netinet/icmp6.h>
59 59 #include <netinet/udp.h>
60 60
61 61 #include <inet/common.h>
62 62 #include <inet/ip.h>
63 63 #include <inet/ip_impl.h>
64 64 #include <inet/ipsec_impl.h>
65 65 #include <inet/ip6.h>
66 66 #include <inet/ip_ire.h>
67 67 #include <inet/ip_if.h>
68 68 #include <inet/ip_multi.h>
69 69 #include <inet/ip_ndp.h>
70 70 #include <inet/proto_set.h>
71 71 #include <inet/mib2.h>
72 72 #include <inet/optcom.h>
73 73 #include <inet/snmpcom.h>
74 74 #include <inet/kstatcom.h>
75 75 #include <inet/ipclassifier.h>
76 76 #include <sys/squeue_impl.h>
77 77 #include <inet/ipnet.h>
78 78 #include <sys/ethernet.h>
79 79
80 80 #include <sys/tsol/label.h>
81 81 #include <sys/tsol/tnet.h>
82 82 #include <rpc/pmap_prot.h>
83 83
84 84 #include <inet/udp_impl.h>
85 85
86 86 /*
87 87 * Synchronization notes:
88 88 *
89 89 * UDP is MT and uses the usual kernel synchronization primitives. There are 2
90 90 * locks, the fanout lock (uf_lock) and conn_lock. conn_lock
91 91 * protects the contents of the udp_t. uf_lock protects the address and the
92 92 * fanout information.
93 93 * The lock order is conn_lock -> uf_lock.
94 94 *
95 95 * The fanout lock uf_lock:
96 96 * When a UDP endpoint is bound to a local port, it is inserted into
97 97 * a bind hash list. The list consists of an array of udp_fanout_t buckets.
98 98 * The size of the array is controlled by the udp_bind_fanout_size variable.
99 99 * This variable can be changed in /etc/system if the default value is
100 100 * not large enough. Each bind hash bucket is protected by a per bucket
101 101 * lock. It protects the udp_bind_hash and udp_ptpbhn fields in the udp_t
102 102 * structure and a few other fields in the udp_t. A UDP endpoint is removed
103 103 * from the bind hash list only when it is being unbound or being closed.
104 104 * The per bucket lock also protects a UDP endpoint's state changes.
105 105 *
106 106 * Plumbing notes:
107 107 * UDP is always a device driver. For compatibility with mibopen() code
108 108 * it is possible to I_PUSH "udp", but that results in pushing a passthrough
109 109 * dummy module.
110 110 *
111 111 * The above implies that we don't support any intermediate module to
112 112 * reside in between /dev/ip and udp -- in fact, we never supported such
113 113 * scenario in the past as the inter-layer communication semantics have
114 114 * always been private.
115 115 */
116 116
117 117 /* For /etc/system control */
118 118 uint_t udp_bind_fanout_size = UDP_BIND_FANOUT_SIZE;
119 119
120 120 static void udp_addr_req(queue_t *q, mblk_t *mp);
121 121 static void udp_tpi_bind(queue_t *q, mblk_t *mp);
122 122 static void udp_bind_hash_insert(udp_fanout_t *uf, udp_t *udp);
123 123 static void udp_bind_hash_remove(udp_t *udp, boolean_t caller_holds_lock);
124 124 static int udp_build_hdr_template(conn_t *, const in6_addr_t *,
125 125 const in6_addr_t *, in_port_t, uint32_t);
126 126 static void udp_capability_req(queue_t *q, mblk_t *mp);
127 127 static int udp_tpi_close(queue_t *q, int flags);
128 128 static void udp_close_free(conn_t *);
129 129 static void udp_tpi_connect(queue_t *q, mblk_t *mp);
130 130 static void udp_tpi_disconnect(queue_t *q, mblk_t *mp);
131 131 static void udp_err_ack(queue_t *q, mblk_t *mp, t_scalar_t t_error,
132 132 int sys_error);
133 133 static void udp_err_ack_prim(queue_t *q, mblk_t *mp, t_scalar_t primitive,
134 134 t_scalar_t tlierr, int sys_error);
135 135 static int udp_extra_priv_ports_get(queue_t *q, mblk_t *mp, caddr_t cp,
136 136 cred_t *cr);
137 137 static int udp_extra_priv_ports_add(queue_t *q, mblk_t *mp,
138 138 char *value, caddr_t cp, cred_t *cr);
139 139 static int udp_extra_priv_ports_del(queue_t *q, mblk_t *mp,
140 140 char *value, caddr_t cp, cred_t *cr);
141 141 static void udp_icmp_input(void *, mblk_t *, void *, ip_recv_attr_t *);
142 142 static void udp_icmp_error_ipv6(conn_t *connp, mblk_t *mp,
143 143 ip_recv_attr_t *ira);
144 144 static void udp_info_req(queue_t *q, mblk_t *mp);
145 145 static void udp_input(void *, mblk_t *, void *, ip_recv_attr_t *);
146 146 static void udp_lrput(queue_t *, mblk_t *);
147 147 static void udp_lwput(queue_t *, mblk_t *);
148 148 static int udp_open(queue_t *q, dev_t *devp, int flag, int sflag,
149 149 cred_t *credp, boolean_t isv6);
150 150 static int udp_openv4(queue_t *q, dev_t *devp, int flag, int sflag,
151 151 cred_t *credp);
152 152 static int udp_openv6(queue_t *q, dev_t *devp, int flag, int sflag,
153 153 cred_t *credp);
154 154 static boolean_t udp_opt_allow_udr_set(t_scalar_t level, t_scalar_t name);
155 155 int udp_opt_set(conn_t *connp, uint_t optset_context,
156 156 int level, int name, uint_t inlen,
157 157 uchar_t *invalp, uint_t *outlenp, uchar_t *outvalp,
158 158 void *thisdg_attrs, cred_t *cr);
159 159 int udp_opt_get(conn_t *connp, int level, int name,
160 160 uchar_t *ptr);
161 161 static int udp_output_connected(conn_t *connp, mblk_t *mp, cred_t *cr,
162 162 pid_t pid);
163 163 static int udp_output_lastdst(conn_t *connp, mblk_t *mp, cred_t *cr,
164 164 pid_t pid, ip_xmit_attr_t *ixa);
165 165 static int udp_output_newdst(conn_t *connp, mblk_t *data_mp, sin_t *sin,
166 166 sin6_t *sin6, ushort_t ipversion, cred_t *cr, pid_t,
167 167 ip_xmit_attr_t *ixa);
168 168 static mblk_t *udp_prepend_hdr(conn_t *, ip_xmit_attr_t *, const ip_pkt_t *,
169 169 const in6_addr_t *, const in6_addr_t *, in_port_t, uint32_t, mblk_t *,
170 170 int *);
171 171 static mblk_t *udp_prepend_header_template(conn_t *, ip_xmit_attr_t *,
172 172 mblk_t *, const in6_addr_t *, in_port_t, uint32_t, int *);
173 173 static void udp_ud_err(queue_t *q, mblk_t *mp, t_scalar_t err);
174 174 static void udp_ud_err_connected(conn_t *, t_scalar_t);
175 175 static void udp_tpi_unbind(queue_t *q, mblk_t *mp);
176 176 static in_port_t udp_update_next_port(udp_t *udp, in_port_t port,
177 177 boolean_t random);
178 178 static void udp_wput_other(queue_t *q, mblk_t *mp);
179 179 static void udp_wput_iocdata(queue_t *q, mblk_t *mp);
180 180 static void udp_wput_fallback(queue_t *q, mblk_t *mp);
181 181 static size_t udp_set_rcv_hiwat(udp_t *udp, size_t size);
182 182
183 183 static void *udp_stack_init(netstackid_t stackid, netstack_t *ns);
184 184 static void udp_stack_fini(netstackid_t stackid, void *arg);
185 185
186 186 /* Common routines for TPI and socket module */
187 187 static void udp_ulp_recv(conn_t *, mblk_t *, uint_t, ip_recv_attr_t *);
188 188
189 189 /* Common routine for TPI and socket module */
190 190 static conn_t *udp_do_open(cred_t *, boolean_t, int, int *);
191 191 static void udp_do_close(conn_t *);
192 192 static int udp_do_bind(conn_t *, struct sockaddr *, socklen_t, cred_t *,
193 193 boolean_t);
194 194 static int udp_do_unbind(conn_t *);
195 195
196 196 int udp_getsockname(sock_lower_handle_t,
197 197 struct sockaddr *, socklen_t *, cred_t *);
198 198 int udp_getpeername(sock_lower_handle_t,
199 199 struct sockaddr *, socklen_t *, cred_t *);
200 200 static int udp_do_connect(conn_t *, const struct sockaddr *, socklen_t,
201 201 cred_t *, pid_t);
202 202
203 203 #pragma inline(udp_output_connected, udp_output_newdst, udp_output_lastdst)
204 204
205 205 /*
206 206 * Checks if the given destination addr/port is allowed out.
207 207 * If allowed, registers the (dest_addr/port, node_ID) mapping at Cluster.
208 208 * Called for each connect() and for sendto()/sendmsg() to a different
209 209 * destination.
210 210 * For connect(), called in udp_connect().
211 211 * For sendto()/sendmsg(), called in udp_output_newdst().
212 212 *
213 213 * This macro assumes that the cl_inet_connect2 hook is not NULL.
214 214 * Please check this before calling this macro.
215 215 *
216 216 * void
217 217 * CL_INET_UDP_CONNECT(conn_t cp, udp_t *udp, boolean_t is_outgoing,
218 218 * in6_addr_t *faddrp, in_port_t (or uint16_t) fport, int err);
219 219 */
220 220 #define CL_INET_UDP_CONNECT(cp, is_outgoing, faddrp, fport, err) { \
221 221 (err) = 0; \
222 222 /* \
223 223 * Running in cluster mode - check and register active \
224 224 * "connection" information \
225 225 */ \
226 226 if ((cp)->conn_ipversion == IPV4_VERSION) \
227 227 (err) = (*cl_inet_connect2)( \
228 228 (cp)->conn_netstack->netstack_stackid, \
229 229 IPPROTO_UDP, is_outgoing, AF_INET, \
230 230 (uint8_t *)&((cp)->conn_laddr_v4), \
231 231 (cp)->conn_lport, \
232 232 (uint8_t *)&(V4_PART_OF_V6(*faddrp)), \
233 233 (in_port_t)(fport), NULL); \
234 234 else \
235 235 (err) = (*cl_inet_connect2)( \
236 236 (cp)->conn_netstack->netstack_stackid, \
237 237 IPPROTO_UDP, is_outgoing, AF_INET6, \
238 238 (uint8_t *)&((cp)->conn_laddr_v6), \
239 239 (cp)->conn_lport, \
240 240 (uint8_t *)(faddrp), (in_port_t)(fport), NULL); \
241 241 }
242 242
243 243 static struct module_info udp_mod_info = {
244 244 UDP_MOD_ID, UDP_MOD_NAME, 1, INFPSZ, UDP_RECV_HIWATER, UDP_RECV_LOWATER
245 245 };
246 246
247 247 /*
248 248 * Entry points for UDP as a device.
249 249 * We have separate open functions for the /dev/udp and /dev/udp6 devices.
250 250 */
251 251 static struct qinit udp_rinitv4 = {
252 252 NULL, NULL, udp_openv4, udp_tpi_close, NULL, &udp_mod_info, NULL
253 253 };
254 254
255 255 static struct qinit udp_rinitv6 = {
256 256 NULL, NULL, udp_openv6, udp_tpi_close, NULL, &udp_mod_info, NULL
257 257 };
258 258
259 259 static struct qinit udp_winit = {
260 260 (pfi_t)udp_wput, (pfi_t)ip_wsrv, NULL, NULL, NULL, &udp_mod_info
261 261 };
262 262
263 263 /* UDP entry point during fallback */
264 264 struct qinit udp_fallback_sock_winit = {
265 265 (pfi_t)udp_wput_fallback, NULL, NULL, NULL, NULL, &udp_mod_info
266 266 };
267 267
268 268 /*
269 269 * UDP needs to handle I_LINK and I_PLINK since ifconfig
270 270 * likes to use it as a place to hang the various streams.
271 271 */
272 272 static struct qinit udp_lrinit = {
273 273 (pfi_t)udp_lrput, NULL, udp_openv4, udp_tpi_close, NULL, &udp_mod_info
274 274 };
275 275
276 276 static struct qinit udp_lwinit = {
277 277 (pfi_t)udp_lwput, NULL, udp_openv4, udp_tpi_close, NULL, &udp_mod_info
278 278 };
279 279
280 280 /* For AF_INET aka /dev/udp */
281 281 struct streamtab udpinfov4 = {
282 282 &udp_rinitv4, &udp_winit, &udp_lrinit, &udp_lwinit
283 283 };
284 284
285 285 /* For AF_INET6 aka /dev/udp6 */
286 286 struct streamtab udpinfov6 = {
287 287 &udp_rinitv6, &udp_winit, &udp_lrinit, &udp_lwinit
288 288 };
289 289
290 290 #define UDP_MAXPACKET_IPV4 (IP_MAXPACKET - UDPH_SIZE - IP_SIMPLE_HDR_LENGTH)
291 291
292 292 /* Default structure copied into T_INFO_ACK messages */
293 293 static struct T_info_ack udp_g_t_info_ack_ipv4 = {
294 294 T_INFO_ACK,
295 295 UDP_MAXPACKET_IPV4, /* TSDU_size. Excl. headers */
296 296 T_INVALID, /* ETSU_size. udp does not support expedited data. */
297 297 T_INVALID, /* CDATA_size. udp does not support connect data. */
298 298 T_INVALID, /* DDATA_size. udp does not support disconnect data. */
299 299 sizeof (sin_t), /* ADDR_size. */
300 300 0, /* OPT_size - not initialized here */
301 301 UDP_MAXPACKET_IPV4, /* TIDU_size. Excl. headers */
302 302 T_CLTS, /* SERV_type. udp supports connection-less. */
303 303 TS_UNBND, /* CURRENT_state. This is set from udp_state. */
304 304 (XPG4_1|SENDZERO) /* PROVIDER_flag */
305 305 };
306 306
307 307 #define UDP_MAXPACKET_IPV6 (IP_MAXPACKET - UDPH_SIZE - IPV6_HDR_LEN)
308 308
309 309 static struct T_info_ack udp_g_t_info_ack_ipv6 = {
310 310 T_INFO_ACK,
311 311 UDP_MAXPACKET_IPV6, /* TSDU_size. Excl. headers */
312 312 T_INVALID, /* ETSU_size. udp does not support expedited data. */
313 313 T_INVALID, /* CDATA_size. udp does not support connect data. */
314 314 T_INVALID, /* DDATA_size. udp does not support disconnect data. */
315 315 sizeof (sin6_t), /* ADDR_size. */
316 316 0, /* OPT_size - not initialized here */
317 317 UDP_MAXPACKET_IPV6, /* TIDU_size. Excl. headers */
318 318 T_CLTS, /* SERV_type. udp supports connection-less. */
319 319 TS_UNBND, /* CURRENT_state. This is set from udp_state. */
320 320 (XPG4_1|SENDZERO) /* PROVIDER_flag */
321 321 };
322 322
323 323 /*
324 324 * UDP tunables related declarations. Definitions are in udp_tunables.c
325 325 */
326 326 extern mod_prop_info_t udp_propinfo_tbl[];
327 327 extern int udp_propinfo_count;
328 328
329 329 /* Setable in /etc/system */
330 330 /* If set to 0, pick ephemeral port sequentially; otherwise randomly. */
331 331 uint32_t udp_random_anon_port = 1;
332 332
333 333 /*
334 334 * Hook functions to enable cluster networking.
335 335 * On non-clustered systems these vectors must always be NULL
336 336 */
337 337
338 338 void (*cl_inet_bind)(netstackid_t stack_id, uchar_t protocol,
339 339 sa_family_t addr_family, uint8_t *laddrp, in_port_t lport,
340 340 void *args) = NULL;
341 341 void (*cl_inet_unbind)(netstackid_t stack_id, uint8_t protocol,
342 342 sa_family_t addr_family, uint8_t *laddrp, in_port_t lport,
343 343 void *args) = NULL;
344 344
345 345 typedef union T_primitives *t_primp_t;
346 346
347 347 /*
348 348 * Return the next anonymous port in the privileged port range for
349 349 * bind checking.
350 350 *
351 351 * Trusted Extension (TX) notes: TX allows administrator to mark or
352 352 * reserve ports as Multilevel ports (MLP). MLP has special function
353 353 * on TX systems. Once a port is made MLP, it's not available as
354 354 * ordinary port. This creates "holes" in the port name space. It
355 355 * may be necessary to skip the "holes" find a suitable anon port.
356 356 */
357 357 static in_port_t
358 358 udp_get_next_priv_port(udp_t *udp)
359 359 {
360 360 static in_port_t next_priv_port = IPPORT_RESERVED - 1;
361 361 in_port_t nextport;
362 362 boolean_t restart = B_FALSE;
363 363 udp_stack_t *us = udp->udp_us;
364 364
365 365 retry:
366 366 if (next_priv_port < us->us_min_anonpriv_port ||
367 367 next_priv_port >= IPPORT_RESERVED) {
368 368 next_priv_port = IPPORT_RESERVED - 1;
369 369 if (restart)
370 370 return (0);
371 371 restart = B_TRUE;
372 372 }
373 373
374 374 if (is_system_labeled() &&
375 375 (nextport = tsol_next_port(crgetzone(udp->udp_connp->conn_cred),
376 376 next_priv_port, IPPROTO_UDP, B_FALSE)) != 0) {
377 377 next_priv_port = nextport;
378 378 goto retry;
379 379 }
380 380
381 381 return (next_priv_port--);
382 382 }
383 383
384 384 /*
385 385 * Hash list removal routine for udp_t structures.
386 386 */
387 387 static void
388 388 udp_bind_hash_remove(udp_t *udp, boolean_t caller_holds_lock)
389 389 {
390 390 udp_t *udpnext;
391 391 kmutex_t *lockp;
392 392 udp_stack_t *us = udp->udp_us;
393 393 conn_t *connp = udp->udp_connp;
394 394
395 395 if (udp->udp_ptpbhn == NULL)
396 396 return;
397 397
398 398 /*
399 399 * Extract the lock pointer in case there are concurrent
400 400 * hash_remove's for this instance.
401 401 */
402 402 ASSERT(connp->conn_lport != 0);
403 403 if (!caller_holds_lock) {
404 404 lockp = &us->us_bind_fanout[UDP_BIND_HASH(connp->conn_lport,
405 405 us->us_bind_fanout_size)].uf_lock;
406 406 ASSERT(lockp != NULL);
407 407 mutex_enter(lockp);
408 408 }
409 409 if (udp->udp_ptpbhn != NULL) {
410 410 udpnext = udp->udp_bind_hash;
411 411 if (udpnext != NULL) {
412 412 udpnext->udp_ptpbhn = udp->udp_ptpbhn;
413 413 udp->udp_bind_hash = NULL;
414 414 }
415 415 *udp->udp_ptpbhn = udpnext;
416 416 udp->udp_ptpbhn = NULL;
417 417 }
418 418 if (!caller_holds_lock) {
419 419 mutex_exit(lockp);
420 420 }
421 421 }
422 422
423 423 static void
424 424 udp_bind_hash_insert(udp_fanout_t *uf, udp_t *udp)
425 425 {
426 426 conn_t *connp = udp->udp_connp;
427 427 udp_t **udpp;
428 428 udp_t *udpnext;
429 429 conn_t *connext;
430 430
431 431 ASSERT(MUTEX_HELD(&uf->uf_lock));
432 432 ASSERT(udp->udp_ptpbhn == NULL);
433 433 udpp = &uf->uf_udp;
434 434 udpnext = udpp[0];
435 435 if (udpnext != NULL) {
436 436 /*
437 437 * If the new udp bound to the INADDR_ANY address
438 438 * and the first one in the list is not bound to
439 439 * INADDR_ANY we skip all entries until we find the
440 440 * first one bound to INADDR_ANY.
441 441 * This makes sure that applications binding to a
442 442 * specific address get preference over those binding to
443 443 * INADDR_ANY.
444 444 */
445 445 connext = udpnext->udp_connp;
446 446 if (V6_OR_V4_INADDR_ANY(connp->conn_bound_addr_v6) &&
447 447 !V6_OR_V4_INADDR_ANY(connext->conn_bound_addr_v6)) {
448 448 while ((udpnext = udpp[0]) != NULL &&
449 449 !V6_OR_V4_INADDR_ANY(connext->conn_bound_addr_v6)) {
450 450 udpp = &(udpnext->udp_bind_hash);
451 451 }
452 452 if (udpnext != NULL)
453 453 udpnext->udp_ptpbhn = &udp->udp_bind_hash;
454 454 } else {
455 455 udpnext->udp_ptpbhn = &udp->udp_bind_hash;
456 456 }
457 457 }
458 458 udp->udp_bind_hash = udpnext;
459 459 udp->udp_ptpbhn = udpp;
460 460 udpp[0] = udp;
461 461 }
462 462
463 463 /*
464 464 * This routine is called to handle each O_T_BIND_REQ/T_BIND_REQ message
465 465 * passed to udp_wput.
466 466 * It associates a port number and local address with the stream.
467 467 * It calls IP to verify the local IP address, and calls IP to insert
468 468 * the conn_t in the fanout table.
469 469 * If everything is ok it then sends the T_BIND_ACK back up.
470 470 *
471 471 * Note that UDP over IPv4 and IPv6 sockets can use the same port number
472 472 * without setting SO_REUSEADDR. This is needed so that they
473 473 * can be viewed as two independent transport protocols.
474 474 * However, anonymouns ports are allocated from the same range to avoid
475 475 * duplicating the us->us_next_port_to_try.
476 476 */
477 477 static void
478 478 udp_tpi_bind(queue_t *q, mblk_t *mp)
479 479 {
480 480 sin_t *sin;
481 481 sin6_t *sin6;
482 482 mblk_t *mp1;
483 483 struct T_bind_req *tbr;
484 484 conn_t *connp;
485 485 udp_t *udp;
486 486 int error;
487 487 struct sockaddr *sa;
488 488 cred_t *cr;
489 489
490 490 /*
491 491 * All Solaris components should pass a db_credp
492 492 * for this TPI message, hence we ASSERT.
493 493 * But in case there is some other M_PROTO that looks
494 494 * like a TPI message sent by some other kernel
495 495 * component, we check and return an error.
496 496 */
497 497 cr = msg_getcred(mp, NULL);
498 498 ASSERT(cr != NULL);
499 499 if (cr == NULL) {
500 500 udp_err_ack(q, mp, TSYSERR, EINVAL);
501 501 return;
502 502 }
503 503
504 504 connp = Q_TO_CONN(q);
505 505 udp = connp->conn_udp;
506 506 if ((mp->b_wptr - mp->b_rptr) < sizeof (*tbr)) {
507 507 (void) mi_strlog(q, 1, SL_ERROR|SL_TRACE,
508 508 "udp_bind: bad req, len %u",
509 509 (uint_t)(mp->b_wptr - mp->b_rptr));
510 510 udp_err_ack(q, mp, TPROTO, 0);
511 511 return;
512 512 }
513 513 if (udp->udp_state != TS_UNBND) {
514 514 (void) mi_strlog(q, 1, SL_ERROR|SL_TRACE,
515 515 "udp_bind: bad state, %u", udp->udp_state);
516 516 udp_err_ack(q, mp, TOUTSTATE, 0);
517 517 return;
518 518 }
519 519 /*
520 520 * Reallocate the message to make sure we have enough room for an
521 521 * address.
522 522 */
523 523 mp1 = reallocb(mp, sizeof (struct T_bind_ack) + sizeof (sin6_t), 1);
524 524 if (mp1 == NULL) {
525 525 udp_err_ack(q, mp, TSYSERR, ENOMEM);
526 526 return;
527 527 }
528 528
529 529 mp = mp1;
530 530
531 531 /* Reset the message type in preparation for shipping it back. */
532 532 DB_TYPE(mp) = M_PCPROTO;
533 533
534 534 tbr = (struct T_bind_req *)mp->b_rptr;
535 535 switch (tbr->ADDR_length) {
536 536 case 0: /* Request for a generic port */
537 537 tbr->ADDR_offset = sizeof (struct T_bind_req);
538 538 if (connp->conn_family == AF_INET) {
539 539 tbr->ADDR_length = sizeof (sin_t);
540 540 sin = (sin_t *)&tbr[1];
541 541 *sin = sin_null;
542 542 sin->sin_family = AF_INET;
543 543 mp->b_wptr = (uchar_t *)&sin[1];
544 544 sa = (struct sockaddr *)sin;
545 545 } else {
546 546 ASSERT(connp->conn_family == AF_INET6);
547 547 tbr->ADDR_length = sizeof (sin6_t);
548 548 sin6 = (sin6_t *)&tbr[1];
549 549 *sin6 = sin6_null;
550 550 sin6->sin6_family = AF_INET6;
551 551 mp->b_wptr = (uchar_t *)&sin6[1];
552 552 sa = (struct sockaddr *)sin6;
553 553 }
554 554 break;
555 555
556 556 case sizeof (sin_t): /* Complete IPv4 address */
557 557 sa = (struct sockaddr *)mi_offset_param(mp, tbr->ADDR_offset,
558 558 sizeof (sin_t));
559 559 if (sa == NULL || !OK_32PTR((char *)sa)) {
560 560 udp_err_ack(q, mp, TSYSERR, EINVAL);
561 561 return;
562 562 }
563 563 if (connp->conn_family != AF_INET ||
564 564 sa->sa_family != AF_INET) {
565 565 udp_err_ack(q, mp, TSYSERR, EAFNOSUPPORT);
566 566 return;
567 567 }
568 568 break;
569 569
570 570 case sizeof (sin6_t): /* complete IPv6 address */
571 571 sa = (struct sockaddr *)mi_offset_param(mp, tbr->ADDR_offset,
572 572 sizeof (sin6_t));
573 573 if (sa == NULL || !OK_32PTR((char *)sa)) {
574 574 udp_err_ack(q, mp, TSYSERR, EINVAL);
575 575 return;
576 576 }
577 577 if (connp->conn_family != AF_INET6 ||
578 578 sa->sa_family != AF_INET6) {
579 579 udp_err_ack(q, mp, TSYSERR, EAFNOSUPPORT);
580 580 return;
581 581 }
582 582 break;
583 583
584 584 default: /* Invalid request */
585 585 (void) mi_strlog(q, 1, SL_ERROR|SL_TRACE,
586 586 "udp_bind: bad ADDR_length length %u", tbr->ADDR_length);
587 587 udp_err_ack(q, mp, TBADADDR, 0);
588 588 return;
589 589 }
590 590
591 591 error = udp_do_bind(connp, sa, tbr->ADDR_length, cr,
592 592 tbr->PRIM_type != O_T_BIND_REQ);
593 593
594 594 if (error != 0) {
595 595 if (error > 0) {
596 596 udp_err_ack(q, mp, TSYSERR, error);
597 597 } else {
598 598 udp_err_ack(q, mp, -error, 0);
599 599 }
600 600 } else {
601 601 tbr->PRIM_type = T_BIND_ACK;
602 602 qreply(q, mp);
603 603 }
604 604 }
605 605
606 606 /*
607 607 * This routine handles each T_CONN_REQ message passed to udp. It
608 608 * associates a default destination address with the stream.
609 609 *
610 610 * After various error checks are completed, udp_connect() lays
611 611 * the target address and port into the composite header template.
612 612 * Then we ask IP for information, including a source address if we didn't
613 613 * already have one. Finally we send up the T_OK_ACK reply message.
614 614 */
615 615 static void
616 616 udp_tpi_connect(queue_t *q, mblk_t *mp)
617 617 {
618 618 conn_t *connp = Q_TO_CONN(q);
619 619 int error;
620 620 socklen_t len;
621 621 struct sockaddr *sa;
622 622 struct T_conn_req *tcr;
623 623 cred_t *cr;
624 624 pid_t pid;
625 625 /*
626 626 * All Solaris components should pass a db_credp
627 627 * for this TPI message, hence we ASSERT.
628 628 * But in case there is some other M_PROTO that looks
629 629 * like a TPI message sent by some other kernel
630 630 * component, we check and return an error.
631 631 */
632 632 cr = msg_getcred(mp, &pid);
633 633 ASSERT(cr != NULL);
634 634 if (cr == NULL) {
635 635 udp_err_ack(q, mp, TSYSERR, EINVAL);
636 636 return;
637 637 }
638 638
639 639 tcr = (struct T_conn_req *)mp->b_rptr;
640 640
641 641 /* A bit of sanity checking */
642 642 if ((mp->b_wptr - mp->b_rptr) < sizeof (struct T_conn_req)) {
643 643 udp_err_ack(q, mp, TPROTO, 0);
644 644 return;
645 645 }
646 646
647 647 if (tcr->OPT_length != 0) {
648 648 udp_err_ack(q, mp, TBADOPT, 0);
649 649 return;
650 650 }
651 651
652 652 /*
653 653 * Determine packet type based on type of address passed in
654 654 * the request should contain an IPv4 or IPv6 address.
655 655 * Make sure that address family matches the type of
656 656 * family of the address passed down.
657 657 */
658 658 len = tcr->DEST_length;
659 659 switch (tcr->DEST_length) {
660 660 default:
661 661 udp_err_ack(q, mp, TBADADDR, 0);
662 662 return;
663 663
664 664 case sizeof (sin_t):
665 665 sa = (struct sockaddr *)mi_offset_param(mp, tcr->DEST_offset,
666 666 sizeof (sin_t));
667 667 break;
668 668
669 669 case sizeof (sin6_t):
670 670 sa = (struct sockaddr *)mi_offset_param(mp, tcr->DEST_offset,
671 671 sizeof (sin6_t));
672 672 break;
673 673 }
674 674
675 675 error = proto_verify_ip_addr(connp->conn_family, sa, len);
676 676 if (error != 0) {
677 677 udp_err_ack(q, mp, TSYSERR, error);
678 678 return;
679 679 }
680 680
681 681 error = udp_do_connect(connp, sa, len, cr, pid);
682 682 if (error != 0) {
683 683 if (error < 0)
684 684 udp_err_ack(q, mp, -error, 0);
685 685 else
686 686 udp_err_ack(q, mp, TSYSERR, error);
687 687 } else {
688 688 mblk_t *mp1;
689 689 /*
690 690 * We have to send a connection confirmation to
691 691 * keep TLI happy.
692 692 */
693 693 if (connp->conn_family == AF_INET) {
694 694 mp1 = mi_tpi_conn_con(NULL, (char *)sa,
695 695 sizeof (sin_t), NULL, 0);
696 696 } else {
697 697 mp1 = mi_tpi_conn_con(NULL, (char *)sa,
698 698 sizeof (sin6_t), NULL, 0);
699 699 }
700 700 if (mp1 == NULL) {
701 701 udp_err_ack(q, mp, TSYSERR, ENOMEM);
702 702 return;
703 703 }
704 704
705 705 /*
706 706 * Send ok_ack for T_CONN_REQ
707 707 */
708 708 mp = mi_tpi_ok_ack_alloc(mp);
709 709 if (mp == NULL) {
710 710 /* Unable to reuse the T_CONN_REQ for the ack. */
711 711 udp_err_ack_prim(q, mp1, T_CONN_REQ, TSYSERR, ENOMEM);
712 712 return;
713 713 }
714 714
715 715 putnext(connp->conn_rq, mp);
716 716 putnext(connp->conn_rq, mp1);
717 717 }
718 718 }
719 719
720 720 static int
721 721 udp_tpi_close(queue_t *q, int flags)
722 722 {
723 723 conn_t *connp;
724 724
725 725 if (flags & SO_FALLBACK) {
726 726 /*
727 727 * stream is being closed while in fallback
728 728 * simply free the resources that were allocated
729 729 */
730 730 inet_minor_free(WR(q)->q_ptr, (dev_t)(RD(q)->q_ptr));
731 731 qprocsoff(q);
732 732 goto done;
733 733 }
734 734
735 735 connp = Q_TO_CONN(q);
736 736 udp_do_close(connp);
737 737 done:
738 738 q->q_ptr = WR(q)->q_ptr = NULL;
739 739 return (0);
740 740 }
741 741
742 742 static void
743 743 udp_close_free(conn_t *connp)
744 744 {
745 745 udp_t *udp = connp->conn_udp;
746 746
747 747 /* If there are any options associated with the stream, free them. */
748 748 if (udp->udp_recv_ipp.ipp_fields != 0)
749 749 ip_pkt_free(&udp->udp_recv_ipp);
750 750
751 751 /*
752 752 * Clear any fields which the kmem_cache constructor clears.
753 753 * Only udp_connp needs to be preserved.
754 754 * TBD: We should make this more efficient to avoid clearing
755 755 * everything.
756 756 */
757 757 ASSERT(udp->udp_connp == connp);
758 758 bzero(udp, sizeof (udp_t));
759 759 udp->udp_connp = connp;
760 760 }
761 761
762 762 static int
763 763 udp_do_disconnect(conn_t *connp)
764 764 {
765 765 udp_t *udp;
766 766 udp_fanout_t *udpf;
767 767 udp_stack_t *us;
768 768 int error;
769 769
770 770 udp = connp->conn_udp;
771 771 us = udp->udp_us;
772 772 mutex_enter(&connp->conn_lock);
773 773 if (udp->udp_state != TS_DATA_XFER) {
774 774 mutex_exit(&connp->conn_lock);
775 775 return (-TOUTSTATE);
776 776 }
777 777 udpf = &us->us_bind_fanout[UDP_BIND_HASH(connp->conn_lport,
778 778 us->us_bind_fanout_size)];
779 779 mutex_enter(&udpf->uf_lock);
780 780 if (connp->conn_mcbc_bind)
781 781 connp->conn_saddr_v6 = ipv6_all_zeros;
782 782 else
783 783 connp->conn_saddr_v6 = connp->conn_bound_addr_v6;
784 784 connp->conn_laddr_v6 = connp->conn_bound_addr_v6;
785 785 connp->conn_faddr_v6 = ipv6_all_zeros;
786 786 connp->conn_fport = 0;
787 787 udp->udp_state = TS_IDLE;
788 788 mutex_exit(&udpf->uf_lock);
789 789
790 790 /* Remove any remnants of mapped address binding */
791 791 if (connp->conn_family == AF_INET6)
792 792 connp->conn_ipversion = IPV6_VERSION;
793 793
794 794 connp->conn_v6lastdst = ipv6_all_zeros;
795 795 error = udp_build_hdr_template(connp, &connp->conn_saddr_v6,
796 796 &connp->conn_faddr_v6, connp->conn_fport, connp->conn_flowinfo);
797 797 mutex_exit(&connp->conn_lock);
798 798 if (error != 0)
799 799 return (error);
800 800
801 801 /*
802 802 * Tell IP to remove the full binding and revert
803 803 * to the local address binding.
804 804 */
805 805 return (ip_laddr_fanout_insert(connp));
806 806 }
807 807
808 808 static void
809 809 udp_tpi_disconnect(queue_t *q, mblk_t *mp)
810 810 {
811 811 conn_t *connp = Q_TO_CONN(q);
812 812 int error;
813 813
814 814 /*
815 815 * Allocate the largest primitive we need to send back
816 816 * T_error_ack is > than T_ok_ack
817 817 */
818 818 mp = reallocb(mp, sizeof (struct T_error_ack), 1);
819 819 if (mp == NULL) {
820 820 /* Unable to reuse the T_DISCON_REQ for the ack. */
821 821 udp_err_ack_prim(q, mp, T_DISCON_REQ, TSYSERR, ENOMEM);
822 822 return;
823 823 }
824 824
825 825 error = udp_do_disconnect(connp);
826 826
827 827 if (error != 0) {
828 828 if (error < 0) {
829 829 udp_err_ack(q, mp, -error, 0);
830 830 } else {
831 831 udp_err_ack(q, mp, TSYSERR, error);
832 832 }
833 833 } else {
834 834 mp = mi_tpi_ok_ack_alloc(mp);
835 835 ASSERT(mp != NULL);
836 836 qreply(q, mp);
837 837 }
838 838 }
839 839
840 840 int
841 841 udp_disconnect(conn_t *connp)
842 842 {
843 843 int error;
844 844
845 845 connp->conn_dgram_errind = B_FALSE;
846 846 error = udp_do_disconnect(connp);
847 847 if (error < 0)
848 848 error = proto_tlitosyserr(-error);
849 849
850 850 return (error);
851 851 }
852 852
853 853 /* This routine creates a T_ERROR_ACK message and passes it upstream. */
854 854 static void
855 855 udp_err_ack(queue_t *q, mblk_t *mp, t_scalar_t t_error, int sys_error)
856 856 {
857 857 if ((mp = mi_tpi_err_ack_alloc(mp, t_error, sys_error)) != NULL)
858 858 qreply(q, mp);
859 859 }
860 860
861 861 /* Shorthand to generate and send TPI error acks to our client */
862 862 static void
863 863 udp_err_ack_prim(queue_t *q, mblk_t *mp, t_scalar_t primitive,
864 864 t_scalar_t t_error, int sys_error)
865 865 {
866 866 struct T_error_ack *teackp;
867 867
868 868 if ((mp = tpi_ack_alloc(mp, sizeof (struct T_error_ack),
869 869 M_PCPROTO, T_ERROR_ACK)) != NULL) {
870 870 teackp = (struct T_error_ack *)mp->b_rptr;
871 871 teackp->ERROR_prim = primitive;
872 872 teackp->TLI_error = t_error;
873 873 teackp->UNIX_error = sys_error;
874 874 qreply(q, mp);
875 875 }
876 876 }
877 877
878 878 /* At minimum we need 4 bytes of UDP header */
879 879 #define ICMP_MIN_UDP_HDR 4
880 880
881 881 /*
882 882 * udp_icmp_input is called as conn_recvicmp to process ICMP messages.
883 883 * Generates the appropriate T_UDERROR_IND for permanent (non-transient) errors.
884 884 * Assumes that IP has pulled up everything up to and including the ICMP header.
885 885 */
886 886 /* ARGSUSED2 */
887 887 static void
888 888 udp_icmp_input(void *arg1, mblk_t *mp, void *arg2, ip_recv_attr_t *ira)
889 889 {
890 890 conn_t *connp = (conn_t *)arg1;
891 891 icmph_t *icmph;
892 892 ipha_t *ipha;
893 893 int iph_hdr_length;
894 894 udpha_t *udpha;
895 895 sin_t sin;
896 896 sin6_t sin6;
897 897 mblk_t *mp1;
898 898 int error = 0;
899 899 udp_t *udp = connp->conn_udp;
900 900
901 901 ipha = (ipha_t *)mp->b_rptr;
902 902
903 903 ASSERT(OK_32PTR(mp->b_rptr));
904 904
905 905 if (IPH_HDR_VERSION(ipha) != IPV4_VERSION) {
906 906 ASSERT(IPH_HDR_VERSION(ipha) == IPV6_VERSION);
907 907 udp_icmp_error_ipv6(connp, mp, ira);
908 908 return;
909 909 }
910 910 ASSERT(IPH_HDR_VERSION(ipha) == IPV4_VERSION);
911 911
912 912 /* Skip past the outer IP and ICMP headers */
913 913 ASSERT(IPH_HDR_LENGTH(ipha) == ira->ira_ip_hdr_length);
914 914 iph_hdr_length = ira->ira_ip_hdr_length;
915 915 icmph = (icmph_t *)&mp->b_rptr[iph_hdr_length];
916 916 ipha = (ipha_t *)&icmph[1]; /* Inner IP header */
917 917
918 918 /* Skip past the inner IP and find the ULP header */
919 919 iph_hdr_length = IPH_HDR_LENGTH(ipha);
920 920 udpha = (udpha_t *)((char *)ipha + iph_hdr_length);
921 921
922 922 switch (icmph->icmph_type) {
923 923 case ICMP_DEST_UNREACHABLE:
924 924 switch (icmph->icmph_code) {
925 925 case ICMP_FRAGMENTATION_NEEDED: {
926 926 ipha_t *ipha;
927 927 ip_xmit_attr_t *ixa;
928 928 /*
929 929 * IP has already adjusted the path MTU.
930 930 * But we need to adjust DF for IPv4.
931 931 */
932 932 if (connp->conn_ipversion != IPV4_VERSION)
933 933 break;
934 934
935 935 ixa = conn_get_ixa(connp, B_FALSE);
936 936 if (ixa == NULL || ixa->ixa_ire == NULL) {
937 937 /*
938 938 * Some other thread holds conn_ixa. We will
939 939 * redo this on the next ICMP too big.
940 940 */
941 941 if (ixa != NULL)
942 942 ixa_refrele(ixa);
943 943 break;
944 944 }
945 945 (void) ip_get_pmtu(ixa);
946 946
947 947 mutex_enter(&connp->conn_lock);
948 948 ipha = (ipha_t *)connp->conn_ht_iphc;
949 949 if (ixa->ixa_flags & IXAF_PMTU_IPV4_DF) {
950 950 ipha->ipha_fragment_offset_and_flags |=
951 951 IPH_DF_HTONS;
952 952 } else {
953 953 ipha->ipha_fragment_offset_and_flags &=
954 954 ~IPH_DF_HTONS;
955 955 }
956 956 mutex_exit(&connp->conn_lock);
957 957 ixa_refrele(ixa);
958 958 break;
959 959 }
960 960 case ICMP_PORT_UNREACHABLE:
961 961 case ICMP_PROTOCOL_UNREACHABLE:
962 962 error = ECONNREFUSED;
963 963 break;
964 964 default:
965 965 /* Transient errors */
966 966 break;
967 967 }
968 968 break;
969 969 default:
970 970 /* Transient errors */
971 971 break;
972 972 }
973 973 if (error == 0) {
974 974 freemsg(mp);
975 975 return;
976 976 }
977 977
978 978 /*
979 979 * Deliver T_UDERROR_IND when the application has asked for it.
980 980 * The socket layer enables this automatically when connected.
981 981 */
982 982 if (!connp->conn_dgram_errind) {
983 983 freemsg(mp);
984 984 return;
985 985 }
986 986
987 987 switch (connp->conn_family) {
988 988 case AF_INET:
989 989 sin = sin_null;
990 990 sin.sin_family = AF_INET;
991 991 sin.sin_addr.s_addr = ipha->ipha_dst;
992 992 sin.sin_port = udpha->uha_dst_port;
993 993 if (IPCL_IS_NONSTR(connp)) {
994 994 mutex_enter(&connp->conn_lock);
995 995 if (udp->udp_state == TS_DATA_XFER) {
996 996 if (sin.sin_port == connp->conn_fport &&
997 997 sin.sin_addr.s_addr ==
998 998 connp->conn_faddr_v4) {
999 999 mutex_exit(&connp->conn_lock);
1000 1000 (*connp->conn_upcalls->su_set_error)
1001 1001 (connp->conn_upper_handle, error);
1002 1002 goto done;
1003 1003 }
1004 1004 } else {
1005 1005 udp->udp_delayed_error = error;
1006 1006 *((sin_t *)&udp->udp_delayed_addr) = sin;
1007 1007 }
1008 1008 mutex_exit(&connp->conn_lock);
1009 1009 } else {
1010 1010 mp1 = mi_tpi_uderror_ind((char *)&sin, sizeof (sin_t),
1011 1011 NULL, 0, error);
1012 1012 if (mp1 != NULL)
1013 1013 putnext(connp->conn_rq, mp1);
1014 1014 }
1015 1015 break;
1016 1016 case AF_INET6:
1017 1017 sin6 = sin6_null;
1018 1018 sin6.sin6_family = AF_INET6;
1019 1019 IN6_IPADDR_TO_V4MAPPED(ipha->ipha_dst, &sin6.sin6_addr);
1020 1020 sin6.sin6_port = udpha->uha_dst_port;
1021 1021 if (IPCL_IS_NONSTR(connp)) {
1022 1022 mutex_enter(&connp->conn_lock);
1023 1023 if (udp->udp_state == TS_DATA_XFER) {
1024 1024 if (sin6.sin6_port == connp->conn_fport &&
1025 1025 IN6_ARE_ADDR_EQUAL(&sin6.sin6_addr,
1026 1026 &connp->conn_faddr_v6)) {
1027 1027 mutex_exit(&connp->conn_lock);
1028 1028 (*connp->conn_upcalls->su_set_error)
1029 1029 (connp->conn_upper_handle, error);
1030 1030 goto done;
1031 1031 }
1032 1032 } else {
1033 1033 udp->udp_delayed_error = error;
1034 1034 *((sin6_t *)&udp->udp_delayed_addr) = sin6;
1035 1035 }
1036 1036 mutex_exit(&connp->conn_lock);
1037 1037 } else {
1038 1038 mp1 = mi_tpi_uderror_ind((char *)&sin6, sizeof (sin6_t),
1039 1039 NULL, 0, error);
1040 1040 if (mp1 != NULL)
1041 1041 putnext(connp->conn_rq, mp1);
1042 1042 }
1043 1043 break;
1044 1044 }
1045 1045 done:
1046 1046 freemsg(mp);
1047 1047 }
1048 1048
1049 1049 /*
1050 1050 * udp_icmp_error_ipv6 is called by udp_icmp_error to process ICMP for IPv6.
1051 1051 * Generates the appropriate T_UDERROR_IND for permanent (non-transient) errors.
1052 1052 * Assumes that IP has pulled up all the extension headers as well as the
1053 1053 * ICMPv6 header.
1054 1054 */
1055 1055 static void
1056 1056 udp_icmp_error_ipv6(conn_t *connp, mblk_t *mp, ip_recv_attr_t *ira)
1057 1057 {
1058 1058 icmp6_t *icmp6;
1059 1059 ip6_t *ip6h, *outer_ip6h;
1060 1060 uint16_t iph_hdr_length;
1061 1061 uint8_t *nexthdrp;
1062 1062 udpha_t *udpha;
1063 1063 sin6_t sin6;
1064 1064 mblk_t *mp1;
1065 1065 int error = 0;
1066 1066 udp_t *udp = connp->conn_udp;
1067 1067 udp_stack_t *us = udp->udp_us;
1068 1068
1069 1069 outer_ip6h = (ip6_t *)mp->b_rptr;
1070 1070 #ifdef DEBUG
1071 1071 if (outer_ip6h->ip6_nxt != IPPROTO_ICMPV6)
1072 1072 iph_hdr_length = ip_hdr_length_v6(mp, outer_ip6h);
1073 1073 else
1074 1074 iph_hdr_length = IPV6_HDR_LEN;
1075 1075 ASSERT(iph_hdr_length == ira->ira_ip_hdr_length);
1076 1076 #endif
1077 1077 /* Skip past the outer IP and ICMP headers */
1078 1078 iph_hdr_length = ira->ira_ip_hdr_length;
1079 1079 icmp6 = (icmp6_t *)&mp->b_rptr[iph_hdr_length];
1080 1080
1081 1081 /* Skip past the inner IP and find the ULP header */
1082 1082 ip6h = (ip6_t *)&icmp6[1]; /* Inner IP header */
1083 1083 if (!ip_hdr_length_nexthdr_v6(mp, ip6h, &iph_hdr_length, &nexthdrp)) {
1084 1084 freemsg(mp);
1085 1085 return;
1086 1086 }
1087 1087 udpha = (udpha_t *)((char *)ip6h + iph_hdr_length);
1088 1088
1089 1089 switch (icmp6->icmp6_type) {
1090 1090 case ICMP6_DST_UNREACH:
1091 1091 switch (icmp6->icmp6_code) {
1092 1092 case ICMP6_DST_UNREACH_NOPORT:
1093 1093 error = ECONNREFUSED;
1094 1094 break;
1095 1095 case ICMP6_DST_UNREACH_ADMIN:
1096 1096 case ICMP6_DST_UNREACH_NOROUTE:
1097 1097 case ICMP6_DST_UNREACH_BEYONDSCOPE:
1098 1098 case ICMP6_DST_UNREACH_ADDR:
1099 1099 /* Transient errors */
1100 1100 break;
1101 1101 default:
1102 1102 break;
1103 1103 }
1104 1104 break;
1105 1105 case ICMP6_PACKET_TOO_BIG: {
1106 1106 struct T_unitdata_ind *tudi;
1107 1107 struct T_opthdr *toh;
1108 1108 size_t udi_size;
1109 1109 mblk_t *newmp;
1110 1110 t_scalar_t opt_length = sizeof (struct T_opthdr) +
1111 1111 sizeof (struct ip6_mtuinfo);
1112 1112 sin6_t *sin6;
1113 1113 struct ip6_mtuinfo *mtuinfo;
1114 1114
1115 1115 /*
1116 1116 * If the application has requested to receive path mtu
1117 1117 * information, send up an empty message containing an
1118 1118 * IPV6_PATHMTU ancillary data item.
1119 1119 */
1120 1120 if (!connp->conn_ipv6_recvpathmtu)
1121 1121 break;
1122 1122
1123 1123 udi_size = sizeof (struct T_unitdata_ind) + sizeof (sin6_t) +
1124 1124 opt_length;
1125 1125 if ((newmp = allocb(udi_size, BPRI_MED)) == NULL) {
1126 1126 UDPS_BUMP_MIB(us, udpInErrors);
1127 1127 break;
1128 1128 }
1129 1129
1130 1130 /*
1131 1131 * newmp->b_cont is left to NULL on purpose. This is an
1132 1132 * empty message containing only ancillary data.
1133 1133 */
1134 1134 newmp->b_datap->db_type = M_PROTO;
1135 1135 tudi = (struct T_unitdata_ind *)newmp->b_rptr;
1136 1136 newmp->b_wptr = (uchar_t *)tudi + udi_size;
1137 1137 tudi->PRIM_type = T_UNITDATA_IND;
1138 1138 tudi->SRC_length = sizeof (sin6_t);
1139 1139 tudi->SRC_offset = sizeof (struct T_unitdata_ind);
1140 1140 tudi->OPT_offset = tudi->SRC_offset + sizeof (sin6_t);
1141 1141 tudi->OPT_length = opt_length;
1142 1142
1143 1143 sin6 = (sin6_t *)&tudi[1];
1144 1144 bzero(sin6, sizeof (sin6_t));
1145 1145 sin6->sin6_family = AF_INET6;
1146 1146 sin6->sin6_addr = connp->conn_faddr_v6;
1147 1147
1148 1148 toh = (struct T_opthdr *)&sin6[1];
1149 1149 toh->level = IPPROTO_IPV6;
1150 1150 toh->name = IPV6_PATHMTU;
1151 1151 toh->len = opt_length;
1152 1152 toh->status = 0;
1153 1153
1154 1154 mtuinfo = (struct ip6_mtuinfo *)&toh[1];
1155 1155 bzero(mtuinfo, sizeof (struct ip6_mtuinfo));
1156 1156 mtuinfo->ip6m_addr.sin6_family = AF_INET6;
1157 1157 mtuinfo->ip6m_addr.sin6_addr = ip6h->ip6_dst;
1158 1158 mtuinfo->ip6m_mtu = icmp6->icmp6_mtu;
1159 1159 /*
1160 1160 * We've consumed everything we need from the original
1161 1161 * message. Free it, then send our empty message.
1162 1162 */
1163 1163 freemsg(mp);
1164 1164 udp_ulp_recv(connp, newmp, msgdsize(newmp), ira);
1165 1165 return;
1166 1166 }
1167 1167 case ICMP6_TIME_EXCEEDED:
1168 1168 /* Transient errors */
1169 1169 break;
1170 1170 case ICMP6_PARAM_PROB:
1171 1171 /* If this corresponds to an ICMP_PROTOCOL_UNREACHABLE */
1172 1172 if (icmp6->icmp6_code == ICMP6_PARAMPROB_NEXTHEADER &&
1173 1173 (uchar_t *)ip6h + icmp6->icmp6_pptr ==
1174 1174 (uchar_t *)nexthdrp) {
1175 1175 error = ECONNREFUSED;
1176 1176 break;
1177 1177 }
1178 1178 break;
1179 1179 }
1180 1180 if (error == 0) {
1181 1181 freemsg(mp);
1182 1182 return;
1183 1183 }
1184 1184
1185 1185 /*
1186 1186 * Deliver T_UDERROR_IND when the application has asked for it.
1187 1187 * The socket layer enables this automatically when connected.
1188 1188 */
1189 1189 if (!connp->conn_dgram_errind) {
1190 1190 freemsg(mp);
1191 1191 return;
1192 1192 }
1193 1193
1194 1194 sin6 = sin6_null;
1195 1195 sin6.sin6_family = AF_INET6;
1196 1196 sin6.sin6_addr = ip6h->ip6_dst;
1197 1197 sin6.sin6_port = udpha->uha_dst_port;
1198 1198 sin6.sin6_flowinfo = ip6h->ip6_vcf & ~IPV6_VERS_AND_FLOW_MASK;
1199 1199
1200 1200 if (IPCL_IS_NONSTR(connp)) {
1201 1201 mutex_enter(&connp->conn_lock);
1202 1202 if (udp->udp_state == TS_DATA_XFER) {
1203 1203 if (sin6.sin6_port == connp->conn_fport &&
1204 1204 IN6_ARE_ADDR_EQUAL(&sin6.sin6_addr,
1205 1205 &connp->conn_faddr_v6)) {
1206 1206 mutex_exit(&connp->conn_lock);
1207 1207 (*connp->conn_upcalls->su_set_error)
1208 1208 (connp->conn_upper_handle, error);
1209 1209 goto done;
1210 1210 }
1211 1211 } else {
1212 1212 udp->udp_delayed_error = error;
1213 1213 *((sin6_t *)&udp->udp_delayed_addr) = sin6;
1214 1214 }
1215 1215 mutex_exit(&connp->conn_lock);
1216 1216 } else {
1217 1217 mp1 = mi_tpi_uderror_ind((char *)&sin6, sizeof (sin6_t),
1218 1218 NULL, 0, error);
1219 1219 if (mp1 != NULL)
1220 1220 putnext(connp->conn_rq, mp1);
1221 1221 }
1222 1222 done:
1223 1223 freemsg(mp);
1224 1224 }
1225 1225
1226 1226 /*
1227 1227 * This routine responds to T_ADDR_REQ messages. It is called by udp_wput.
1228 1228 * The local address is filled in if endpoint is bound. The remote address
1229 1229 * is filled in if remote address has been precified ("connected endpoint")
1230 1230 * (The concept of connected CLTS sockets is alien to published TPI
1231 1231 * but we support it anyway).
1232 1232 */
1233 1233 static void
1234 1234 udp_addr_req(queue_t *q, mblk_t *mp)
1235 1235 {
1236 1236 struct sockaddr *sa;
1237 1237 mblk_t *ackmp;
1238 1238 struct T_addr_ack *taa;
1239 1239 udp_t *udp = Q_TO_UDP(q);
1240 1240 conn_t *connp = udp->udp_connp;
1241 1241 uint_t addrlen;
1242 1242
1243 1243 /* Make it large enough for worst case */
1244 1244 ackmp = reallocb(mp, sizeof (struct T_addr_ack) +
1245 1245 2 * sizeof (sin6_t), 1);
1246 1246 if (ackmp == NULL) {
1247 1247 udp_err_ack(q, mp, TSYSERR, ENOMEM);
1248 1248 return;
1249 1249 }
1250 1250 taa = (struct T_addr_ack *)ackmp->b_rptr;
1251 1251
1252 1252 bzero(taa, sizeof (struct T_addr_ack));
1253 1253 ackmp->b_wptr = (uchar_t *)&taa[1];
1254 1254
1255 1255 taa->PRIM_type = T_ADDR_ACK;
1256 1256 ackmp->b_datap->db_type = M_PCPROTO;
1257 1257
1258 1258 if (connp->conn_family == AF_INET)
1259 1259 addrlen = sizeof (sin_t);
1260 1260 else
1261 1261 addrlen = sizeof (sin6_t);
1262 1262
1263 1263 mutex_enter(&connp->conn_lock);
1264 1264 /*
1265 1265 * Note: Following code assumes 32 bit alignment of basic
1266 1266 * data structures like sin_t and struct T_addr_ack.
1267 1267 */
1268 1268 if (udp->udp_state != TS_UNBND) {
1269 1269 /*
1270 1270 * Fill in local address first
1271 1271 */
1272 1272 taa->LOCADDR_offset = sizeof (*taa);
1273 1273 taa->LOCADDR_length = addrlen;
1274 1274 sa = (struct sockaddr *)&taa[1];
1275 1275 (void) conn_getsockname(connp, sa, &addrlen);
1276 1276 ackmp->b_wptr += addrlen;
1277 1277 }
1278 1278 if (udp->udp_state == TS_DATA_XFER) {
1279 1279 /*
1280 1280 * connected, fill remote address too
1281 1281 */
1282 1282 taa->REMADDR_length = addrlen;
1283 1283 /* assumed 32-bit alignment */
1284 1284 taa->REMADDR_offset = taa->LOCADDR_offset + taa->LOCADDR_length;
1285 1285 sa = (struct sockaddr *)(ackmp->b_rptr + taa->REMADDR_offset);
1286 1286 (void) conn_getpeername(connp, sa, &addrlen);
1287 1287 ackmp->b_wptr += addrlen;
1288 1288 }
1289 1289 mutex_exit(&connp->conn_lock);
1290 1290 ASSERT(ackmp->b_wptr <= ackmp->b_datap->db_lim);
1291 1291 qreply(q, ackmp);
1292 1292 }
1293 1293
1294 1294 static void
1295 1295 udp_copy_info(struct T_info_ack *tap, udp_t *udp)
1296 1296 {
1297 1297 conn_t *connp = udp->udp_connp;
1298 1298
1299 1299 if (connp->conn_family == AF_INET) {
1300 1300 *tap = udp_g_t_info_ack_ipv4;
1301 1301 } else {
1302 1302 *tap = udp_g_t_info_ack_ipv6;
1303 1303 }
1304 1304 tap->CURRENT_state = udp->udp_state;
1305 1305 tap->OPT_size = udp_max_optsize;
1306 1306 }
1307 1307
1308 1308 static void
1309 1309 udp_do_capability_ack(udp_t *udp, struct T_capability_ack *tcap,
1310 1310 t_uscalar_t cap_bits1)
1311 1311 {
1312 1312 tcap->CAP_bits1 = 0;
1313 1313
1314 1314 if (cap_bits1 & TC1_INFO) {
1315 1315 udp_copy_info(&tcap->INFO_ack, udp);
1316 1316 tcap->CAP_bits1 |= TC1_INFO;
1317 1317 }
1318 1318 }
1319 1319
1320 1320 /*
1321 1321 * This routine responds to T_CAPABILITY_REQ messages. It is called by
1322 1322 * udp_wput. Much of the T_CAPABILITY_ACK information is copied from
1323 1323 * udp_g_t_info_ack. The current state of the stream is copied from
1324 1324 * udp_state.
1325 1325 */
1326 1326 static void
1327 1327 udp_capability_req(queue_t *q, mblk_t *mp)
1328 1328 {
1329 1329 t_uscalar_t cap_bits1;
1330 1330 struct T_capability_ack *tcap;
1331 1331 udp_t *udp = Q_TO_UDP(q);
1332 1332
1333 1333 cap_bits1 = ((struct T_capability_req *)mp->b_rptr)->CAP_bits1;
1334 1334
1335 1335 mp = tpi_ack_alloc(mp, sizeof (struct T_capability_ack),
1336 1336 mp->b_datap->db_type, T_CAPABILITY_ACK);
1337 1337 if (!mp)
1338 1338 return;
1339 1339
1340 1340 tcap = (struct T_capability_ack *)mp->b_rptr;
1341 1341 udp_do_capability_ack(udp, tcap, cap_bits1);
1342 1342
1343 1343 qreply(q, mp);
1344 1344 }
1345 1345
1346 1346 /*
1347 1347 * This routine responds to T_INFO_REQ messages. It is called by udp_wput.
1348 1348 * Most of the T_INFO_ACK information is copied from udp_g_t_info_ack.
1349 1349 * The current state of the stream is copied from udp_state.
1350 1350 */
1351 1351 static void
1352 1352 udp_info_req(queue_t *q, mblk_t *mp)
1353 1353 {
1354 1354 udp_t *udp = Q_TO_UDP(q);
1355 1355
1356 1356 /* Create a T_INFO_ACK message. */
1357 1357 mp = tpi_ack_alloc(mp, sizeof (struct T_info_ack), M_PCPROTO,
1358 1358 T_INFO_ACK);
1359 1359 if (!mp)
1360 1360 return;
1361 1361 udp_copy_info((struct T_info_ack *)mp->b_rptr, udp);
1362 1362 qreply(q, mp);
1363 1363 }
1364 1364
1365 1365 /* For /dev/udp aka AF_INET open */
1366 1366 static int
1367 1367 udp_openv4(queue_t *q, dev_t *devp, int flag, int sflag, cred_t *credp)
1368 1368 {
1369 1369 return (udp_open(q, devp, flag, sflag, credp, B_FALSE));
1370 1370 }
1371 1371
1372 1372 /* For /dev/udp6 aka AF_INET6 open */
1373 1373 static int
1374 1374 udp_openv6(queue_t *q, dev_t *devp, int flag, int sflag, cred_t *credp)
1375 1375 {
1376 1376 return (udp_open(q, devp, flag, sflag, credp, B_TRUE));
1377 1377 }
1378 1378
1379 1379 /*
1380 1380 * This is the open routine for udp. It allocates a udp_t structure for
1381 1381 * the stream and, on the first open of the module, creates an ND table.
1382 1382 */
1383 1383 static int
1384 1384 udp_open(queue_t *q, dev_t *devp, int flag, int sflag, cred_t *credp,
1385 1385 boolean_t isv6)
1386 1386 {
1387 1387 udp_t *udp;
1388 1388 conn_t *connp;
1389 1389 dev_t conn_dev;
1390 1390 vmem_t *minor_arena;
1391 1391 int err;
1392 1392
1393 1393 /* If the stream is already open, return immediately. */
1394 1394 if (q->q_ptr != NULL)
1395 1395 return (0);
1396 1396
1397 1397 if (sflag == MODOPEN)
1398 1398 return (EINVAL);
1399 1399
1400 1400 if ((ip_minor_arena_la != NULL) && (flag & SO_SOCKSTR) &&
1401 1401 ((conn_dev = inet_minor_alloc(ip_minor_arena_la)) != 0)) {
1402 1402 minor_arena = ip_minor_arena_la;
1403 1403 } else {
1404 1404 /*
1405 1405 * Either minor numbers in the large arena were exhausted
1406 1406 * or a non socket application is doing the open.
1407 1407 * Try to allocate from the small arena.
1408 1408 */
1409 1409 if ((conn_dev = inet_minor_alloc(ip_minor_arena_sa)) == 0)
1410 1410 return (EBUSY);
1411 1411
1412 1412 minor_arena = ip_minor_arena_sa;
1413 1413 }
1414 1414
1415 1415 if (flag & SO_FALLBACK) {
1416 1416 /*
1417 1417 * Non streams socket needs a stream to fallback to
1418 1418 */
1419 1419 RD(q)->q_ptr = (void *)conn_dev;
1420 1420 WR(q)->q_qinfo = &udp_fallback_sock_winit;
1421 1421 WR(q)->q_ptr = (void *)minor_arena;
1422 1422 qprocson(q);
1423 1423 return (0);
1424 1424 }
1425 1425
1426 1426 connp = udp_do_open(credp, isv6, KM_SLEEP, &err);
1427 1427 if (connp == NULL) {
1428 1428 inet_minor_free(minor_arena, conn_dev);
1429 1429 return (err);
1430 1430 }
1431 1431 udp = connp->conn_udp;
1432 1432
1433 1433 *devp = makedevice(getemajor(*devp), (minor_t)conn_dev);
1434 1434 connp->conn_dev = conn_dev;
1435 1435 connp->conn_minor_arena = minor_arena;
1436 1436
1437 1437 /*
1438 1438 * Initialize the udp_t structure for this stream.
1439 1439 */
1440 1440 q->q_ptr = connp;
1441 1441 WR(q)->q_ptr = connp;
1442 1442 connp->conn_rq = q;
1443 1443 connp->conn_wq = WR(q);
1444 1444
1445 1445 /*
1446 1446 * Since this conn_t/udp_t is not yet visible to anybody else we don't
1447 1447 * need to lock anything.
1448 1448 */
1449 1449 ASSERT(connp->conn_proto == IPPROTO_UDP);
1450 1450 ASSERT(connp->conn_udp == udp);
1451 1451 ASSERT(udp->udp_connp == connp);
1452 1452
1453 1453 if (flag & SO_SOCKSTR) {
1454 1454 udp->udp_issocket = B_TRUE;
1455 1455 }
1456 1456
1457 1457 WR(q)->q_hiwat = connp->conn_sndbuf;
1458 1458 WR(q)->q_lowat = connp->conn_sndlowat;
1459 1459
1460 1460 qprocson(q);
1461 1461
1462 1462 /* Set the Stream head write offset and high watermark. */
1463 1463 (void) proto_set_tx_wroff(q, connp, connp->conn_wroff);
1464 1464 (void) proto_set_rx_hiwat(q, connp,
1465 1465 udp_set_rcv_hiwat(udp, connp->conn_rcvbuf));
1466 1466
1467 1467 mutex_enter(&connp->conn_lock);
1468 1468 connp->conn_state_flags &= ~CONN_INCIPIENT;
1469 1469 mutex_exit(&connp->conn_lock);
1470 1470 return (0);
1471 1471 }
1472 1472
1473 1473 /*
1474 1474 * Which UDP options OK to set through T_UNITDATA_REQ...
1475 1475 */
1476 1476 /* ARGSUSED */
1477 1477 static boolean_t
1478 1478 udp_opt_allow_udr_set(t_scalar_t level, t_scalar_t name)
1479 1479 {
1480 1480 return (B_TRUE);
1481 1481 }
1482 1482
1483 1483 /*
1484 1484 * This routine gets default values of certain options whose default
1485 1485 * values are maintained by protcol specific code
1486 1486 */
1487 1487 int
1488 1488 udp_opt_default(queue_t *q, t_scalar_t level, t_scalar_t name, uchar_t *ptr)
1489 1489 {
1490 1490 udp_t *udp = Q_TO_UDP(q);
1491 1491 udp_stack_t *us = udp->udp_us;
1492 1492 int *i1 = (int *)ptr;
1493 1493
1494 1494 switch (level) {
1495 1495 case IPPROTO_IP:
1496 1496 switch (name) {
1497 1497 case IP_MULTICAST_TTL:
1498 1498 *ptr = (uchar_t)IP_DEFAULT_MULTICAST_TTL;
1499 1499 return (sizeof (uchar_t));
1500 1500 case IP_MULTICAST_LOOP:
1501 1501 *ptr = (uchar_t)IP_DEFAULT_MULTICAST_LOOP;
1502 1502 return (sizeof (uchar_t));
1503 1503 }
1504 1504 break;
1505 1505 case IPPROTO_IPV6:
1506 1506 switch (name) {
1507 1507 case IPV6_MULTICAST_HOPS:
1508 1508 *i1 = IP_DEFAULT_MULTICAST_TTL;
1509 1509 return (sizeof (int));
1510 1510 case IPV6_MULTICAST_LOOP:
1511 1511 *i1 = IP_DEFAULT_MULTICAST_LOOP;
1512 1512 return (sizeof (int));
1513 1513 case IPV6_UNICAST_HOPS:
1514 1514 *i1 = us->us_ipv6_hoplimit;
1515 1515 return (sizeof (int));
1516 1516 }
1517 1517 break;
1518 1518 }
1519 1519 return (-1);
1520 1520 }
1521 1521
1522 1522 /*
1523 1523 * This routine retrieves the current status of socket options.
1524 1524 * It returns the size of the option retrieved, or -1.
1525 1525 */
1526 1526 int
1527 1527 udp_opt_get(conn_t *connp, t_scalar_t level, t_scalar_t name,
1528 1528 uchar_t *ptr)
1529 1529 {
1530 1530 int *i1 = (int *)ptr;
1531 1531 udp_t *udp = connp->conn_udp;
1532 1532 int len;
1533 1533 conn_opt_arg_t coas;
1534 1534 int retval;
1535 1535
1536 1536 coas.coa_connp = connp;
1537 1537 coas.coa_ixa = connp->conn_ixa;
1538 1538 coas.coa_ipp = &connp->conn_xmit_ipp;
1539 1539 coas.coa_ancillary = B_FALSE;
1540 1540 coas.coa_changed = 0;
1541 1541
1542 1542 /*
1543 1543 * We assume that the optcom framework has checked for the set
1544 1544 * of levels and names that are supported, hence we don't worry
1545 1545 * about rejecting based on that.
1546 1546 * First check for UDP specific handling, then pass to common routine.
1547 1547 */
1548 1548 switch (level) {
1549 1549 case IPPROTO_IP:
1550 1550 /*
1551 1551 * Only allow IPv4 option processing on IPv4 sockets.
1552 1552 */
1553 1553 if (connp->conn_family != AF_INET)
1554 1554 return (-1);
1555 1555
1556 1556 switch (name) {
1557 1557 case IP_OPTIONS:
1558 1558 case T_IP_OPTIONS:
1559 1559 mutex_enter(&connp->conn_lock);
1560 1560 if (!(udp->udp_recv_ipp.ipp_fields &
1561 1561 IPPF_IPV4_OPTIONS)) {
1562 1562 mutex_exit(&connp->conn_lock);
1563 1563 return (0);
1564 1564 }
1565 1565
1566 1566 len = udp->udp_recv_ipp.ipp_ipv4_options_len;
1567 1567 ASSERT(len != 0);
1568 1568 bcopy(udp->udp_recv_ipp.ipp_ipv4_options, ptr, len);
1569 1569 mutex_exit(&connp->conn_lock);
1570 1570 return (len);
1571 1571 }
1572 1572 break;
1573 1573 case IPPROTO_UDP:
1574 1574 switch (name) {
1575 1575 case UDP_NAT_T_ENDPOINT:
1576 1576 mutex_enter(&connp->conn_lock);
1577 1577 *i1 = udp->udp_nat_t_endpoint;
1578 1578 mutex_exit(&connp->conn_lock);
1579 1579 return (sizeof (int));
1580 1580 case UDP_RCVHDR:
1581 1581 mutex_enter(&connp->conn_lock);
1582 1582 *i1 = udp->udp_rcvhdr ? 1 : 0;
1583 1583 mutex_exit(&connp->conn_lock);
1584 1584 return (sizeof (int));
1585 1585 }
1586 1586 }
1587 1587 mutex_enter(&connp->conn_lock);
1588 1588 retval = conn_opt_get(&coas, level, name, ptr);
1589 1589 mutex_exit(&connp->conn_lock);
1590 1590 return (retval);
1591 1591 }
1592 1592
1593 1593 /*
1594 1594 * This routine retrieves the current status of socket options.
1595 1595 * It returns the size of the option retrieved, or -1.
1596 1596 */
1597 1597 int
1598 1598 udp_tpi_opt_get(queue_t *q, t_scalar_t level, t_scalar_t name, uchar_t *ptr)
1599 1599 {
1600 1600 conn_t *connp = Q_TO_CONN(q);
1601 1601 int err;
1602 1602
1603 1603 err = udp_opt_get(connp, level, name, ptr);
1604 1604 return (err);
1605 1605 }
1606 1606
1607 1607 /*
1608 1608 * This routine sets socket options.
1609 1609 */
1610 1610 int
1611 1611 udp_do_opt_set(conn_opt_arg_t *coa, int level, int name,
1612 1612 uint_t inlen, uchar_t *invalp, cred_t *cr, boolean_t checkonly)
1613 1613 {
1614 1614 conn_t *connp = coa->coa_connp;
1615 1615 ip_xmit_attr_t *ixa = coa->coa_ixa;
1616 1616 udp_t *udp = connp->conn_udp;
1617 1617 udp_stack_t *us = udp->udp_us;
1618 1618 int *i1 = (int *)invalp;
1619 1619 boolean_t onoff = (*i1 == 0) ? 0 : 1;
1620 1620 int error;
1621 1621
1622 1622 ASSERT(MUTEX_NOT_HELD(&coa->coa_connp->conn_lock));
1623 1623 /*
1624 1624 * First do UDP specific sanity checks and handle UDP specific
1625 1625 * options. Note that some IPPROTO_UDP options are handled
1626 1626 * by conn_opt_set.
1627 1627 */
1628 1628 switch (level) {
1629 1629 case SOL_SOCKET:
1630 1630 switch (name) {
1631 1631 case SO_SNDBUF:
1632 1632 if (*i1 > us->us_max_buf) {
1633 1633 return (ENOBUFS);
1634 1634 }
1635 1635 break;
1636 1636 case SO_RCVBUF:
1637 1637 if (*i1 > us->us_max_buf) {
1638 1638 return (ENOBUFS);
1639 1639 }
1640 1640 break;
1641 1641
1642 1642 case SCM_UCRED: {
1643 1643 struct ucred_s *ucr;
1644 1644 cred_t *newcr;
1645 1645 ts_label_t *tsl;
1646 1646
1647 1647 /*
1648 1648 * Only sockets that have proper privileges and are
1649 1649 * bound to MLPs will have any other value here, so
1650 1650 * this implicitly tests for privilege to set label.
1651 1651 */
1652 1652 if (connp->conn_mlp_type == mlptSingle)
1653 1653 break;
1654 1654
1655 1655 ucr = (struct ucred_s *)invalp;
1656 1656 if (inlen < sizeof (*ucr) + sizeof (bslabel_t) ||
1657 1657 ucr->uc_labeloff < sizeof (*ucr) ||
1658 1658 ucr->uc_labeloff + sizeof (bslabel_t) > inlen)
1659 1659 return (EINVAL);
1660 1660 if (!checkonly) {
1661 1661 /*
1662 1662 * Set ixa_tsl to the new label.
1663 1663 * We assume that crgetzoneid doesn't change
1664 1664 * as part of the SCM_UCRED.
1665 1665 */
1666 1666 ASSERT(cr != NULL);
1667 1667 if ((tsl = crgetlabel(cr)) == NULL)
1668 1668 return (EINVAL);
1669 1669 newcr = copycred_from_bslabel(cr, UCLABEL(ucr),
1670 1670 tsl->tsl_doi, KM_NOSLEEP);
1671 1671 if (newcr == NULL)
1672 1672 return (ENOSR);
1673 1673 ASSERT(newcr->cr_label != NULL);
1674 1674 /*
1675 1675 * Move the hold on the cr_label to ixa_tsl by
1676 1676 * setting cr_label to NULL. Then release newcr.
1677 1677 */
1678 1678 ip_xmit_attr_replace_tsl(ixa, newcr->cr_label);
1679 1679 ixa->ixa_flags |= IXAF_UCRED_TSL;
1680 1680 newcr->cr_label = NULL;
1681 1681 crfree(newcr);
1682 1682 coa->coa_changed |= COA_HEADER_CHANGED;
1683 1683 coa->coa_changed |= COA_WROFF_CHANGED;
1684 1684 }
1685 1685 /* Fully handled this option. */
1686 1686 return (0);
1687 1687 }
1688 1688 }
1689 1689 break;
1690 1690 case IPPROTO_UDP:
1691 1691 switch (name) {
1692 1692 case UDP_NAT_T_ENDPOINT:
1693 1693 if ((error = secpolicy_ip_config(cr, B_FALSE)) != 0) {
1694 1694 return (error);
1695 1695 }
1696 1696
1697 1697 /*
1698 1698 * Use conn_family instead so we can avoid ambiguitites
1699 1699 * with AF_INET6 sockets that may switch from IPv4
1700 1700 * to IPv6.
1701 1701 */
1702 1702 if (connp->conn_family != AF_INET) {
1703 1703 return (EAFNOSUPPORT);
1704 1704 }
1705 1705
1706 1706 if (!checkonly) {
1707 1707 mutex_enter(&connp->conn_lock);
1708 1708 udp->udp_nat_t_endpoint = onoff;
1709 1709 mutex_exit(&connp->conn_lock);
1710 1710 coa->coa_changed |= COA_HEADER_CHANGED;
1711 1711 coa->coa_changed |= COA_WROFF_CHANGED;
1712 1712 }
1713 1713 /* Fully handled this option. */
1714 1714 return (0);
1715 1715 case UDP_RCVHDR:
1716 1716 mutex_enter(&connp->conn_lock);
1717 1717 udp->udp_rcvhdr = onoff;
1718 1718 mutex_exit(&connp->conn_lock);
1719 1719 return (0);
1720 1720 }
1721 1721 break;
1722 1722 }
1723 1723 error = conn_opt_set(coa, level, name, inlen, invalp,
1724 1724 checkonly, cr);
1725 1725 return (error);
1726 1726 }
1727 1727
1728 1728 /*
1729 1729 * This routine sets socket options.
1730 1730 */
1731 1731 int
1732 1732 udp_opt_set(conn_t *connp, uint_t optset_context, int level,
1733 1733 int name, uint_t inlen, uchar_t *invalp, uint_t *outlenp,
1734 1734 uchar_t *outvalp, void *thisdg_attrs, cred_t *cr)
1735 1735 {
1736 1736 udp_t *udp = connp->conn_udp;
1737 1737 int err;
1738 1738 conn_opt_arg_t coas, *coa;
1739 1739 boolean_t checkonly;
1740 1740 udp_stack_t *us = udp->udp_us;
1741 1741
1742 1742 switch (optset_context) {
1743 1743 case SETFN_OPTCOM_CHECKONLY:
1744 1744 checkonly = B_TRUE;
1745 1745 /*
1746 1746 * Note: Implies T_CHECK semantics for T_OPTCOM_REQ
1747 1747 * inlen != 0 implies value supplied and
1748 1748 * we have to "pretend" to set it.
1749 1749 * inlen == 0 implies that there is no
1750 1750 * value part in T_CHECK request and just validation
1751 1751 * done elsewhere should be enough, we just return here.
1752 1752 */
1753 1753 if (inlen == 0) {
1754 1754 *outlenp = 0;
1755 1755 return (0);
1756 1756 }
1757 1757 break;
1758 1758 case SETFN_OPTCOM_NEGOTIATE:
1759 1759 checkonly = B_FALSE;
1760 1760 break;
1761 1761 case SETFN_UD_NEGOTIATE:
1762 1762 case SETFN_CONN_NEGOTIATE:
1763 1763 checkonly = B_FALSE;
1764 1764 /*
1765 1765 * Negotiating local and "association-related" options
1766 1766 * through T_UNITDATA_REQ.
1767 1767 *
1768 1768 * Following routine can filter out ones we do not
1769 1769 * want to be "set" this way.
1770 1770 */
1771 1771 if (!udp_opt_allow_udr_set(level, name)) {
1772 1772 *outlenp = 0;
1773 1773 return (EINVAL);
1774 1774 }
1775 1775 break;
1776 1776 default:
1777 1777 /*
1778 1778 * We should never get here
1779 1779 */
1780 1780 *outlenp = 0;
1781 1781 return (EINVAL);
1782 1782 }
1783 1783
1784 1784 ASSERT((optset_context != SETFN_OPTCOM_CHECKONLY) ||
1785 1785 (optset_context == SETFN_OPTCOM_CHECKONLY && inlen != 0));
1786 1786
1787 1787 if (thisdg_attrs != NULL) {
1788 1788 /* Options from T_UNITDATA_REQ */
1789 1789 coa = (conn_opt_arg_t *)thisdg_attrs;
1790 1790 ASSERT(coa->coa_connp == connp);
1791 1791 ASSERT(coa->coa_ixa != NULL);
1792 1792 ASSERT(coa->coa_ipp != NULL);
1793 1793 ASSERT(coa->coa_ancillary);
1794 1794 } else {
1795 1795 coa = &coas;
1796 1796 coas.coa_connp = connp;
1797 1797 /* Get a reference on conn_ixa to prevent concurrent mods */
1798 1798 coas.coa_ixa = conn_get_ixa(connp, B_TRUE);
1799 1799 if (coas.coa_ixa == NULL) {
1800 1800 *outlenp = 0;
1801 1801 return (ENOMEM);
1802 1802 }
1803 1803 coas.coa_ipp = &connp->conn_xmit_ipp;
1804 1804 coas.coa_ancillary = B_FALSE;
1805 1805 coas.coa_changed = 0;
1806 1806 }
1807 1807
1808 1808 err = udp_do_opt_set(coa, level, name, inlen, invalp,
1809 1809 cr, checkonly);
1810 1810 if (err != 0) {
1811 1811 errout:
1812 1812 if (!coa->coa_ancillary)
1813 1813 ixa_refrele(coa->coa_ixa);
1814 1814 *outlenp = 0;
1815 1815 return (err);
1816 1816 }
1817 1817 /* Handle DHCPINIT here outside of lock */
1818 1818 if (level == IPPROTO_IP && name == IP_DHCPINIT_IF) {
1819 1819 uint_t ifindex;
1820 1820 ill_t *ill;
1821 1821
1822 1822 ifindex = *(uint_t *)invalp;
1823 1823 if (ifindex == 0) {
1824 1824 ill = NULL;
1825 1825 } else {
1826 1826 ill = ill_lookup_on_ifindex(ifindex, B_FALSE,
1827 1827 coa->coa_ixa->ixa_ipst);
1828 1828 if (ill == NULL) {
1829 1829 err = ENXIO;
1830 1830 goto errout;
1831 1831 }
1832 1832
1833 1833 mutex_enter(&ill->ill_lock);
1834 1834 if (ill->ill_state_flags & ILL_CONDEMNED) {
1835 1835 mutex_exit(&ill->ill_lock);
1836 1836 ill_refrele(ill);
1837 1837 err = ENXIO;
1838 1838 goto errout;
1839 1839 }
1840 1840 if (IS_VNI(ill)) {
1841 1841 mutex_exit(&ill->ill_lock);
1842 1842 ill_refrele(ill);
1843 1843 err = EINVAL;
1844 1844 goto errout;
1845 1845 }
1846 1846 }
1847 1847 mutex_enter(&connp->conn_lock);
1848 1848
1849 1849 if (connp->conn_dhcpinit_ill != NULL) {
1850 1850 /*
1851 1851 * We've locked the conn so conn_cleanup_ill()
1852 1852 * cannot clear conn_dhcpinit_ill -- so it's
1853 1853 * safe to access the ill.
1854 1854 */
1855 1855 ill_t *oill = connp->conn_dhcpinit_ill;
1856 1856
1857 1857 ASSERT(oill->ill_dhcpinit != 0);
1858 1858 atomic_dec_32(&oill->ill_dhcpinit);
1859 1859 ill_set_inputfn(connp->conn_dhcpinit_ill);
1860 1860 connp->conn_dhcpinit_ill = NULL;
1861 1861 }
1862 1862
1863 1863 if (ill != NULL) {
1864 1864 connp->conn_dhcpinit_ill = ill;
1865 1865 atomic_inc_32(&ill->ill_dhcpinit);
1866 1866 ill_set_inputfn(ill);
1867 1867 mutex_exit(&connp->conn_lock);
1868 1868 mutex_exit(&ill->ill_lock);
1869 1869 ill_refrele(ill);
1870 1870 } else {
1871 1871 mutex_exit(&connp->conn_lock);
1872 1872 }
1873 1873 }
1874 1874
1875 1875 /*
1876 1876 * Common case of OK return with outval same as inval.
1877 1877 */
1878 1878 if (invalp != outvalp) {
1879 1879 /* don't trust bcopy for identical src/dst */
1880 1880 (void) bcopy(invalp, outvalp, inlen);
1881 1881 }
1882 1882 *outlenp = inlen;
1883 1883
1884 1884 /*
1885 1885 * If this was not ancillary data, then we rebuild the headers,
1886 1886 * update the IRE/NCE, and IPsec as needed.
1887 1887 * Since the label depends on the destination we go through
1888 1888 * ip_set_destination first.
1889 1889 */
1890 1890 if (coa->coa_ancillary) {
1891 1891 return (0);
1892 1892 }
1893 1893
1894 1894 if (coa->coa_changed & COA_ROUTE_CHANGED) {
1895 1895 in6_addr_t saddr, faddr, nexthop;
1896 1896 in_port_t fport;
1897 1897
1898 1898 /*
1899 1899 * We clear lastdst to make sure we pick up the change
1900 1900 * next time sending.
1901 1901 * If we are connected we re-cache the information.
1902 1902 * We ignore errors to preserve BSD behavior.
1903 1903 * Note that we don't redo IPsec policy lookup here
1904 1904 * since the final destination (or source) didn't change.
1905 1905 */
1906 1906 mutex_enter(&connp->conn_lock);
1907 1907 connp->conn_v6lastdst = ipv6_all_zeros;
1908 1908
1909 1909 ip_attr_nexthop(coa->coa_ipp, coa->coa_ixa,
1910 1910 &connp->conn_faddr_v6, &nexthop);
1911 1911 saddr = connp->conn_saddr_v6;
1912 1912 faddr = connp->conn_faddr_v6;
1913 1913 fport = connp->conn_fport;
1914 1914 mutex_exit(&connp->conn_lock);
1915 1915
1916 1916 if (!IN6_IS_ADDR_UNSPECIFIED(&faddr) &&
1917 1917 !IN6_IS_ADDR_V4MAPPED_ANY(&faddr)) {
1918 1918 (void) ip_attr_connect(connp, coa->coa_ixa,
1919 1919 &saddr, &faddr, &nexthop, fport, NULL, NULL,
1920 1920 IPDF_ALLOW_MCBC | IPDF_VERIFY_DST);
1921 1921 }
1922 1922 }
1923 1923
1924 1924 ixa_refrele(coa->coa_ixa);
1925 1925
1926 1926 if (coa->coa_changed & COA_HEADER_CHANGED) {
1927 1927 /*
1928 1928 * Rebuild the header template if we are connected.
1929 1929 * Otherwise clear conn_v6lastdst so we rebuild the header
1930 1930 * in the data path.
1931 1931 */
1932 1932 mutex_enter(&connp->conn_lock);
1933 1933 if (!IN6_IS_ADDR_UNSPECIFIED(&connp->conn_faddr_v6) &&
1934 1934 !IN6_IS_ADDR_V4MAPPED_ANY(&connp->conn_faddr_v6)) {
1935 1935 err = udp_build_hdr_template(connp,
1936 1936 &connp->conn_saddr_v6, &connp->conn_faddr_v6,
1937 1937 connp->conn_fport, connp->conn_flowinfo);
1938 1938 if (err != 0) {
1939 1939 mutex_exit(&connp->conn_lock);
1940 1940 return (err);
1941 1941 }
1942 1942 } else {
1943 1943 connp->conn_v6lastdst = ipv6_all_zeros;
1944 1944 }
1945 1945 mutex_exit(&connp->conn_lock);
1946 1946 }
1947 1947 if (coa->coa_changed & COA_RCVBUF_CHANGED) {
1948 1948 (void) proto_set_rx_hiwat(connp->conn_rq, connp,
1949 1949 connp->conn_rcvbuf);
1950 1950 }
1951 1951 if ((coa->coa_changed & COA_SNDBUF_CHANGED) && !IPCL_IS_NONSTR(connp)) {
1952 1952 connp->conn_wq->q_hiwat = connp->conn_sndbuf;
1953 1953 }
1954 1954 if (coa->coa_changed & COA_WROFF_CHANGED) {
1955 1955 /* Increase wroff if needed */
1956 1956 uint_t wroff;
1957 1957
1958 1958 mutex_enter(&connp->conn_lock);
1959 1959 wroff = connp->conn_ht_iphc_allocated + us->us_wroff_extra;
1960 1960 if (udp->udp_nat_t_endpoint)
1961 1961 wroff += sizeof (uint32_t);
1962 1962 if (wroff > connp->conn_wroff) {
1963 1963 connp->conn_wroff = wroff;
1964 1964 mutex_exit(&connp->conn_lock);
1965 1965 (void) proto_set_tx_wroff(connp->conn_rq, connp, wroff);
1966 1966 } else {
1967 1967 mutex_exit(&connp->conn_lock);
1968 1968 }
1969 1969 }
1970 1970 return (err);
1971 1971 }
1972 1972
1973 1973 /* This routine sets socket options. */
1974 1974 int
1975 1975 udp_tpi_opt_set(queue_t *q, uint_t optset_context, int level, int name,
1976 1976 uint_t inlen, uchar_t *invalp, uint_t *outlenp, uchar_t *outvalp,
1977 1977 void *thisdg_attrs, cred_t *cr)
1978 1978 {
1979 1979 conn_t *connp = Q_TO_CONN(q);
1980 1980 int error;
1981 1981
1982 1982 error = udp_opt_set(connp, optset_context, level, name, inlen, invalp,
1983 1983 outlenp, outvalp, thisdg_attrs, cr);
1984 1984 return (error);
1985 1985 }
1986 1986
1987 1987 /*
1988 1988 * Setup IP and UDP headers.
1989 1989 * Returns NULL on allocation failure, in which case data_mp is freed.
1990 1990 */
1991 1991 mblk_t *
1992 1992 udp_prepend_hdr(conn_t *connp, ip_xmit_attr_t *ixa, const ip_pkt_t *ipp,
1993 1993 const in6_addr_t *v6src, const in6_addr_t *v6dst, in_port_t dstport,
1994 1994 uint32_t flowinfo, mblk_t *data_mp, int *errorp)
1995 1995 {
1996 1996 mblk_t *mp;
1997 1997 udpha_t *udpha;
1998 1998 udp_stack_t *us = connp->conn_netstack->netstack_udp;
1999 1999 uint_t data_len;
2000 2000 uint32_t cksum;
2001 2001 udp_t *udp = connp->conn_udp;
2002 2002 boolean_t insert_spi = udp->udp_nat_t_endpoint;
2003 2003 uint_t ulp_hdr_len;
2004 2004
2005 2005 data_len = msgdsize(data_mp);
2006 2006 ulp_hdr_len = UDPH_SIZE;
2007 2007 if (insert_spi)
2008 2008 ulp_hdr_len += sizeof (uint32_t);
2009 2009
2010 2010 mp = conn_prepend_hdr(ixa, ipp, v6src, v6dst, IPPROTO_UDP, flowinfo,
2011 2011 ulp_hdr_len, data_mp, data_len, us->us_wroff_extra, &cksum, errorp);
2012 2012 if (mp == NULL) {
2013 2013 ASSERT(*errorp != 0);
2014 2014 return (NULL);
2015 2015 }
2016 2016
2017 2017 data_len += ulp_hdr_len;
2018 2018 ixa->ixa_pktlen = data_len + ixa->ixa_ip_hdr_length;
2019 2019
2020 2020 udpha = (udpha_t *)(mp->b_rptr + ixa->ixa_ip_hdr_length);
2021 2021 udpha->uha_src_port = connp->conn_lport;
2022 2022 udpha->uha_dst_port = dstport;
2023 2023 udpha->uha_checksum = 0;
2024 2024 udpha->uha_length = htons(data_len);
2025 2025
2026 2026 /*
2027 2027 * If there was a routing option/header then conn_prepend_hdr
2028 2028 * has massaged it and placed the pseudo-header checksum difference
2029 2029 * in the cksum argument.
2030 2030 *
2031 2031 * Setup header length and prepare for ULP checksum done in IP.
2032 2032 *
2033 2033 * We make it easy for IP to include our pseudo header
2034 2034 * by putting our length in uha_checksum.
2035 2035 * The IP source, destination, and length have already been set by
2036 2036 * conn_prepend_hdr.
2037 2037 */
2038 2038 cksum += data_len;
2039 2039 cksum = (cksum >> 16) + (cksum & 0xFFFF);
2040 2040 ASSERT(cksum < 0x10000);
2041 2041
2042 2042 if (ixa->ixa_flags & IXAF_IS_IPV4) {
2043 2043 ipha_t *ipha = (ipha_t *)mp->b_rptr;
2044 2044
2045 2045 ASSERT(ntohs(ipha->ipha_length) == ixa->ixa_pktlen);
2046 2046
2047 2047 /* IP does the checksum if uha_checksum is non-zero */
2048 2048 if (us->us_do_checksum) {
2049 2049 if (cksum == 0)
2050 2050 udpha->uha_checksum = 0xffff;
2051 2051 else
2052 2052 udpha->uha_checksum = htons(cksum);
2053 2053 } else {
2054 2054 udpha->uha_checksum = 0;
2055 2055 }
2056 2056 } else {
2057 2057 ip6_t *ip6h = (ip6_t *)mp->b_rptr;
2058 2058
2059 2059 ASSERT(ntohs(ip6h->ip6_plen) + IPV6_HDR_LEN == ixa->ixa_pktlen);
2060 2060 if (cksum == 0)
2061 2061 udpha->uha_checksum = 0xffff;
2062 2062 else
2063 2063 udpha->uha_checksum = htons(cksum);
2064 2064 }
2065 2065
2066 2066 /* Insert all-0s SPI now. */
2067 2067 if (insert_spi)
2068 2068 *((uint32_t *)(udpha + 1)) = 0;
2069 2069
2070 2070 return (mp);
2071 2071 }
2072 2072
2073 2073 static int
2074 2074 udp_build_hdr_template(conn_t *connp, const in6_addr_t *v6src,
2075 2075 const in6_addr_t *v6dst, in_port_t dstport, uint32_t flowinfo)
2076 2076 {
2077 2077 udpha_t *udpha;
2078 2078 int error;
2079 2079
2080 2080 ASSERT(MUTEX_HELD(&connp->conn_lock));
2081 2081 /*
2082 2082 * We clear lastdst to make sure we don't use the lastdst path
2083 2083 * next time sending since we might not have set v6dst yet.
2084 2084 */
2085 2085 connp->conn_v6lastdst = ipv6_all_zeros;
2086 2086
2087 2087 error = conn_build_hdr_template(connp, UDPH_SIZE, 0, v6src, v6dst,
2088 2088 flowinfo);
2089 2089 if (error != 0)
2090 2090 return (error);
2091 2091
2092 2092 /*
2093 2093 * Any routing header/option has been massaged. The checksum difference
2094 2094 * is stored in conn_sum.
2095 2095 */
2096 2096 udpha = (udpha_t *)connp->conn_ht_ulp;
2097 2097 udpha->uha_src_port = connp->conn_lport;
2098 2098 udpha->uha_dst_port = dstport;
2099 2099 udpha->uha_checksum = 0;
2100 2100 udpha->uha_length = htons(UDPH_SIZE); /* Filled in later */
2101 2101 return (0);
2102 2102 }
2103 2103
2104 2104 static mblk_t *
2105 2105 udp_queue_fallback(udp_t *udp, mblk_t *mp)
2106 2106 {
2107 2107 ASSERT(MUTEX_HELD(&udp->udp_recv_lock));
2108 2108 if (IPCL_IS_NONSTR(udp->udp_connp)) {
2109 2109 /*
2110 2110 * fallback has started but messages have not been moved yet
2111 2111 */
2112 2112 if (udp->udp_fallback_queue_head == NULL) {
2113 2113 ASSERT(udp->udp_fallback_queue_tail == NULL);
2114 2114 udp->udp_fallback_queue_head = mp;
2115 2115 udp->udp_fallback_queue_tail = mp;
2116 2116 } else {
2117 2117 ASSERT(udp->udp_fallback_queue_tail != NULL);
2118 2118 udp->udp_fallback_queue_tail->b_next = mp;
2119 2119 udp->udp_fallback_queue_tail = mp;
2120 2120 }
2121 2121 return (NULL);
2122 2122 } else {
2123 2123 /*
2124 2124 * Fallback completed, let the caller putnext() the mblk.
2125 2125 */
2126 2126 return (mp);
2127 2127 }
2128 2128 }
2129 2129
2130 2130 /*
2131 2131 * Deliver data to ULP. In case we have a socket, and it's falling back to
2132 2132 * TPI, then we'll queue the mp for later processing.
2133 2133 */
2134 2134 static void
2135 2135 udp_ulp_recv(conn_t *connp, mblk_t *mp, uint_t len, ip_recv_attr_t *ira)
2136 2136 {
2137 2137 if (IPCL_IS_NONSTR(connp)) {
2138 2138 udp_t *udp = connp->conn_udp;
2139 2139 int error;
2140 2140
2141 2141 ASSERT(len == msgdsize(mp));
2142 2142 if ((*connp->conn_upcalls->su_recv)
2143 2143 (connp->conn_upper_handle, mp, len, 0, &error, NULL) < 0) {
2144 2144 mutex_enter(&udp->udp_recv_lock);
2145 2145 if (error == ENOSPC) {
2146 2146 /*
2147 2147 * let's confirm while holding the lock
2148 2148 */
2149 2149 if ((*connp->conn_upcalls->su_recv)
2150 2150 (connp->conn_upper_handle, NULL, 0, 0,
2151 2151 &error, NULL) < 0) {
2152 2152 ASSERT(error == ENOSPC);
2153 2153 if (error == ENOSPC) {
2154 2154 connp->conn_flow_cntrld =
2155 2155 B_TRUE;
2156 2156 }
2157 2157 }
2158 2158 mutex_exit(&udp->udp_recv_lock);
2159 2159 } else {
2160 2160 ASSERT(error == EOPNOTSUPP);
2161 2161 mp = udp_queue_fallback(udp, mp);
2162 2162 mutex_exit(&udp->udp_recv_lock);
2163 2163 if (mp != NULL)
2164 2164 putnext(connp->conn_rq, mp);
2165 2165 }
2166 2166 }
2167 2167 ASSERT(MUTEX_NOT_HELD(&udp->udp_recv_lock));
2168 2168 } else {
2169 2169 if (is_system_labeled()) {
2170 2170 ASSERT(ira->ira_cred != NULL);
2171 2171 /*
2172 2172 * Provide for protocols above UDP such as RPC
2173 2173 * NOPID leaves db_cpid unchanged.
2174 2174 */
2175 2175 mblk_setcred(mp, ira->ira_cred, NOPID);
2176 2176 }
2177 2177
2178 2178 putnext(connp->conn_rq, mp);
2179 2179 }
2180 2180 }
2181 2181
2182 2182 /*
2183 2183 * This is the inbound data path.
2184 2184 * IP has already pulled up the IP plus UDP headers and verified alignment
2185 2185 * etc.
2186 2186 */
2187 2187 /* ARGSUSED2 */
2188 2188 static void
2189 2189 udp_input(void *arg1, mblk_t *mp, void *arg2, ip_recv_attr_t *ira)
2190 2190 {
2191 2191 conn_t *connp = (conn_t *)arg1;
2192 2192 struct T_unitdata_ind *tudi;
2193 2193 uchar_t *rptr; /* Pointer to IP header */
2194 2194 int hdr_length; /* Length of IP+UDP headers */
2195 2195 int udi_size; /* Size of T_unitdata_ind */
2196 2196 int pkt_len;
2197 2197 udp_t *udp;
2198 2198 udpha_t *udpha;
2199 2199 ip_pkt_t ipps;
2200 2200 ip6_t *ip6h;
2201 2201 mblk_t *mp1;
2202 2202 uint32_t udp_ipv4_options_len;
2203 2203 crb_t recv_ancillary;
2204 2204 udp_stack_t *us;
2205 2205
2206 2206 ASSERT(connp->conn_flags & IPCL_UDPCONN);
2207 2207
2208 2208 udp = connp->conn_udp;
2209 2209 us = udp->udp_us;
2210 2210 rptr = mp->b_rptr;
2211 2211
2212 2212 ASSERT(DB_TYPE(mp) == M_DATA);
2213 2213 ASSERT(OK_32PTR(rptr));
2214 2214 ASSERT(ira->ira_pktlen == msgdsize(mp));
2215 2215 pkt_len = ira->ira_pktlen;
2216 2216
2217 2217 /*
2218 2218 * Get a snapshot of these and allow other threads to change
2219 2219 * them after that. We need the same recv_ancillary when determining
2220 2220 * the size as when adding the ancillary data items.
2221 2221 */
2222 2222 mutex_enter(&connp->conn_lock);
2223 2223 udp_ipv4_options_len = udp->udp_recv_ipp.ipp_ipv4_options_len;
2224 2224 recv_ancillary = connp->conn_recv_ancillary;
2225 2225 mutex_exit(&connp->conn_lock);
2226 2226
2227 2227 hdr_length = ira->ira_ip_hdr_length;
2228 2228
2229 2229 /*
2230 2230 * IP inspected the UDP header thus all of it must be in the mblk.
2231 2231 * UDP length check is performed for IPv6 packets and IPv4 packets
2232 2232 * to check if the size of the packet as specified
2233 2233 * by the UDP header is the same as the length derived from the IP
2234 2234 * header.
2235 2235 */
2236 2236 udpha = (udpha_t *)(rptr + hdr_length);
2237 2237 if (pkt_len != ntohs(udpha->uha_length) + hdr_length)
2238 2238 goto tossit;
2239 2239
2240 2240 hdr_length += UDPH_SIZE;
2241 2241 ASSERT(MBLKL(mp) >= hdr_length); /* IP did a pullup */
2242 2242
2243 2243 /* Initialize regardless of IP version */
2244 2244 ipps.ipp_fields = 0;
2245 2245
2246 2246 if (((ira->ira_flags & IRAF_IPV4_OPTIONS) ||
2247 2247 udp_ipv4_options_len > 0) &&
2248 2248 connp->conn_family == AF_INET) {
2249 2249 int err;
2250 2250
2251 2251 /*
2252 2252 * Record/update udp_recv_ipp with the lock
2253 2253 * held. Not needed for AF_INET6 sockets
2254 2254 * since they don't support a getsockopt of IP_OPTIONS.
2255 2255 */
2256 2256 mutex_enter(&connp->conn_lock);
2257 2257 err = ip_find_hdr_v4((ipha_t *)rptr, &udp->udp_recv_ipp,
2258 2258 B_TRUE);
2259 2259 if (err != 0) {
2260 2260 /* Allocation failed. Drop packet */
2261 2261 mutex_exit(&connp->conn_lock);
2262 2262 freemsg(mp);
2263 2263 UDPS_BUMP_MIB(us, udpInErrors);
2264 2264 return;
2265 2265 }
2266 2266 mutex_exit(&connp->conn_lock);
2267 2267 }
2268 2268
2269 2269 if (recv_ancillary.crb_all != 0) {
2270 2270 /*
2271 2271 * Record packet information in the ip_pkt_t
2272 2272 */
2273 2273 if (ira->ira_flags & IRAF_IS_IPV4) {
2274 2274 ASSERT(IPH_HDR_VERSION(rptr) == IPV4_VERSION);
2275 2275 ASSERT(MBLKL(mp) >= sizeof (ipha_t));
2276 2276 ASSERT(((ipha_t *)rptr)->ipha_protocol == IPPROTO_UDP);
2277 2277 ASSERT(ira->ira_ip_hdr_length == IPH_HDR_LENGTH(rptr));
2278 2278
2279 2279 (void) ip_find_hdr_v4((ipha_t *)rptr, &ipps, B_FALSE);
2280 2280 } else {
2281 2281 uint8_t nexthdrp;
2282 2282
2283 2283 ASSERT(IPH_HDR_VERSION(rptr) == IPV6_VERSION);
2284 2284 /*
2285 2285 * IPv6 packets can only be received by applications
2286 2286 * that are prepared to receive IPv6 addresses.
2287 2287 * The IP fanout must ensure this.
2288 2288 */
2289 2289 ASSERT(connp->conn_family == AF_INET6);
2290 2290
2291 2291 ip6h = (ip6_t *)rptr;
2292 2292
2293 2293 /* We don't care about the length, but need the ipp */
2294 2294 hdr_length = ip_find_hdr_v6(mp, ip6h, B_TRUE, &ipps,
2295 2295 &nexthdrp);
2296 2296 ASSERT(hdr_length == ira->ira_ip_hdr_length);
2297 2297 /* Restore */
2298 2298 hdr_length = ira->ira_ip_hdr_length + UDPH_SIZE;
2299 2299 ASSERT(nexthdrp == IPPROTO_UDP);
2300 2300 }
2301 2301 }
2302 2302
2303 2303 /*
2304 2304 * This is the inbound data path. Packets are passed upstream as
2305 2305 * T_UNITDATA_IND messages.
2306 2306 */
2307 2307 if (connp->conn_family == AF_INET) {
2308 2308 sin_t *sin;
2309 2309
2310 2310 ASSERT(IPH_HDR_VERSION((ipha_t *)rptr) == IPV4_VERSION);
2311 2311
2312 2312 /*
2313 2313 * Normally only send up the source address.
2314 2314 * If any ancillary data items are wanted we add those.
2315 2315 */
2316 2316 udi_size = sizeof (struct T_unitdata_ind) + sizeof (sin_t);
2317 2317 if (recv_ancillary.crb_all != 0) {
2318 2318 udi_size += conn_recvancillary_size(connp,
2319 2319 recv_ancillary, ira, mp, &ipps);
2320 2320 }
2321 2321
2322 2322 /* Allocate a message block for the T_UNITDATA_IND structure. */
2323 2323 mp1 = allocb(udi_size, BPRI_MED);
2324 2324 if (mp1 == NULL) {
2325 2325 freemsg(mp);
2326 2326 UDPS_BUMP_MIB(us, udpInErrors);
2327 2327 return;
2328 2328 }
2329 2329 mp1->b_cont = mp;
2330 2330 mp1->b_datap->db_type = M_PROTO;
2331 2331 tudi = (struct T_unitdata_ind *)mp1->b_rptr;
2332 2332 mp1->b_wptr = (uchar_t *)tudi + udi_size;
2333 2333 tudi->PRIM_type = T_UNITDATA_IND;
2334 2334 tudi->SRC_length = sizeof (sin_t);
2335 2335 tudi->SRC_offset = sizeof (struct T_unitdata_ind);
2336 2336 tudi->OPT_offset = sizeof (struct T_unitdata_ind) +
2337 2337 sizeof (sin_t);
2338 2338 udi_size -= (sizeof (struct T_unitdata_ind) + sizeof (sin_t));
2339 2339 tudi->OPT_length = udi_size;
2340 2340 sin = (sin_t *)&tudi[1];
2341 2341 sin->sin_addr.s_addr = ((ipha_t *)rptr)->ipha_src;
2342 2342 sin->sin_port = udpha->uha_src_port;
2343 2343 sin->sin_family = connp->conn_family;
2344 2344 *(uint32_t *)&sin->sin_zero[0] = 0;
2345 2345 *(uint32_t *)&sin->sin_zero[4] = 0;
2346 2346
2347 2347 /*
2348 2348 * Add options if IP_RECVDSTADDR, IP_RECVIF, IP_RECVSLLA or
2349 2349 * IP_RECVTTL has been set.
2350 2350 */
2351 2351 if (udi_size != 0) {
2352 2352 conn_recvancillary_add(connp, recv_ancillary, ira,
2353 2353 &ipps, (uchar_t *)&sin[1], udi_size);
2354 2354 }
2355 2355 } else {
2356 2356 sin6_t *sin6;
2357 2357
2358 2358 /*
2359 2359 * Handle both IPv4 and IPv6 packets for IPv6 sockets.
2360 2360 *
2361 2361 * Normally we only send up the address. If receiving of any
2362 2362 * optional receive side information is enabled, we also send
2363 2363 * that up as options.
2364 2364 */
2365 2365 udi_size = sizeof (struct T_unitdata_ind) + sizeof (sin6_t);
2366 2366
2367 2367 if (recv_ancillary.crb_all != 0) {
2368 2368 udi_size += conn_recvancillary_size(connp,
2369 2369 recv_ancillary, ira, mp, &ipps);
2370 2370 }
2371 2371
2372 2372 mp1 = allocb(udi_size, BPRI_MED);
2373 2373 if (mp1 == NULL) {
2374 2374 freemsg(mp);
2375 2375 UDPS_BUMP_MIB(us, udpInErrors);
2376 2376 return;
2377 2377 }
2378 2378 mp1->b_cont = mp;
2379 2379 mp1->b_datap->db_type = M_PROTO;
2380 2380 tudi = (struct T_unitdata_ind *)mp1->b_rptr;
2381 2381 mp1->b_wptr = (uchar_t *)tudi + udi_size;
2382 2382 tudi->PRIM_type = T_UNITDATA_IND;
2383 2383 tudi->SRC_length = sizeof (sin6_t);
2384 2384 tudi->SRC_offset = sizeof (struct T_unitdata_ind);
2385 2385 tudi->OPT_offset = sizeof (struct T_unitdata_ind) +
2386 2386 sizeof (sin6_t);
2387 2387 udi_size -= (sizeof (struct T_unitdata_ind) + sizeof (sin6_t));
2388 2388 tudi->OPT_length = udi_size;
2389 2389 sin6 = (sin6_t *)&tudi[1];
2390 2390 if (ira->ira_flags & IRAF_IS_IPV4) {
2391 2391 in6_addr_t v6dst;
2392 2392
2393 2393 IN6_IPADDR_TO_V4MAPPED(((ipha_t *)rptr)->ipha_src,
2394 2394 &sin6->sin6_addr);
2395 2395 IN6_IPADDR_TO_V4MAPPED(((ipha_t *)rptr)->ipha_dst,
2396 2396 &v6dst);
2397 2397 sin6->sin6_flowinfo = 0;
2398 2398 sin6->sin6_scope_id = 0;
2399 2399 sin6->__sin6_src_id = ip_srcid_find_addr(&v6dst,
2400 2400 IPCL_ZONEID(connp), us->us_netstack);
2401 2401 } else {
2402 2402 ip6h = (ip6_t *)rptr;
2403 2403
2404 2404 sin6->sin6_addr = ip6h->ip6_src;
2405 2405 /* No sin6_flowinfo per API */
2406 2406 sin6->sin6_flowinfo = 0;
2407 2407 /* For link-scope pass up scope id */
2408 2408 if (IN6_IS_ADDR_LINKSCOPE(&ip6h->ip6_src))
2409 2409 sin6->sin6_scope_id = ira->ira_ruifindex;
2410 2410 else
2411 2411 sin6->sin6_scope_id = 0;
2412 2412 sin6->__sin6_src_id = ip_srcid_find_addr(
2413 2413 &ip6h->ip6_dst, IPCL_ZONEID(connp),
2414 2414 us->us_netstack);
2415 2415 }
2416 2416 sin6->sin6_port = udpha->uha_src_port;
2417 2417 sin6->sin6_family = connp->conn_family;
2418 2418
2419 2419 if (udi_size != 0) {
2420 2420 conn_recvancillary_add(connp, recv_ancillary, ira,
2421 2421 &ipps, (uchar_t *)&sin6[1], udi_size);
2422 2422 }
2423 2423 }
2424 2424
2425 2425 /*
2426 2426 * DTrace this UDP input as udp:::receive (this is for IPv4, IPv6 and
2427 2427 * loopback traffic).
2428 2428 */
2429 2429 DTRACE_UDP5(receive, mblk_t *, NULL, ip_xmit_attr_t *, connp->conn_ixa,
2430 2430 void_ip_t *, rptr, udp_t *, udp, udpha_t *, udpha);
2431 2431
2432 2432 /* Walk past the headers unless IP_RECVHDR was set. */
2433 2433 if (!udp->udp_rcvhdr) {
2434 2434 mp->b_rptr = rptr + hdr_length;
2435 2435 pkt_len -= hdr_length;
2436 2436 }
2437 2437
2438 2438 UDPS_BUMP_MIB(us, udpHCInDatagrams);
2439 2439 udp_ulp_recv(connp, mp1, pkt_len, ira);
2440 2440 return;
2441 2441
2442 2442 tossit:
2443 2443 freemsg(mp);
2444 2444 UDPS_BUMP_MIB(us, udpInErrors);
2445 2445 }
2446 2446
2447 2447 /*
2448 2448 * This routine creates a T_UDERROR_IND message and passes it upstream.
2449 2449 * The address and options are copied from the T_UNITDATA_REQ message
2450 2450 * passed in mp. This message is freed.
2451 2451 */
2452 2452 static void
2453 2453 udp_ud_err(queue_t *q, mblk_t *mp, t_scalar_t err)
2454 2454 {
2455 2455 struct T_unitdata_req *tudr;
2456 2456 mblk_t *mp1;
2457 2457 uchar_t *destaddr;
2458 2458 t_scalar_t destlen;
2459 2459 uchar_t *optaddr;
2460 2460 t_scalar_t optlen;
2461 2461
2462 2462 if ((mp->b_wptr < mp->b_rptr) ||
2463 2463 (MBLKL(mp)) < sizeof (struct T_unitdata_req)) {
2464 2464 goto done;
2465 2465 }
2466 2466 tudr = (struct T_unitdata_req *)mp->b_rptr;
2467 2467 destaddr = mp->b_rptr + tudr->DEST_offset;
2468 2468 if (destaddr < mp->b_rptr || destaddr >= mp->b_wptr ||
2469 2469 destaddr + tudr->DEST_length < mp->b_rptr ||
2470 2470 destaddr + tudr->DEST_length > mp->b_wptr) {
2471 2471 goto done;
2472 2472 }
2473 2473 optaddr = mp->b_rptr + tudr->OPT_offset;
2474 2474 if (optaddr < mp->b_rptr || optaddr >= mp->b_wptr ||
2475 2475 optaddr + tudr->OPT_length < mp->b_rptr ||
2476 2476 optaddr + tudr->OPT_length > mp->b_wptr) {
2477 2477 goto done;
2478 2478 }
2479 2479 destlen = tudr->DEST_length;
2480 2480 optlen = tudr->OPT_length;
2481 2481
2482 2482 mp1 = mi_tpi_uderror_ind((char *)destaddr, destlen,
2483 2483 (char *)optaddr, optlen, err);
2484 2484 if (mp1 != NULL)
2485 2485 qreply(q, mp1);
2486 2486
2487 2487 done:
2488 2488 freemsg(mp);
2489 2489 }
2490 2490
2491 2491 /*
2492 2492 * This routine removes a port number association from a stream. It
2493 2493 * is called by udp_wput to handle T_UNBIND_REQ messages.
2494 2494 */
2495 2495 static void
2496 2496 udp_tpi_unbind(queue_t *q, mblk_t *mp)
2497 2497 {
2498 2498 conn_t *connp = Q_TO_CONN(q);
2499 2499 int error;
2500 2500
2501 2501 error = udp_do_unbind(connp);
2502 2502 if (error) {
2503 2503 if (error < 0)
2504 2504 udp_err_ack(q, mp, -error, 0);
2505 2505 else
2506 2506 udp_err_ack(q, mp, TSYSERR, error);
2507 2507 return;
2508 2508 }
2509 2509
2510 2510 mp = mi_tpi_ok_ack_alloc(mp);
2511 2511 ASSERT(mp != NULL);
2512 2512 ASSERT(((struct T_ok_ack *)mp->b_rptr)->PRIM_type == T_OK_ACK);
2513 2513 qreply(q, mp);
2514 2514 }
2515 2515
2516 2516 /*
2517 2517 * Don't let port fall into the privileged range.
2518 2518 * Since the extra privileged ports can be arbitrary we also
2519 2519 * ensure that we exclude those from consideration.
2520 2520 * us->us_epriv_ports is not sorted thus we loop over it until
2521 2521 * there are no changes.
2522 2522 */
2523 2523 static in_port_t
2524 2524 udp_update_next_port(udp_t *udp, in_port_t port, boolean_t random)
2525 2525 {
2526 2526 int i, bump;
2527 2527 in_port_t nextport;
2528 2528 boolean_t restart = B_FALSE;
2529 2529 udp_stack_t *us = udp->udp_us;
2530 2530
2531 2531 if (random && udp_random_anon_port != 0) {
2532 2532 (void) random_get_pseudo_bytes((uint8_t *)&port,
2533 2533 sizeof (in_port_t));
2534 2534 /*
2535 2535 * Unless changed by a sys admin, the smallest anon port
2536 2536 * is 32768 and the largest anon port is 65535. It is
2537 2537 * very likely (50%) for the random port to be smaller
2538 2538 * than the smallest anon port. When that happens,
2539 2539 * add port % (anon port range) to the smallest anon
2540 2540 * port to get the random port. It should fall into the
2541 2541 * valid anon port range.
2542 2542 */
2543 2543 if ((port < us->us_smallest_anon_port) ||
2544 2544 (port > us->us_largest_anon_port)) {
2545 2545 if (us->us_smallest_anon_port ==
2546 2546 us->us_largest_anon_port) {
2547 2547 bump = 0;
2548 2548 } else {
2549 2549 bump = port % (us->us_largest_anon_port -
2550 2550 us->us_smallest_anon_port);
2551 2551 }
2552 2552
2553 2553 port = us->us_smallest_anon_port + bump;
2554 2554 }
2555 2555 }
2556 2556
2557 2557 retry:
2558 2558 if (port < us->us_smallest_anon_port)
2559 2559 port = us->us_smallest_anon_port;
2560 2560
2561 2561 if (port > us->us_largest_anon_port) {
2562 2562 port = us->us_smallest_anon_port;
2563 2563 if (restart)
2564 2564 return (0);
2565 2565 restart = B_TRUE;
2566 2566 }
2567 2567
2568 2568 if (port < us->us_smallest_nonpriv_port)
2569 2569 port = us->us_smallest_nonpriv_port;
2570 2570
2571 2571 for (i = 0; i < us->us_num_epriv_ports; i++) {
2572 2572 if (port == us->us_epriv_ports[i]) {
2573 2573 port++;
2574 2574 /*
2575 2575 * Make sure that the port is in the
2576 2576 * valid range.
2577 2577 */
2578 2578 goto retry;
2579 2579 }
2580 2580 }
2581 2581
2582 2582 if (is_system_labeled() &&
2583 2583 (nextport = tsol_next_port(crgetzone(udp->udp_connp->conn_cred),
2584 2584 port, IPPROTO_UDP, B_TRUE)) != 0) {
2585 2585 port = nextport;
2586 2586 goto retry;
2587 2587 }
2588 2588
2589 2589 return (port);
2590 2590 }
2591 2591
2592 2592 /*
2593 2593 * Handle T_UNITDATA_REQ with options. Both IPv4 and IPv6
2594 2594 * Either tudr_mp or msg is set. If tudr_mp we take ancillary data from
2595 2595 * the TPI options, otherwise we take them from msg_control.
2596 2596 * If both sin and sin6 is set it is a connected socket and we use conn_faddr.
2597 2597 * Always consumes mp; never consumes tudr_mp.
2598 2598 */
2599 2599 static int
2600 2600 udp_output_ancillary(conn_t *connp, sin_t *sin, sin6_t *sin6, mblk_t *mp,
2601 2601 mblk_t *tudr_mp, struct nmsghdr *msg, cred_t *cr, pid_t pid)
2602 2602 {
2603 2603 udp_t *udp = connp->conn_udp;
2604 2604 udp_stack_t *us = udp->udp_us;
2605 2605 int error;
2606 2606 ip_xmit_attr_t *ixa;
2607 2607 ip_pkt_t *ipp;
2608 2608 in6_addr_t v6src;
2609 2609 in6_addr_t v6dst;
2610 2610 in6_addr_t v6nexthop;
2611 2611 in_port_t dstport;
2612 2612 uint32_t flowinfo;
2613 2613 uint_t srcid;
2614 2614 int is_absreq_failure = 0;
2615 2615 conn_opt_arg_t coas, *coa;
2616 2616
2617 2617 ASSERT(tudr_mp != NULL || msg != NULL);
2618 2618
2619 2619 /*
2620 2620 * Get ixa before checking state to handle a disconnect race.
2621 2621 *
2622 2622 * We need an exclusive copy of conn_ixa since the ancillary data
2623 2623 * options might modify it. That copy has no pointers hence we
2624 2624 * need to set them up once we've parsed the ancillary data.
2625 2625 */
2626 2626 ixa = conn_get_ixa_exclusive(connp);
2627 2627 if (ixa == NULL) {
2628 2628 UDPS_BUMP_MIB(us, udpOutErrors);
2629 2629 freemsg(mp);
2630 2630 return (ENOMEM);
2631 2631 }
2632 2632 ASSERT(cr != NULL);
2633 2633 ASSERT(!(ixa->ixa_free_flags & IXA_FREE_CRED));
2634 2634 ixa->ixa_cred = cr;
2635 2635 ixa->ixa_cpid = pid;
2636 2636 if (is_system_labeled()) {
2637 2637 /* We need to restart with a label based on the cred */
2638 2638 ip_xmit_attr_restore_tsl(ixa, ixa->ixa_cred);
2639 2639 }
2640 2640
2641 2641 /* In case previous destination was multicast or multirt */
2642 2642 ip_attr_newdst(ixa);
2643 2643
2644 2644 /* Get a copy of conn_xmit_ipp since the options might change it */
2645 2645 ipp = kmem_zalloc(sizeof (*ipp), KM_NOSLEEP);
2646 2646 if (ipp == NULL) {
2647 2647 ASSERT(!(ixa->ixa_free_flags & IXA_FREE_CRED));
2648 2648 ixa->ixa_cred = connp->conn_cred; /* Restore */
2649 2649 ixa->ixa_cpid = connp->conn_cpid;
2650 2650 ixa_refrele(ixa);
2651 2651 UDPS_BUMP_MIB(us, udpOutErrors);
2652 2652 freemsg(mp);
2653 2653 return (ENOMEM);
2654 2654 }
2655 2655 mutex_enter(&connp->conn_lock);
2656 2656 error = ip_pkt_copy(&connp->conn_xmit_ipp, ipp, KM_NOSLEEP);
2657 2657 mutex_exit(&connp->conn_lock);
2658 2658 if (error != 0) {
2659 2659 UDPS_BUMP_MIB(us, udpOutErrors);
2660 2660 freemsg(mp);
2661 2661 goto done;
2662 2662 }
2663 2663
2664 2664 /*
2665 2665 * Parse the options and update ixa and ipp as a result.
2666 2666 * Note that ixa_tsl can be updated if SCM_UCRED.
2667 2667 * ixa_refrele/ixa_inactivate will release any reference on ixa_tsl.
2668 2668 */
2669 2669
2670 2670 coa = &coas;
2671 2671 coa->coa_connp = connp;
2672 2672 coa->coa_ixa = ixa;
2673 2673 coa->coa_ipp = ipp;
2674 2674 coa->coa_ancillary = B_TRUE;
2675 2675 coa->coa_changed = 0;
2676 2676
2677 2677 if (msg != NULL) {
2678 2678 error = process_auxiliary_options(connp, msg->msg_control,
2679 2679 msg->msg_controllen, coa, &udp_opt_obj, udp_opt_set, cr);
2680 2680 } else {
2681 2681 struct T_unitdata_req *tudr;
2682 2682
2683 2683 tudr = (struct T_unitdata_req *)tudr_mp->b_rptr;
2684 2684 ASSERT(tudr->PRIM_type == T_UNITDATA_REQ);
2685 2685 error = tpi_optcom_buf(connp->conn_wq, tudr_mp,
2686 2686 &tudr->OPT_length, tudr->OPT_offset, cr, &udp_opt_obj,
2687 2687 coa, &is_absreq_failure);
2688 2688 }
2689 2689 if (error != 0) {
2690 2690 /*
2691 2691 * Note: No special action needed in this
2692 2692 * module for "is_absreq_failure"
2693 2693 */
2694 2694 freemsg(mp);
2695 2695 UDPS_BUMP_MIB(us, udpOutErrors);
2696 2696 goto done;
2697 2697 }
2698 2698 ASSERT(is_absreq_failure == 0);
2699 2699
2700 2700 mutex_enter(&connp->conn_lock);
2701 2701 /*
2702 2702 * If laddr is unspecified then we look at sin6_src_id.
2703 2703 * We will give precedence to a source address set with IPV6_PKTINFO
2704 2704 * (aka IPPF_ADDR) but that is handled in build_hdrs. However, we don't
2705 2705 * want ip_attr_connect to select a source (since it can fail) when
2706 2706 * IPV6_PKTINFO is specified.
2707 2707 * If this doesn't result in a source address then we get a source
2708 2708 * from ip_attr_connect() below.
2709 2709 */
2710 2710 v6src = connp->conn_saddr_v6;
2711 2711 if (sin != NULL) {
2712 2712 IN6_IPADDR_TO_V4MAPPED(sin->sin_addr.s_addr, &v6dst);
2713 2713 dstport = sin->sin_port;
2714 2714 flowinfo = 0;
2715 2715 ixa->ixa_flags &= ~IXAF_SCOPEID_SET;
2716 2716 ixa->ixa_flags |= IXAF_IS_IPV4;
2717 2717 } else if (sin6 != NULL) {
2718 2718 boolean_t v4mapped;
2719 2719
2720 2720 v6dst = sin6->sin6_addr;
2721 2721 dstport = sin6->sin6_port;
2722 2722 flowinfo = sin6->sin6_flowinfo;
2723 2723 srcid = sin6->__sin6_src_id;
2724 2724 if (IN6_IS_ADDR_LINKSCOPE(&v6dst) && sin6->sin6_scope_id != 0) {
2725 2725 ixa->ixa_scopeid = sin6->sin6_scope_id;
|
↓ open down ↓ |
2725 lines elided |
↑ open up ↑ |
2726 2726 ixa->ixa_flags |= IXAF_SCOPEID_SET;
2727 2727 } else {
2728 2728 ixa->ixa_flags &= ~IXAF_SCOPEID_SET;
2729 2729 }
2730 2730 v4mapped = IN6_IS_ADDR_V4MAPPED(&v6dst);
2731 2731 if (v4mapped)
2732 2732 ixa->ixa_flags |= IXAF_IS_IPV4;
2733 2733 else
2734 2734 ixa->ixa_flags &= ~IXAF_IS_IPV4;
2735 2735 if (srcid != 0 && IN6_IS_ADDR_UNSPECIFIED(&v6src)) {
2736 - if (ip_srcid_find_id(srcid, &v6src, IPCL_ZONEID(connp),
2736 + if (!ip_srcid_find_id(srcid, &v6src, IPCL_ZONEID(connp),
2737 2737 v4mapped, connp->conn_netstack)) {
2738 2738 /* Mismatch - v4mapped/v6 specified by srcid. */
2739 2739 mutex_exit(&connp->conn_lock);
2740 2740 error = EADDRNOTAVAIL;
2741 2741 goto failed; /* Does freemsg() and mib. */
2742 2742 }
2743 2743 }
2744 2744 } else {
2745 2745 /* Connected case */
2746 2746 v6dst = connp->conn_faddr_v6;
2747 2747 dstport = connp->conn_fport;
2748 2748 flowinfo = connp->conn_flowinfo;
2749 2749 }
2750 2750 mutex_exit(&connp->conn_lock);
2751 2751
2752 2752 /* Handle IP_PKTINFO/IPV6_PKTINFO setting source address. */
2753 2753 if (ipp->ipp_fields & IPPF_ADDR) {
2754 2754 if (ixa->ixa_flags & IXAF_IS_IPV4) {
2755 2755 if (IN6_IS_ADDR_V4MAPPED(&ipp->ipp_addr))
2756 2756 v6src = ipp->ipp_addr;
2757 2757 } else {
2758 2758 if (!IN6_IS_ADDR_V4MAPPED(&ipp->ipp_addr))
2759 2759 v6src = ipp->ipp_addr;
2760 2760 }
2761 2761 }
2762 2762
2763 2763 ip_attr_nexthop(ipp, ixa, &v6dst, &v6nexthop);
2764 2764 error = ip_attr_connect(connp, ixa, &v6src, &v6dst, &v6nexthop, dstport,
2765 2765 &v6src, NULL, IPDF_ALLOW_MCBC | IPDF_VERIFY_DST | IPDF_IPSEC);
2766 2766
2767 2767 switch (error) {
2768 2768 case 0:
2769 2769 break;
2770 2770 case EADDRNOTAVAIL:
2771 2771 /*
2772 2772 * IXAF_VERIFY_SOURCE tells us to pick a better source.
2773 2773 * Don't have the application see that errno
2774 2774 */
2775 2775 error = ENETUNREACH;
2776 2776 goto failed;
2777 2777 case ENETDOWN:
2778 2778 /*
2779 2779 * Have !ipif_addr_ready address; drop packet silently
2780 2780 * until we can get applications to not send until we
2781 2781 * are ready.
2782 2782 */
2783 2783 error = 0;
2784 2784 goto failed;
2785 2785 case EHOSTUNREACH:
2786 2786 case ENETUNREACH:
2787 2787 if (ixa->ixa_ire != NULL) {
2788 2788 /*
2789 2789 * Let conn_ip_output/ire_send_noroute return
2790 2790 * the error and send any local ICMP error.
2791 2791 */
2792 2792 error = 0;
2793 2793 break;
2794 2794 }
2795 2795 /* FALLTHRU */
2796 2796 default:
2797 2797 failed:
2798 2798 freemsg(mp);
2799 2799 UDPS_BUMP_MIB(us, udpOutErrors);
2800 2800 goto done;
2801 2801 }
2802 2802
2803 2803 /*
2804 2804 * We might be going to a different destination than last time,
2805 2805 * thus check that TX allows the communication and compute any
2806 2806 * needed label.
2807 2807 *
2808 2808 * TSOL Note: We have an exclusive ipp and ixa for this thread so we
2809 2809 * don't have to worry about concurrent threads.
2810 2810 */
2811 2811 if (is_system_labeled()) {
2812 2812 /* Using UDP MLP requires SCM_UCRED from user */
2813 2813 if (connp->conn_mlp_type != mlptSingle &&
2814 2814 !((ixa->ixa_flags & IXAF_UCRED_TSL))) {
2815 2815 UDPS_BUMP_MIB(us, udpOutErrors);
2816 2816 error = ECONNREFUSED;
2817 2817 freemsg(mp);
2818 2818 goto done;
2819 2819 }
2820 2820 /*
2821 2821 * Check whether Trusted Solaris policy allows communication
2822 2822 * with this host, and pretend that the destination is
2823 2823 * unreachable if not.
2824 2824 * Compute any needed label and place it in ipp_label_v4/v6.
2825 2825 *
2826 2826 * Later conn_build_hdr_template/conn_prepend_hdr takes
2827 2827 * ipp_label_v4/v6 to form the packet.
2828 2828 *
2829 2829 * Tsol note: We have ipp structure local to this thread so
2830 2830 * no locking is needed.
2831 2831 */
2832 2832 error = conn_update_label(connp, ixa, &v6dst, ipp);
2833 2833 if (error != 0) {
2834 2834 freemsg(mp);
2835 2835 UDPS_BUMP_MIB(us, udpOutErrors);
2836 2836 goto done;
2837 2837 }
2838 2838 }
2839 2839 mp = udp_prepend_hdr(connp, ixa, ipp, &v6src, &v6dst, dstport,
2840 2840 flowinfo, mp, &error);
2841 2841 if (mp == NULL) {
2842 2842 ASSERT(error != 0);
2843 2843 UDPS_BUMP_MIB(us, udpOutErrors);
2844 2844 goto done;
2845 2845 }
2846 2846 if (ixa->ixa_pktlen > IP_MAXPACKET) {
2847 2847 error = EMSGSIZE;
2848 2848 UDPS_BUMP_MIB(us, udpOutErrors);
2849 2849 freemsg(mp);
2850 2850 goto done;
2851 2851 }
2852 2852 /* We're done. Pass the packet to ip. */
2853 2853 UDPS_BUMP_MIB(us, udpHCOutDatagrams);
2854 2854
2855 2855 DTRACE_UDP5(send, mblk_t *, NULL, ip_xmit_attr_t *, ixa,
2856 2856 void_ip_t *, mp->b_rptr, udp_t *, udp, udpha_t *,
2857 2857 &mp->b_rptr[ixa->ixa_ip_hdr_length]);
2858 2858
2859 2859 error = conn_ip_output(mp, ixa);
2860 2860 /* No udpOutErrors if an error since IP increases its error counter */
2861 2861 switch (error) {
2862 2862 case 0:
2863 2863 break;
2864 2864 case EWOULDBLOCK:
2865 2865 (void) ixa_check_drain_insert(connp, ixa);
2866 2866 error = 0;
2867 2867 break;
2868 2868 case EADDRNOTAVAIL:
2869 2869 /*
2870 2870 * IXAF_VERIFY_SOURCE tells us to pick a better source.
2871 2871 * Don't have the application see that errno
2872 2872 */
2873 2873 error = ENETUNREACH;
2874 2874 /* FALLTHRU */
2875 2875 default:
2876 2876 mutex_enter(&connp->conn_lock);
2877 2877 /*
2878 2878 * Clear the source and v6lastdst so we call ip_attr_connect
2879 2879 * for the next packet and try to pick a better source.
2880 2880 */
2881 2881 if (connp->conn_mcbc_bind)
2882 2882 connp->conn_saddr_v6 = ipv6_all_zeros;
2883 2883 else
2884 2884 connp->conn_saddr_v6 = connp->conn_bound_addr_v6;
2885 2885 connp->conn_v6lastdst = ipv6_all_zeros;
2886 2886 mutex_exit(&connp->conn_lock);
2887 2887 break;
2888 2888 }
2889 2889 done:
2890 2890 ASSERT(!(ixa->ixa_free_flags & IXA_FREE_CRED));
2891 2891 ixa->ixa_cred = connp->conn_cred; /* Restore */
2892 2892 ixa->ixa_cpid = connp->conn_cpid;
2893 2893 ixa_refrele(ixa);
2894 2894 ip_pkt_free(ipp);
2895 2895 kmem_free(ipp, sizeof (*ipp));
2896 2896 return (error);
2897 2897 }
2898 2898
2899 2899 /*
2900 2900 * Handle sending an M_DATA for a connected socket.
2901 2901 * Handles both IPv4 and IPv6.
2902 2902 */
2903 2903 static int
2904 2904 udp_output_connected(conn_t *connp, mblk_t *mp, cred_t *cr, pid_t pid)
2905 2905 {
2906 2906 udp_t *udp = connp->conn_udp;
2907 2907 udp_stack_t *us = udp->udp_us;
2908 2908 int error;
2909 2909 ip_xmit_attr_t *ixa;
2910 2910
2911 2911 /*
2912 2912 * If no other thread is using conn_ixa this just gets a reference to
2913 2913 * conn_ixa. Otherwise we get a safe copy of conn_ixa.
2914 2914 */
2915 2915 ixa = conn_get_ixa(connp, B_FALSE);
2916 2916 if (ixa == NULL) {
2917 2917 UDPS_BUMP_MIB(us, udpOutErrors);
2918 2918 freemsg(mp);
2919 2919 return (ENOMEM);
2920 2920 }
2921 2921
2922 2922 ASSERT(cr != NULL);
2923 2923 ASSERT(!(ixa->ixa_free_flags & IXA_FREE_CRED));
2924 2924 ixa->ixa_cred = cr;
2925 2925 ixa->ixa_cpid = pid;
2926 2926
2927 2927 mutex_enter(&connp->conn_lock);
2928 2928 mp = udp_prepend_header_template(connp, ixa, mp, &connp->conn_saddr_v6,
2929 2929 connp->conn_fport, connp->conn_flowinfo, &error);
2930 2930
2931 2931 if (mp == NULL) {
2932 2932 ASSERT(error != 0);
2933 2933 mutex_exit(&connp->conn_lock);
2934 2934 ASSERT(!(ixa->ixa_free_flags & IXA_FREE_CRED));
2935 2935 ixa->ixa_cred = connp->conn_cred; /* Restore */
2936 2936 ixa->ixa_cpid = connp->conn_cpid;
2937 2937 ixa_refrele(ixa);
2938 2938 UDPS_BUMP_MIB(us, udpOutErrors);
2939 2939 freemsg(mp);
2940 2940 return (error);
2941 2941 }
2942 2942
2943 2943 /*
2944 2944 * In case we got a safe copy of conn_ixa, or if opt_set made us a new
2945 2945 * safe copy, then we need to fill in any pointers in it.
2946 2946 */
2947 2947 if (ixa->ixa_ire == NULL) {
2948 2948 in6_addr_t faddr, saddr;
2949 2949 in6_addr_t nexthop;
2950 2950 in_port_t fport;
2951 2951
2952 2952 saddr = connp->conn_saddr_v6;
2953 2953 faddr = connp->conn_faddr_v6;
2954 2954 fport = connp->conn_fport;
2955 2955 ip_attr_nexthop(&connp->conn_xmit_ipp, ixa, &faddr, &nexthop);
2956 2956 mutex_exit(&connp->conn_lock);
2957 2957
2958 2958 error = ip_attr_connect(connp, ixa, &saddr, &faddr, &nexthop,
2959 2959 fport, NULL, NULL, IPDF_ALLOW_MCBC | IPDF_VERIFY_DST |
2960 2960 IPDF_IPSEC);
2961 2961 switch (error) {
2962 2962 case 0:
2963 2963 break;
2964 2964 case EADDRNOTAVAIL:
2965 2965 /*
2966 2966 * IXAF_VERIFY_SOURCE tells us to pick a better source.
2967 2967 * Don't have the application see that errno
2968 2968 */
2969 2969 error = ENETUNREACH;
2970 2970 goto failed;
2971 2971 case ENETDOWN:
2972 2972 /*
2973 2973 * Have !ipif_addr_ready address; drop packet silently
2974 2974 * until we can get applications to not send until we
2975 2975 * are ready.
2976 2976 */
2977 2977 error = 0;
2978 2978 goto failed;
2979 2979 case EHOSTUNREACH:
2980 2980 case ENETUNREACH:
2981 2981 if (ixa->ixa_ire != NULL) {
2982 2982 /*
2983 2983 * Let conn_ip_output/ire_send_noroute return
2984 2984 * the error and send any local ICMP error.
2985 2985 */
2986 2986 error = 0;
2987 2987 break;
2988 2988 }
2989 2989 /* FALLTHRU */
2990 2990 default:
2991 2991 failed:
2992 2992 ASSERT(!(ixa->ixa_free_flags & IXA_FREE_CRED));
2993 2993 ixa->ixa_cred = connp->conn_cred; /* Restore */
2994 2994 ixa->ixa_cpid = connp->conn_cpid;
2995 2995 ixa_refrele(ixa);
2996 2996 freemsg(mp);
2997 2997 UDPS_BUMP_MIB(us, udpOutErrors);
2998 2998 return (error);
2999 2999 }
3000 3000 } else {
3001 3001 /* Done with conn_t */
3002 3002 mutex_exit(&connp->conn_lock);
3003 3003 }
3004 3004 ASSERT(ixa->ixa_ire != NULL);
3005 3005
3006 3006 /* We're done. Pass the packet to ip. */
3007 3007 UDPS_BUMP_MIB(us, udpHCOutDatagrams);
3008 3008
3009 3009 DTRACE_UDP5(send, mblk_t *, NULL, ip_xmit_attr_t *, ixa,
3010 3010 void_ip_t *, mp->b_rptr, udp_t *, udp, udpha_t *,
3011 3011 &mp->b_rptr[ixa->ixa_ip_hdr_length]);
3012 3012
3013 3013 error = conn_ip_output(mp, ixa);
3014 3014 /* No udpOutErrors if an error since IP increases its error counter */
3015 3015 switch (error) {
3016 3016 case 0:
3017 3017 break;
3018 3018 case EWOULDBLOCK:
3019 3019 (void) ixa_check_drain_insert(connp, ixa);
3020 3020 error = 0;
3021 3021 break;
3022 3022 case EADDRNOTAVAIL:
3023 3023 /*
3024 3024 * IXAF_VERIFY_SOURCE tells us to pick a better source.
3025 3025 * Don't have the application see that errno
3026 3026 */
3027 3027 error = ENETUNREACH;
3028 3028 break;
3029 3029 }
3030 3030 ASSERT(!(ixa->ixa_free_flags & IXA_FREE_CRED));
3031 3031 ixa->ixa_cred = connp->conn_cred; /* Restore */
3032 3032 ixa->ixa_cpid = connp->conn_cpid;
3033 3033 ixa_refrele(ixa);
3034 3034 return (error);
3035 3035 }
3036 3036
3037 3037 /*
3038 3038 * Handle sending an M_DATA to the last destination.
3039 3039 * Handles both IPv4 and IPv6.
3040 3040 *
3041 3041 * NOTE: The caller must hold conn_lock and we drop it here.
3042 3042 */
3043 3043 static int
3044 3044 udp_output_lastdst(conn_t *connp, mblk_t *mp, cred_t *cr, pid_t pid,
3045 3045 ip_xmit_attr_t *ixa)
3046 3046 {
3047 3047 udp_t *udp = connp->conn_udp;
3048 3048 udp_stack_t *us = udp->udp_us;
3049 3049 int error;
3050 3050
3051 3051 ASSERT(MUTEX_HELD(&connp->conn_lock));
3052 3052 ASSERT(ixa != NULL);
3053 3053
3054 3054 ASSERT(cr != NULL);
3055 3055 ASSERT(!(ixa->ixa_free_flags & IXA_FREE_CRED));
3056 3056 ixa->ixa_cred = cr;
3057 3057 ixa->ixa_cpid = pid;
3058 3058
3059 3059 mp = udp_prepend_header_template(connp, ixa, mp, &connp->conn_v6lastsrc,
3060 3060 connp->conn_lastdstport, connp->conn_lastflowinfo, &error);
3061 3061
3062 3062 if (mp == NULL) {
3063 3063 ASSERT(error != 0);
3064 3064 mutex_exit(&connp->conn_lock);
3065 3065 ASSERT(!(ixa->ixa_free_flags & IXA_FREE_CRED));
3066 3066 ixa->ixa_cred = connp->conn_cred; /* Restore */
3067 3067 ixa->ixa_cpid = connp->conn_cpid;
3068 3068 ixa_refrele(ixa);
3069 3069 UDPS_BUMP_MIB(us, udpOutErrors);
3070 3070 freemsg(mp);
3071 3071 return (error);
3072 3072 }
3073 3073
3074 3074 /*
3075 3075 * In case we got a safe copy of conn_ixa, or if opt_set made us a new
3076 3076 * safe copy, then we need to fill in any pointers in it.
3077 3077 */
3078 3078 if (ixa->ixa_ire == NULL) {
3079 3079 in6_addr_t lastdst, lastsrc;
3080 3080 in6_addr_t nexthop;
3081 3081 in_port_t lastport;
3082 3082
3083 3083 lastsrc = connp->conn_v6lastsrc;
3084 3084 lastdst = connp->conn_v6lastdst;
3085 3085 lastport = connp->conn_lastdstport;
3086 3086 ip_attr_nexthop(&connp->conn_xmit_ipp, ixa, &lastdst, &nexthop);
3087 3087 mutex_exit(&connp->conn_lock);
3088 3088
3089 3089 error = ip_attr_connect(connp, ixa, &lastsrc, &lastdst,
3090 3090 &nexthop, lastport, NULL, NULL, IPDF_ALLOW_MCBC |
3091 3091 IPDF_VERIFY_DST | IPDF_IPSEC);
3092 3092 switch (error) {
3093 3093 case 0:
3094 3094 break;
3095 3095 case EADDRNOTAVAIL:
3096 3096 /*
3097 3097 * IXAF_VERIFY_SOURCE tells us to pick a better source.
3098 3098 * Don't have the application see that errno
3099 3099 */
3100 3100 error = ENETUNREACH;
3101 3101 goto failed;
3102 3102 case ENETDOWN:
3103 3103 /*
3104 3104 * Have !ipif_addr_ready address; drop packet silently
3105 3105 * until we can get applications to not send until we
3106 3106 * are ready.
3107 3107 */
3108 3108 error = 0;
3109 3109 goto failed;
3110 3110 case EHOSTUNREACH:
3111 3111 case ENETUNREACH:
3112 3112 if (ixa->ixa_ire != NULL) {
3113 3113 /*
3114 3114 * Let conn_ip_output/ire_send_noroute return
3115 3115 * the error and send any local ICMP error.
3116 3116 */
3117 3117 error = 0;
3118 3118 break;
3119 3119 }
3120 3120 /* FALLTHRU */
3121 3121 default:
3122 3122 failed:
3123 3123 ASSERT(!(ixa->ixa_free_flags & IXA_FREE_CRED));
3124 3124 ixa->ixa_cred = connp->conn_cred; /* Restore */
3125 3125 ixa->ixa_cpid = connp->conn_cpid;
3126 3126 ixa_refrele(ixa);
3127 3127 freemsg(mp);
3128 3128 UDPS_BUMP_MIB(us, udpOutErrors);
3129 3129 return (error);
3130 3130 }
3131 3131 } else {
3132 3132 /* Done with conn_t */
3133 3133 mutex_exit(&connp->conn_lock);
3134 3134 }
3135 3135
3136 3136 /* We're done. Pass the packet to ip. */
3137 3137 UDPS_BUMP_MIB(us, udpHCOutDatagrams);
3138 3138
3139 3139 DTRACE_UDP5(send, mblk_t *, NULL, ip_xmit_attr_t *, ixa,
3140 3140 void_ip_t *, mp->b_rptr, udp_t *, udp, udpha_t *,
3141 3141 &mp->b_rptr[ixa->ixa_ip_hdr_length]);
3142 3142
3143 3143 error = conn_ip_output(mp, ixa);
3144 3144 /* No udpOutErrors if an error since IP increases its error counter */
3145 3145 switch (error) {
3146 3146 case 0:
3147 3147 break;
3148 3148 case EWOULDBLOCK:
3149 3149 (void) ixa_check_drain_insert(connp, ixa);
3150 3150 error = 0;
3151 3151 break;
3152 3152 case EADDRNOTAVAIL:
3153 3153 /*
3154 3154 * IXAF_VERIFY_SOURCE tells us to pick a better source.
3155 3155 * Don't have the application see that errno
3156 3156 */
3157 3157 error = ENETUNREACH;
3158 3158 /* FALLTHRU */
3159 3159 default:
3160 3160 mutex_enter(&connp->conn_lock);
3161 3161 /*
3162 3162 * Clear the source and v6lastdst so we call ip_attr_connect
3163 3163 * for the next packet and try to pick a better source.
3164 3164 */
3165 3165 if (connp->conn_mcbc_bind)
3166 3166 connp->conn_saddr_v6 = ipv6_all_zeros;
3167 3167 else
3168 3168 connp->conn_saddr_v6 = connp->conn_bound_addr_v6;
3169 3169 connp->conn_v6lastdst = ipv6_all_zeros;
3170 3170 mutex_exit(&connp->conn_lock);
3171 3171 break;
3172 3172 }
3173 3173 ASSERT(!(ixa->ixa_free_flags & IXA_FREE_CRED));
3174 3174 ixa->ixa_cred = connp->conn_cred; /* Restore */
3175 3175 ixa->ixa_cpid = connp->conn_cpid;
3176 3176 ixa_refrele(ixa);
3177 3177 return (error);
3178 3178 }
3179 3179
3180 3180
3181 3181 /*
3182 3182 * Prepend the header template and then fill in the source and
3183 3183 * flowinfo. The caller needs to handle the destination address since
3184 3184 * it's setting is different if rthdr or source route.
3185 3185 *
3186 3186 * Returns NULL is allocation failed or if the packet would exceed IP_MAXPACKET.
3187 3187 * When it returns NULL it sets errorp.
3188 3188 */
3189 3189 static mblk_t *
3190 3190 udp_prepend_header_template(conn_t *connp, ip_xmit_attr_t *ixa, mblk_t *mp,
3191 3191 const in6_addr_t *v6src, in_port_t dstport, uint32_t flowinfo, int *errorp)
3192 3192 {
3193 3193 udp_t *udp = connp->conn_udp;
3194 3194 udp_stack_t *us = udp->udp_us;
3195 3195 boolean_t insert_spi = udp->udp_nat_t_endpoint;
3196 3196 uint_t pktlen;
3197 3197 uint_t alloclen;
3198 3198 uint_t copylen;
3199 3199 uint8_t *iph;
3200 3200 uint_t ip_hdr_length;
3201 3201 udpha_t *udpha;
3202 3202 uint32_t cksum;
3203 3203 ip_pkt_t *ipp;
3204 3204
3205 3205 ASSERT(MUTEX_HELD(&connp->conn_lock));
3206 3206
3207 3207 /*
3208 3208 * Copy the header template and leave space for an SPI
3209 3209 */
3210 3210 copylen = connp->conn_ht_iphc_len;
3211 3211 alloclen = copylen + (insert_spi ? sizeof (uint32_t) : 0);
3212 3212 pktlen = alloclen + msgdsize(mp);
3213 3213 if (pktlen > IP_MAXPACKET) {
3214 3214 freemsg(mp);
3215 3215 *errorp = EMSGSIZE;
3216 3216 return (NULL);
3217 3217 }
3218 3218 ixa->ixa_pktlen = pktlen;
3219 3219
3220 3220 /* check/fix buffer config, setup pointers into it */
3221 3221 iph = mp->b_rptr - alloclen;
3222 3222 if (DB_REF(mp) != 1 || iph < DB_BASE(mp) || !OK_32PTR(iph)) {
3223 3223 mblk_t *mp1;
3224 3224
3225 3225 mp1 = allocb(alloclen + us->us_wroff_extra, BPRI_MED);
3226 3226 if (mp1 == NULL) {
3227 3227 freemsg(mp);
3228 3228 *errorp = ENOMEM;
3229 3229 return (NULL);
3230 3230 }
3231 3231 mp1->b_wptr = DB_LIM(mp1);
3232 3232 mp1->b_cont = mp;
3233 3233 mp = mp1;
3234 3234 iph = (mp->b_wptr - alloclen);
3235 3235 }
3236 3236 mp->b_rptr = iph;
3237 3237 bcopy(connp->conn_ht_iphc, iph, copylen);
3238 3238 ip_hdr_length = (uint_t)(connp->conn_ht_ulp - connp->conn_ht_iphc);
3239 3239
3240 3240 ixa->ixa_ip_hdr_length = ip_hdr_length;
3241 3241 udpha = (udpha_t *)(iph + ip_hdr_length);
3242 3242
3243 3243 /*
3244 3244 * Setup header length and prepare for ULP checksum done in IP.
3245 3245 * udp_build_hdr_template has already massaged any routing header
3246 3246 * and placed the result in conn_sum.
3247 3247 *
3248 3248 * We make it easy for IP to include our pseudo header
3249 3249 * by putting our length in uha_checksum.
3250 3250 */
3251 3251 cksum = pktlen - ip_hdr_length;
3252 3252 udpha->uha_length = htons(cksum);
3253 3253
3254 3254 cksum += connp->conn_sum;
3255 3255 cksum = (cksum >> 16) + (cksum & 0xFFFF);
3256 3256 ASSERT(cksum < 0x10000);
3257 3257
3258 3258 ipp = &connp->conn_xmit_ipp;
3259 3259 if (ixa->ixa_flags & IXAF_IS_IPV4) {
3260 3260 ipha_t *ipha = (ipha_t *)iph;
3261 3261
3262 3262 ipha->ipha_length = htons((uint16_t)pktlen);
3263 3263
3264 3264 /* IP does the checksum if uha_checksum is non-zero */
3265 3265 if (us->us_do_checksum)
3266 3266 udpha->uha_checksum = htons(cksum);
3267 3267
3268 3268 /* if IP_PKTINFO specified an addres it wins over bind() */
3269 3269 if ((ipp->ipp_fields & IPPF_ADDR) &&
3270 3270 IN6_IS_ADDR_V4MAPPED(&ipp->ipp_addr)) {
3271 3271 ASSERT(ipp->ipp_addr_v4 != INADDR_ANY);
3272 3272 ipha->ipha_src = ipp->ipp_addr_v4;
3273 3273 } else {
3274 3274 IN6_V4MAPPED_TO_IPADDR(v6src, ipha->ipha_src);
3275 3275 }
3276 3276 } else {
3277 3277 ip6_t *ip6h = (ip6_t *)iph;
3278 3278
3279 3279 ip6h->ip6_plen = htons((uint16_t)(pktlen - IPV6_HDR_LEN));
3280 3280 udpha->uha_checksum = htons(cksum);
3281 3281
3282 3282 /* if IP_PKTINFO specified an addres it wins over bind() */
3283 3283 if ((ipp->ipp_fields & IPPF_ADDR) &&
3284 3284 !IN6_IS_ADDR_V4MAPPED(&ipp->ipp_addr)) {
3285 3285 ASSERT(!IN6_IS_ADDR_UNSPECIFIED(&ipp->ipp_addr));
3286 3286 ip6h->ip6_src = ipp->ipp_addr;
3287 3287 } else {
3288 3288 ip6h->ip6_src = *v6src;
3289 3289 }
3290 3290 ip6h->ip6_vcf =
3291 3291 (IPV6_DEFAULT_VERS_AND_FLOW & IPV6_VERS_AND_FLOW_MASK) |
3292 3292 (flowinfo & ~IPV6_VERS_AND_FLOW_MASK);
3293 3293 if (ipp->ipp_fields & IPPF_TCLASS) {
3294 3294 /* Overrides the class part of flowinfo */
3295 3295 ip6h->ip6_vcf = IPV6_TCLASS_FLOW(ip6h->ip6_vcf,
3296 3296 ipp->ipp_tclass);
3297 3297 }
3298 3298 }
3299 3299
3300 3300 /* Insert all-0s SPI now. */
3301 3301 if (insert_spi)
3302 3302 *((uint32_t *)(udpha + 1)) = 0;
3303 3303
3304 3304 udpha->uha_dst_port = dstport;
3305 3305 return (mp);
3306 3306 }
3307 3307
3308 3308 /*
3309 3309 * Send a T_UDERR_IND in response to an M_DATA
3310 3310 */
3311 3311 static void
3312 3312 udp_ud_err_connected(conn_t *connp, t_scalar_t error)
3313 3313 {
3314 3314 struct sockaddr_storage ss;
3315 3315 sin_t *sin;
3316 3316 sin6_t *sin6;
3317 3317 struct sockaddr *addr;
3318 3318 socklen_t addrlen;
3319 3319 mblk_t *mp1;
3320 3320
3321 3321 mutex_enter(&connp->conn_lock);
3322 3322 /* Initialize addr and addrlen as if they're passed in */
3323 3323 if (connp->conn_family == AF_INET) {
3324 3324 sin = (sin_t *)&ss;
3325 3325 *sin = sin_null;
3326 3326 sin->sin_family = AF_INET;
3327 3327 sin->sin_port = connp->conn_fport;
3328 3328 sin->sin_addr.s_addr = connp->conn_faddr_v4;
3329 3329 addr = (struct sockaddr *)sin;
3330 3330 addrlen = sizeof (*sin);
3331 3331 } else {
3332 3332 sin6 = (sin6_t *)&ss;
3333 3333 *sin6 = sin6_null;
3334 3334 sin6->sin6_family = AF_INET6;
3335 3335 sin6->sin6_port = connp->conn_fport;
3336 3336 sin6->sin6_flowinfo = connp->conn_flowinfo;
3337 3337 sin6->sin6_addr = connp->conn_faddr_v6;
3338 3338 if (IN6_IS_ADDR_LINKSCOPE(&connp->conn_faddr_v6) &&
3339 3339 (connp->conn_ixa->ixa_flags & IXAF_SCOPEID_SET)) {
3340 3340 sin6->sin6_scope_id = connp->conn_ixa->ixa_scopeid;
3341 3341 } else {
3342 3342 sin6->sin6_scope_id = 0;
3343 3343 }
3344 3344 sin6->__sin6_src_id = 0;
3345 3345 addr = (struct sockaddr *)sin6;
3346 3346 addrlen = sizeof (*sin6);
3347 3347 }
3348 3348 mutex_exit(&connp->conn_lock);
3349 3349
3350 3350 mp1 = mi_tpi_uderror_ind((char *)addr, addrlen, NULL, 0, error);
3351 3351 if (mp1 != NULL)
3352 3352 putnext(connp->conn_rq, mp1);
3353 3353 }
3354 3354
3355 3355 /*
3356 3356 * This routine handles all messages passed downstream. It either
3357 3357 * consumes the message or passes it downstream; it never queues a
3358 3358 * a message.
3359 3359 *
3360 3360 * Also entry point for sockfs when udp is in "direct sockfs" mode. This mode
3361 3361 * is valid when we are directly beneath the stream head, and thus sockfs
3362 3362 * is able to bypass STREAMS and directly call us, passing along the sockaddr
3363 3363 * structure without the cumbersome T_UNITDATA_REQ interface for the case of
3364 3364 * connected endpoints.
3365 3365 */
3366 3366 void
3367 3367 udp_wput(queue_t *q, mblk_t *mp)
3368 3368 {
3369 3369 sin6_t *sin6;
3370 3370 sin_t *sin = NULL;
3371 3371 uint_t srcid;
3372 3372 conn_t *connp = Q_TO_CONN(q);
3373 3373 udp_t *udp = connp->conn_udp;
3374 3374 int error = 0;
3375 3375 struct sockaddr *addr = NULL;
3376 3376 socklen_t addrlen;
3377 3377 udp_stack_t *us = udp->udp_us;
3378 3378 struct T_unitdata_req *tudr;
3379 3379 mblk_t *data_mp;
3380 3380 ushort_t ipversion;
3381 3381 cred_t *cr;
3382 3382 pid_t pid;
3383 3383
3384 3384 /*
3385 3385 * We directly handle several cases here: T_UNITDATA_REQ message
3386 3386 * coming down as M_PROTO/M_PCPROTO and M_DATA messages for connected
3387 3387 * socket.
3388 3388 */
3389 3389 switch (DB_TYPE(mp)) {
3390 3390 case M_DATA:
3391 3391 if (!udp->udp_issocket || udp->udp_state != TS_DATA_XFER) {
3392 3392 /* Not connected; address is required */
3393 3393 UDPS_BUMP_MIB(us, udpOutErrors);
3394 3394 UDP_DBGSTAT(us, udp_data_notconn);
3395 3395 UDP_STAT(us, udp_out_err_notconn);
3396 3396 freemsg(mp);
3397 3397 return;
3398 3398 }
3399 3399 /*
3400 3400 * All Solaris components should pass a db_credp
3401 3401 * for this message, hence we ASSERT.
3402 3402 * On production kernels we return an error to be robust against
3403 3403 * random streams modules sitting on top of us.
3404 3404 */
3405 3405 cr = msg_getcred(mp, &pid);
3406 3406 ASSERT(cr != NULL);
3407 3407 if (cr == NULL) {
3408 3408 UDPS_BUMP_MIB(us, udpOutErrors);
3409 3409 freemsg(mp);
3410 3410 return;
3411 3411 }
3412 3412 ASSERT(udp->udp_issocket);
3413 3413 UDP_DBGSTAT(us, udp_data_conn);
3414 3414 error = udp_output_connected(connp, mp, cr, pid);
3415 3415 if (error != 0) {
3416 3416 UDP_STAT(us, udp_out_err_output);
3417 3417 if (connp->conn_rq != NULL)
3418 3418 udp_ud_err_connected(connp, (t_scalar_t)error);
3419 3419 #ifdef DEBUG
3420 3420 printf("udp_output_connected returned %d\n", error);
3421 3421 #endif
3422 3422 }
3423 3423 return;
3424 3424
3425 3425 case M_PROTO:
3426 3426 case M_PCPROTO:
3427 3427 tudr = (struct T_unitdata_req *)mp->b_rptr;
3428 3428 if (MBLKL(mp) < sizeof (*tudr) ||
3429 3429 ((t_primp_t)mp->b_rptr)->type != T_UNITDATA_REQ) {
3430 3430 udp_wput_other(q, mp);
3431 3431 return;
3432 3432 }
3433 3433 break;
3434 3434
3435 3435 default:
3436 3436 udp_wput_other(q, mp);
3437 3437 return;
3438 3438 }
3439 3439
3440 3440 /* Handle valid T_UNITDATA_REQ here */
3441 3441 data_mp = mp->b_cont;
3442 3442 if (data_mp == NULL) {
3443 3443 error = EPROTO;
3444 3444 goto ud_error2;
3445 3445 }
3446 3446 mp->b_cont = NULL;
3447 3447
3448 3448 if (!MBLKIN(mp, 0, tudr->DEST_offset + tudr->DEST_length)) {
3449 3449 error = EADDRNOTAVAIL;
3450 3450 goto ud_error2;
3451 3451 }
3452 3452
3453 3453 /*
3454 3454 * All Solaris components should pass a db_credp
3455 3455 * for this TPI message, hence we should ASSERT.
3456 3456 * However, RPC (svc_clts_ksend) does this odd thing where it
3457 3457 * passes the options from a T_UNITDATA_IND unchanged in a
3458 3458 * T_UNITDATA_REQ. While that is the right thing to do for
3459 3459 * some options, SCM_UCRED being the key one, this also makes it
3460 3460 * pass down IP_RECVDSTADDR. Hence we can't ASSERT here.
3461 3461 */
3462 3462 cr = msg_getcred(mp, &pid);
3463 3463 if (cr == NULL) {
3464 3464 cr = connp->conn_cred;
3465 3465 pid = connp->conn_cpid;
3466 3466 }
3467 3467
3468 3468 /*
3469 3469 * If a port has not been bound to the stream, fail.
3470 3470 * This is not a problem when sockfs is directly
3471 3471 * above us, because it will ensure that the socket
3472 3472 * is first bound before allowing data to be sent.
3473 3473 */
3474 3474 if (udp->udp_state == TS_UNBND) {
3475 3475 error = EPROTO;
3476 3476 goto ud_error2;
3477 3477 }
3478 3478 addr = (struct sockaddr *)&mp->b_rptr[tudr->DEST_offset];
3479 3479 addrlen = tudr->DEST_length;
3480 3480
3481 3481 switch (connp->conn_family) {
3482 3482 case AF_INET6:
3483 3483 sin6 = (sin6_t *)addr;
3484 3484 if (!OK_32PTR((char *)sin6) || (addrlen != sizeof (sin6_t)) ||
3485 3485 (sin6->sin6_family != AF_INET6)) {
3486 3486 error = EADDRNOTAVAIL;
3487 3487 goto ud_error2;
3488 3488 }
3489 3489
3490 3490 srcid = sin6->__sin6_src_id;
3491 3491 if (!IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
3492 3492 /*
3493 3493 * Destination is a non-IPv4-compatible IPv6 address.
3494 3494 * Send out an IPv6 format packet.
3495 3495 */
3496 3496
3497 3497 /*
3498 3498 * If the local address is a mapped address return
3499 3499 * an error.
3500 3500 * It would be possible to send an IPv6 packet but the
3501 3501 * response would never make it back to the application
3502 3502 * since it is bound to a mapped address.
3503 3503 */
3504 3504 if (IN6_IS_ADDR_V4MAPPED(&connp->conn_saddr_v6)) {
3505 3505 error = EADDRNOTAVAIL;
3506 3506 goto ud_error2;
3507 3507 }
3508 3508
3509 3509 UDP_DBGSTAT(us, udp_out_ipv6);
3510 3510
3511 3511 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr))
3512 3512 sin6->sin6_addr = ipv6_loopback;
3513 3513 ipversion = IPV6_VERSION;
3514 3514 } else {
3515 3515 if (connp->conn_ipv6_v6only) {
3516 3516 error = EADDRNOTAVAIL;
3517 3517 goto ud_error2;
3518 3518 }
3519 3519
3520 3520 /*
3521 3521 * If the local address is not zero or a mapped address
3522 3522 * return an error. It would be possible to send an
3523 3523 * IPv4 packet but the response would never make it
3524 3524 * back to the application since it is bound to a
3525 3525 * non-mapped address.
3526 3526 */
3527 3527 if (!IN6_IS_ADDR_V4MAPPED(&connp->conn_saddr_v6) &&
3528 3528 !IN6_IS_ADDR_UNSPECIFIED(&connp->conn_saddr_v6)) {
3529 3529 error = EADDRNOTAVAIL;
3530 3530 goto ud_error2;
3531 3531 }
3532 3532 UDP_DBGSTAT(us, udp_out_mapped);
3533 3533
3534 3534 if (V4_PART_OF_V6(sin6->sin6_addr) == INADDR_ANY) {
3535 3535 V4_PART_OF_V6(sin6->sin6_addr) =
3536 3536 htonl(INADDR_LOOPBACK);
3537 3537 }
3538 3538 ipversion = IPV4_VERSION;
3539 3539 }
3540 3540
3541 3541 if (tudr->OPT_length != 0) {
3542 3542 /*
3543 3543 * If we are connected then the destination needs to be
3544 3544 * the same as the connected one.
3545 3545 */
3546 3546 if (udp->udp_state == TS_DATA_XFER &&
3547 3547 !conn_same_as_last_v6(connp, sin6)) {
3548 3548 error = EISCONN;
3549 3549 goto ud_error2;
3550 3550 }
3551 3551 UDP_STAT(us, udp_out_opt);
3552 3552 error = udp_output_ancillary(connp, NULL, sin6,
3553 3553 data_mp, mp, NULL, cr, pid);
3554 3554 } else {
3555 3555 ip_xmit_attr_t *ixa;
3556 3556
3557 3557 /*
3558 3558 * We have to allocate an ip_xmit_attr_t before we grab
3559 3559 * conn_lock and we need to hold conn_lock once we've
3560 3560 * checked conn_same_as_last_v6 to handle concurrent
3561 3561 * send* calls on a socket.
3562 3562 */
3563 3563 ixa = conn_get_ixa(connp, B_FALSE);
3564 3564 if (ixa == NULL) {
3565 3565 error = ENOMEM;
3566 3566 goto ud_error2;
3567 3567 }
3568 3568 mutex_enter(&connp->conn_lock);
3569 3569
3570 3570 if (conn_same_as_last_v6(connp, sin6) &&
3571 3571 connp->conn_lastsrcid == srcid &&
3572 3572 ipsec_outbound_policy_current(ixa)) {
3573 3573 UDP_DBGSTAT(us, udp_out_lastdst);
3574 3574 /* udp_output_lastdst drops conn_lock */
3575 3575 error = udp_output_lastdst(connp, data_mp, cr,
3576 3576 pid, ixa);
3577 3577 } else {
3578 3578 UDP_DBGSTAT(us, udp_out_diffdst);
3579 3579 /* udp_output_newdst drops conn_lock */
3580 3580 error = udp_output_newdst(connp, data_mp, NULL,
3581 3581 sin6, ipversion, cr, pid, ixa);
3582 3582 }
3583 3583 ASSERT(MUTEX_NOT_HELD(&connp->conn_lock));
3584 3584 }
3585 3585 if (error == 0) {
3586 3586 freeb(mp);
3587 3587 return;
3588 3588 }
3589 3589 break;
3590 3590
3591 3591 case AF_INET:
3592 3592 sin = (sin_t *)addr;
3593 3593 if ((!OK_32PTR((char *)sin) || addrlen != sizeof (sin_t)) ||
3594 3594 (sin->sin_family != AF_INET)) {
3595 3595 error = EADDRNOTAVAIL;
3596 3596 goto ud_error2;
3597 3597 }
3598 3598 UDP_DBGSTAT(us, udp_out_ipv4);
3599 3599 if (sin->sin_addr.s_addr == INADDR_ANY)
3600 3600 sin->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
3601 3601 ipversion = IPV4_VERSION;
3602 3602
3603 3603 srcid = 0;
3604 3604 if (tudr->OPT_length != 0) {
3605 3605 /*
3606 3606 * If we are connected then the destination needs to be
3607 3607 * the same as the connected one.
3608 3608 */
3609 3609 if (udp->udp_state == TS_DATA_XFER &&
3610 3610 !conn_same_as_last_v4(connp, sin)) {
3611 3611 error = EISCONN;
3612 3612 goto ud_error2;
3613 3613 }
3614 3614 UDP_STAT(us, udp_out_opt);
3615 3615 error = udp_output_ancillary(connp, sin, NULL,
3616 3616 data_mp, mp, NULL, cr, pid);
3617 3617 } else {
3618 3618 ip_xmit_attr_t *ixa;
3619 3619
3620 3620 /*
3621 3621 * We have to allocate an ip_xmit_attr_t before we grab
3622 3622 * conn_lock and we need to hold conn_lock once we've
3623 3623 * checked conn_same_as_last_v4 to handle concurrent
3624 3624 * send* calls on a socket.
3625 3625 */
3626 3626 ixa = conn_get_ixa(connp, B_FALSE);
3627 3627 if (ixa == NULL) {
3628 3628 error = ENOMEM;
3629 3629 goto ud_error2;
3630 3630 }
3631 3631 mutex_enter(&connp->conn_lock);
3632 3632
3633 3633 if (conn_same_as_last_v4(connp, sin) &&
3634 3634 ipsec_outbound_policy_current(ixa)) {
3635 3635 UDP_DBGSTAT(us, udp_out_lastdst);
3636 3636 /* udp_output_lastdst drops conn_lock */
3637 3637 error = udp_output_lastdst(connp, data_mp, cr,
3638 3638 pid, ixa);
3639 3639 } else {
3640 3640 UDP_DBGSTAT(us, udp_out_diffdst);
3641 3641 /* udp_output_newdst drops conn_lock */
3642 3642 error = udp_output_newdst(connp, data_mp, sin,
3643 3643 NULL, ipversion, cr, pid, ixa);
3644 3644 }
3645 3645 ASSERT(MUTEX_NOT_HELD(&connp->conn_lock));
3646 3646 }
3647 3647 if (error == 0) {
3648 3648 freeb(mp);
3649 3649 return;
3650 3650 }
3651 3651 break;
3652 3652 }
3653 3653 UDP_STAT(us, udp_out_err_output);
3654 3654 ASSERT(mp != NULL);
3655 3655 /* mp is freed by the following routine */
3656 3656 udp_ud_err(q, mp, (t_scalar_t)error);
3657 3657 return;
3658 3658
3659 3659 ud_error2:
3660 3660 UDPS_BUMP_MIB(us, udpOutErrors);
3661 3661 freemsg(data_mp);
3662 3662 UDP_STAT(us, udp_out_err_output);
3663 3663 ASSERT(mp != NULL);
3664 3664 /* mp is freed by the following routine */
3665 3665 udp_ud_err(q, mp, (t_scalar_t)error);
3666 3666 }
3667 3667
3668 3668 /*
3669 3669 * Handle the case of the IP address, port, flow label being different
3670 3670 * for both IPv4 and IPv6.
3671 3671 *
3672 3672 * NOTE: The caller must hold conn_lock and we drop it here.
3673 3673 */
3674 3674 static int
3675 3675 udp_output_newdst(conn_t *connp, mblk_t *data_mp, sin_t *sin, sin6_t *sin6,
3676 3676 ushort_t ipversion, cred_t *cr, pid_t pid, ip_xmit_attr_t *ixa)
3677 3677 {
3678 3678 uint_t srcid;
3679 3679 uint32_t flowinfo;
3680 3680 udp_t *udp = connp->conn_udp;
3681 3681 int error = 0;
3682 3682 ip_xmit_attr_t *oldixa;
3683 3683 udp_stack_t *us = udp->udp_us;
3684 3684 in6_addr_t v6src;
3685 3685 in6_addr_t v6dst;
3686 3686 in6_addr_t v6nexthop;
3687 3687 in_port_t dstport;
3688 3688
3689 3689 ASSERT(MUTEX_HELD(&connp->conn_lock));
3690 3690 ASSERT(ixa != NULL);
3691 3691 /*
3692 3692 * We hold conn_lock across all the use and modifications of
3693 3693 * the conn_lastdst, conn_ixa, and conn_xmit_ipp to ensure that they
3694 3694 * stay consistent.
3695 3695 */
3696 3696
3697 3697 ASSERT(cr != NULL);
3698 3698 ASSERT(!(ixa->ixa_free_flags & IXA_FREE_CRED));
3699 3699 ixa->ixa_cred = cr;
3700 3700 ixa->ixa_cpid = pid;
3701 3701 if (is_system_labeled()) {
3702 3702 /* We need to restart with a label based on the cred */
3703 3703 ip_xmit_attr_restore_tsl(ixa, ixa->ixa_cred);
3704 3704 }
3705 3705
3706 3706 /*
3707 3707 * If we are connected then the destination needs to be the
3708 3708 * same as the connected one, which is not the case here since we
3709 3709 * checked for that above.
3710 3710 */
3711 3711 if (udp->udp_state == TS_DATA_XFER) {
3712 3712 mutex_exit(&connp->conn_lock);
3713 3713 error = EISCONN;
3714 3714 goto ud_error;
3715 3715 }
3716 3716
3717 3717 /* In case previous destination was multicast or multirt */
3718 3718 ip_attr_newdst(ixa);
3719 3719
3720 3720 /*
3721 3721 * If laddr is unspecified then we look at sin6_src_id.
3722 3722 * We will give precedence to a source address set with IPV6_PKTINFO
3723 3723 * (aka IPPF_ADDR) but that is handled in build_hdrs. However, we don't
3724 3724 * want ip_attr_connect to select a source (since it can fail) when
3725 3725 * IPV6_PKTINFO is specified.
3726 3726 * If this doesn't result in a source address then we get a source
3727 3727 * from ip_attr_connect() below.
3728 3728 */
3729 3729 v6src = connp->conn_saddr_v6;
3730 3730 if (sin != NULL) {
3731 3731 IN6_IPADDR_TO_V4MAPPED(sin->sin_addr.s_addr, &v6dst);
3732 3732 dstport = sin->sin_port;
3733 3733 flowinfo = 0;
3734 3734 /* Don't bother with ip_srcid_find_id(), but indicate anyway. */
3735 3735 srcid = 0;
3736 3736 ixa->ixa_flags &= ~IXAF_SCOPEID_SET;
3737 3737 ixa->ixa_flags |= IXAF_IS_IPV4;
3738 3738 } else {
3739 3739 boolean_t v4mapped;
3740 3740
3741 3741 v6dst = sin6->sin6_addr;
3742 3742 dstport = sin6->sin6_port;
3743 3743 flowinfo = sin6->sin6_flowinfo;
3744 3744 srcid = sin6->__sin6_src_id;
3745 3745 if (IN6_IS_ADDR_LINKSCOPE(&v6dst) && sin6->sin6_scope_id != 0) {
3746 3746 ixa->ixa_scopeid = sin6->sin6_scope_id;
|
↓ open down ↓ |
1000 lines elided |
↑ open up ↑ |
3747 3747 ixa->ixa_flags |= IXAF_SCOPEID_SET;
3748 3748 } else {
3749 3749 ixa->ixa_flags &= ~IXAF_SCOPEID_SET;
3750 3750 }
3751 3751 v4mapped = IN6_IS_ADDR_V4MAPPED(&v6dst);
3752 3752 if (v4mapped)
3753 3753 ixa->ixa_flags |= IXAF_IS_IPV4;
3754 3754 else
3755 3755 ixa->ixa_flags &= ~IXAF_IS_IPV4;
3756 3756 if (srcid != 0 && IN6_IS_ADDR_UNSPECIFIED(&v6src)) {
3757 - if (ip_srcid_find_id(srcid, &v6src, IPCL_ZONEID(connp),
3757 + if (!ip_srcid_find_id(srcid, &v6src, IPCL_ZONEID(connp),
3758 3758 v4mapped, connp->conn_netstack)) {
3759 3759 /* Mismatched v4mapped/v6 specified by srcid. */
3760 3760 mutex_exit(&connp->conn_lock);
3761 3761 error = EADDRNOTAVAIL;
3762 3762 goto ud_error;
3763 3763 }
3764 3764 }
3765 3765 }
3766 3766 /* Handle IP_PKTINFO/IPV6_PKTINFO setting source address. */
3767 3767 if (connp->conn_xmit_ipp.ipp_fields & IPPF_ADDR) {
3768 3768 ip_pkt_t *ipp = &connp->conn_xmit_ipp;
3769 3769
3770 3770 if (ixa->ixa_flags & IXAF_IS_IPV4) {
3771 3771 if (IN6_IS_ADDR_V4MAPPED(&ipp->ipp_addr))
3772 3772 v6src = ipp->ipp_addr;
3773 3773 } else {
3774 3774 if (!IN6_IS_ADDR_V4MAPPED(&ipp->ipp_addr))
3775 3775 v6src = ipp->ipp_addr;
3776 3776 }
3777 3777 }
3778 3778
3779 3779 ip_attr_nexthop(&connp->conn_xmit_ipp, ixa, &v6dst, &v6nexthop);
3780 3780 mutex_exit(&connp->conn_lock);
3781 3781
3782 3782 error = ip_attr_connect(connp, ixa, &v6src, &v6dst, &v6nexthop, dstport,
3783 3783 &v6src, NULL, IPDF_ALLOW_MCBC | IPDF_VERIFY_DST | IPDF_IPSEC);
3784 3784 switch (error) {
3785 3785 case 0:
3786 3786 break;
3787 3787 case EADDRNOTAVAIL:
3788 3788 /*
3789 3789 * IXAF_VERIFY_SOURCE tells us to pick a better source.
3790 3790 * Don't have the application see that errno
3791 3791 */
3792 3792 error = ENETUNREACH;
3793 3793 goto failed;
3794 3794 case ENETDOWN:
3795 3795 /*
3796 3796 * Have !ipif_addr_ready address; drop packet silently
3797 3797 * until we can get applications to not send until we
3798 3798 * are ready.
3799 3799 */
3800 3800 error = 0;
3801 3801 goto failed;
3802 3802 case EHOSTUNREACH:
3803 3803 case ENETUNREACH:
3804 3804 if (ixa->ixa_ire != NULL) {
3805 3805 /*
3806 3806 * Let conn_ip_output/ire_send_noroute return
3807 3807 * the error and send any local ICMP error.
3808 3808 */
3809 3809 error = 0;
3810 3810 break;
3811 3811 }
3812 3812 /* FALLTHRU */
3813 3813 failed:
3814 3814 default:
3815 3815 goto ud_error;
3816 3816 }
3817 3817
3818 3818
3819 3819 /*
3820 3820 * Cluster note: we let the cluster hook know that we are sending to a
3821 3821 * new address and/or port.
3822 3822 */
3823 3823 if (cl_inet_connect2 != NULL) {
3824 3824 CL_INET_UDP_CONNECT(connp, B_TRUE, &v6dst, dstport, error);
3825 3825 if (error != 0) {
3826 3826 error = EHOSTUNREACH;
3827 3827 goto ud_error;
3828 3828 }
3829 3829 }
3830 3830
3831 3831 mutex_enter(&connp->conn_lock);
3832 3832 /*
3833 3833 * While we dropped the lock some other thread might have connected
3834 3834 * this socket. If so we bail out with EISCONN to ensure that the
3835 3835 * connecting thread is the one that updates conn_ixa, conn_ht_*
3836 3836 * and conn_*last*.
3837 3837 */
3838 3838 if (udp->udp_state == TS_DATA_XFER) {
3839 3839 mutex_exit(&connp->conn_lock);
3840 3840 error = EISCONN;
3841 3841 goto ud_error;
3842 3842 }
3843 3843
3844 3844 /*
3845 3845 * We need to rebuild the headers if
3846 3846 * - we are labeling packets (could be different for different
3847 3847 * destinations)
3848 3848 * - we have a source route (or routing header) since we need to
3849 3849 * massage that to get the pseudo-header checksum
3850 3850 * - the IP version is different than the last time
3851 3851 * - a socket option with COA_HEADER_CHANGED has been set which
3852 3852 * set conn_v6lastdst to zero.
3853 3853 *
3854 3854 * Otherwise the prepend function will just update the src, dst,
3855 3855 * dstport, and flow label.
3856 3856 */
3857 3857 if (is_system_labeled()) {
3858 3858 /* TX MLP requires SCM_UCRED and don't have that here */
3859 3859 if (connp->conn_mlp_type != mlptSingle) {
3860 3860 mutex_exit(&connp->conn_lock);
3861 3861 error = ECONNREFUSED;
3862 3862 goto ud_error;
3863 3863 }
3864 3864 /*
3865 3865 * Check whether Trusted Solaris policy allows communication
3866 3866 * with this host, and pretend that the destination is
3867 3867 * unreachable if not.
3868 3868 * Compute any needed label and place it in ipp_label_v4/v6.
3869 3869 *
3870 3870 * Later conn_build_hdr_template/conn_prepend_hdr takes
3871 3871 * ipp_label_v4/v6 to form the packet.
3872 3872 *
3873 3873 * Tsol note: Since we hold conn_lock we know no other
3874 3874 * thread manipulates conn_xmit_ipp.
3875 3875 */
3876 3876 error = conn_update_label(connp, ixa, &v6dst,
3877 3877 &connp->conn_xmit_ipp);
3878 3878 if (error != 0) {
3879 3879 mutex_exit(&connp->conn_lock);
3880 3880 goto ud_error;
3881 3881 }
3882 3882 /* Rebuild the header template */
3883 3883 error = udp_build_hdr_template(connp, &v6src, &v6dst, dstport,
3884 3884 flowinfo);
3885 3885 if (error != 0) {
3886 3886 mutex_exit(&connp->conn_lock);
3887 3887 goto ud_error;
3888 3888 }
3889 3889 } else if ((connp->conn_xmit_ipp.ipp_fields &
3890 3890 (IPPF_IPV4_OPTIONS|IPPF_RTHDR)) ||
3891 3891 ipversion != connp->conn_lastipversion ||
3892 3892 IN6_IS_ADDR_UNSPECIFIED(&connp->conn_v6lastdst)) {
3893 3893 /* Rebuild the header template */
3894 3894 error = udp_build_hdr_template(connp, &v6src, &v6dst, dstport,
3895 3895 flowinfo);
3896 3896 if (error != 0) {
3897 3897 mutex_exit(&connp->conn_lock);
3898 3898 goto ud_error;
3899 3899 }
3900 3900 } else {
3901 3901 /* Simply update the destination address if no source route */
3902 3902 if (ixa->ixa_flags & IXAF_IS_IPV4) {
3903 3903 ipha_t *ipha = (ipha_t *)connp->conn_ht_iphc;
3904 3904
3905 3905 IN6_V4MAPPED_TO_IPADDR(&v6dst, ipha->ipha_dst);
3906 3906 if (ixa->ixa_flags & IXAF_PMTU_IPV4_DF) {
3907 3907 ipha->ipha_fragment_offset_and_flags |=
3908 3908 IPH_DF_HTONS;
3909 3909 } else {
3910 3910 ipha->ipha_fragment_offset_and_flags &=
3911 3911 ~IPH_DF_HTONS;
3912 3912 }
3913 3913 } else {
3914 3914 ip6_t *ip6h = (ip6_t *)connp->conn_ht_iphc;
3915 3915 ip6h->ip6_dst = v6dst;
3916 3916 }
3917 3917 }
3918 3918
3919 3919 /*
3920 3920 * Remember the dst/dstport etc which corresponds to the built header
3921 3921 * template and conn_ixa.
3922 3922 */
3923 3923 oldixa = conn_replace_ixa(connp, ixa);
3924 3924 connp->conn_v6lastdst = v6dst;
3925 3925 connp->conn_lastipversion = ipversion;
3926 3926 connp->conn_lastdstport = dstport;
3927 3927 connp->conn_lastflowinfo = flowinfo;
3928 3928 connp->conn_lastscopeid = ixa->ixa_scopeid;
3929 3929 connp->conn_lastsrcid = srcid;
3930 3930 /* Also remember a source to use together with lastdst */
3931 3931 connp->conn_v6lastsrc = v6src;
3932 3932
3933 3933 data_mp = udp_prepend_header_template(connp, ixa, data_mp, &v6src,
3934 3934 dstport, flowinfo, &error);
3935 3935
3936 3936 /* Done with conn_t */
3937 3937 mutex_exit(&connp->conn_lock);
3938 3938 ixa_refrele(oldixa);
3939 3939
3940 3940 if (data_mp == NULL) {
3941 3941 ASSERT(error != 0);
3942 3942 goto ud_error;
3943 3943 }
3944 3944
3945 3945 /* We're done. Pass the packet to ip. */
3946 3946 UDPS_BUMP_MIB(us, udpHCOutDatagrams);
3947 3947
3948 3948 DTRACE_UDP5(send, mblk_t *, NULL, ip_xmit_attr_t *, ixa,
3949 3949 void_ip_t *, data_mp->b_rptr, udp_t *, udp, udpha_t *,
3950 3950 &data_mp->b_rptr[ixa->ixa_ip_hdr_length]);
3951 3951
3952 3952 error = conn_ip_output(data_mp, ixa);
3953 3953 /* No udpOutErrors if an error since IP increases its error counter */
3954 3954 switch (error) {
3955 3955 case 0:
3956 3956 break;
3957 3957 case EWOULDBLOCK:
3958 3958 (void) ixa_check_drain_insert(connp, ixa);
3959 3959 error = 0;
3960 3960 break;
3961 3961 case EADDRNOTAVAIL:
3962 3962 /*
3963 3963 * IXAF_VERIFY_SOURCE tells us to pick a better source.
3964 3964 * Don't have the application see that errno
3965 3965 */
3966 3966 error = ENETUNREACH;
3967 3967 /* FALLTHRU */
3968 3968 default:
3969 3969 mutex_enter(&connp->conn_lock);
3970 3970 /*
3971 3971 * Clear the source and v6lastdst so we call ip_attr_connect
3972 3972 * for the next packet and try to pick a better source.
3973 3973 */
3974 3974 if (connp->conn_mcbc_bind)
3975 3975 connp->conn_saddr_v6 = ipv6_all_zeros;
3976 3976 else
3977 3977 connp->conn_saddr_v6 = connp->conn_bound_addr_v6;
3978 3978 connp->conn_v6lastdst = ipv6_all_zeros;
3979 3979 mutex_exit(&connp->conn_lock);
3980 3980 break;
3981 3981 }
3982 3982 ASSERT(!(ixa->ixa_free_flags & IXA_FREE_CRED));
3983 3983 ixa->ixa_cred = connp->conn_cred; /* Restore */
3984 3984 ixa->ixa_cpid = connp->conn_cpid;
3985 3985 ixa_refrele(ixa);
3986 3986 return (error);
3987 3987
3988 3988 ud_error:
3989 3989 ASSERT(!(ixa->ixa_free_flags & IXA_FREE_CRED));
3990 3990 ixa->ixa_cred = connp->conn_cred; /* Restore */
3991 3991 ixa->ixa_cpid = connp->conn_cpid;
3992 3992 ixa_refrele(ixa);
3993 3993
3994 3994 freemsg(data_mp);
3995 3995 UDPS_BUMP_MIB(us, udpOutErrors);
3996 3996 UDP_STAT(us, udp_out_err_output);
3997 3997 return (error);
3998 3998 }
3999 3999
4000 4000 /* ARGSUSED */
4001 4001 static void
4002 4002 udp_wput_fallback(queue_t *wq, mblk_t *mp)
4003 4003 {
4004 4004 #ifdef DEBUG
4005 4005 cmn_err(CE_CONT, "udp_wput_fallback: Message in fallback \n");
4006 4006 #endif
4007 4007 freemsg(mp);
4008 4008 }
4009 4009
4010 4010
4011 4011 /*
4012 4012 * Handle special out-of-band ioctl requests (see PSARC/2008/265).
4013 4013 */
4014 4014 static void
4015 4015 udp_wput_cmdblk(queue_t *q, mblk_t *mp)
4016 4016 {
4017 4017 void *data;
4018 4018 mblk_t *datamp = mp->b_cont;
4019 4019 conn_t *connp = Q_TO_CONN(q);
4020 4020 udp_t *udp = connp->conn_udp;
4021 4021 cmdblk_t *cmdp = (cmdblk_t *)mp->b_rptr;
4022 4022
4023 4023 if (datamp == NULL || MBLKL(datamp) < cmdp->cb_len) {
4024 4024 cmdp->cb_error = EPROTO;
4025 4025 qreply(q, mp);
4026 4026 return;
4027 4027 }
4028 4028 data = datamp->b_rptr;
4029 4029
4030 4030 mutex_enter(&connp->conn_lock);
4031 4031 switch (cmdp->cb_cmd) {
4032 4032 case TI_GETPEERNAME:
4033 4033 if (udp->udp_state != TS_DATA_XFER)
4034 4034 cmdp->cb_error = ENOTCONN;
4035 4035 else
4036 4036 cmdp->cb_error = conn_getpeername(connp, data,
4037 4037 &cmdp->cb_len);
4038 4038 break;
4039 4039 case TI_GETMYNAME:
4040 4040 cmdp->cb_error = conn_getsockname(connp, data, &cmdp->cb_len);
4041 4041 break;
4042 4042 default:
4043 4043 cmdp->cb_error = EINVAL;
4044 4044 break;
4045 4045 }
4046 4046 mutex_exit(&connp->conn_lock);
4047 4047
4048 4048 qreply(q, mp);
4049 4049 }
4050 4050
4051 4051 static void
4052 4052 udp_use_pure_tpi(udp_t *udp)
4053 4053 {
4054 4054 conn_t *connp = udp->udp_connp;
4055 4055
4056 4056 mutex_enter(&connp->conn_lock);
4057 4057 udp->udp_issocket = B_FALSE;
4058 4058 mutex_exit(&connp->conn_lock);
4059 4059 UDP_STAT(udp->udp_us, udp_sock_fallback);
4060 4060 }
4061 4061
4062 4062 static void
4063 4063 udp_wput_other(queue_t *q, mblk_t *mp)
4064 4064 {
4065 4065 uchar_t *rptr = mp->b_rptr;
4066 4066 struct iocblk *iocp;
4067 4067 conn_t *connp = Q_TO_CONN(q);
4068 4068 udp_t *udp = connp->conn_udp;
4069 4069 cred_t *cr;
4070 4070
4071 4071 switch (mp->b_datap->db_type) {
4072 4072 case M_CMD:
4073 4073 udp_wput_cmdblk(q, mp);
4074 4074 return;
4075 4075
4076 4076 case M_PROTO:
4077 4077 case M_PCPROTO:
4078 4078 if (mp->b_wptr - rptr < sizeof (t_scalar_t)) {
4079 4079 /*
4080 4080 * If the message does not contain a PRIM_type,
4081 4081 * throw it away.
4082 4082 */
4083 4083 freemsg(mp);
4084 4084 return;
4085 4085 }
4086 4086 switch (((t_primp_t)rptr)->type) {
4087 4087 case T_ADDR_REQ:
4088 4088 udp_addr_req(q, mp);
4089 4089 return;
4090 4090 case O_T_BIND_REQ:
4091 4091 case T_BIND_REQ:
4092 4092 udp_tpi_bind(q, mp);
4093 4093 return;
4094 4094 case T_CONN_REQ:
4095 4095 udp_tpi_connect(q, mp);
4096 4096 return;
4097 4097 case T_CAPABILITY_REQ:
4098 4098 udp_capability_req(q, mp);
4099 4099 return;
4100 4100 case T_INFO_REQ:
4101 4101 udp_info_req(q, mp);
4102 4102 return;
4103 4103 case T_UNITDATA_REQ:
4104 4104 /*
4105 4105 * If a T_UNITDATA_REQ gets here, the address must
4106 4106 * be bad. Valid T_UNITDATA_REQs are handled
4107 4107 * in udp_wput.
4108 4108 */
4109 4109 udp_ud_err(q, mp, EADDRNOTAVAIL);
4110 4110 return;
4111 4111 case T_UNBIND_REQ:
4112 4112 udp_tpi_unbind(q, mp);
4113 4113 return;
4114 4114 case T_SVR4_OPTMGMT_REQ:
4115 4115 /*
4116 4116 * All Solaris components should pass a db_credp
4117 4117 * for this TPI message, hence we ASSERT.
4118 4118 * But in case there is some other M_PROTO that looks
4119 4119 * like a TPI message sent by some other kernel
4120 4120 * component, we check and return an error.
4121 4121 */
4122 4122 cr = msg_getcred(mp, NULL);
4123 4123 ASSERT(cr != NULL);
4124 4124 if (cr == NULL) {
4125 4125 udp_err_ack(q, mp, TSYSERR, EINVAL);
4126 4126 return;
4127 4127 }
4128 4128 if (!snmpcom_req(q, mp, udp_snmp_set, ip_snmp_get,
4129 4129 cr)) {
4130 4130 svr4_optcom_req(q, mp, cr, &udp_opt_obj);
4131 4131 }
4132 4132 return;
4133 4133
4134 4134 case T_OPTMGMT_REQ:
4135 4135 /*
4136 4136 * All Solaris components should pass a db_credp
4137 4137 * for this TPI message, hence we ASSERT.
4138 4138 * But in case there is some other M_PROTO that looks
4139 4139 * like a TPI message sent by some other kernel
4140 4140 * component, we check and return an error.
4141 4141 */
4142 4142 cr = msg_getcred(mp, NULL);
4143 4143 ASSERT(cr != NULL);
4144 4144 if (cr == NULL) {
4145 4145 udp_err_ack(q, mp, TSYSERR, EINVAL);
4146 4146 return;
4147 4147 }
4148 4148 tpi_optcom_req(q, mp, cr, &udp_opt_obj);
4149 4149 return;
4150 4150
4151 4151 case T_DISCON_REQ:
4152 4152 udp_tpi_disconnect(q, mp);
4153 4153 return;
4154 4154
4155 4155 /* The following TPI message is not supported by udp. */
4156 4156 case O_T_CONN_RES:
4157 4157 case T_CONN_RES:
4158 4158 udp_err_ack(q, mp, TNOTSUPPORT, 0);
4159 4159 return;
4160 4160
4161 4161 /* The following 3 TPI requests are illegal for udp. */
4162 4162 case T_DATA_REQ:
4163 4163 case T_EXDATA_REQ:
4164 4164 case T_ORDREL_REQ:
4165 4165 udp_err_ack(q, mp, TNOTSUPPORT, 0);
4166 4166 return;
4167 4167 default:
4168 4168 break;
4169 4169 }
4170 4170 break;
4171 4171 case M_FLUSH:
4172 4172 if (*rptr & FLUSHW)
4173 4173 flushq(q, FLUSHDATA);
4174 4174 break;
4175 4175 case M_IOCTL:
4176 4176 iocp = (struct iocblk *)mp->b_rptr;
4177 4177 switch (iocp->ioc_cmd) {
4178 4178 case TI_GETPEERNAME:
4179 4179 if (udp->udp_state != TS_DATA_XFER) {
4180 4180 /*
4181 4181 * If a default destination address has not
4182 4182 * been associated with the stream, then we
4183 4183 * don't know the peer's name.
4184 4184 */
4185 4185 iocp->ioc_error = ENOTCONN;
4186 4186 iocp->ioc_count = 0;
4187 4187 mp->b_datap->db_type = M_IOCACK;
4188 4188 qreply(q, mp);
4189 4189 return;
4190 4190 }
4191 4191 /* FALLTHRU */
4192 4192 case TI_GETMYNAME:
4193 4193 /*
4194 4194 * For TI_GETPEERNAME and TI_GETMYNAME, we first
4195 4195 * need to copyin the user's strbuf structure.
4196 4196 * Processing will continue in the M_IOCDATA case
4197 4197 * below.
4198 4198 */
4199 4199 mi_copyin(q, mp, NULL,
4200 4200 SIZEOF_STRUCT(strbuf, iocp->ioc_flag));
4201 4201 return;
4202 4202 case _SIOCSOCKFALLBACK:
4203 4203 /*
4204 4204 * Either sockmod is about to be popped and the
4205 4205 * socket would now be treated as a plain stream,
4206 4206 * or a module is about to be pushed so we have
4207 4207 * to follow pure TPI semantics.
4208 4208 */
4209 4209 if (!udp->udp_issocket) {
4210 4210 DB_TYPE(mp) = M_IOCNAK;
4211 4211 iocp->ioc_error = EINVAL;
4212 4212 } else {
4213 4213 udp_use_pure_tpi(udp);
4214 4214
4215 4215 DB_TYPE(mp) = M_IOCACK;
4216 4216 iocp->ioc_error = 0;
4217 4217 }
4218 4218 iocp->ioc_count = 0;
4219 4219 iocp->ioc_rval = 0;
4220 4220 qreply(q, mp);
4221 4221 return;
4222 4222 default:
4223 4223 break;
4224 4224 }
4225 4225 break;
4226 4226 case M_IOCDATA:
4227 4227 udp_wput_iocdata(q, mp);
4228 4228 return;
4229 4229 default:
4230 4230 /* Unrecognized messages are passed through without change. */
4231 4231 break;
4232 4232 }
4233 4233 ip_wput_nondata(q, mp);
4234 4234 }
4235 4235
4236 4236 /*
4237 4237 * udp_wput_iocdata is called by udp_wput_other to handle all M_IOCDATA
4238 4238 * messages.
4239 4239 */
4240 4240 static void
4241 4241 udp_wput_iocdata(queue_t *q, mblk_t *mp)
4242 4242 {
4243 4243 mblk_t *mp1;
4244 4244 struct iocblk *iocp = (struct iocblk *)mp->b_rptr;
4245 4245 STRUCT_HANDLE(strbuf, sb);
4246 4246 uint_t addrlen;
4247 4247 conn_t *connp = Q_TO_CONN(q);
4248 4248 udp_t *udp = connp->conn_udp;
4249 4249
4250 4250 /* Make sure it is one of ours. */
4251 4251 switch (iocp->ioc_cmd) {
4252 4252 case TI_GETMYNAME:
4253 4253 case TI_GETPEERNAME:
4254 4254 break;
4255 4255 default:
4256 4256 ip_wput_nondata(q, mp);
4257 4257 return;
4258 4258 }
4259 4259
4260 4260 switch (mi_copy_state(q, mp, &mp1)) {
4261 4261 case -1:
4262 4262 return;
4263 4263 case MI_COPY_CASE(MI_COPY_IN, 1):
4264 4264 break;
4265 4265 case MI_COPY_CASE(MI_COPY_OUT, 1):
4266 4266 /*
4267 4267 * The address has been copied out, so now
4268 4268 * copyout the strbuf.
4269 4269 */
4270 4270 mi_copyout(q, mp);
4271 4271 return;
4272 4272 case MI_COPY_CASE(MI_COPY_OUT, 2):
4273 4273 /*
4274 4274 * The address and strbuf have been copied out.
4275 4275 * We're done, so just acknowledge the original
4276 4276 * M_IOCTL.
4277 4277 */
4278 4278 mi_copy_done(q, mp, 0);
4279 4279 return;
4280 4280 default:
4281 4281 /*
4282 4282 * Something strange has happened, so acknowledge
4283 4283 * the original M_IOCTL with an EPROTO error.
4284 4284 */
4285 4285 mi_copy_done(q, mp, EPROTO);
4286 4286 return;
4287 4287 }
4288 4288
4289 4289 /*
4290 4290 * Now we have the strbuf structure for TI_GETMYNAME
4291 4291 * and TI_GETPEERNAME. Next we copyout the requested
4292 4292 * address and then we'll copyout the strbuf.
4293 4293 */
4294 4294 STRUCT_SET_HANDLE(sb, iocp->ioc_flag, (void *)mp1->b_rptr);
4295 4295
4296 4296 if (connp->conn_family == AF_INET)
4297 4297 addrlen = sizeof (sin_t);
4298 4298 else
4299 4299 addrlen = sizeof (sin6_t);
4300 4300
4301 4301 if (STRUCT_FGET(sb, maxlen) < addrlen) {
4302 4302 mi_copy_done(q, mp, EINVAL);
4303 4303 return;
4304 4304 }
4305 4305
4306 4306 switch (iocp->ioc_cmd) {
4307 4307 case TI_GETMYNAME:
4308 4308 break;
4309 4309 case TI_GETPEERNAME:
4310 4310 if (udp->udp_state != TS_DATA_XFER) {
4311 4311 mi_copy_done(q, mp, ENOTCONN);
4312 4312 return;
4313 4313 }
4314 4314 break;
4315 4315 }
4316 4316 mp1 = mi_copyout_alloc(q, mp, STRUCT_FGETP(sb, buf), addrlen, B_TRUE);
4317 4317 if (!mp1)
4318 4318 return;
4319 4319
4320 4320 STRUCT_FSET(sb, len, addrlen);
4321 4321 switch (((struct iocblk *)mp->b_rptr)->ioc_cmd) {
4322 4322 case TI_GETMYNAME:
4323 4323 (void) conn_getsockname(connp, (struct sockaddr *)mp1->b_wptr,
4324 4324 &addrlen);
4325 4325 break;
4326 4326 case TI_GETPEERNAME:
4327 4327 (void) conn_getpeername(connp, (struct sockaddr *)mp1->b_wptr,
4328 4328 &addrlen);
4329 4329 break;
4330 4330 }
4331 4331 mp1->b_wptr += addrlen;
4332 4332 /* Copy out the address */
4333 4333 mi_copyout(q, mp);
4334 4334 }
4335 4335
4336 4336 void
4337 4337 udp_ddi_g_init(void)
4338 4338 {
4339 4339 udp_max_optsize = optcom_max_optsize(udp_opt_obj.odb_opt_des_arr,
4340 4340 udp_opt_obj.odb_opt_arr_cnt);
4341 4341
4342 4342 /*
4343 4343 * We want to be informed each time a stack is created or
4344 4344 * destroyed in the kernel, so we can maintain the
4345 4345 * set of udp_stack_t's.
4346 4346 */
4347 4347 netstack_register(NS_UDP, udp_stack_init, NULL, udp_stack_fini);
4348 4348 }
4349 4349
4350 4350 void
4351 4351 udp_ddi_g_destroy(void)
4352 4352 {
4353 4353 netstack_unregister(NS_UDP);
4354 4354 }
4355 4355
4356 4356 #define INET_NAME "ip"
4357 4357
4358 4358 /*
4359 4359 * Initialize the UDP stack instance.
4360 4360 */
4361 4361 static void *
4362 4362 udp_stack_init(netstackid_t stackid, netstack_t *ns)
4363 4363 {
4364 4364 udp_stack_t *us;
4365 4365 int i;
4366 4366 int error = 0;
4367 4367 major_t major;
4368 4368 size_t arrsz;
4369 4369
4370 4370 us = (udp_stack_t *)kmem_zalloc(sizeof (*us), KM_SLEEP);
4371 4371 us->us_netstack = ns;
4372 4372
4373 4373 mutex_init(&us->us_epriv_port_lock, NULL, MUTEX_DEFAULT, NULL);
4374 4374 us->us_num_epriv_ports = UDP_NUM_EPRIV_PORTS;
4375 4375 us->us_epriv_ports[0] = ULP_DEF_EPRIV_PORT1;
4376 4376 us->us_epriv_ports[1] = ULP_DEF_EPRIV_PORT2;
4377 4377
4378 4378 /*
4379 4379 * The smallest anonymous port in the priviledged port range which UDP
4380 4380 * looks for free port. Use in the option UDP_ANONPRIVBIND.
4381 4381 */
4382 4382 us->us_min_anonpriv_port = 512;
4383 4383
4384 4384 us->us_bind_fanout_size = udp_bind_fanout_size;
4385 4385
4386 4386 /* Roundup variable that might have been modified in /etc/system */
4387 4387 if (us->us_bind_fanout_size & (us->us_bind_fanout_size - 1)) {
4388 4388 /* Not a power of two. Round up to nearest power of two */
4389 4389 for (i = 0; i < 31; i++) {
4390 4390 if (us->us_bind_fanout_size < (1 << i))
4391 4391 break;
4392 4392 }
4393 4393 us->us_bind_fanout_size = 1 << i;
4394 4394 }
4395 4395 us->us_bind_fanout = kmem_zalloc(us->us_bind_fanout_size *
4396 4396 sizeof (udp_fanout_t), KM_SLEEP);
4397 4397 for (i = 0; i < us->us_bind_fanout_size; i++) {
4398 4398 mutex_init(&us->us_bind_fanout[i].uf_lock, NULL, MUTEX_DEFAULT,
4399 4399 NULL);
4400 4400 }
4401 4401
4402 4402 arrsz = udp_propinfo_count * sizeof (mod_prop_info_t);
4403 4403 us->us_propinfo_tbl = (mod_prop_info_t *)kmem_alloc(arrsz,
4404 4404 KM_SLEEP);
4405 4405 bcopy(udp_propinfo_tbl, us->us_propinfo_tbl, arrsz);
4406 4406
4407 4407 /* Allocate the per netstack stats */
4408 4408 mutex_enter(&cpu_lock);
4409 4409 us->us_sc_cnt = MAX(ncpus, boot_ncpus);
4410 4410 mutex_exit(&cpu_lock);
4411 4411 us->us_sc = kmem_zalloc(max_ncpus * sizeof (udp_stats_cpu_t *),
4412 4412 KM_SLEEP);
4413 4413 for (i = 0; i < us->us_sc_cnt; i++) {
4414 4414 us->us_sc[i] = kmem_zalloc(sizeof (udp_stats_cpu_t),
4415 4415 KM_SLEEP);
4416 4416 }
4417 4417
4418 4418 us->us_kstat = udp_kstat2_init(stackid);
4419 4419 us->us_mibkp = udp_kstat_init(stackid);
4420 4420
4421 4421 major = mod_name_to_major(INET_NAME);
4422 4422 error = ldi_ident_from_major(major, &us->us_ldi_ident);
4423 4423 ASSERT(error == 0);
4424 4424 return (us);
4425 4425 }
4426 4426
4427 4427 /*
4428 4428 * Free the UDP stack instance.
4429 4429 */
4430 4430 static void
4431 4431 udp_stack_fini(netstackid_t stackid, void *arg)
4432 4432 {
4433 4433 udp_stack_t *us = (udp_stack_t *)arg;
4434 4434 int i;
4435 4435
4436 4436 for (i = 0; i < us->us_bind_fanout_size; i++) {
4437 4437 mutex_destroy(&us->us_bind_fanout[i].uf_lock);
4438 4438 }
4439 4439
4440 4440 kmem_free(us->us_bind_fanout, us->us_bind_fanout_size *
4441 4441 sizeof (udp_fanout_t));
4442 4442
4443 4443 us->us_bind_fanout = NULL;
4444 4444
4445 4445 for (i = 0; i < us->us_sc_cnt; i++)
4446 4446 kmem_free(us->us_sc[i], sizeof (udp_stats_cpu_t));
4447 4447 kmem_free(us->us_sc, max_ncpus * sizeof (udp_stats_cpu_t *));
4448 4448
4449 4449 kmem_free(us->us_propinfo_tbl,
4450 4450 udp_propinfo_count * sizeof (mod_prop_info_t));
4451 4451 us->us_propinfo_tbl = NULL;
4452 4452
4453 4453 udp_kstat_fini(stackid, us->us_mibkp);
4454 4454 us->us_mibkp = NULL;
4455 4455
4456 4456 udp_kstat2_fini(stackid, us->us_kstat);
4457 4457 us->us_kstat = NULL;
4458 4458
4459 4459 mutex_destroy(&us->us_epriv_port_lock);
4460 4460 ldi_ident_release(us->us_ldi_ident);
4461 4461 kmem_free(us, sizeof (*us));
4462 4462 }
4463 4463
4464 4464 static size_t
4465 4465 udp_set_rcv_hiwat(udp_t *udp, size_t size)
4466 4466 {
4467 4467 udp_stack_t *us = udp->udp_us;
4468 4468
4469 4469 /* We add a bit of extra buffering */
4470 4470 size += size >> 1;
4471 4471 if (size > us->us_max_buf)
4472 4472 size = us->us_max_buf;
4473 4473
4474 4474 udp->udp_rcv_hiwat = size;
4475 4475 return (size);
4476 4476 }
4477 4477
4478 4478 /*
4479 4479 * For the lower queue so that UDP can be a dummy mux.
4480 4480 * Nobody should be sending
4481 4481 * packets up this stream
4482 4482 */
4483 4483 static void
4484 4484 udp_lrput(queue_t *q, mblk_t *mp)
4485 4485 {
4486 4486 switch (mp->b_datap->db_type) {
4487 4487 case M_FLUSH:
4488 4488 /* Turn around */
4489 4489 if (*mp->b_rptr & FLUSHW) {
4490 4490 *mp->b_rptr &= ~FLUSHR;
4491 4491 qreply(q, mp);
4492 4492 return;
4493 4493 }
4494 4494 break;
4495 4495 }
4496 4496 freemsg(mp);
4497 4497 }
4498 4498
4499 4499 /*
4500 4500 * For the lower queue so that UDP can be a dummy mux.
4501 4501 * Nobody should be sending packets down this stream.
4502 4502 */
4503 4503 /* ARGSUSED */
4504 4504 void
4505 4505 udp_lwput(queue_t *q, mblk_t *mp)
4506 4506 {
4507 4507 freemsg(mp);
4508 4508 }
4509 4509
4510 4510 /*
4511 4511 * When a CPU is added, we need to allocate the per CPU stats struct.
4512 4512 */
4513 4513 void
4514 4514 udp_stack_cpu_add(udp_stack_t *us, processorid_t cpu_seqid)
4515 4515 {
4516 4516 int i;
4517 4517
4518 4518 if (cpu_seqid < us->us_sc_cnt)
4519 4519 return;
4520 4520 for (i = us->us_sc_cnt; i <= cpu_seqid; i++) {
4521 4521 ASSERT(us->us_sc[i] == NULL);
4522 4522 us->us_sc[i] = kmem_zalloc(sizeof (udp_stats_cpu_t),
4523 4523 KM_SLEEP);
4524 4524 }
4525 4525 membar_producer();
4526 4526 us->us_sc_cnt = cpu_seqid + 1;
4527 4527 }
4528 4528
4529 4529 /*
4530 4530 * Below routines for UDP socket module.
4531 4531 */
4532 4532
4533 4533 static conn_t *
4534 4534 udp_do_open(cred_t *credp, boolean_t isv6, int flags, int *errorp)
4535 4535 {
4536 4536 udp_t *udp;
4537 4537 conn_t *connp;
4538 4538 zoneid_t zoneid;
4539 4539 netstack_t *ns;
4540 4540 udp_stack_t *us;
4541 4541 int len;
4542 4542
4543 4543 ASSERT(errorp != NULL);
4544 4544
4545 4545 if ((*errorp = secpolicy_basic_net_access(credp)) != 0)
4546 4546 return (NULL);
4547 4547
4548 4548 ns = netstack_find_by_cred(credp);
4549 4549 ASSERT(ns != NULL);
4550 4550 us = ns->netstack_udp;
4551 4551 ASSERT(us != NULL);
4552 4552
4553 4553 /*
4554 4554 * For exclusive stacks we set the zoneid to zero
4555 4555 * to make UDP operate as if in the global zone.
4556 4556 */
4557 4557 if (ns->netstack_stackid != GLOBAL_NETSTACKID)
4558 4558 zoneid = GLOBAL_ZONEID;
4559 4559 else
4560 4560 zoneid = crgetzoneid(credp);
4561 4561
4562 4562 ASSERT(flags == KM_SLEEP || flags == KM_NOSLEEP);
4563 4563
4564 4564 connp = ipcl_conn_create(IPCL_UDPCONN, flags, ns);
4565 4565 if (connp == NULL) {
4566 4566 netstack_rele(ns);
4567 4567 *errorp = ENOMEM;
4568 4568 return (NULL);
4569 4569 }
4570 4570 udp = connp->conn_udp;
4571 4571
4572 4572 /*
4573 4573 * ipcl_conn_create did a netstack_hold. Undo the hold that was
4574 4574 * done by netstack_find_by_cred()
4575 4575 */
4576 4576 netstack_rele(ns);
4577 4577
4578 4578 /*
4579 4579 * Since this conn_t/udp_t is not yet visible to anybody else we don't
4580 4580 * need to lock anything.
4581 4581 */
4582 4582 ASSERT(connp->conn_proto == IPPROTO_UDP);
4583 4583 ASSERT(connp->conn_udp == udp);
4584 4584 ASSERT(udp->udp_connp == connp);
4585 4585
4586 4586 /* Set the initial state of the stream and the privilege status. */
4587 4587 udp->udp_state = TS_UNBND;
4588 4588 connp->conn_ixa->ixa_flags |= IXAF_VERIFY_SOURCE;
4589 4589 if (isv6) {
4590 4590 connp->conn_family = AF_INET6;
4591 4591 connp->conn_ipversion = IPV6_VERSION;
4592 4592 connp->conn_ixa->ixa_flags &= ~IXAF_IS_IPV4;
4593 4593 connp->conn_default_ttl = us->us_ipv6_hoplimit;
4594 4594 len = sizeof (ip6_t) + UDPH_SIZE;
4595 4595 } else {
4596 4596 connp->conn_family = AF_INET;
4597 4597 connp->conn_ipversion = IPV4_VERSION;
4598 4598 connp->conn_ixa->ixa_flags |= IXAF_IS_IPV4;
4599 4599 connp->conn_default_ttl = us->us_ipv4_ttl;
4600 4600 len = sizeof (ipha_t) + UDPH_SIZE;
4601 4601 }
4602 4602
4603 4603 ASSERT(connp->conn_ixa->ixa_protocol == connp->conn_proto);
4604 4604 connp->conn_xmit_ipp.ipp_unicast_hops = connp->conn_default_ttl;
4605 4605
4606 4606 connp->conn_ixa->ixa_multicast_ttl = IP_DEFAULT_MULTICAST_TTL;
4607 4607 connp->conn_ixa->ixa_flags |= IXAF_MULTICAST_LOOP | IXAF_SET_ULP_CKSUM;
4608 4608 /* conn_allzones can not be set this early, hence no IPCL_ZONEID */
4609 4609 connp->conn_ixa->ixa_zoneid = zoneid;
4610 4610
4611 4611 connp->conn_zoneid = zoneid;
4612 4612
4613 4613 /*
4614 4614 * If the caller has the process-wide flag set, then default to MAC
4615 4615 * exempt mode. This allows read-down to unlabeled hosts.
4616 4616 */
4617 4617 if (getpflags(NET_MAC_AWARE, credp) != 0)
4618 4618 connp->conn_mac_mode = CONN_MAC_AWARE;
4619 4619
4620 4620 connp->conn_zone_is_global = (crgetzoneid(credp) == GLOBAL_ZONEID);
4621 4621
4622 4622 udp->udp_us = us;
4623 4623
4624 4624 connp->conn_rcvbuf = us->us_recv_hiwat;
4625 4625 connp->conn_sndbuf = us->us_xmit_hiwat;
4626 4626 connp->conn_sndlowat = us->us_xmit_lowat;
4627 4627 connp->conn_rcvlowat = udp_mod_info.mi_lowat;
4628 4628
4629 4629 connp->conn_wroff = len + us->us_wroff_extra;
4630 4630 connp->conn_so_type = SOCK_DGRAM;
4631 4631
4632 4632 connp->conn_recv = udp_input;
4633 4633 connp->conn_recvicmp = udp_icmp_input;
4634 4634 crhold(credp);
4635 4635 connp->conn_cred = credp;
4636 4636 connp->conn_cpid = curproc->p_pid;
4637 4637 connp->conn_open_time = ddi_get_lbolt64();
4638 4638 /* Cache things in ixa without an extra refhold */
4639 4639 ASSERT(!(connp->conn_ixa->ixa_free_flags & IXA_FREE_CRED));
4640 4640 connp->conn_ixa->ixa_cred = connp->conn_cred;
4641 4641 connp->conn_ixa->ixa_cpid = connp->conn_cpid;
4642 4642 if (is_system_labeled())
4643 4643 connp->conn_ixa->ixa_tsl = crgetlabel(connp->conn_cred);
4644 4644
4645 4645 *((sin6_t *)&udp->udp_delayed_addr) = sin6_null;
4646 4646
4647 4647 if (us->us_pmtu_discovery)
4648 4648 connp->conn_ixa->ixa_flags |= IXAF_PMTU_DISCOVERY;
4649 4649
4650 4650 return (connp);
4651 4651 }
4652 4652
4653 4653 sock_lower_handle_t
4654 4654 udp_create(int family, int type, int proto, sock_downcalls_t **sock_downcalls,
4655 4655 uint_t *smodep, int *errorp, int flags, cred_t *credp)
4656 4656 {
4657 4657 udp_t *udp = NULL;
4658 4658 udp_stack_t *us;
4659 4659 conn_t *connp;
4660 4660 boolean_t isv6;
4661 4661
4662 4662 if (type != SOCK_DGRAM || (family != AF_INET && family != AF_INET6) ||
4663 4663 (proto != 0 && proto != IPPROTO_UDP)) {
4664 4664 *errorp = EPROTONOSUPPORT;
4665 4665 return (NULL);
4666 4666 }
4667 4667
4668 4668 if (family == AF_INET6)
4669 4669 isv6 = B_TRUE;
4670 4670 else
4671 4671 isv6 = B_FALSE;
4672 4672
4673 4673 connp = udp_do_open(credp, isv6, flags, errorp);
4674 4674 if (connp == NULL)
4675 4675 return (NULL);
4676 4676
4677 4677 udp = connp->conn_udp;
4678 4678 ASSERT(udp != NULL);
4679 4679 us = udp->udp_us;
4680 4680 ASSERT(us != NULL);
4681 4681
4682 4682 udp->udp_issocket = B_TRUE;
4683 4683 connp->conn_flags |= IPCL_NONSTR;
4684 4684
4685 4685 /*
4686 4686 * Set flow control
4687 4687 * Since this conn_t/udp_t is not yet visible to anybody else we don't
4688 4688 * need to lock anything.
4689 4689 */
4690 4690 (void) udp_set_rcv_hiwat(udp, connp->conn_rcvbuf);
4691 4691 udp->udp_rcv_disply_hiwat = connp->conn_rcvbuf;
4692 4692
4693 4693 connp->conn_flow_cntrld = B_FALSE;
4694 4694
4695 4695 mutex_enter(&connp->conn_lock);
4696 4696 connp->conn_state_flags &= ~CONN_INCIPIENT;
4697 4697 mutex_exit(&connp->conn_lock);
4698 4698
4699 4699 *errorp = 0;
4700 4700 *smodep = SM_ATOMIC;
4701 4701 *sock_downcalls = &sock_udp_downcalls;
4702 4702 return ((sock_lower_handle_t)connp);
4703 4703 }
4704 4704
4705 4705 /* ARGSUSED3 */
4706 4706 void
4707 4707 udp_activate(sock_lower_handle_t proto_handle, sock_upper_handle_t sock_handle,
4708 4708 sock_upcalls_t *sock_upcalls, int flags, cred_t *cr)
4709 4709 {
4710 4710 conn_t *connp = (conn_t *)proto_handle;
4711 4711 struct sock_proto_props sopp;
4712 4712
4713 4713 /* All Solaris components should pass a cred for this operation. */
4714 4714 ASSERT(cr != NULL);
4715 4715
4716 4716 connp->conn_upcalls = sock_upcalls;
4717 4717 connp->conn_upper_handle = sock_handle;
4718 4718
4719 4719 sopp.sopp_flags = SOCKOPT_WROFF | SOCKOPT_RCVHIWAT | SOCKOPT_RCVLOWAT |
4720 4720 SOCKOPT_MAXBLK | SOCKOPT_MAXPSZ | SOCKOPT_MINPSZ;
4721 4721 sopp.sopp_wroff = connp->conn_wroff;
4722 4722 sopp.sopp_maxblk = INFPSZ;
4723 4723 sopp.sopp_rxhiwat = connp->conn_rcvbuf;
4724 4724 sopp.sopp_rxlowat = connp->conn_rcvlowat;
4725 4725 sopp.sopp_maxaddrlen = sizeof (sin6_t);
4726 4726 sopp.sopp_maxpsz =
4727 4727 (connp->conn_family == AF_INET) ? UDP_MAXPACKET_IPV4 :
4728 4728 UDP_MAXPACKET_IPV6;
4729 4729 sopp.sopp_minpsz = (udp_mod_info.mi_minpsz == 1) ? 0 :
4730 4730 udp_mod_info.mi_minpsz;
4731 4731
4732 4732 (*connp->conn_upcalls->su_set_proto_props)(connp->conn_upper_handle,
4733 4733 &sopp);
4734 4734 }
4735 4735
4736 4736 static void
4737 4737 udp_do_close(conn_t *connp)
4738 4738 {
4739 4739 udp_t *udp;
4740 4740
4741 4741 ASSERT(connp != NULL && IPCL_IS_UDP(connp));
4742 4742 udp = connp->conn_udp;
4743 4743
4744 4744 if (cl_inet_unbind != NULL && udp->udp_state == TS_IDLE) {
4745 4745 /*
4746 4746 * Running in cluster mode - register unbind information
4747 4747 */
4748 4748 if (connp->conn_ipversion == IPV4_VERSION) {
4749 4749 (*cl_inet_unbind)(
4750 4750 connp->conn_netstack->netstack_stackid,
4751 4751 IPPROTO_UDP, AF_INET,
4752 4752 (uint8_t *)(&V4_PART_OF_V6(connp->conn_laddr_v6)),
4753 4753 (in_port_t)connp->conn_lport, NULL);
4754 4754 } else {
4755 4755 (*cl_inet_unbind)(
4756 4756 connp->conn_netstack->netstack_stackid,
4757 4757 IPPROTO_UDP, AF_INET6,
4758 4758 (uint8_t *)&(connp->conn_laddr_v6),
4759 4759 (in_port_t)connp->conn_lport, NULL);
4760 4760 }
4761 4761 }
4762 4762
4763 4763 udp_bind_hash_remove(udp, B_FALSE);
4764 4764
4765 4765 ip_quiesce_conn(connp);
4766 4766
4767 4767 if (!IPCL_IS_NONSTR(connp)) {
4768 4768 ASSERT(connp->conn_wq != NULL);
4769 4769 ASSERT(connp->conn_rq != NULL);
4770 4770 qprocsoff(connp->conn_rq);
4771 4771 }
4772 4772
4773 4773 udp_close_free(connp);
4774 4774
4775 4775 /*
4776 4776 * Now we are truly single threaded on this stream, and can
4777 4777 * delete the things hanging off the connp, and finally the connp.
4778 4778 * We removed this connp from the fanout list, it cannot be
4779 4779 * accessed thru the fanouts, and we already waited for the
4780 4780 * conn_ref to drop to 0. We are already in close, so
4781 4781 * there cannot be any other thread from the top. qprocsoff
4782 4782 * has completed, and service has completed or won't run in
4783 4783 * future.
4784 4784 */
4785 4785 ASSERT(connp->conn_ref == 1);
4786 4786
4787 4787 if (!IPCL_IS_NONSTR(connp)) {
4788 4788 inet_minor_free(connp->conn_minor_arena, connp->conn_dev);
4789 4789 } else {
4790 4790 ip_free_helper_stream(connp);
4791 4791 }
4792 4792
4793 4793 connp->conn_ref--;
4794 4794 ipcl_conn_destroy(connp);
4795 4795 }
4796 4796
4797 4797 /* ARGSUSED1 */
4798 4798 int
4799 4799 udp_close(sock_lower_handle_t proto_handle, int flags, cred_t *cr)
4800 4800 {
4801 4801 conn_t *connp = (conn_t *)proto_handle;
4802 4802
4803 4803 /* All Solaris components should pass a cred for this operation. */
4804 4804 ASSERT(cr != NULL);
4805 4805
4806 4806 udp_do_close(connp);
4807 4807 return (0);
4808 4808 }
4809 4809
4810 4810 static int
4811 4811 udp_do_bind(conn_t *connp, struct sockaddr *sa, socklen_t len, cred_t *cr,
4812 4812 boolean_t bind_to_req_port_only)
4813 4813 {
4814 4814 sin_t *sin;
4815 4815 sin6_t *sin6;
4816 4816 udp_t *udp = connp->conn_udp;
4817 4817 int error = 0;
4818 4818 ip_laddr_t laddr_type = IPVL_UNICAST_UP; /* INADDR_ANY */
4819 4819 in_port_t port; /* Host byte order */
4820 4820 in_port_t requested_port; /* Host byte order */
4821 4821 int count;
4822 4822 ipaddr_t v4src; /* Set if AF_INET */
4823 4823 in6_addr_t v6src;
4824 4824 int loopmax;
4825 4825 udp_fanout_t *udpf;
4826 4826 in_port_t lport; /* Network byte order */
4827 4827 uint_t scopeid = 0;
4828 4828 zoneid_t zoneid = IPCL_ZONEID(connp);
4829 4829 ip_stack_t *ipst = connp->conn_netstack->netstack_ip;
4830 4830 boolean_t is_inaddr_any;
4831 4831 mlp_type_t addrtype, mlptype;
4832 4832 udp_stack_t *us = udp->udp_us;
4833 4833
4834 4834 switch (len) {
4835 4835 case sizeof (sin_t): /* Complete IPv4 address */
4836 4836 sin = (sin_t *)sa;
4837 4837
4838 4838 if (sin == NULL || !OK_32PTR((char *)sin))
4839 4839 return (EINVAL);
4840 4840
4841 4841 if (connp->conn_family != AF_INET ||
4842 4842 sin->sin_family != AF_INET) {
4843 4843 return (EAFNOSUPPORT);
4844 4844 }
4845 4845 v4src = sin->sin_addr.s_addr;
4846 4846 IN6_IPADDR_TO_V4MAPPED(v4src, &v6src);
4847 4847 if (v4src != INADDR_ANY) {
4848 4848 laddr_type = ip_laddr_verify_v4(v4src, zoneid, ipst,
4849 4849 B_TRUE);
4850 4850 }
4851 4851 port = ntohs(sin->sin_port);
4852 4852 break;
4853 4853
4854 4854 case sizeof (sin6_t): /* complete IPv6 address */
4855 4855 sin6 = (sin6_t *)sa;
4856 4856
4857 4857 if (sin6 == NULL || !OK_32PTR((char *)sin6))
4858 4858 return (EINVAL);
4859 4859
4860 4860 if (connp->conn_family != AF_INET6 ||
4861 4861 sin6->sin6_family != AF_INET6) {
4862 4862 return (EAFNOSUPPORT);
4863 4863 }
4864 4864 v6src = sin6->sin6_addr;
4865 4865 if (IN6_IS_ADDR_V4MAPPED(&v6src)) {
4866 4866 if (connp->conn_ipv6_v6only)
4867 4867 return (EADDRNOTAVAIL);
4868 4868
4869 4869 IN6_V4MAPPED_TO_IPADDR(&v6src, v4src);
4870 4870 if (v4src != INADDR_ANY) {
4871 4871 laddr_type = ip_laddr_verify_v4(v4src,
4872 4872 zoneid, ipst, B_FALSE);
4873 4873 }
4874 4874 } else {
4875 4875 if (!IN6_IS_ADDR_UNSPECIFIED(&v6src)) {
4876 4876 if (IN6_IS_ADDR_LINKSCOPE(&v6src))
4877 4877 scopeid = sin6->sin6_scope_id;
4878 4878 laddr_type = ip_laddr_verify_v6(&v6src,
4879 4879 zoneid, ipst, B_TRUE, scopeid);
4880 4880 }
4881 4881 }
4882 4882 port = ntohs(sin6->sin6_port);
4883 4883 break;
4884 4884
4885 4885 default: /* Invalid request */
4886 4886 (void) strlog(UDP_MOD_ID, 0, 1, SL_ERROR|SL_TRACE,
4887 4887 "udp_bind: bad ADDR_length length %u", len);
4888 4888 return (-TBADADDR);
4889 4889 }
4890 4890
4891 4891 /* Is the local address a valid unicast, multicast, or broadcast? */
4892 4892 if (laddr_type == IPVL_BAD)
4893 4893 return (EADDRNOTAVAIL);
4894 4894
4895 4895 requested_port = port;
4896 4896
4897 4897 if (requested_port == 0 || !bind_to_req_port_only)
4898 4898 bind_to_req_port_only = B_FALSE;
4899 4899 else /* T_BIND_REQ and requested_port != 0 */
4900 4900 bind_to_req_port_only = B_TRUE;
4901 4901
4902 4902 if (requested_port == 0) {
4903 4903 /*
4904 4904 * If the application passed in zero for the port number, it
4905 4905 * doesn't care which port number we bind to. Get one in the
4906 4906 * valid range.
4907 4907 */
4908 4908 if (connp->conn_anon_priv_bind) {
4909 4909 port = udp_get_next_priv_port(udp);
4910 4910 } else {
4911 4911 port = udp_update_next_port(udp,
4912 4912 us->us_next_port_to_try, B_TRUE);
4913 4913 }
4914 4914 } else {
4915 4915 /*
4916 4916 * If the port is in the well-known privileged range,
4917 4917 * make sure the caller was privileged.
4918 4918 */
4919 4919 int i;
4920 4920 boolean_t priv = B_FALSE;
4921 4921
4922 4922 if (port < us->us_smallest_nonpriv_port) {
4923 4923 priv = B_TRUE;
4924 4924 } else {
4925 4925 for (i = 0; i < us->us_num_epriv_ports; i++) {
4926 4926 if (port == us->us_epriv_ports[i]) {
4927 4927 priv = B_TRUE;
4928 4928 break;
4929 4929 }
4930 4930 }
4931 4931 }
4932 4932
4933 4933 if (priv) {
4934 4934 if (secpolicy_net_privaddr(cr, port, IPPROTO_UDP) != 0)
4935 4935 return (-TACCES);
4936 4936 }
4937 4937 }
4938 4938
4939 4939 if (port == 0)
4940 4940 return (-TNOADDR);
4941 4941
4942 4942 /*
4943 4943 * The state must be TS_UNBND. TPI mandates that users must send
4944 4944 * TPI primitives only 1 at a time and wait for the response before
4945 4945 * sending the next primitive.
4946 4946 */
4947 4947 mutex_enter(&connp->conn_lock);
4948 4948 if (udp->udp_state != TS_UNBND) {
4949 4949 mutex_exit(&connp->conn_lock);
4950 4950 (void) strlog(UDP_MOD_ID, 0, 1, SL_ERROR|SL_TRACE,
4951 4951 "udp_bind: bad state, %u", udp->udp_state);
4952 4952 return (-TOUTSTATE);
4953 4953 }
4954 4954 /*
4955 4955 * Copy the source address into our udp structure. This address
4956 4956 * may still be zero; if so, IP will fill in the correct address
4957 4957 * each time an outbound packet is passed to it. Since the udp is
4958 4958 * not yet in the bind hash list, we don't grab the uf_lock to
4959 4959 * change conn_ipversion
4960 4960 */
4961 4961 if (connp->conn_family == AF_INET) {
4962 4962 ASSERT(sin != NULL);
4963 4963 ASSERT(connp->conn_ixa->ixa_flags & IXAF_IS_IPV4);
4964 4964 } else {
4965 4965 if (IN6_IS_ADDR_V4MAPPED(&v6src)) {
4966 4966 /*
4967 4967 * no need to hold the uf_lock to set the conn_ipversion
4968 4968 * since we are not yet in the fanout list
4969 4969 */
4970 4970 connp->conn_ipversion = IPV4_VERSION;
4971 4971 connp->conn_ixa->ixa_flags |= IXAF_IS_IPV4;
4972 4972 } else {
4973 4973 connp->conn_ipversion = IPV6_VERSION;
4974 4974 connp->conn_ixa->ixa_flags &= ~IXAF_IS_IPV4;
4975 4975 }
4976 4976 }
4977 4977
4978 4978 /*
4979 4979 * If conn_reuseaddr is not set, then we have to make sure that
4980 4980 * the IP address and port number the application requested
4981 4981 * (or we selected for the application) is not being used by
4982 4982 * another stream. If another stream is already using the
4983 4983 * requested IP address and port, the behavior depends on
4984 4984 * "bind_to_req_port_only". If set the bind fails; otherwise we
4985 4985 * search for any an unused port to bind to the stream.
4986 4986 *
4987 4987 * As per the BSD semantics, as modified by the Deering multicast
4988 4988 * changes, if udp_reuseaddr is set, then we allow multiple binds
4989 4989 * to the same port independent of the local IP address.
4990 4990 *
4991 4991 * This is slightly different than in SunOS 4.X which did not
4992 4992 * support IP multicast. Note that the change implemented by the
4993 4993 * Deering multicast code effects all binds - not only binding
4994 4994 * to IP multicast addresses.
4995 4995 *
4996 4996 * Note that when binding to port zero we ignore SO_REUSEADDR in
4997 4997 * order to guarantee a unique port.
4998 4998 */
4999 4999
5000 5000 count = 0;
5001 5001 if (connp->conn_anon_priv_bind) {
5002 5002 /*
5003 5003 * loopmax = (IPPORT_RESERVED-1) -
5004 5004 * us->us_min_anonpriv_port + 1
5005 5005 */
5006 5006 loopmax = IPPORT_RESERVED - us->us_min_anonpriv_port;
5007 5007 } else {
5008 5008 loopmax = us->us_largest_anon_port -
5009 5009 us->us_smallest_anon_port + 1;
5010 5010 }
5011 5011
5012 5012 is_inaddr_any = V6_OR_V4_INADDR_ANY(v6src);
5013 5013
5014 5014 for (;;) {
5015 5015 udp_t *udp1;
5016 5016 boolean_t found_exclbind = B_FALSE;
5017 5017 conn_t *connp1;
5018 5018
5019 5019 /*
5020 5020 * Walk through the list of udp streams bound to
5021 5021 * requested port with the same IP address.
5022 5022 */
5023 5023 lport = htons(port);
5024 5024 udpf = &us->us_bind_fanout[UDP_BIND_HASH(lport,
5025 5025 us->us_bind_fanout_size)];
5026 5026 mutex_enter(&udpf->uf_lock);
5027 5027 for (udp1 = udpf->uf_udp; udp1 != NULL;
5028 5028 udp1 = udp1->udp_bind_hash) {
5029 5029 connp1 = udp1->udp_connp;
5030 5030
5031 5031 if (lport != connp1->conn_lport)
5032 5032 continue;
5033 5033
5034 5034 /*
5035 5035 * On a labeled system, we must treat bindings to ports
5036 5036 * on shared IP addresses by sockets with MAC exemption
5037 5037 * privilege as being in all zones, as there's
5038 5038 * otherwise no way to identify the right receiver.
5039 5039 */
5040 5040 if (!IPCL_BIND_ZONE_MATCH(connp1, connp))
5041 5041 continue;
5042 5042
5043 5043 /*
5044 5044 * If UDP_EXCLBIND is set for either the bound or
5045 5045 * binding endpoint, the semantics of bind
5046 5046 * is changed according to the following chart.
5047 5047 *
5048 5048 * spec = specified address (v4 or v6)
5049 5049 * unspec = unspecified address (v4 or v6)
5050 5050 * A = specified addresses are different for endpoints
5051 5051 *
5052 5052 * bound bind to allowed?
5053 5053 * -------------------------------------
5054 5054 * unspec unspec no
5055 5055 * unspec spec no
5056 5056 * spec unspec no
5057 5057 * spec spec yes if A
5058 5058 *
5059 5059 * For labeled systems, SO_MAC_EXEMPT behaves the same
5060 5060 * as UDP_EXCLBIND, except that zoneid is ignored.
5061 5061 */
5062 5062 if (connp1->conn_exclbind || connp->conn_exclbind ||
5063 5063 IPCL_CONNS_MAC(udp1->udp_connp, connp)) {
5064 5064 if (V6_OR_V4_INADDR_ANY(
5065 5065 connp1->conn_bound_addr_v6) ||
5066 5066 is_inaddr_any ||
5067 5067 IN6_ARE_ADDR_EQUAL(
5068 5068 &connp1->conn_bound_addr_v6,
5069 5069 &v6src)) {
5070 5070 found_exclbind = B_TRUE;
5071 5071 break;
5072 5072 }
5073 5073 continue;
5074 5074 }
5075 5075
5076 5076 /*
5077 5077 * Check ipversion to allow IPv4 and IPv6 sockets to
5078 5078 * have disjoint port number spaces.
5079 5079 */
5080 5080 if (connp->conn_ipversion != connp1->conn_ipversion) {
5081 5081
5082 5082 /*
5083 5083 * On the first time through the loop, if the
5084 5084 * the user intentionally specified a
5085 5085 * particular port number, then ignore any
5086 5086 * bindings of the other protocol that may
5087 5087 * conflict. This allows the user to bind IPv6
5088 5088 * alone and get both v4 and v6, or bind both
5089 5089 * both and get each seperately. On subsequent
5090 5090 * times through the loop, we're checking a
5091 5091 * port that we chose (not the user) and thus
5092 5092 * we do not allow casual duplicate bindings.
5093 5093 */
5094 5094 if (count == 0 && requested_port != 0)
5095 5095 continue;
5096 5096 }
5097 5097
5098 5098 /*
5099 5099 * No difference depending on SO_REUSEADDR.
5100 5100 *
5101 5101 * If existing port is bound to a
5102 5102 * non-wildcard IP address and
5103 5103 * the requesting stream is bound to
5104 5104 * a distinct different IP addresses
5105 5105 * (non-wildcard, also), keep going.
5106 5106 */
5107 5107 if (!is_inaddr_any &&
5108 5108 !V6_OR_V4_INADDR_ANY(connp1->conn_bound_addr_v6) &&
5109 5109 !IN6_ARE_ADDR_EQUAL(&connp1->conn_laddr_v6,
5110 5110 &v6src)) {
5111 5111 continue;
5112 5112 }
5113 5113 break;
5114 5114 }
5115 5115
5116 5116 if (!found_exclbind &&
5117 5117 (connp->conn_reuseaddr && requested_port != 0)) {
5118 5118 break;
5119 5119 }
5120 5120
5121 5121 if (udp1 == NULL) {
5122 5122 /*
5123 5123 * No other stream has this IP address
5124 5124 * and port number. We can use it.
5125 5125 */
5126 5126 break;
5127 5127 }
5128 5128 mutex_exit(&udpf->uf_lock);
5129 5129 if (bind_to_req_port_only) {
5130 5130 /*
5131 5131 * We get here only when requested port
5132 5132 * is bound (and only first of the for()
5133 5133 * loop iteration).
5134 5134 *
5135 5135 * The semantics of this bind request
5136 5136 * require it to fail so we return from
5137 5137 * the routine (and exit the loop).
5138 5138 *
5139 5139 */
5140 5140 mutex_exit(&connp->conn_lock);
5141 5141 return (-TADDRBUSY);
5142 5142 }
5143 5143
5144 5144 if (connp->conn_anon_priv_bind) {
5145 5145 port = udp_get_next_priv_port(udp);
5146 5146 } else {
5147 5147 if ((count == 0) && (requested_port != 0)) {
5148 5148 /*
5149 5149 * If the application wants us to find
5150 5150 * a port, get one to start with. Set
5151 5151 * requested_port to 0, so that we will
5152 5152 * update us->us_next_port_to_try below.
5153 5153 */
5154 5154 port = udp_update_next_port(udp,
5155 5155 us->us_next_port_to_try, B_TRUE);
5156 5156 requested_port = 0;
5157 5157 } else {
5158 5158 port = udp_update_next_port(udp, port + 1,
5159 5159 B_FALSE);
5160 5160 }
5161 5161 }
5162 5162
5163 5163 if (port == 0 || ++count >= loopmax) {
5164 5164 /*
5165 5165 * We've tried every possible port number and
5166 5166 * there are none available, so send an error
5167 5167 * to the user.
5168 5168 */
5169 5169 mutex_exit(&connp->conn_lock);
5170 5170 return (-TNOADDR);
5171 5171 }
5172 5172 }
5173 5173
5174 5174 /*
5175 5175 * Copy the source address into our udp structure. This address
5176 5176 * may still be zero; if so, ip_attr_connect will fill in the correct
5177 5177 * address when a packet is about to be sent.
5178 5178 * If we are binding to a broadcast or multicast address then
5179 5179 * we just set the conn_bound_addr since we don't want to use
5180 5180 * that as the source address when sending.
5181 5181 */
5182 5182 connp->conn_bound_addr_v6 = v6src;
5183 5183 connp->conn_laddr_v6 = v6src;
5184 5184 if (scopeid != 0) {
5185 5185 connp->conn_ixa->ixa_flags |= IXAF_SCOPEID_SET;
5186 5186 connp->conn_ixa->ixa_scopeid = scopeid;
5187 5187 connp->conn_incoming_ifindex = scopeid;
5188 5188 } else {
5189 5189 connp->conn_ixa->ixa_flags &= ~IXAF_SCOPEID_SET;
5190 5190 connp->conn_incoming_ifindex = connp->conn_bound_if;
5191 5191 }
5192 5192
5193 5193 switch (laddr_type) {
5194 5194 case IPVL_UNICAST_UP:
5195 5195 case IPVL_UNICAST_DOWN:
5196 5196 connp->conn_saddr_v6 = v6src;
5197 5197 connp->conn_mcbc_bind = B_FALSE;
5198 5198 break;
5199 5199 case IPVL_MCAST:
5200 5200 case IPVL_BCAST:
5201 5201 /* ip_set_destination will pick a source address later */
5202 5202 connp->conn_saddr_v6 = ipv6_all_zeros;
5203 5203 connp->conn_mcbc_bind = B_TRUE;
5204 5204 break;
5205 5205 }
5206 5206
5207 5207 /* Any errors after this point should use late_error */
5208 5208 connp->conn_lport = lport;
5209 5209
5210 5210 /*
5211 5211 * Now reset the next anonymous port if the application requested
5212 5212 * an anonymous port, or we handed out the next anonymous port.
5213 5213 */
5214 5214 if ((requested_port == 0) && (!connp->conn_anon_priv_bind)) {
5215 5215 us->us_next_port_to_try = port + 1;
5216 5216 }
5217 5217
5218 5218 /* Initialize the T_BIND_ACK. */
5219 5219 if (connp->conn_family == AF_INET) {
5220 5220 sin->sin_port = connp->conn_lport;
5221 5221 } else {
5222 5222 sin6->sin6_port = connp->conn_lport;
5223 5223 }
5224 5224 udp->udp_state = TS_IDLE;
5225 5225 udp_bind_hash_insert(udpf, udp);
5226 5226 mutex_exit(&udpf->uf_lock);
5227 5227 mutex_exit(&connp->conn_lock);
5228 5228
5229 5229 if (cl_inet_bind) {
5230 5230 /*
5231 5231 * Running in cluster mode - register bind information
5232 5232 */
5233 5233 if (connp->conn_ipversion == IPV4_VERSION) {
5234 5234 (*cl_inet_bind)(connp->conn_netstack->netstack_stackid,
5235 5235 IPPROTO_UDP, AF_INET, (uint8_t *)&v4src,
5236 5236 (in_port_t)connp->conn_lport, NULL);
5237 5237 } else {
5238 5238 (*cl_inet_bind)(connp->conn_netstack->netstack_stackid,
5239 5239 IPPROTO_UDP, AF_INET6, (uint8_t *)&v6src,
5240 5240 (in_port_t)connp->conn_lport, NULL);
5241 5241 }
5242 5242 }
5243 5243
5244 5244 mutex_enter(&connp->conn_lock);
5245 5245 connp->conn_anon_port = (is_system_labeled() && requested_port == 0);
5246 5246 if (is_system_labeled() && (!connp->conn_anon_port ||
5247 5247 connp->conn_anon_mlp)) {
5248 5248 uint16_t mlpport;
5249 5249 zone_t *zone;
5250 5250
5251 5251 zone = crgetzone(cr);
5252 5252 connp->conn_mlp_type =
5253 5253 connp->conn_recv_ancillary.crb_recvucred ? mlptBoth :
5254 5254 mlptSingle;
5255 5255 addrtype = tsol_mlp_addr_type(
5256 5256 connp->conn_allzones ? ALL_ZONES : zone->zone_id,
5257 5257 IPV6_VERSION, &v6src, us->us_netstack->netstack_ip);
5258 5258 if (addrtype == mlptSingle) {
5259 5259 error = -TNOADDR;
5260 5260 mutex_exit(&connp->conn_lock);
5261 5261 goto late_error;
5262 5262 }
5263 5263 mlpport = connp->conn_anon_port ? PMAPPORT : port;
5264 5264 mlptype = tsol_mlp_port_type(zone, IPPROTO_UDP, mlpport,
5265 5265 addrtype);
5266 5266
5267 5267 /*
5268 5268 * It is a coding error to attempt to bind an MLP port
5269 5269 * without first setting SOL_SOCKET/SCM_UCRED.
5270 5270 */
5271 5271 if (mlptype != mlptSingle &&
5272 5272 connp->conn_mlp_type == mlptSingle) {
5273 5273 error = EINVAL;
5274 5274 mutex_exit(&connp->conn_lock);
5275 5275 goto late_error;
5276 5276 }
5277 5277
5278 5278 /*
5279 5279 * It is an access violation to attempt to bind an MLP port
5280 5280 * without NET_BINDMLP privilege.
5281 5281 */
5282 5282 if (mlptype != mlptSingle &&
5283 5283 secpolicy_net_bindmlp(cr) != 0) {
5284 5284 if (connp->conn_debug) {
5285 5285 (void) strlog(UDP_MOD_ID, 0, 1,
5286 5286 SL_ERROR|SL_TRACE,
5287 5287 "udp_bind: no priv for multilevel port %d",
5288 5288 mlpport);
5289 5289 }
5290 5290 error = -TACCES;
5291 5291 mutex_exit(&connp->conn_lock);
5292 5292 goto late_error;
5293 5293 }
5294 5294
5295 5295 /*
5296 5296 * If we're specifically binding a shared IP address and the
5297 5297 * port is MLP on shared addresses, then check to see if this
5298 5298 * zone actually owns the MLP. Reject if not.
5299 5299 */
5300 5300 if (mlptype == mlptShared && addrtype == mlptShared) {
5301 5301 /*
5302 5302 * No need to handle exclusive-stack zones since
5303 5303 * ALL_ZONES only applies to the shared stack.
5304 5304 */
5305 5305 zoneid_t mlpzone;
5306 5306
5307 5307 mlpzone = tsol_mlp_findzone(IPPROTO_UDP,
5308 5308 htons(mlpport));
5309 5309 if (connp->conn_zoneid != mlpzone) {
5310 5310 if (connp->conn_debug) {
5311 5311 (void) strlog(UDP_MOD_ID, 0, 1,
5312 5312 SL_ERROR|SL_TRACE,
5313 5313 "udp_bind: attempt to bind port "
5314 5314 "%d on shared addr in zone %d "
5315 5315 "(should be %d)",
5316 5316 mlpport, connp->conn_zoneid,
5317 5317 mlpzone);
5318 5318 }
5319 5319 error = -TACCES;
5320 5320 mutex_exit(&connp->conn_lock);
5321 5321 goto late_error;
5322 5322 }
5323 5323 }
5324 5324 if (connp->conn_anon_port) {
5325 5325 error = tsol_mlp_anon(zone, mlptype, connp->conn_proto,
5326 5326 port, B_TRUE);
5327 5327 if (error != 0) {
5328 5328 if (connp->conn_debug) {
5329 5329 (void) strlog(UDP_MOD_ID, 0, 1,
5330 5330 SL_ERROR|SL_TRACE,
5331 5331 "udp_bind: cannot establish anon "
5332 5332 "MLP for port %d", port);
5333 5333 }
5334 5334 error = -TACCES;
5335 5335 mutex_exit(&connp->conn_lock);
5336 5336 goto late_error;
5337 5337 }
5338 5338 }
5339 5339 connp->conn_mlp_type = mlptype;
5340 5340 }
5341 5341
5342 5342 /*
5343 5343 * We create an initial header template here to make a subsequent
5344 5344 * sendto have a starting point. Since conn_last_dst is zero the
5345 5345 * first sendto will always follow the 'dst changed' code path.
5346 5346 * Note that we defer massaging options and the related checksum
5347 5347 * adjustment until we have a destination address.
5348 5348 */
5349 5349 error = udp_build_hdr_template(connp, &connp->conn_saddr_v6,
5350 5350 &connp->conn_faddr_v6, connp->conn_fport, connp->conn_flowinfo);
5351 5351 if (error != 0) {
5352 5352 mutex_exit(&connp->conn_lock);
5353 5353 goto late_error;
5354 5354 }
5355 5355 /* Just in case */
5356 5356 connp->conn_faddr_v6 = ipv6_all_zeros;
5357 5357 connp->conn_fport = 0;
5358 5358 connp->conn_v6lastdst = ipv6_all_zeros;
5359 5359 mutex_exit(&connp->conn_lock);
5360 5360
5361 5361 error = ip_laddr_fanout_insert(connp);
5362 5362 if (error != 0)
5363 5363 goto late_error;
5364 5364
5365 5365 /* Bind succeeded */
5366 5366 return (0);
5367 5367
5368 5368 late_error:
5369 5369 /* We had already picked the port number, and then the bind failed */
5370 5370 mutex_enter(&connp->conn_lock);
5371 5371 udpf = &us->us_bind_fanout[
5372 5372 UDP_BIND_HASH(connp->conn_lport,
5373 5373 us->us_bind_fanout_size)];
5374 5374 mutex_enter(&udpf->uf_lock);
5375 5375 connp->conn_saddr_v6 = ipv6_all_zeros;
5376 5376 connp->conn_bound_addr_v6 = ipv6_all_zeros;
5377 5377 connp->conn_laddr_v6 = ipv6_all_zeros;
5378 5378 if (scopeid != 0) {
5379 5379 connp->conn_ixa->ixa_flags &= ~IXAF_SCOPEID_SET;
5380 5380 connp->conn_incoming_ifindex = connp->conn_bound_if;
5381 5381 }
5382 5382 udp->udp_state = TS_UNBND;
5383 5383 udp_bind_hash_remove(udp, B_TRUE);
5384 5384 connp->conn_lport = 0;
5385 5385 mutex_exit(&udpf->uf_lock);
5386 5386 connp->conn_anon_port = B_FALSE;
5387 5387 connp->conn_mlp_type = mlptSingle;
5388 5388
5389 5389 connp->conn_v6lastdst = ipv6_all_zeros;
5390 5390
5391 5391 /* Restore the header that was built above - different source address */
5392 5392 (void) udp_build_hdr_template(connp, &connp->conn_saddr_v6,
5393 5393 &connp->conn_faddr_v6, connp->conn_fport, connp->conn_flowinfo);
5394 5394 mutex_exit(&connp->conn_lock);
5395 5395 return (error);
5396 5396 }
5397 5397
5398 5398 int
5399 5399 udp_bind(sock_lower_handle_t proto_handle, struct sockaddr *sa,
5400 5400 socklen_t len, cred_t *cr)
5401 5401 {
5402 5402 int error;
5403 5403 conn_t *connp;
5404 5404
5405 5405 /* All Solaris components should pass a cred for this operation. */
5406 5406 ASSERT(cr != NULL);
5407 5407
5408 5408 connp = (conn_t *)proto_handle;
5409 5409
5410 5410 if (sa == NULL)
5411 5411 error = udp_do_unbind(connp);
5412 5412 else
5413 5413 error = udp_do_bind(connp, sa, len, cr, B_TRUE);
5414 5414
5415 5415 if (error < 0) {
5416 5416 if (error == -TOUTSTATE)
5417 5417 error = EINVAL;
5418 5418 else
5419 5419 error = proto_tlitosyserr(-error);
5420 5420 }
5421 5421
5422 5422 return (error);
5423 5423 }
5424 5424
5425 5425 static int
5426 5426 udp_implicit_bind(conn_t *connp, cred_t *cr)
5427 5427 {
5428 5428 sin6_t sin6addr;
5429 5429 sin_t *sin;
5430 5430 sin6_t *sin6;
5431 5431 socklen_t len;
5432 5432 int error;
5433 5433
5434 5434 /* All Solaris components should pass a cred for this operation. */
5435 5435 ASSERT(cr != NULL);
5436 5436
5437 5437 if (connp->conn_family == AF_INET) {
5438 5438 len = sizeof (struct sockaddr_in);
5439 5439 sin = (sin_t *)&sin6addr;
5440 5440 *sin = sin_null;
5441 5441 sin->sin_family = AF_INET;
5442 5442 sin->sin_addr.s_addr = INADDR_ANY;
5443 5443 } else {
5444 5444 ASSERT(connp->conn_family == AF_INET6);
5445 5445 len = sizeof (sin6_t);
5446 5446 sin6 = (sin6_t *)&sin6addr;
5447 5447 *sin6 = sin6_null;
5448 5448 sin6->sin6_family = AF_INET6;
5449 5449 V6_SET_ZERO(sin6->sin6_addr);
5450 5450 }
5451 5451
5452 5452 error = udp_do_bind(connp, (struct sockaddr *)&sin6addr, len,
5453 5453 cr, B_FALSE);
5454 5454 return ((error < 0) ? proto_tlitosyserr(-error) : error);
5455 5455 }
5456 5456
5457 5457 /*
5458 5458 * This routine removes a port number association from a stream. It
5459 5459 * is called by udp_unbind and udp_tpi_unbind.
5460 5460 */
5461 5461 static int
5462 5462 udp_do_unbind(conn_t *connp)
5463 5463 {
5464 5464 udp_t *udp = connp->conn_udp;
5465 5465 udp_fanout_t *udpf;
5466 5466 udp_stack_t *us = udp->udp_us;
5467 5467
5468 5468 if (cl_inet_unbind != NULL) {
5469 5469 /*
5470 5470 * Running in cluster mode - register unbind information
5471 5471 */
5472 5472 if (connp->conn_ipversion == IPV4_VERSION) {
5473 5473 (*cl_inet_unbind)(
5474 5474 connp->conn_netstack->netstack_stackid,
5475 5475 IPPROTO_UDP, AF_INET,
5476 5476 (uint8_t *)(&V4_PART_OF_V6(connp->conn_laddr_v6)),
5477 5477 (in_port_t)connp->conn_lport, NULL);
5478 5478 } else {
5479 5479 (*cl_inet_unbind)(
5480 5480 connp->conn_netstack->netstack_stackid,
5481 5481 IPPROTO_UDP, AF_INET6,
5482 5482 (uint8_t *)&(connp->conn_laddr_v6),
5483 5483 (in_port_t)connp->conn_lport, NULL);
5484 5484 }
5485 5485 }
5486 5486
5487 5487 mutex_enter(&connp->conn_lock);
5488 5488 /* If a bind has not been done, we can't unbind. */
5489 5489 if (udp->udp_state == TS_UNBND) {
5490 5490 mutex_exit(&connp->conn_lock);
5491 5491 return (-TOUTSTATE);
5492 5492 }
5493 5493 udpf = &us->us_bind_fanout[UDP_BIND_HASH(connp->conn_lport,
5494 5494 us->us_bind_fanout_size)];
5495 5495 mutex_enter(&udpf->uf_lock);
5496 5496 udp_bind_hash_remove(udp, B_TRUE);
5497 5497 connp->conn_saddr_v6 = ipv6_all_zeros;
5498 5498 connp->conn_bound_addr_v6 = ipv6_all_zeros;
5499 5499 connp->conn_laddr_v6 = ipv6_all_zeros;
5500 5500 connp->conn_mcbc_bind = B_FALSE;
5501 5501 connp->conn_lport = 0;
5502 5502 /* In case we were also connected */
5503 5503 connp->conn_faddr_v6 = ipv6_all_zeros;
5504 5504 connp->conn_fport = 0;
5505 5505 mutex_exit(&udpf->uf_lock);
5506 5506
5507 5507 connp->conn_v6lastdst = ipv6_all_zeros;
5508 5508 udp->udp_state = TS_UNBND;
5509 5509
5510 5510 (void) udp_build_hdr_template(connp, &connp->conn_saddr_v6,
5511 5511 &connp->conn_faddr_v6, connp->conn_fport, connp->conn_flowinfo);
5512 5512 mutex_exit(&connp->conn_lock);
5513 5513
5514 5514 ip_unbind(connp);
5515 5515
5516 5516 return (0);
5517 5517 }
5518 5518
5519 5519 /*
5520 5520 * It associates a default destination address with the stream.
5521 5521 */
5522 5522 static int
5523 5523 udp_do_connect(conn_t *connp, const struct sockaddr *sa, socklen_t len,
5524 5524 cred_t *cr, pid_t pid)
5525 5525 {
5526 5526 sin6_t *sin6;
5527 5527 sin_t *sin;
5528 5528 in6_addr_t v6dst;
5529 5529 ipaddr_t v4dst;
5530 5530 uint16_t dstport;
5531 5531 uint32_t flowinfo;
5532 5532 udp_fanout_t *udpf;
5533 5533 udp_t *udp, *udp1;
5534 5534 ushort_t ipversion;
5535 5535 udp_stack_t *us;
5536 5536 int error;
5537 5537 conn_t *connp1;
5538 5538 ip_xmit_attr_t *ixa;
5539 5539 ip_xmit_attr_t *oldixa;
5540 5540 uint_t scopeid = 0;
5541 5541 uint_t srcid = 0;
5542 5542 in6_addr_t v6src = connp->conn_saddr_v6;
5543 5543 boolean_t v4mapped;
5544 5544
5545 5545 udp = connp->conn_udp;
5546 5546 us = udp->udp_us;
5547 5547
5548 5548 /*
5549 5549 * Address has been verified by the caller
5550 5550 */
5551 5551 switch (len) {
5552 5552 default:
5553 5553 /*
5554 5554 * Should never happen
5555 5555 */
5556 5556 return (EINVAL);
5557 5557
5558 5558 case sizeof (sin_t):
5559 5559 sin = (sin_t *)sa;
5560 5560 v4dst = sin->sin_addr.s_addr;
5561 5561 dstport = sin->sin_port;
5562 5562 IN6_IPADDR_TO_V4MAPPED(v4dst, &v6dst);
5563 5563 ASSERT(connp->conn_ipversion == IPV4_VERSION);
|
↓ open down ↓ |
1796 lines elided |
↑ open up ↑ |
5564 5564 ipversion = IPV4_VERSION;
5565 5565 break;
5566 5566
5567 5567 case sizeof (sin6_t):
5568 5568 sin6 = (sin6_t *)sa;
5569 5569 v6dst = sin6->sin6_addr;
5570 5570 dstport = sin6->sin6_port;
5571 5571 srcid = sin6->__sin6_src_id;
5572 5572 v4mapped = IN6_IS_ADDR_V4MAPPED(&v6dst);
5573 5573 if (srcid != 0 && IN6_IS_ADDR_UNSPECIFIED(&v6src)) {
5574 - if (ip_srcid_find_id(srcid, &v6src, IPCL_ZONEID(connp),
5574 + if (!ip_srcid_find_id(srcid, &v6src, IPCL_ZONEID(connp),
5575 5575 v4mapped, connp->conn_netstack)) {
5576 5576 /* Mismatch v4mapped/v6 specified by srcid. */
5577 5577 return (EADDRNOTAVAIL);
5578 5578 }
5579 5579 }
5580 5580 if (v4mapped) {
5581 5581 if (connp->conn_ipv6_v6only)
5582 5582 return (EADDRNOTAVAIL);
5583 5583
5584 5584 /*
5585 5585 * Destination adress is mapped IPv6 address.
5586 5586 * Source bound address should be unspecified or
5587 5587 * IPv6 mapped address as well.
5588 5588 */
5589 5589 if (!IN6_IS_ADDR_UNSPECIFIED(
5590 5590 &connp->conn_bound_addr_v6) &&
5591 5591 !IN6_IS_ADDR_V4MAPPED(&connp->conn_bound_addr_v6)) {
5592 5592 return (EADDRNOTAVAIL);
5593 5593 }
5594 5594 IN6_V4MAPPED_TO_IPADDR(&v6dst, v4dst);
5595 5595 ipversion = IPV4_VERSION;
5596 5596 flowinfo = 0;
5597 5597 } else {
5598 5598 ipversion = IPV6_VERSION;
5599 5599 flowinfo = sin6->sin6_flowinfo;
5600 5600 if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr))
5601 5601 scopeid = sin6->sin6_scope_id;
5602 5602 }
5603 5603 break;
5604 5604 }
5605 5605
5606 5606 if (dstport == 0)
5607 5607 return (-TBADADDR);
5608 5608
5609 5609 /*
5610 5610 * If there is a different thread using conn_ixa then we get a new
5611 5611 * copy and cut the old one loose from conn_ixa. Otherwise we use
5612 5612 * conn_ixa and prevent any other thread from using/changing it.
5613 5613 * Once connect() is done other threads can use conn_ixa since the
5614 5614 * refcnt will be back at one.
5615 5615 * We defer updating conn_ixa until later to handle any concurrent
5616 5616 * conn_ixa_cleanup thread.
5617 5617 */
5618 5618 ixa = conn_get_ixa(connp, B_FALSE);
5619 5619 if (ixa == NULL)
5620 5620 return (ENOMEM);
5621 5621
5622 5622 mutex_enter(&connp->conn_lock);
5623 5623 /*
5624 5624 * This udp_t must have bound to a port already before doing a connect.
5625 5625 * Reject if a connect is in progress (we drop conn_lock during
5626 5626 * udp_do_connect).
5627 5627 */
5628 5628 if (udp->udp_state == TS_UNBND || udp->udp_state == TS_WCON_CREQ) {
5629 5629 mutex_exit(&connp->conn_lock);
5630 5630 (void) strlog(UDP_MOD_ID, 0, 1, SL_ERROR|SL_TRACE,
5631 5631 "udp_connect: bad state, %u", udp->udp_state);
5632 5632 ixa_refrele(ixa);
5633 5633 return (-TOUTSTATE);
5634 5634 }
5635 5635 ASSERT(connp->conn_lport != 0 && udp->udp_ptpbhn != NULL);
5636 5636
5637 5637 udpf = &us->us_bind_fanout[UDP_BIND_HASH(connp->conn_lport,
5638 5638 us->us_bind_fanout_size)];
5639 5639
5640 5640 mutex_enter(&udpf->uf_lock);
5641 5641 if (udp->udp_state == TS_DATA_XFER) {
5642 5642 /* Already connected - clear out state */
5643 5643 if (connp->conn_mcbc_bind)
5644 5644 connp->conn_saddr_v6 = ipv6_all_zeros;
5645 5645 else
5646 5646 connp->conn_saddr_v6 = connp->conn_bound_addr_v6;
5647 5647 connp->conn_laddr_v6 = connp->conn_bound_addr_v6;
5648 5648 connp->conn_faddr_v6 = ipv6_all_zeros;
5649 5649 connp->conn_fport = 0;
5650 5650 udp->udp_state = TS_IDLE;
5651 5651 }
5652 5652
5653 5653 connp->conn_fport = dstport;
5654 5654 connp->conn_ipversion = ipversion;
5655 5655 if (ipversion == IPV4_VERSION) {
5656 5656 /*
5657 5657 * Interpret a zero destination to mean loopback.
5658 5658 * Update the T_CONN_REQ (sin/sin6) since it is used to
5659 5659 * generate the T_CONN_CON.
5660 5660 */
5661 5661 if (v4dst == INADDR_ANY) {
5662 5662 v4dst = htonl(INADDR_LOOPBACK);
5663 5663 IN6_IPADDR_TO_V4MAPPED(v4dst, &v6dst);
5664 5664 if (connp->conn_family == AF_INET) {
5665 5665 sin->sin_addr.s_addr = v4dst;
5666 5666 } else {
5667 5667 sin6->sin6_addr = v6dst;
5668 5668 }
5669 5669 }
5670 5670 connp->conn_faddr_v6 = v6dst;
5671 5671 connp->conn_flowinfo = 0;
5672 5672 } else {
5673 5673 ASSERT(connp->conn_ipversion == IPV6_VERSION);
5674 5674 /*
5675 5675 * Interpret a zero destination to mean loopback.
5676 5676 * Update the T_CONN_REQ (sin/sin6) since it is used to
5677 5677 * generate the T_CONN_CON.
5678 5678 */
5679 5679 if (IN6_IS_ADDR_UNSPECIFIED(&v6dst)) {
5680 5680 v6dst = ipv6_loopback;
5681 5681 sin6->sin6_addr = v6dst;
5682 5682 }
5683 5683 connp->conn_faddr_v6 = v6dst;
5684 5684 connp->conn_flowinfo = flowinfo;
5685 5685 }
5686 5686 mutex_exit(&udpf->uf_lock);
5687 5687
5688 5688 /*
5689 5689 * We update our cred/cpid based on the caller of connect
5690 5690 */
5691 5691 if (connp->conn_cred != cr) {
5692 5692 crhold(cr);
5693 5693 crfree(connp->conn_cred);
5694 5694 connp->conn_cred = cr;
5695 5695 }
5696 5696 connp->conn_cpid = pid;
5697 5697 ASSERT(!(ixa->ixa_free_flags & IXA_FREE_CRED));
5698 5698 ixa->ixa_cred = cr;
5699 5699 ixa->ixa_cpid = pid;
5700 5700 if (is_system_labeled()) {
5701 5701 /* We need to restart with a label based on the cred */
5702 5702 ip_xmit_attr_restore_tsl(ixa, ixa->ixa_cred);
5703 5703 }
5704 5704
5705 5705 if (scopeid != 0) {
5706 5706 ixa->ixa_flags |= IXAF_SCOPEID_SET;
5707 5707 ixa->ixa_scopeid = scopeid;
5708 5708 connp->conn_incoming_ifindex = scopeid;
5709 5709 } else {
5710 5710 ixa->ixa_flags &= ~IXAF_SCOPEID_SET;
5711 5711 connp->conn_incoming_ifindex = connp->conn_bound_if;
5712 5712 }
5713 5713 /*
5714 5714 * conn_connect will drop conn_lock and reacquire it.
5715 5715 * To prevent a send* from messing with this udp_t while the lock
5716 5716 * is dropped we set udp_state and clear conn_v6lastdst.
5717 5717 * That will make all send* fail with EISCONN.
5718 5718 */
5719 5719 connp->conn_v6lastdst = ipv6_all_zeros;
5720 5720 udp->udp_state = TS_WCON_CREQ;
5721 5721
5722 5722 error = conn_connect(connp, NULL, IPDF_ALLOW_MCBC);
5723 5723 mutex_exit(&connp->conn_lock);
5724 5724 if (error != 0)
5725 5725 goto connect_failed;
5726 5726
5727 5727 /*
5728 5728 * The addresses have been verified. Time to insert in
5729 5729 * the correct fanout list.
5730 5730 */
5731 5731 error = ipcl_conn_insert(connp);
5732 5732 if (error != 0)
5733 5733 goto connect_failed;
5734 5734
5735 5735 mutex_enter(&connp->conn_lock);
5736 5736 error = udp_build_hdr_template(connp, &connp->conn_saddr_v6,
5737 5737 &connp->conn_faddr_v6, connp->conn_fport, connp->conn_flowinfo);
5738 5738 if (error != 0) {
5739 5739 mutex_exit(&connp->conn_lock);
5740 5740 goto connect_failed;
5741 5741 }
5742 5742
5743 5743 udp->udp_state = TS_DATA_XFER;
5744 5744 /* Record this as the "last" send even though we haven't sent any */
5745 5745 connp->conn_v6lastdst = connp->conn_faddr_v6;
5746 5746 connp->conn_lastipversion = connp->conn_ipversion;
5747 5747 connp->conn_lastdstport = connp->conn_fport;
5748 5748 connp->conn_lastflowinfo = connp->conn_flowinfo;
5749 5749 connp->conn_lastscopeid = scopeid;
5750 5750 connp->conn_lastsrcid = srcid;
5751 5751 /* Also remember a source to use together with lastdst */
5752 5752 connp->conn_v6lastsrc = v6src;
5753 5753
5754 5754 oldixa = conn_replace_ixa(connp, ixa);
5755 5755 mutex_exit(&connp->conn_lock);
5756 5756 ixa_refrele(oldixa);
5757 5757
5758 5758 /*
5759 5759 * We've picked a source address above. Now we can
5760 5760 * verify that the src/port/dst/port is unique for all
5761 5761 * connections in TS_DATA_XFER, skipping ourselves.
5762 5762 */
5763 5763 mutex_enter(&udpf->uf_lock);
5764 5764 for (udp1 = udpf->uf_udp; udp1 != NULL; udp1 = udp1->udp_bind_hash) {
5765 5765 if (udp1->udp_state != TS_DATA_XFER)
5766 5766 continue;
5767 5767
5768 5768 if (udp1 == udp)
5769 5769 continue;
5770 5770
5771 5771 connp1 = udp1->udp_connp;
5772 5772 if (connp->conn_lport != connp1->conn_lport ||
5773 5773 connp->conn_ipversion != connp1->conn_ipversion ||
5774 5774 dstport != connp1->conn_fport ||
5775 5775 !IN6_ARE_ADDR_EQUAL(&connp->conn_laddr_v6,
5776 5776 &connp1->conn_laddr_v6) ||
5777 5777 !IN6_ARE_ADDR_EQUAL(&v6dst, &connp1->conn_faddr_v6) ||
5778 5778 !(IPCL_ZONE_MATCH(connp, connp1->conn_zoneid) ||
5779 5779 IPCL_ZONE_MATCH(connp1, connp->conn_zoneid)))
5780 5780 continue;
5781 5781 mutex_exit(&udpf->uf_lock);
5782 5782 error = -TBADADDR;
5783 5783 goto connect_failed;
5784 5784 }
5785 5785 if (cl_inet_connect2 != NULL) {
5786 5786 CL_INET_UDP_CONNECT(connp, B_TRUE, &v6dst, dstport, error);
5787 5787 if (error != 0) {
5788 5788 mutex_exit(&udpf->uf_lock);
5789 5789 error = -TBADADDR;
5790 5790 goto connect_failed;
5791 5791 }
5792 5792 }
5793 5793 mutex_exit(&udpf->uf_lock);
5794 5794
5795 5795 ixa_refrele(ixa);
5796 5796 return (0);
5797 5797
5798 5798 connect_failed:
5799 5799 if (ixa != NULL)
5800 5800 ixa_refrele(ixa);
5801 5801 mutex_enter(&connp->conn_lock);
5802 5802 mutex_enter(&udpf->uf_lock);
5803 5803 udp->udp_state = TS_IDLE;
5804 5804 connp->conn_faddr_v6 = ipv6_all_zeros;
5805 5805 connp->conn_fport = 0;
5806 5806 /* In case the source address was set above */
5807 5807 if (connp->conn_mcbc_bind)
5808 5808 connp->conn_saddr_v6 = ipv6_all_zeros;
5809 5809 else
5810 5810 connp->conn_saddr_v6 = connp->conn_bound_addr_v6;
5811 5811 connp->conn_laddr_v6 = connp->conn_bound_addr_v6;
5812 5812 mutex_exit(&udpf->uf_lock);
5813 5813
5814 5814 connp->conn_v6lastdst = ipv6_all_zeros;
5815 5815 connp->conn_flowinfo = 0;
5816 5816
5817 5817 (void) udp_build_hdr_template(connp, &connp->conn_saddr_v6,
5818 5818 &connp->conn_faddr_v6, connp->conn_fport, connp->conn_flowinfo);
5819 5819 mutex_exit(&connp->conn_lock);
5820 5820 return (error);
5821 5821 }
5822 5822
5823 5823 static int
5824 5824 udp_connect(sock_lower_handle_t proto_handle, const struct sockaddr *sa,
5825 5825 socklen_t len, sock_connid_t *id, cred_t *cr)
5826 5826 {
5827 5827 conn_t *connp = (conn_t *)proto_handle;
5828 5828 udp_t *udp = connp->conn_udp;
5829 5829 int error;
5830 5830 boolean_t did_bind = B_FALSE;
5831 5831 pid_t pid = curproc->p_pid;
5832 5832
5833 5833 /* All Solaris components should pass a cred for this operation. */
5834 5834 ASSERT(cr != NULL);
5835 5835
5836 5836 if (sa == NULL) {
5837 5837 /*
5838 5838 * Disconnect
5839 5839 * Make sure we are connected
5840 5840 */
5841 5841 if (udp->udp_state != TS_DATA_XFER)
5842 5842 return (EINVAL);
5843 5843
5844 5844 error = udp_disconnect(connp);
5845 5845 return (error);
5846 5846 }
5847 5847
5848 5848 error = proto_verify_ip_addr(connp->conn_family, sa, len);
5849 5849 if (error != 0)
5850 5850 goto done;
5851 5851
5852 5852 /* do an implicit bind if necessary */
5853 5853 if (udp->udp_state == TS_UNBND) {
5854 5854 error = udp_implicit_bind(connp, cr);
5855 5855 /*
5856 5856 * We could be racing with an actual bind, in which case
5857 5857 * we would see EPROTO. We cross our fingers and try
5858 5858 * to connect.
5859 5859 */
5860 5860 if (!(error == 0 || error == EPROTO))
5861 5861 goto done;
5862 5862 did_bind = B_TRUE;
5863 5863 }
5864 5864 /*
5865 5865 * set SO_DGRAM_ERRIND
5866 5866 */
5867 5867 connp->conn_dgram_errind = B_TRUE;
5868 5868
5869 5869 error = udp_do_connect(connp, sa, len, cr, pid);
5870 5870
5871 5871 if (error != 0 && did_bind) {
5872 5872 int unbind_err;
5873 5873
5874 5874 unbind_err = udp_do_unbind(connp);
5875 5875 ASSERT(unbind_err == 0);
5876 5876 }
5877 5877
5878 5878 if (error == 0) {
5879 5879 *id = 0;
5880 5880 (*connp->conn_upcalls->su_connected)
5881 5881 (connp->conn_upper_handle, 0, NULL, -1);
5882 5882 } else if (error < 0) {
5883 5883 error = proto_tlitosyserr(-error);
5884 5884 }
5885 5885
5886 5886 done:
5887 5887 if (error != 0 && udp->udp_state == TS_DATA_XFER) {
5888 5888 /*
5889 5889 * No need to hold locks to set state
5890 5890 * after connect failure socket state is undefined
5891 5891 * We set the state only to imitate old sockfs behavior
5892 5892 */
5893 5893 udp->udp_state = TS_IDLE;
5894 5894 }
5895 5895 return (error);
5896 5896 }
5897 5897
5898 5898 int
5899 5899 udp_send(sock_lower_handle_t proto_handle, mblk_t *mp, struct nmsghdr *msg,
5900 5900 cred_t *cr)
5901 5901 {
5902 5902 sin6_t *sin6;
5903 5903 sin_t *sin = NULL;
5904 5904 uint_t srcid;
5905 5905 conn_t *connp = (conn_t *)proto_handle;
5906 5906 udp_t *udp = connp->conn_udp;
5907 5907 int error = 0;
5908 5908 udp_stack_t *us = udp->udp_us;
5909 5909 ushort_t ipversion;
5910 5910 pid_t pid = curproc->p_pid;
5911 5911 ip_xmit_attr_t *ixa;
5912 5912
5913 5913 ASSERT(DB_TYPE(mp) == M_DATA);
5914 5914
5915 5915 /* All Solaris components should pass a cred for this operation. */
5916 5916 ASSERT(cr != NULL);
5917 5917
5918 5918 /* do an implicit bind if necessary */
5919 5919 if (udp->udp_state == TS_UNBND) {
5920 5920 error = udp_implicit_bind(connp, cr);
5921 5921 /*
5922 5922 * We could be racing with an actual bind, in which case
5923 5923 * we would see EPROTO. We cross our fingers and try
5924 5924 * to connect.
5925 5925 */
5926 5926 if (!(error == 0 || error == EPROTO)) {
5927 5927 freemsg(mp);
5928 5928 return (error);
5929 5929 }
5930 5930 }
5931 5931
5932 5932 /* Connected? */
5933 5933 if (msg->msg_name == NULL) {
5934 5934 if (udp->udp_state != TS_DATA_XFER) {
5935 5935 UDPS_BUMP_MIB(us, udpOutErrors);
5936 5936 return (EDESTADDRREQ);
5937 5937 }
5938 5938 if (msg->msg_controllen != 0) {
5939 5939 error = udp_output_ancillary(connp, NULL, NULL, mp,
5940 5940 NULL, msg, cr, pid);
5941 5941 } else {
5942 5942 error = udp_output_connected(connp, mp, cr, pid);
5943 5943 }
5944 5944 if (us->us_sendto_ignerr)
5945 5945 return (0);
5946 5946 else
5947 5947 return (error);
5948 5948 }
5949 5949 if (udp->udp_state == TS_DATA_XFER) {
5950 5950 UDPS_BUMP_MIB(us, udpOutErrors);
5951 5951 return (EISCONN);
5952 5952 }
5953 5953 error = proto_verify_ip_addr(connp->conn_family,
5954 5954 (struct sockaddr *)msg->msg_name, msg->msg_namelen);
5955 5955 if (error != 0) {
5956 5956 UDPS_BUMP_MIB(us, udpOutErrors);
5957 5957 return (error);
5958 5958 }
5959 5959 switch (connp->conn_family) {
5960 5960 case AF_INET6:
5961 5961 sin6 = (sin6_t *)msg->msg_name;
5962 5962
5963 5963 srcid = sin6->__sin6_src_id;
5964 5964
5965 5965 if (!IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr)) {
5966 5966 /*
5967 5967 * Destination is a non-IPv4-compatible IPv6 address.
5968 5968 * Send out an IPv6 format packet.
5969 5969 */
5970 5970
5971 5971 /*
5972 5972 * If the local address is a mapped address return
5973 5973 * an error.
5974 5974 * It would be possible to send an IPv6 packet but the
5975 5975 * response would never make it back to the application
5976 5976 * since it is bound to a mapped address.
5977 5977 */
5978 5978 if (IN6_IS_ADDR_V4MAPPED(&connp->conn_saddr_v6)) {
5979 5979 UDPS_BUMP_MIB(us, udpOutErrors);
5980 5980 return (EADDRNOTAVAIL);
5981 5981 }
5982 5982 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr))
5983 5983 sin6->sin6_addr = ipv6_loopback;
5984 5984 ipversion = IPV6_VERSION;
5985 5985 } else {
5986 5986 if (connp->conn_ipv6_v6only) {
5987 5987 UDPS_BUMP_MIB(us, udpOutErrors);
5988 5988 return (EADDRNOTAVAIL);
5989 5989 }
5990 5990
5991 5991 /*
5992 5992 * If the local address is not zero or a mapped address
5993 5993 * return an error. It would be possible to send an
5994 5994 * IPv4 packet but the response would never make it
5995 5995 * back to the application since it is bound to a
5996 5996 * non-mapped address.
5997 5997 */
5998 5998 if (!IN6_IS_ADDR_V4MAPPED(&connp->conn_saddr_v6) &&
5999 5999 !IN6_IS_ADDR_UNSPECIFIED(&connp->conn_saddr_v6)) {
6000 6000 UDPS_BUMP_MIB(us, udpOutErrors);
6001 6001 return (EADDRNOTAVAIL);
6002 6002 }
6003 6003
6004 6004 if (V4_PART_OF_V6(sin6->sin6_addr) == INADDR_ANY) {
6005 6005 V4_PART_OF_V6(sin6->sin6_addr) =
6006 6006 htonl(INADDR_LOOPBACK);
6007 6007 }
6008 6008 ipversion = IPV4_VERSION;
6009 6009 }
6010 6010
6011 6011 /*
6012 6012 * We have to allocate an ip_xmit_attr_t before we grab
6013 6013 * conn_lock and we need to hold conn_lock once we've check
6014 6014 * conn_same_as_last_v6 to handle concurrent send* calls on a
6015 6015 * socket.
6016 6016 */
6017 6017 if (msg->msg_controllen == 0) {
6018 6018 ixa = conn_get_ixa(connp, B_FALSE);
6019 6019 if (ixa == NULL) {
6020 6020 UDPS_BUMP_MIB(us, udpOutErrors);
6021 6021 return (ENOMEM);
6022 6022 }
6023 6023 } else {
6024 6024 ixa = NULL;
6025 6025 }
6026 6026 mutex_enter(&connp->conn_lock);
6027 6027 if (udp->udp_delayed_error != 0) {
6028 6028 sin6_t *sin2 = (sin6_t *)&udp->udp_delayed_addr;
6029 6029
6030 6030 error = udp->udp_delayed_error;
6031 6031 udp->udp_delayed_error = 0;
6032 6032
6033 6033 /* Compare IP address, port, and family */
6034 6034
6035 6035 if (sin6->sin6_port == sin2->sin6_port &&
6036 6036 IN6_ARE_ADDR_EQUAL(&sin6->sin6_addr,
6037 6037 &sin2->sin6_addr) &&
6038 6038 sin6->sin6_family == sin2->sin6_family) {
6039 6039 mutex_exit(&connp->conn_lock);
6040 6040 UDPS_BUMP_MIB(us, udpOutErrors);
6041 6041 if (ixa != NULL)
6042 6042 ixa_refrele(ixa);
6043 6043 return (error);
6044 6044 }
6045 6045 }
6046 6046
6047 6047 if (msg->msg_controllen != 0) {
6048 6048 mutex_exit(&connp->conn_lock);
6049 6049 ASSERT(ixa == NULL);
6050 6050 error = udp_output_ancillary(connp, NULL, sin6, mp,
6051 6051 NULL, msg, cr, pid);
6052 6052 } else if (conn_same_as_last_v6(connp, sin6) &&
6053 6053 connp->conn_lastsrcid == srcid &&
6054 6054 ipsec_outbound_policy_current(ixa)) {
6055 6055 /* udp_output_lastdst drops conn_lock */
6056 6056 error = udp_output_lastdst(connp, mp, cr, pid, ixa);
6057 6057 } else {
6058 6058 /* udp_output_newdst drops conn_lock */
6059 6059 error = udp_output_newdst(connp, mp, NULL, sin6,
6060 6060 ipversion, cr, pid, ixa);
6061 6061 }
6062 6062 ASSERT(MUTEX_NOT_HELD(&connp->conn_lock));
6063 6063 if (us->us_sendto_ignerr)
6064 6064 return (0);
6065 6065 else
6066 6066 return (error);
6067 6067 case AF_INET:
6068 6068 sin = (sin_t *)msg->msg_name;
6069 6069
6070 6070 ipversion = IPV4_VERSION;
6071 6071
6072 6072 if (sin->sin_addr.s_addr == INADDR_ANY)
6073 6073 sin->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
6074 6074
6075 6075 /*
6076 6076 * We have to allocate an ip_xmit_attr_t before we grab
6077 6077 * conn_lock and we need to hold conn_lock once we've check
6078 6078 * conn_same_as_last_v6 to handle concurrent send* on a socket.
6079 6079 */
6080 6080 if (msg->msg_controllen == 0) {
6081 6081 ixa = conn_get_ixa(connp, B_FALSE);
6082 6082 if (ixa == NULL) {
6083 6083 UDPS_BUMP_MIB(us, udpOutErrors);
6084 6084 return (ENOMEM);
6085 6085 }
6086 6086 } else {
6087 6087 ixa = NULL;
6088 6088 }
6089 6089 mutex_enter(&connp->conn_lock);
6090 6090 if (udp->udp_delayed_error != 0) {
6091 6091 sin_t *sin2 = (sin_t *)&udp->udp_delayed_addr;
6092 6092
6093 6093 error = udp->udp_delayed_error;
6094 6094 udp->udp_delayed_error = 0;
6095 6095
6096 6096 /* Compare IP address and port */
6097 6097
6098 6098 if (sin->sin_port == sin2->sin_port &&
6099 6099 sin->sin_addr.s_addr == sin2->sin_addr.s_addr) {
6100 6100 mutex_exit(&connp->conn_lock);
6101 6101 UDPS_BUMP_MIB(us, udpOutErrors);
6102 6102 if (ixa != NULL)
6103 6103 ixa_refrele(ixa);
6104 6104 return (error);
6105 6105 }
6106 6106 }
6107 6107 if (msg->msg_controllen != 0) {
6108 6108 mutex_exit(&connp->conn_lock);
6109 6109 ASSERT(ixa == NULL);
6110 6110 error = udp_output_ancillary(connp, sin, NULL, mp,
6111 6111 NULL, msg, cr, pid);
6112 6112 } else if (conn_same_as_last_v4(connp, sin) &&
6113 6113 ipsec_outbound_policy_current(ixa)) {
6114 6114 /* udp_output_lastdst drops conn_lock */
6115 6115 error = udp_output_lastdst(connp, mp, cr, pid, ixa);
6116 6116 } else {
6117 6117 /* udp_output_newdst drops conn_lock */
6118 6118 error = udp_output_newdst(connp, mp, sin, NULL,
6119 6119 ipversion, cr, pid, ixa);
6120 6120 }
6121 6121 ASSERT(MUTEX_NOT_HELD(&connp->conn_lock));
6122 6122 if (us->us_sendto_ignerr)
6123 6123 return (0);
6124 6124 else
6125 6125 return (error);
6126 6126 default:
6127 6127 return (EINVAL);
6128 6128 }
6129 6129 }
6130 6130
6131 6131 int
6132 6132 udp_fallback(sock_lower_handle_t proto_handle, queue_t *q,
6133 6133 boolean_t issocket, so_proto_quiesced_cb_t quiesced_cb,
6134 6134 sock_quiesce_arg_t *arg)
6135 6135 {
6136 6136 conn_t *connp = (conn_t *)proto_handle;
6137 6137 udp_t *udp;
6138 6138 struct T_capability_ack tca;
6139 6139 struct sockaddr_in6 laddr, faddr;
6140 6140 socklen_t laddrlen, faddrlen;
6141 6141 short opts;
6142 6142 struct stroptions *stropt;
6143 6143 mblk_t *mp, *stropt_mp;
6144 6144 int error;
6145 6145
6146 6146 udp = connp->conn_udp;
6147 6147
6148 6148 stropt_mp = allocb_wait(sizeof (*stropt), BPRI_HI, STR_NOSIG, NULL);
6149 6149
6150 6150 /*
6151 6151 * setup the fallback stream that was allocated
6152 6152 */
6153 6153 connp->conn_dev = (dev_t)RD(q)->q_ptr;
6154 6154 connp->conn_minor_arena = WR(q)->q_ptr;
6155 6155
6156 6156 RD(q)->q_ptr = WR(q)->q_ptr = connp;
6157 6157
6158 6158 WR(q)->q_qinfo = &udp_winit;
6159 6159
6160 6160 connp->conn_rq = RD(q);
6161 6161 connp->conn_wq = WR(q);
6162 6162
6163 6163 /* Notify stream head about options before sending up data */
6164 6164 stropt_mp->b_datap->db_type = M_SETOPTS;
6165 6165 stropt_mp->b_wptr += sizeof (*stropt);
6166 6166 stropt = (struct stroptions *)stropt_mp->b_rptr;
6167 6167 stropt->so_flags = SO_WROFF | SO_HIWAT;
6168 6168 stropt->so_wroff = connp->conn_wroff;
6169 6169 stropt->so_hiwat = udp->udp_rcv_disply_hiwat;
6170 6170 putnext(RD(q), stropt_mp);
6171 6171
6172 6172 /*
6173 6173 * Free the helper stream
6174 6174 */
6175 6175 ip_free_helper_stream(connp);
6176 6176
6177 6177 if (!issocket)
6178 6178 udp_use_pure_tpi(udp);
6179 6179
6180 6180 /*
6181 6181 * Collect the information needed to sync with the sonode
6182 6182 */
6183 6183 udp_do_capability_ack(udp, &tca, TC1_INFO);
6184 6184
6185 6185 laddrlen = faddrlen = sizeof (sin6_t);
6186 6186 (void) udp_getsockname((sock_lower_handle_t)connp,
6187 6187 (struct sockaddr *)&laddr, &laddrlen, CRED());
6188 6188 error = udp_getpeername((sock_lower_handle_t)connp,
6189 6189 (struct sockaddr *)&faddr, &faddrlen, CRED());
6190 6190 if (error != 0)
6191 6191 faddrlen = 0;
6192 6192
6193 6193 opts = 0;
6194 6194 if (connp->conn_dgram_errind)
6195 6195 opts |= SO_DGRAM_ERRIND;
6196 6196 if (connp->conn_ixa->ixa_flags & IXAF_DONTROUTE)
6197 6197 opts |= SO_DONTROUTE;
6198 6198
6199 6199 mp = (*quiesced_cb)(connp->conn_upper_handle, arg, &tca,
6200 6200 (struct sockaddr *)&laddr, laddrlen,
6201 6201 (struct sockaddr *)&faddr, faddrlen, opts);
6202 6202
6203 6203 mutex_enter(&udp->udp_recv_lock);
6204 6204 /*
6205 6205 * Attempts to send data up during fallback will result in it being
6206 6206 * queued in udp_t. First push up the datagrams obtained from the
6207 6207 * socket, then any packets queued in udp_t.
6208 6208 */
6209 6209 if (mp != NULL) {
6210 6210 mp->b_next = udp->udp_fallback_queue_head;
6211 6211 udp->udp_fallback_queue_head = mp;
6212 6212 }
6213 6213 while (udp->udp_fallback_queue_head != NULL) {
6214 6214 mp = udp->udp_fallback_queue_head;
6215 6215 udp->udp_fallback_queue_head = mp->b_next;
6216 6216 mutex_exit(&udp->udp_recv_lock);
6217 6217 mp->b_next = NULL;
6218 6218 putnext(RD(q), mp);
6219 6219 mutex_enter(&udp->udp_recv_lock);
6220 6220 }
6221 6221 udp->udp_fallback_queue_tail = udp->udp_fallback_queue_head;
6222 6222 /*
6223 6223 * No longer a streams less socket
6224 6224 */
6225 6225 mutex_enter(&connp->conn_lock);
6226 6226 connp->conn_flags &= ~IPCL_NONSTR;
6227 6227 mutex_exit(&connp->conn_lock);
6228 6228
6229 6229 mutex_exit(&udp->udp_recv_lock);
6230 6230
6231 6231 ASSERT(connp->conn_ref >= 1);
6232 6232
6233 6233 return (0);
6234 6234 }
6235 6235
6236 6236 /* ARGSUSED3 */
6237 6237 int
6238 6238 udp_getpeername(sock_lower_handle_t proto_handle, struct sockaddr *sa,
6239 6239 socklen_t *salenp, cred_t *cr)
6240 6240 {
6241 6241 conn_t *connp = (conn_t *)proto_handle;
6242 6242 udp_t *udp = connp->conn_udp;
6243 6243 int error;
6244 6244
6245 6245 /* All Solaris components should pass a cred for this operation. */
6246 6246 ASSERT(cr != NULL);
6247 6247
6248 6248 mutex_enter(&connp->conn_lock);
6249 6249 if (udp->udp_state != TS_DATA_XFER)
6250 6250 error = ENOTCONN;
6251 6251 else
6252 6252 error = conn_getpeername(connp, sa, salenp);
6253 6253 mutex_exit(&connp->conn_lock);
6254 6254 return (error);
6255 6255 }
6256 6256
6257 6257 /* ARGSUSED3 */
6258 6258 int
6259 6259 udp_getsockname(sock_lower_handle_t proto_handle, struct sockaddr *sa,
6260 6260 socklen_t *salenp, cred_t *cr)
6261 6261 {
6262 6262 conn_t *connp = (conn_t *)proto_handle;
6263 6263 int error;
6264 6264
6265 6265 /* All Solaris components should pass a cred for this operation. */
6266 6266 ASSERT(cr != NULL);
6267 6267
6268 6268 mutex_enter(&connp->conn_lock);
6269 6269 error = conn_getsockname(connp, sa, salenp);
6270 6270 mutex_exit(&connp->conn_lock);
6271 6271 return (error);
6272 6272 }
6273 6273
6274 6274 int
6275 6275 udp_getsockopt(sock_lower_handle_t proto_handle, int level, int option_name,
6276 6276 void *optvalp, socklen_t *optlen, cred_t *cr)
6277 6277 {
6278 6278 conn_t *connp = (conn_t *)proto_handle;
6279 6279 int error;
6280 6280 t_uscalar_t max_optbuf_len;
6281 6281 void *optvalp_buf;
6282 6282 int len;
6283 6283
6284 6284 /* All Solaris components should pass a cred for this operation. */
6285 6285 ASSERT(cr != NULL);
6286 6286
6287 6287 error = proto_opt_check(level, option_name, *optlen, &max_optbuf_len,
6288 6288 udp_opt_obj.odb_opt_des_arr,
6289 6289 udp_opt_obj.odb_opt_arr_cnt,
6290 6290 B_FALSE, B_TRUE, cr);
6291 6291 if (error != 0) {
6292 6292 if (error < 0)
6293 6293 error = proto_tlitosyserr(-error);
6294 6294 return (error);
6295 6295 }
6296 6296
6297 6297 optvalp_buf = kmem_alloc(max_optbuf_len, KM_SLEEP);
6298 6298 len = udp_opt_get(connp, level, option_name, optvalp_buf);
6299 6299 if (len == -1) {
6300 6300 kmem_free(optvalp_buf, max_optbuf_len);
6301 6301 return (EINVAL);
6302 6302 }
6303 6303
6304 6304 /*
6305 6305 * update optlen and copy option value
6306 6306 */
6307 6307 t_uscalar_t size = MIN(len, *optlen);
6308 6308
6309 6309 bcopy(optvalp_buf, optvalp, size);
6310 6310 bcopy(&size, optlen, sizeof (size));
6311 6311
6312 6312 kmem_free(optvalp_buf, max_optbuf_len);
6313 6313 return (0);
6314 6314 }
6315 6315
6316 6316 int
6317 6317 udp_setsockopt(sock_lower_handle_t proto_handle, int level, int option_name,
6318 6318 const void *optvalp, socklen_t optlen, cred_t *cr)
6319 6319 {
6320 6320 conn_t *connp = (conn_t *)proto_handle;
6321 6321 int error;
6322 6322
6323 6323 /* All Solaris components should pass a cred for this operation. */
6324 6324 ASSERT(cr != NULL);
6325 6325
6326 6326 error = proto_opt_check(level, option_name, optlen, NULL,
6327 6327 udp_opt_obj.odb_opt_des_arr,
6328 6328 udp_opt_obj.odb_opt_arr_cnt,
6329 6329 B_TRUE, B_FALSE, cr);
6330 6330
6331 6331 if (error != 0) {
6332 6332 if (error < 0)
6333 6333 error = proto_tlitosyserr(-error);
6334 6334 return (error);
6335 6335 }
6336 6336
6337 6337 error = udp_opt_set(connp, SETFN_OPTCOM_NEGOTIATE, level, option_name,
6338 6338 optlen, (uchar_t *)optvalp, (uint_t *)&optlen, (uchar_t *)optvalp,
6339 6339 NULL, cr);
6340 6340
6341 6341 ASSERT(error >= 0);
6342 6342
6343 6343 return (error);
6344 6344 }
6345 6345
6346 6346 void
6347 6347 udp_clr_flowctrl(sock_lower_handle_t proto_handle)
6348 6348 {
6349 6349 conn_t *connp = (conn_t *)proto_handle;
6350 6350 udp_t *udp = connp->conn_udp;
6351 6351
6352 6352 mutex_enter(&udp->udp_recv_lock);
6353 6353 connp->conn_flow_cntrld = B_FALSE;
6354 6354 mutex_exit(&udp->udp_recv_lock);
6355 6355 }
6356 6356
6357 6357 /* ARGSUSED2 */
6358 6358 int
6359 6359 udp_shutdown(sock_lower_handle_t proto_handle, int how, cred_t *cr)
6360 6360 {
6361 6361 conn_t *connp = (conn_t *)proto_handle;
6362 6362
6363 6363 /* All Solaris components should pass a cred for this operation. */
6364 6364 ASSERT(cr != NULL);
6365 6365
6366 6366 /* shut down the send side */
6367 6367 if (how != SHUT_RD)
6368 6368 (*connp->conn_upcalls->su_opctl)(connp->conn_upper_handle,
6369 6369 SOCK_OPCTL_SHUT_SEND, 0);
6370 6370 /* shut down the recv side */
6371 6371 if (how != SHUT_WR)
6372 6372 (*connp->conn_upcalls->su_opctl)(connp->conn_upper_handle,
6373 6373 SOCK_OPCTL_SHUT_RECV, 0);
6374 6374 return (0);
6375 6375 }
6376 6376
6377 6377 int
6378 6378 udp_ioctl(sock_lower_handle_t proto_handle, int cmd, intptr_t arg,
6379 6379 int mode, int32_t *rvalp, cred_t *cr)
6380 6380 {
6381 6381 conn_t *connp = (conn_t *)proto_handle;
6382 6382 int error;
6383 6383
6384 6384 /* All Solaris components should pass a cred for this operation. */
6385 6385 ASSERT(cr != NULL);
6386 6386
6387 6387 /*
6388 6388 * If we don't have a helper stream then create one.
6389 6389 * ip_create_helper_stream takes care of locking the conn_t,
6390 6390 * so this check for NULL is just a performance optimization.
6391 6391 */
6392 6392 if (connp->conn_helper_info == NULL) {
6393 6393 udp_stack_t *us = connp->conn_udp->udp_us;
6394 6394
6395 6395 ASSERT(us->us_ldi_ident != NULL);
6396 6396
6397 6397 /*
6398 6398 * Create a helper stream for non-STREAMS socket.
6399 6399 */
6400 6400 error = ip_create_helper_stream(connp, us->us_ldi_ident);
6401 6401 if (error != 0) {
6402 6402 ip0dbg(("tcp_ioctl: create of IP helper stream "
6403 6403 "failed %d\n", error));
6404 6404 return (error);
6405 6405 }
6406 6406 }
6407 6407
6408 6408 switch (cmd) {
6409 6409 case _SIOCSOCKFALLBACK:
6410 6410 case TI_GETPEERNAME:
6411 6411 case TI_GETMYNAME:
6412 6412 ip1dbg(("udp_ioctl: cmd 0x%x on non streams socket",
6413 6413 cmd));
6414 6414 error = EINVAL;
6415 6415 break;
6416 6416 default:
6417 6417 /*
6418 6418 * Pass on to IP using helper stream
6419 6419 */
6420 6420 error = ldi_ioctl(connp->conn_helper_info->iphs_handle,
6421 6421 cmd, arg, mode, cr, rvalp);
6422 6422 break;
6423 6423 }
6424 6424 return (error);
6425 6425 }
6426 6426
6427 6427 /* ARGSUSED */
6428 6428 int
6429 6429 udp_accept(sock_lower_handle_t lproto_handle,
6430 6430 sock_lower_handle_t eproto_handle, sock_upper_handle_t sock_handle,
6431 6431 cred_t *cr)
6432 6432 {
6433 6433 return (EOPNOTSUPP);
6434 6434 }
6435 6435
6436 6436 /* ARGSUSED */
6437 6437 int
6438 6438 udp_listen(sock_lower_handle_t proto_handle, int backlog, cred_t *cr)
6439 6439 {
6440 6440 return (EOPNOTSUPP);
6441 6441 }
6442 6442
6443 6443 sock_downcalls_t sock_udp_downcalls = {
6444 6444 udp_activate, /* sd_activate */
6445 6445 udp_accept, /* sd_accept */
6446 6446 udp_bind, /* sd_bind */
6447 6447 udp_listen, /* sd_listen */
6448 6448 udp_connect, /* sd_connect */
6449 6449 udp_getpeername, /* sd_getpeername */
6450 6450 udp_getsockname, /* sd_getsockname */
6451 6451 udp_getsockopt, /* sd_getsockopt */
6452 6452 udp_setsockopt, /* sd_setsockopt */
6453 6453 udp_send, /* sd_send */
6454 6454 NULL, /* sd_send_uio */
6455 6455 NULL, /* sd_recv_uio */
6456 6456 NULL, /* sd_poll */
6457 6457 udp_shutdown, /* sd_shutdown */
6458 6458 udp_clr_flowctrl, /* sd_setflowctrl */
6459 6459 udp_ioctl, /* sd_ioctl */
6460 6460 udp_close /* sd_close */
6461 6461 };
|
↓ open down ↓ |
877 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX