2 * 32bit Socket syscall emulation. Based on arch/sparc64/kernel/sys_sparc32.c.
4 * Copyright (C) 2000 VA Linux Co
5 * Copyright (C) 2000 Don Dugger <n0ano@valinux.com>
6 * Copyright (C) 1999 Arun Sharma <arun.sharma@intel.com>
7 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
8 * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu)
9 * Copyright (C) 2000 Hewlett-Packard Co.
10 * Copyright (C) 2000 David Mosberger-Tang <davidm@hpl.hp.com>
11 * Copyright (C) 2000,2001 Andi Kleen, SuSE Labs
14 #include <linux/kernel.h>
16 #include <linux/sched.h>
17 #include <linux/types.h>
18 #include <linux/file.h>
19 #include <linux/icmpv6.h>
20 #include <linux/socket.h>
21 #include <linux/syscalls.h>
22 #include <linux/filter.h>
23 #include <linux/compat.h>
24 #include <linux/netfilter_ipv4/ip_tables.h>
25 #include <linux/security.h>
29 #include <asm/uaccess.h>
30 #include <net/compat.h>
32 static inline int iov_from_user_compat_to_kern(struct iovec
*kiov
,
33 struct compat_iovec __user
*uiov32
,
42 if(get_user(len
, &uiov32
->iov_len
) ||
43 get_user(buf
, &uiov32
->iov_base
)) {
48 kiov
->iov_base
= compat_ptr(buf
);
49 kiov
->iov_len
= (__kernel_size_t
) len
;
57 int get_compat_msghdr(struct msghdr
*kmsg
, struct compat_msghdr __user
*umsg
)
59 compat_uptr_t tmp1
, tmp2
, tmp3
;
61 if (!access_ok(VERIFY_READ
, umsg
, sizeof(*umsg
)) ||
62 __get_user(tmp1
, &umsg
->msg_name
) ||
63 __get_user(kmsg
->msg_namelen
, &umsg
->msg_namelen
) ||
64 __get_user(tmp2
, &umsg
->msg_iov
) ||
65 __get_user(kmsg
->msg_iovlen
, &umsg
->msg_iovlen
) ||
66 __get_user(tmp3
, &umsg
->msg_control
) ||
67 __get_user(kmsg
->msg_controllen
, &umsg
->msg_controllen
) ||
68 __get_user(kmsg
->msg_flags
, &umsg
->msg_flags
))
70 kmsg
->msg_name
= compat_ptr(tmp1
);
71 kmsg
->msg_iov
= compat_ptr(tmp2
);
72 kmsg
->msg_control
= compat_ptr(tmp3
);
76 /* I've named the args so it is easy to tell whose space the pointers are in. */
77 int verify_compat_iovec(struct msghdr
*kern_msg
, struct iovec
*kern_iov
,
78 char *kern_address
, int mode
)
82 if(kern_msg
->msg_namelen
) {
83 if(mode
==VERIFY_READ
) {
84 int err
= move_addr_to_kernel(kern_msg
->msg_name
,
85 kern_msg
->msg_namelen
,
90 kern_msg
->msg_name
= kern_address
;
92 kern_msg
->msg_name
= NULL
;
94 tot_len
= iov_from_user_compat_to_kern(kern_iov
,
95 (struct compat_iovec __user
*)kern_msg
->msg_iov
,
96 kern_msg
->msg_iovlen
);
98 kern_msg
->msg_iov
= kern_iov
;
104 #define CMSG_COMPAT_ALIGN(len) ALIGN((len), sizeof(s32))
106 #define CMSG_COMPAT_DATA(cmsg) \
107 ((void __user *)((char __user *)(cmsg) + CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr))))
108 #define CMSG_COMPAT_SPACE(len) \
109 (CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr)) + CMSG_COMPAT_ALIGN(len))
110 #define CMSG_COMPAT_LEN(len) \
111 (CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr)) + (len))
113 #define CMSG_COMPAT_FIRSTHDR(msg) \
114 (((msg)->msg_controllen) >= sizeof(struct compat_cmsghdr) ? \
115 (struct compat_cmsghdr __user *)((msg)->msg_control) : \
116 (struct compat_cmsghdr __user *)NULL)
118 #define CMSG_COMPAT_OK(ucmlen, ucmsg, mhdr) \
119 ((ucmlen) >= sizeof(struct compat_cmsghdr) && \
120 (ucmlen) <= (unsigned long) \
121 ((mhdr)->msg_controllen - \
122 ((char *)(ucmsg) - (char *)(mhdr)->msg_control)))
124 static inline struct compat_cmsghdr __user
*cmsg_compat_nxthdr(struct msghdr
*msg
,
125 struct compat_cmsghdr __user
*cmsg
, int cmsg_len
)
127 char __user
*ptr
= (char __user
*)cmsg
+ CMSG_COMPAT_ALIGN(cmsg_len
);
128 if ((unsigned long)(ptr
+ 1 - (char __user
*)msg
->msg_control
) >
131 return (struct compat_cmsghdr __user
*)ptr
;
134 /* There is a lot of hair here because the alignment rules (and
135 * thus placement) of cmsg headers and length are different for
136 * 32-bit apps. -DaveM
138 int cmsghdr_from_user_compat_to_kern(struct msghdr
*kmsg
,
139 unsigned char *stackbuf
, int stackbuf_size
)
141 struct compat_cmsghdr __user
*ucmsg
;
142 struct cmsghdr
*kcmsg
, *kcmsg_base
;
143 compat_size_t ucmlen
;
144 __kernel_size_t kcmlen
, tmp
;
147 kcmsg_base
= kcmsg
= (struct cmsghdr
*)stackbuf
;
148 ucmsg
= CMSG_COMPAT_FIRSTHDR(kmsg
);
149 while(ucmsg
!= NULL
) {
150 if(get_user(ucmlen
, &ucmsg
->cmsg_len
))
154 if (!CMSG_COMPAT_OK(ucmlen
, ucmsg
, kmsg
))
157 tmp
= ((ucmlen
- CMSG_COMPAT_ALIGN(sizeof(*ucmsg
))) +
158 CMSG_ALIGN(sizeof(struct cmsghdr
)));
160 ucmsg
= cmsg_compat_nxthdr(kmsg
, ucmsg
, ucmlen
);
165 /* The kcmlen holds the 64-bit version of the control length.
166 * It may not be modified as we do not stick it into the kmsg
167 * until we have successfully copied over all of the data
170 if(kcmlen
> stackbuf_size
)
171 kcmsg_base
= kcmsg
= kmalloc(kcmlen
, GFP_KERNEL
);
175 /* Now copy them over neatly. */
176 memset(kcmsg
, 0, kcmlen
);
177 ucmsg
= CMSG_COMPAT_FIRSTHDR(kmsg
);
178 while(ucmsg
!= NULL
) {
179 __get_user(ucmlen
, &ucmsg
->cmsg_len
);
180 tmp
= ((ucmlen
- CMSG_COMPAT_ALIGN(sizeof(*ucmsg
))) +
181 CMSG_ALIGN(sizeof(struct cmsghdr
)));
182 kcmsg
->cmsg_len
= tmp
;
183 __get_user(kcmsg
->cmsg_level
, &ucmsg
->cmsg_level
);
184 __get_user(kcmsg
->cmsg_type
, &ucmsg
->cmsg_type
);
186 /* Copy over the data. */
187 if(copy_from_user(CMSG_DATA(kcmsg
),
188 CMSG_COMPAT_DATA(ucmsg
),
189 (ucmlen
- CMSG_COMPAT_ALIGN(sizeof(*ucmsg
)))))
190 goto out_free_efault
;
193 kcmsg
= (struct cmsghdr
*)((char *)kcmsg
+ CMSG_ALIGN(tmp
));
194 ucmsg
= cmsg_compat_nxthdr(kmsg
, ucmsg
, ucmlen
);
197 /* Ok, looks like we made it. Hook it up and return success. */
198 kmsg
->msg_control
= kcmsg_base
;
199 kmsg
->msg_controllen
= kcmlen
;
203 if(kcmsg_base
!= (struct cmsghdr
*)stackbuf
)
208 int put_cmsg_compat(struct msghdr
*kmsg
, int level
, int type
, int len
, void *data
)
210 struct compat_timeval ctv
;
211 struct compat_cmsghdr __user
*cm
= (struct compat_cmsghdr __user
*) kmsg
->msg_control
;
212 struct compat_cmsghdr cmhdr
;
215 if(cm
== NULL
|| kmsg
->msg_controllen
< sizeof(*cm
)) {
216 kmsg
->msg_flags
|= MSG_CTRUNC
;
217 return 0; /* XXX: return error? check spec. */
220 if (level
== SOL_SOCKET
&& type
== SO_TIMESTAMP
) {
221 struct timeval
*tv
= (struct timeval
*)data
;
222 ctv
.tv_sec
= tv
->tv_sec
;
223 ctv
.tv_usec
= tv
->tv_usec
;
225 len
= sizeof(struct compat_timeval
);
228 cmlen
= CMSG_COMPAT_LEN(len
);
229 if(kmsg
->msg_controllen
< cmlen
) {
230 kmsg
->msg_flags
|= MSG_CTRUNC
;
231 cmlen
= kmsg
->msg_controllen
;
233 cmhdr
.cmsg_level
= level
;
234 cmhdr
.cmsg_type
= type
;
235 cmhdr
.cmsg_len
= cmlen
;
237 if(copy_to_user(cm
, &cmhdr
, sizeof cmhdr
))
239 if(copy_to_user(CMSG_COMPAT_DATA(cm
), data
, cmlen
- sizeof(struct compat_cmsghdr
)))
241 cmlen
= CMSG_COMPAT_SPACE(len
);
242 kmsg
->msg_control
+= cmlen
;
243 kmsg
->msg_controllen
-= cmlen
;
247 void scm_detach_fds_compat(struct msghdr
*kmsg
, struct scm_cookie
*scm
)
249 struct compat_cmsghdr __user
*cm
= (struct compat_cmsghdr __user
*) kmsg
->msg_control
;
250 int fdmax
= (kmsg
->msg_controllen
- sizeof(struct compat_cmsghdr
)) / sizeof(int);
251 int fdnum
= scm
->fp
->count
;
252 struct file
**fp
= scm
->fp
->fp
;
259 for (i
= 0, cmfptr
= (int __user
*) CMSG_COMPAT_DATA(cm
); i
< fdmax
; i
++, cmfptr
++) {
261 err
= security_file_receive(fp
[i
]);
264 err
= get_unused_fd();
268 err
= put_user(new_fd
, cmfptr
);
270 put_unused_fd(new_fd
);
273 /* Bump the usage count and install the file. */
275 fd_install(new_fd
, fp
[i
]);
279 int cmlen
= CMSG_COMPAT_LEN(i
* sizeof(int));
281 err
= put_user(SOL_SOCKET
, &cm
->cmsg_level
);
283 err
= put_user(SCM_RIGHTS
, &cm
->cmsg_type
);
285 err
= put_user(cmlen
, &cm
->cmsg_len
);
287 cmlen
= CMSG_COMPAT_SPACE(i
* sizeof(int));
288 kmsg
->msg_control
+= cmlen
;
289 kmsg
->msg_controllen
-= cmlen
;
293 kmsg
->msg_flags
|= MSG_CTRUNC
;
296 * All of the files that fit in the message have had their
297 * usage counts incremented, so we just free the list.
303 * For now, we assume that the compatibility and native version
304 * of struct ipt_entry are the same - sfr. FIXME
306 struct compat_ipt_replace
{
307 char name
[IPT_TABLE_MAXNAMELEN
];
311 u32 hook_entry
[NF_IP_NUMHOOKS
];
312 u32 underflow
[NF_IP_NUMHOOKS
];
314 compat_uptr_t counters
; /* struct ipt_counters * */
315 struct ipt_entry entries
[0];
318 static int do_netfilter_replace(int fd
, int level
, int optname
,
319 char __user
*optval
, int optlen
)
321 struct compat_ipt_replace __user
*urepl
;
322 struct ipt_replace __user
*repl_nat
;
323 char name
[IPT_TABLE_MAXNAMELEN
];
324 u32 origsize
, tmp32
, num_counters
;
325 unsigned int repl_nat_size
;
328 compat_uptr_t ucntrs
;
330 urepl
= (struct compat_ipt_replace __user
*)optval
;
331 if (get_user(origsize
, &urepl
->size
))
334 /* Hack: Causes ipchains to give correct error msg --RR */
335 if (optlen
!= sizeof(*urepl
) + origsize
)
338 /* XXX Assumes that size of ipt_entry is the same both in
339 * native and compat environments.
341 repl_nat_size
= sizeof(*repl_nat
) + origsize
;
342 repl_nat
= compat_alloc_user_space(repl_nat_size
);
345 if (put_user(origsize
, &repl_nat
->size
))
348 if (!access_ok(VERIFY_READ
, urepl
, optlen
) ||
349 !access_ok(VERIFY_WRITE
, repl_nat
, optlen
))
352 if (__copy_from_user(name
, urepl
->name
, sizeof(urepl
->name
)) ||
353 __copy_to_user(repl_nat
->name
, name
, sizeof(repl_nat
->name
)))
356 if (__get_user(tmp32
, &urepl
->valid_hooks
) ||
357 __put_user(tmp32
, &repl_nat
->valid_hooks
))
360 if (__get_user(tmp32
, &urepl
->num_entries
) ||
361 __put_user(tmp32
, &repl_nat
->num_entries
))
364 if (__get_user(num_counters
, &urepl
->num_counters
) ||
365 __put_user(num_counters
, &repl_nat
->num_counters
))
368 if (__get_user(ucntrs
, &urepl
->counters
) ||
369 __put_user(compat_ptr(ucntrs
), &repl_nat
->counters
))
372 if (__copy_in_user(&repl_nat
->entries
[0],
377 for (i
= 0; i
< NF_IP_NUMHOOKS
; i
++) {
378 if (__get_user(tmp32
, &urepl
->hook_entry
[i
]) ||
379 __put_user(tmp32
, &repl_nat
->hook_entry
[i
]) ||
380 __get_user(tmp32
, &urepl
->underflow
[i
]) ||
381 __put_user(tmp32
, &repl_nat
->underflow
[i
]))
386 * Since struct ipt_counters just contains two u_int64_t members
387 * we can just do the access_ok check here and pass the (converted)
388 * pointer into the standard syscall. We hope that the pointer is
391 if (!access_ok(VERIFY_WRITE
, compat_ptr(ucntrs
),
392 num_counters
* sizeof(struct ipt_counters
)))
396 ret
= sys_setsockopt(fd
, level
, optname
,
397 (char __user
*)repl_nat
, repl_nat_size
);
404 * A struct sock_filter is architecture independent.
406 struct compat_sock_fprog
{
408 compat_uptr_t filter
; /* struct sock_filter * */
411 static int do_set_attach_filter(int fd
, int level
, int optname
,
412 char __user
*optval
, int optlen
)
414 struct compat_sock_fprog __user
*fprog32
= (struct compat_sock_fprog __user
*)optval
;
415 struct sock_fprog __user
*kfprog
= compat_alloc_user_space(sizeof(struct sock_fprog
));
419 if (!access_ok(VERIFY_READ
, fprog32
, sizeof(*fprog32
)) ||
420 !access_ok(VERIFY_WRITE
, kfprog
, sizeof(struct sock_fprog
)) ||
421 __get_user(len
, &fprog32
->len
) ||
422 __get_user(ptr
, &fprog32
->filter
) ||
423 __put_user(len
, &kfprog
->len
) ||
424 __put_user(compat_ptr(ptr
), &kfprog
->filter
))
427 return sys_setsockopt(fd
, level
, optname
, (char __user
*)kfprog
,
428 sizeof(struct sock_fprog
));
431 static int do_set_sock_timeout(int fd
, int level
, int optname
, char __user
*optval
, int optlen
)
433 struct compat_timeval __user
*up
= (struct compat_timeval __user
*) optval
;
434 struct timeval ktime
;
438 if (optlen
< sizeof(*up
))
440 if (!access_ok(VERIFY_READ
, up
, sizeof(*up
)) ||
441 __get_user(ktime
.tv_sec
, &up
->tv_sec
) ||
442 __get_user(ktime
.tv_usec
, &up
->tv_usec
))
446 err
= sys_setsockopt(fd
, level
, optname
, (char *) &ktime
, sizeof(ktime
));
452 asmlinkage
long compat_sys_setsockopt(int fd
, int level
, int optname
,
453 char __user
*optval
, int optlen
)
455 /* SO_SET_REPLACE seems to be the same in all levels */
456 if (optname
== IPT_SO_SET_REPLACE
)
457 return do_netfilter_replace(fd
, level
, optname
,
459 if (level
== SOL_SOCKET
&& optname
== SO_ATTACH_FILTER
)
460 return do_set_attach_filter(fd
, level
, optname
,
462 if (level
== SOL_SOCKET
&&
463 (optname
== SO_RCVTIMEO
|| optname
== SO_SNDTIMEO
))
464 return do_set_sock_timeout(fd
, level
, optname
, optval
, optlen
);
466 return sys_setsockopt(fd
, level
, optname
, optval
, optlen
);
469 static int do_get_sock_timeout(int fd
, int level
, int optname
,
470 char __user
*optval
, int __user
*optlen
)
472 struct compat_timeval __user
*up
;
473 struct timeval ktime
;
477 up
= (struct compat_timeval __user
*) optval
;
478 if (get_user(len
, optlen
))
480 if (len
< sizeof(*up
))
485 err
= sys_getsockopt(fd
, level
, optname
, (char *) &ktime
, &len
);
489 if (put_user(sizeof(*up
), optlen
) ||
490 !access_ok(VERIFY_WRITE
, up
, sizeof(*up
)) ||
491 __put_user(ktime
.tv_sec
, &up
->tv_sec
) ||
492 __put_user(ktime
.tv_usec
, &up
->tv_usec
))
498 asmlinkage
long compat_sys_getsockopt(int fd
, int level
, int optname
,
499 char __user
*optval
, int __user
*optlen
)
501 if (level
== SOL_SOCKET
&&
502 (optname
== SO_RCVTIMEO
|| optname
== SO_SNDTIMEO
))
503 return do_get_sock_timeout(fd
, level
, optname
, optval
, optlen
);
504 return sys_getsockopt(fd
, level
, optname
, optval
, optlen
);
507 /* Argument list sizes for compat_sys_socketcall */
508 #define AL(x) ((x) * sizeof(u32))
509 static unsigned char nas
[18]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
510 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
511 AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)};
514 asmlinkage
long compat_sys_sendmsg(int fd
, struct compat_msghdr __user
*msg
, unsigned flags
)
516 return sys_sendmsg(fd
, (struct msghdr __user
*)msg
, flags
| MSG_CMSG_COMPAT
);
519 asmlinkage
long compat_sys_recvmsg(int fd
, struct compat_msghdr __user
*msg
, unsigned int flags
)
521 return sys_recvmsg(fd
, (struct msghdr __user
*)msg
, flags
| MSG_CMSG_COMPAT
);
524 asmlinkage
long compat_sys_socketcall(int call
, u32 __user
*args
)
530 if (call
< SYS_SOCKET
|| call
> SYS_RECVMSG
)
532 if (copy_from_user(a
, args
, nas
[call
]))
539 ret
= sys_socket(a0
, a1
, a
[2]);
542 ret
= sys_bind(a0
, compat_ptr(a1
), a
[2]);
545 ret
= sys_connect(a0
, compat_ptr(a1
), a
[2]);
548 ret
= sys_listen(a0
, a1
);
551 ret
= sys_accept(a0
, compat_ptr(a1
), compat_ptr(a
[2]));
553 case SYS_GETSOCKNAME
:
554 ret
= sys_getsockname(a0
, compat_ptr(a1
), compat_ptr(a
[2]));
556 case SYS_GETPEERNAME
:
557 ret
= sys_getpeername(a0
, compat_ptr(a1
), compat_ptr(a
[2]));
560 ret
= sys_socketpair(a0
, a1
, a
[2], compat_ptr(a
[3]));
563 ret
= sys_send(a0
, compat_ptr(a1
), a
[2], a
[3]);
566 ret
= sys_sendto(a0
, compat_ptr(a1
), a
[2], a
[3], compat_ptr(a
[4]), a
[5]);
569 ret
= sys_recv(a0
, compat_ptr(a1
), a
[2], a
[3]);
572 ret
= sys_recvfrom(a0
, compat_ptr(a1
), a
[2], a
[3], compat_ptr(a
[4]), compat_ptr(a
[5]));
575 ret
= sys_shutdown(a0
,a1
);
578 ret
= compat_sys_setsockopt(a0
, a1
, a
[2],
579 compat_ptr(a
[3]), a
[4]);
582 ret
= compat_sys_getsockopt(a0
, a1
, a
[2],
583 compat_ptr(a
[3]), compat_ptr(a
[4]));
586 ret
= compat_sys_sendmsg(a0
, compat_ptr(a1
), a
[2]);
589 ret
= compat_sys_recvmsg(a0
, compat_ptr(a1
), a
[2]);