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