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>
28 #include <asm/uaccess.h>
29 #include <net/compat.h>
31 static inline int iov_from_user_compat_to_kern(struct iovec *kiov,
32 struct compat_iovec *uiov32,
41 if(get_user(len, &uiov32->iov_len) ||
42 get_user(buf, &uiov32->iov_base)) {
47 kiov->iov_base = compat_ptr(buf);
48 kiov->iov_len = (__kernel_size_t) len;
56 int get_compat_msghdr(struct msghdr *kmsg, struct compat_msghdr *umsg)
58 compat_uptr_t tmp1, tmp2, tmp3;
60 if (!access_ok(VERIFY_READ, umsg, sizeof(*umsg)) ||
61 __get_user(tmp1, &umsg->msg_name) ||
62 __get_user(kmsg->msg_namelen, &umsg->msg_namelen) ||
63 __get_user(tmp2, &umsg->msg_iov) ||
64 __get_user(kmsg->msg_iovlen, &umsg->msg_iovlen) ||
65 __get_user(tmp3, &umsg->msg_control) ||
66 __get_user(kmsg->msg_controllen, &umsg->msg_controllen) ||
67 __get_user(kmsg->msg_flags, &umsg->msg_flags))
69 kmsg->msg_name = compat_ptr(tmp1);
70 kmsg->msg_iov = compat_ptr(tmp2);
71 kmsg->msg_control = compat_ptr(tmp3);
75 /* I've named the args so it is easy to tell whose space the pointers are in. */
76 int verify_compat_iovec(struct msghdr *kern_msg, struct iovec *kern_iov,
77 char *kern_address, int mode)
81 if(kern_msg->msg_namelen) {
82 if(mode==VERIFY_READ) {
83 int err = move_addr_to_kernel(kern_msg->msg_name,
84 kern_msg->msg_namelen,
89 kern_msg->msg_name = kern_address;
91 kern_msg->msg_name = NULL;
93 if(kern_msg->msg_iovlen > UIO_FASTIOV) {
94 kern_iov = kmalloc(kern_msg->msg_iovlen * sizeof(struct iovec),
100 tot_len = iov_from_user_compat_to_kern(kern_iov,
101 (struct compat_iovec *)kern_msg->msg_iov,
102 kern_msg->msg_iovlen);
104 kern_msg->msg_iov = kern_iov;
105 else if(kern_msg->msg_iovlen > UIO_FASTIOV)
112 #define CMSG_COMPAT_ALIGN(len) ALIGN((len), sizeof(s32))
114 #define CMSG_COMPAT_DATA(cmsg) \
115 ((void *)((char *)(cmsg) + CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr))))
116 #define CMSG_COMPAT_SPACE(len) \
117 (CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr)) + CMSG_COMPAT_ALIGN(len))
118 #define CMSG_COMPAT_LEN(len) \
119 (CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr)) + (len))
121 #define CMSG_COMPAT_FIRSTHDR(msg) \
122 (((msg)->msg_controllen) >= sizeof(struct compat_cmsghdr) ? \
123 (struct compat_cmsghdr *)((msg)->msg_control) : \
124 (struct compat_cmsghdr *)NULL)
126 static inline struct compat_cmsghdr *cmsg_compat_nxthdr(struct msghdr *msg,
127 struct compat_cmsghdr *cmsg, int cmsg_len)
129 struct compat_cmsghdr *ptr;
131 ptr = (struct compat_cmsghdr *)(((unsigned char *)cmsg) +
132 CMSG_COMPAT_ALIGN(cmsg_len));
133 if ((unsigned long)((char *)(ptr + 1) - (char *)msg->msg_control) >
139 /* There is a lot of hair here because the alignment rules (and
140 * thus placement) of cmsg headers and length are different for
141 * 32-bit apps. -DaveM
143 int cmsghdr_from_user_compat_to_kern(struct msghdr *kmsg,
144 unsigned char *stackbuf, int stackbuf_size)
146 struct compat_cmsghdr *ucmsg;
147 struct cmsghdr *kcmsg, *kcmsg_base;
148 compat_size_t ucmlen;
149 __kernel_size_t kcmlen, tmp;
152 kcmsg_base = kcmsg = (struct cmsghdr *)stackbuf;
153 ucmsg = CMSG_COMPAT_FIRSTHDR(kmsg);
154 while(ucmsg != NULL) {
155 if(get_user(ucmlen, &ucmsg->cmsg_len))
159 if(CMSG_COMPAT_ALIGN(ucmlen) <
160 CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr)))
162 if((unsigned long)(((char *)ucmsg - (char *)kmsg->msg_control)
163 + ucmlen) > kmsg->msg_controllen)
166 tmp = ((ucmlen - CMSG_COMPAT_ALIGN(sizeof(*ucmsg))) +
167 CMSG_ALIGN(sizeof(struct cmsghdr)));
169 ucmsg = cmsg_compat_nxthdr(kmsg, ucmsg, ucmlen);
174 /* The kcmlen holds the 64-bit version of the control length.
175 * It may not be modified as we do not stick it into the kmsg
176 * until we have successfully copied over all of the data
179 if(kcmlen > stackbuf_size)
180 kcmsg_base = kcmsg = kmalloc(kcmlen, GFP_KERNEL);
184 /* Now copy them over neatly. */
185 memset(kcmsg, 0, kcmlen);
186 ucmsg = CMSG_COMPAT_FIRSTHDR(kmsg);
187 while(ucmsg != NULL) {
188 __get_user(ucmlen, &ucmsg->cmsg_len);
189 tmp = ((ucmlen - CMSG_COMPAT_ALIGN(sizeof(*ucmsg))) +
190 CMSG_ALIGN(sizeof(struct cmsghdr)));
191 kcmsg->cmsg_len = tmp;
192 __get_user(kcmsg->cmsg_level, &ucmsg->cmsg_level);
193 __get_user(kcmsg->cmsg_type, &ucmsg->cmsg_type);
195 /* Copy over the data. */
196 if(copy_from_user(CMSG_DATA(kcmsg),
197 CMSG_COMPAT_DATA(ucmsg),
198 (ucmlen - CMSG_COMPAT_ALIGN(sizeof(*ucmsg)))))
199 goto out_free_efault;
202 kcmsg = (struct cmsghdr *)((char *)kcmsg + CMSG_ALIGN(tmp));
203 ucmsg = cmsg_compat_nxthdr(kmsg, ucmsg, ucmlen);
206 /* Ok, looks like we made it. Hook it up and return success. */
207 kmsg->msg_control = kcmsg_base;
208 kmsg->msg_controllen = kcmlen;
212 if(kcmsg_base != (struct cmsghdr *)stackbuf)
217 int put_cmsg_compat(struct msghdr *kmsg, int level, int type, int len, void *data)
219 struct compat_timeval ctv;
220 struct compat_cmsghdr *cm = (struct compat_cmsghdr *) kmsg->msg_control;
221 struct compat_cmsghdr cmhdr;
224 if(cm == NULL || kmsg->msg_controllen < sizeof(*cm)) {
225 kmsg->msg_flags |= MSG_CTRUNC;
226 return 0; /* XXX: return error? check spec. */
229 if (level == SOL_SOCKET && type == SO_TIMESTAMP) {
230 struct timeval *tv = (struct timeval *)data;
231 ctv.tv_sec = tv->tv_sec;
232 ctv.tv_usec = tv->tv_usec;
234 len = sizeof(struct compat_timeval);
237 cmlen = CMSG_COMPAT_LEN(len);
238 if(kmsg->msg_controllen < cmlen) {
239 kmsg->msg_flags |= MSG_CTRUNC;
240 cmlen = kmsg->msg_controllen;
242 cmhdr.cmsg_level = level;
243 cmhdr.cmsg_type = type;
244 cmhdr.cmsg_len = cmlen;
246 if(copy_to_user(cm, &cmhdr, sizeof cmhdr))
248 if(copy_to_user(CMSG_COMPAT_DATA(cm), data, cmlen - sizeof(struct compat_cmsghdr)))
250 cmlen = CMSG_COMPAT_SPACE(len);
251 kmsg->msg_control += cmlen;
252 kmsg->msg_controllen -= cmlen;
256 void scm_detach_fds_compat(struct msghdr *kmsg, struct scm_cookie *scm)
258 struct compat_cmsghdr *cm = (struct compat_cmsghdr *) kmsg->msg_control;
259 int fdmax = (kmsg->msg_controllen - sizeof(struct compat_cmsghdr)) / sizeof(int);
260 int fdnum = scm->fp->count;
261 struct file **fp = scm->fp->fp;
268 for (i = 0, cmfptr = (int *) CMSG_COMPAT_DATA(cm); i < fdmax; i++, cmfptr++) {
270 err = get_unused_fd();
274 err = put_user(new_fd, cmfptr);
276 put_unused_fd(new_fd);
279 /* Bump the usage count and install the file. */
281 fd_install(new_fd, fp[i]);
285 int cmlen = CMSG_COMPAT_LEN(i * sizeof(int));
287 err = put_user(SOL_SOCKET, &cm->cmsg_level);
289 err = put_user(SCM_RIGHTS, &cm->cmsg_type);
291 err = put_user(cmlen, &cm->cmsg_len);
293 cmlen = CMSG_COMPAT_SPACE(i * sizeof(int));
294 kmsg->msg_control += cmlen;
295 kmsg->msg_controllen -= cmlen;
299 kmsg->msg_flags |= MSG_CTRUNC;
302 * All of the files that fit in the message have had their
303 * usage counts incremented, so we just free the list.
309 * For now, we assume that the compatibility and native version
310 * of struct ipt_entry are the same - sfr. FIXME
312 struct compat_ipt_replace {
313 char name[IPT_TABLE_MAXNAMELEN];
317 u32 hook_entry[NF_IP_NUMHOOKS];
318 u32 underflow[NF_IP_NUMHOOKS];
320 compat_uptr_t counters; /* struct ipt_counters * */
321 struct ipt_entry entries[0];
324 static int do_netfilter_replace(int fd, int level, int optname,
325 char *optval, int optlen)
327 struct compat_ipt_replace *urepl = (struct compat_ipt_replace *)optval;
328 struct ipt_replace *repl_nat;
329 char name[IPT_TABLE_MAXNAMELEN];
330 u32 origsize, tmp32, num_counters;
331 unsigned int repl_nat_size;
334 compat_uptr_t ucntrs;
336 if (get_user(origsize, &urepl->size))
339 /* Hack: Causes ipchains to give correct error msg --RR */
340 if (optlen != sizeof(*urepl) + origsize)
343 /* XXX Assumes that size of ipt_entry is the same both in
344 * native and compat environments.
346 repl_nat_size = sizeof(*repl_nat) + origsize;
347 repl_nat = compat_alloc_user_space(repl_nat_size);
350 if (put_user(origsize, &repl_nat->size))
353 if (!access_ok(VERIFY_READ, urepl, optlen) ||
354 !access_ok(VERIFY_WRITE, repl_nat, optlen))
357 if (__copy_from_user(name, urepl->name, sizeof(urepl->name)) ||
358 __copy_to_user(repl_nat->name, name, sizeof(repl_nat->name)))
361 if (__get_user(tmp32, &urepl->valid_hooks) ||
362 __put_user(tmp32, &repl_nat->valid_hooks))
365 if (__get_user(tmp32, &urepl->num_entries) ||
366 __put_user(tmp32, &repl_nat->num_entries))
369 if (__get_user(num_counters, &urepl->num_counters) ||
370 __put_user(num_counters, &repl_nat->num_counters))
373 if (__get_user(ucntrs, &urepl->counters) ||
374 __put_user(compat_ptr(ucntrs), &repl_nat->counters))
377 if (__copy_in_user(&repl_nat->entries[0],
382 for (i = 0; i < NF_IP_NUMHOOKS; i++) {
383 if (__get_user(tmp32, &urepl->hook_entry[i]) ||
384 __put_user(tmp32, &repl_nat->hook_entry[i]) ||
385 __get_user(tmp32, &urepl->underflow[i]) ||
386 __put_user(tmp32, &repl_nat->underflow[i]))
391 * Since struct ipt_counters just contains two u_int64_t members
392 * we can just do the access_ok check here and pass the (converted)
393 * pointer into the standard syscall. We hope that the pointer is
396 if (!access_ok(VERIFY_WRITE, compat_ptr(ucntrs),
397 num_counters * sizeof(struct ipt_counters)))
401 ret = sys_setsockopt(fd, level, optname,
402 (char *)repl_nat, repl_nat_size);
409 * A struct sock_filter is architecture independent.
411 struct compat_sock_fprog {
413 compat_uptr_t filter; /* struct sock_filter * */
416 static int do_set_attach_filter(int fd, int level, int optname,
417 char *optval, int optlen)
419 struct compat_sock_fprog *fprog32 = (struct compat_sock_fprog *)optval;
420 struct sock_fprog *kfprog = compat_alloc_user_space(sizeof(struct sock_fprog));
424 if (!access_ok(VERIFY_READ, fprog32, sizeof(*fprog32)) ||
425 !access_ok(VERIFY_WRITE, kfprog, sizeof(struct sock_fprog)) ||
426 __get_user(len, &fprog32->len) ||
427 __get_user(ptr, &fprog32->filter) ||
428 __put_user(len, &kfprog->len) ||
429 __put_user(compat_ptr(ptr), &kfprog->filter))
432 return sys_setsockopt(fd, level, optname, (char *)kfprog,
433 sizeof(struct sock_fprog));
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);
469 return sys_setsockopt(fd, level, optname, optval, optlen);
472 static int do_get_sock_timeout(int fd, int level, int optname, char *optval,
475 struct compat_timeval *up = (struct compat_timeval *) optval;
476 struct timeval ktime;
480 if (get_user(len, optlen))
482 if (len < sizeof(*up))
487 err = sys_getsockopt(fd, level, optname, (char *) &ktime, &len);
491 if (put_user(sizeof(*up), optlen) ||
492 !access_ok(VERIFY_WRITE, up, sizeof(*up)) ||
493 __put_user(ktime.tv_sec, &up->tv_sec) ||
494 __put_user(ktime.tv_usec, &up->tv_usec))
500 asmlinkage long compat_sys_getsockopt(int fd, int level, int optname,
501 char *optval, int *optlen)
503 if (optname == SO_RCVTIMEO || optname == SO_SNDTIMEO)
504 return do_get_sock_timeout(fd, level, optname, optval, optlen);
505 return sys_getsockopt(fd, level, optname, optval, optlen);
508 /* Argument list sizes for compat_sys_socketcall */
509 #define AL(x) ((x) * sizeof(u32))
510 static unsigned char nas[18]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
511 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
512 AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)};
515 asmlinkage long compat_sys_sendmsg(int fd, struct compat_msghdr *msg, unsigned flags)
517 return sys_sendmsg(fd, (struct msghdr *)msg, flags | MSG_CMSG_COMPAT);
520 asmlinkage long compat_sys_recvmsg(int fd, struct compat_msghdr *msg, unsigned int flags)
522 return sys_recvmsg(fd, (struct msghdr *)msg, flags | MSG_CMSG_COMPAT);
525 asmlinkage long compat_sys_socketcall(int call, u32 *args)
531 if (call < SYS_SOCKET || call > SYS_RECVMSG)
533 if (copy_from_user(a, args, nas[call]))
540 ret = sys_socket(a0, a1, a[2]);
543 ret = sys_bind(a0, compat_ptr(a1), a[2]);
546 ret = sys_connect(a0, compat_ptr(a1), a[2]);
549 ret = sys_listen(a0, a1);
552 ret = sys_accept(a0, compat_ptr(a1), compat_ptr(a[2]));
554 case SYS_GETSOCKNAME:
555 ret = sys_getsockname(a0, compat_ptr(a1), compat_ptr(a[2]));
557 case SYS_GETPEERNAME:
558 ret = sys_getpeername(a0, compat_ptr(a1), compat_ptr(a[2]));
561 ret = sys_socketpair(a0, a1, a[2], compat_ptr(a[3]));
564 ret = sys_send(a0, compat_ptr(a1), a[2], a[3]);
567 ret = sys_sendto(a0, compat_ptr(a1), a[2], a[3], compat_ptr(a[4]), a[5]);
570 ret = sys_recv(a0, compat_ptr(a1), a[2], a[3]);
573 ret = sys_recvfrom(a0, compat_ptr(a1), a[2], a[3], compat_ptr(a[4]), compat_ptr(a[5]));
576 ret = sys_shutdown(a0,a1);
579 ret = compat_sys_setsockopt(a0, a1, a[2],
580 compat_ptr(a[3]), a[4]);
583 ret = compat_sys_getsockopt(a0, a1, a[2],
584 compat_ptr(a[3]), compat_ptr(a[4]));
587 ret = compat_sys_sendmsg(a0, compat_ptr(a1), a[2]);
590 ret = compat_sys_recvmsg(a0, compat_ptr(a1), a[2]);