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