![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to uipc_syscalls.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / kern|
Return to uipc_syscalls.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / kern |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
26: /*
27: * Copyright (c) 1982, 1986, 1989, 1990, 1993
28: * The Regents of the University of California. All rights reserved.
29: *
30: * Redistribution and use in source and binary forms, with or without
31: * modification, are permitted provided that the following conditions
32: * are met:
33: * 1. Redistributions of source code must retain the above copyright
34: * notice, this list of conditions and the following disclaimer.
35: * 2. Redistributions in binary form must reproduce the above copyright
36: * notice, this list of conditions and the following disclaimer in the
37: * documentation and/or other materials provided with the distribution.
38: * 3. All advertising materials mentioning features or use of this software
39: * must display the following acknowledgement:
40: * This product includes software developed by the University of
41: * California, Berkeley and its contributors.
42: * 4. Neither the name of the University nor the names of its contributors
43: * may be used to endorse or promote products derived from this software
44: * without specific prior written permission.
45: *
46: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
47: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
48: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
49: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
50: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
51: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
52: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
53: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
54: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
55: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56: * SUCH DAMAGE.
57: *
58: * @(#)uipc_syscalls.c 8.6 (Berkeley) 2/14/95
59: */
60:
61: #include <sys/param.h>
62: #include <sys/systm.h>
63: #include <sys/filedesc.h>
64: #include <sys/proc.h>
65: #include <sys/file.h>
66: #include <sys/buf.h>
67: #include <sys/malloc.h>
68: #include <sys/mbuf.h>
69: #include <sys/protosw.h>
70: #include <sys/socket.h>
71: #include <sys/socketvar.h>
72: #if KTRACE
73: #include <sys/ktrace.h>
74: #endif
75: #include <sys/kernel.h>
76:
77: #if NEXT
78: #import <kern/kdebug.h>
79:
80: #if KDEBUG
81:
82: #define DBG_LAYER_IN_BEG NETDBG_CODE(DBG_NETSOCK, 0)
83: #define DBG_LAYER_IN_END NETDBG_CODE(DBG_NETSOCK, 2)
84: #define DBG_LAYER_OUT_BEG NETDBG_CODE(DBG_NETSOCK, 1)
85: #define DBG_LAYER_OUT_END NETDBG_CODE(DBG_NETSOCK, 3)
86: #define DBG_FNC_SENDMSG NETDBG_CODE(DBG_NETSOCK, (1 << 8) | 1)
87: #define DBG_FNC_SENDTO NETDBG_CODE(DBG_NETSOCK, (2 << 8) | 1)
88: #define DBG_FNC_SENDIT NETDBG_CODE(DBG_NETSOCK, (3 << 8) | 1)
89: #define DBG_FNC_RECVFROM NETDBG_CODE(DBG_NETSOCK, (5 << 8))
90: #define DBG_FNC_RECVMSG NETDBG_CODE(DBG_NETSOCK, (6 << 8))
91: #define DBG_FNC_RECVIT NETDBG_CODE(DBG_NETSOCK, (7 << 8))
92:
93:
94: #endif
95:
96: #endif
97:
98:
99:
100: /*
101: * System call interface to the socket abstraction.
102: */
103: #if COMPAT_43
104: #define COMPAT_OLDSOCK
105: #endif
106:
107: extern struct fileops socketops;
108:
109: struct socket_args {
110: int domain;
111: int type;
112: int protocol;
113: };
114: int
115: socket(p, uap, retval)
116: struct proc *p;
117: register struct socket_args *uap;
118: register_t *retval;
119: {
120: struct socket *so;
121: struct file *fp;
122: int fd, error;
123:
124: if (error = falloc(p, &fp, &fd))
125: return (error);
126: fp->f_flag = FREAD|FWRITE;
127: fp->f_type = DTYPE_SOCKET;
128: fp->f_ops = &socketops;
129: if (error = socreate(uap->domain, &so, uap->type,
130: uap->protocol)) {
131: fdrelse(p, fd);
132: ffree(fp);
133: } else {
134: fp->f_data = (caddr_t)so;
135: *fdflags(p, fd) &= ~UF_RESERVED;
136: *retval = fd;
137: }
138: return (error);
139: }
140:
141: struct bind_args {
142: int s;
143: caddr_t name;
144: int namelen;
145: };
146:
147: /* ARGSUSED */
148: int
149: bind(p, uap, retval)
150: struct proc *p;
151: register struct bind_args *uap;
152: register_t *retval;
153: {
154: struct file *fp;
155: struct mbuf *nam;
156: int error;
157:
158: if (error = getsock(p, uap->s, &fp))
159: return (error);
160: if (error = sockargs(&nam, uap->name, uap->namelen,
161: MT_SONAME))
162: return (error);
163: error = sobind((struct socket *)fp->f_data, nam);
164: m_freem(nam);
165: return (error);
166: }
167:
168: struct listen_args {
169: int s;
170: int backlog;
171: };
172: /* ARGSUSED */
173: int
174: listen(p, uap, retval)
175: struct proc *p;
176: register struct listen_args *uap;
177: register_t *retval;
178: {
179: struct file *fp;
180: int error;
181:
182: if (error = getsock(p, uap->s, &fp))
183: return (error);
184: return (solisten((struct socket *)fp->f_data, uap->backlog));
185: }
186:
187: struct accept_args {
188: int s;
189: caddr_t name;
190: int *anamelen;
191: };
192: #ifdef COMPAT_OLDSOCK
193: int
194: accept(p, uap, retval)
195: struct proc *p;
196: struct accept_args *uap;
197: register_t *retval;
198: {
199:
200: return (accept1(p, uap, retval, 0));
201: }
202:
203: int
204: oaccept(p, uap, retval)
205: struct proc *p;
206: struct accept_args *uap;
207: register_t *retval;
208: {
209:
210: return (accept1(p, uap, retval, 1));
211: }
212: #else /* COMPAT_OLDSOCK */
213:
214: #define accept1 accept
215: #endif
216:
217: int
218: accept1(p, uap, retval, compat_43)
219: struct proc *p;
220: register struct accept_args *uap;
221: register_t *retval;
222: int compat_43;
223: {
224: struct file *fp;
225: struct mbuf *nam;
226: u_int namelen;
227: int error, s, tmpfd;
228: register struct socket *so;
229:
230: if (uap->name && (error = copyin((caddr_t)uap->anamelen,
231: (caddr_t)&namelen, sizeof (namelen))))
232: return (error);
233: if (error = getsock(p, uap->s, &fp))
234: return (error);
235: s = splnet();
236: so = (struct socket *)fp->f_data;
237: if ((so->so_options & SO_ACCEPTCONN) == 0) {
238: splx(s);
239: return (EINVAL);
240: }
241: if ((so->so_state & SS_NBIO) && so->so_qlen == 0) {
242: splx(s);
243: return (EWOULDBLOCK);
244: }
245: /*
246: * Move the falloc before tsleep so that we can correctly have
247: * multiple accept().
248: */
249: if (error = falloc(p, &fp, &tmpfd)) {
250: splx(s);
251: return (error);
252: }
253: while (so->so_qlen == 0 && so->so_error == 0) {
254: if (so->so_state & SS_CANTRCVMORE) {
255: so->so_error = ECONNABORTED;
256: break;
257: }
258: if (error = tsleep((caddr_t)&so->so_timeo, PSOCK | PCATCH,
259: netcon, 0)) {
260: goto ffreeout;
261: }
262: }
263: if (so->so_error) {
264: error = so->so_error;
265: so->so_error = 0;
266: goto ffreeout;
267: }
268: *fdflags(p, tmpfd) &= ~UF_RESERVED;
269: *retval = tmpfd;
270: { struct socket *aso = so->so_q;
271: if (soqremque(aso, 1) == 0)
272: panic("accept");
273: so = aso;
274: }
275: fp->f_type = DTYPE_SOCKET;
276: fp->f_flag = FREAD|FWRITE;
277: fp->f_ops = &socketops;
278: fp->f_data = (caddr_t)so;
279: nam = m_get(M_WAIT, MT_SONAME);
280: (void) soaccept(so, nam);
281: if (uap->name) {
282: #ifdef COMPAT_OLDSOCK
283: if (compat_43)
284: mtod(nam, struct osockaddr *)->sa_family =
285: mtod(nam, struct sockaddr *)->sa_family;
286: #endif
287: if (namelen > nam->m_len)
288: namelen = nam->m_len;
289: /* SHOULD COPY OUT A CHAIN HERE */
290: if ((error = copyout(mtod(nam, caddr_t),
291: (caddr_t)uap->name, (u_int)namelen)) == 0)
292: error = copyout((caddr_t)&namelen,
293: (caddr_t)uap->anamelen,
294: sizeof (*uap->anamelen));
295: }
296: m_freem(nam);
297: splx(s);
298: return (error);
299:
300: ffreeout:
301: fdrelse(p, tmpfd);
302: ffree(fp);
303: splx(s);
304: return (error);
305: }
306:
307: struct connect_args {
308: int s;
309: caddr_t name;
310: int namelen;
311: };
312: /* ARGSUSED */
313: int
314: connect(p, uap, retval)
315: struct proc *p;
316: register struct connect_args *uap;
317: register_t *retval;
318: {
319: struct file *fp;
320: register struct socket *so;
321: struct mbuf *nam;
322: int error, s;
323:
324: if (error = getsock(p, uap->s, &fp))
325: return (error);
326: so = (struct socket *)fp->f_data;
327: if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING))
328: return (EALREADY);
329: if (error = sockargs(&nam, uap->name, uap->namelen,
330: MT_SONAME))
331: return (error);
332: error = soconnect(so, nam);
333: if (error)
334: goto bad;
335: if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {
336: m_freem(nam);
337: return (EINPROGRESS);
338: }
339: s = splnet();
340: while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0)
341: if (error = tsleep((caddr_t)&so->so_timeo, PSOCK | PCATCH,
342: netcon, 0))
343: break;
344: if (error == 0) {
345: error = so->so_error;
346: so->so_error = 0;
347: }
348: splx(s);
349: bad:
350: so->so_state &= ~SS_ISCONNECTING;
351: m_freem(nam);
352: if (error == ERESTART)
353: error = EINTR;
354: return (error);
355: }
356:
357: struct socketpair_args {
358: int domain;
359: int type;
360: int protocol;
361: int *rsv;
362: };
363: int
364: socketpair(p, uap, retval)
365: struct proc *p;
366: register struct socketpair_args *uap;
367: register_t *retval;
368: {
369: struct file *fp1, *fp2;
370: struct socket *so1, *so2;
371: int fd, error, sv[2];
372:
373: if (error = socreate(uap->domain, &so1, uap->type,
374: uap->protocol))
375: return (error);
376: if (error = socreate(uap->domain, &so2, uap->type,
377: uap->protocol))
378: goto free1;
379: if (error = falloc(p, &fp1, &fd))
380: goto free2;
381: sv[0] = fd;
382: fp1->f_flag = FREAD|FWRITE;
383: fp1->f_type = DTYPE_SOCKET;
384: fp1->f_ops = &socketops;
385: fp1->f_data = (caddr_t)so1;
386: if (error = falloc(p, &fp2, &fd))
387: goto free3;
388: fp2->f_flag = FREAD|FWRITE;
389: fp2->f_type = DTYPE_SOCKET;
390: fp2->f_ops = &socketops;
391: fp2->f_data = (caddr_t)so2;
392: sv[1] = fd;
393: if (error = soconnect2(so1, so2))
394: goto free4;
395: if (uap->type == SOCK_DGRAM) {
396: /*
397: * Datagram socket connection is asymmetric.
398: */
399: if (error = soconnect2(so2, so1))
400: goto free4;
401: }
402: *fdflags(p, sv[0]) &= ~UF_RESERVED;
403: *fdflags(p, sv[1]) &= ~UF_RESERVED;
404: error = copyout((caddr_t)sv, (caddr_t)uap->rsv,
405: 2 * sizeof (int));
406: #if 0 /* old pipe(2) syscall compatability, unused these days */
407: retval[0] = sv[0]; /* XXX ??? */
408: retval[1] = sv[1]; /* XXX ??? */
409: #endif /* 0 */
410: return (error);
411: free4:
412: fdrelse(p, sv[1]);
413: ffree(fp2);
414: free3:
415: fdrelse(p, sv[0]);
416: ffree(fp1);
417: free2:
418: (void)soclose(so2);
419: free1:
420: (void)soclose(so1);
421: return (error);
422: }
423:
424: int sendit(struct proc *, int, struct msghdr *, int, register_t *);
425:
426: struct sendto_args {
427: int s;
428: caddr_t buf;
429: size_t len;
430: int flags;
431: caddr_t to;
432: int tolen;
433: };
434: int
435: sendto(p, uap, retval)
436: struct proc *p;
437: register struct sendto_args *uap;
438: register_t *retval;
439: {
440: struct msghdr msg;
441: struct iovec aiov;
442: int stat;
443:
444: KERNEL_DEBUG(DBG_FNC_SENDTO | DBG_FUNC_START, 0,0,0,0,0);
445:
446: msg.msg_name = uap->to;
447: msg.msg_namelen = uap->tolen;
448: msg.msg_iov = &aiov;
449: msg.msg_iovlen = 1;
450: msg.msg_control = 0;
451: #ifdef COMPAT_OLDSOCK
452: msg.msg_flags = 0;
453: #endif
454: aiov.iov_base = uap->buf;
455: aiov.iov_len = uap->len;
456:
457: stat = sendit(p, uap->s, &msg, uap->flags, retval);
458: KERNEL_DEBUG(DBG_FNC_SENDTO | DBG_FUNC_END, stat, *retval,0,0,0);
459: return (stat);
460: }
461:
462: #ifdef COMPAT_OLDSOCK
463: struct osend_args {
464: int s;
465: caddr_t buf;
466: int len;
467: int flags;
468: };
469: int
470: osend(p, uap, retval)
471: struct proc *p;
472: register struct osend_args *uap;
473: register_t *retval;
474: {
475: struct msghdr msg;
476: struct iovec aiov;
477:
478: msg.msg_name = 0;
479: msg.msg_namelen = 0;
480: msg.msg_iov = &aiov;
481: msg.msg_iovlen = 1;
482: aiov.iov_base = uap->buf;
483: aiov.iov_len = uap->len;
484: msg.msg_control = 0;
485: msg.msg_flags = 0;
486: return (sendit(p, uap->s, &msg, uap->flags, retval));
487: }
488:
489: #define MSG_COMPAT 0x8000
490: struct osendmsg_args {
491: int s;
492: caddr_t msg;
493: int flags;
494: };
495: int
496: osendmsg(p, uap, retval)
497: struct proc *p;
498: register struct osendmsg_args *uap;
499: register_t *retval;
500: {
501: struct msghdr msg;
502: struct iovec aiov[UIO_SMALLIOV], *iov;
503: int error;
504: u_int iovlen;
505:
506: if (error = copyin(uap->msg, (caddr_t)&msg,
507: sizeof (struct omsghdr)))
508: return (error);
509: iovlen = (u_int)msg.msg_iovlen;
510: if (iovlen >= UIO_SMALLIOV) {
511: if (iovlen >= UIO_MAXIOV)
512: return (EMSGSIZE);
513: MALLOC_ZONE(iov, struct iovec *,
514: sizeof(struct iovec) * iovlen, M_IOV, M_WAITOK);
515: } else
516: iov = aiov;
517: if (error = copyin((caddr_t)msg.msg_iov, (caddr_t)iov,
518: (unsigned)(msg.msg_iovlen * sizeof (struct iovec))))
519: goto done;
520: msg.msg_flags = MSG_COMPAT;
521: msg.msg_iov = iov;
522: error = sendit(p, uap->s, &msg, uap->flags, retval);
523: done:
524: if (iov != aiov)
525: FREE_ZONE(iov, sizeof (struct iovec) * iovlen, M_IOV);
526: return (error);
527: }
528: #endif
529:
530: struct sendmsg_args {
531: int s;
532: caddr_t msg;
533: int flags;
534: };
535: int
536: sendmsg(p, uap, retval)
537: struct proc *p;
538: register struct sendmsg_args *uap;
539: register_t *retval;
540: {
541: struct msghdr msg;
542: struct iovec aiov[UIO_SMALLIOV], *iov;
543: int error;
544: u_int iovlen;
545:
546: KERNEL_DEBUG(DBG_FNC_SENDMSG | DBG_FUNC_START, 0,0,0,0,0);
547: if (error = copyin(uap->msg, (caddr_t)&msg, sizeof (msg)))
548: {
549: KERNEL_DEBUG(DBG_FNC_SENDMSG | DBG_FUNC_END, error,0,0,0,0);
550: return (error);
551: }
552:
553: iovlen = (u_int)msg.msg_iovlen;
554: if (iovlen >= UIO_SMALLIOV) {
555: if (iovlen >= UIO_MAXIOV)
556: {
557: KERNEL_DEBUG(DBG_FNC_SENDMSG | DBG_FUNC_END, EMSGSIZE,0,0,0,0);
558: return (EMSGSIZE);
559: }
560:
561: MALLOC_ZONE(iov, struct iovec *,
562: sizeof(struct iovec) * iovlen, M_IOV, M_WAITOK);
563: } else
564: iov = aiov;
565: if (msg.msg_iovlen &&
566: (error = copyin((caddr_t)msg.msg_iov, (caddr_t)iov,
567: (unsigned)(msg.msg_iovlen * sizeof (struct iovec)))))
568: goto done;
569: msg.msg_iov = iov;
570: #ifdef COMPAT_OLDSOCK
571: msg.msg_flags = 0;
572: #endif
573: error = sendit(p, uap->s, &msg, uap->flags, retval);
574: done:
575: if (iov != aiov)
576: FREE_ZONE(iov, sizeof (struct iovec) * iovlen, M_IOV);
577: KERNEL_DEBUG(DBG_FNC_SENDMSG | DBG_FUNC_END, error,0,0,0,0);
578: return (error);
579: }
580:
581: int
582: sendit(p, s, mp, flags, retsize)
583: register struct proc *p;
584: int s;
585: register struct msghdr *mp;
586: int flags;
587: register_t *retsize;
588: {
589: struct file *fp;
590: struct uio auio;
591: register struct iovec *iov;
592: register int i;
593: struct mbuf *to, *control;
594: int len, error;
595: #if KTRACE
596: struct iovec *ktriov = NULL;
597: #endif
598:
599: KERNEL_DEBUG(DBG_FNC_SENDIT | DBG_FUNC_START, 0,0,0,0,0);
600:
601: if (error = getsock(p, s, &fp))
602: {
603: KERNEL_DEBUG(DBG_FNC_SENDIT | DBG_FUNC_END, error,0,0,0,0);
604: return (error);
605: }
606:
607: auio.uio_iov = mp->msg_iov;
608: auio.uio_iovcnt = mp->msg_iovlen;
609: auio.uio_segflg = UIO_USERSPACE;
610: auio.uio_rw = UIO_WRITE;
611: auio.uio_procp = p;
612: auio.uio_offset = 0; /* XXX */
613: auio.uio_resid = 0;
614: iov = mp->msg_iov;
615: for (i = 0; i < mp->msg_iovlen; i++, iov++) {
616: if (iov->iov_len < 0)
617: {
618: KERNEL_DEBUG(DBG_FNC_SENDIT | DBG_FUNC_END, EINVAL,0,0,0,0);
619: return (EINVAL);
620: }
621:
622: if ((auio.uio_resid += iov->iov_len) < 0)
623: {
624: KERNEL_DEBUG(DBG_FNC_SENDIT | DBG_FUNC_END, EINVAL,0,0,0,0);
625: return (EINVAL);
626: }
627: }
628: if (mp->msg_name) {
629: if (error = sockargs(&to, mp->msg_name, mp->msg_namelen,
630: MT_SONAME))
631: {
632: KERNEL_DEBUG(DBG_FNC_SENDIT | DBG_FUNC_END, error,0,0,0,0);
633: return (error);
634: }
635: } else
636: to = 0;
637: if (mp->msg_control) {
638: if (mp->msg_controllen < sizeof(struct cmsghdr)
639: #ifdef COMPAT_OLDSOCK
640: && mp->msg_flags != MSG_COMPAT
641: #endif
642: ) {
643: error = EINVAL;
644: goto bad;
645: }
646: if (error = sockargs(&control, mp->msg_control,
647: mp->msg_controllen, MT_CONTROL))
648: goto bad;
649: #ifdef COMPAT_OLDSOCK
650: if (mp->msg_flags == MSG_COMPAT) {
651: register struct cmsghdr *cm;
652:
653: M_PREPEND(control, sizeof(*cm), M_WAIT);
654: if (control == 0) {
655: error = ENOBUFS;
656: goto bad;
657: } else {
658: cm = mtod(control, struct cmsghdr *);
659: cm->cmsg_len = control->m_len;
660: cm->cmsg_level = SOL_SOCKET;
661: cm->cmsg_type = SCM_RIGHTS;
662: }
663: }
664: #endif
665: } else
666: control = 0;
667: #if KTRACE
668: if (KTRPOINT(p, KTR_GENIO)) {
669: int iovlen = auio.uio_iovcnt * sizeof (struct iovec);
670:
671: MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
672: bcopy((caddr_t)auio.uio_iov, (caddr_t)ktriov, iovlen);
673: }
674: #endif
675: len = auio.uio_resid;
676: if (error = sosend((struct socket *)fp->f_data, to, &auio,
677: (struct mbuf *)0, control, flags)) {
678: if (auio.uio_resid != len && (error == ERESTART ||
679: error == EINTR || error == EWOULDBLOCK))
680: error = 0;
681: if (error == EPIPE)
682: psignal(p, SIGPIPE);
683: }
684: if (error == 0)
685: *retsize = len - auio.uio_resid;
686: #if KTRACE
687: if (ktriov != NULL) {
688: if (error == 0)
689: ktrgenio(p->p_tracep, s, UIO_WRITE,
690: ktriov, *retsize, error);
691: FREE(ktriov, M_TEMP);
692: }
693: #endif
694: bad:
695: if (to)
696: m_freem(to);
697:
698: KERNEL_DEBUG(DBG_FNC_SENDIT | DBG_FUNC_END, error,0,0,0,0);
699: return (error);
700: }
701:
702: struct recvfrom_args {
703: int s;
704: caddr_t buf;
705: size_t len;
706: int flags;
707: caddr_t from;
708: int *fromlenaddr;
709: };
710: #ifdef COMPAT_OLDSOCK
711: int
712: orecvfrom(p, uap, retval)
713: struct proc *p;
714: struct recvfrom_args *uap;
715: register_t *retval;
716: {
717:
718: uap->flags |= MSG_COMPAT;
719: return (recvfrom(p, uap, retval));
720: }
721: #endif
722:
723: int
724: recvfrom(p, uap, retval)
725: struct proc *p;
726: register struct recvfrom_args *uap;
727: register_t *retval;
728: {
729: struct msghdr msg;
730: struct iovec aiov;
731: int error;
732:
733:
734: KERNEL_DEBUG(DBG_FNC_RECVFROM | DBG_FUNC_START, 0,0,0,0,0);
735:
736: if (uap->fromlenaddr) {
737: if (error = copyin((caddr_t)uap->fromlenaddr,
738: (caddr_t)&msg.msg_namelen, sizeof (msg.msg_namelen)))
739: {
740: KERNEL_DEBUG(DBG_FNC_RECVFROM | DBG_FUNC_END, error,0,0,0,0);
741: return (error);
742: }
743: } else
744: msg.msg_namelen = 0;
745: msg.msg_name = uap->from;
746: msg.msg_iov = &aiov;
747: msg.msg_iovlen = 1;
748: aiov.iov_base = uap->buf;
749: aiov.iov_len = uap->len;
750: msg.msg_control = 0;
751: msg.msg_flags = uap->flags;
752: error = recvit(p, uap->s, &msg, (caddr_t)uap->fromlenaddr, retval);
753: KERNEL_DEBUG(DBG_FNC_RECVFROM | DBG_FUNC_END, error,0,0,0,0);
754: return (error);
755: }
756:
757: #ifdef COMPAT_OLDSOCK
758: struct orecv_args {
759: int s;
760: caddr_t buf;
761: int len;
762: int flags;
763: };
764: int
765: orecv(p, uap, retval)
766: struct proc *p;
767: register struct orecv_args *uap;
768: register_t *retval;
769: {
770: struct msghdr msg;
771: struct iovec aiov;
772:
773: msg.msg_name = 0;
774: msg.msg_namelen = 0;
775: msg.msg_iov = &aiov;
776: msg.msg_iovlen = 1;
777: aiov.iov_base = uap->buf;
778: aiov.iov_len = uap->len;
779: msg.msg_control = 0;
780: msg.msg_flags = uap->flags;
781: return (recvit(p, uap->s, &msg, (caddr_t)0, retval));
782: }
783:
784: /*
785: * Old recvmsg. This code takes advantage of the fact that the old msghdr
786: * overlays the new one, missing only the flags, and with the (old) access
787: * rights where the control fields are now.
788: */
789: struct orecvmsg_args {
790: int s;
791: struct omsghdr *msg;
792: int flags;
793: };
794: int
795: orecvmsg(p, uap, retval)
796: struct proc *p;
797: register struct orecvmsg_args *uap;
798: register_t *retval;
799: {
800: struct msghdr msg;
801: struct iovec aiov[UIO_SMALLIOV], *iov;
802: int error;
803: u_int iovlen;
804:
805: if (error = copyin((caddr_t)uap->msg, (caddr_t)&msg,
806: sizeof (struct omsghdr)))
807: return (error);
808: iovlen = (u_int)msg.msg_iovlen;
809: if (iovlen >= UIO_SMALLIOV) {
810: if (iovlen >= UIO_MAXIOV)
811: return (EMSGSIZE);
812: MALLOC_ZONE(iov, struct iovec *,
813: sizeof(struct iovec) * iovlen, M_IOV, M_WAITOK);
814: } else
815: iov = aiov;
816: msg.msg_flags = uap->flags | MSG_COMPAT;
817: if (error = copyin((caddr_t)msg.msg_iov, (caddr_t)iov,
818: (unsigned)(msg.msg_iovlen * sizeof (struct iovec))))
819: goto done;
820: msg.msg_iov = iov;
821: error = recvit(p, uap->s, &msg,
822: (caddr_t)&uap->msg->msg_namelen, retval);
823:
824: if (msg.msg_controllen && error == 0)
825: error = copyout((caddr_t)&msg.msg_controllen,
826: (caddr_t)&uap->msg->msg_accrightslen, sizeof (int));
827: done:
828: if (iov != aiov)
829: FREE_ZONE(iov, sizeof (struct iovec) * iovlen, M_IOV);
830: return (error);
831: }
832: #endif
833:
834: struct recvmsg_args {
835: int s;
836: struct msghdr *msg;
837: int flags;
838: };
839: int
840: recvmsg(p, uap, retval)
841: struct proc *p;
842: register struct recvmsg_args *uap;
843: register_t *retval;
844: {
845: struct msghdr msg;
846: struct iovec aiov[UIO_SMALLIOV], *uiov, *iov;
847: register int error;
848: u_int iovlen;
849:
850: KERNEL_DEBUG(DBG_FNC_RECVMSG | DBG_FUNC_START, 0,0,0,0,0);
851: if (error = copyin((caddr_t)uap->msg, (caddr_t)&msg,
852: sizeof (msg)))
853: {
854: KERNEL_DEBUG(DBG_FNC_RECVMSG | DBG_FUNC_END, error,0,0,0,0);
855: return (error);
856: }
857:
858: iovlen = (u_int)msg.msg_iovlen;
859: if (iovlen >= UIO_SMALLIOV) {
860: if (iovlen >= UIO_MAXIOV)
861: {
862: KERNEL_DEBUG(DBG_FNC_RECVMSG | DBG_FUNC_END, error,0,0,0,0);
863: return (EMSGSIZE);
864: }
865:
866: MALLOC_ZONE(iov, struct iovec *,
867: sizeof(struct iovec) * iovlen, M_IOV, M_WAITOK);
868: } else
869: iov = aiov;
870: #ifdef COMPAT_OLDSOCK
871: msg.msg_flags = uap->flags &~ MSG_COMPAT;
872: #else
873: msg.msg_flags = uap->flags;
874: #endif
875: uiov = msg.msg_iov;
876: msg.msg_iov = iov;
877: if (error = copyin((caddr_t)uiov, (caddr_t)iov,
878: (unsigned)(msg.msg_iovlen * sizeof (struct iovec))))
879: goto done;
880: if ((error = recvit(p, uap->s, &msg, (caddr_t)0, retval)) == 0) {
881: msg.msg_iov = uiov;
882: error = copyout((caddr_t)&msg, (caddr_t)uap->msg,
883: sizeof(msg));
884: }
885: done:
886: if (iov != aiov)
887: FREE_ZONE(iov, sizeof (struct iovec) * iovlen, M_IOV);
888:
889: KERNEL_DEBUG(DBG_FNC_RECVMSG | DBG_FUNC_END, error,0,0,0,0);
890: return (error);
891: }
892:
893: int
894: recvit(p, s, mp, namelenp, retsize)
895: register struct proc *p;
896: int s;
897: register struct msghdr *mp;
898: caddr_t namelenp;
899: register_t *retsize;
900: {
901: struct file *fp;
902: struct uio auio;
903: register struct iovec *iov;
904: register int i;
905: int len, error;
906: struct mbuf *from = 0, *control = 0;
907: #if KTRACE
908: struct iovec *ktriov = NULL;
909: #endif
910:
911: KERNEL_DEBUG(DBG_FNC_RECVIT | DBG_FUNC_START, 0,0,0,0,0);
912: if (error = getsock(p, s, &fp))
913: {
914: KERNEL_DEBUG(DBG_FNC_RECVIT | DBG_FUNC_END, error,0,0,0,0);
915: return (error);
916: }
917:
918: auio.uio_iov = mp->msg_iov;
919: auio.uio_iovcnt = mp->msg_iovlen;
920: auio.uio_segflg = UIO_USERSPACE;
921: auio.uio_rw = UIO_READ;
922: auio.uio_procp = p;
923: auio.uio_offset = 0; /* XXX */
924: auio.uio_resid = 0;
925: iov = mp->msg_iov;
926: for (i = 0; i < mp->msg_iovlen; i++, iov++) {
927: if (iov->iov_len < 0)
928: {
929: KERNEL_DEBUG(DBG_FNC_RECVIT | DBG_FUNC_END, EINVAL,0,0,0,0);
930: return (EINVAL);
931: }
932: if ((auio.uio_resid += iov->iov_len) < 0)
933: {
934: KERNEL_DEBUG(DBG_FNC_RECVIT | DBG_FUNC_END, EINVAL,0,0,0,0);
935: return (EINVAL);
936: }
937:
938: }
939: #if KTRACE
940: if (KTRPOINT(p, KTR_GENIO)) {
941: int iovlen = auio.uio_iovcnt * sizeof (struct iovec);
942:
943: MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
944: bcopy((caddr_t)auio.uio_iov, (caddr_t)ktriov, iovlen);
945: }
946: #endif
947: len = auio.uio_resid;
948: if (error = soreceive((struct socket *)fp->f_data, &from, &auio,
949: (struct mbuf **)0, mp->msg_control ? &control : (struct mbuf **)0,
950: &mp->msg_flags)) {
951: if (auio.uio_resid != len && (error == ERESTART ||
952: error == EINTR || error == EWOULDBLOCK))
953: error = 0;
954: }
955: #if KTRACE
956: if (ktriov != NULL) {
957: if (error == 0)
958: ktrgenio(p->p_tracep, s, UIO_READ,
959: ktriov, len - auio.uio_resid, error);
960: FREE(ktriov, M_TEMP);
961: }
962: #endif
963: if (error)
964: goto out;
965: *retsize = len - auio.uio_resid;
966: if (mp->msg_name) {
967: len = mp->msg_namelen;
968: if (len <= 0 || from == 0)
969: len = 0;
970: else {
971: #ifdef COMPAT_OLDSOCK
972: if (mp->msg_flags & MSG_COMPAT)
973: mtod(from, struct osockaddr *)->sa_family =
974: mtod(from, struct sockaddr *)->sa_family;
975: #endif
976: if (len > from->m_len)
977: len = from->m_len;
978: /* else if len < from->m_len ??? */
979: if (error = copyout(mtod(from, caddr_t),
980: (caddr_t)mp->msg_name, (unsigned)len))
981: goto out;
982: }
983: mp->msg_namelen = len;
984: if (namelenp &&
985: (error = copyout((caddr_t)&len, namelenp, sizeof (int)))) {
986: #ifdef COMPAT_OLDSOCK
987: if (mp->msg_flags & MSG_COMPAT)
988: error = 0; /* old recvfrom didn't check */
989: else
990: #endif
991: goto out;
992: }
993: }
994: if (mp->msg_control) {
995: #ifdef COMPAT_OLDSOCK
996: /*
997: * We assume that old recvmsg calls won't receive access
998: * rights and other control info, esp. as control info
999: * is always optional and those options didn't exist in 4.3.
1000: * If we receive rights, trim the cmsghdr; anything else
1001: * is tossed.
1002: */
1003: if (control && mp->msg_flags & MSG_COMPAT) {
1004: if (mtod(control, struct cmsghdr *)->cmsg_level !=
1005: SOL_SOCKET ||
1006: mtod(control, struct cmsghdr *)->cmsg_type !=
1007: SCM_RIGHTS) {
1008: mp->msg_controllen = 0;
1009: goto out;
1010: }
1011: control->m_len -= sizeof (struct cmsghdr);
1012: control->m_data += sizeof (struct cmsghdr);
1013: }
1014: #endif
1015: len = 0;
1016: if (mp->msg_controllen <= 0 || control == 0)
1017: ;
1018: else {
1019: struct mbuf * c = control;
1020:
1021: for (c = control;
1022: c && len < mp->msg_controllen && !error;
1023: c = c->m_next) {
1024: int clen;
1025: clen = c->m_len;
1026: if ((len + clen) > mp->msg_controllen) {
1027: clen = mp->msg_controllen - len;
1028: mp->msg_flags |= MSG_CTRUNC;
1029: }
1030: error = copyout((caddr_t)mtod(c, caddr_t),
1031: (caddr_t)mp->msg_control + len,
1032: (unsigned)clen);
1033: len += clen;
1034: }
1035: }
1036: mp->msg_controllen = len;
1037: }
1038: out:
1039: if (from)
1040: m_freem(from);
1041: if (control)
1042: m_freem(control);
1043:
1044: KERNEL_DEBUG(DBG_FNC_RECVIT | DBG_FUNC_END, error,0,0,0,0);
1045: return (error);
1046: }
1047:
1048: struct shutdown_args {
1049: int s;
1050: int how;
1051: };
1052: /* ARGSUSED */
1053: int
1054: shutdown(p, uap, retval)
1055: struct proc *p;
1056: register struct shutdown_args *uap;
1057: register_t *retval;
1058: {
1059: struct file *fp;
1060: int error;
1061:
1062: if (error = getsock(p, uap->s, &fp))
1063: return (error);
1064: return (soshutdown((struct socket *)fp->f_data, uap->how));
1065: }
1066:
1067: struct setsockopt_args {
1068: int s;
1069: int level;
1070: int name;
1071: caddr_t val;
1072: int valsize;
1073: };
1074: /* ARGSUSED */
1075: int
1076: setsockopt(p, uap, retval)
1077: struct proc *p;
1078: register struct setsockopt_args *uap;
1079: register_t *retval;
1080: {
1081: struct file *fp;
1082: struct mbuf *m = NULL;
1083: int error;
1084:
1085: if (error = getsock(p, uap->s, &fp))
1086: return (error);
1087: if (uap->valsize > MLEN)
1088: return (EINVAL);
1089: if (uap->val) {
1090: m = m_get(M_WAIT, MT_SOOPTS);
1091: if (m == NULL)
1092: return (ENOBUFS);
1093: if (error = copyin(uap->val, mtod(m, caddr_t),
1094: (u_int)uap->valsize)) {
1095: (void) m_free(m);
1096: return (error);
1097: }
1098: m->m_len = uap->valsize;
1099: }
1100: return (sosetopt((struct socket *)fp->f_data, uap->level,
1101: uap->name, m));
1102: }
1103:
1104: struct getsockopt_args {
1105: int s;
1106: int level;
1107: int name;
1108: caddr_t val;
1109: int *avalsize;
1110: };
1111: /* ARGSUSED */
1112: int
1113: getsockopt(p, uap, retval)
1114: struct proc *p;
1115: register struct getsockopt_args *uap;
1116: register_t *retval;
1117: {
1118: struct file *fp;
1119: struct mbuf *m = NULL;
1120: int valsize, error;
1121:
1122: if (error = getsock(p, uap->s, &fp))
1123: return (error);
1124: if (uap->val) {
1125: if (error = copyin((caddr_t)uap->avalsize,
1126: (caddr_t)&valsize, sizeof (valsize)))
1127: return (error);
1128: } else
1129: valsize = 0;
1130: if ((error = sogetopt((struct socket *)fp->f_data, uap->level,
1131: uap->name, &m)) == 0 && uap->val && valsize &&
1132: m != NULL) {
1133: if (valsize > m->m_len)
1134: valsize = m->m_len;
1135: error = copyout(mtod(m, caddr_t), uap->val,
1136: (u_int)valsize);
1137: if (error == 0)
1138: error = copyout((caddr_t)&valsize,
1139: (caddr_t)uap->avalsize, sizeof (valsize));
1140: }
1141: if (m != NULL)
1142: (void) m_free(m);
1143: return (error);
1144: }
1145:
1146: struct pipe_args {
1147: int dummy;
1148: };
1149: /* ARGSUSED */
1150: int
1151: pipe(p, uap, retval)
1152: struct proc *p;
1153: struct pipe_args *uap;
1154: register_t *retval;
1155: {
1156: struct file *rf, *wf;
1157: struct socket *rso, *wso;
1158: int fd, error;
1159:
1160: if (error = socreate(AF_UNIX, &rso, SOCK_STREAM, 0))
1161: return (error);
1162: if (error = socreate(AF_UNIX, &wso, SOCK_STREAM, 0))
1163: goto free1;
1164: if (error = falloc(p, &rf, &fd))
1165: goto free2;
1166: retval[0] = fd;
1167: rf->f_flag = FREAD;
1168: rf->f_type = DTYPE_SOCKET;
1169: rf->f_ops = &socketops;
1170: rf->f_data = (caddr_t)rso;
1171: if (error = falloc(p, &wf, &fd))
1172: goto free3;
1173: wf->f_flag = FWRITE;
1174: wf->f_type = DTYPE_SOCKET;
1175: wf->f_ops = &socketops;
1176: wf->f_data = (caddr_t)wso;
1177: retval[1] = fd;
1178: if (error = unp_connect2(wso, rso))
1179: goto free4;
1180: *fdflags(p, retval[0]) &= ~UF_RESERVED;
1181: *fdflags(p, retval[1]) &= ~UF_RESERVED;
1182: return (0);
1183: free4:
1184: fdrelse(p, retval[1]);
1185: ffree(wf);
1186: free3:
1187: fdrelse(p, retval[0]);
1188: ffree(rf);
1189: free2:
1190: (void)soclose(wso);
1191: free1:
1192: (void)soclose(rso);
1193: return (error);
1194: }
1195:
1196: /*
1197: * Get socket name.
1198: */
1199: struct getsockname_args {
1200: int fdes;
1201: caddr_t asa;
1202: int *alen;
1203: };
1204: #ifdef COMPAT_OLDSOCK
1205: int
1206: getsockname(p, uap, retval)
1207: struct proc *p;
1208: struct getsockname_args *uap;
1209: register_t *retval;
1210: {
1211: return (getsockname1(p, uap, retval, 0));
1212: }
1213:
1214: int
1215: ogetsockname(p, uap, retval)
1216: struct proc *p;
1217: struct getsockname_args *uap;
1218: register_t *retval;
1219: {
1220: return (getsockname1(p, uap, retval, 1));
1221: }
1222: #else /* COMPAT_OLDSOCK */
1223:
1224: #define getsockname1 getsockname
1225: #endif
1226:
1227: /* ARGSUSED */
1228: int
1229: getsockname1(p, uap, retval, compat_43)
1230: struct proc *p;
1231: register struct getsockname_args *uap;
1232: register_t *retval;
1233: int compat_43;
1234: {
1235: struct file *fp;
1236: register struct socket *so;
1237: struct mbuf *m;
1238: int len, error;
1239:
1240: if (error = getsock(p, uap->fdes, &fp))
1241: return (error);
1242: if (error = copyin((caddr_t)uap->alen, (caddr_t)&len,
1243: sizeof (len)))
1244: return (error);
1245: so = (struct socket *)fp->f_data;
1246: m = m_getclr(M_WAIT, MT_SONAME);
1247: if (m == NULL)
1248: return (ENOBUFS);
1249: if (error = (*so->so_proto->pr_usrreq)(so, PRU_SOCKADDR, 0, m, 0))
1250: goto bad;
1251: if (len > m->m_len)
1252: len = m->m_len;
1253: #ifdef COMPAT_OLDSOCK
1254: if (compat_43)
1255: mtod(m, struct osockaddr *)->sa_family =
1256: mtod(m, struct sockaddr *)->sa_family;
1257: #endif
1258: error = copyout(mtod(m, caddr_t), (caddr_t)uap->asa, (u_int)len);
1259: if (error == 0)
1260: error = copyout((caddr_t)&len, (caddr_t)uap->alen,
1261: sizeof (len));
1262: bad:
1263: m_freem(m);
1264: return (error);
1265: }
1266:
1267: /*
1268: * Get name of peer for connected socket.
1269: */
1270: struct getpeername_args {
1271: int fdes;
1272: caddr_t asa;
1273: int *alen;
1274: };
1275: #ifdef COMPAT_OLDSOCK
1276: int
1277: getpeername(p, uap, retval)
1278: struct proc *p;
1279: struct getpeername_args *uap;
1280: register_t *retval;
1281: {
1282: return (getpeername1(p, uap, retval, 0));
1283: }
1284:
1285: int
1286: ogetpeername(p, uap, retval)
1287: struct proc *p;
1288: struct getpeername_args *uap;
1289: register_t *retval;
1290: {
1291:
1292: return (getpeername1(p, uap, retval, 1));
1293: }
1294: #else /* COMPAT_OLDSOCK */
1295:
1296: #define getpeername1 getpeername
1297: #endif
1298:
1299: /* ARGSUSED */
1300: int
1301: getpeername1(p, uap, retval, compat_43)
1302: struct proc *p;
1303: register struct getpeername_args *uap;
1304: register_t *retval;
1305: int compat_43;
1306: {
1307: struct file *fp;
1308: register struct socket *so;
1309: struct mbuf *m;
1310: int len, error;
1311:
1312: if (error = getsock(p, uap->fdes, &fp))
1313: return (error);
1314: so = (struct socket *)fp->f_data;
1315: if ((so->so_state & (SS_ISCONNECTED|SS_ISCONFIRMING)) == 0)
1316: return (ENOTCONN);
1317: if (error =
1318: copyin((caddr_t)uap->alen, (caddr_t)&len, sizeof (len)))
1319: return (error);
1320: m = m_getclr(M_WAIT, MT_SONAME);
1321: if (m == NULL)
1322: return (ENOBUFS);
1323: if (error = (*so->so_proto->pr_usrreq)(so, PRU_PEERADDR, 0, m, 0))
1324: goto bad;
1325: if (len > m->m_len)
1326: len = m->m_len;
1327: #ifdef COMPAT_OLDSOCK
1328: if (compat_43)
1329: mtod(m, struct osockaddr *)->sa_family =
1330: mtod(m, struct sockaddr *)->sa_family;
1331: #endif
1332: if (error =
1333: copyout(mtod(m, caddr_t), (caddr_t)uap->asa, (u_int)len))
1334: goto bad;
1335: error = copyout((caddr_t)&len, (caddr_t)uap->alen, sizeof (len));
1336: bad:
1337: m_freem(m);
1338: return (error);
1339: }
1340:
1341: int
1342: sockargs(mp, buf, buflen, type)
1343: struct mbuf **mp;
1344: caddr_t buf;
1345: int buflen, type;
1346: {
1347: register struct sockaddr *sa;
1348: register struct mbuf *m;
1349: int error;
1350:
1351: if ((u_int)buflen > MLEN) {
1352: #ifdef COMPAT_OLDSOCK
1353: if (type == MT_SONAME && (u_int)buflen <= 112)
1354: buflen = MLEN; /* unix domain compat. hack */
1355: else
1356: #endif
1357: return (EINVAL);
1358: }
1359: m = m_get(M_WAIT, type);
1360: if (m == NULL)
1361: return (ENOBUFS);
1362: m->m_len = buflen;
1363: error = copyin(buf, mtod(m, caddr_t), (u_int)buflen);
1364: if (error) {
1365: (void) m_free(m);
1366: return (error);
1367: }
1368: *mp = m;
1369: if (type == MT_SONAME) {
1370: sa = mtod(m, struct sockaddr *);
1371:
1372: #if defined(COMPAT_OLDSOCK) && BYTE_ORDER != BIG_ENDIAN
1373: if (sa->sa_family == 0 && sa->sa_len < AF_MAX)
1374: sa->sa_family = sa->sa_len;
1375: #endif
1376: sa->sa_len = buflen;
1377: }
1378: return (0);
1379: }
1380:
1381: int
1382: getsock(p, fdes, fpp)
1383: struct proc *p;
1384: int fdes;
1385: struct file **fpp;
1386: {
1387: struct file *fp;
1388: int error;
1389:
1390: if (error = fdgetf(p, fdes, &fp))
1391: return (error);
1392: if (fp->f_type != DTYPE_SOCKET)
1393: return (ENOTSOCK);
1394: *fpp = fp;
1395: return (0);
1396: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.