xref: /titanic_41/usr/src/uts/common/inet/proto_set.c (revision bd670b35a010421b6e1a5536c34453a827007c81)
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