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 /* 23 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 26 #ifndef _SOCKFS_SOCKTPI_H 27 #define _SOCKFS_SOCKTPI_H 28 29 #include <inet/kssl/ksslapi.h> 30 31 #ifdef __cplusplus 32 extern "C" { 33 #endif 34 35 /* 36 * Internal representation used for addresses. 37 */ 38 struct soaddr { 39 struct sockaddr *soa_sa; /* Actual address */ 40 t_uscalar_t soa_len; /* Length in bytes for kmem_free */ 41 t_uscalar_t soa_maxlen; /* Allocated length */ 42 }; 43 /* Maximum size address for transports that have ADDR_size == 1 */ 44 #define SOA_DEFSIZE 128 45 46 struct sonode; 47 48 /* 49 * TPI Sockets 50 * ====================== 51 * 52 * A TPI socket can be created by the TPI socket module, or as a 53 * result of fallback. In either case, the TPI related information is 54 * stored in a sotpi_info_t. Sockets that are TPI based from the 55 * beginning will use a sotpi_sonode_t, but fallback case the 56 * sotpi_info_t will be allocated when needed. However, the so_priv 57 * field in the sonode will always point to the sotpi_info_t, and the 58 * structure should only be accessed via so_priv. Use SOTOTPI(). 59 * 60 * A TPI socket always corresponds to a VCHR stream representing the 61 * transport provider (e.g. /dev/tcp). This information is retrieved 62 * from the kernel socket configuration table and accessible via 63 * so_sockparams->sp_sdev_info. sockfs uses this to perform 64 * VOP_ACCESS checks before allowing an open of the transport 65 * provider. 66 * 67 * AF_UNIX Sockets 68 * ------------------------- 69 * 70 * When an AF_UNIX socket is bound to a pathname the sockfs creates a 71 * VSOCK vnode in the underlying file system. However, the vnodeops 72 * etc in this VNODE remain those of the underlying file system. 73 * Sockfs uses the v_stream pointer in the underlying file system 74 * VSOCK node to find the sonode bound to the pathname. The bound 75 * pathname vnode is accessed through sti_ux_vp. 76 * 77 * Out of Band Data Handling 78 * ------------------------- 79 * 80 * The counts (sti_oobcnt and sti_oobsigcnt) track the number of 81 * urgent indicates that are (logically) queued on the stream head 82 * read queue. The urgent data is queued on the stream head 83 * as follows. 84 * 85 * In the normal case the SIGURG is not generated until 86 * the T_EXDATA_IND arrives at the stream head. However, transports 87 * that have an early indication that urgent data is pending 88 * (e.g. TCP receiving a "new" urgent pointer value) can send up 89 * an M_PCPROTO/SIGURG message to generate the signal early. 90 * 91 * The mark is indicated by either: 92 * - a T_EXDATA_IND (with no M_DATA b_cont) with MSGMARK set. 93 * When this message is consumed by sorecvmsg the socket layer 94 * sets SS_RCVATMARK until data has been consumed past the mark. 95 * - a message with MSGMARKNEXT set (indicating that the 96 * first byte of the next message constitutes the mark). When 97 * the last byte of the MSGMARKNEXT message is consumed in 98 * the stream head the stream head sets STRATMARK. This flag 99 * is cleared when at least one byte is read. (Note that 100 * the MSGMARKNEXT messages can be of zero length when there 101 * is no previous data to which the marknext can be attached.) 102 * 103 * While the T_EXDATA_IND method is the common case which is used 104 * with all TPI transports, the MSGMARKNEXT method is needed to 105 * indicate the mark when e.g. the TCP urgent byte has not been 106 * received yet but the TCP urgent pointer has made TCP generate 107 * the M_PCSIG/SIGURG. 108 * 109 * The signal (the M_PCSIG carrying the SIGURG) and the mark 110 * indication can not be delivered as a single message, since 111 * the signal should be delivered as high priority and any mark 112 * indication must flow with the data. This implies that immediately 113 * when the SIGURG has been delivered if the stream head queue is 114 * empty it is impossible to determine if this will be the position 115 * of the mark. This race condition is resolved by using MSGNOTMARKNEXT 116 * messages and the STRNOTATMARK flag in the stream head. The 117 * SIOCATMARK code calls the stream head to wait for either a 118 * non-empty queue or one of the STR*ATMARK flags being set. 119 * This implies that any transport that is sending M_PCSIG(SIGURG) 120 * should send the appropriate MSGNOTMARKNEXT message (which can be 121 * zero length) after sending an M_PCSIG to prevent SIOCATMARK 122 * from sleeping unnecessarily. 123 */ 124 125 #define SOTPI_INFO_MAGIC 0x12345678 126 127 /* 128 * Information used by TPI/STREAMS sockets 129 */ 130 typedef struct sotpi_info { 131 /* 132 * These fields are initialized once. 133 */ 134 uint32_t sti_magic; /* always set to SOTPI_INFO_MAGIC */ 135 dev_t sti_dev; /* device the sonode represents */ 136 137 struct sockparams *sti_orig_sp; /* in case of fallback; the orig sp */ 138 139 kmutex_t sti_plumb_lock; /* serializes plumbs, and the related */ 140 /* so_pushcnt */ 141 short sti_pushcnt; /* Number of modules above "sockmod" */ 142 143 kcondvar_t sti_ack_cv; /* wait for TPI acks */ 144 145 uint8_t 146 sti_laddr_valid : 1, /* sti_laddr valid for user */ 147 sti_faddr_valid : 1, /* sti_faddr valid for user */ 148 sti_faddr_noxlate : 1, /* No xlation of faddr for AF_UNIX */ 149 150 sti_direct : 1, /* transport is directly below */ 151 152 sti_pad_to_bit7 : 4; 153 154 mblk_t *sti_ack_mp; /* TPI ack received from below */ 155 mblk_t *sti_unbind_mp; /* Preallocated T_UNBIND_REQ message */ 156 157 time_t sti_atime; /* time of last access */ 158 time_t sti_mtime; /* time of last modification */ 159 time_t sti_ctime; /* time of last attributes change */ 160 161 ushort_t sti_delayed_error; /* From T_uderror_ind */ 162 mblk_t *sti_eaddr_mp; /* for so_delayed_error */ 163 /* put here for delayed processing */ 164 165 mblk_t *sti_conn_ind_head; /* b_next list of T_CONN_IND */ 166 mblk_t *sti_conn_ind_tail; 167 168 uint_t sti_oobsigcnt; /* Number of SIGURG generated */ 169 uint_t sti_oobcnt; /* Number of T_EXDATA_IND queued */ 170 171 /* From T_info_ack */ 172 t_uscalar_t sti_tsdu_size; 173 t_uscalar_t sti_etsdu_size; 174 t_scalar_t sti_addr_size; 175 t_uscalar_t sti_opt_size; 176 t_uscalar_t sti_tidu_size; 177 t_scalar_t sti_serv_type; 178 179 /* From T_capability_ack */ 180 t_uscalar_t sti_acceptor_id; 181 182 /* Internal provider information */ 183 struct tpi_provinfo *sti_provinfo; 184 185 /* 186 * The local and remote addresses have multiple purposes 187 * but one of the key reasons for their existence and careful 188 * tracking in sockfs is to support getsockname and getpeername 189 * when the transport does not handle the TI_GET*NAME ioctls 190 * and caching when it does (signalled by valid bits in so_state). 191 * When all transports support the new TPI (with T_ADDR_REQ) 192 * we can revisit this code. 193 * 194 * The other usage of sti_faddr is to keep the "connected to" 195 * address for datagram sockets. 196 * 197 * Finally, for AF_UNIX both local and remote addresses are used 198 * to record the sockaddr_un since we use a separate namespace 199 * in the loopback transport. 200 */ 201 struct soaddr sti_laddr; /* Local address */ 202 struct soaddr sti_faddr; /* Peer address */ 203 #define sti_laddr_sa sti_laddr.soa_sa 204 #define sti_faddr_sa sti_faddr.soa_sa 205 #define sti_laddr_len sti_laddr.soa_len 206 #define sti_faddr_len sti_faddr.soa_len 207 #define sti_laddr_maxlen sti_laddr.soa_maxlen 208 #define sti_faddr_maxlen sti_faddr.soa_maxlen 209 210 /* 211 * For AF_UNIX sockets: 212 * 213 * sti_ux_laddr/faddr records the internal addresses used with the 214 * transport. sti_ux_vp and v_stream->sd_vnode form the 215 * cross-linkage between the underlying fs vnode corresponding 216 * to the bound sockaddr_un and the socket node. 217 */ 218 struct so_ux_addr sti_ux_laddr; /* laddr bound with the transport */ 219 struct so_ux_addr sti_ux_faddr; /* temporary peer address */ 220 struct vnode *sti_ux_bound_vp; /* bound AF_UNIX file system vnode */ 221 struct sonode *sti_next_so; /* next sonode on socklist */ 222 struct sonode *sti_prev_so; /* previous sonode on socklist */ 223 mblk_t *sti_discon_ind_mp; /* T_DISCON_IND received from below */ 224 225 /* 226 * For NL7C sockets: 227 * 228 * sti_nl7c_flags the NL7C state of URL processing. 229 * 230 * sti_nl7c_rcv_mp mblk_t chain of already received data to be 231 * passed up to the app after NL7C gives up on 232 * a socket. 233 * 234 * sti_nl7c_rcv_rval returned rval for last mblk_t from above. 235 * 236 * sti_nl7c_uri the URI currently being processed. 237 * 238 * sti_nl7c_rtime URI request gethrestime_sec(). 239 * 240 * sti_nl7c_addr pointer returned by nl7c_addr_lookup(). 241 */ 242 uint64_t sti_nl7c_flags; 243 mblk_t *sti_nl7c_rcv_mp; 244 int64_t sti_nl7c_rcv_rval; 245 void *sti_nl7c_uri; 246 time_t sti_nl7c_rtime; 247 void *sti_nl7c_addr; 248 249 /* For sockets acting as an in-kernel SSL proxy */ 250 kssl_endpt_type_t sti_kssl_type; /* is proxy/is proxied/none */ 251 kssl_ent_t sti_kssl_ent; /* SSL config entry */ 252 kssl_ctx_t sti_kssl_ctx; /* SSL session context */ 253 } sotpi_info_t; 254 255 struct T_capability_ack; 256 257 extern sonodeops_t sotpi_sonodeops; 258 259 extern int socktpi_init(void); 260 extern int sotpi_convert_sonode(struct sonode *, struct sockparams *, 261 boolean_t *, queue_t **, struct cred *); 262 extern void sotpi_revert_sonode(struct sonode *, struct cred *); 263 extern void sotpi_update_state(struct sonode *, struct T_capability_ack *, 264 struct sockaddr *, socklen_t, struct sockaddr *, socklen_t, 265 short); 266 267 extern sotpi_info_t *sotpi_sototpi(struct sonode *); 268 #ifdef DEBUG 269 #define SOTOTPI(so) (sotpi_sototpi(so)) 270 #else 271 #define SOTOTPI(so) ((sotpi_info_t *)(so)->so_priv) 272 #endif 273 274 /* for consumers outside sockfs */ 275 #define _SOTOTPI(so) ((sotpi_info_t *)(so)->so_priv) 276 277 #ifdef __cplusplus 278 } 279 #endif 280 281 #endif /* _SOCKFS_SOCKTPI_H */ 282