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 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/types.h>
27 #include <inet/common.h>
28 #include <sys/stream.h>
29 #include <sys/stropts.h>
30 #include <sys/strsun.h>
31 #include <sys/sysmacros.h>
32 #include <sys/stropts.h>
33 #include <sys/strsubr.h>
34 #include <sys/tpicommon.h>
35 #include <sys/socket_proto.h>
36 #include <sys/policy.h>
37 #include <inet/optcom.h>
38 #include <inet/ipclassifier.h>
39
40 boolean_t
proto_set_rx_hiwat(queue_t * q,conn_t * connp,size_t size)41 proto_set_rx_hiwat(queue_t *q, conn_t *connp, size_t size)
42 {
43
44 if (connp != NULL && IPCL_IS_NONSTR(connp)) {
45 struct sock_proto_props sopp;
46
47 sopp.sopp_flags = SOCKOPT_RCVHIWAT;
48 sopp.sopp_rxhiwat = size;
49 (*connp->conn_upcalls->su_set_proto_props)
50 (connp->conn_upper_handle, &sopp);
51 } else {
52 MBLKP mp;
53 struct stroptions *stropt;
54
55 if (!(mp = allocb(sizeof (*stropt), BPRI_LO)))
56 return (B_FALSE);
57 mp->b_datap->db_type = M_SETOPTS;
58 mp->b_wptr += sizeof (*stropt);
59 stropt = (struct stroptions *)mp->b_rptr;
60 stropt->so_flags = SO_HIWAT;
61 stropt->so_hiwat = size;
62 putnext(q, mp);
63 }
64 return (B_TRUE);
65 }
66
67 boolean_t
proto_set_rx_lowat(queue_t * q,conn_t * connp,size_t size)68 proto_set_rx_lowat(queue_t *q, conn_t *connp, size_t size)
69 {
70
71 if (connp != NULL && IPCL_IS_NONSTR(connp)) {
72 struct sock_proto_props sopp;
73
74 sopp.sopp_flags = SOCKOPT_RCVLOWAT;
75 sopp.sopp_rxlowat = size;
76 (*connp->conn_upcalls->su_set_proto_props)
77 (connp->conn_upper_handle, &sopp);
78 } else {
79 MBLKP mp;
80 struct stroptions *stropt;
81
82 if (!(mp = allocb(sizeof (*stropt), BPRI_LO)))
83 return (B_FALSE);
84 mp->b_datap->db_type = M_SETOPTS;
85 mp->b_wptr += sizeof (*stropt);
86 stropt = (struct stroptions *)mp->b_rptr;
87 stropt->so_flags = SO_LOWAT;
88 stropt->so_lowat = size;
89 putnext(q, mp);
90 }
91 return (B_TRUE);
92 }
93
94 /*
95 * Set maximum packet size. This is the maximum amount of data the protocol
96 * wants to be given at any time, Larger data needs to be broken in multiples
97 * of maximum packet size and given to the protocol one at a time.
98 */
99 boolean_t
proto_set_maxpsz(queue_t * q,conn_t * connp,size_t size)100 proto_set_maxpsz(queue_t *q, conn_t *connp, size_t size)
101 {
102 if (connp != NULL && IPCL_IS_NONSTR(connp)) {
103 struct sock_proto_props sopp;
104
105 sopp.sopp_flags = SOCKOPT_MAXPSZ;
106 sopp.sopp_maxpsz = size;
107 (*connp->conn_upcalls->su_set_proto_props)
108 (connp->conn_upper_handle, &sopp);
109 return (B_TRUE);
110 } else {
111 struct stdata *stp;
112 queue_t *wq;
113 stp = STREAM(q);
114
115 /*
116 * At this point change of a queue parameter is not allowed
117 * when a multiplexor is sitting on top.
118 */
119 if (stp == NULL || stp->sd_flag & STPLEX)
120 return (B_FALSE);
121
122 claimstr(stp->sd_wrq);
123 wq = stp->sd_wrq->q_next;
124 ASSERT(wq != NULL);
125 (void) strqset(wq, QMAXPSZ, 0, size);
126 releasestr(stp->sd_wrq);
127 return (B_TRUE);
128 }
129 }
130
131 /* ARGSUSED */
132 boolean_t
proto_set_tx_maxblk(queue_t * q,conn_t * connp,ssize_t size)133 proto_set_tx_maxblk(queue_t *q, conn_t *connp, ssize_t size)
134 {
135 if (connp != NULL && IPCL_IS_NONSTR(connp)) {
136 struct sock_proto_props sopp;
137
138 sopp.sopp_flags = SOCKOPT_MAXBLK;
139 sopp.sopp_maxblk = size;
140 (*connp->conn_upcalls->su_set_proto_props)
141 (connp->conn_upper_handle, &sopp);
142 } else {
143 MBLKP mp;
144 struct stroptions *stropt;
145
146 if (!(mp = allocb(sizeof (*stropt), BPRI_LO)))
147 return (B_FALSE);
148 mp->b_datap->db_type = M_SETOPTS;
149 mp->b_wptr += sizeof (*stropt);
150 stropt = (struct stroptions *)mp->b_rptr;
151 stropt->so_flags = SO_MAXBLK;
152 stropt->so_maxblk = size;
153 putnext(q, mp);
154 }
155 return (B_TRUE);
156 }
157
158 boolean_t
proto_set_tx_copyopt(queue_t * q,conn_t * connp,int copyopt)159 proto_set_tx_copyopt(queue_t *q, conn_t *connp, int copyopt)
160 {
161 if (connp != NULL && IPCL_IS_NONSTR(connp)) {
162 struct sock_proto_props sopp;
163
164 sopp.sopp_flags = SOCKOPT_ZCOPY;
165 sopp.sopp_zcopyflag = (ushort_t)copyopt;
166 (*connp->conn_upcalls->su_set_proto_props)
167 (connp->conn_upper_handle, &sopp);
168 } else {
169 MBLKP mp;
170 struct stroptions *stropt;
171
172 if (!(mp = allocb(sizeof (*stropt), BPRI_LO)))
173 return (B_FALSE);
174 mp->b_datap->db_type = M_SETOPTS;
175 mp->b_wptr += sizeof (*stropt);
176 stropt = (struct stroptions *)mp->b_rptr;
177 stropt->so_flags = SO_COPYOPT;
178 stropt->so_copyopt = (ushort_t)copyopt;
179 putnext(q, mp);
180 }
181 return (B_TRUE);
182 }
183
184 boolean_t
proto_set_tx_wroff(queue_t * q,conn_t * connp,size_t size)185 proto_set_tx_wroff(queue_t *q, conn_t *connp, size_t size)
186 {
187 if (connp != NULL && IPCL_IS_NONSTR(connp)) {
188 struct sock_proto_props sopp;
189
190 sopp.sopp_flags = SOCKOPT_WROFF;
191 sopp.sopp_wroff = size;
192
193 /* XXX workaround for CR6757374 */
194 if (connp->conn_upper_handle != NULL)
195 (*connp->conn_upcalls->su_set_proto_props)
196 (connp->conn_upper_handle, &sopp);
197 } else {
198
199 MBLKP mp;
200 struct stroptions *stropt;
201 if (!(mp = allocb(sizeof (*stropt), BPRI_LO)))
202 return (B_FALSE);
203 mp->b_datap->db_type = M_SETOPTS;
204 mp->b_wptr += sizeof (*stropt);
205 stropt = (struct stroptions *)mp->b_rptr;
206 stropt->so_flags = SO_WROFF;
207 stropt->so_wroff = (ushort_t)size;
208 putnext(q, mp);
209 }
210 return (B_TRUE);
211 }
212
213 /*
214 * set OOBINLINE processing on the socket
215 */
216 void
proto_set_rx_oob_opt(conn_t * connp,boolean_t onoff)217 proto_set_rx_oob_opt(conn_t *connp, boolean_t onoff)
218 {
219 struct sock_proto_props sopp;
220
221 ASSERT(IPCL_IS_NONSTR(connp));
222
223 sopp.sopp_flags = SOCKOPT_OOBINLINE;
224 sopp.sopp_oobinline = onoff;
225 (*connp->conn_upcalls->su_set_proto_props)
226 (connp->conn_upper_handle, &sopp);
227 }
228
229 /*
230 * Translate a TLI(/XTI) error into a system error as best we can.
231 */
232 static const int tli_errs[] = {
233 0, /* no error */
234 EADDRNOTAVAIL, /* TBADADDR */
235 ENOPROTOOPT, /* TBADOPT */
236 EACCES, /* TACCES */
237 EBADF, /* TBADF */
238 EADDRNOTAVAIL, /* TNOADDR */
239 EPROTO, /* TOUTSTATE */
240 ECONNABORTED, /* TBADSEQ */
241 0, /* TSYSERR - will never get */
242 EPROTO, /* TLOOK - should never be sent by transport */
243 EMSGSIZE, /* TBADDATA */
244 EMSGSIZE, /* TBUFOVFLW */
245 EPROTO, /* TFLOW */
246 EWOULDBLOCK, /* TNODATA */
247 EPROTO, /* TNODIS */
248 EPROTO, /* TNOUDERR */
249 EINVAL, /* TBADFLAG */
250 EPROTO, /* TNOREL */
251 EOPNOTSUPP, /* TNOTSUPPORT */
252 EPROTO, /* TSTATECHNG */
253 /* following represent error namespace expansion with XTI */
254 EPROTO, /* TNOSTRUCTYPE - never sent by transport */
255 EPROTO, /* TBADNAME - never sent by transport */
256 EPROTO, /* TBADQLEN - never sent by transport */
257 EADDRINUSE, /* TADDRBUSY */
258 EBADF, /* TINDOUT */
259 EBADF, /* TPROVMISMATCH */
260 EBADF, /* TRESQLEN */
261 EBADF, /* TRESADDR */
262 EPROTO, /* TQFULL - never sent by transport */
263 EPROTO, /* TPROTO */
264 };
265
266 int
proto_tlitosyserr(int terr)267 proto_tlitosyserr(int terr)
268 {
269 ASSERT(terr != TSYSERR);
270 if (terr >= (sizeof (tli_errs) / sizeof (tli_errs[0])))
271 return (EPROTO);
272 else
273 return (tli_errs[terr]);
274 }
275
276 /*
277 * Verify that address is suitable for connect/sendmsg and is aligned properly
278 * Since this is a generic function we do not test for port being zero
279 * as some protocols like icmp do not require a port
280 */
281 int
proto_verify_ip_addr(int family,const struct sockaddr * name,socklen_t namelen)282 proto_verify_ip_addr(int family, const struct sockaddr *name, socklen_t namelen)
283 {
284
285 if (name == NULL || !OK_32PTR((char *)name))
286 return (EINVAL);
287
288 switch (family) {
289 case AF_INET:
290 if (name->sa_family != AF_INET) {
291 return (EAFNOSUPPORT);
292 }
293
294 if (namelen != (socklen_t)sizeof (struct sockaddr_in)) {
295 return (EINVAL);
296 }
297 break;
298 case AF_INET6: {
299 #ifdef DEBUG
300 struct sockaddr_in6 *sin6;
301 #endif /* DEBUG */
302
303 if (name->sa_family != AF_INET6) {
304 return (EAFNOSUPPORT);
305 }
306 if (namelen != (socklen_t)sizeof (struct sockaddr_in6)) {
307 return (EINVAL);
308 }
309 #ifdef DEBUG
310 /* Verify that apps don't forget to clear sin6_scope_id etc */
311 sin6 = (struct sockaddr_in6 *)name;
312 if (sin6->sin6_scope_id != 0 &&
313 !IN6_IS_ADDR_LINKSCOPE(&sin6->sin6_addr)) {
314 zcmn_err(getzoneid(), CE_WARN,
315 "connect/send* with uninitialized sin6_scope_id "
316 "(%d) on socket. Pid = %d\n",
317 (int)sin6->sin6_scope_id, (int)curproc->p_pid);
318 }
319 #endif /* DEBUG */
320 break;
321 }
322 default:
323 return (EINVAL);
324 }
325
326 return (0);
327 }
328
329 /*
330 * Do a lookup of the options in the array.
331 * Rerurn NULL if there isn't a match.
332 */
333 opdes_t *
proto_opt_lookup(t_uscalar_t level,t_uscalar_t name,opdes_t * opt_arr,uint_t opt_arr_cnt)334 proto_opt_lookup(t_uscalar_t level, t_uscalar_t name, opdes_t *opt_arr,
335 uint_t opt_arr_cnt)
336 {
337 opdes_t *optd;
338
339 for (optd = opt_arr; optd < &opt_arr[opt_arr_cnt];
340 optd++) {
341 if (level == (uint_t)optd->opdes_level &&
342 name == (uint_t)optd->opdes_name)
343 return (optd);
344 }
345 return (NULL);
346 }
347
348 /*
349 * Do a lookup of the options in the array and do permission and length checking
350 * Returns zero if there is no error (note: for non-tpi-providers not being able
351 * to find the option is not an error). TPI errors are returned as negative
352 * numbers and errnos as positive numbers.
353 * If max_len is set we update it based on the max length of the option.
354 */
355 int
proto_opt_check(int level,int name,int len,t_uscalar_t * max_len,opdes_t * opt_arr,uint_t opt_arr_cnt,boolean_t negotiate,boolean_t check,cred_t * cr)356 proto_opt_check(int level, int name, int len, t_uscalar_t *max_len,
357 opdes_t *opt_arr, uint_t opt_arr_cnt, boolean_t negotiate, boolean_t check,
358 cred_t *cr)
359 {
360 opdes_t *optd;
361
362 /* Find the option in the opt_arr. */
363 optd = proto_opt_lookup(level, name, opt_arr, opt_arr_cnt);
364 if (optd == NULL)
365 return (-TBADOPT);
366
367 /* Additional checks dependent on operation. */
368 if (negotiate) {
369 /* Cannot be true at the same time */
370 ASSERT(check == B_FALSE);
371
372 if (!OA_WRITE_OR_EXECUTE(optd, cr)) {
373 /* can't negotiate option */
374 if (!(OA_MATCHED_PRIV(optd, cr)) &&
375 OA_WX_ANYPRIV(optd)) {
376 /*
377 * not privileged but privilege
378 * will help negotiate option.
379 */
380 return (-TACCES);
381 } else {
382 return (-TBADOPT);
383 }
384 }
385 /*
386 * Verify size for options
387 * Note: For retaining compatibility with historical
388 * behavior, variable lengths options will have their
389 * length verified in the setfn() processing.
390 * In order to be compatible with SunOS 4.X we return
391 * EINVAL errors for bad lengths.
392 */
393 if (!(optd->opdes_props & OP_VARLEN)) {
394 /* fixed length - size must match */
395 if (len != optd->opdes_size) {
396 return (EINVAL);
397 }
398 }
399 } else {
400 if (check) {
401 if (!OA_RWX_ANYPRIV(optd))
402 /* any of "rwx" permission but not none */
403 return (-TBADOPT);
404 }
405 /*
406 * XXX Since T_CURRENT was not there in TLI and the
407 * official TLI inspired TPI standard, getsockopt()
408 * API uses T_CHECK (for T_CURRENT semantics)
409 * Thus T_CHECK includes the T_CURRENT semantics due to that
410 * historical use.
411 */
412 if (!OA_READ_PERMISSION(optd, cr)) {
413 /* can't read option value */
414 if (!(OA_MATCHED_PRIV(optd, cr)) &&
415 OA_R_ANYPRIV(optd)) {
416 /*
417 * not privileged but privilege
418 * will help in reading option value.
419 */
420 return (-TACCES);
421 } else {
422 return (-TBADOPT);
423 }
424 }
425 }
426 if (max_len != NULL)
427 *max_len = optd->opdes_size;
428
429 /* We liked it. Keep going. */
430 return (0);
431 }
432