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/filter.h>
22 #include <linux/compat.h>
23 #include <linux/netfilter_ipv4/ip_tables.h>
27 #include <asm/uaccess.h>
28 #include <net/compat.h>
30 static inline int iov_from_user_compat_to_kern(struct iovec
*kiov
,
31 struct compat_iovec
*uiov32
,
40 if(get_user(len
, &uiov32
->iov_len
) ||
41 get_user(buf
, &uiov32
->iov_base
)) {
46 kiov
->iov_base
= compat_ptr(buf
);
47 kiov
->iov_len
= (__kernel_size_t
) len
;
55 int get_compat_msghdr(struct msghdr
*kmsg
, struct compat_msghdr
*umsg
)
57 compat_uptr_t tmp1
, tmp2
, tmp3
;
59 if (!access_ok(VERIFY_READ
, umsg
, sizeof(*umsg
)) ||
60 __get_user(tmp1
, &umsg
->msg_name
) ||
61 __get_user(kmsg
->msg_namelen
, &umsg
->msg_namelen
) ||
62 __get_user(tmp2
, &umsg
->msg_iov
) ||
63 __get_user(kmsg
->msg_iovlen
, &umsg
->msg_iovlen
) ||
64 __get_user(tmp3
, &umsg
->msg_control
) ||
65 __get_user(kmsg
->msg_controllen
, &umsg
->msg_controllen
) ||
66 __get_user(kmsg
->msg_flags
, &umsg
->msg_flags
))
68 kmsg
->msg_name
= compat_ptr(tmp1
);
69 kmsg
->msg_iov
= compat_ptr(tmp2
);
70 kmsg
->msg_control
= compat_ptr(tmp3
);
74 /* I've named the args so it is easy to tell whose space the pointers are in. */
75 int verify_compat_iovec(struct msghdr
*kern_msg
, struct iovec
*kern_iov
,
76 char *kern_address
, int mode
)
80 if(kern_msg
->msg_namelen
) {
81 if(mode
==VERIFY_READ
) {
82 int err
= move_addr_to_kernel(kern_msg
->msg_name
,
83 kern_msg
->msg_namelen
,
88 kern_msg
->msg_name
= kern_address
;
90 kern_msg
->msg_name
= NULL
;
92 if(kern_msg
->msg_iovlen
> UIO_FASTIOV
) {
93 kern_iov
= kmalloc(kern_msg
->msg_iovlen
* sizeof(struct iovec
),
99 tot_len
= iov_from_user_compat_to_kern(kern_iov
,
100 (struct compat_iovec
*)kern_msg
->msg_iov
,
101 kern_msg
->msg_iovlen
);
103 kern_msg
->msg_iov
= kern_iov
;
104 else if(kern_msg
->msg_iovlen
> UIO_FASTIOV
)
111 #define CMSG_COMPAT_ALIGN(len) ALIGN((len), sizeof(s32))
113 #define CMSG_COMPAT_DATA(cmsg) \
114 ((void *)((char *)(cmsg) + CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr))))
115 #define CMSG_COMPAT_SPACE(len) \
116 (CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr)) + CMSG_COMPAT_ALIGN(len))
117 #define CMSG_COMPAT_LEN(len) \
118 (CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr)) + (len))
120 #define CMSG_COMPAT_FIRSTHDR(msg) \
121 (((msg)->msg_controllen) >= sizeof(struct compat_cmsghdr) ? \
122 (struct compat_cmsghdr *)((msg)->msg_control) : \
123 (struct compat_cmsghdr *)NULL)
125 static inline struct compat_cmsghdr
*cmsg_compat_nxthdr(struct msghdr
*msg
,
126 struct compat_cmsghdr
*cmsg
, int cmsg_len
)
128 struct compat_cmsghdr
*ptr
;
130 ptr
= (struct compat_cmsghdr
*)(((unsigned char *)cmsg
) +
131 CMSG_COMPAT_ALIGN(cmsg_len
));
132 if ((unsigned long)((char *)(ptr
+ 1) - (char *)msg
->msg_control
) >
138 /* There is a lot of hair here because the alignment rules (and
139 * thus placement) of cmsg headers and length are different for
140 * 32-bit apps. -DaveM
142 int cmsghdr_from_user_compat_to_kern(struct msghdr
*kmsg
,
143 unsigned char *stackbuf
, int stackbuf_size
)
145 struct compat_cmsghdr
*ucmsg
;
146 struct cmsghdr
*kcmsg
, *kcmsg_base
;
147 compat_size_t ucmlen
;
148 __kernel_size_t kcmlen
, tmp
;
151 kcmsg_base
= kcmsg
= (struct cmsghdr
*)stackbuf
;
152 ucmsg
= CMSG_COMPAT_FIRSTHDR(kmsg
);
153 while(ucmsg
!= NULL
) {
154 if(get_user(ucmlen
, &ucmsg
->cmsg_len
))
158 if(CMSG_COMPAT_ALIGN(ucmlen
) <
159 CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr
)))
161 if((unsigned long)(((char *)ucmsg
- (char *)kmsg
->msg_control
)
162 + ucmlen
) > kmsg
->msg_controllen
)
165 tmp
= ((ucmlen
- CMSG_COMPAT_ALIGN(sizeof(*ucmsg
))) +
166 CMSG_ALIGN(sizeof(struct cmsghdr
)));
168 ucmsg
= cmsg_compat_nxthdr(kmsg
, ucmsg
, ucmlen
);
173 /* The kcmlen holds the 64-bit version of the control length.
174 * It may not be modified as we do not stick it into the kmsg
175 * until we have successfully copied over all of the data
178 if(kcmlen
> stackbuf_size
)
179 kcmsg_base
= kcmsg
= kmalloc(kcmlen
, GFP_KERNEL
);
183 /* Now copy them over neatly. */
184 memset(kcmsg
, 0, kcmlen
);
185 ucmsg
= CMSG_COMPAT_FIRSTHDR(kmsg
);
186 while(ucmsg
!= NULL
) {
187 __get_user(ucmlen
, &ucmsg
->cmsg_len
);
188 tmp
= ((ucmlen
- CMSG_COMPAT_ALIGN(sizeof(*ucmsg
))) +
189 CMSG_ALIGN(sizeof(struct cmsghdr
)));
190 kcmsg
->cmsg_len
= tmp
;
191 __get_user(kcmsg
->cmsg_level
, &ucmsg
->cmsg_level
);
192 __get_user(kcmsg
->cmsg_type
, &ucmsg
->cmsg_type
);
194 /* Copy over the data. */
195 if(copy_from_user(CMSG_DATA(kcmsg
),
196 CMSG_COMPAT_DATA(ucmsg
),
197 (ucmlen
- CMSG_COMPAT_ALIGN(sizeof(*ucmsg
)))))
198 goto out_free_efault
;
201 kcmsg
= (struct cmsghdr
*)((char *)kcmsg
+ CMSG_ALIGN(tmp
));
202 ucmsg
= cmsg_compat_nxthdr(kmsg
, ucmsg
, ucmlen
);
205 /* Ok, looks like we made it. Hook it up and return success. */
206 kmsg
->msg_control
= kcmsg_base
;
207 kmsg
->msg_controllen
= kcmlen
;
211 if(kcmsg_base
!= (struct cmsghdr
*)stackbuf
)
216 int put_cmsg_compat(struct msghdr
*kmsg
, int level
, int type
, int len
, void *data
)
218 struct compat_cmsghdr
*cm
= (struct compat_cmsghdr
*) kmsg
->msg_control
;
219 struct compat_cmsghdr cmhdr
;
220 int cmlen
= CMSG_COMPAT_LEN(len
);
222 if(cm
== NULL
|| kmsg
->msg_controllen
< sizeof(*cm
)) {
223 kmsg
->msg_flags
|= MSG_CTRUNC
;
224 return 0; /* XXX: return error? check spec. */
227 if(kmsg
->msg_controllen
< cmlen
) {
228 kmsg
->msg_flags
|= MSG_CTRUNC
;
229 cmlen
= kmsg
->msg_controllen
;
231 cmhdr
.cmsg_level
= level
;
232 cmhdr
.cmsg_type
= type
;
233 cmhdr
.cmsg_len
= cmlen
;
235 if(copy_to_user(cm
, &cmhdr
, sizeof cmhdr
))
237 if(copy_to_user(CMSG_COMPAT_DATA(cm
), data
, cmlen
- sizeof(struct compat_cmsghdr
)))
239 cmlen
= CMSG_COMPAT_SPACE(len
);
240 kmsg
->msg_control
+= cmlen
;
241 kmsg
->msg_controllen
-= cmlen
;
245 void scm_detach_fds_compat(struct msghdr
*kmsg
, struct scm_cookie
*scm
)
247 struct compat_cmsghdr
*cm
= (struct compat_cmsghdr
*) kmsg
->msg_control
;
248 int fdmax
= (kmsg
->msg_controllen
- sizeof(struct compat_cmsghdr
)) / sizeof(int);
249 int fdnum
= scm
->fp
->count
;
250 struct file
**fp
= scm
->fp
->fp
;
257 for (i
= 0, cmfptr
= (int *) CMSG_COMPAT_DATA(cm
); i
< fdmax
; i
++, cmfptr
++) {
259 err
= get_unused_fd();
263 err
= put_user(new_fd
, cmfptr
);
265 put_unused_fd(new_fd
);
268 /* Bump the usage count and install the file. */
270 fd_install(new_fd
, fp
[i
]);
274 int cmlen
= CMSG_COMPAT_LEN(i
* sizeof(int));
276 err
= put_user(SOL_SOCKET
, &cm
->cmsg_level
);
278 err
= put_user(SCM_RIGHTS
, &cm
->cmsg_type
);
280 err
= put_user(cmlen
, &cm
->cmsg_len
);
282 cmlen
= CMSG_COMPAT_SPACE(i
* sizeof(int));
283 kmsg
->msg_control
+= cmlen
;
284 kmsg
->msg_controllen
-= cmlen
;
288 kmsg
->msg_flags
|= MSG_CTRUNC
;
291 * All of the files that fit in the message have had their
292 * usage counts incremented, so we just free the list.
297 extern asmlinkage
long sys_setsockopt(int fd
, int level
, int optname
,
298 char *optval
, int optlen
);
301 * For now, we assume that the compatibility and native version
302 * of struct ipt_entry are the same - sfr. FIXME
304 struct compat_ipt_replace
{
305 char name
[IPT_TABLE_MAXNAMELEN
];
309 u32 hook_entry
[NF_IP_NUMHOOKS
];
310 u32 underflow
[NF_IP_NUMHOOKS
];
312 compat_uptr_t counters
; /* struct ipt_counters * */
313 struct ipt_entry entries
[0];
316 static int do_netfilter_replace(int fd
, int level
, int optname
,
317 char *optval
, int optlen
)
319 struct compat_ipt_replace
*urepl
= (struct compat_ipt_replace
*)optval
;
320 struct ipt_replace
*krepl
;
322 unsigned int kreplsize
;
326 compat_uptr_t ucntrs
;
328 if (get_user(origsize
, &urepl
->size
))
331 /* Hack: Causes ipchains to give correct error msg --RR */
332 if (optlen
!= sizeof(*urepl
) + origsize
)
335 /* XXX Assumes that size of ipt_entry is the same both in
336 * native and compat environments.
338 kreplsize
= sizeof(*krepl
) + origsize
;
339 krepl
= (struct ipt_replace
*)kmalloc(kreplsize
, GFP_KERNEL
);
344 krepl
->size
= origsize
;
345 if (!access_ok(VERIFY_READ
, urepl
, optlen
) ||
346 __copy_from_user(krepl
->name
, urepl
->name
, sizeof(urepl
->name
)) ||
347 __get_user(krepl
->valid_hooks
, &urepl
->valid_hooks
) ||
348 __get_user(krepl
->num_entries
, &urepl
->num_entries
) ||
349 __get_user(krepl
->num_counters
, &urepl
->num_counters
) ||
350 __get_user(ucntrs
, &urepl
->counters
) ||
351 __copy_from_user(krepl
->entries
, &urepl
->entries
, origsize
))
353 for (i
= 0; i
< NF_IP_NUMHOOKS
; i
++) {
354 if (__get_user(krepl
->hook_entry
[i
], &urepl
->hook_entry
[i
]) ||
355 __get_user(krepl
->underflow
[i
], &urepl
->underflow
[i
]))
360 * Since struct ipt_counters just contains two u_int64_t members
361 * we can just do the access_ok check here and pass the (converted)
362 * pointer into the standard syscall. We hope that the pointer is
365 krepl
->counters
= compat_ptr(ucntrs
);
366 if (!access_ok(VERIFY_WRITE
, krepl
->counters
,
367 krepl
->num_counters
* sizeof(struct ipt_counters
)))
372 ret
= sys_setsockopt(fd
, level
, optname
, (char *)krepl
, kreplsize
);
381 * A struct sock_filter is architecture independent.
383 struct compat_sock_fprog
{
385 compat_uptr_t filter
; /* struct sock_filter * */
388 static int do_set_attach_filter(int fd
, int level
, int optname
,
389 char *optval
, int optlen
)
391 struct compat_sock_fprog
*fprog32
= (struct compat_sock_fprog
*)optval
;
392 struct sock_fprog
*kfprog
= compat_alloc_user_space(sizeof(struct sock_fprog
));
396 if (!access_ok(VERIFY_READ
, fprog32
, sizeof(*fprog32
)) ||
397 !access_ok(VERIFY_WRITE
, kfprog
, sizeof(struct sock_fprog
)) ||
398 __get_user(len
, &fprog32
->len
) ||
399 __get_user(ptr
, &fprog32
->filter
) ||
400 __put_user(len
, &kfprog
->len
) ||
401 __put_user(compat_ptr(ptr
), &kfprog
->filter
))
404 return sys_setsockopt(fd
, level
, optname
, (char *)kfprog
,
405 sizeof(struct sock_fprog
));
408 static int do_set_icmpv6_filter(int fd
, int level
, int optname
,
409 char *optval
, int optlen
)
411 struct icmp6_filter kfilter
;
415 if (optlen
< sizeof(kfilter
))
417 if (copy_from_user(&kfilter
, optval
, sizeof(kfilter
)))
420 for (i
= 0; i
< 8; i
+= 2) {
421 u32 tmp
= kfilter
.data
[i
];
423 kfilter
.data
[i
] = kfilter
.data
[i
+ 1];
424 kfilter
.data
[i
+ 1] = tmp
;
429 ret
= sys_setsockopt(fd
, level
, optname
,
430 (char *) &kfilter
, sizeof(kfilter
));
436 static int do_set_sock_timeout(int fd
, int level
, int optname
, char *optval
, int optlen
)
438 struct compat_timeval
*up
= (struct compat_timeval
*) optval
;
439 struct timeval ktime
;
443 if (optlen
< sizeof(*up
))
445 if (!access_ok(VERIFY_READ
, up
, sizeof(*up
)) ||
446 __get_user(ktime
.tv_sec
, &up
->tv_sec
) ||
447 __get_user(ktime
.tv_usec
, &up
->tv_usec
))
451 err
= sys_setsockopt(fd
, level
, optname
, (char *) &ktime
, sizeof(ktime
));
457 asmlinkage
long compat_sys_setsockopt(int fd
, int level
, int optname
,
458 char *optval
, int optlen
)
460 if (optname
== IPT_SO_SET_REPLACE
)
461 return do_netfilter_replace(fd
, level
, optname
,
463 if (optname
== SO_ATTACH_FILTER
)
464 return do_set_attach_filter(fd
, level
, optname
,
466 if (optname
== SO_RCVTIMEO
|| optname
== SO_SNDTIMEO
)
467 return do_set_sock_timeout(fd
, level
, optname
, optval
, optlen
);
468 if (level
== SOL_ICMPV6
&& optname
== ICMPV6_FILTER
)
469 return do_set_icmpv6_filter(fd
, level
, optname
,
472 return sys_setsockopt(fd
, level
, optname
, optval
, optlen
);
475 extern asmlinkage
long sys_getsockopt(int fd
, int level
, int optname
,
476 void * optval
, int *optlen
);
478 static int do_get_sock_timeout(int fd
, int level
, int optname
, char *optval
,
481 struct compat_timeval
*up
= (struct compat_timeval
*) optval
;
482 struct timeval ktime
;
486 if (get_user(len
, optlen
))
488 if (len
< sizeof(*up
))
493 err
= sys_getsockopt(fd
, level
, optname
, (char *) &ktime
, &len
);
497 if (put_user(sizeof(*up
), optlen
) ||
498 !access_ok(VERIFY_WRITE
, up
, sizeof(*up
)) ||
499 __put_user(ktime
.tv_sec
, &up
->tv_sec
) ||
500 __put_user(ktime
.tv_usec
, &up
->tv_usec
))
506 asmlinkage
long compat_sys_getsockopt(int fd
, int level
, int optname
,
507 char *optval
, int *optlen
)
509 if (optname
== SO_RCVTIMEO
|| optname
== SO_SNDTIMEO
)
510 return do_get_sock_timeout(fd
, level
, optname
, optval
, optlen
);
511 return sys_getsockopt(fd
, level
, optname
, optval
, optlen
);
514 /* Argument list sizes for compat_sys_socketcall */
515 #define AL(x) ((x) * sizeof(u32))
516 static unsigned char nas
[18]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
517 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
518 AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)};
521 extern asmlinkage
long sys_bind(int, struct sockaddr
*, int);
522 extern asmlinkage
long sys_connect(int, struct sockaddr
*, int);
523 extern asmlinkage
long sys_accept(int, struct sockaddr
*, int *);
524 extern asmlinkage
long sys_getsockname(int, struct sockaddr
*, int *);
525 extern asmlinkage
long sys_getpeername(int, struct sockaddr
*, int *);
526 extern asmlinkage
long sys_send(int, void *, size_t, unsigned);
527 extern asmlinkage
long sys_sendto(int, void *, size_t, unsigned,
528 struct sockaddr
*, int);
529 extern asmlinkage
long sys_recv(int, void *, size_t, unsigned);
530 extern asmlinkage
long sys_recvfrom(int, void *, size_t, unsigned,
531 struct sockaddr
*, int *);
532 extern asmlinkage
long sys_socket(int, int, int);
533 extern asmlinkage
long sys_socketpair(int, int, int, int [2]);
534 extern asmlinkage
long sys_shutdown(int, int);
535 extern asmlinkage
long sys_listen(int, int);
537 asmlinkage
long compat_sys_sendmsg(int fd
, struct compat_msghdr
*msg
, unsigned flags
)
539 return sys_sendmsg(fd
, (struct msghdr
*)msg
, flags
| MSG_CMSG_COMPAT
);
542 asmlinkage
long compat_sys_recvmsg(int fd
, struct compat_msghdr
*msg
, unsigned int flags
)
544 return sys_recvmsg(fd
, (struct msghdr
*)msg
, flags
| MSG_CMSG_COMPAT
);
547 asmlinkage
long compat_sys_socketcall(int call
, u32
*args
)
553 if (call
< SYS_SOCKET
|| call
> SYS_RECVMSG
)
555 if (copy_from_user(a
, args
, nas
[call
]))
562 ret
= sys_socket(a0
, a1
, a
[2]);
565 ret
= sys_bind(a0
, compat_ptr(a1
), a
[2]);
568 ret
= sys_connect(a0
, compat_ptr(a1
), a
[2]);
571 ret
= sys_listen(a0
, a1
);
574 ret
= sys_accept(a0
, compat_ptr(a1
), compat_ptr(a
[2]));
576 case SYS_GETSOCKNAME
:
577 ret
= sys_getsockname(a0
, compat_ptr(a1
), compat_ptr(a
[2]));
579 case SYS_GETPEERNAME
:
580 ret
= sys_getpeername(a0
, compat_ptr(a1
), compat_ptr(a
[2]));
583 ret
= sys_socketpair(a0
, a1
, a
[2], compat_ptr(a
[3]));
586 ret
= sys_send(a0
, compat_ptr(a1
), a
[2], a
[3]);
589 ret
= sys_sendto(a0
, compat_ptr(a1
), a
[2], a
[3], compat_ptr(a
[4]), a
[5]);
592 ret
= sys_recv(a0
, compat_ptr(a1
), a
[2], a
[3]);
595 ret
= sys_recvfrom(a0
, compat_ptr(a1
), a
[2], a
[3], compat_ptr(a
[4]), compat_ptr(a
[5]));
598 ret
= sys_shutdown(a0
,a1
);
601 ret
= compat_sys_setsockopt(a0
, a1
, a
[2],
602 compat_ptr(a
[3]), a
[4]);
605 ret
= compat_sys_getsockopt(a0
, a1
, a
[2],
606 compat_ptr(a
[3]), compat_ptr(a
[4]));
609 ret
= compat_sys_sendmsg(a0
, compat_ptr(a1
), a
[2]);
612 ret
= compat_sys_recvmsg(a0
, compat_ptr(a1
), a
[2]);