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, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
28 /*	  All Rights Reserved  	*/
29 
30 
31 #pragma ident	"%Z%%M%	%I%	%E% SMI"
32 
33 #include <sys/types.h>
34 #include <sys/sysmacros.h>
35 #include <sys/param.h>
36 #include <sys/systm.h>
37 #include <sys/errno.h>
38 #include <sys/vnode.h>
39 #include <sys/file.h>
40 #include <sys/proc.h>
41 #include <sys/stropts.h>
42 #include <sys/stream.h>
43 #include <sys/strsubr.h>
44 #include <sys/fs/fifonode.h>
45 #include <sys/socket.h>
46 #include <sys/socketvar.h>
47 #include <sys/debug.h>
48 
49 /*
50  * STREAMS system calls.
51  */
52 
53 int getmsg(int fdes, struct strbuf *ctl, struct strbuf *data, int *flagsp);
54 int putmsg(int fdes, struct strbuf *ctl, struct strbuf *data, int flags);
55 int getpmsg(int fdes, struct strbuf *ctl, struct strbuf *data, int *prip,
56     int *flagsp);
57 int putpmsg(int fdes, struct strbuf *ctl, struct strbuf *data, int pri,
58     int flags);
59 
60 static int msgio(int fdes, struct strbuf *ctl, struct strbuf *data, int *rval,
61     int mode, unsigned char *prip, int *flagsp);
62 
63 int
getmsg(int fdes,struct strbuf * ctl,struct strbuf * data,int * flagsp)64 getmsg(int fdes, struct strbuf *ctl, struct strbuf *data, int *flagsp)
65 {
66 	int error;
67 	int localflags;
68 	int realflags = 0;
69 	unsigned char pri = 0;
70 	int rv = 0;
71 
72 	/*
73 	 * Convert between old flags (localflags) and new flags (realflags).
74 	 */
75 	if (copyin(flagsp, &localflags, sizeof (*flagsp)))
76 		return (set_errno(EFAULT));
77 	switch (localflags) {
78 	case 0:
79 		realflags = MSG_ANY;
80 		break;
81 
82 	case RS_HIPRI:
83 		realflags = MSG_HIPRI;
84 		break;
85 
86 	default:
87 		return (set_errno(EINVAL));
88 	}
89 
90 	if ((error = msgio(fdes, ctl, data, &rv, FREAD, &pri,
91 	    &realflags)) == 0) {
92 		/*
93 		 * massage realflags based on localflags.
94 		 */
95 		if (realflags == MSG_HIPRI)
96 			localflags = RS_HIPRI;
97 		else
98 			localflags = 0;
99 		if (copyout(&localflags, flagsp, sizeof (*flagsp)))
100 			error = EFAULT;
101 	}
102 	if (error != 0)
103 		return (set_errno(error));
104 	return (rv);
105 }
106 
107 int
putmsg(int fdes,struct strbuf * ctl,struct strbuf * data,int flags)108 putmsg(int fdes, struct strbuf *ctl, struct strbuf *data, int flags)
109 {
110 	unsigned char pri = 0;
111 	int realflags;
112 	int error;
113 	int rv = 0;
114 
115 	switch (flags) {
116 	case RS_HIPRI:
117 		realflags = MSG_HIPRI;
118 		break;
119 	case (RS_HIPRI|MSG_XPG4):
120 		realflags = MSG_HIPRI|MSG_XPG4;
121 		break;
122 	case MSG_XPG4:
123 		realflags = MSG_BAND|MSG_XPG4;
124 		break;
125 	case 0:
126 		realflags = MSG_BAND;
127 		break;
128 
129 	default:
130 		return (set_errno(EINVAL));
131 	}
132 	error = msgio(fdes, ctl, data, &rv, FWRITE, &pri, &realflags);
133 	if (error != 0)
134 		return (set_errno(error));
135 	return (rv);
136 }
137 
138 
139 int
getpmsg(int fdes,struct strbuf * ctl,struct strbuf * data,int * prip,int * flagsp)140 getpmsg(int fdes, struct strbuf *ctl, struct strbuf *data, int *prip,
141     int *flagsp)
142 {
143 	int error;
144 	int flags;
145 	int intpri;
146 	unsigned char pri;
147 	int rv = 0;
148 
149 	if (copyin(flagsp, &flags, sizeof (flags)))
150 		return (set_errno(EFAULT));
151 	if (copyin(prip, &intpri, sizeof (intpri)))
152 		return (set_errno(EFAULT));
153 	if ((intpri > 255) || (intpri < 0))
154 		return (set_errno(EINVAL));
155 	pri = (unsigned char)intpri;
156 	error = msgio(fdes, ctl, data, &rv, FREAD, &pri, &flags);
157 	if (error != 0)
158 		return (set_errno(error));
159 	if (copyout(&flags, flagsp, sizeof (flags)))
160 		return (set_errno(EFAULT));
161 	intpri = (int)pri;
162 	if (copyout(&intpri, prip, sizeof (intpri)))
163 		return (set_errno(EFAULT));
164 	return (rv);
165 }
166 
167 int
putpmsg(int fdes,struct strbuf * ctl,struct strbuf * data,int intpri,int flags)168 putpmsg(int fdes, struct strbuf *ctl, struct strbuf *data, int intpri,
169     int flags)
170 {
171 	unsigned char pri;
172 	int rv = 0;
173 	int error;
174 
175 	if ((intpri > 255) || (intpri < 0))
176 		return (set_errno(EINVAL));
177 	pri = (unsigned char)intpri;
178 	error = msgio(fdes, ctl, data, &rv, FWRITE, &pri, &flags);
179 	if (error != 0)
180 		return (set_errno(error));
181 	return (rv);
182 }
183 
184 /*
185  * Common code for getmsg and putmsg calls: check permissions,
186  * copy in args, do preliminary setup, and switch to
187  * appropriate stream routine.
188  */
189 static int
msgio(int fdes,struct strbuf * ctl,struct strbuf * data,int * rval,int mode,unsigned char * prip,int * flagsp)190 msgio(int fdes, struct strbuf *ctl, struct strbuf *data, int *rval,
191     int mode, unsigned char *prip, int *flagsp)
192 {
193 	file_t *fp;
194 	vnode_t *vp;
195 	struct strbuf msgctl, msgdata;
196 	int error;
197 	int flag;
198 	klwp_t *lwp = ttolwp(curthread);
199 	rval_t rv;
200 
201 	if ((fp = getf(fdes)) == NULL)
202 		return (EBADF);
203 	if ((fp->f_flag & mode) == 0) {
204 		releasef(fdes);
205 		return (EBADF);
206 	}
207 	vp = fp->f_vnode;
208 	if (vp->v_type == VFIFO) {
209 		if (vp->v_stream) {
210 			/*
211 			 * must use sd_vnode, could be named pipe
212 			 */
213 			(void) fifo_vfastoff(vp->v_stream->sd_vnode);
214 		} else {
215 			releasef(fdes);
216 			return (ENOSTR);
217 		}
218 	} else if ((vp->v_type != VCHR && vp->v_type != VSOCK) ||
219 		    vp->v_stream == NULL) {
220 		releasef(fdes);
221 		return (ENOSTR);
222 	}
223 	if ((ctl != NULL) &&
224 	    copyin(ctl, &msgctl, sizeof (struct strbuf))) {
225 		releasef(fdes);
226 		return (EFAULT);
227 	}
228 	if ((data != NULL) &&
229 	    copyin(data, &msgdata, sizeof (struct strbuf))) {
230 		releasef(fdes);
231 		return (EFAULT);
232 	}
233 
234 	if (mode == FREAD) {
235 		if (ctl == NULL)
236 			msgctl.maxlen = -1;
237 		if (data == NULL)
238 			msgdata.maxlen = -1;
239 		flag = fp->f_flag;
240 		rv.r_val1 = 0;
241 		if (vp->v_type == VSOCK) {
242 			error = sock_getmsg(vp, &msgctl, &msgdata, prip,
243 			    flagsp, flag, &rv);
244 		} else {
245 			error = strgetmsg(vp, &msgctl, &msgdata, prip,
246 			    flagsp, flag, &rv);
247 		}
248 		*rval = rv.r_val1;
249 		if (error != 0) {
250 			releasef(fdes);
251 			return (error);
252 		}
253 		if (lwp != NULL)
254 			lwp->lwp_ru.msgrcv++;
255 		if (((ctl != NULL) &&
256 		    copyout(&msgctl, ctl, sizeof (struct strbuf))) ||
257 		    ((data != NULL) &&
258 		    copyout(&msgdata, data, sizeof (struct strbuf)))) {
259 			releasef(fdes);
260 			return (EFAULT);
261 		}
262 		releasef(fdes);
263 		return (0);
264 	}
265 
266 	/*
267 	 * FWRITE case
268 	 */
269 	if (ctl == NULL)
270 		msgctl.len = -1;
271 	if (data == NULL)
272 		msgdata.len = -1;
273 	flag = fp->f_flag;
274 	if (vp->v_type == VSOCK) {
275 		error = sock_putmsg(vp, &msgctl, &msgdata, *prip, *flagsp,
276 		    flag);
277 	} else {
278 		error = strputmsg(vp, &msgctl, &msgdata, *prip, *flagsp, flag);
279 	}
280 	releasef(fdes);
281 	if (error == 0 && lwp != NULL)
282 		lwp->lwp_ru.msgsnd++;
283 	return (error);
284 }
285 
286 
287 #if defined(_LP64) && defined(_SYSCALL32)
288 
289 static int msgio32(int fdes, struct strbuf32 *ctl, struct strbuf32 *data,
290     int *rval, int mode, unsigned char *prip, int *flagsp);
291 
292 int
getmsg32(int fdes,struct strbuf32 * ctl,struct strbuf32 * data,int32_t * flagsp)293 getmsg32(int fdes, struct strbuf32 *ctl, struct strbuf32 *data, int32_t *flagsp)
294 {
295 	int error;
296 	int32_t localflags;
297 	int realflags = 0;
298 	unsigned char pri = 0;
299 	int rv = 0;
300 
301 	/*
302 	 * Convert between old flags (localflags) and new flags (realflags).
303 	 */
304 	if (copyin(flagsp, &localflags, sizeof (*flagsp)))
305 		return (set_errno(EFAULT));
306 	switch (localflags) {
307 	case 0:
308 		realflags = MSG_ANY;
309 		break;
310 
311 	case RS_HIPRI:
312 		realflags = MSG_HIPRI;
313 		break;
314 
315 	default:
316 		return (set_errno(EINVAL));
317 	}
318 
319 	if ((error = msgio32(fdes, ctl, data, &rv, FREAD, &pri,
320 	    &realflags)) == 0) {
321 		/*
322 		 * massage realflags based on localflags.
323 		 */
324 		if (realflags == MSG_HIPRI)
325 			localflags = RS_HIPRI;
326 		else
327 			localflags = 0;
328 		if (copyout(&localflags, flagsp, sizeof (*flagsp)))
329 			error = EFAULT;
330 	}
331 	if (error != 0)
332 		return (set_errno(error));
333 	return (rv);
334 }
335 
336 int
putmsg32(int fdes,struct strbuf32 * ctl,struct strbuf32 * data,int32_t flags)337 putmsg32(int fdes, struct strbuf32 *ctl, struct strbuf32 *data, int32_t flags)
338 {
339 	unsigned char pri = 0;
340 	int realflags;
341 	int error;
342 	int rv = 0;
343 
344 	switch (flags) {
345 	case RS_HIPRI:
346 		realflags = MSG_HIPRI;
347 		break;
348 	case (RS_HIPRI|MSG_XPG4):
349 		realflags = MSG_HIPRI|MSG_XPG4;
350 		break;
351 	case MSG_XPG4:
352 		realflags = MSG_BAND|MSG_XPG4;
353 		break;
354 	case 0:
355 		realflags = MSG_BAND;
356 		break;
357 
358 	default:
359 		return (set_errno(EINVAL));
360 	}
361 	error = msgio32(fdes, ctl, data, &rv, FWRITE, &pri, &realflags);
362 	if (error != 0)
363 		return (set_errno(error));
364 	return (rv);
365 }
366 
367 
368 int
getpmsg32(int fdes,struct strbuf32 * ctl,struct strbuf32 * data,int32_t * prip,int32_t * flagsp)369 getpmsg32(int fdes, struct strbuf32 *ctl, struct strbuf32 *data, int32_t *prip,
370     int32_t *flagsp)
371 {
372 	int error;
373 	int32_t flags;
374 	int32_t intpri;
375 	unsigned char pri;
376 	int rv = 0;
377 
378 	if (copyin(flagsp, &flags, sizeof (*flagsp)))
379 		return (set_errno(EFAULT));
380 	if (copyin(prip, &intpri, sizeof (intpri)))
381 		return (set_errno(EFAULT));
382 	if ((intpri > 255) || (intpri < 0))
383 		return (set_errno(EINVAL));
384 	pri = (unsigned char)intpri;
385 	error = msgio32(fdes, ctl, data, &rv, FREAD, &pri, &flags);
386 	if (error != 0)
387 		return (set_errno(error));
388 	if (copyout(&flags, flagsp, sizeof (flags)))
389 		return (set_errno(EFAULT));
390 	intpri = (int)pri;
391 	if (copyout(&intpri, prip, sizeof (intpri)))
392 		return (set_errno(EFAULT));
393 	return (rv);
394 }
395 
396 int
putpmsg32(int fdes,struct strbuf32 * ctl,struct strbuf32 * data,int32_t intpri,int32_t flags)397 putpmsg32(int fdes, struct strbuf32 *ctl, struct strbuf32 *data, int32_t intpri,
398     int32_t flags)
399 {
400 	unsigned char pri;
401 	int rv = 0;
402 	int error;
403 
404 	if ((intpri > 255) || (intpri < 0))
405 		return (set_errno(EINVAL));
406 	pri = (unsigned char)intpri;
407 	error = msgio32(fdes, ctl, data, &rv, FWRITE, &pri, &flags);
408 	if (error != 0)
409 		return (set_errno(error));
410 	return (rv);
411 }
412 
413 /*
414  * Common code for getmsg and putmsg calls: check permissions,
415  * copy in args, do preliminary setup, and switch to
416  * appropriate stream routine.
417  */
418 static int
msgio32(int fdes,struct strbuf32 * ctl,struct strbuf32 * data,int * rval,int mode,unsigned char * prip,int * flagsp)419 msgio32(int fdes, struct strbuf32 *ctl, struct strbuf32 *data, int *rval,
420     int mode, unsigned char *prip, int *flagsp)
421 {
422 	file_t *fp;
423 	vnode_t *vp;
424 	struct strbuf32 msgctl32, msgdata32;
425 	struct strbuf msgctl, msgdata;
426 	int error;
427 	int flag;
428 	klwp_t *lwp = ttolwp(curthread);
429 	rval_t rv;
430 
431 	if ((fp = getf(fdes)) == NULL)
432 		return (EBADF);
433 	if ((fp->f_flag & mode) == 0) {
434 		releasef(fdes);
435 		return (EBADF);
436 	}
437 	vp = fp->f_vnode;
438 	if (vp->v_type == VFIFO) {
439 		if (vp->v_stream) {
440 			/*
441 			 * must use sd_vnode, could be named pipe
442 			 */
443 			(void) fifo_vfastoff(vp->v_stream->sd_vnode);
444 		} else {
445 			releasef(fdes);
446 			return (ENOSTR);
447 		}
448 	} else if ((vp->v_type != VCHR && vp->v_type != VSOCK) ||
449 		    vp->v_stream == NULL) {
450 		releasef(fdes);
451 		return (ENOSTR);
452 	}
453 	if (ctl != NULL) {
454 		if (copyin(ctl, &msgctl32, sizeof (msgctl32))) {
455 			releasef(fdes);
456 			return (EFAULT);
457 		}
458 		msgctl.len = msgctl32.len;
459 		msgctl.maxlen = msgctl32.maxlen;
460 		msgctl.buf = (caddr_t)(uintptr_t)msgctl32.buf;
461 	}
462 	if (data != NULL) {
463 		if (copyin(data, &msgdata32, sizeof (msgdata32))) {
464 			releasef(fdes);
465 			return (EFAULT);
466 		}
467 		msgdata.len = msgdata32.len;
468 		msgdata.maxlen = msgdata32.maxlen;
469 		msgdata.buf = (caddr_t)(uintptr_t)msgdata32.buf;
470 	}
471 
472 	if (mode == FREAD) {
473 		if (ctl == NULL)
474 			msgctl.maxlen = -1;
475 		if (data == NULL)
476 			msgdata.maxlen = -1;
477 		flag = fp->f_flag;
478 		rv.r_val1 = 0;
479 		if (vp->v_type == VSOCK) {
480 			error = sock_getmsg(vp, &msgctl, &msgdata, prip,
481 			    flagsp, flag, &rv);
482 		} else {
483 			error = strgetmsg(vp, &msgctl, &msgdata, prip,
484 			    flagsp, flag, &rv);
485 		}
486 		*rval = rv.r_val1;
487 		if (error != 0) {
488 			releasef(fdes);
489 			return (error);
490 		}
491 		if (lwp != NULL)
492 			lwp->lwp_ru.msgrcv++;
493 		if (ctl != NULL) {
494 			/* XX64 - range check */
495 			msgctl32.len = msgctl.len;
496 			msgctl32.maxlen = msgctl.maxlen;
497 			msgctl32.buf = (caddr32_t)(uintptr_t)msgctl.buf;
498 			if (copyout(&msgctl32, ctl, sizeof (msgctl32))) {
499 				releasef(fdes);
500 				return (EFAULT);
501 			}
502 		}
503 		if (data != NULL) {
504 			/* XX64 - range check */
505 			msgdata32.len = msgdata.len;
506 			msgdata32.maxlen = msgdata.maxlen;
507 			msgdata32.buf = (caddr32_t)(uintptr_t)msgdata.buf;
508 			if (copyout(&msgdata32, data, sizeof (msgdata32))) {
509 				releasef(fdes);
510 				return (EFAULT);
511 			}
512 		}
513 		releasef(fdes);
514 		return (0);
515 	}
516 
517 	/*
518 	 * FWRITE case
519 	 */
520 	if (ctl == NULL)
521 		msgctl.len = -1;
522 	if (data == NULL)
523 		msgdata.len = -1;
524 	flag = fp->f_flag;
525 	if (vp->v_type == VSOCK) {
526 		error = sock_putmsg(vp, &msgctl, &msgdata, *prip, *flagsp,
527 		    flag);
528 	} else {
529 		error = strputmsg(vp, &msgctl, &msgdata, *prip, *flagsp, flag);
530 	}
531 	releasef(fdes);
532 	if (error == 0 && lwp != NULL)
533 		lwp->lwp_ru.msgsnd++;
534 	return (error);
535 }
536 
537 #endif /* _LP64 && _SYSCALL32 */
538