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>
26 #include <asm/uaccess.h>
27 #include <asm/socket32.h>
29 #define A(__x) ((unsigned long)(__x))
30 #define AA(__x) ((unsigned long)(__x))
33 static inline int iov_from_user32_to_kern(struct iovec *kiov,
34 struct iovec32 *uiov32,
42 if(get_user(len, &uiov32->iov_len) ||
43 get_user(buf, &uiov32->iov_base)) {
48 kiov->iov_base = (void *)A(buf);
49 kiov->iov_len = (__kernel_size_t) len;
57 static inline int msghdr_from_user32_to_kern(struct msghdr *kmsg,
58 struct msghdr32 *umsg)
63 err = get_user(tmp1, &umsg->msg_name);
64 err |= __get_user(tmp2, &umsg->msg_iov);
65 err |= __get_user(tmp3, &umsg->msg_control);
69 kmsg->msg_name = (void *)A(tmp1);
70 kmsg->msg_iov = (struct iovec *)A(tmp2);
71 kmsg->msg_control = (void *)A(tmp3);
73 err = get_user(kmsg->msg_namelen, &umsg->msg_namelen);
74 err |= get_user(kmsg->msg_iovlen, &umsg->msg_iovlen);
75 err |= get_user(kmsg->msg_controllen, &umsg->msg_controllen);
76 err |= get_user(kmsg->msg_flags, &umsg->msg_flags);
81 /* I've named the args so it is easy to tell whose space the pointers are in. */
82 static int verify_iovec32(struct msghdr *kern_msg, struct iovec *kern_iov,
83 char *kern_address, int mode)
87 if(kern_msg->msg_namelen) {
88 if(mode==VERIFY_READ) {
89 int err = move_addr_to_kernel(kern_msg->msg_name,
90 kern_msg->msg_namelen,
95 kern_msg->msg_name = kern_address;
97 kern_msg->msg_name = NULL;
99 if(kern_msg->msg_iovlen > UIO_FASTIOV) {
100 if (kern_msg->msg_iovlen > (2*PAGE_SIZE)/ sizeof(struct iovec))
102 kern_iov = kmalloc(kern_msg->msg_iovlen * sizeof(struct iovec),
108 tot_len = iov_from_user32_to_kern(kern_iov,
109 (struct iovec32 *)kern_msg->msg_iov,
110 kern_msg->msg_iovlen);
112 kern_msg->msg_iov = kern_iov;
113 else if(kern_msg->msg_iovlen > UIO_FASTIOV)
119 /* There is a lot of hair here because the alignment rules (and
120 * thus placement) of cmsg headers and length are different for
121 * 32-bit apps. -DaveM
123 static int cmsghdr_from_user32_to_kern(struct msghdr *kmsg,
124 unsigned char *stackbuf, int stackbuf_size)
126 struct cmsghdr32 *ucmsg;
127 struct cmsghdr *kcmsg, *kcmsg_base;
128 __kernel_size_t32 ucmlen;
129 __kernel_size_t kcmlen, tmp;
133 kcmsg_base = kcmsg = (struct cmsghdr *)stackbuf;
134 ucmsg = CMSG32_FIRSTHDR(kmsg);
135 while(ucmsg != NULL) {
136 if (get_user(ucmlen, &ucmsg->cmsg_len))
140 if (!CMSG32_OK(ucmlen, ucmsg, kmsg))
143 if (kmsg->msg_controllen > 65536)
146 tmp = ((ucmlen - CMSG32_ALIGN(sizeof(*ucmsg))) +
147 CMSG_ALIGN(sizeof(struct cmsghdr)));
149 ucmsg = CMSG32_NXTHDR(kmsg, ucmsg, ucmlen);
154 /* The kcmlen holds the 64-bit version of the control length.
155 * It may not be modified as we do not stick it into the kmsg
156 * until we have successfully copied over all of the data
159 if(kcmlen > stackbuf_size)
160 kcmsg_base = kcmsg = kmalloc(kcmlen, GFP_KERNEL);
164 /* Now copy them over neatly. */
165 memset(kcmsg, 0, kcmlen);
166 ucmsg = CMSG32_FIRSTHDR(kmsg);
167 while(ucmsg != NULL) {
168 if (__get_user(ucmlen, &ucmsg->cmsg_len))
170 tmp = ((ucmlen - CMSG32_ALIGN(sizeof(*ucmsg))) +
171 CMSG_ALIGN(sizeof(struct cmsghdr)));
172 if ((char *)kcmsg_base + kcmlen - (char *)kcmsg < CMSG_ALIGN(tmp))
174 kcmsg->cmsg_len = tmp;
175 if (__get_user(kcmsg->cmsg_level, &ucmsg->cmsg_level) ||
176 __get_user(kcmsg->cmsg_type, &ucmsg->cmsg_type) ||
177 copy_from_user(CMSG_DATA(kcmsg),
179 (ucmlen - CMSG32_ALIGN(sizeof(*ucmsg)))))
183 kcmsg = (struct cmsghdr *)((char *)kcmsg + CMSG_ALIGN(tmp));
184 ucmsg = CMSG32_NXTHDR(kmsg, ucmsg, ucmlen);
187 /* Ok, looks like we made it. Hook it up and return success. */
188 kmsg->msg_control = kcmsg_base;
189 kmsg->msg_controllen = kcmlen;
195 if (kcmsg_base != (struct cmsghdr *)stackbuf)
200 static void put_cmsg32(struct msghdr *kmsg, int level, int type,
203 struct cmsghdr32 *cm = (struct cmsghdr32 *) kmsg->msg_control;
204 struct cmsghdr32 cmhdr;
205 int cmlen = CMSG32_LEN(len);
207 if(cm == NULL || kmsg->msg_controllen < sizeof(*cm)) {
208 kmsg->msg_flags |= MSG_CTRUNC;
212 if(kmsg->msg_controllen < cmlen) {
213 kmsg->msg_flags |= MSG_CTRUNC;
214 cmlen = kmsg->msg_controllen;
216 cmhdr.cmsg_level = level;
217 cmhdr.cmsg_type = type;
218 cmhdr.cmsg_len = cmlen;
220 if(copy_to_user(cm, &cmhdr, sizeof cmhdr))
222 if(copy_to_user(CMSG32_DATA(cm), data, cmlen - sizeof(struct cmsghdr32)))
224 cmlen = CMSG32_SPACE(len);
225 kmsg->msg_control += cmlen;
226 kmsg->msg_controllen -= cmlen;
229 static void scm_detach_fds32(struct msghdr *kmsg, struct scm_cookie *scm)
231 struct cmsghdr32 *cm = (struct cmsghdr32 *) kmsg->msg_control;
232 int fdmax = (kmsg->msg_controllen - sizeof(struct cmsghdr32)) / sizeof(int);
233 int fdnum = scm->fp->count;
234 struct file **fp = scm->fp->fp;
241 for (i = 0, cmfptr = (int *) CMSG32_DATA(cm); i < fdmax; i++, cmfptr++) {
243 err = get_unused_fd();
247 err = put_user(new_fd, cmfptr);
249 put_unused_fd(new_fd);
252 /* Bump the usage count and install the file. */
254 fd_install(new_fd, fp[i]);
258 int cmlen = CMSG32_LEN(i * sizeof(int));
260 err = put_user(SOL_SOCKET, &cm->cmsg_level);
262 err = put_user(SCM_RIGHTS, &cm->cmsg_type);
264 err = put_user(cmlen, &cm->cmsg_len);
266 cmlen = CMSG32_SPACE(i * sizeof(int));
267 kmsg->msg_control += cmlen;
268 kmsg->msg_controllen -= cmlen;
272 kmsg->msg_flags |= MSG_CTRUNC;
275 * All of the files that fit in the message have had their
276 * usage counts incremented, so we just free the list.
281 /* In these cases we (currently) can just copy to data over verbatim
282 * because all CMSGs created by the kernel have well defined types which
283 * have the same layout in both the 32-bit and 64-bit API. One must add
284 * some special cased conversions here if we start sending control messages
285 * with incompatible types.
287 * SCM_RIGHTS and SCM_CREDENTIALS are done by hand in recvmsg32 right after
288 * we do our work. The remaining cases are:
290 * SOL_IP IP_PKTINFO struct in_pktinfo 32-bit clean
291 * IP_TTL int 32-bit clean
292 * IP_TOS __u8 32-bit clean
293 * IP_RECVOPTS variable length 32-bit clean
294 * IP_RETOPTS variable length 32-bit clean
295 * (these last two are clean because the types are defined
296 * by the IPv4 protocol)
297 * IP_RECVERR struct sock_extended_err +
298 * struct sockaddr_in 32-bit clean
299 * SOL_IPV6 IPV6_RECVERR struct sock_extended_err +
300 * struct sockaddr_in6 32-bit clean
301 * IPV6_PKTINFO struct in6_pktinfo 32-bit clean
302 * IPV6_HOPLIMIT int 32-bit clean
303 * IPV6_FLOWINFO u32 32-bit clean
304 * IPV6_HOPOPTS ipv6 hop exthdr 32-bit clean
305 * IPV6_DSTOPTS ipv6 dst exthdr(s) 32-bit clean
306 * IPV6_RTHDR ipv6 routing exthdr 32-bit clean
307 * IPV6_AUTHHDR ipv6 auth exthdr 32-bit clean
309 static void cmsg32_recvmsg_fixup(struct msghdr *kmsg,
310 unsigned long orig_cmsg_uptr, __kernel_size_t orig_cmsg_len)
312 unsigned char *workbuf, *wp;
313 unsigned long bufsz, space_avail;
314 struct cmsghdr *ucmsg;
316 bufsz = ((unsigned long)kmsg->msg_control) - orig_cmsg_uptr;
317 space_avail = kmsg->msg_controllen + bufsz;
318 wp = workbuf = kmalloc(bufsz, GFP_KERNEL);
322 /* To make this more sane we assume the kernel sends back properly
323 * formatted control messages. Because of how the kernel will truncate
324 * the cmsg_len for MSG_TRUNC cases, we need not check that case either.
326 ucmsg = (struct cmsghdr *) orig_cmsg_uptr;
327 while(((unsigned long)ucmsg) <=
328 (((unsigned long)kmsg->msg_control) - sizeof(struct cmsghdr))) {
329 struct cmsghdr32 *kcmsg32 = (struct cmsghdr32 *) wp;
332 /* UCMSG is the 64-bit format CMSG entry in user-space.
333 * KCMSG32 is within the kernel space temporary buffer
334 * we use to convert into a 32-bit style CMSG.
336 __get_user(kcmsg32->cmsg_len, &ucmsg->cmsg_len);
337 __get_user(kcmsg32->cmsg_level, &ucmsg->cmsg_level);
338 __get_user(kcmsg32->cmsg_type, &ucmsg->cmsg_type);
340 clen64 = kcmsg32->cmsg_len;
341 if ((clen64 < CMSG_ALIGN(sizeof(*ucmsg))) ||
342 (clen64 > (orig_cmsg_len + wp - workbuf)))
344 copy_from_user(CMSG32_DATA(kcmsg32), CMSG_DATA(ucmsg),
345 clen64 - CMSG_ALIGN(sizeof(*ucmsg)));
346 clen32 = ((clen64 - CMSG_ALIGN(sizeof(*ucmsg))) +
347 CMSG32_ALIGN(sizeof(struct cmsghdr32)));
348 kcmsg32->cmsg_len = clen32;
350 ucmsg = (struct cmsghdr *) (((char *)ucmsg) + CMSG_ALIGN(clen64));
351 wp = (((char *)kcmsg32) + CMSG32_ALIGN(clen32));
354 /* Copy back fixed up data, and adjust pointers. */
355 bufsz = (wp - workbuf);
356 copy_to_user((void *)orig_cmsg_uptr, workbuf, bufsz);
358 kmsg->msg_control = (struct cmsghdr *)
359 (((char *)orig_cmsg_uptr) + bufsz);
360 kmsg->msg_controllen = space_avail - bufsz;
366 /* If we leave the 64-bit format CMSG chunks in there,
367 * the application could get confused and crash. So to
368 * ensure greater recovery, we report no CMSGs.
370 kmsg->msg_controllen += bufsz;
371 kmsg->msg_control = (void *) orig_cmsg_uptr;
374 asmlinkage long sys32_sendmsg(int fd, struct msghdr32 *user_msg, unsigned user_flags)
377 char address[MAX_SOCK_ADDR];
378 struct iovec iov[UIO_FASTIOV];
379 unsigned char ctl[sizeof(struct cmsghdr) + 20];
380 unsigned char *ctl_buf = ctl;
381 struct msghdr kern_msg;
384 if(msghdr_from_user32_to_kern(&kern_msg, user_msg))
386 if(kern_msg.msg_iovlen > UIO_MAXIOV)
388 err = verify_iovec32(&kern_msg, iov, address, VERIFY_READ);
393 if(kern_msg.msg_controllen) {
394 err = cmsghdr_from_user32_to_kern(&kern_msg, ctl, sizeof(ctl));
397 ctl_buf = kern_msg.msg_control;
399 kern_msg.msg_flags = user_flags;
401 sock = sockfd_lookup(fd, &err);
403 if (sock->file->f_flags & O_NONBLOCK)
404 kern_msg.msg_flags |= MSG_DONTWAIT;
405 err = sock_sendmsg(sock, &kern_msg, total_len);
409 /* N.B. Use kfree here, as kern_msg.msg_controllen might change? */
413 if(kern_msg.msg_iov != iov)
414 kfree(kern_msg.msg_iov);
419 asmlinkage long sys32_recvmsg(int fd, struct msghdr32 *user_msg, unsigned int user_flags)
421 struct iovec iovstack[UIO_FASTIOV];
422 struct msghdr kern_msg;
423 char addr[MAX_SOCK_ADDR];
425 struct iovec *iov = iovstack;
426 struct sockaddr *uaddr;
428 unsigned long cmsg_ptr;
429 __kernel_size_t cmsg_len;
430 int err, total_len, len = 0;
432 if(msghdr_from_user32_to_kern(&kern_msg, user_msg))
434 if(kern_msg.msg_iovlen > UIO_MAXIOV)
437 uaddr = kern_msg.msg_name;
438 uaddr_len = &user_msg->msg_namelen;
439 err = verify_iovec32(&kern_msg, iov, addr, VERIFY_WRITE);
444 cmsg_ptr = (unsigned long) kern_msg.msg_control;
445 cmsg_len = kern_msg.msg_controllen;
446 kern_msg.msg_flags = 0;
448 sock = sockfd_lookup(fd, &err);
450 struct scm_cookie scm;
452 if (sock->file->f_flags & O_NONBLOCK)
453 user_flags |= MSG_DONTWAIT;
454 memset(&scm, 0, sizeof(scm));
455 err = sock->ops->recvmsg(sock, &kern_msg, total_len,
459 if(!kern_msg.msg_control) {
460 if(sock->passcred || scm.fp)
461 kern_msg.msg_flags |= MSG_CTRUNC;
465 /* If recvmsg processing itself placed some
466 * control messages into user space, it's is
467 * using 64-bit CMSG processing, so we need
468 * to fix it up before we tack on more stuff.
470 if((unsigned long) kern_msg.msg_control != cmsg_ptr)
471 cmsg32_recvmsg_fixup(&kern_msg,
476 put_cmsg32(&kern_msg,
477 SOL_SOCKET, SCM_CREDENTIALS,
478 sizeof(scm.creds), &scm.creds);
480 scm_detach_fds32(&kern_msg, &scm);
486 if(uaddr != NULL && err >= 0)
487 err = move_addr_to_user(addr, kern_msg.msg_namelen, uaddr, uaddr_len);
488 if(cmsg_ptr != 0 && err >= 0) {
489 unsigned long ucmsg_ptr = ((unsigned long)kern_msg.msg_control);
490 __kernel_size_t32 uclen = (__kernel_size_t32) (ucmsg_ptr - cmsg_ptr);
491 err |= __put_user(uclen, &user_msg->msg_controllen);
494 err = __put_user(kern_msg.msg_flags, &user_msg->msg_flags);
495 if(kern_msg.msg_iov != iov)
496 kfree(kern_msg.msg_iov);
503 extern asmlinkage int sys_setsockopt(int fd, int level, int optname,
504 char *optval, int optlen);
506 static int do_set_attach_filter(int fd, int level, int optname,
507 char *optval, int optlen)
509 struct sock_fprog32 {
512 } *fprog32 = (struct sock_fprog32 *)optval;
513 struct sock_fprog kfprog;
518 if (get_user(kfprog.len, &fprog32->len) ||
519 __get_user(uptr, &fprog32->filter))
522 kfprog.filter = (struct sock_filter *)A(uptr);
524 if (verify_area(VERIFY_WRITE, kfprog.filter, kfprog.len*sizeof(struct sock_filter)))
529 ret = sys_setsockopt(fd, level, optname,
530 (char *)&kfprog, sizeof(kfprog));
536 static int do_set_icmpv6_filter(int fd, int level, int optname,
537 char *optval, int optlen)
539 struct icmp6_filter kfilter;
543 if (copy_from_user(&kfilter, optval, sizeof(kfilter)))
547 for (i = 0; i < 8; i += 2) {
548 u32 tmp = kfilter.data[i];
550 kfilter.data[i] = kfilter.data[i + 1];
551 kfilter.data[i + 1] = tmp;
556 ret = sys_setsockopt(fd, level, optname,
557 (char *) &kfilter, sizeof(kfilter));
563 asmlinkage long sys32_setsockopt(int fd, int level, int optname,
564 char *optval, int optlen)
566 if (level == SOL_SOCKET && optname == SO_ATTACH_FILTER)
567 return do_set_attach_filter(fd, level, optname,
569 if (level == SOL_ICMPV6 && optname == ICMPV6_FILTER)
570 return do_set_icmpv6_filter(fd, level, optname,
573 return sys_setsockopt(fd, level, optname, optval, optlen);
577 /* Argument list sizes for sys_socketcall */
578 #define AL(x) ((x) * sizeof(u32))
579 static unsigned char nas[18]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
580 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
581 AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)};
584 extern asmlinkage long sys_bind(int fd, struct sockaddr *umyaddr, int addrlen);
585 extern asmlinkage long sys_connect(int fd, struct sockaddr *uservaddr,
587 extern asmlinkage long sys_accept(int fd, struct sockaddr *upeer_sockaddr,
589 extern asmlinkage long sys_getsockname(int fd, struct sockaddr *usockaddr,
591 extern asmlinkage long sys_getpeername(int fd, struct sockaddr *usockaddr,
593 extern asmlinkage long sys_send(int fd, void *buff, size_t len, unsigned flags);
594 extern asmlinkage long sys_sendto(int fd, u32 buff, __kernel_size_t32 len,
595 unsigned flags, u32 addr, int addr_len);
596 extern asmlinkage long sys_recv(int fd, void *ubuf, size_t size, unsigned flags);
597 extern asmlinkage long sys_recvfrom(int fd, u32 ubuf, __kernel_size_t32 size,
598 unsigned flags, u32 addr, u32 addr_len);
599 extern asmlinkage long sys_getsockopt(int fd, int level, int optname,
600 u32 optval, u32 optlen);
602 extern asmlinkage long sys_socket(int family, int type, int protocol);
603 extern asmlinkage long sys_socketpair(int family, int type, int protocol,
605 extern asmlinkage long sys_shutdown(int fd, int how);
606 extern asmlinkage long sys_listen(int fd, int backlog);
608 asmlinkage long sys32_socketcall(int call, u32 *args)
614 if (call<SYS_SOCKET||call>SYS_RECVMSG)
616 if (copy_from_user(a, args, nas[call]))
624 ret = sys_socket(a0, a1, a[2]);
627 ret = sys_bind(a0, (struct sockaddr *)A(a1), a[2]);
630 ret = sys_connect(a0, (struct sockaddr *)A(a1), a[2]);
633 ret = sys_listen(a0, a1);
636 ret = sys_accept(a0, (struct sockaddr *)A(a1),
639 case SYS_GETSOCKNAME:
640 ret = sys_getsockname(a0, (struct sockaddr *)A(a1),
643 case SYS_GETPEERNAME:
644 ret = sys_getpeername(a0, (struct sockaddr *)A(a1),
648 ret = sys_socketpair(a0, a1, a[2], (int *)A(a[3]));
651 ret = sys_send(a0, (void *)A(a1), a[2], a[3]);
654 ret = sys_sendto(a0, a1, a[2], a[3], a[4], a[5]);
657 ret = sys_recv(a0, (void *)A(a1), a[2], a[3]);
660 ret = sys_recvfrom(a0, a1, a[2], a[3], a[4], a[5]);
663 ret = sys_shutdown(a0,a1);
666 ret = sys32_setsockopt(a0, a1, a[2], (char *)A(a[3]),
670 ret = sys_getsockopt(a0, a1, a[2], a[3], a[4]);
673 ret = sys32_sendmsg(a0, (struct msghdr32 *)A(a1),
677 ret = sys32_recvmsg(a0, (struct msghdr32 *)A(a1),