Gitiles
Code Review Sign In
code.illumos.org / illumos-gate / de8c4a14ec9a49bad5e62b2cfa6c1ba21de1c708 / . / usr / src / uts / common / inet / udp / udp.c
blob: 30c876b45f4bb06280f6a9f08175a7832a9a61a5 [file] [log] [blame]
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
/* Copyright (c) 1990 Mentat Inc. */
#include <sys/types.h>
#include <sys/stream.h>
#include <sys/dlpi.h>
#include <sys/pattr.h>
#include <sys/stropts.h>
#include <sys/strlog.h>
#include <sys/strsun.h>
#include <sys/time.h>
#define _SUN_TPI_VERSION 2
#include <sys/tihdr.h>
#include <sys/timod.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/strsubr.h>
#include <sys/suntpi.h>
#include <sys/xti_inet.h>
#include <sys/kmem.h>
#include <sys/policy.h>
#include <sys/ucred.h>
#include <sys/zone.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/sockio.h>
#include <sys/vtrace.h>
#include <sys/sdt.h>
#include <sys/debug.h>
#include <sys/isa_defs.h>
#include <sys/random.h>
#include <netinet/in.h>
#include <netinet/ip6.h>
#include <netinet/icmp6.h>
#include <netinet/udp.h>
#include <net/if.h>
#include <net/route.h>
#include <inet/common.h>
#include <inet/ip.h>
#include <inet/ip_impl.h>
#include <inet/ip6.h>
#include <inet/ip_ire.h>
#include <inet/ip_if.h>
#include <inet/ip_multi.h>
#include <inet/ip_ndp.h>
#include <inet/proto_set.h>
#include <inet/mib2.h>
#include <inet/nd.h>
#include <inet/optcom.h>
#include <inet/snmpcom.h>
#include <inet/kstatcom.h>
#include <inet/udp_impl.h>
#include <inet/ipclassifier.h>
#include <inet/ipsec_impl.h>
#include <inet/ipp_common.h>
#include <sys/squeue_impl.h>
#include <inet/ipnet.h>
#include <sys/ethernet.h>
/*
* The ipsec_info.h header file is here since it has the definition for the
* M_CTL message types used by IP to convey information to the ULP. The
* ipsec_info.h needs the pfkeyv2.h, hence the latter's presence.
*/
#include <net/pfkeyv2.h>
#include <inet/ipsec_info.h>
#include <sys/tsol/label.h>
#include <sys/tsol/tnet.h>
#include <rpc/pmap_prot.h>
/*
* Synchronization notes:
*
* UDP is MT and uses the usual kernel synchronization primitives. There are 2
* locks, the fanout lock (uf_lock) and the udp endpoint lock udp_rwlock.
* We also use conn_lock when updating things that affect the IP classifier
* lookup.
* The lock order is udp_rwlock -> uf_lock and is udp_rwlock -> conn_lock.
*
* The fanout lock uf_lock:
* When a UDP endpoint is bound to a local port, it is inserted into
* a bind hash list. The list consists of an array of udp_fanout_t buckets.
* The size of the array is controlled by the udp_bind_fanout_size variable.
* This variable can be changed in /etc/system if the default value is
* not large enough. Each bind hash bucket is protected by a per bucket
* lock. It protects the udp_bind_hash and udp_ptpbhn fields in the udp_t
* structure and a few other fields in the udp_t. A UDP endpoint is removed
* from the bind hash list only when it is being unbound or being closed.
* The per bucket lock also protects a UDP endpoint's state changes.
*
* The udp_rwlock:
* This protects most of the other fields in the udp_t. The exact list of
* fields which are protected by each of the above locks is documented in
* the udp_t structure definition.
*
* Plumbing notes:
* UDP is always a device driver. For compatibility with mibopen() code
* it is possible to I_PUSH "udp", but that results in pushing a passthrough
* dummy module.
*
* The above implies that we don't support any intermediate module to
* reside in between /dev/ip and udp -- in fact, we never supported such
* scenario in the past as the inter-layer communication semantics have
* always been private.
*/
/* For /etc/system control */
uint_t udp_bind_fanout_size = UDP_BIND_FANOUT_SIZE;
#define NDD_TOO_QUICK_MSG \
"ndd get info rate too high for non-privileged users, try again " \
"later.\n"
#define NDD_OUT_OF_BUF_MSG "<< Out of buffer >>\n"
/* Option processing attrs */
typedef struct udpattrs_s {
union {
ip6_pkt_t *udpattr_ipp6; /* For V6 */
ip4_pkt_t *udpattr_ipp4; /* For V4 */
} udpattr_ippu;
#define udpattr_ipp6 udpattr_ippu.udpattr_ipp6
#define udpattr_ipp4 udpattr_ippu.udpattr_ipp4
mblk_t *udpattr_mb;
boolean_t udpattr_credset;
} udpattrs_t;
static void udp_addr_req(queue_t *q, mblk_t *mp);
static void udp_tpi_bind(queue_t *q, mblk_t *mp);
static void udp_bind_hash_insert(udp_fanout_t *uf, udp_t *udp);
static void udp_bind_hash_remove(udp_t *udp, boolean_t caller_holds_lock);
static int udp_build_hdrs(udp_t *udp);
static void udp_capability_req(queue_t *q, mblk_t *mp);
static int udp_tpi_close(queue_t *q, int flags);
static void udp_tpi_connect(queue_t *q, mblk_t *mp);
static void udp_tpi_disconnect(queue_t *q, mblk_t *mp);
static void udp_err_ack(queue_t *q, mblk_t *mp, t_scalar_t t_error,
int sys_error);
static void udp_err_ack_prim(queue_t *q, mblk_t *mp, int primitive,
t_scalar_t tlierr, int unixerr);
static int udp_extra_priv_ports_get(queue_t *q, mblk_t *mp, caddr_t cp,
cred_t *cr);
static int udp_extra_priv_ports_add(queue_t *q, mblk_t *mp,
char *value, caddr_t cp, cred_t *cr);
static int udp_extra_priv_ports_del(queue_t *q, mblk_t *mp,
char *value, caddr_t cp, cred_t *cr);
static void udp_icmp_error(conn_t *, mblk_t *);
static void udp_icmp_error_ipv6(conn_t *, mblk_t *);
static void udp_info_req(queue_t *q, mblk_t *mp);
static void udp_input(void *, mblk_t *, void *);
static mblk_t *udp_ip_bind_mp(udp_t *udp, t_scalar_t bind_prim,
t_scalar_t addr_length);
static void udp_lrput(queue_t *, mblk_t *);
static void udp_lwput(queue_t *, mblk_t *);
static int udp_open(queue_t *q, dev_t *devp, int flag, int sflag,
cred_t *credp, boolean_t isv6);
static int udp_openv4(queue_t *q, dev_t *devp, int flag, int sflag,
cred_t *credp);
static int udp_openv6(queue_t *q, dev_t *devp, int flag, int sflag,
cred_t *credp);
static int udp_unitdata_opt_process(queue_t *q, mblk_t *mp,
int *errorp, udpattrs_t *udpattrs);
static boolean_t udp_opt_allow_udr_set(t_scalar_t level, t_scalar_t name);
static int udp_param_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *cr);
static boolean_t udp_param_register(IDP *ndp, udpparam_t *udppa, int cnt);
static int udp_param_set(queue_t *q, mblk_t *mp, char *value, caddr_t cp,
cred_t *cr);
static void udp_report_item(mblk_t *mp, udp_t *udp);
static int udp_rinfop(queue_t *q, infod_t *dp);
static int udp_rrw(queue_t *q, struiod_t *dp);
static int udp_status_report(queue_t *q, mblk_t *mp, caddr_t cp,
cred_t *cr);
static void udp_send_data(udp_t *udp, queue_t *q, mblk_t *mp,
ipha_t *ipha);
static void udp_ud_err(queue_t *q, mblk_t *mp, uchar_t *destaddr,
t_scalar_t destlen, t_scalar_t err);
static void udp_tpi_unbind(queue_t *q, mblk_t *mp);
static in_port_t udp_update_next_port(udp_t *udp, in_port_t port,
boolean_t random);
static mblk_t *udp_output_v4(conn_t *, mblk_t *, ipaddr_t, uint16_t, uint_t,
int *, boolean_t, struct nmsghdr *, cred_t *, pid_t);
static mblk_t *udp_output_v6(conn_t *connp, mblk_t *mp, sin6_t *sin6,
int *error, struct nmsghdr *msg, cred_t *cr, pid_t pid);
static void udp_wput_other(queue_t *q, mblk_t *mp);
static void udp_wput_iocdata(queue_t *q, mblk_t *mp);
static void udp_wput_fallback(queue_t *q, mblk_t *mp);
static size_t udp_set_rcv_hiwat(udp_t *udp, size_t size);
static void *udp_stack_init(netstackid_t stackid, netstack_t *ns);
static void udp_stack_fini(netstackid_t stackid, void *arg);
static void *udp_kstat_init(netstackid_t stackid);
static void udp_kstat_fini(netstackid_t stackid, kstat_t *ksp);
static void *udp_kstat2_init(netstackid_t, udp_stat_t *);
static void udp_kstat2_fini(netstackid_t, kstat_t *);
static int udp_kstat_update(kstat_t *kp, int rw);
static void udp_rcv_enqueue(queue_t *q, udp_t *udp, mblk_t *mp,
uint_t pkt_len);
static void udp_rcv_drain(queue_t *q, udp_t *udp, boolean_t closing);
static void udp_xmit(queue_t *, mblk_t *, ire_t *ire, conn_t *, zoneid_t);
static int udp_send_connected(conn_t *, mblk_t *, struct nmsghdr *,
cred_t *, pid_t);
/* Common routine for TPI and socket module */
static conn_t *udp_do_open(cred_t *, boolean_t, int);
static void udp_do_close(conn_t *);
static int udp_do_bind(conn_t *, struct sockaddr *, socklen_t, cred_t *,
boolean_t);
static int udp_do_unbind(conn_t *);
static int udp_do_getsockname(udp_t *, struct sockaddr *, uint_t *);
static int udp_do_getpeername(udp_t *, struct sockaddr *, uint_t *);
int udp_getsockname(sock_lower_handle_t,
struct sockaddr *, socklen_t *, cred_t *);
int udp_getpeername(sock_lower_handle_t,
struct sockaddr *, socklen_t *, cred_t *);
static int udp_do_connect(conn_t *, const struct sockaddr *, socklen_t,
cred_t *cr);
static int udp_post_ip_bind_connect(udp_t *, mblk_t *, int);
#define UDP_RECV_HIWATER (56 * 1024)
#define UDP_RECV_LOWATER 128
#define UDP_XMIT_HIWATER (56 * 1024)
#define UDP_XMIT_LOWATER 1024
/*
* The following is defined in tcp.c
*/
extern int (*cl_inet_connect2)(netstackid_t stack_id,
uint8_t protocol, boolean_t is_outgoing,
sa_family_t addr_family,
uint8_t *laddrp, in_port_t lport,
uint8_t *faddrp, in_port_t fport, void *args);
/*
* Checks if the given destination addr/port is allowed out.
* If allowed, registers the (dest_addr/port, node_ID) mapping at Cluster.
* Called for each connect() and for sendto()/sendmsg() to a different
* destination.
* For connect(), called in udp_connect().
* For sendto()/sendmsg(), called in udp_output_v{4,6}().
*
* This macro assumes that the cl_inet_connect2 hook is not NULL.
* Please check this before calling this macro.
*
* void
* CL_INET_UDP_CONNECT(conn_t cp, udp_t *udp, boolean_t is_outgoing,
* in6_addr_t *faddrp, in_port_t (or uint16_t) fport, int err);
*/
#define CL_INET_UDP_CONNECT(cp, udp, is_outgoing, faddrp, fport, err) { \
(err) = 0; \
/* \
* Running in cluster mode - check and register active \
* "connection" information \
*/ \
if ((udp)->udp_ipversion == IPV4_VERSION) \
(err) = (*cl_inet_connect2)( \
(cp)->conn_netstack->netstack_stackid, \
IPPROTO_UDP, is_outgoing, AF_INET, \
(uint8_t *)&((udp)->udp_v6src._S6_un._S6_u32[3]), \
(udp)->udp_port, \
(uint8_t *)&((faddrp)->_S6_un._S6_u32[3]), \
(in_port_t)(fport), NULL); \
else \
(err) = (*cl_inet_connect2)( \
(cp)->conn_netstack->netstack_stackid, \
IPPROTO_UDP, is_outgoing, AF_INET6, \
(uint8_t *)&((udp)->udp_v6src), (udp)->udp_port, \
(uint8_t *)(faddrp), (in_port_t)(fport), NULL); \
}
static struct module_info udp_mod_info = {
UDP_MOD_ID, UDP_MOD_NAME, 1, INFPSZ, UDP_RECV_HIWATER, UDP_RECV_LOWATER
};
/*
* Entry points for UDP as a device.
* We have separate open functions for the /dev/udp and /dev/udp6 devices.
*/
static struct qinit udp_rinitv4 = {
NULL, NULL, udp_openv4, udp_tpi_close, NULL,
&udp_mod_info, NULL, udp_rrw, udp_rinfop, STRUIOT_STANDARD
};
static struct qinit udp_rinitv6 = {
NULL, NULL, udp_openv6, udp_tpi_close, NULL,
&udp_mod_info, NULL, udp_rrw, udp_rinfop, STRUIOT_STANDARD
};
static struct qinit udp_winit = {
(pfi_t)udp_wput, (pfi_t)ip_wsrv, NULL, NULL, NULL,
&udp_mod_info, NULL, NULL, NULL, STRUIOT_NONE
};
/* UDP entry point during fallback */
struct qinit udp_fallback_sock_winit = {
(pfi_t)udp_wput_fallback, NULL, NULL, NULL, NULL, &udp_mod_info
};
/*
* UDP needs to handle I_LINK and I_PLINK since ifconfig
* likes to use it as a place to hang the various streams.
*/
static struct qinit udp_lrinit = {
(pfi_t)udp_lrput, NULL, udp_openv4, udp_tpi_close, NULL,
&udp_mod_info
};
static struct qinit udp_lwinit = {
(pfi_t)udp_lwput, NULL, udp_openv4, udp_tpi_close, NULL,
&udp_mod_info
};
/* For AF_INET aka /dev/udp */
struct streamtab udpinfov4 = {
&udp_rinitv4, &udp_winit, &udp_lrinit, &udp_lwinit
};
/* For AF_INET6 aka /dev/udp6 */
struct streamtab udpinfov6 = {
&udp_rinitv6, &udp_winit, &udp_lrinit, &udp_lwinit
};
static sin_t sin_null; /* Zero address for quick clears */
static sin6_t sin6_null; /* Zero address for quick clears */
#define UDP_MAXPACKET_IPV4 (IP_MAXPACKET - UDPH_SIZE - IP_SIMPLE_HDR_LENGTH)
/* Default structure copied into T_INFO_ACK messages */
static struct T_info_ack udp_g_t_info_ack_ipv4 = {
T_INFO_ACK,
UDP_MAXPACKET_IPV4, /* TSDU_size. Excl. headers */
T_INVALID, /* ETSU_size. udp does not support expedited data. */
T_INVALID, /* CDATA_size. udp does not support connect data. */
T_INVALID, /* DDATA_size. udp does not support disconnect data. */
sizeof (sin_t), /* ADDR_size. */
0, /* OPT_size - not initialized here */
UDP_MAXPACKET_IPV4, /* TIDU_size. Excl. headers */
T_CLTS, /* SERV_type. udp supports connection-less. */
TS_UNBND, /* CURRENT_state. This is set from udp_state. */
(XPG4_1|SENDZERO) /* PROVIDER_flag */
};
#define UDP_MAXPACKET_IPV6 (IP_MAXPACKET - UDPH_SIZE - IPV6_HDR_LEN)
static struct T_info_ack udp_g_t_info_ack_ipv6 = {
T_INFO_ACK,
UDP_MAXPACKET_IPV6, /* TSDU_size. Excl. headers */
T_INVALID, /* ETSU_size. udp does not support expedited data. */
T_INVALID, /* CDATA_size. udp does not support connect data. */
T_INVALID, /* DDATA_size. udp does not support disconnect data. */
sizeof (sin6_t), /* ADDR_size. */
0, /* OPT_size - not initialized here */
UDP_MAXPACKET_IPV6, /* TIDU_size. Excl. headers */
T_CLTS, /* SERV_type. udp supports connection-less. */
TS_UNBND, /* CURRENT_state. This is set from udp_state. */
(XPG4_1|SENDZERO) /* PROVIDER_flag */
};
/* largest UDP port number */
#define UDP_MAX_PORT 65535
/*
* Table of ND variables supported by udp. These are loaded into us_nd
* in udp_open.
* All of these are alterable, within the min/max values given, at run time.
*/
/* BEGIN CSTYLED */
udpparam_t udp_param_arr[] = {
/*min max value name */
{ 0L, 256, 32, "udp_wroff_extra" },
{ 1L, 255, 255, "udp_ipv4_ttl" },
{ 0, IPV6_MAX_HOPS, IPV6_DEFAULT_HOPS, "udp_ipv6_hoplimit"},
{ 1024, (32 * 1024), 1024, "udp_smallest_nonpriv_port" },
{ 0, 1, 1, "udp_do_checksum" },
{ 1024, UDP_MAX_PORT, (32 * 1024), "udp_smallest_anon_port" },
{ 1024, UDP_MAX_PORT, UDP_MAX_PORT, "udp_largest_anon_port" },
{ UDP_XMIT_LOWATER, (1<<30), UDP_XMIT_HIWATER, "udp_xmit_hiwat"},
{ 0, (1<<30), UDP_XMIT_LOWATER, "udp_xmit_lowat"},
{ UDP_RECV_LOWATER, (1<<30), UDP_RECV_HIWATER, "udp_recv_hiwat"},
{ 65536, (1<<30), 2*1024*1024, "udp_max_buf"},
{ 100, 60000, 1000, "udp_ndd_get_info_interval"},
};
/* END CSTYLED */
/* Setable in /etc/system */
/* If set to 0, pick ephemeral port sequentially; otherwise randomly. */
uint32_t udp_random_anon_port = 1;
/*
* Hook functions to enable cluster networking.
* On non-clustered systems these vectors must always be NULL
*/
void (*cl_inet_bind)(netstackid_t stack_id, uchar_t protocol,
sa_family_t addr_family, uint8_t *laddrp, in_port_t lport,
void *args) = NULL;
void (*cl_inet_unbind)(netstackid_t stack_id, uint8_t protocol,
sa_family_t addr_family, uint8_t *laddrp, in_port_t lport,
void *args) = NULL;
typedef union T_primitives *t_primp_t;
/*
* Return the next anonymous port in the privileged port range for
* bind checking.
*
* Trusted Extension (TX) notes: TX allows administrator to mark or
* reserve ports as Multilevel ports (MLP). MLP has special function
* on TX systems. Once a port is made MLP, it's not available as
* ordinary port. This creates "holes" in the port name space. It
* may be necessary to skip the "holes" find a suitable anon port.
*/
static in_port_t
udp_get_next_priv_port(udp_t *udp)
{
static in_port_t next_priv_port = IPPORT_RESERVED - 1;
in_port_t nextport;
boolean_t restart = B_FALSE;
udp_stack_t *us = udp->udp_us;
retry:
if (next_priv_port < us->us_min_anonpriv_port ||
next_priv_port >= IPPORT_RESERVED) {
next_priv_port = IPPORT_RESERVED - 1;
if (restart)
return (0);
restart = B_TRUE;
}
if (is_system_labeled() &&
(nextport = tsol_next_port(crgetzone(udp->udp_connp->conn_cred),
next_priv_port, IPPROTO_UDP, B_FALSE)) != 0) {
next_priv_port = nextport;
goto retry;
}
return (next_priv_port--);
}
/* UDP bind hash report triggered via the Named Dispatch mechanism. */
/* ARGSUSED */
static int
udp_bind_hash_report(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *cr)
{
udp_fanout_t *udpf;
int i;
zoneid_t zoneid;
conn_t *connp;
udp_t *udp;
udp_stack_t *us;
connp = Q_TO_CONN(q);
udp = connp->conn_udp;
us = udp->udp_us;
/* Refer to comments in udp_status_report(). */
if (cr == NULL || secpolicy_ip_config(cr, B_TRUE) != 0) {
if (ddi_get_lbolt() - us->us_last_ndd_get_info_time <
drv_usectohz(us->us_ndd_get_info_interval * 1000)) {
(void) mi_mpprintf(mp, NDD_TOO_QUICK_MSG);
return (0);
}
}
if ((mp->b_cont = allocb(ND_MAX_BUF_LEN, BPRI_HI)) == NULL) {
/* The following may work even if we cannot get a large buf. */
(void) mi_mpprintf(mp, NDD_OUT_OF_BUF_MSG);
return (0);
}
(void) mi_mpprintf(mp,
"UDP " MI_COL_HDRPAD_STR
/* 12345678[89ABCDEF] */
" zone lport src addr dest addr port state");
/* 1234 12345 xxx.xxx.xxx.xxx xxx.xxx.xxx.xxx 12345 UNBOUND */
zoneid = connp->conn_zoneid;
for (i = 0; i < us->us_bind_fanout_size; i++) {
udpf = &us->us_bind_fanout[i];
mutex_enter(&udpf->uf_lock);
/* Print the hash index. */
udp = udpf->uf_udp;
if (zoneid != GLOBAL_ZONEID) {
/* skip to first entry in this zone; might be none */
while (udp != NULL &&
udp->udp_connp->conn_zoneid != zoneid)
udp = udp->udp_bind_hash;
}
if (udp != NULL) {
uint_t print_len, buf_len;
buf_len = mp->b_cont->b_datap->db_lim -
mp->b_cont->b_wptr;
print_len = snprintf((char *)mp->b_cont->b_wptr,
buf_len, "%d\n", i);
if (print_len < buf_len) {
mp->b_cont->b_wptr += print_len;
} else {
mp->b_cont->b_wptr += buf_len;
}
for (; udp != NULL; udp = udp->udp_bind_hash) {
if (zoneid == GLOBAL_ZONEID ||
zoneid == udp->udp_connp->conn_zoneid)
udp_report_item(mp->b_cont, udp);
}
}
mutex_exit(&udpf->uf_lock);
}
us->us_last_ndd_get_info_time = ddi_get_lbolt();
return (0);
}
/*
* Hash list removal routine for udp_t structures.
*/
static void
udp_bind_hash_remove(udp_t *udp, boolean_t caller_holds_lock)
{
udp_t *udpnext;
kmutex_t *lockp;
udp_stack_t *us = udp->udp_us;
if (udp->udp_ptpbhn == NULL)
return;
/*
* Extract the lock pointer in case there are concurrent
* hash_remove's for this instance.
*/
ASSERT(udp->udp_port != 0);
if (!caller_holds_lock) {
lockp = &us->us_bind_fanout[UDP_BIND_HASH(udp->udp_port,
us->us_bind_fanout_size)].uf_lock;
ASSERT(lockp != NULL);
mutex_enter(lockp);
}
if (udp->udp_ptpbhn != NULL) {
udpnext = udp->udp_bind_hash;
if (udpnext != NULL) {
udpnext->udp_ptpbhn = udp->udp_ptpbhn;
udp->udp_bind_hash = NULL;
}
*udp->udp_ptpbhn = udpnext;
udp->udp_ptpbhn = NULL;
}
if (!caller_holds_lock) {
mutex_exit(lockp);
}
}
static void
udp_bind_hash_insert(udp_fanout_t *uf, udp_t *udp)
{
udp_t **udpp;
udp_t *udpnext;
ASSERT(MUTEX_HELD(&uf->uf_lock));
ASSERT(udp->udp_ptpbhn == NULL);
udpp = &uf->uf_udp;
udpnext = udpp[0];
if (udpnext != NULL) {
/*
* If the new udp bound to the INADDR_ANY address
* and the first one in the list is not bound to
* INADDR_ANY we skip all entries until we find the
* first one bound to INADDR_ANY.
* This makes sure that applications binding to a
* specific address get preference over those binding to
* INADDR_ANY.
*/
if (V6_OR_V4_INADDR_ANY(udp->udp_bound_v6src) &&
!V6_OR_V4_INADDR_ANY(udpnext->udp_bound_v6src)) {
while ((udpnext = udpp[0]) != NULL &&
!V6_OR_V4_INADDR_ANY(
udpnext->udp_bound_v6src)) {
udpp = &(udpnext->udp_bind_hash);
}
if (udpnext != NULL)
udpnext->udp_ptpbhn = &udp->udp_bind_hash;
} else {
udpnext->udp_ptpbhn = &udp->udp_bind_hash;
}
}
udp->udp_bind_hash = udpnext;
udp->udp_ptpbhn = udpp;
udpp[0] = udp;
}
/*
* This routine is called to handle each O_T_BIND_REQ/T_BIND_REQ message
* passed to udp_wput.
* It associates a port number and local address with the stream.
* The O_T_BIND_REQ/T_BIND_REQ is passed downstream to ip with the UDP
* protocol type (IPPROTO_UDP) placed in the message following the address.
* A T_BIND_ACK message is passed upstream when ip acknowledges the request.
* (Called as writer.)
*
* Note that UDP over IPv4 and IPv6 sockets can use the same port number
* without setting SO_REUSEADDR. This is needed so that they
* can be viewed as two independent transport protocols.
* However, anonymouns ports are allocated from the same range to avoid
* duplicating the us->us_next_port_to_try.
*/
static void
udp_tpi_bind(queue_t *q, mblk_t *mp)
{
sin_t *sin;
sin6_t *sin6;
mblk_t *mp1;
struct T_bind_req *tbr;
conn_t *connp;
udp_t *udp;
int error;
struct sockaddr *sa;
cred_t *cr;
/*
* All Solaris components should pass a db_credp
* for this TPI message, hence we ASSERT.
* But in case there is some other M_PROTO that looks
* like a TPI message sent by some other kernel
* component, we check and return an error.
*/
cr = msg_getcred(mp, NULL);
ASSERT(cr != NULL);
if (cr == NULL) {
udp_err_ack(q, mp, TSYSERR, EINVAL);
return;
}
connp = Q_TO_CONN(q);
udp = connp->conn_udp;
if ((mp->b_wptr - mp->b_rptr) < sizeof (*tbr)) {
(void) mi_strlog(q, 1, SL_ERROR|SL_TRACE,
"udp_bind: bad req, len %u",
(uint_t)(mp->b_wptr - mp->b_rptr));
udp_err_ack(q, mp, TPROTO, 0);
return;
}
if (udp->udp_state != TS_UNBND) {
(void) mi_strlog(q, 1, SL_ERROR|SL_TRACE,
"udp_bind: bad state, %u", udp->udp_state);
udp_err_ack(q, mp, TOUTSTATE, 0);
return;
}
/*
* Reallocate the message to make sure we have enough room for an
* address and the protocol type.
*/
mp1 = reallocb(mp, sizeof (struct T_bind_ack) + sizeof (sin6_t) + 1, 1);
if (!mp1) {
udp_err_ack(q, mp, TSYSERR, ENOMEM);
return;
}
mp = mp1;
/* Reset the message type in preparation for shipping it back. */
DB_TYPE(mp) = M_PCPROTO;
tbr = (struct T_bind_req *)mp->b_rptr;
switch (tbr->ADDR_length) {
case 0: /* Request for a generic port */
tbr->ADDR_offset = sizeof (struct T_bind_req);
if (udp->udp_family == AF_INET) {
tbr->ADDR_length = sizeof (sin_t);
sin = (sin_t *)&tbr[1];
*sin = sin_null;
sin->sin_family = AF_INET;
mp->b_wptr = (uchar_t *)&sin[1];
sa = (struct sockaddr *)sin;
} else {
ASSERT(udp->udp_family == AF_INET6);
tbr->ADDR_length = sizeof (sin6_t);
sin6 = (sin6_t *)&tbr[1];
*sin6 = sin6_null;
sin6->sin6_family = AF_INET6;
mp->b_wptr = (uchar_t *)&sin6[1];
sa = (struct sockaddr *)sin6;
}
break;
case sizeof (sin_t): /* Complete IPv4 address */
sa = (struct sockaddr *)mi_offset_param(mp, tbr->ADDR_offset,
sizeof (sin_t));
if (sa == NULL || !OK_32PTR((char *)sa)) {
udp_err_ack(q, mp, TSYSERR, EINVAL);
return;
}
if (udp->udp_family != AF_INET ||
sa->sa_family != AF_INET) {
udp_err_ack(q, mp, TSYSERR, EAFNOSUPPORT);
return;
}
break;
case sizeof (sin6_t): /* complete IPv6 address */
sa = (struct sockaddr *)mi_offset_param(mp, tbr->ADDR_offset,
sizeof (sin6_t));
if (sa == NULL || !OK_32PTR((char *)sa)) {
udp_err_ack(q, mp, TSYSERR, EINVAL);
return;
}
if (udp->udp_family != AF_INET6 ||
sa->sa_family != AF_INET6) {
udp_err_ack(q, mp, TSYSERR, EAFNOSUPPORT);
return;
}
break;
default: /* Invalid request */
(void) mi_strlog(q, 1, SL_ERROR|SL_TRACE,
"udp_bind: bad ADDR_length length %u", tbr->ADDR_length);
udp_err_ack(q, mp, TBADADDR, 0);
return;
}
error = udp_do_bind(connp, sa, tbr->ADDR_length, cr,
tbr->PRIM_type != O_T_BIND_REQ);
if (error != 0) {
if (error > 0) {
udp_err_ack(q, mp, TSYSERR, error);
} else {
udp_err_ack(q, mp, -error, 0);
}
} else {
tbr->PRIM_type = T_BIND_ACK;
qreply(q, mp);
}
}
/*
* This routine handles each T_CONN_REQ message passed to udp. It
* associates a default destination address with the stream.
*
* This routine sends down a T_BIND_REQ to IP with the following mblks:
* T_BIND_REQ - specifying local and remote address/port
* IRE_DB_REQ_TYPE - to get an IRE back containing ire_type and src
* T_OK_ACK - for the T_CONN_REQ
* T_CONN_CON - to keep the TPI user happy
*
* The connect completes in udp_do_connect.
* When a T_BIND_ACK is received information is extracted from the IRE
* and the two appended messages are sent to the TPI user.
* Should udp_bind_result receive T_ERROR_ACK for the T_BIND_REQ it will
* convert it to an error ack for the appropriate primitive.
*/
static void
udp_tpi_connect(queue_t *q, mblk_t *mp)
{
mblk_t *mp1;
udp_t *udp;
conn_t *connp = Q_TO_CONN(q);
int error;
socklen_t len;
struct sockaddr *sa;
struct T_conn_req *tcr;
cred_t *cr;
/*
* All Solaris components should pass a db_credp
* for this TPI message, hence we ASSERT.
* But in case there is some other M_PROTO that looks
* like a TPI message sent by some other kernel
* component, we check and return an error.
*/
cr = msg_getcred(mp, NULL);
ASSERT(cr != NULL);
if (cr == NULL) {
udp_err_ack(q, mp, TSYSERR, EINVAL);
return;
}
udp = connp->conn_udp;
tcr = (struct T_conn_req *)mp->b_rptr;
/* A bit of sanity checking */
if ((mp->b_wptr - mp->b_rptr) < sizeof (struct T_conn_req)) {
udp_err_ack(q, mp, TPROTO, 0);
return;
}
if (tcr->OPT_length != 0) {
udp_err_ack(q, mp, TBADOPT, 0);
return;
}
/*
* Determine packet type based on type of address passed in
* the request should contain an IPv4 or IPv6 address.
* Make sure that address family matches the type of
* family of the the address passed down
*/
len = tcr->DEST_length;
switch (tcr->DEST_length) {
default:
udp_err_ack(q, mp, TBADADDR, 0);
return;
case sizeof (sin_t):
sa = (struct sockaddr *)mi_offset_param(mp, tcr->DEST_offset,
sizeof (sin_t));
break;
case sizeof (sin6_t):
sa = (struct sockaddr *)mi_offset_param(mp, tcr->DEST_offset,
sizeof (sin6_t));
break;
}
error = proto_verify_ip_addr(udp->udp_family, sa, len);
if (error != 0) {
udp_err_ack(q, mp, TSYSERR, error);
return;
}
/*
* We have to send a connection confirmation to
* keep TLI happy.
*/
if (udp->udp_family == AF_INET) {
mp1 = mi_tpi_conn_con(NULL, (char *)sa,
sizeof (sin_t), NULL, 0);
} else {
mp1 = mi_tpi_conn_con(NULL, (char *)sa,
sizeof (sin6_t), NULL, 0);
}
if (mp1 == NULL) {
udp_err_ack(q, mp, TSYSERR, ENOMEM);
return;
}
/*
* ok_ack for T_CONN_REQ
*/
mp = mi_tpi_ok_ack_alloc(mp);
if (mp == NULL) {
/* Unable to reuse the T_CONN_REQ for the ack. */
freemsg(mp1);
udp_err_ack_prim(q, mp1, T_CONN_REQ, TSYSERR, ENOMEM);
return;
}
error = udp_do_connect(connp, sa, len, cr);
if (error != 0) {
freeb(mp1);
if (error < 0)
udp_err_ack(q, mp, -error, 0);
else
udp_err_ack(q, mp, TSYSERR, error);
} else {
putnext(connp->conn_rq, mp);
putnext(connp->conn_rq, mp1);
}
}
static int
udp_tpi_close(queue_t *q, int flags)
{
conn_t *connp;
if (flags & SO_FALLBACK) {
/*
* stream is being closed while in fallback
* simply free the resources that were allocated
*/
inet_minor_free(WR(q)->q_ptr, (dev_t)(RD(q)->q_ptr));
qprocsoff(q);
goto done;
}
connp = Q_TO_CONN(q);
udp_do_close(connp);
done:
q->q_ptr = WR(q)->q_ptr = NULL;
return (0);
}
/*
* Called in the close path to quiesce the conn
*/
void
udp_quiesce_conn(conn_t *connp)
{
udp_t *udp = connp->conn_udp;
if (cl_inet_unbind != NULL && udp->udp_state == TS_IDLE) {
/*
* Running in cluster mode - register unbind information
*/
if (udp->udp_ipversion == IPV4_VERSION) {
(*cl_inet_unbind)(
connp->conn_netstack->netstack_stackid,
IPPROTO_UDP, AF_INET,
(uint8_t *)(&(V4_PART_OF_V6(udp->udp_v6src))),
(in_port_t)udp->udp_port, NULL);
} else {
(*cl_inet_unbind)(
connp->conn_netstack->netstack_stackid,
IPPROTO_UDP, AF_INET6,
(uint8_t *)(&(udp->udp_v6src)),
(in_port_t)udp->udp_port, NULL);
}
}
udp_bind_hash_remove(udp, B_FALSE);
}
void
udp_close_free(conn_t *connp)
{
udp_t *udp = connp->conn_udp;
/* If there are any options associated with the stream, free them. */
if (udp->udp_ip_snd_options != NULL) {
mi_free((char *)udp->udp_ip_snd_options);
udp->udp_ip_snd_options = NULL;
udp->udp_ip_snd_options_len = 0;
}
if (udp->udp_ip_rcv_options != NULL) {
mi_free((char *)udp->udp_ip_rcv_options);
udp->udp_ip_rcv_options = NULL;
udp->udp_ip_rcv_options_len = 0;
}
/* Free memory associated with sticky options */
if (udp->udp_sticky_hdrs_len != 0) {
kmem_free(udp->udp_sticky_hdrs,
udp->udp_sticky_hdrs_len);
udp->udp_sticky_hdrs = NULL;
udp->udp_sticky_hdrs_len = 0;
}
ip6_pkt_free(&udp->udp_sticky_ipp);
/*
* Clear any fields which the kmem_cache constructor clears.
* Only udp_connp needs to be preserved.
* TBD: We should make this more efficient to avoid clearing
* everything.
*/
ASSERT(udp->udp_connp == connp);
bzero(udp, sizeof (udp_t));
udp->udp_connp = connp;
}
static int
udp_do_disconnect(conn_t *connp)
{
udp_t *udp;
mblk_t *ire_mp;
udp_fanout_t *udpf;
udp_stack_t *us;
int error;
udp = connp->conn_udp;
us = udp->udp_us;
rw_enter(&udp->udp_rwlock, RW_WRITER);
if (udp->udp_state != TS_DATA_XFER || udp->udp_pending_op != -1) {
rw_exit(&udp->udp_rwlock);
return (-TOUTSTATE);
}
udp->udp_pending_op = T_DISCON_REQ;
udpf = &us->us_bind_fanout[UDP_BIND_HASH(udp->udp_port,
us->us_bind_fanout_size)];
mutex_enter(&udpf->uf_lock);
udp->udp_v6src = udp->udp_bound_v6src;
udp->udp_state = TS_IDLE;
mutex_exit(&udpf->uf_lock);
if (udp->udp_family == AF_INET6) {
/* Rebuild the header template */
error = udp_build_hdrs(udp);
if (error != 0) {
udp->udp_pending_op = -1;
rw_exit(&udp->udp_rwlock);
return (error);
}
}
ire_mp = allocb(sizeof (ire_t), BPRI_HI);
if (ire_mp == NULL) {
mutex_enter(&udpf->uf_lock);
udp->udp_pending_op = -1;
mutex_exit(&udpf->uf_lock);
rw_exit(&udp->udp_rwlock);
return (ENOMEM);
}
rw_exit(&udp->udp_rwlock);
if (udp->udp_family == AF_INET6) {
error = ip_proto_bind_laddr_v6(connp, &ire_mp, IPPROTO_UDP,
&udp->udp_bound_v6src, udp->udp_port, B_TRUE);
} else {
error = ip_proto_bind_laddr_v4(connp, &ire_mp, IPPROTO_UDP,
V4_PART_OF_V6(udp->udp_bound_v6src), udp->udp_port, B_TRUE);
}
return (udp_post_ip_bind_connect(udp, ire_mp, error));
}
static void
udp_tpi_disconnect(queue_t *q, mblk_t *mp)
{
conn_t *connp = Q_TO_CONN(q);
int error;
/*
* Allocate the largest primitive we need to send back
* T_error_ack is > than T_ok_ack
*/
mp = reallocb(mp, sizeof (struct T_error_ack), 1);
if (mp == NULL) {
/* Unable to reuse the T_DISCON_REQ for the ack. */
udp_err_ack_prim(q, mp, T_DISCON_REQ, TSYSERR, ENOMEM);
return;
}
error = udp_do_disconnect(connp);
if (error != 0) {
if (error < 0) {
udp_err_ack(q, mp, -error, 0);
} else {
udp_err_ack(q, mp, TSYSERR, error);
}
} else {
mp = mi_tpi_ok_ack_alloc(mp);
ASSERT(mp != NULL);
qreply(q, mp);
}
}
int
udp_disconnect(conn_t *connp)
{
int error;
udp_t *udp = connp->conn_udp;
udp->udp_dgram_errind = B_FALSE;
error = udp_do_disconnect(connp);
if (error < 0)
error = proto_tlitosyserr(-error);
return (error);
}
/* This routine creates a T_ERROR_ACK message and passes it upstream. */
static void
udp_err_ack(queue_t *q, mblk_t *mp, t_scalar_t t_error, int sys_error)
{
if ((mp = mi_tpi_err_ack_alloc(mp, t_error, sys_error)) != NULL)
qreply(q, mp);
}
/* Shorthand to generate and send TPI error acks to our client */
static void
udp_err_ack_prim(queue_t *q, mblk_t *mp, int primitive, t_scalar_t t_error,
int sys_error)
{
struct T_error_ack *teackp;
if ((mp = tpi_ack_alloc(mp, sizeof (struct T_error_ack),
M_PCPROTO, T_ERROR_ACK)) != NULL) {
teackp = (struct T_error_ack *)mp->b_rptr;
teackp->ERROR_prim = primitive;
teackp->TLI_error = t_error;
teackp->UNIX_error = sys_error;
qreply(q, mp);
}
}
/*ARGSUSED*/
static int
udp_extra_priv_ports_get(queue_t *q, mblk_t *mp, caddr_t cp, cred_t *cr)
{
int i;
udp_t *udp = Q_TO_UDP(q);
udp_stack_t *us = udp->udp_us;
for (i = 0; i < us->us_num_epriv_ports; i++) {
if (us->us_epriv_ports[i] != 0)
(void) mi_mpprintf(mp, "%d ", us->us_epriv_ports[i]);
}
return (0);
}
/* ARGSUSED */
static int
udp_extra_priv_ports_add(queue_t *q, mblk_t *mp, char *value, caddr_t cp,
cred_t *cr)
{
long new_value;
int i;
udp_t *udp = Q_TO_UDP(q);
udp_stack_t *us = udp->udp_us;
/*
* Fail the request if the new value does not lie within the
* port number limits.
*/
if (ddi_strtol(value, NULL, 10, &new_value) != 0 ||
new_value <= 0 || new_value >= 65536) {
return (EINVAL);
}
/* Check if the value is already in the list */
for (i = 0; i < us->us_num_epriv_ports; i++) {
if (new_value == us->us_epriv_ports[i]) {
return (EEXIST);
}
}
/* Find an empty slot */
for (i = 0; i < us->us_num_epriv_ports; i++) {
if (us->us_epriv_ports[i] == 0)
break;
}
if (i == us->us_num_epriv_ports) {
return (EOVERFLOW);
}
/* Set the new value */
us->us_epriv_ports[i] = (in_port_t)new_value;
return (0);
}
/* ARGSUSED */
static int
udp_extra_priv_ports_del(queue_t *q, mblk_t *mp, char *value, caddr_t cp,
cred_t *cr)
{
long new_value;
int i;
udp_t *udp = Q_TO_UDP(q);
udp_stack_t *us = udp->udp_us;
/*
* Fail the request if the new value does not lie within the
* port number limits.
*/
if (ddi_strtol(value, NULL, 10, &new_value) != 0 ||
new_value <= 0 || new_value >= 65536) {
return (EINVAL);
}
/* Check that the value is already in the list */
for (i = 0; i < us->us_num_epriv_ports; i++) {
if (us->us_epriv_ports[i] == new_value)
break;
}
if (i == us->us_num_epriv_ports) {
return (ESRCH);
}
/* Clear the value */
us->us_epriv_ports[i] = 0;
return (0);
}
/* At minimum we need 4 bytes of UDP header */
#define ICMP_MIN_UDP_HDR 4
/*
* udp_icmp_error is called by udp_input to process ICMP msgs. passed up by IP.
* Generates the appropriate T_UDERROR_IND for permanent (non-transient) errors.
* Assumes that IP has pulled up everything up to and including the ICMP header.
*/
static void
udp_icmp_error(conn_t *connp, mblk_t *mp)
{
icmph_t *icmph;
ipha_t *ipha;
int iph_hdr_length;
udpha_t *udpha;
sin_t sin;
sin6_t sin6;
mblk_t *mp1;
int error = 0;
udp_t *udp = connp->conn_udp;
mp1 = NULL;
ipha = (ipha_t *)mp->b_rptr;
ASSERT(OK_32PTR(mp->b_rptr));
if (IPH_HDR_VERSION(ipha) != IPV4_VERSION) {
ASSERT(IPH_HDR_VERSION(ipha) == IPV6_VERSION);
udp_icmp_error_ipv6(connp, mp);
return;
}
ASSERT(IPH_HDR_VERSION(ipha) == IPV4_VERSION);
/* Skip past the outer IP and ICMP headers */
iph_hdr_length = IPH_HDR_LENGTH(ipha);
icmph = (icmph_t *)&mp->b_rptr[iph_hdr_length];
ipha = (ipha_t *)&icmph[1];
/* Skip past the inner IP and find the ULP header */
iph_hdr_length = IPH_HDR_LENGTH(ipha);
udpha = (udpha_t *)((char *)ipha + iph_hdr_length);
switch (icmph->icmph_type) {
case ICMP_DEST_UNREACHABLE:
switch (icmph->icmph_code) {
case ICMP_FRAGMENTATION_NEEDED:
/*
* IP has already adjusted the path MTU.
*/
break;
case ICMP_PORT_UNREACHABLE:
case ICMP_PROTOCOL_UNREACHABLE:
error = ECONNREFUSED;
break;
default:
/* Transient errors */
break;
}
break;
default:
/* Transient errors */
break;
}
if (error == 0) {
freemsg(mp);
return;
}
/*
* Deliver T_UDERROR_IND when the application has asked for it.
* The socket layer enables this automatically when connected.
*/
if (!udp->udp_dgram_errind) {
freemsg(mp);
return;
}
switch (udp->udp_family) {
case AF_INET:
sin = sin_null;
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = ipha->ipha_dst;
sin.sin_port = udpha->uha_dst_port;
if (IPCL_IS_NONSTR(connp)) {
rw_enter(&udp->udp_rwlock, RW_WRITER);
if (udp->udp_state == TS_DATA_XFER) {
if (sin.sin_port == udp->udp_dstport &&
sin.sin_addr.s_addr ==
V4_PART_OF_V6(udp->udp_v6dst)) {
rw_exit(&udp->udp_rwlock);
(*connp->conn_upcalls->su_set_error)
(connp->conn_upper_handle, error);
goto done;
}
} else {
udp->udp_delayed_error = error;
*((sin_t *)&udp->udp_delayed_addr) = sin;
}
rw_exit(&udp->udp_rwlock);
} else {
mp1 = mi_tpi_uderror_ind((char *)&sin, sizeof (sin_t),
NULL, 0, error);
}
break;
case AF_INET6:
sin6 = sin6_null;
sin6.sin6_family = AF_INET6;
IN6_IPADDR_TO_V4MAPPED(ipha->ipha_dst, &sin6.sin6_addr);
sin6.sin6_port = udpha->uha_dst_port;
if (IPCL_IS_NONSTR(connp)) {
rw_enter(&udp->udp_rwlock, RW_WRITER);
if (udp->udp_state == TS_DATA_XFER) {
if (sin6.sin6_port == udp->udp_dstport &&
IN6_ARE_ADDR_EQUAL(&sin6.sin6_addr,
&udp->udp_v6dst)) {
rw_exit(&udp->udp_rwlock);
(*connp->conn_upcalls->su_set_error)
(connp->conn_upper_handle, error);
goto done;
}
} else {
udp->udp_delayed_error = error;
*((sin6_t *)&udp->udp_delayed_addr) = sin6;
}
rw_exit(&udp->udp_rwlock);
} else {
mp1 = mi_tpi_uderror_ind((char *)&sin6, sizeof (sin6_t),
NULL, 0, error);
}
break;
}
if (mp1 != NULL)
putnext(connp->conn_rq, mp1);
done:
freemsg(mp);
}
/*
* udp_icmp_error_ipv6 is called by udp_icmp_error to process ICMP for IPv6.
* Generates the appropriate T_UDERROR_IND for permanent (non-transient) errors.
* Assumes that IP has pulled up all the extension headers as well as the
* ICMPv6 header.
*/
static void
udp_icmp_error_ipv6(conn_t *connp, mblk_t *mp)
{
icmp6_t *icmp6;
ip6_t *ip6h, *outer_ip6h;
uint16_t iph_hdr_length;
uint8_t *nexthdrp;
udpha_t *udpha;
sin6_t sin6;
mblk_t *mp1;
int error = 0;
udp_t *udp = connp->conn_udp;
udp_stack_t *us = udp->udp_us;
outer_ip6h = (ip6_t *)mp->b_rptr;
if (outer_ip6h->ip6_nxt != IPPROTO_ICMPV6)
iph_hdr_length = ip_hdr_length_v6(mp, outer_ip6h);
else
iph_hdr_length = IPV6_HDR_LEN;
icmp6 = (icmp6_t *)&mp->b_rptr[iph_hdr_length];
ip6h = (ip6_t *)&icmp6[1];
if (!ip_hdr_length_nexthdr_v6(mp, ip6h, &iph_hdr_length, &nexthdrp)) {
freemsg(mp);
return;
}
udpha = (udpha_t *)((char *)ip6h + iph_hdr_length);
switch (icmp6->icmp6_type) {
case ICMP6_DST_UNREACH:
switch (icmp6->icmp6_code) {
case ICMP6_DST_UNREACH_NOPORT:
error = ECONNREFUSED;
break;
case ICMP6_DST_UNREACH_ADMIN:
case ICMP6_DST_UNREACH_NOROUTE:
case ICMP6_DST_UNREACH_BEYONDSCOPE:
case ICMP6_DST_UNREACH_ADDR:
/* Transient errors */
break;
default:
break;
}
break;
case ICMP6_PACKET_TOO_BIG: {
struct T_unitdata_ind *tudi;
struct T_opthdr *toh;
size_t udi_size;
mblk_t *newmp;
t_scalar_t opt_length = sizeof (struct T_opthdr) +
sizeof (struct ip6_mtuinfo);
sin6_t *sin6;
struct ip6_mtuinfo *mtuinfo;
/*
* If the application has requested to receive path mtu
* information, send up an empty message containing an
* IPV6_PATHMTU ancillary data item.
*/
if (!udp->udp_ipv6_recvpathmtu)
break;
udi_size = sizeof (struct T_unitdata_ind) + sizeof (sin6_t) +
opt_length;
if ((newmp = allocb(udi_size, BPRI_MED)) == NULL) {
BUMP_MIB(&us->us_udp_mib, udpInErrors);
break;
}
/*
* newmp->b_cont is left to NULL on purpose. This is an
* empty message containing only ancillary data.
*/
newmp->b_datap->db_type = M_PROTO;
tudi = (struct T_unitdata_ind *)newmp->b_rptr;
newmp->b_wptr = (uchar_t *)tudi + udi_size;
tudi->PRIM_type = T_UNITDATA_IND;
tudi->SRC_length = sizeof (sin6_t);
tudi->SRC_offset = sizeof (struct T_unitdata_ind);
tudi->OPT_offset = tudi->SRC_offset + sizeof (sin6_t);
tudi->OPT_length = opt_length;
sin6 = (sin6_t *)&tudi[1];
bzero(sin6, sizeof (sin6_t));
sin6->sin6_family = AF_INET6;
sin6->sin6_addr = udp->udp_v6dst;
toh = (struct T_opthdr *)&sin6[1];
toh->level = IPPROTO_IPV6;
toh->name = IPV6_PATHMTU;
toh->len = opt_length;
toh->status = 0;
mtuinfo = (struct ip6_mtuinfo *)&toh[1];
bzero(mtuinfo, sizeof (struct ip6_mtuinfo));
mtuinfo->ip6m_addr.sin6_family = AF_INET6;
mtuinfo->ip6m_addr.sin6_addr = ip6h->ip6_dst;
mtuinfo->ip6m_mtu = icmp6->icmp6_mtu;
/*
* We've consumed everything we need from the original
* message. Free it, then send our empty message.
*/
freemsg(mp);
if (!IPCL_IS_NONSTR(connp)) {
putnext(connp->conn_rq, newmp);
} else {
(*connp->conn_upcalls->su_recv)
(connp->conn_upper_handle, newmp, 0, 0, &error,
NULL);
}
return;
}
case ICMP6_TIME_EXCEEDED:
/* Transient errors */
break;
case ICMP6_PARAM_PROB:
/* If this corresponds to an ICMP_PROTOCOL_UNREACHABLE */
if (icmp6->icmp6_code == ICMP6_PARAMPROB_NEXTHEADER &&
(uchar_t *)ip6h + icmp6->icmp6_pptr ==
(uchar_t *)nexthdrp) {
error = ECONNREFUSED;
break;
}
break;
}
if (error == 0) {
freemsg(mp);
return;
}
/*
* Deliver T_UDERROR_IND when the application has asked for it.
* The socket layer enables this automatically when connected.
*/
if (!udp->udp_dgram_errind) {
freemsg(mp);
return;
}
sin6 = sin6_null;
sin6.sin6_family = AF_INET6;
sin6.sin6_addr = ip6h->ip6_dst;
sin6.sin6_port = udpha->uha_dst_port;
sin6.sin6_flowinfo = ip6h->ip6_vcf & ~IPV6_VERS_AND_FLOW_MASK;
if (IPCL_IS_NONSTR(connp)) {
rw_enter(&udp->udp_rwlock, RW_WRITER);
if (udp->udp_state == TS_DATA_XFER) {
if (sin6.sin6_port == udp->udp_dstport &&
IN6_ARE_ADDR_EQUAL(&sin6.sin6_addr,
&udp->udp_v6dst)) {
rw_exit(&udp->udp_rwlock);
(*connp->conn_upcalls->su_set_error)
(connp->conn_upper_handle, error);
goto done;
}
} else {
udp->udp_delayed_error = error;
*((sin6_t *)&udp->udp_delayed_addr) = sin6;
}
rw_exit(&udp->udp_rwlock);
} else {
mp1 = mi_tpi_uderror_ind((char *)&sin6, sizeof (sin6_t),
NULL, 0, error);
if (mp1 != NULL)
putnext(connp->conn_rq, mp1);
}
done:
freemsg(mp);
}
/*
* This routine responds to T_ADDR_REQ messages. It is called by udp_wput.
* The local address is filled in if endpoint is bound. The remote address
* is filled in if remote address has been precified ("connected endpoint")
* (The concept of connected CLTS sockets is alien to published TPI
* but we support it anyway).
*/
static void
udp_addr_req(queue_t *q, mblk_t *mp)
{
sin_t *sin;
sin6_t *sin6;
mblk_t *ackmp;
struct T_addr_ack *taa;
udp_t *udp = Q_TO_UDP(q);
/* Make it large enough for worst case */
ackmp = reallocb(mp, sizeof (struct T_addr_ack) +
2 * sizeof (sin6_t), 1);
if (ackmp == NULL) {
udp_err_ack(q, mp, TSYSERR, ENOMEM);
return;
}
taa = (struct T_addr_ack *)ackmp->b_rptr;
bzero(taa, sizeof (struct T_addr_ack));
ackmp->b_wptr = (uchar_t *)&taa[1];
taa->PRIM_type = T_ADDR_ACK;
ackmp->b_datap->db_type = M_PCPROTO;
rw_enter(&udp->udp_rwlock, RW_READER);
/*
* Note: Following code assumes 32 bit alignment of basic
* data structures like sin_t and struct T_addr_ack.
*/
if (udp->udp_state != TS_UNBND) {
/*
* Fill in local address first
*/
taa->LOCADDR_offset = sizeof (*taa);
if (udp->udp_family == AF_INET) {
taa->LOCADDR_length = sizeof (sin_t);
sin = (sin_t *)&taa[1];
/* Fill zeroes and then initialize non-zero fields */
*sin = sin_null;
sin->sin_family = AF_INET;
if (!IN6_IS_ADDR_V4MAPPED_ANY(&udp->udp_v6src) &&
!IN6_IS_ADDR_UNSPECIFIED(&udp->udp_v6src)) {
IN6_V4MAPPED_TO_IPADDR(&udp->udp_v6src,
sin->sin_addr.s_addr);
} else {
/*
* INADDR_ANY
* udp_v6src is not set, we might be bound to
* broadcast/multicast. Use udp_bound_v6src as
* local address instead (that could
* also still be INADDR_ANY)
*/
IN6_V4MAPPED_TO_IPADDR(&udp->udp_bound_v6src,
sin->sin_addr.s_addr);
}
sin->sin_port = udp->udp_port;
ackmp->b_wptr = (uchar_t *)&sin[1];
if (udp->udp_state == TS_DATA_XFER) {
/*
* connected, fill remote address too
*/
taa->REMADDR_length = sizeof (sin_t);
/* assumed 32-bit alignment */
taa->REMADDR_offset = taa->LOCADDR_offset +
taa->LOCADDR_length;
sin = (sin_t *)(ackmp->b_rptr +
taa->REMADDR_offset);
/* initialize */
*sin = sin_null;
sin->sin_family = AF_INET;
sin->sin_addr.s_addr =
V4_PART_OF_V6(udp->udp_v6dst);
sin->sin_port = udp->udp_dstport;
ackmp->b_wptr = (uchar_t *)&sin[1];
}
} else {
taa->LOCADDR_length = sizeof (sin6_t);
sin6 = (sin6_t *)&taa[1];
/* Fill zeroes and then initialize non-zero fields */
*sin6 = sin6_null;
sin6->sin6_family = AF_INET6;
if (!IN6_IS_ADDR_UNSPECIFIED(&udp->udp_v6src)) {
sin6->sin6_addr = udp->udp_v6src;
} else {
/*
* UNSPECIFIED
* udp_v6src is not set, we might be bound to
* broadcast/multicast. Use udp_bound_v6src as
* local address instead (that could
* also still be UNSPECIFIED)
*/
sin6->sin6_addr =
udp->udp_bound_v6src;
}
sin6->sin6_port = udp->udp_port;
ackmp->b_wptr = (uchar_t *)&sin6[1];
if (udp->udp_state == TS_DATA_XFER) {
/*
* connected, fill remote address too
*/
taa->REMADDR_length = sizeof (sin6_t);
/* assumed 32-bit alignment */
taa->REMADDR_offset = taa->LOCADDR_offset +
taa->LOCADDR_length;
sin6 = (sin6_t *)(ackmp->b_rptr +
taa->REMADDR_offset);
/* initialize */
*sin6 = sin6_null;
sin6->sin6_family = AF_INET6;
sin6->sin6_addr = udp->udp_v6dst;
sin6->sin6_port = udp->udp_dstport;
ackmp->b_wptr = (uchar_t *)&sin6[1];
}
ackmp->b_wptr = (uchar_t *)&sin6[1];
}
}
rw_exit(&udp->udp_rwlock);
ASSERT(ackmp->b_wptr <= ackmp->b_datap->db_lim);
qreply(q, ackmp);
}
static void
udp_copy_info(struct T_info_ack *tap, udp_t *udp)
{
if (udp->udp_family == AF_INET) {
*tap = udp_g_t_info_ack_ipv4;
} else {
*tap = udp_g_t_info_ack_ipv6;
}
tap->CURRENT_state = udp->udp_state;
tap->OPT_size = udp_max_optsize;
}
static void
udp_do_capability_ack(udp_t *udp, struct T_capability_ack *tcap,
t_uscalar_t cap_bits1)
{
tcap->CAP_bits1 = 0;
if (cap_bits1 & TC1_INFO) {
udp_copy_info(&tcap->INFO_ack, udp);
tcap->CAP_bits1 |= TC1_INFO;
}
}
/*
* This routine responds to T_CAPABILITY_REQ messages. It is called by
* udp_wput. Much of the T_CAPABILITY_ACK information is copied from
* udp_g_t_info_ack. The current state of the stream is copied from
* udp_state.
*/
static void
udp_capability_req(queue_t *q, mblk_t *mp)
{
t_uscalar_t cap_bits1;
struct T_capability_ack *tcap;
udp_t *udp = Q_TO_UDP(q);
cap_bits1 = ((struct T_capability_req *)mp->b_rptr)->CAP_bits1;
mp = tpi_ack_alloc(mp, sizeof (struct T_capability_ack),
mp->b_datap->db_type, T_CAPABILITY_ACK);
if (!mp)
return;
tcap = (struct T_capability_ack *)mp->b_rptr;
udp_do_capability_ack(udp, tcap, cap_bits1);
qreply(q, mp);
}
/*
* This routine responds to T_INFO_REQ messages. It is called by udp_wput.
* Most of the T_INFO_ACK information is copied from udp_g_t_info_ack.
* The current state of the stream is copied from udp_state.
*/
static void
udp_info_req(queue_t *q, mblk_t *mp)
{
udp_t *udp = Q_TO_UDP(q);
/* Create a T_INFO_ACK message. */
mp = tpi_ack_alloc(mp, sizeof (struct T_info_ack), M_PCPROTO,
T_INFO_ACK);
if (!mp)
return;
udp_copy_info((struct T_info_ack *)mp->b_rptr, udp);
qreply(q, mp);
}
/*
* IP recognizes seven kinds of bind requests:
*
* - A zero-length address binds only to the protocol number.
*
* - A 4-byte address is treated as a request to
* validate that the address is a valid local IPv4
* address, appropriate for an application to bind to.
* IP does the verification, but does not make any note
* of the address at this time.
*
* - A 16-byte address contains is treated as a request
* to validate a local IPv6 address, as the 4-byte
* address case above.
*
* - A 16-byte sockaddr_in to validate the local IPv4 address and also
* use it for the inbound fanout of packets.
*
* - A 24-byte sockaddr_in6 to validate the local IPv6 address and also
* use it for the inbound fanout of packets.
*
* - A 12-byte address (ipa_conn_t) containing complete IPv4 fanout
* information consisting of local and remote addresses
* and ports. In this case, the addresses are both
* validated as appropriate for this operation, and, if
* so, the information is retained for use in the
* inbound fanout.
*
* - A 36-byte address address (ipa6_conn_t) containing complete IPv6
* fanout information, like the 12-byte case above.
*
* IP will also fill in the IRE request mblk with information
* regarding our peer. In all cases, we notify IP of our protocol
* type by appending a single protocol byte to the bind request.
*/
static mblk_t *
udp_ip_bind_mp(udp_t *udp, t_scalar_t bind_prim, t_scalar_t addr_length)
{
char *cp;
mblk_t *mp;
struct T_bind_req *tbr;
ipa_conn_t *ac;
ipa6_conn_t *ac6;
sin_t *sin;
sin6_t *sin6;
ASSERT(bind_prim == O_T_BIND_REQ || bind_prim == T_BIND_REQ);
ASSERT(RW_LOCK_HELD(&udp->udp_rwlock));
mp = allocb(sizeof (*tbr) + addr_length + 1, BPRI_HI);
if (!mp)
return (mp);
mp->b_datap->db_type = M_PROTO;
tbr = (struct T_bind_req *)mp->b_rptr;
tbr->PRIM_type = bind_prim;
tbr->ADDR_offset = sizeof (*tbr);
tbr->CONIND_number = 0;
tbr->ADDR_length = addr_length;
cp = (char *)&tbr[1];
switch (addr_length) {
case sizeof (ipa_conn_t):
ASSERT(udp->udp_family == AF_INET);
/* Append a request for an IRE */
mp->b_cont = allocb(sizeof (ire_t), BPRI_HI);
if (!mp->b_cont) {
freemsg(mp);
return (NULL);
}
mp->b_cont->b_wptr += sizeof (ire_t);
mp->b_cont->b_datap->db_type = IRE_DB_REQ_TYPE;
/* cp known to be 32 bit aligned */
ac = (ipa_conn_t *)cp;
ac->ac_laddr = V4_PART_OF_V6(udp->udp_v6src);
ac->ac_faddr = V4_PART_OF_V6(udp->udp_v6dst);
ac->ac_fport = udp->udp_dstport;
ac->ac_lport = udp->udp_port;
break;
case sizeof (ipa6_conn_t):
ASSERT(udp->udp_family == AF_INET6);
/* Append a request for an IRE */
mp->b_cont = allocb(sizeof (ire_t), BPRI_HI);
if (!mp->b_cont) {
freemsg(mp);
return (NULL);
}
mp->b_cont->b_wptr += sizeof (ire_t);
mp->b_cont->b_datap->db_type = IRE_DB_REQ_TYPE;
/* cp known to be 32 bit aligned */
ac6 = (ipa6_conn_t *)cp;
ac6->ac6_laddr = udp->udp_v6src;
ac6->ac6_faddr = udp->udp_v6dst;
ac6->ac6_fport = udp->udp_dstport;
ac6->ac6_lport = udp->udp_port;
break;
case sizeof (sin_t):
ASSERT(udp->udp_family == AF_INET);
/* Append a request for an IRE */
mp->b_cont = allocb(sizeof (ire_t), BPRI_HI);
if (!mp->b_cont) {
freemsg(mp);
return (NULL);
}
mp->b_cont->b_wptr += sizeof (ire_t);
mp->b_cont->b_datap->db_type = IRE_DB_REQ_TYPE;
sin = (sin_t *)cp;
*sin = sin_null;
sin->sin_family = AF_INET;
sin->sin_addr.s_addr = V4_PART_OF_V6(udp->udp_bound_v6src);
sin->sin_port = udp->udp_port;
break;
case sizeof (sin6_t):
ASSERT(udp->udp_family == AF_INET6);
/* Append a request for an IRE */
mp->b_cont = allocb(sizeof (ire_t), BPRI_HI);
if (!mp->b_cont) {
freemsg(mp);
return (NULL);
}
mp->b_cont->b_wptr += sizeof (ire_t);
mp->b_cont->b_datap->db_type = IRE_DB_REQ_TYPE;
sin6 = (sin6_t *)cp;
*sin6 = sin6_null;
sin6->sin6_family = AF_INET6;
sin6->sin6_addr = udp->udp_bound_v6src;
sin6->sin6_port = udp->udp_port;
break;
}
/* Add protocol number to end */
cp[addr_length] = (char)IPPROTO_UDP;
mp->b_wptr = (uchar_t *)&cp[addr_length + 1];
return (mp);
}
/* For /dev/udp aka AF_INET open */
static int
udp_openv4(queue_t *q, dev_t *devp, int flag, int sflag, cred_t *credp)
{
return (udp_open(q, devp, flag, sflag, credp, B_FALSE));
}
/* For /dev/udp6 aka AF_INET6 open */
static int
udp_openv6(queue_t *q, dev_t *devp, int flag, int sflag, cred_t *credp)
{
return (udp_open(q, devp, flag, sflag, credp, B_TRUE));
}
/*
* This is the open routine for udp. It allocates a udp_t structure for
* the stream and, on the first open of the module, creates an ND table.
*/
/*ARGSUSED2*/
static int
udp_open(queue_t *q, dev_t *devp, int flag, int sflag, cred_t *credp,
boolean_t isv6)
{
int error;
udp_t *udp;
conn_t *connp;
dev_t conn_dev;
udp_stack_t *us;
vmem_t *minor_arena;
TRACE_1(TR_FAC_UDP, TR_UDP_OPEN, "udp_open: q %p", q);
/* If the stream is already open, return immediately. */
if (q->q_ptr != NULL)
return (0);
if (sflag == MODOPEN)
return (EINVAL);
if ((ip_minor_arena_la != NULL) && (flag & SO_SOCKSTR) &&
((conn_dev = inet_minor_alloc(ip_minor_arena_la)) != 0)) {
minor_arena = ip_minor_arena_la;
} else {
/*
* Either minor numbers in the large arena were exhausted
* or a non socket application is doing the open.
* Try to allocate from the small arena.
*/
if ((conn_dev = inet_minor_alloc(ip_minor_arena_sa)) == 0)
return (EBUSY);
minor_arena = ip_minor_arena_sa;
}
if (flag & SO_FALLBACK) {
/*
* Non streams socket needs a stream to fallback to
*/
RD(q)->q_ptr = (void *)conn_dev;
WR(q)->q_qinfo = &udp_fallback_sock_winit;
WR(q)->q_ptr = (void *)minor_arena;
qprocson(q);
return (0);
}
connp = udp_do_open(credp, isv6, KM_SLEEP);
if (connp == NULL) {
inet_minor_free(minor_arena, conn_dev);
return (ENOMEM);
}
udp = connp->conn_udp;
us = udp->udp_us;
*devp = makedevice(getemajor(*devp), (minor_t)conn_dev);
connp->conn_dev = conn_dev;
connp->conn_minor_arena = minor_arena;
/*
* Initialize the udp_t structure for this stream.
*/
q->q_ptr = connp;
WR(q)->q_ptr = connp;
connp->conn_rq = q;
connp->conn_wq = WR(q);
rw_enter(&udp->udp_rwlock, RW_WRITER);
ASSERT(connp->conn_ulp == IPPROTO_UDP);
ASSERT(connp->conn_udp == udp);
ASSERT(udp->udp_connp == connp);
if (flag & SO_SOCKSTR) {
connp->conn_flags |= IPCL_SOCKET;
udp->udp_issocket = B_TRUE;
udp->udp_direct_sockfs = B_TRUE;
}
q->q_hiwat = us->us_recv_hiwat;
WR(q)->q_hiwat = us->us_xmit_hiwat;
WR(q)->q_lowat = us->us_xmit_lowat;
qprocson(q);
if (udp->udp_family == AF_INET6) {
/* Build initial header template for transmit */
if ((error = udp_build_hdrs(udp)) != 0) {
rw_exit(&udp->udp_rwlock);
qprocsoff(q);
inet_minor_free(minor_arena, conn_dev);
ipcl_conn_destroy(connp);
return (error);
}
}
rw_exit(&udp->udp_rwlock);
/* Set the Stream head write offset and high watermark. */
(void) proto_set_tx_wroff(q, connp,
udp->udp_max_hdr_len + us->us_wroff_extra);
/* XXX udp_set_rcv_hiwat() doesn't hold the lock, is it a bug??? */
(void) proto_set_rx_hiwat(q, connp, udp_set_rcv_hiwat(udp, q->q_hiwat));
mutex_enter(&connp->conn_lock);
connp->conn_state_flags &= ~CONN_INCIPIENT;
mutex_exit(&connp->conn_lock);
return (0);
}
/*
* Which UDP options OK to set through T_UNITDATA_REQ...
*/
/* ARGSUSED */
static boolean_t
udp_opt_allow_udr_set(t_scalar_t level, t_scalar_t name)
{
return (B_TRUE);
}
/*
* This routine gets default values of certain options whose default
* values are maintained by protcol specific code
*/
/* ARGSUSED */
int
udp_opt_default(queue_t *q, t_scalar_t level, t_scalar_t name, uchar_t *ptr)
{
udp_t *udp = Q_TO_UDP(q);
udp_stack_t *us = udp->udp_us;
int *i1 = (int *)ptr;
switch (level) {
case IPPROTO_IP:
switch (name) {
case IP_MULTICAST_TTL:
*ptr = (uchar_t)IP_DEFAULT_MULTICAST_TTL;
return (sizeof (uchar_t));
case IP_MULTICAST_LOOP:
*ptr = (uchar_t)IP_DEFAULT_MULTICAST_LOOP;
return (sizeof (uchar_t));
}
break;
case IPPROTO_IPV6:
switch (name) {
case IPV6_MULTICAST_HOPS:
*i1 = IP_DEFAULT_MULTICAST_TTL;
return (sizeof (int));
case IPV6_MULTICAST_LOOP:
*i1 = IP_DEFAULT_MULTICAST_LOOP;
return (sizeof (int));
case IPV6_UNICAST_HOPS:
*i1 = us->us_ipv6_hoplimit;
return (sizeof (int));
}
break;
}
return (-1);
}
/*
* This routine retrieves the current status of socket options.
* It returns the size of the option retrieved.
*/
static int
udp_opt_get(conn_t *connp, int level, int name, uchar_t *ptr)
{
udp_t *udp = connp->conn_udp;
udp_stack_t *us = udp->udp_us;
int *i1 = (int *)ptr;
ip6_pkt_t *ipp = &udp->udp_sticky_ipp;
int len;
ASSERT(RW_READ_HELD(&udp->udp_rwlock));
switch (level) {
case SOL_SOCKET:
switch (name) {
case SO_DEBUG:
*i1 = udp->udp_debug;
break; /* goto sizeof (int) option return */
case SO_REUSEADDR:
*i1 = udp->udp_reuseaddr;
break; /* goto sizeof (int) option return */
case SO_TYPE:
*i1 = SOCK_DGRAM;
break; /* goto sizeof (int) option return */
/*
* The following three items are available here,
* but are only meaningful to IP.
*/
case SO_DONTROUTE:
*i1 = udp->udp_dontroute;
break; /* goto sizeof (int) option return */
case SO_USELOOPBACK:
*i1 = udp->udp_useloopback;
break; /* goto sizeof (int) option return */
case SO_BROADCAST:
*i1 = udp->udp_broadcast;
break; /* goto sizeof (int) option return */
case SO_SNDBUF:
*i1 = udp->udp_xmit_hiwat;
break; /* goto sizeof (int) option return */
case SO_RCVBUF:
*i1 = udp->udp_rcv_disply_hiwat;
break; /* goto sizeof (int) option return */
case SO_DGRAM_ERRIND:
*i1 = udp->udp_dgram_errind;
break; /* goto sizeof (int) option return */
case SO_RECVUCRED:
*i1 = udp->udp_recvucred;
break; /* goto sizeof (int) option return */
case SO_TIMESTAMP:
*i1 = udp->udp_timestamp;
break; /* goto sizeof (int) option return */
case SO_ANON_MLP:
*i1 = connp->conn_anon_mlp;
break; /* goto sizeof (int) option return */
case SO_MAC_EXEMPT:
*i1 = connp->conn_mac_exempt;
break; /* goto sizeof (int) option return */
case SO_ALLZONES:
*i1 = connp->conn_allzones;
break; /* goto sizeof (int) option return */
case SO_EXCLBIND:
*i1 = udp->udp_exclbind ? SO_EXCLBIND : 0;
break;
case SO_PROTOTYPE:
*i1 = IPPROTO_UDP;
break;
case SO_DOMAIN:
*i1 = udp->udp_family;
break;
default:
return (-1);
}
break;
case IPPROTO_IP:
if (udp->udp_family != AF_INET)
return (-1);
switch (name) {
case IP_OPTIONS:
case T_IP_OPTIONS:
len = udp->udp_ip_rcv_options_len - udp->udp_label_len;
if (len > 0) {
bcopy(udp->udp_ip_rcv_options +
udp->udp_label_len, ptr, len);
}
return (len);
case IP_TOS:
case T_IP_TOS:
*i1 = (int)udp->udp_type_of_service;
break; /* goto sizeof (int) option return */
case IP_TTL:
*i1 = (int)udp->udp_ttl;
break; /* goto sizeof (int) option return */
case IP_DHCPINIT_IF:
return (-EINVAL);
case IP_NEXTHOP:
case IP_RECVPKTINFO:
/*
* This also handles IP_PKTINFO.
* IP_PKTINFO and IP_RECVPKTINFO have the same value.
* Differentiation is based on the size of the argument
* passed in.
* This option is handled in IP which will return an
* error for IP_PKTINFO as it's not supported as a
* sticky option.
*/
return (-EINVAL);
case IP_MULTICAST_IF:
/* 0 address if not set */
*(ipaddr_t *)ptr = udp->udp_multicast_if_addr;
return (sizeof (ipaddr_t));
case IP_MULTICAST_TTL:
*(uchar_t *)ptr = udp->udp_multicast_ttl;
return (sizeof (uchar_t));
case IP_MULTICAST_LOOP:
*ptr = connp->conn_multicast_loop;
return (sizeof (uint8_t));
case IP_RECVOPTS:
*i1 = udp->udp_recvopts;
break; /* goto sizeof (int) option return */
case IP_RECVDSTADDR:
*i1 = udp->udp_recvdstaddr;
break; /* goto sizeof (int) option return */
case IP_RECVIF:
*i1 = udp->udp_recvif;
break; /* goto sizeof (int) option return */
case IP_RECVSLLA:
*i1 = udp->udp_recvslla;
break; /* goto sizeof (int) option return */
case IP_RECVTTL:
*i1 = udp->udp_recvttl;
break; /* goto sizeof (int) option return */
case IP_ADD_MEMBERSHIP:
case IP_DROP_MEMBERSHIP:
case IP_BLOCK_SOURCE:
case IP_UNBLOCK_SOURCE:
case IP_ADD_SOURCE_MEMBERSHIP:
case IP_DROP_SOURCE_MEMBERSHIP:
case MCAST_JOIN_GROUP:
case MCAST_LEAVE_GROUP:
case MCAST_BLOCK_SOURCE:
case MCAST_UNBLOCK_SOURCE:
case MCAST_JOIN_SOURCE_GROUP:
case MCAST_LEAVE_SOURCE_GROUP:
/* cannot "get" the value for these */
return (-1);
case IP_BOUND_IF:
/* Zero if not set */
*i1 = udp->udp_bound_if;
break; /* goto sizeof (int) option return */
case IP_UNSPEC_SRC:
*i1 = udp->udp_unspec_source;
break; /* goto sizeof (int) option return */
case IP_BROADCAST_TTL:
*(uchar_t *)ptr = connp->conn_broadcast_ttl;
return (sizeof (uchar_t));
default:
return (-1);
}
break;
case IPPROTO_IPV6:
if (udp->udp_family != AF_INET6)
return (-1);
switch (name) {
case IPV6_UNICAST_HOPS:
*i1 = (unsigned int)udp->udp_ttl;
break; /* goto sizeof (int) option return */
case IPV6_MULTICAST_IF:
/* 0 index if not set */
*i1 = udp->udp_multicast_if_index;
break; /* goto sizeof (int) option return */
case IPV6_MULTICAST_HOPS:
*i1 = udp->udp_multicast_ttl;
break; /* goto sizeof (int) option return */
case IPV6_MULTICAST_LOOP:
*i1 = connp->conn_multicast_loop;
break; /* goto sizeof (int) option return */
case IPV6_JOIN_GROUP:
case IPV6_LEAVE_GROUP:
case MCAST_JOIN_GROUP:
case MCAST_LEAVE_GROUP:
case MCAST_BLOCK_SOURCE:
case MCAST_UNBLOCK_SOURCE:
case MCAST_JOIN_SOURCE_GROUP:
case MCAST_LEAVE_SOURCE_GROUP:
/* cannot "get" the value for these */
return (-1);
case IPV6_BOUND_IF:
/* Zero if not set */
*i1 = udp->udp_bound_if;
break; /* goto sizeof (int) option return */
case IPV6_UNSPEC_SRC:
*i1 = udp->udp_unspec_source;
break; /* goto sizeof (int) option return */
case IPV6_RECVPKTINFO:
*i1 = udp->udp_ip_recvpktinfo;
break; /* goto sizeof (int) option return */
case IPV6_RECVTCLASS:
*i1 = udp->udp_ipv6_recvtclass;
break; /* goto sizeof (int) option return */
case IPV6_RECVPATHMTU:
*i1 = udp->udp_ipv6_recvpathmtu;
break; /* goto sizeof (int) option return */
case IPV6_RECVHOPLIMIT:
*i1 = udp->udp_ipv6_recvhoplimit;
break; /* goto sizeof (int) option return */
case IPV6_RECVHOPOPTS:
*i1 = udp->udp_ipv6_recvhopopts;
break; /* goto sizeof (int) option return */
case IPV6_RECVDSTOPTS:
*i1 = udp->udp_ipv6_recvdstopts;
break; /* goto sizeof (int) option return */
case _OLD_IPV6_RECVDSTOPTS:
*i1 = udp->udp_old_ipv6_recvdstopts;
break; /* goto sizeof (int) option return */
case IPV6_RECVRTHDRDSTOPTS:
*i1 = udp->udp_ipv6_recvrthdrdstopts;
break; /* goto sizeof (int) option return */
case IPV6_RECVRTHDR:
*i1 = udp->udp_ipv6_recvrthdr;
break; /* goto sizeof (int) option return */
case IPV6_PKTINFO: {
/* XXX assumes that caller has room for max size! */
struct in6_pktinfo *pkti;
pkti = (struct in6_pktinfo *)ptr;
if (ipp->ipp_fields & IPPF_IFINDEX)
pkti->ipi6_ifindex = ipp->ipp_ifindex;
else
pkti->ipi6_ifindex = 0;
if (ipp->ipp_fields & IPPF_ADDR)
pkti->ipi6_addr = ipp->ipp_addr;
else
pkti->ipi6_addr = ipv6_all_zeros;
return (sizeof (struct in6_pktinfo));
}
case IPV6_TCLASS:
if (ipp->ipp_fields & IPPF_TCLASS)
*i1 = ipp->ipp_tclass;
else
*i1 = IPV6_FLOW_TCLASS(
IPV6_DEFAULT_VERS_AND_FLOW);
break; /* goto sizeof (int) option return */
case IPV6_NEXTHOP: {
sin6_t *sin6 = (sin6_t *)ptr;
if (!(ipp->ipp_fields & IPPF_NEXTHOP))
return (0);
*sin6 = sin6_null;
sin6->sin6_family = AF_INET6;
sin6->sin6_addr = ipp->ipp_nexthop;
return (sizeof (sin6_t));
}
case IPV6_HOPOPTS:
if (!(ipp->ipp_fields & IPPF_HOPOPTS))
return (0);
if (ipp->ipp_hopoptslen <= udp->udp_label_len_v6)
return (0);
/*
* The cipso/label option is added by kernel.
* User is not usually aware of this option.
* We copy out the hbh opt after the label option.
*/
bcopy((char *)ipp->ipp_hopopts + udp->udp_label_len_v6,
ptr, ipp->ipp_hopoptslen - udp->udp_label_len_v6);
if (udp->udp_label_len_v6 > 0) {
ptr[0] = ((char *)ipp->ipp_hopopts)[0];
ptr[1] = (ipp->ipp_hopoptslen -
udp->udp_label_len_v6 + 7) / 8 - 1;
}
return (ipp->ipp_hopoptslen - udp->udp_label_len_v6);
case IPV6_RTHDRDSTOPTS:
if (!(ipp->ipp_fields & IPPF_RTDSTOPTS))
return (0);
bcopy(ipp->ipp_rtdstopts, ptr, ipp->ipp_rtdstoptslen);
return (ipp->ipp_rtdstoptslen);
case IPV6_RTHDR:
if (!(ipp->ipp_fields & IPPF_RTHDR))
return (0);
bcopy(ipp->ipp_rthdr, ptr, ipp->ipp_rthdrlen);
return (ipp->ipp_rthdrlen);
case IPV6_DSTOPTS:
if (!(ipp->ipp_fields & IPPF_DSTOPTS))
return (0);
bcopy(ipp->ipp_dstopts, ptr, ipp->ipp_dstoptslen);
return (ipp->ipp_dstoptslen);
case IPV6_PATHMTU:
return (ip_fill_mtuinfo(&udp->udp_v6dst,
udp->udp_dstport, (struct ip6_mtuinfo *)ptr,
us->us_netstack));
default:
return (-1);
}
break;
case IPPROTO_UDP:
switch (name) {
case UDP_ANONPRIVBIND:
*i1 = udp->udp_anon_priv_bind;
break;
case UDP_EXCLBIND:
*i1 = udp->udp_exclbind ? UDP_EXCLBIND : 0;
break;
case UDP_RCVHDR:
*i1 = udp->udp_rcvhdr ? 1 : 0;
break;
case UDP_NAT_T_ENDPOINT:
*i1 = udp->udp_nat_t_endpoint;
break;
default:
return (-1);
}
break;
default:
return (-1);
}
return (sizeof (int));
}
int
udp_tpi_opt_get(queue_t *q, t_scalar_t level, t_scalar_t name, uchar_t *ptr)
{
udp_t *udp;
int err;
udp = Q_TO_UDP(q);
rw_enter(&udp->udp_rwlock, RW_READER);
err = udp_opt_get(Q_TO_CONN(q), level, name, ptr);
rw_exit(&udp->udp_rwlock);
return (err);
}
/*
* This routine sets socket options.
*/
/* ARGSUSED */
static int
udp_do_opt_set(conn_t *connp, int level, int name, uint_t inlen,
uchar_t *invalp, uint_t *outlenp, uchar_t *outvalp, cred_t *cr,
void *thisdg_attrs, boolean_t checkonly)
{
udpattrs_t *attrs = thisdg_attrs;
int *i1 = (int *)invalp;
boolean_t onoff = (*i1 == 0) ? 0 : 1;
udp_t *udp = connp->conn_udp;
udp_stack_t *us = udp->udp_us;
int error;
uint_t newlen;
size_t sth_wroff;
ASSERT(RW_WRITE_HELD(&udp->udp_rwlock));
/*
* For fixed length options, no sanity check
* of passed in length is done. It is assumed *_optcom_req()
* routines do the right thing.
*/
switch (level) {
case SOL_SOCKET:
switch (name) {
case SO_REUSEADDR:
if (!checkonly) {
udp->udp_reuseaddr = onoff;
PASS_OPT_TO_IP(connp);
}
break;
case SO_DEBUG:
if (!checkonly)
udp->udp_debug = onoff;
break;
/*
* The following three items are available here,
* but are only meaningful to IP.
*/
case SO_DONTROUTE:
if (!checkonly) {
udp->udp_dontroute = onoff;
PASS_OPT_TO_IP(connp);
}
break;
case SO_USELOOPBACK:
if (!checkonly) {
udp->udp_useloopback = onoff;
PASS_OPT_TO_IP(connp);
}
break;
case SO_BROADCAST:
if (!checkonly) {
udp->udp_broadcast = onoff;
PASS_OPT_TO_IP(connp);
}
break;
case SO_SNDBUF:
if (*i1 > us->us_max_buf) {
*outlenp = 0;
return (ENOBUFS);
}
if (!checkonly) {
udp->udp_xmit_hiwat = *i1;
connp->conn_wq->q_hiwat = *i1;
}
break;
case SO_RCVBUF:
if (*i1 > us->us_max_buf) {
*outlenp = 0;
return (ENOBUFS);
}
if (!checkonly) {
int size;
udp->udp_rcv_disply_hiwat = *i1;
size = udp_set_rcv_hiwat(udp, *i1);
rw_exit(&udp->udp_rwlock);
(void) proto_set_rx_hiwat(connp->conn_rq, connp,
size);
rw_enter(&udp->udp_rwlock, RW_WRITER);
}
break;
case SO_DGRAM_ERRIND:
if (!checkonly)
udp->udp_dgram_errind = onoff;
break;
case SO_RECVUCRED:
if (!checkonly)
udp->udp_recvucred = onoff;
break;
case SO_ALLZONES:
/*
* "soft" error (negative)
* option not handled at this level
* Do not modify *outlenp.
*/
return (-EINVAL);
case SO_TIMESTAMP:
if (!checkonly)
udp->udp_timestamp = onoff;
break;
case SO_ANON_MLP:
if (!checkonly) {
connp->conn_anon_mlp = onoff;
PASS_OPT_TO_IP(connp);
}
break;
case SO_MAC_EXEMPT:
if (secpolicy_net_mac_aware(cr) != 0 ||
udp->udp_state != TS_UNBND)
return (EACCES);
if (!checkonly) {
connp->conn_mac_exempt = onoff;
PASS_OPT_TO_IP(connp);
}
break;
case SCM_UCRED: {
struct ucred_s *ucr;
cred_t *cr, *newcr;
ts_label_t *tsl;
/*
* Only sockets that have proper privileges and are
* bound to MLPs will have any other value here, so
* this implicitly tests for privilege to set label.
*/
if (connp->conn_mlp_type == mlptSingle)
break;
ucr = (struct ucred_s *)invalp;
if (inlen != ucredsize ||
ucr->uc_labeloff < sizeof (*ucr) ||
ucr->uc_labeloff + sizeof (bslabel_t) > inlen)
return (EINVAL);
if (!checkonly) {
mblk_t *mb;
pid_t cpid;
if (attrs == NULL ||
(mb = attrs->udpattr_mb) == NULL)
return (EINVAL);
if ((cr = msg_getcred(mb, &cpid)) == NULL)
cr = udp->udp_connp->conn_cred;
ASSERT(cr != NULL);
if ((tsl = crgetlabel(cr)) == NULL)
return (EINVAL);
newcr = copycred_from_bslabel(cr, UCLABEL(ucr),
tsl->tsl_doi, KM_NOSLEEP);
if (newcr == NULL)
return (ENOSR);
mblk_setcred(mb, newcr, cpid);
attrs->udpattr_credset = B_TRUE;
crfree(newcr);
}
break;
}
case SO_EXCLBIND:
if (!checkonly)
udp->udp_exclbind = onoff;
break;
case SO_RCVTIMEO:
case SO_SNDTIMEO:
/*
* Pass these two options in order for third part
* protocol usage. Here just return directly.
*/
return (0);
default:
*outlenp = 0;
return (EINVAL);
}
break;
case IPPROTO_IP:
if (udp->udp_family != AF_INET) {
*outlenp = 0;
return (ENOPROTOOPT);
}
switch (name) {
case IP_OPTIONS:
case T_IP_OPTIONS:
/* Save options for use by IP. */
newlen = inlen + udp->udp_label_len;
if ((inlen & 0x3) || newlen > IP_MAX_OPT_LENGTH) {
*outlenp = 0;
return (EINVAL);
}
if (checkonly)
break;
/*
* Update the stored options taking into account
* any CIPSO option which we should not overwrite.
*/
if (!tsol_option_set(&udp->udp_ip_snd_options,
&udp->udp_ip_snd_options_len,
udp->udp_label_len, invalp, inlen)) {
*outlenp = 0;
return (ENOMEM);
}
udp->udp_max_hdr_len = IP_SIMPLE_HDR_LENGTH +
UDPH_SIZE + udp->udp_ip_snd_options_len;
sth_wroff = udp->udp_max_hdr_len + us->us_wroff_extra;
rw_exit(&udp->udp_rwlock);
(void) proto_set_tx_wroff(connp->conn_rq, connp,
sth_wroff);
rw_enter(&udp->udp_rwlock, RW_WRITER);
break;
case IP_TTL:
if (!checkonly) {
udp->udp_ttl = (uchar_t)*i1;
}
break;
case IP_TOS:
case T_IP_TOS:
if (!checkonly) {
udp->udp_type_of_service = (uchar_t)*i1;
}
break;
case IP_MULTICAST_IF: {
/*
* TODO should check OPTMGMT reply and undo this if
* there is an error.
*/
struct in_addr *inap = (struct in_addr *)invalp;
if (!checkonly) {
udp->udp_multicast_if_addr =
inap->s_addr;
PASS_OPT_TO_IP(connp);
}
break;
}
case IP_MULTICAST_TTL:
if (!checkonly)
udp->udp_multicast_ttl = *invalp;
break;
case IP_MULTICAST_LOOP:
if (!checkonly) {
connp->conn_multicast_loop = *invalp;
PASS_OPT_TO_IP(connp);
}
break;
case IP_RECVOPTS:
if (!checkonly)
udp->udp_recvopts = onoff;
break;
case IP_RECVDSTADDR:
if (!checkonly)
udp->udp_recvdstaddr = onoff;
break;
case IP_RECVIF:
if (!checkonly) {
udp->udp_recvif = onoff;
PASS_OPT_TO_IP(connp);
}
break;
case IP_RECVSLLA:
if (!checkonly) {
udp->udp_recvslla = onoff;
PASS_OPT_TO_IP(connp);
}
break;
case IP_RECVTTL:
if (!checkonly)
udp->udp_recvttl = onoff;
break;
case IP_PKTINFO: {
/*
* This also handles IP_RECVPKTINFO.
* IP_PKTINFO and IP_RECVPKTINFO have same value.
* Differentiation is based on the size of the
* argument passed in.
*/
struct in_pktinfo *pktinfop;
ip4_pkt_t *attr_pktinfop;
if (checkonly)
break;
if (inlen == sizeof (int)) {
/*
* This is IP_RECVPKTINFO option.
* Keep a local copy of whether this option is
* set or not and pass it down to IP for
* processing.
*/
udp->udp_ip_recvpktinfo = onoff;
return (-EINVAL);
}
if (attrs == NULL ||
(attr_pktinfop = attrs->udpattr_ipp4) == NULL) {
/*
* sticky option or no buffer to return
* the results.
*/
return (EINVAL);
}
if (inlen != sizeof (struct in_pktinfo))
return (EINVAL);
pktinfop = (struct in_pktinfo *)invalp;
/*
* At least one of the values should be specified
*/
if (pktinfop->ipi_ifindex == 0 &&
pktinfop->ipi_spec_dst.s_addr == INADDR_ANY) {
return (EINVAL);
}
attr_pktinfop->ip4_addr = pktinfop->ipi_spec_dst.s_addr;
attr_pktinfop->ip4_ill_index = pktinfop->ipi_ifindex;
break;
}
case IP_ADD_MEMBERSHIP:
case IP_DROP_MEMBERSHIP:
case IP_BLOCK_SOURCE:
case IP_UNBLOCK_SOURCE:
case IP_ADD_SOURCE_MEMBERSHIP:
case IP_DROP_SOURCE_MEMBERSHIP:
case MCAST_JOIN_GROUP:
case MCAST_LEAVE_GROUP:
case MCAST_BLOCK_SOURCE:
case MCAST_UNBLOCK_SOURCE:</