Annotation of sys/compat/common/uipc_syscalls_43.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: uipc_syscalls_43.c,v 1.7 2003/06/02 23:27:59 millert Exp $ */
2: /* $NetBSD: uipc_syscalls_43.c,v 1.5 1996/03/14 19:31:50 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/kernel.h>
39: #include <sys/proc.h>
40: #include <sys/file.h>
41: #include <sys/socket.h>
42: #include <sys/socketvar.h>
43: #include <sys/stat.h>
44: #include <sys/ioctl.h>
45: #include <sys/fcntl.h>
46: #include <sys/malloc.h>
47: #include <sys/syslog.h>
48: #include <sys/unistd.h>
49: #include <sys/resourcevar.h>
50:
51: #include <sys/mount.h>
52: #include <sys/syscallargs.h>
53:
54: int
55: compat_43_sys_accept(p, v, retval)
56: struct proc *p;
57: void *v;
58: register_t *retval;
59: {
60: struct sys_accept_args /* {
61: syscallarg(int) s;
62: syscallarg(caddr_t) name;
63: syscallarg(int *) anamelen;
64: } */ *uap = v;
65: int error;
66:
67: if ((error = sys_accept(p, uap, retval)) != 0)
68: return error;
69:
70: if (SCARG(uap, name)) {
71: struct sockaddr sa;
72:
73: if ((error = copyin(SCARG(uap, name), &sa, sizeof(sa))) != 0)
74: return error;
75:
76: ((struct osockaddr*) &sa)->sa_family = sa.sa_family;
77:
78: if ((error = copyout(&sa, SCARG(uap, name), sizeof(sa))) != 0)
79: return error;
80: }
81: return 0;
82: }
83:
84:
85: int
86: compat_43_sys_getpeername(p, v, retval)
87: struct proc *p;
88: void *v;
89: register_t *retval;
90: {
91: struct sys_getpeername_args /* {
92: syscallarg(int) fdes;
93: syscallarg(caddr_t) asa;
94: syscallarg(int *) alen;
95: } */ *uap = v;
96: struct sockaddr sa;
97:
98: int error;
99:
100: if ((error = sys_getpeername(p, uap, retval)) != 0)
101: return error;
102:
103: if ((error = copyin(SCARG(uap, asa), &sa, sizeof(sa))) != 0)
104: return error;
105:
106: ((struct osockaddr*) &sa)->sa_family = sa.sa_family;
107:
108: if ((error = copyout(&sa, SCARG(uap, asa), sizeof(sa))) != 0)
109: return error;
110:
111: return 0;
112: }
113:
114:
115: int
116: compat_43_sys_getsockname(p, v, retval)
117: struct proc *p;
118: void *v;
119: register_t *retval;
120: {
121: struct sys_getsockname_args /* {
122: syscallarg(int) fdes;
123: syscallarg(caddr_t) asa;
124: syscallarg(int *) alen;
125: } */ *uap = v;
126: struct sockaddr sa;
127: int error;
128:
129: if ((error = sys_getsockname(p, uap, retval)) != 0)
130: return error;
131:
132: if ((error = copyin(SCARG(uap, asa), &sa, sizeof(sa))) != 0)
133: return error;
134:
135: ((struct osockaddr*) &sa)->sa_family = sa.sa_family;
136:
137: if ((error = copyout(&sa, SCARG(uap, asa), sizeof(sa))) != 0)
138: return error;
139:
140: return 0;
141: }
142:
143:
144: int
145: compat_43_sys_recv(p, v, retval)
146: struct proc *p;
147: void *v;
148: register_t *retval;
149: {
150: register struct compat_43_sys_recv_args /* {
151: syscallarg(int) s;
152: syscallarg(caddr_t) buf;
153: syscallarg(int) len;
154: syscallarg(int) flags;
155: } */ *uap = v;
156: struct msghdr msg;
157: struct iovec aiov;
158:
159: msg.msg_name = 0;
160: msg.msg_namelen = 0;
161: msg.msg_iov = &aiov;
162: msg.msg_iovlen = 1;
163: aiov.iov_base = SCARG(uap, buf);
164: aiov.iov_len = SCARG(uap, len);
165: msg.msg_control = 0;
166: msg.msg_flags = SCARG(uap, flags);
167: return (recvit(p, SCARG(uap, s), &msg, (caddr_t)0, retval));
168: }
169:
170:
171: #ifdef MSG_COMPAT
172: int
173: compat_43_sys_recvfrom(p, v, retval)
174: struct proc *p;
175: void *v;
176: register_t *retval;
177: {
178: struct sys_recvfrom_args /* {
179: syscallarg(int) s;
180: syscallarg(caddr_t) buf;
181: syscallarg(size_t) len;
182: syscallarg(int) flags;
183: syscallarg(caddr_t) from;
184: syscallarg(int *) fromlenaddr;
185: } */ *uap = v;
186:
187: SCARG(uap, flags) |= MSG_COMPAT;
188: return (sys_recvfrom(p, uap, retval));
189: }
190: #endif
191:
192:
193: #ifdef MSG_COMPAT
194: /*
195: * Old recvmsg. This code takes advantage of the fact that the old msghdr
196: * overlays the new one, missing only the flags, and with the (old) access
197: * rights where the control fields are now.
198: */
199: int
200: compat_43_sys_recvmsg(p, v, retval)
201: struct proc *p;
202: void *v;
203: register_t *retval;
204: {
205: register struct compat_43_sys_recvmsg_args /* {
206: syscallarg(int) s;
207: syscallarg(struct omsghdr *) msg;
208: syscallarg(int) flags;
209: } */ *uap = v;
210: struct msghdr msg;
211: struct iovec aiov[UIO_SMALLIOV], *iov;
212: int error;
213:
214: error = copyin((caddr_t)SCARG(uap, msg), (caddr_t)&msg,
215: sizeof (struct omsghdr));
216: if (error)
217: return (error);
218: if (msg.msg_iovlen <= 0 || msg.msg_iovlen > IOV_MAX)
219: return (EMSGSIZE);
220: if (msg.msg_iovlen > UIO_SMALLIOV)
221: MALLOC(iov, struct iovec *,
222: sizeof(struct iovec) * msg.msg_iovlen, M_IOV, M_WAITOK);
223: else
224: iov = aiov;
225: msg.msg_flags = SCARG(uap, flags) | MSG_COMPAT;
226: error = copyin((caddr_t)msg.msg_iov, (caddr_t)iov,
227: (unsigned)(msg.msg_iovlen * sizeof (struct iovec)));
228: if (error)
229: goto done;
230: msg.msg_iov = iov;
231: error = recvit(p, SCARG(uap, s), &msg,
232: (caddr_t)&SCARG(uap, msg)->msg_namelen, retval);
233:
234: if (msg.msg_controllen && error == 0)
235: error = copyout((caddr_t)&msg.msg_controllen,
236: (caddr_t)&SCARG(uap, msg)->msg_accrightslen, sizeof (int));
237: done:
238: if (iov != aiov)
239: FREE(iov, M_IOV);
240: return (error);
241: }
242: #endif
243:
244: int
245: compat_43_sys_send(p, v, retval)
246: struct proc *p;
247: void *v;
248: register_t *retval;
249: {
250: register struct compat_43_sys_send_args /* {
251: syscallarg(int) s;
252: syscallarg(caddr_t) buf;
253: syscallarg(int) len;
254: syscallarg(int) flags;
255: } */ *uap = v;
256: struct msghdr msg;
257: struct iovec aiov;
258:
259: msg.msg_name = 0;
260: msg.msg_namelen = 0;
261: msg.msg_iov = &aiov;
262: msg.msg_iovlen = 1;
263: aiov.iov_base = SCARG(uap, buf);
264: aiov.iov_len = SCARG(uap, len);
265: msg.msg_control = 0;
266: msg.msg_flags = 0;
267: return (sendit(p, SCARG(uap, s), &msg, SCARG(uap, flags), retval));
268: }
269:
270: #ifdef MSG_COMPAT
271: int
272: compat_43_sys_sendmsg(p, v, retval)
273: struct proc *p;
274: void *v;
275: register_t *retval;
276: {
277: register struct compat_43_sys_sendmsg_args /* {
278: syscallarg(int) s;
279: syscallarg(caddr_t) msg;
280: syscallarg(int) flags;
281: } */ *uap = v;
282: struct msghdr msg;
283: struct iovec aiov[UIO_SMALLIOV], *iov;
284: int error;
285:
286: error = copyin(SCARG(uap, msg), (caddr_t)&msg,
287: sizeof (struct omsghdr));
288: if (error)
289: return (error);
290: if (msg.msg_iovlen <= 0 || msg.msg_iovlen > IOV_MAX)
291: return (EMSGSIZE);
292: if (msg.msg_iovlen > UIO_SMALLIOV)
293: MALLOC(iov, struct iovec *,
294: sizeof(struct iovec) * msg.msg_iovlen, M_IOV, M_WAITOK);
295: else
296: iov = aiov;
297: error = copyin((caddr_t)msg.msg_iov, (caddr_t)iov,
298: (unsigned)(msg.msg_iovlen * sizeof (struct iovec)));
299: if (error)
300: goto done;
301: msg.msg_flags = MSG_COMPAT;
302: msg.msg_iov = iov;
303: error = sendit(p, SCARG(uap, s), &msg, SCARG(uap, flags), retval);
304: done:
305: if (iov != aiov)
306: FREE(iov, M_IOV);
307: return (error);
308: }
309: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to uipc_syscalls_43.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / common