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>
15 #include <linux/gfp.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/security.h>
25 #include <linux/export.h>
31 #include <asm/uaccess.h>
32 #include <net/compat.h>
34 ssize_t
get_compat_msghdr(struct msghdr
*kmsg
,
35 struct compat_msghdr __user
*umsg
,
36 struct sockaddr __user
**save_addr
,
39 compat_uptr_t uaddr
, uiov
, tmp3
;
40 compat_size_t nr_segs
;
43 if (!access_ok(VERIFY_READ
, umsg
, sizeof(*umsg
)) ||
44 __get_user(uaddr
, &umsg
->msg_name
) ||
45 __get_user(kmsg
->msg_namelen
, &umsg
->msg_namelen
) ||
46 __get_user(uiov
, &umsg
->msg_iov
) ||
47 __get_user(nr_segs
, &umsg
->msg_iovlen
) ||
48 __get_user(tmp3
, &umsg
->msg_control
) ||
49 __get_user(kmsg
->msg_controllen
, &umsg
->msg_controllen
) ||
50 __get_user(kmsg
->msg_flags
, &umsg
->msg_flags
))
54 kmsg
->msg_namelen
= 0;
56 if (kmsg
->msg_namelen
< 0)
59 if (kmsg
->msg_namelen
> sizeof(struct sockaddr_storage
))
60 kmsg
->msg_namelen
= sizeof(struct sockaddr_storage
);
61 kmsg
->msg_control
= compat_ptr(tmp3
);
64 *save_addr
= compat_ptr(uaddr
);
66 if (uaddr
&& kmsg
->msg_namelen
) {
68 err
= move_addr_to_kernel(compat_ptr(uaddr
),
75 kmsg
->msg_name
= NULL
;
76 kmsg
->msg_namelen
= 0;
79 if (nr_segs
> UIO_MAXIOV
)
82 err
= compat_rw_copy_check_uvector(save_addr
? READ
: WRITE
,
83 compat_ptr(uiov
), nr_segs
,
84 UIO_FASTIOV
, *iov
, iov
);
86 iov_iter_init(&kmsg
->msg_iter
, save_addr
? READ
: WRITE
,
92 #define CMSG_COMPAT_ALIGN(len) ALIGN((len), sizeof(s32))
94 #define CMSG_COMPAT_DATA(cmsg) \
95 ((void __user *)((char __user *)(cmsg) + CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr))))
96 #define CMSG_COMPAT_SPACE(len) \
97 (CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr)) + CMSG_COMPAT_ALIGN(len))
98 #define CMSG_COMPAT_LEN(len) \
99 (CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr)) + (len))
101 #define CMSG_COMPAT_FIRSTHDR(msg) \
102 (((msg)->msg_controllen) >= sizeof(struct compat_cmsghdr) ? \
103 (struct compat_cmsghdr __user *)((msg)->msg_control) : \
104 (struct compat_cmsghdr __user *)NULL)
106 #define CMSG_COMPAT_OK(ucmlen, ucmsg, mhdr) \
107 ((ucmlen) >= sizeof(struct compat_cmsghdr) && \
108 (ucmlen) <= (unsigned long) \
109 ((mhdr)->msg_controllen - \
110 ((char *)(ucmsg) - (char *)(mhdr)->msg_control)))
112 static inline struct compat_cmsghdr __user
*cmsg_compat_nxthdr(struct msghdr
*msg
,
113 struct compat_cmsghdr __user
*cmsg
, int cmsg_len
)
115 char __user
*ptr
= (char __user
*)cmsg
+ CMSG_COMPAT_ALIGN(cmsg_len
);
116 if ((unsigned long)(ptr
+ 1 - (char __user
*)msg
->msg_control
) >
119 return (struct compat_cmsghdr __user
*)ptr
;
122 /* There is a lot of hair here because the alignment rules (and
123 * thus placement) of cmsg headers and length are different for
124 * 32-bit apps. -DaveM
126 int cmsghdr_from_user_compat_to_kern(struct msghdr
*kmsg
, struct sock
*sk
,
127 unsigned char *stackbuf
, int stackbuf_size
)
129 struct compat_cmsghdr __user
*ucmsg
;
130 struct cmsghdr
*kcmsg
, *kcmsg_base
;
131 compat_size_t ucmlen
;
132 __kernel_size_t kcmlen
, tmp
;
136 kcmsg_base
= kcmsg
= (struct cmsghdr
*)stackbuf
;
137 ucmsg
= CMSG_COMPAT_FIRSTHDR(kmsg
);
138 while (ucmsg
!= NULL
) {
139 if (get_user(ucmlen
, &ucmsg
->cmsg_len
))
143 if (!CMSG_COMPAT_OK(ucmlen
, ucmsg
, kmsg
))
146 tmp
= ((ucmlen
- CMSG_COMPAT_ALIGN(sizeof(*ucmsg
))) +
147 CMSG_ALIGN(sizeof(struct cmsghdr
)));
148 tmp
= CMSG_ALIGN(tmp
);
150 ucmsg
= cmsg_compat_nxthdr(kmsg
, ucmsg
, ucmlen
);
155 /* The kcmlen holds the 64-bit version of the control length.
156 * It may not be modified as we do not stick it into the kmsg
157 * until we have successfully copied over all of the data
160 if (kcmlen
> stackbuf_size
)
161 kcmsg_base
= kcmsg
= sock_kmalloc(sk
, kcmlen
, GFP_KERNEL
);
165 /* Now copy them over neatly. */
166 memset(kcmsg
, 0, kcmlen
);
167 ucmsg
= CMSG_COMPAT_FIRSTHDR(kmsg
);
168 while (ucmsg
!= NULL
) {
169 if (__get_user(ucmlen
, &ucmsg
->cmsg_len
))
171 if (!CMSG_COMPAT_OK(ucmlen
, ucmsg
, kmsg
))
173 tmp
= ((ucmlen
- CMSG_COMPAT_ALIGN(sizeof(*ucmsg
))) +
174 CMSG_ALIGN(sizeof(struct cmsghdr
)));
175 if ((char *)kcmsg_base
+ kcmlen
- (char *)kcmsg
< CMSG_ALIGN(tmp
))
177 kcmsg
->cmsg_len
= tmp
;
178 tmp
= CMSG_ALIGN(tmp
);
179 if (__get_user(kcmsg
->cmsg_level
, &ucmsg
->cmsg_level
) ||
180 __get_user(kcmsg
->cmsg_type
, &ucmsg
->cmsg_type
) ||
181 copy_from_user(CMSG_DATA(kcmsg
),
182 CMSG_COMPAT_DATA(ucmsg
),
183 (ucmlen
- CMSG_COMPAT_ALIGN(sizeof(*ucmsg
)))))
187 kcmsg
= (struct cmsghdr
*)((char *)kcmsg
+ tmp
);
188 ucmsg
= cmsg_compat_nxthdr(kmsg
, ucmsg
, ucmlen
);
191 /* Ok, looks like we made it. Hook it up and return success. */
192 kmsg
->msg_control
= kcmsg_base
;
193 kmsg
->msg_controllen
= kcmlen
;
199 if (kcmsg_base
!= (struct cmsghdr
*)stackbuf
)
200 sock_kfree_s(sk
, kcmsg_base
, kcmlen
);
204 int put_cmsg_compat(struct msghdr
*kmsg
, int level
, int type
, int len
, void *data
)
206 struct compat_cmsghdr __user
*cm
= (struct compat_cmsghdr __user
*) kmsg
->msg_control
;
207 struct compat_cmsghdr cmhdr
;
208 struct compat_timeval ctv
;
209 struct compat_timespec cts
[3];
212 if (cm
== NULL
|| kmsg
->msg_controllen
< sizeof(*cm
)) {
213 kmsg
->msg_flags
|= MSG_CTRUNC
;
214 return 0; /* XXX: return error? check spec. */
217 if (!COMPAT_USE_64BIT_TIME
) {
218 if (level
== SOL_SOCKET
&& type
== SCM_TIMESTAMP
) {
219 struct timeval
*tv
= (struct timeval
*)data
;
220 ctv
.tv_sec
= tv
->tv_sec
;
221 ctv
.tv_usec
= tv
->tv_usec
;
225 if (level
== SOL_SOCKET
&&
226 (type
== SCM_TIMESTAMPNS
|| type
== SCM_TIMESTAMPING
)) {
227 int count
= type
== SCM_TIMESTAMPNS
? 1 : 3;
229 struct timespec
*ts
= (struct timespec
*)data
;
230 for (i
= 0; i
< count
; i
++) {
231 cts
[i
].tv_sec
= ts
[i
].tv_sec
;
232 cts
[i
].tv_nsec
= ts
[i
].tv_nsec
;
235 len
= sizeof(cts
[0]) * count
;
239 cmlen
= CMSG_COMPAT_LEN(len
);
240 if (kmsg
->msg_controllen
< cmlen
) {
241 kmsg
->msg_flags
|= MSG_CTRUNC
;
242 cmlen
= kmsg
->msg_controllen
;
244 cmhdr
.cmsg_level
= level
;
245 cmhdr
.cmsg_type
= type
;
246 cmhdr
.cmsg_len
= cmlen
;
248 if (copy_to_user(cm
, &cmhdr
, sizeof cmhdr
))
250 if (copy_to_user(CMSG_COMPAT_DATA(cm
), data
, cmlen
- sizeof(struct compat_cmsghdr
)))
252 cmlen
= CMSG_COMPAT_SPACE(len
);
253 if (kmsg
->msg_controllen
< cmlen
)
254 cmlen
= kmsg
->msg_controllen
;
255 kmsg
->msg_control
+= cmlen
;
256 kmsg
->msg_controllen
-= cmlen
;
260 void scm_detach_fds_compat(struct msghdr
*kmsg
, struct scm_cookie
*scm
)
262 struct compat_cmsghdr __user
*cm
= (struct compat_cmsghdr __user
*) kmsg
->msg_control
;
263 int fdmax
= (kmsg
->msg_controllen
- sizeof(struct compat_cmsghdr
)) / sizeof(int);
264 int fdnum
= scm
->fp
->count
;
265 struct file
**fp
= scm
->fp
->fp
;
272 for (i
= 0, cmfptr
= (int __user
*) CMSG_COMPAT_DATA(cm
); i
< fdmax
; i
++, cmfptr
++) {
274 err
= security_file_receive(fp
[i
]);
277 err
= get_unused_fd_flags(MSG_CMSG_CLOEXEC
& kmsg
->msg_flags
282 err
= put_user(new_fd
, cmfptr
);
284 put_unused_fd(new_fd
);
287 /* Bump the usage count and install the file. */
288 fd_install(new_fd
, get_file(fp
[i
]));
292 int cmlen
= CMSG_COMPAT_LEN(i
* sizeof(int));
293 err
= put_user(SOL_SOCKET
, &cm
->cmsg_level
);
295 err
= put_user(SCM_RIGHTS
, &cm
->cmsg_type
);
297 err
= put_user(cmlen
, &cm
->cmsg_len
);
299 cmlen
= CMSG_COMPAT_SPACE(i
* sizeof(int));
300 kmsg
->msg_control
+= cmlen
;
301 kmsg
->msg_controllen
-= cmlen
;
305 kmsg
->msg_flags
|= MSG_CTRUNC
;
308 * All of the files that fit in the message have had their
309 * usage counts incremented, so we just free the list.
314 static int do_set_attach_filter(struct socket
*sock
, int level
, int optname
,
315 char __user
*optval
, unsigned int optlen
)
317 struct compat_sock_fprog __user
*fprog32
= (struct compat_sock_fprog __user
*)optval
;
318 struct sock_fprog __user
*kfprog
= compat_alloc_user_space(sizeof(struct sock_fprog
));
322 if (!access_ok(VERIFY_READ
, fprog32
, sizeof(*fprog32
)) ||
323 !access_ok(VERIFY_WRITE
, kfprog
, sizeof(struct sock_fprog
)) ||
324 __get_user(len
, &fprog32
->len
) ||
325 __get_user(ptr
, &fprog32
->filter
) ||
326 __put_user(len
, &kfprog
->len
) ||
327 __put_user(compat_ptr(ptr
), &kfprog
->filter
))
330 return sock_setsockopt(sock
, level
, optname
, (char __user
*)kfprog
,
331 sizeof(struct sock_fprog
));
334 static int do_set_sock_timeout(struct socket
*sock
, int level
,
335 int optname
, char __user
*optval
, unsigned int optlen
)
337 struct compat_timeval __user
*up
= (struct compat_timeval __user
*)optval
;
338 struct timeval ktime
;
342 if (optlen
< sizeof(*up
))
344 if (!access_ok(VERIFY_READ
, up
, sizeof(*up
)) ||
345 __get_user(ktime
.tv_sec
, &up
->tv_sec
) ||
346 __get_user(ktime
.tv_usec
, &up
->tv_usec
))
350 err
= sock_setsockopt(sock
, level
, optname
, (char *)&ktime
, sizeof(ktime
));
356 static int compat_sock_setsockopt(struct socket
*sock
, int level
, int optname
,
357 char __user
*optval
, unsigned int optlen
)
359 if (optname
== SO_ATTACH_FILTER
)
360 return do_set_attach_filter(sock
, level
, optname
,
362 if (optname
== SO_RCVTIMEO
|| optname
== SO_SNDTIMEO
)
363 return do_set_sock_timeout(sock
, level
, optname
, optval
, optlen
);
365 return sock_setsockopt(sock
, level
, optname
, optval
, optlen
);
368 COMPAT_SYSCALL_DEFINE5(setsockopt
, int, fd
, int, level
, int, optname
,
369 char __user
*, optval
, unsigned int, optlen
)
372 struct socket
*sock
= sockfd_lookup(fd
, &err
);
375 err
= security_socket_setsockopt(sock
, level
, optname
);
381 if (level
== SOL_SOCKET
)
382 err
= compat_sock_setsockopt(sock
, level
,
383 optname
, optval
, optlen
);
384 else if (sock
->ops
->compat_setsockopt
)
385 err
= sock
->ops
->compat_setsockopt(sock
, level
,
386 optname
, optval
, optlen
);
388 err
= sock
->ops
->setsockopt(sock
, level
,
389 optname
, optval
, optlen
);
395 static int do_get_sock_timeout(struct socket
*sock
, int level
, int optname
,
396 char __user
*optval
, int __user
*optlen
)
398 struct compat_timeval __user
*up
;
399 struct timeval ktime
;
403 up
= (struct compat_timeval __user
*) optval
;
404 if (get_user(len
, optlen
))
406 if (len
< sizeof(*up
))
411 err
= sock_getsockopt(sock
, level
, optname
, (char *) &ktime
, &len
);
415 if (put_user(sizeof(*up
), optlen
) ||
416 !access_ok(VERIFY_WRITE
, up
, sizeof(*up
)) ||
417 __put_user(ktime
.tv_sec
, &up
->tv_sec
) ||
418 __put_user(ktime
.tv_usec
, &up
->tv_usec
))
424 static int compat_sock_getsockopt(struct socket
*sock
, int level
, int optname
,
425 char __user
*optval
, int __user
*optlen
)
427 if (optname
== SO_RCVTIMEO
|| optname
== SO_SNDTIMEO
)
428 return do_get_sock_timeout(sock
, level
, optname
, optval
, optlen
);
429 return sock_getsockopt(sock
, level
, optname
, optval
, optlen
);
432 int compat_sock_get_timestamp(struct sock
*sk
, struct timeval __user
*userstamp
)
434 struct compat_timeval __user
*ctv
;
438 if (COMPAT_USE_64BIT_TIME
)
439 return sock_get_timestamp(sk
, userstamp
);
441 ctv
= (struct compat_timeval __user
*) userstamp
;
443 if (!sock_flag(sk
, SOCK_TIMESTAMP
))
444 sock_enable_timestamp(sk
, SOCK_TIMESTAMP
);
445 tv
= ktime_to_timeval(sk
->sk_stamp
);
448 if (tv
.tv_sec
== 0) {
449 sk
->sk_stamp
= ktime_get_real();
450 tv
= ktime_to_timeval(sk
->sk_stamp
);
453 if (put_user(tv
.tv_sec
, &ctv
->tv_sec
) ||
454 put_user(tv
.tv_usec
, &ctv
->tv_usec
))
458 EXPORT_SYMBOL(compat_sock_get_timestamp
);
460 int compat_sock_get_timestampns(struct sock
*sk
, struct timespec __user
*userstamp
)
462 struct compat_timespec __user
*ctv
;
466 if (COMPAT_USE_64BIT_TIME
)
467 return sock_get_timestampns (sk
, userstamp
);
469 ctv
= (struct compat_timespec __user
*) userstamp
;
471 if (!sock_flag(sk
, SOCK_TIMESTAMP
))
472 sock_enable_timestamp(sk
, SOCK_TIMESTAMP
);
473 ts
= ktime_to_timespec(sk
->sk_stamp
);
476 if (ts
.tv_sec
== 0) {
477 sk
->sk_stamp
= ktime_get_real();
478 ts
= ktime_to_timespec(sk
->sk_stamp
);
481 if (put_user(ts
.tv_sec
, &ctv
->tv_sec
) ||
482 put_user(ts
.tv_nsec
, &ctv
->tv_nsec
))
486 EXPORT_SYMBOL(compat_sock_get_timestampns
);
488 COMPAT_SYSCALL_DEFINE5(getsockopt
, int, fd
, int, level
, int, optname
,
489 char __user
*, optval
, int __user
*, optlen
)
492 struct socket
*sock
= sockfd_lookup(fd
, &err
);
495 err
= security_socket_getsockopt(sock
, level
, optname
);
501 if (level
== SOL_SOCKET
)
502 err
= compat_sock_getsockopt(sock
, level
,
503 optname
, optval
, optlen
);
504 else if (sock
->ops
->compat_getsockopt
)
505 err
= sock
->ops
->compat_getsockopt(sock
, level
,
506 optname
, optval
, optlen
);
508 err
= sock
->ops
->getsockopt(sock
, level
,
509 optname
, optval
, optlen
);
515 struct compat_group_req
{
517 struct __kernel_sockaddr_storage gr_group
518 __attribute__ ((aligned(4)));
521 struct compat_group_source_req
{
523 struct __kernel_sockaddr_storage gsr_group
524 __attribute__ ((aligned(4)));
525 struct __kernel_sockaddr_storage gsr_source
526 __attribute__ ((aligned(4)));
529 struct compat_group_filter
{
531 struct __kernel_sockaddr_storage gf_group
532 __attribute__ ((aligned(4)));
535 struct __kernel_sockaddr_storage gf_slist
[1]
536 __attribute__ ((aligned(4)));
539 #define __COMPAT_GF0_SIZE (sizeof(struct compat_group_filter) - \
540 sizeof(struct __kernel_sockaddr_storage))
543 int compat_mc_setsockopt(struct sock
*sock
, int level
, int optname
,
544 char __user
*optval
, unsigned int optlen
,
545 int (*setsockopt
)(struct sock
*, int, int, char __user
*, unsigned int))
547 char __user
*koptval
= optval
;
548 int koptlen
= optlen
;
551 case MCAST_JOIN_GROUP
:
552 case MCAST_LEAVE_GROUP
:
554 struct compat_group_req __user
*gr32
= (void *)optval
;
555 struct group_req __user
*kgr
=
556 compat_alloc_user_space(sizeof(struct group_req
));
559 if (!access_ok(VERIFY_READ
, gr32
, sizeof(*gr32
)) ||
560 !access_ok(VERIFY_WRITE
, kgr
, sizeof(struct group_req
)) ||
561 __get_user(interface
, &gr32
->gr_interface
) ||
562 __put_user(interface
, &kgr
->gr_interface
) ||
563 copy_in_user(&kgr
->gr_group
, &gr32
->gr_group
,
564 sizeof(kgr
->gr_group
)))
566 koptval
= (char __user
*)kgr
;
567 koptlen
= sizeof(struct group_req
);
570 case MCAST_JOIN_SOURCE_GROUP
:
571 case MCAST_LEAVE_SOURCE_GROUP
:
572 case MCAST_BLOCK_SOURCE
:
573 case MCAST_UNBLOCK_SOURCE
:
575 struct compat_group_source_req __user
*gsr32
= (void *)optval
;
576 struct group_source_req __user
*kgsr
= compat_alloc_user_space(
577 sizeof(struct group_source_req
));
580 if (!access_ok(VERIFY_READ
, gsr32
, sizeof(*gsr32
)) ||
581 !access_ok(VERIFY_WRITE
, kgsr
,
582 sizeof(struct group_source_req
)) ||
583 __get_user(interface
, &gsr32
->gsr_interface
) ||
584 __put_user(interface
, &kgsr
->gsr_interface
) ||
585 copy_in_user(&kgsr
->gsr_group
, &gsr32
->gsr_group
,
586 sizeof(kgsr
->gsr_group
)) ||
587 copy_in_user(&kgsr
->gsr_source
, &gsr32
->gsr_source
,
588 sizeof(kgsr
->gsr_source
)))
590 koptval
= (char __user
*)kgsr
;
591 koptlen
= sizeof(struct group_source_req
);
596 struct compat_group_filter __user
*gf32
= (void *)optval
;
597 struct group_filter __user
*kgf
;
598 u32 interface
, fmode
, numsrc
;
600 if (!access_ok(VERIFY_READ
, gf32
, __COMPAT_GF0_SIZE
) ||
601 __get_user(interface
, &gf32
->gf_interface
) ||
602 __get_user(fmode
, &gf32
->gf_fmode
) ||
603 __get_user(numsrc
, &gf32
->gf_numsrc
))
605 koptlen
= optlen
+ sizeof(struct group_filter
) -
606 sizeof(struct compat_group_filter
);
607 if (koptlen
< GROUP_FILTER_SIZE(numsrc
))
609 kgf
= compat_alloc_user_space(koptlen
);
610 if (!access_ok(VERIFY_WRITE
, kgf
, koptlen
) ||
611 __put_user(interface
, &kgf
->gf_interface
) ||
612 __put_user(fmode
, &kgf
->gf_fmode
) ||
613 __put_user(numsrc
, &kgf
->gf_numsrc
) ||
614 copy_in_user(&kgf
->gf_group
, &gf32
->gf_group
,
615 sizeof(kgf
->gf_group
)) ||
616 (numsrc
&& copy_in_user(kgf
->gf_slist
, gf32
->gf_slist
,
617 numsrc
* sizeof(kgf
->gf_slist
[0]))))
619 koptval
= (char __user
*)kgf
;
626 return setsockopt(sock
, level
, optname
, koptval
, koptlen
);
628 EXPORT_SYMBOL(compat_mc_setsockopt
);
630 int compat_mc_getsockopt(struct sock
*sock
, int level
, int optname
,
631 char __user
*optval
, int __user
*optlen
,
632 int (*getsockopt
)(struct sock
*, int, int, char __user
*, int __user
*))
634 struct compat_group_filter __user
*gf32
= (void *)optval
;
635 struct group_filter __user
*kgf
;
637 u32 interface
, fmode
, numsrc
;
640 if (optname
!= MCAST_MSFILTER
)
641 return getsockopt(sock
, level
, optname
, optval
, optlen
);
643 koptlen
= compat_alloc_user_space(sizeof(*koptlen
));
644 if (!access_ok(VERIFY_READ
, optlen
, sizeof(*optlen
)) ||
645 __get_user(ulen
, optlen
))
648 /* adjust len for pad */
649 klen
= ulen
+ sizeof(*kgf
) - sizeof(*gf32
);
651 if (klen
< GROUP_FILTER_SIZE(0))
654 if (!access_ok(VERIFY_WRITE
, koptlen
, sizeof(*koptlen
)) ||
655 __put_user(klen
, koptlen
))
658 /* have to allow space for previous compat_alloc_user_space, too */
659 kgf
= compat_alloc_user_space(klen
+sizeof(*optlen
));
661 if (!access_ok(VERIFY_READ
, gf32
, __COMPAT_GF0_SIZE
) ||
662 __get_user(interface
, &gf32
->gf_interface
) ||
663 __get_user(fmode
, &gf32
->gf_fmode
) ||
664 __get_user(numsrc
, &gf32
->gf_numsrc
) ||
665 __put_user(interface
, &kgf
->gf_interface
) ||
666 __put_user(fmode
, &kgf
->gf_fmode
) ||
667 __put_user(numsrc
, &kgf
->gf_numsrc
) ||
668 copy_in_user(&kgf
->gf_group
, &gf32
->gf_group
, sizeof(kgf
->gf_group
)))
671 err
= getsockopt(sock
, level
, optname
, (char __user
*)kgf
, koptlen
);
675 if (!access_ok(VERIFY_READ
, koptlen
, sizeof(*koptlen
)) ||
676 __get_user(klen
, koptlen
))
679 ulen
= klen
- (sizeof(*kgf
)-sizeof(*gf32
));
681 if (!access_ok(VERIFY_WRITE
, optlen
, sizeof(*optlen
)) ||
682 __put_user(ulen
, optlen
))
685 if (!access_ok(VERIFY_READ
, kgf
, klen
) ||
686 !access_ok(VERIFY_WRITE
, gf32
, ulen
) ||
687 __get_user(interface
, &kgf
->gf_interface
) ||
688 __get_user(fmode
, &kgf
->gf_fmode
) ||
689 __get_user(numsrc
, &kgf
->gf_numsrc
) ||
690 __put_user(interface
, &gf32
->gf_interface
) ||
691 __put_user(fmode
, &gf32
->gf_fmode
) ||
692 __put_user(numsrc
, &gf32
->gf_numsrc
))
697 klen
-= GROUP_FILTER_SIZE(0);
698 copylen
= numsrc
* sizeof(gf32
->gf_slist
[0]);
701 if (copy_in_user(gf32
->gf_slist
, kgf
->gf_slist
, copylen
))
706 EXPORT_SYMBOL(compat_mc_getsockopt
);
709 /* Argument list sizes for compat_sys_socketcall */
710 #define AL(x) ((x) * sizeof(u32))
711 static unsigned char nas
[21] = {
712 AL(0), AL(3), AL(3), AL(3), AL(2), AL(3),
713 AL(3), AL(3), AL(4), AL(4), AL(4), AL(6),
714 AL(6), AL(2), AL(5), AL(5), AL(3), AL(3),
719 COMPAT_SYSCALL_DEFINE3(sendmsg
, int, fd
, struct compat_msghdr __user
*, msg
, unsigned int, flags
)
721 return __sys_sendmsg(fd
, (struct user_msghdr __user
*)msg
, flags
| MSG_CMSG_COMPAT
);
724 COMPAT_SYSCALL_DEFINE4(sendmmsg
, int, fd
, struct compat_mmsghdr __user
*, mmsg
,
725 unsigned int, vlen
, unsigned int, flags
)
727 return __sys_sendmmsg(fd
, (struct mmsghdr __user
*)mmsg
, vlen
,
728 flags
| MSG_CMSG_COMPAT
);
731 COMPAT_SYSCALL_DEFINE3(recvmsg
, int, fd
, struct compat_msghdr __user
*, msg
, unsigned int, flags
)
733 return __sys_recvmsg(fd
, (struct user_msghdr __user
*)msg
, flags
| MSG_CMSG_COMPAT
);
736 COMPAT_SYSCALL_DEFINE4(recv
, int, fd
, void __user
*, buf
, compat_size_t
, len
, unsigned int, flags
)
738 return sys_recv(fd
, buf
, len
, flags
| MSG_CMSG_COMPAT
);
741 COMPAT_SYSCALL_DEFINE6(recvfrom
, int, fd
, void __user
*, buf
, compat_size_t
, len
,
742 unsigned int, flags
, struct sockaddr __user
*, addr
,
743 int __user
*, addrlen
)
745 return sys_recvfrom(fd
, buf
, len
, flags
| MSG_CMSG_COMPAT
, addr
, addrlen
);
748 COMPAT_SYSCALL_DEFINE5(recvmmsg
, int, fd
, struct compat_mmsghdr __user
*, mmsg
,
749 unsigned int, vlen
, unsigned int, flags
,
750 struct compat_timespec __user
*, timeout
)
753 struct timespec ktspec
;
756 return __sys_recvmmsg(fd
, (struct mmsghdr __user
*)mmsg
, vlen
,
757 flags
| MSG_CMSG_COMPAT
, NULL
);
759 if (compat_get_timespec(&ktspec
, timeout
))
762 datagrams
= __sys_recvmmsg(fd
, (struct mmsghdr __user
*)mmsg
, vlen
,
763 flags
| MSG_CMSG_COMPAT
, &ktspec
);
764 if (datagrams
> 0 && compat_put_timespec(&ktspec
, timeout
))
770 COMPAT_SYSCALL_DEFINE2(socketcall
, int, call
, u32 __user
*, args
)
776 if (call
< SYS_SOCKET
|| call
> SYS_SENDMMSG
)
778 if (copy_from_user(a
, args
, nas
[call
]))
785 ret
= sys_socket(a0
, a1
, a
[2]);
788 ret
= sys_bind(a0
, compat_ptr(a1
), a
[2]);
791 ret
= sys_connect(a0
, compat_ptr(a1
), a
[2]);
794 ret
= sys_listen(a0
, a1
);
797 ret
= sys_accept4(a0
, compat_ptr(a1
), compat_ptr(a
[2]), 0);
799 case SYS_GETSOCKNAME
:
800 ret
= sys_getsockname(a0
, compat_ptr(a1
), compat_ptr(a
[2]));
802 case SYS_GETPEERNAME
:
803 ret
= sys_getpeername(a0
, compat_ptr(a1
), compat_ptr(a
[2]));
806 ret
= sys_socketpair(a0
, a1
, a
[2], compat_ptr(a
[3]));
809 ret
= sys_send(a0
, compat_ptr(a1
), a
[2], a
[3]);
812 ret
= sys_sendto(a0
, compat_ptr(a1
), a
[2], a
[3], compat_ptr(a
[4]), a
[5]);
815 ret
= compat_sys_recv(a0
, compat_ptr(a1
), a
[2], a
[3]);
818 ret
= compat_sys_recvfrom(a0
, compat_ptr(a1
), a
[2], a
[3],
819 compat_ptr(a
[4]), compat_ptr(a
[5]));
822 ret
= sys_shutdown(a0
, a1
);
825 ret
= compat_sys_setsockopt(a0
, a1
, a
[2],
826 compat_ptr(a
[3]), a
[4]);
829 ret
= compat_sys_getsockopt(a0
, a1
, a
[2],
830 compat_ptr(a
[3]), compat_ptr(a
[4]));
833 ret
= compat_sys_sendmsg(a0
, compat_ptr(a1
), a
[2]);
836 ret
= compat_sys_sendmmsg(a0
, compat_ptr(a1
), a
[2], a
[3]);
839 ret
= compat_sys_recvmsg(a0
, compat_ptr(a1
), a
[2]);
842 ret
= compat_sys_recvmmsg(a0
, compat_ptr(a1
), a
[2], a
[3],
846 ret
= sys_accept4(a0
, compat_ptr(a1
), compat_ptr(a
[2]), a
[3]);