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