1 /* $NetBSD: uipc_syscalls.c,v 1.105.2.1 2007/05/13 21:23:46 pavel Exp $ */
2
3 /*
4 * Copyright (c) 1982, 1986, 1989, 1990, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the University nor the names of its contributors
16 * may be used to endorse or promote products derived from this software
17 * without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 *
31 * @(#)uipc_syscalls.c 8.6 (Berkeley) 2/14/95
32 */
33
34 #include <sys/cdefs.h>
35 __KERNEL_RCSID(0, "$NetBSD: uipc_syscalls.c,v 1.105.2.1 2007/05/13 21:23:46 pavel Exp $");
36
37 #include "opt_ktrace.h"
38 #include "opt_pipe.h"
39
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/filedesc.h>
43 #include <sys/proc.h>
44 #include <sys/file.h>
45 #include <sys/buf.h>
46 #include <sys/malloc.h>
47 #include <sys/mbuf.h>
48 #include <sys/protosw.h>
49 #include <sys/socket.h>
50 #include <sys/socketvar.h>
51 #include <sys/signalvar.h>
52 #include <sys/un.h>
53 #ifdef KTRACE
54 #include <sys/ktrace.h>
55 #endif
56 #include <sys/event.h>
57
58 #include <sys/mount.h>
59 #include <sys/sa.h>
60 #include <sys/syscallargs.h>
61
62 #include <uvm/uvm_extern.h>
63
64 static void adjust_rights(struct mbuf *m, int len, struct lwp *l);
65
66 /*
67 * System call interface to the socket abstraction.
68 */
69 extern const struct fileops socketops;
70
71 int
72 sys___socket30(struct lwp *l, void *v, register_t *retval)
73 {
74 struct sys___socket30_args /* {
75 syscallarg(int) domain;
76 syscallarg(int) type;
77 syscallarg(int) protocol;
78 } */ *uap = v;
79
80 struct filedesc *fdp;
81 struct socket *so;
82 struct file *fp;
83 int fd, error;
84
85 fdp = l->l_proc->p_fd;
86 /* falloc() will use the desciptor for us */
87 if ((error = falloc(l, &fp, &fd)) != 0)
88 return (error);
89 fp->f_flag = FREAD|FWRITE;
90 fp->f_type = DTYPE_SOCKET;
91 fp->f_ops = &socketops;
92 error = socreate(SCARG(uap, domain), &so, SCARG(uap, type),
93 SCARG(uap, protocol), l);
94 if (error) {
95 FILE_UNUSE(fp, l);
96 fdremove(fdp, fd);
97 ffree(fp);
98 } else {
99 fp->f_data = (caddr_t)so;
100 FILE_SET_MATURE(fp);
101 FILE_UNUSE(fp, l);
102 *retval = fd;
103 }
104 return (error);
105 }
106
107 /* ARGSUSED */
108 int
109 sys_bind(struct lwp *l, void *v, register_t *retval)
110 {
111 struct sys_bind_args /* {
112 syscallarg(int) s;
113 syscallarg(const struct sockaddr *) name;
114 syscallarg(unsigned int) namelen;
115 } */ *uap = v;
116 struct proc *p;
117 struct file *fp;
118 struct mbuf *nam;
119 int error;
120
121 p = l->l_proc;
122 /* getsock() will use the descriptor for us */
123 if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0)
124 return (error);
125 error = sockargs(&nam, SCARG(uap, name), SCARG(uap, namelen),
126 MT_SONAME);
127 if (error) {
128 FILE_UNUSE(fp, l);
129 return (error);
130 }
131 MCLAIM(nam, ((struct socket *)fp->f_data)->so_mowner);
132 error = sobind((struct socket *)fp->f_data, nam, l);
133 m_freem(nam);
134 FILE_UNUSE(fp, l);
135 return (error);
136 }
137
138 /* ARGSUSED */
139 int
140 sys_listen(struct lwp *l, void *v, register_t *retval)
141 {
142 struct sys_listen_args /* {
143 syscallarg(int) s;
144 syscallarg(int) backlog;
145 } */ *uap = v;
146 struct proc *p;
147 struct file *fp;
148 int error;
149
150 p = l->l_proc;
151 /* getsock() will use the descriptor for us */
152 if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0)
153 return (error);
154 error = solisten((struct socket *)fp->f_data, SCARG(uap, backlog));
155 FILE_UNUSE(fp, l);
156 return (error);
157 }
158
159 int
160 sys_accept(struct lwp *l, void *v, register_t *retval)
161 {
162 struct sys_accept_args /* {
163 syscallarg(int) s;
164 syscallarg(struct sockaddr *) name;
165 syscallarg(unsigned int *) anamelen;
166 } */ *uap = v;
167 struct filedesc *fdp;
168 struct file *fp;
169 struct mbuf *nam;
170 unsigned int namelen;
171 int error, s, fd;
172 struct socket *so;
173 int fflag;
174
175 fdp = l->l_proc->p_fd;
176 if (SCARG(uap, name) && (error = copyin(SCARG(uap, anamelen),
177 &namelen, sizeof(namelen))))
178 return (error);
179
180 /* getsock() will use the descriptor for us */
181 if ((error = getsock(fdp, SCARG(uap, s), &fp)) != 0)
182 return (error);
183 s = splsoftnet();
184 so = (struct socket *)fp->f_data;
185 FILE_UNUSE(fp, l);
186 if (!(so->so_proto->pr_flags & PR_LISTEN)) {
187 splx(s);
188 return (EOPNOTSUPP);
189 }
190 if ((so->so_options & SO_ACCEPTCONN) == 0) {
191 splx(s);
192 return (EINVAL);
193 }
194 if ((so->so_state & SS_NBIO) && so->so_qlen == 0) {
195 splx(s);
196 return (EWOULDBLOCK);
197 }
198 while (so->so_qlen == 0 && so->so_error == 0) {
199 if (so->so_state & SS_CANTRCVMORE) {
200 so->so_error = ECONNABORTED;
201 break;
202 }
203 error = tsleep((caddr_t)&so->so_timeo, PSOCK | PCATCH,
204 netcon, 0);
205 if (error) {
206 splx(s);
207 return (error);
208 }
209 }
210 if (so->so_error) {
211 error = so->so_error;
212 so->so_error = 0;
213 splx(s);
214 return (error);
215 }
216 fflag = fp->f_flag;
217 /* falloc() will use the descriptor for us */
218 if ((error = falloc(l, &fp, &fd)) != 0) {
219 splx(s);
220 return (error);
221 }
222 *retval = fd;
223
224 /* connection has been removed from the listen queue */
225 KNOTE(&so->so_rcv.sb_sel.sel_klist, 0);
226
227 { struct socket *aso = TAILQ_FIRST(&so->so_q);
228 if (soqremque(aso, 1) == 0)
229 panic("accept");
230 so = aso;
231 }
232 fp->f_type = DTYPE_SOCKET;
233 fp->f_flag = fflag;
234 fp->f_ops = &socketops;
235 fp->f_data = (caddr_t)so;
236 nam = m_get(M_WAIT, MT_SONAME);
237 if ((error = soaccept(so, nam)) == 0 && SCARG(uap, name)) {
238 if (namelen > nam->m_len)
239 namelen = nam->m_len;
240 /* SHOULD COPY OUT A CHAIN HERE */
241 error = copyout(mtod(nam, void *), SCARG(uap, name), namelen);
242 if (error == 0) {
243 error = copyout(&namelen, SCARG(uap, anamelen),
244 sizeof(*SCARG(uap, anamelen)));
245 }
246 }
247 /* if an error occurred, free the file descriptor */
248 if (error) {
249 fdremove(fdp, fd);
250 closef(fp, l);
251 } else {
252 FILE_SET_MATURE(fp);
253 FILE_UNUSE(fp, l);
254 }
255 m_freem(nam);
256 splx(s);
257 return (error);
258 }
259
260 /* ARGSUSED */
261 int
262 sys_connect(struct lwp *l, void *v, register_t *retval)
263 {
264 struct sys_connect_args /* {
265 syscallarg(int) s;
266 syscallarg(const struct sockaddr *) name;
267 syscallarg(unsigned int) namelen;
268 } */ *uap = v;
269 struct proc *p;
270 struct file *fp;
271 struct socket *so;
272 struct mbuf *nam;
273 int error, s;
274 int interrupted = 0;
275
276 p = l->l_proc;
277 /* getsock() will use the descriptor for us */
278 if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0)
279 return (error);
280 so = (struct socket *)fp->f_data;
281 if (so->so_state & SS_ISCONNECTING) {
282 error = EALREADY;
283 goto out;
284 }
285 error = sockargs(&nam, SCARG(uap, name), SCARG(uap, namelen),
286 MT_SONAME);
287 if (error)
288 goto out;
289 MCLAIM(nam, so->so_mowner);
290 error = soconnect(so, nam, l);
291 if (error)
292 goto bad;
293 if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {
294 m_freem(nam);
295 error = EINPROGRESS;
296 goto out;
297 }
298 s = splsoftnet();
299 while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
300 error = tsleep((caddr_t)&so->so_timeo, PSOCK | PCATCH,
301 netcon, 0);
302 if (error) {
303 if (error == EINTR || error == ERESTART)
304 interrupted = 1;
305 break;
306 }
307 }
308 if (error == 0) {
309 error = so->so_error;
310 so->so_error = 0;
311 }
312 splx(s);
313 bad:
314 if (!interrupted)
315 so->so_state &= ~SS_ISCONNECTING;
316 m_freem(nam);
317 if (error == ERESTART)
318 error = EINTR;
319 out:
320 FILE_UNUSE(fp, l);
321 return (error);
322 }
323
324 int
325 sys_socketpair(struct lwp *l, void *v, register_t *retval)
326 {
327 struct sys_socketpair_args /* {
328 syscallarg(int) domain;
329 syscallarg(int) type;
330 syscallarg(int) protocol;
331 syscallarg(int *) rsv;
332 } */ *uap = v;
333 struct filedesc *fdp;
334 struct file *fp1, *fp2;
335 struct socket *so1, *so2;
336 int fd, error, sv[2];
337
338 fdp = l->l_proc->p_fd;
339 error = socreate(SCARG(uap, domain), &so1, SCARG(uap, type),
340 SCARG(uap, protocol), l);
341 if (error)
342 return (error);
343 error = socreate(SCARG(uap, domain), &so2, SCARG(uap, type),
344 SCARG(uap, protocol), l);
345 if (error)
346 goto free1;
347 /* falloc() will use the descriptor for us */
348 if ((error = falloc(l, &fp1, &fd)) != 0)
349 goto free2;
350 sv[0] = fd;
351 fp1->f_flag = FREAD|FWRITE;
352 fp1->f_type = DTYPE_SOCKET;
353 fp1->f_ops = &socketops;
354 fp1->f_data = (caddr_t)so1;
355 if ((error = falloc(l, &fp2, &fd)) != 0)
356 goto free3;
357 fp2->f_flag = FREAD|FWRITE;
358 fp2->f_type = DTYPE_SOCKET;
359 fp2->f_ops = &socketops;
360 fp2->f_data = (caddr_t)so2;
361 sv[1] = fd;
362 if ((error = soconnect2(so1, so2)) != 0)
363 goto free4;
364 if (SCARG(uap, type) == SOCK_DGRAM) {
365 /*
366 * Datagram socket connection is asymmetric.
367 */
368 if ((error = soconnect2(so2, so1)) != 0)
369 goto free4;
370 }
371 error = copyout((caddr_t)sv, (caddr_t)SCARG(uap, rsv),
372 2 * sizeof(int));
373 FILE_SET_MATURE(fp1);
374 FILE_SET_MATURE(fp2);
375 FILE_UNUSE(fp1, l);
376 FILE_UNUSE(fp2, l);
377 return (error);
378 free4:
379 FILE_UNUSE(fp2, l);
380 ffree(fp2);
381 fdremove(fdp, sv[1]);
382 free3:
383 FILE_UNUSE(fp1, l);
384 ffree(fp1);
385 fdremove(fdp, sv[0]);
386 free2:
387 (void)soclose(so2);
388 free1:
389 (void)soclose(so1);
390 return (error);
391 }
392
393 int
394 sys_sendto(struct lwp *l, void *v, register_t *retval)
395 {
396 struct sys_sendto_args /* {
397 syscallarg(int) s;
398 syscallarg(const void *) buf;
399 syscallarg(size_t) len;
400 syscallarg(int) flags;
401 syscallarg(const struct sockaddr *) to;
402 syscallarg(unsigned int) tolen;
403 } */ *uap = v;
404 struct msghdr msg;
405 struct iovec aiov;
406
407 msg.msg_name = __UNCONST(SCARG(uap, to)); /* XXXUNCONST kills const */
408 msg.msg_namelen = SCARG(uap, tolen);
409 msg.msg_iov = &aiov;
410 msg.msg_iovlen = 1;
411 msg.msg_control = 0;
412 msg.msg_flags = 0;
413 aiov.iov_base = __UNCONST(SCARG(uap, buf)); /* XXXUNCONST kills const */
414 aiov.iov_len = SCARG(uap, len);
415 return (sendit(l, SCARG(uap, s), &msg, SCARG(uap, flags), retval));
416 }
417
418 int
419 sys_sendmsg(struct lwp *l, void *v, register_t *retval)
420 {
421 struct sys_sendmsg_args /* {
422 syscallarg(int) s;
423 syscallarg(const struct msghdr *) msg;
424 syscallarg(int) flags;
425 } */ *uap = v;
426 struct msghdr msg;
427 struct iovec aiov[UIO_SMALLIOV], *iov;
428 int error;
429
430 error = copyin(SCARG(uap, msg), (caddr_t)&msg, sizeof(msg));
431 if (error)
432 return (error);
433 if ((unsigned int)msg.msg_iovlen > UIO_SMALLIOV) {
434 if ((unsigned int)msg.msg_iovlen > IOV_MAX)
435 return (EMSGSIZE);
436 iov = malloc(sizeof(struct iovec) * msg.msg_iovlen,
437 M_IOV, M_WAITOK);
438 } else
439 iov = aiov;
440 if ((unsigned int)msg.msg_iovlen > 0) {
441 error = copyin((caddr_t)msg.msg_iov, (caddr_t)iov,
442 (size_t)(msg.msg_iovlen * sizeof(struct iovec)));
443 if (error)
444 goto done;
445 }
446 msg.msg_iov = iov;
447 msg.msg_flags = 0;
448 error = sendit(l, SCARG(uap, s), &msg, SCARG(uap, flags), retval);
449 done:
450 if (iov != aiov)
451 free(iov, M_IOV);
452 return (error);
453 }
454
455 int
456 sendit(struct lwp *l, int s, struct msghdr *mp, int flags, register_t *retsize)
457 {
458 struct proc *p;
459 struct file *fp;
460 struct uio auio;
461 struct iovec *iov;
462 int i, len, error;
463 struct mbuf *to, *control;
464 struct socket *so;
465 #ifdef KTRACE
466 struct iovec *ktriov;
467 #endif
468
469 #ifdef KTRACE
470 ktriov = NULL;
471 #endif
472 p = l->l_proc;
473 /* getsock() will use the descriptor for us */
474 if ((error = getsock(p->p_fd, s, &fp)) != 0)
475 return (error);
476 so = (struct socket *)fp->f_data;
477 auio.uio_iov = mp->msg_iov;
478 auio.uio_iovcnt = mp->msg_iovlen;
479 auio.uio_rw = UIO_WRITE;
480 auio.uio_offset = 0; /* XXX */
481 auio.uio_resid = 0;
482 KASSERT(l == curlwp);
483 auio.uio_vmspace = l->l_proc->p_vmspace;
484 iov = mp->msg_iov;
485 for (i = 0; i < mp->msg_iovlen; i++, iov++) {
486 #if 0
487 /* cannot happen; iov_len is unsigned */
488 if (iov->iov_len < 0) {
489 error = EINVAL;
490 goto out;
491 }
492 #endif
493 /*
494 * Writes return ssize_t because -1 is returned on error.
495 * Therefore, we must restrict the length to SSIZE_MAX to
496 * avoid garbage return values.
497 */
498 auio.uio_resid += iov->iov_len;
499 if (iov->iov_len > SSIZE_MAX || auio.uio_resid > SSIZE_MAX) {
500 error = EINVAL;
501 goto out;
502 }
503 }
504 if (mp->msg_name) {
505 error = sockargs(&to, mp->msg_name, mp->msg_namelen,
506 MT_SONAME);
507 if (error)
508 goto out;
509 MCLAIM(to, so->so_mowner);
510 } else
511 to = 0;
512 if (mp->msg_control) {
513 if (mp->msg_controllen < CMSG_ALIGN(sizeof(struct cmsghdr))) {
514 error = EINVAL;
515 goto bad;
516 }
517 error = sockargs(&control, mp->msg_control,
518 mp->msg_controllen, MT_CONTROL);
519 if (error)
520 goto bad;
521 MCLAIM(control, so->so_mowner);
522 } else
523 control = 0;
524 #ifdef KTRACE
525 if (KTRPOINT(p, KTR_GENIO)) {
526 int iovlen = auio.uio_iovcnt * sizeof(struct iovec);
527
528 ktriov = malloc(iovlen, M_TEMP, M_WAITOK);
529 memcpy((caddr_t)ktriov, (caddr_t)auio.uio_iov, iovlen);
530 }
531 #endif
532 len = auio.uio_resid;
533 error = (*so->so_send)(so, to, &auio, NULL, control, flags, l);
534 if (error) {
535 if (auio.uio_resid != len && (error == ERESTART ||
536 error == EINTR || error == EWOULDBLOCK))
537 error = 0;
538 if (error == EPIPE && (flags & MSG_NOSIGNAL) == 0)
539 psignal(p, SIGPIPE);
540 }
541 if (error == 0)
542 *retsize = len - auio.uio_resid;
543 #ifdef KTRACE
544 if (ktriov != NULL) {
545 if (error == 0)
546 ktrgenio(l, s, UIO_WRITE, ktriov, *retsize, error);
547 free(ktriov, M_TEMP);
548 }
549 #endif
550 bad:
551 if (to)
552 m_freem(to);
553 out:
554 FILE_UNUSE(fp, l);
555 return (error);
556 }
557
558 int
559 sys_recvfrom(struct lwp *l, void *v, register_t *retval)
560 {
561 struct sys_recvfrom_args /* {
562 syscallarg(int) s;
563 syscallarg(void *) buf;
564 syscallarg(size_t) len;
565 syscallarg(int) flags;
566 syscallarg(struct sockaddr *) from;
567 syscallarg(unsigned int *) fromlenaddr;
568 } */ *uap = v;
569 struct msghdr msg;
570 struct iovec aiov;
571 int error;
572
573 if (SCARG(uap, fromlenaddr)) {
574 error = copyin((caddr_t)SCARG(uap, fromlenaddr),
575 (caddr_t)&msg.msg_namelen,
576 sizeof(msg.msg_namelen));
577 if (error)
578 return (error);
579 } else
580 msg.msg_namelen = 0;
581 msg.msg_name = (caddr_t)SCARG(uap, from);
582 msg.msg_iov = &aiov;
583 msg.msg_iovlen = 1;
584 aiov.iov_base = SCARG(uap, buf);
585 aiov.iov_len = SCARG(uap, len);
586 msg.msg_control = 0;
587 msg.msg_flags = SCARG(uap, flags);
588 return (recvit(l, SCARG(uap, s), &msg,
589 (caddr_t)SCARG(uap, fromlenaddr), retval));
590 }
591
592 int
593 sys_recvmsg(struct lwp *l, void *v, register_t *retval)
594 {
595 struct sys_recvmsg_args /* {
596 syscallarg(int) s;
597 syscallarg(struct msghdr *) msg;
598 syscallarg(int) flags;
599 } */ *uap = v;
600 struct iovec aiov[UIO_SMALLIOV], *uiov, *iov;
601 struct msghdr msg;
602 int error;
603
604 error = copyin((caddr_t)SCARG(uap, msg), (caddr_t)&msg,
605 sizeof(msg));
606 if (error)
607 return (error);
608 if ((unsigned int)msg.msg_iovlen > UIO_SMALLIOV) {
609 if ((unsigned int)msg.msg_iovlen > IOV_MAX)
610 return (EMSGSIZE);
611 iov = malloc(sizeof(struct iovec) * msg.msg_iovlen,
612 M_IOV, M_WAITOK);
613 } else
614 iov = aiov;
615 if ((unsigned int)msg.msg_iovlen > 0) {
616 error = copyin((caddr_t)msg.msg_iov, (caddr_t)iov,
617 (size_t)(msg.msg_iovlen * sizeof(struct iovec)));
618 if (error)
619 goto done;
620 }
621 uiov = msg.msg_iov;
622 msg.msg_iov = iov;
623 msg.msg_flags = SCARG(uap, flags);
624 if ((error = recvit(l, SCARG(uap, s), &msg, (caddr_t)0, retval)) == 0) {
625 msg.msg_iov = uiov;
626 error = copyout((caddr_t)&msg, (caddr_t)SCARG(uap, msg),
627 sizeof(msg));
628 }
629 done:
630 if (iov != aiov)
631 free(iov, M_IOV);
632 return (error);
633 }
634
635 /*
636 * Adjust for a truncated SCM_RIGHTS control message. This means
637 * closing any file descriptors that aren't entirely present in the
638 * returned buffer. m is the mbuf holding the (already externalized)
639 * SCM_RIGHTS message; len is the length it is being truncated to. p
640 * is the affected process.
641 */
642 static void
643 adjust_rights(struct mbuf *m, int len, struct lwp *l)
644 {
645 int nfd;
646 int i;
647 int nok;
648 int *fdv;
649
650 nfd = m->m_len < CMSG_SPACE(sizeof(int)) ? 0
651 : (m->m_len - CMSG_SPACE(sizeof(int))) / sizeof(int) + 1;
652 nok = (len < CMSG_LEN(0)) ? 0 : ((len - CMSG_LEN(0)) / sizeof(int));
653 fdv = (int *) CMSG_DATA(mtod(m,struct cmsghdr *));
654 for (i = nok; i < nfd; i++)
655 fdrelease(l,fdv[i]);
656 }
657
658 int
659 recvit(struct lwp *l, int s, struct msghdr *mp, caddr_t namelenp,
660 register_t *retsize)
661 {
662 struct proc *p;
663 struct file *fp;
664 struct uio auio;
665 struct iovec *iov;
666 int i, len, error;
667 struct mbuf *from, *control;
668 struct socket *so;
669 #ifdef KTRACE
670 struct iovec *ktriov;
671 #endif
672
673 p = l->l_proc;
674 from = 0;
675 control = 0;
676 #ifdef KTRACE
677 ktriov = NULL;
678 #endif
679
680 /* getsock() will use the descriptor for us */
681 if ((error = getsock(p->p_fd, s, &fp)) != 0)
682 return (error);
683 so = (struct socket *)fp->f_data;
684 auio.uio_iov = mp->msg_iov;
685 auio.uio_iovcnt = mp->msg_iovlen;
686 auio.uio_rw = UIO_READ;
687 auio.uio_offset = 0; /* XXX */
688 auio.uio_resid = 0;
689 KASSERT(l == curlwp);
690 auio.uio_vmspace = l->l_proc->p_vmspace;
691 iov = mp->msg_iov;
692 for (i = 0; i < mp->msg_iovlen; i++, iov++) {
693 #if 0
694 /* cannot happen iov_len is unsigned */
695 if (iov->iov_len < 0) {
696 error = EINVAL;
697 goto out1;
698 }
699 #endif
700 /*
701 * Reads return ssize_t because -1 is returned on error.
702 * Therefore we must restrict the length to SSIZE_MAX to
703 * avoid garbage return values.
704 */
705 auio.uio_resid += iov->iov_len;
706 if (iov->iov_len > SSIZE_MAX || auio.uio_resid > SSIZE_MAX) {
707 error = EINVAL;
708 goto out1;
709 }
710 }
711 #ifdef KTRACE
712 if (KTRPOINT(p, KTR_GENIO)) {
713 int iovlen = auio.uio_iovcnt * sizeof(struct iovec);
714
715 ktriov = malloc(iovlen, M_TEMP, M_WAITOK);
716 memcpy((caddr_t)ktriov, (caddr_t)auio.uio_iov, iovlen);
717 }
718 #endif
719 len = auio.uio_resid;
720 error = (*so->so_receive)(so, &from, &auio, NULL,
721 mp->msg_control ? &control : NULL, &mp->msg_flags);
722 if (error) {
723 if (auio.uio_resid != len && (error == ERESTART ||
724 error == EINTR || error == EWOULDBLOCK))
725 error = 0;
726 }
727 #ifdef KTRACE
728 if (ktriov != NULL) {
729 if (error == 0)
730 ktrgenio(l, s, UIO_READ, ktriov,
731 len - auio.uio_resid, error);
732 free(ktriov, M_TEMP);
733 }
734 #endif
735 if (error)
736 goto out;
737 *retsize = len - auio.uio_resid;
738 if (mp->msg_name) {
739 len = mp->msg_namelen;
740 if (len <= 0 || from == 0)
741 len = 0;
742 else {
743 if (len > from->m_len)
744 len = from->m_len;
745 /* else if len < from->m_len ??? */
746 error = copyout(mtod(from, caddr_t),
747 (caddr_t)mp->msg_name, (unsigned)len);
748 if (error)
749 goto out;
750 }
751 mp->msg_namelen = len;
752 if (namelenp &&
753 (error = copyout((caddr_t)&len, namelenp, sizeof(int))))
754 goto out;
755 }
756 if (mp->msg_control) {
757 len = mp->msg_controllen;
758 if (len <= 0 || control == 0)
759 len = 0;
760 else {
761 struct mbuf *m = control;
762 caddr_t q = (caddr_t)mp->msg_control;
763
764 do {
765 i = m->m_len;
766 if (len < i) {
767 mp->msg_flags |= MSG_CTRUNC;
768 i = len;
769 if (mtod(m, struct cmsghdr *)->
770 cmsg_type == SCM_RIGHTS)
771 adjust_rights(m, len, l);
772 }
773 error = copyout(mtod(m, caddr_t), q,
774 (unsigned)i);
775 m = m->m_next;
776 if (m)
777 i = ALIGN(i);
778 q += i;
779 len -= i;
780 if (error != 0 || len <= 0)
781 break;
782 } while (m != NULL);
783 while (m) {
784 if (mtod(m, struct cmsghdr *)->
785 cmsg_type == SCM_RIGHTS)
786 adjust_rights(m, 0, l);
787 m = m->m_next;
788 }
789 len = q - (caddr_t)mp->msg_control;
790 }
791 mp->msg_controllen = len;
792 }
793 out:
794 if (from)
795 m_freem(from);
796 if (control)
797 m_freem(control);
798 out1:
799 FILE_UNUSE(fp, l);
800 return (error);
801 }
802
803 /* ARGSUSED */
804 int
805 sys_shutdown(struct lwp *l, void *v, register_t *retval)
806 {
807 struct sys_shutdown_args /* {
808 syscallarg(int) s;
809 syscallarg(int) how;
810 } */ *uap = v;
811 struct proc *p;
812 struct file *fp;
813 int error;
814
815 p = l->l_proc;
816 /* getsock() will use the descriptor for us */
817 if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0)
818 return (error);
819 error = soshutdown((struct socket *)fp->f_data, SCARG(uap, how));
820 FILE_UNUSE(fp, l);
821 return (error);
822 }
823
824 /* ARGSUSED */
825 int
826 sys_setsockopt(struct lwp *l, void *v, register_t *retval)
827 {
828 struct sys_setsockopt_args /* {
829 syscallarg(int) s;
830 syscallarg(int) level;
831 syscallarg(int) name;
832 syscallarg(const void *) val;
833 syscallarg(unsigned int) valsize;
834 } */ *uap = v;
835 struct proc *p;
836 struct file *fp;
837 struct mbuf *m;
838 struct socket *so;
839 int error;
840 unsigned int len;
841
842 p = l->l_proc;
843 m = NULL;
844 /* getsock() will use the descriptor for us */
845 if ((error = getsock(p->p_fd, SCARG(uap, s), &fp)) != 0)
846 return (error);
847 so = (struct socket *)fp->f_data;
848 len = SCARG(uap, valsize);
849 if (len > MCLBYTES) {
850 error = EINVAL;
851 goto out;
852 }
853 if (SCARG(uap, val)) {
854 m = m_get(M_WAIT, MT_SOOPTS);
855 MCLAIM(m, so->so_mowner);
856 if (len > MLEN)
857 m_clget(m, M_WAIT);
858 error = copyin(SCARG(uap, val), mtod(m, caddr_t), len);
859 if (error) {
860 (void) m_free(m);
861 goto out;
862 }
863 m->m_len = SCARG(uap, valsize);
864 }
865 error = sosetopt(so, SCARG(uap, level), SCARG(uap, name), m);
866 out:
867 FILE_UNUSE(fp, l);
868 return (error);
869 }
870
871 /* ARGSUSED */
872 int
873 sys_getsockopt(struct lwp *l, void *v, register_t *retval)
874 {
875 struct sys_getsockopt_args /* {
876 syscallarg(int) s;
877 syscallarg(int) level;
878 syscallarg(int) name;
879 syscallarg(void *) val;
880 syscallarg(unsigned int *) avalsize;
881 } */ *uap = v;
882 struct file *fp;
883 struct mbuf *m;
884 unsigned int op, i, valsize;
885 int error;
886
887 m = NULL;
888 /* getsock() will use the descriptor for us */
889 if ((error = getsock(l->l_proc->p_fd, SCARG(uap, s), &fp)) != 0)
890 return (error);
891 if (SCARG(uap, val)) {
892 error = copyin((caddr_t)SCARG(uap, avalsize),
893 (caddr_t)&valsize, sizeof(valsize));
894 if (error)
895 goto out;
896 } else
897 valsize = 0;
898 if ((error = sogetopt((struct socket *)fp->f_data, SCARG(uap, level),
899 SCARG(uap, name), &m)) == 0 && SCARG(uap, val) && valsize &&
900 m != NULL) {
901 op = 0;
902 while (m && !error && op < valsize) {
903 i = min(m->m_len, (valsize - op));
904 error = copyout(mtod(m, caddr_t), SCARG(uap, val), i);
905 op += i;
906 SCARG(uap, val) = ((uint8_t *)SCARG(uap, val)) + i;
907 m = m_free(m);
908 }
909 valsize = op;
910 if (error == 0)
911 error = copyout(&valsize,
912 SCARG(uap, avalsize), sizeof(valsize));
913 }
914 if (m != NULL)
915 (void) m_freem(m);
916 out:
917 FILE_UNUSE(fp, l);
918 return (error);
919 }
920
921 #ifdef PIPE_SOCKETPAIR
922 /* ARGSUSED */
923 int
924 sys_pipe(struct lwp *l, void *v, register_t *retval)
925 {
926 struct filedesc *fdp;
927 struct file *rf, *wf;
928 struct socket *rso, *wso;
929 int fd, error;
930
931 fdp = l->l_proc->p_fd;
932 if ((error = socreate(AF_LOCAL, &rso, SOCK_STREAM, 0, l)) != 0)
933 return (error);
934 if ((error = socreate(AF_LOCAL, &wso, SOCK_STREAM, 0, l)) != 0)
935 goto free1;
936 /* remember this socket pair implements a pipe */
937 wso->so_state |= SS_ISAPIPE;
938 rso->so_state |= SS_ISAPIPE;
939 /* falloc() will use the descriptor for us */
940 if ((error = falloc(l, &rf, &fd)) != 0)
941 goto free2;
942 retval[0] = fd;
943 rf->f_flag = FREAD;
944 rf->f_type = DTYPE_SOCKET;
945 rf->f_ops = &socketops;
946 rf->f_data = (caddr_t)rso;
947 if ((error = falloc(l, &wf, &fd)) != 0)
948 goto free3;
949 wf->f_flag = FWRITE;
950 wf->f_type = DTYPE_SOCKET;
951 wf->f_ops = &socketops;
952 wf->f_data = (caddr_t)wso;
953 retval[1] = fd;
954 if ((error = unp_connect2(wso, rso, PRU_CONNECT2)) != 0)
955 goto free4;
956 FILE_SET_MATURE(rf);
957 FILE_SET_MATURE(wf);
958 FILE_UNUSE(rf, l);
959 FILE_UNUSE(wf, l);
960 return (0);
961 free4:
962 FILE_UNUSE(wf, l);
963 ffree(wf);
964 fdremove(fdp, retval[1]);
965 free3:
966 FILE_UNUSE(rf, l);
967 ffree(rf);
968 fdremove(fdp, retval[0]);
969 free2:
970 (void)soclose(wso);
971 free1:
972 (void)soclose(rso);
973 return (error);
974 }
975 #endif /* PIPE_SOCKETPAIR */
976
977 /*
978 * Get socket name.
979 */
980 /* ARGSUSED */
981 int
982 sys_getsockname(struct lwp *l, void *v, register_t *retval)
983 {
984 struct sys_getsockname_args /* {
985 syscallarg(int) fdes;
986 syscallarg(struct sockaddr *) asa;
987 syscallarg(unsigned int *) alen;
988 } */ *uap = v;
989 struct proc *p;
990 struct file *fp;
991 struct socket *so;
992 struct mbuf *m;
993 unsigned int len;
994 int error;
995
996 p = l->l_proc;
997 /* getsock() will use the descriptor for us */
998 if ((error = getsock(p->p_fd, SCARG(uap, fdes), &fp)) != 0)
999 return (error);
1000 error = copyin((caddr_t)SCARG(uap, alen), (caddr_t)&len, sizeof(len));
1001 if (error)
1002 goto out;
1003 so = (struct socket *)fp->f_data;
1004 m = m_getclr(M_WAIT, MT_SONAME);
1005 MCLAIM(m, so->so_mowner);
1006 error = (*so->so_proto->pr_usrreq)(so, PRU_SOCKADDR, (struct mbuf *)0,
1007 m, (struct mbuf *)0, (struct lwp *)0);
1008 if (error)
1009 goto bad;
1010 if (len > m->m_len)
1011 len = m->m_len;
1012 error = copyout(mtod(m, caddr_t), (caddr_t)SCARG(uap, asa), len);
1013 if (error == 0)
1014 error = copyout((caddr_t)&len, (caddr_t)SCARG(uap, alen),
1015 sizeof(len));
1016 bad:
1017 m_freem(m);
1018 out:
1019 FILE_UNUSE(fp, l);
1020 return (error);
1021 }
1022
1023 /*
1024 * Get name of peer for connected socket.
1025 */
1026 /* ARGSUSED */
1027 int
1028 sys_getpeername(struct lwp *l, void *v, register_t *retval)
1029 {
1030 struct sys_getpeername_args /* {
1031 syscallarg(int) fdes;
1032 syscallarg(struct sockaddr *) asa;
1033 syscallarg(unsigned int *) alen;
1034 } */ *uap = v;
1035 struct proc *p;
1036 struct file *fp;
1037 struct socket *so;
1038 struct mbuf *m;
1039 unsigned int len;
1040 int error;
1041
1042 p = l->l_proc;
1043 /* getsock() will use the descriptor for us */
1044 if ((error = getsock(p->p_fd, SCARG(uap, fdes), &fp)) != 0)
1045 return (error);
1046 so = (struct socket *)fp->f_data;
1047 if ((so->so_state & (SS_ISCONNECTED|SS_ISCONFIRMING)) == 0) {
1048 error = ENOTCONN;
1049 goto out;
1050 }
1051 error = copyin((caddr_t)SCARG(uap, alen), (caddr_t)&len, sizeof(len));
1052 if (error)
1053 goto out;
1054 m = m_getclr(M_WAIT, MT_SONAME);
1055 MCLAIM(m, so->so_mowner);
1056 error = (*so->so_proto->pr_usrreq)(so, PRU_PEERADDR, (struct mbuf *)0,
1057 m, (struct mbuf *)0, (struct lwp *)0);
1058 if (error)
1059 goto bad;
1060 if (len > m->m_len)
1061 len = m->m_len;
1062 error = copyout(mtod(m, caddr_t), (caddr_t)SCARG(uap, asa), len);
1063 if (error)
1064 goto bad;
1065 error = copyout((caddr_t)&len, (caddr_t)SCARG(uap, alen), sizeof(len));
1066 bad:
1067 m_freem(m);
1068 out:
1069 FILE_UNUSE(fp, l);
1070 return (error);
1071 }
1072
1073 /*
1074 * XXX In a perfect world, we wouldn't pass around socket control
1075 * XXX arguments in mbufs, and this could go away.
1076 */
1077 int
1078 sockargs(struct mbuf **mp, const void *bf, size_t buflen, int type)
1079 {
1080 struct sockaddr *sa;
1081 struct mbuf *m;
1082 int error;
1083
1084 /*
1085 * We can't allow socket names > UCHAR_MAX in length, since that
1086 * will overflow sa_len. Control data more than a page size in
1087 * length is just too much.
1088 */
1089 if (buflen > (type == MT_SONAME ? UCHAR_MAX : PAGE_SIZE))
1090 return (EINVAL);
1091
1092 /* Allocate an mbuf to hold the arguments. */
1093 m = m_get(M_WAIT, type);
1094 /* can't claim. don't who to assign it to. */
1095 if (buflen > MLEN) {
1096 /*
1097 * Won't fit into a regular mbuf, so we allocate just
1098 * enough external storage to hold the argument.
1099 */
1100 MEXTMALLOC(m, buflen, M_WAITOK);
1101 }
1102 m->m_len = buflen;
1103 error = copyin(bf, mtod(m, caddr_t), buflen);
1104 if (error) {
1105 (void) m_free(m);
1106 return (error);
1107 }
1108 *mp = m;
1109 if (type == MT_SONAME) {
1110 sa = mtod(m, struct sockaddr *);
1111 #if BYTE_ORDER != BIG_ENDIAN
1112 /*
1113 * 4.3BSD compat thing - need to stay, since bind(2),
1114 * connect(2), sendto(2) were not versioned for COMPAT_43.
1115 */
1116 if (sa->sa_family == 0 && sa->sa_len < AF_MAX)
1117 sa->sa_family = sa->sa_len;
1118 #endif
1119 sa->sa_len = buflen;
1120 }
1121 return (0);
1122 }
1123
1124 int
1125 getsock(struct filedesc *fdp, int fdes, struct file **fpp)
1126 {
1127 struct file *fp;
1128
1129 if ((fp = fd_getfile(fdp, fdes)) == NULL)
1130 return (EBADF);
1131
1132 FILE_USE(fp);
1133
1134 if (fp->f_type != DTYPE_SOCKET) {
1135 FILE_UNUSE(fp, NULL);
1136 return (ENOTSOCK);
1137 }
1138 *fpp = fp;
1139 return (0);
1140 }
Cache object: 8867689c46db517cf50930258c429131
|