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/audit.h>
26 #include <linux/export.h>
32 #include <linux/uaccess.h>
33 #include <net/compat.h>
35 int get_compat_msghdr(struct msghdr
*kmsg
,
36 struct compat_msghdr __user
*umsg
,
37 struct sockaddr __user
**save_addr
,
40 struct compat_msghdr msg
;
43 if (copy_from_user(&msg
, umsg
, sizeof(*umsg
)))
46 kmsg
->msg_flags
= msg
.msg_flags
;
47 kmsg
->msg_namelen
= msg
.msg_namelen
;
50 kmsg
->msg_namelen
= 0;
52 if (kmsg
->msg_namelen
< 0)
55 if (kmsg
->msg_namelen
> sizeof(struct sockaddr_storage
))
56 kmsg
->msg_namelen
= sizeof(struct sockaddr_storage
);
58 kmsg
->msg_control
= compat_ptr(msg
.msg_control
);
59 kmsg
->msg_controllen
= msg
.msg_controllen
;
62 *save_addr
= compat_ptr(msg
.msg_name
);
64 if (msg
.msg_name
&& kmsg
->msg_namelen
) {
66 err
= move_addr_to_kernel(compat_ptr(msg
.msg_name
),
73 kmsg
->msg_name
= NULL
;
74 kmsg
->msg_namelen
= 0;
77 if (msg
.msg_iovlen
> UIO_MAXIOV
)
80 kmsg
->msg_iocb
= NULL
;
82 return compat_import_iovec(save_addr
? READ
: WRITE
,
83 compat_ptr(msg
.msg_iov
), msg
.msg_iovlen
,
84 UIO_FASTIOV
, iov
, &kmsg
->msg_iter
);
88 #define CMSG_COMPAT_ALIGN(len) ALIGN((len), sizeof(s32))
90 #define CMSG_COMPAT_DATA(cmsg) \
91 ((void __user *)((char __user *)(cmsg) + sizeof(struct compat_cmsghdr)))
92 #define CMSG_COMPAT_SPACE(len) \
93 (sizeof(struct compat_cmsghdr) + CMSG_COMPAT_ALIGN(len))
94 #define CMSG_COMPAT_LEN(len) \
95 (sizeof(struct compat_cmsghdr) + (len))
97 #define CMSG_COMPAT_FIRSTHDR(msg) \
98 (((msg)->msg_controllen) >= sizeof(struct compat_cmsghdr) ? \
99 (struct compat_cmsghdr __user *)((msg)->msg_control) : \
100 (struct compat_cmsghdr __user *)NULL)
102 #define CMSG_COMPAT_OK(ucmlen, ucmsg, mhdr) \
103 ((ucmlen) >= sizeof(struct compat_cmsghdr) && \
104 (ucmlen) <= (unsigned long) \
105 ((mhdr)->msg_controllen - \
106 ((char *)(ucmsg) - (char *)(mhdr)->msg_control)))
108 static inline struct compat_cmsghdr __user
*cmsg_compat_nxthdr(struct msghdr
*msg
,
109 struct compat_cmsghdr __user
*cmsg
, int cmsg_len
)
111 char __user
*ptr
= (char __user
*)cmsg
+ CMSG_COMPAT_ALIGN(cmsg_len
);
112 if ((unsigned long)(ptr
+ 1 - (char __user
*)msg
->msg_control
) >
115 return (struct compat_cmsghdr __user
*)ptr
;
118 /* There is a lot of hair here because the alignment rules (and
119 * thus placement) of cmsg headers and length are different for
120 * 32-bit apps. -DaveM
122 int cmsghdr_from_user_compat_to_kern(struct msghdr
*kmsg
, struct sock
*sk
,
123 unsigned char *stackbuf
, int stackbuf_size
)
125 struct compat_cmsghdr __user
*ucmsg
;
126 struct cmsghdr
*kcmsg
, *kcmsg_base
;
127 compat_size_t ucmlen
;
128 __kernel_size_t kcmlen
, tmp
;
131 BUILD_BUG_ON(sizeof(struct compat_cmsghdr
) !=
132 CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr
)));
135 kcmsg_base
= kcmsg
= (struct cmsghdr
*)stackbuf
;
136 ucmsg
= CMSG_COMPAT_FIRSTHDR(kmsg
);
137 while (ucmsg
!= NULL
) {
138 if (get_user(ucmlen
, &ucmsg
->cmsg_len
))
142 if (!CMSG_COMPAT_OK(ucmlen
, ucmsg
, kmsg
))
145 tmp
= ((ucmlen
- sizeof(*ucmsg
)) + sizeof(struct cmsghdr
));
146 tmp
= CMSG_ALIGN(tmp
);
148 ucmsg
= cmsg_compat_nxthdr(kmsg
, ucmsg
, ucmlen
);
153 /* The kcmlen holds the 64-bit version of the control length.
154 * It may not be modified as we do not stick it into the kmsg
155 * until we have successfully copied over all of the data
158 if (kcmlen
> stackbuf_size
)
159 kcmsg_base
= kcmsg
= sock_kmalloc(sk
, kcmlen
, GFP_KERNEL
);
163 /* Now copy them over neatly. */
164 memset(kcmsg
, 0, kcmlen
);
165 ucmsg
= CMSG_COMPAT_FIRSTHDR(kmsg
);
166 while (ucmsg
!= NULL
) {
167 if (__get_user(ucmlen
, &ucmsg
->cmsg_len
))
169 if (!CMSG_COMPAT_OK(ucmlen
, ucmsg
, kmsg
))
171 tmp
= ((ucmlen
- sizeof(*ucmsg
)) + sizeof(struct cmsghdr
));
172 if ((char *)kcmsg_base
+ kcmlen
- (char *)kcmsg
< CMSG_ALIGN(tmp
))
174 kcmsg
->cmsg_len
= tmp
;
175 tmp
= CMSG_ALIGN(tmp
);
176 if (__get_user(kcmsg
->cmsg_level
, &ucmsg
->cmsg_level
) ||
177 __get_user(kcmsg
->cmsg_type
, &ucmsg
->cmsg_type
) ||
178 copy_from_user(CMSG_DATA(kcmsg
),
179 CMSG_COMPAT_DATA(ucmsg
),
180 (ucmlen
- sizeof(*ucmsg
))))
184 kcmsg
= (struct cmsghdr
*)((char *)kcmsg
+ tmp
);
185 ucmsg
= cmsg_compat_nxthdr(kmsg
, ucmsg
, ucmlen
);
189 * check the length of messages copied in is the same as the
190 * what we get from the first loop
192 if ((char *)kcmsg
- (char *)kcmsg_base
!= kcmlen
)
195 /* Ok, looks like we made it. Hook it up and return success. */
196 kmsg
->msg_control
= kcmsg_base
;
197 kmsg
->msg_controllen
= kcmlen
;
203 if (kcmsg_base
!= (struct cmsghdr
*)stackbuf
)
204 sock_kfree_s(sk
, kcmsg_base
, kcmlen
);
208 int put_cmsg_compat(struct msghdr
*kmsg
, int level
, int type
, int len
, void *data
)
210 struct compat_cmsghdr __user
*cm
= (struct compat_cmsghdr __user
*) kmsg
->msg_control
;
211 struct compat_cmsghdr cmhdr
;
212 struct compat_timeval ctv
;
213 struct compat_timespec cts
[3];
216 if (cm
== NULL
|| kmsg
->msg_controllen
< sizeof(*cm
)) {
217 kmsg
->msg_flags
|= MSG_CTRUNC
;
218 return 0; /* XXX: return error? check spec. */
221 if (!COMPAT_USE_64BIT_TIME
) {
222 if (level
== SOL_SOCKET
&& type
== SCM_TIMESTAMP
) {
223 struct timeval
*tv
= (struct timeval
*)data
;
224 ctv
.tv_sec
= tv
->tv_sec
;
225 ctv
.tv_usec
= tv
->tv_usec
;
229 if (level
== SOL_SOCKET
&&
230 (type
== SCM_TIMESTAMPNS
|| type
== SCM_TIMESTAMPING
)) {
231 int count
= type
== SCM_TIMESTAMPNS
? 1 : 3;
233 struct timespec
*ts
= (struct timespec
*)data
;
234 for (i
= 0; i
< count
; i
++) {
235 cts
[i
].tv_sec
= ts
[i
].tv_sec
;
236 cts
[i
].tv_nsec
= ts
[i
].tv_nsec
;
239 len
= sizeof(cts
[0]) * count
;
243 cmlen
= CMSG_COMPAT_LEN(len
);
244 if (kmsg
->msg_controllen
< cmlen
) {
245 kmsg
->msg_flags
|= MSG_CTRUNC
;
246 cmlen
= kmsg
->msg_controllen
;
248 cmhdr
.cmsg_level
= level
;
249 cmhdr
.cmsg_type
= type
;
250 cmhdr
.cmsg_len
= cmlen
;
252 if (copy_to_user(cm
, &cmhdr
, sizeof cmhdr
))
254 if (copy_to_user(CMSG_COMPAT_DATA(cm
), data
, cmlen
- sizeof(struct compat_cmsghdr
)))
256 cmlen
= CMSG_COMPAT_SPACE(len
);
257 if (kmsg
->msg_controllen
< cmlen
)
258 cmlen
= kmsg
->msg_controllen
;
259 kmsg
->msg_control
+= cmlen
;
260 kmsg
->msg_controllen
-= cmlen
;
264 void scm_detach_fds_compat(struct msghdr
*kmsg
, struct scm_cookie
*scm
)
266 struct compat_cmsghdr __user
*cm
= (struct compat_cmsghdr __user
*) kmsg
->msg_control
;
267 int fdmax
= (kmsg
->msg_controllen
- sizeof(struct compat_cmsghdr
)) / sizeof(int);
268 int fdnum
= scm
->fp
->count
;
269 struct file
**fp
= scm
->fp
->fp
;
276 for (i
= 0, cmfptr
= (int __user
*) CMSG_COMPAT_DATA(cm
); i
< fdmax
; i
++, cmfptr
++) {
278 err
= security_file_receive(fp
[i
]);
281 err
= get_unused_fd_flags(MSG_CMSG_CLOEXEC
& kmsg
->msg_flags
286 err
= put_user(new_fd
, cmfptr
);
288 put_unused_fd(new_fd
);
291 /* Bump the usage count and install the file. */
292 fd_install(new_fd
, get_file(fp
[i
]));
296 int cmlen
= CMSG_COMPAT_LEN(i
* sizeof(int));
297 err
= put_user(SOL_SOCKET
, &cm
->cmsg_level
);
299 err
= put_user(SCM_RIGHTS
, &cm
->cmsg_type
);
301 err
= put_user(cmlen
, &cm
->cmsg_len
);
303 cmlen
= CMSG_COMPAT_SPACE(i
* sizeof(int));
304 kmsg
->msg_control
+= cmlen
;
305 kmsg
->msg_controllen
-= cmlen
;
309 kmsg
->msg_flags
|= MSG_CTRUNC
;
312 * All of the files that fit in the message have had their
313 * usage counts incremented, so we just free the list.
318 /* allocate a 64-bit sock_fprog on the user stack for duration of syscall. */
319 struct sock_fprog __user
*get_compat_bpf_fprog(char __user
*optval
)
321 struct compat_sock_fprog __user
*fprog32
= (struct compat_sock_fprog __user
*)optval
;
322 struct sock_fprog __user
*kfprog
= compat_alloc_user_space(sizeof(struct sock_fprog
));
323 struct compat_sock_fprog f32
;
326 if (copy_from_user(&f32
, fprog32
, sizeof(*fprog32
)))
328 memset(&f
, 0, sizeof(f
));
330 f
.filter
= compat_ptr(f32
.filter
);
331 if (copy_to_user(kfprog
, &f
, sizeof(struct sock_fprog
)))
336 EXPORT_SYMBOL_GPL(get_compat_bpf_fprog
);
338 static int do_set_attach_filter(struct socket
*sock
, int level
, int optname
,
339 char __user
*optval
, unsigned int optlen
)
341 struct sock_fprog __user
*kfprog
;
343 kfprog
= get_compat_bpf_fprog(optval
);
347 return sock_setsockopt(sock
, level
, optname
, (char __user
*)kfprog
,
348 sizeof(struct sock_fprog
));
351 static int do_set_sock_timeout(struct socket
*sock
, int level
,
352 int optname
, char __user
*optval
, unsigned int optlen
)
354 struct compat_timeval __user
*up
= (struct compat_timeval __user
*)optval
;
355 struct timeval ktime
;
359 if (optlen
< sizeof(*up
))
361 if (!access_ok(up
, sizeof(*up
)) ||
362 __get_user(ktime
.tv_sec
, &up
->tv_sec
) ||
363 __get_user(ktime
.tv_usec
, &up
->tv_usec
))
367 err
= sock_setsockopt(sock
, level
, optname
, (char *)&ktime
, sizeof(ktime
));
373 static int compat_sock_setsockopt(struct socket
*sock
, int level
, int optname
,
374 char __user
*optval
, unsigned int optlen
)
376 if (optname
== SO_ATTACH_FILTER
||
377 optname
== SO_ATTACH_REUSEPORT_CBPF
)
378 return do_set_attach_filter(sock
, level
, optname
,
380 if (!COMPAT_USE_64BIT_TIME
&&
381 (optname
== SO_RCVTIMEO
|| optname
== SO_SNDTIMEO
))
382 return do_set_sock_timeout(sock
, level
, optname
, optval
, optlen
);
384 return sock_setsockopt(sock
, level
, optname
, optval
, optlen
);
387 static int __compat_sys_setsockopt(int fd
, int level
, int optname
,
388 char __user
*optval
, unsigned int optlen
)
393 if (optlen
> INT_MAX
)
396 sock
= sockfd_lookup(fd
, &err
);
398 err
= security_socket_setsockopt(sock
, level
, optname
);
404 if (level
== SOL_SOCKET
)
405 err
= compat_sock_setsockopt(sock
, level
,
406 optname
, optval
, optlen
);
407 else if (sock
->ops
->compat_setsockopt
)
408 err
= sock
->ops
->compat_setsockopt(sock
, level
,
409 optname
, optval
, optlen
);
411 err
= sock
->ops
->setsockopt(sock
, level
,
412 optname
, optval
, optlen
);
418 COMPAT_SYSCALL_DEFINE5(setsockopt
, int, fd
, int, level
, int, optname
,
419 char __user
*, optval
, unsigned int, optlen
)
421 return __compat_sys_setsockopt(fd
, level
, optname
, optval
, optlen
);
424 static int do_get_sock_timeout(struct socket
*sock
, int level
, int optname
,
425 char __user
*optval
, int __user
*optlen
)
427 struct compat_timeval __user
*up
;
428 struct timeval ktime
;
432 up
= (struct compat_timeval __user
*) optval
;
433 if (get_user(len
, optlen
))
435 if (len
< sizeof(*up
))
440 err
= sock_getsockopt(sock
, level
, optname
, (char *) &ktime
, &len
);
444 if (put_user(sizeof(*up
), optlen
) ||
445 !access_ok(up
, sizeof(*up
)) ||
446 __put_user(ktime
.tv_sec
, &up
->tv_sec
) ||
447 __put_user(ktime
.tv_usec
, &up
->tv_usec
))
453 static int compat_sock_getsockopt(struct socket
*sock
, int level
, int optname
,
454 char __user
*optval
, int __user
*optlen
)
456 if (!COMPAT_USE_64BIT_TIME
&&
457 (optname
== SO_RCVTIMEO
|| optname
== SO_SNDTIMEO
))
458 return do_get_sock_timeout(sock
, level
, optname
, optval
, optlen
);
459 return sock_getsockopt(sock
, level
, optname
, optval
, optlen
);
462 int compat_sock_get_timestamp(struct sock
*sk
, struct timeval __user
*userstamp
)
464 struct compat_timeval __user
*ctv
;
468 if (COMPAT_USE_64BIT_TIME
)
469 return sock_get_timestamp(sk
, userstamp
);
471 ctv
= (struct compat_timeval __user
*) userstamp
;
473 sock_enable_timestamp(sk
, SOCK_TIMESTAMP
);
474 tv
= ktime_to_timeval(sock_read_timestamp(sk
));
478 if (tv
.tv_sec
== 0) {
479 ktime_t kt
= ktime_get_real();
480 sock_write_timestamp(sk
, kt
);
481 tv
= ktime_to_timeval(kt
);
484 if (put_user(tv
.tv_sec
, &ctv
->tv_sec
) ||
485 put_user(tv
.tv_usec
, &ctv
->tv_usec
))
489 EXPORT_SYMBOL(compat_sock_get_timestamp
);
491 int compat_sock_get_timestampns(struct sock
*sk
, struct timespec __user
*userstamp
)
493 struct compat_timespec __user
*ctv
;
497 if (COMPAT_USE_64BIT_TIME
)
498 return sock_get_timestampns (sk
, userstamp
);
500 ctv
= (struct compat_timespec __user
*) userstamp
;
502 sock_enable_timestamp(sk
, SOCK_TIMESTAMP
);
503 ts
= ktime_to_timespec(sock_read_timestamp(sk
));
506 if (ts
.tv_sec
== 0) {
507 ktime_t kt
= ktime_get_real();
508 sock_write_timestamp(sk
, kt
);
509 ts
= ktime_to_timespec(kt
);
512 if (put_user(ts
.tv_sec
, &ctv
->tv_sec
) ||
513 put_user(ts
.tv_nsec
, &ctv
->tv_nsec
))
517 EXPORT_SYMBOL(compat_sock_get_timestampns
);
519 static int __compat_sys_getsockopt(int fd
, int level
, int optname
,
524 struct socket
*sock
= sockfd_lookup(fd
, &err
);
527 err
= security_socket_getsockopt(sock
, level
, optname
);
533 if (level
== SOL_SOCKET
)
534 err
= compat_sock_getsockopt(sock
, level
,
535 optname
, optval
, optlen
);
536 else if (sock
->ops
->compat_getsockopt
)
537 err
= sock
->ops
->compat_getsockopt(sock
, level
,
538 optname
, optval
, optlen
);
540 err
= sock
->ops
->getsockopt(sock
, level
,
541 optname
, optval
, optlen
);
547 COMPAT_SYSCALL_DEFINE5(getsockopt
, int, fd
, int, level
, int, optname
,
548 char __user
*, optval
, int __user
*, optlen
)
550 return __compat_sys_getsockopt(fd
, level
, optname
, optval
, optlen
);
553 struct compat_group_req
{
555 struct __kernel_sockaddr_storage gr_group
559 struct compat_group_source_req
{
561 struct __kernel_sockaddr_storage gsr_group
563 struct __kernel_sockaddr_storage gsr_source
567 struct compat_group_filter
{
569 struct __kernel_sockaddr_storage gf_group
573 struct __kernel_sockaddr_storage gf_slist
[1]
577 #define __COMPAT_GF0_SIZE (sizeof(struct compat_group_filter) - \
578 sizeof(struct __kernel_sockaddr_storage))
581 int compat_mc_setsockopt(struct sock
*sock
, int level
, int optname
,
582 char __user
*optval
, unsigned int optlen
,
583 int (*setsockopt
)(struct sock
*, int, int, char __user
*, unsigned int))
585 char __user
*koptval
= optval
;
586 int koptlen
= optlen
;
589 case MCAST_JOIN_GROUP
:
590 case MCAST_LEAVE_GROUP
:
592 struct compat_group_req __user
*gr32
= (void *)optval
;
593 struct group_req __user
*kgr
=
594 compat_alloc_user_space(sizeof(struct group_req
));
597 if (!access_ok(gr32
, sizeof(*gr32
)) ||
598 !access_ok(kgr
, sizeof(struct group_req
)) ||
599 __get_user(interface
, &gr32
->gr_interface
) ||
600 __put_user(interface
, &kgr
->gr_interface
) ||
601 copy_in_user(&kgr
->gr_group
, &gr32
->gr_group
,
602 sizeof(kgr
->gr_group
)))
604 koptval
= (char __user
*)kgr
;
605 koptlen
= sizeof(struct group_req
);
608 case MCAST_JOIN_SOURCE_GROUP
:
609 case MCAST_LEAVE_SOURCE_GROUP
:
610 case MCAST_BLOCK_SOURCE
:
611 case MCAST_UNBLOCK_SOURCE
:
613 struct compat_group_source_req __user
*gsr32
= (void *)optval
;
614 struct group_source_req __user
*kgsr
= compat_alloc_user_space(
615 sizeof(struct group_source_req
));
618 if (!access_ok(gsr32
, sizeof(*gsr32
)) ||
620 sizeof(struct group_source_req
)) ||
621 __get_user(interface
, &gsr32
->gsr_interface
) ||
622 __put_user(interface
, &kgsr
->gsr_interface
) ||
623 copy_in_user(&kgsr
->gsr_group
, &gsr32
->gsr_group
,
624 sizeof(kgsr
->gsr_group
)) ||
625 copy_in_user(&kgsr
->gsr_source
, &gsr32
->gsr_source
,
626 sizeof(kgsr
->gsr_source
)))
628 koptval
= (char __user
*)kgsr
;
629 koptlen
= sizeof(struct group_source_req
);
634 struct compat_group_filter __user
*gf32
= (void *)optval
;
635 struct group_filter __user
*kgf
;
636 u32 interface
, fmode
, numsrc
;
638 if (!access_ok(gf32
, __COMPAT_GF0_SIZE
) ||
639 __get_user(interface
, &gf32
->gf_interface
) ||
640 __get_user(fmode
, &gf32
->gf_fmode
) ||
641 __get_user(numsrc
, &gf32
->gf_numsrc
))
643 koptlen
= optlen
+ sizeof(struct group_filter
) -
644 sizeof(struct compat_group_filter
);
645 if (koptlen
< GROUP_FILTER_SIZE(numsrc
))
647 kgf
= compat_alloc_user_space(koptlen
);
648 if (!access_ok(kgf
, koptlen
) ||
649 __put_user(interface
, &kgf
->gf_interface
) ||
650 __put_user(fmode
, &kgf
->gf_fmode
) ||
651 __put_user(numsrc
, &kgf
->gf_numsrc
) ||
652 copy_in_user(&kgf
->gf_group
, &gf32
->gf_group
,
653 sizeof(kgf
->gf_group
)) ||
654 (numsrc
&& copy_in_user(kgf
->gf_slist
, gf32
->gf_slist
,
655 numsrc
* sizeof(kgf
->gf_slist
[0]))))
657 koptval
= (char __user
*)kgf
;
664 return setsockopt(sock
, level
, optname
, koptval
, koptlen
);
666 EXPORT_SYMBOL(compat_mc_setsockopt
);
668 int compat_mc_getsockopt(struct sock
*sock
, int level
, int optname
,
669 char __user
*optval
, int __user
*optlen
,
670 int (*getsockopt
)(struct sock
*, int, int, char __user
*, int __user
*))
672 struct compat_group_filter __user
*gf32
= (void *)optval
;
673 struct group_filter __user
*kgf
;
675 u32 interface
, fmode
, numsrc
;
678 if (optname
!= MCAST_MSFILTER
)
679 return getsockopt(sock
, level
, optname
, optval
, optlen
);
681 koptlen
= compat_alloc_user_space(sizeof(*koptlen
));
682 if (!access_ok(optlen
, sizeof(*optlen
)) ||
683 __get_user(ulen
, optlen
))
686 /* adjust len for pad */
687 klen
= ulen
+ sizeof(*kgf
) - sizeof(*gf32
);
689 if (klen
< GROUP_FILTER_SIZE(0))
692 if (!access_ok(koptlen
, sizeof(*koptlen
)) ||
693 __put_user(klen
, koptlen
))
696 /* have to allow space for previous compat_alloc_user_space, too */
697 kgf
= compat_alloc_user_space(klen
+sizeof(*optlen
));
699 if (!access_ok(gf32
, __COMPAT_GF0_SIZE
) ||
700 __get_user(interface
, &gf32
->gf_interface
) ||
701 __get_user(fmode
, &gf32
->gf_fmode
) ||
702 __get_user(numsrc
, &gf32
->gf_numsrc
) ||
703 __put_user(interface
, &kgf
->gf_interface
) ||
704 __put_user(fmode
, &kgf
->gf_fmode
) ||
705 __put_user(numsrc
, &kgf
->gf_numsrc
) ||
706 copy_in_user(&kgf
->gf_group
, &gf32
->gf_group
, sizeof(kgf
->gf_group
)))
709 err
= getsockopt(sock
, level
, optname
, (char __user
*)kgf
, koptlen
);
713 if (!access_ok(koptlen
, sizeof(*koptlen
)) ||
714 __get_user(klen
, koptlen
))
717 ulen
= klen
- (sizeof(*kgf
)-sizeof(*gf32
));
719 if (!access_ok(optlen
, sizeof(*optlen
)) ||
720 __put_user(ulen
, optlen
))
723 if (!access_ok(kgf
, klen
) ||
724 !access_ok(gf32
, ulen
) ||
725 __get_user(interface
, &kgf
->gf_interface
) ||
726 __get_user(fmode
, &kgf
->gf_fmode
) ||
727 __get_user(numsrc
, &kgf
->gf_numsrc
) ||
728 __put_user(interface
, &gf32
->gf_interface
) ||
729 __put_user(fmode
, &gf32
->gf_fmode
) ||
730 __put_user(numsrc
, &gf32
->gf_numsrc
))
735 klen
-= GROUP_FILTER_SIZE(0);
736 copylen
= numsrc
* sizeof(gf32
->gf_slist
[0]);
739 if (copy_in_user(gf32
->gf_slist
, kgf
->gf_slist
, copylen
))
744 EXPORT_SYMBOL(compat_mc_getsockopt
);
747 /* Argument list sizes for compat_sys_socketcall */
748 #define AL(x) ((x) * sizeof(u32))
749 static unsigned char nas
[21] = {
750 AL(0), AL(3), AL(3), AL(3), AL(2), AL(3),
751 AL(3), AL(3), AL(4), AL(4), AL(4), AL(6),
752 AL(6), AL(2), AL(5), AL(5), AL(3), AL(3),
757 static inline long __compat_sys_sendmsg(int fd
,
758 struct compat_msghdr __user
*msg
,
761 return __sys_sendmsg(fd
, (struct user_msghdr __user
*)msg
,
762 flags
| MSG_CMSG_COMPAT
, false);
765 COMPAT_SYSCALL_DEFINE3(sendmsg
, int, fd
, struct compat_msghdr __user
*, msg
,
768 return __compat_sys_sendmsg(fd
, msg
, flags
);
771 static inline long __compat_sys_sendmmsg(int fd
,
772 struct compat_mmsghdr __user
*mmsg
,
773 unsigned int vlen
, unsigned int flags
)
775 return __sys_sendmmsg(fd
, (struct mmsghdr __user
*)mmsg
, vlen
,
776 flags
| MSG_CMSG_COMPAT
, false);
779 COMPAT_SYSCALL_DEFINE4(sendmmsg
, int, fd
, struct compat_mmsghdr __user
*, mmsg
,
780 unsigned int, vlen
, unsigned int, flags
)
782 return __compat_sys_sendmmsg(fd
, mmsg
, vlen
, flags
);
785 static inline long __compat_sys_recvmsg(int fd
,
786 struct compat_msghdr __user
*msg
,
789 return __sys_recvmsg(fd
, (struct user_msghdr __user
*)msg
,
790 flags
| MSG_CMSG_COMPAT
, false);
793 COMPAT_SYSCALL_DEFINE3(recvmsg
, int, fd
, struct compat_msghdr __user
*, msg
,
796 return __compat_sys_recvmsg(fd
, msg
, flags
);
799 static inline long __compat_sys_recvfrom(int fd
, void __user
*buf
,
800 compat_size_t len
, unsigned int flags
,
801 struct sockaddr __user
*addr
,
804 return __sys_recvfrom(fd
, buf
, len
, flags
| MSG_CMSG_COMPAT
, addr
,
808 COMPAT_SYSCALL_DEFINE4(recv
, int, fd
, void __user
*, buf
, compat_size_t
, len
, unsigned int, flags
)
810 return __compat_sys_recvfrom(fd
, buf
, len
, flags
, NULL
, NULL
);
813 COMPAT_SYSCALL_DEFINE6(recvfrom
, int, fd
, void __user
*, buf
, compat_size_t
, len
,
814 unsigned int, flags
, struct sockaddr __user
*, addr
,
815 int __user
*, addrlen
)
817 return __compat_sys_recvfrom(fd
, buf
, len
, flags
, addr
, addrlen
);
820 COMPAT_SYSCALL_DEFINE5(recvmmsg_time64
, int, fd
, struct compat_mmsghdr __user
*, mmsg
,
821 unsigned int, vlen
, unsigned int, flags
,
822 struct __kernel_timespec __user
*, timeout
)
824 return __sys_recvmmsg(fd
, (struct mmsghdr __user
*)mmsg
, vlen
,
825 flags
| MSG_CMSG_COMPAT
, timeout
, NULL
);
828 #ifdef CONFIG_COMPAT_32BIT_TIME
829 COMPAT_SYSCALL_DEFINE5(recvmmsg
, int, fd
, struct compat_mmsghdr __user
*, mmsg
,
830 unsigned int, vlen
, unsigned int, flags
,
831 struct old_timespec32 __user
*, timeout
)
833 return __sys_recvmmsg(fd
, (struct mmsghdr __user
*)mmsg
, vlen
,
834 flags
| MSG_CMSG_COMPAT
, NULL
, timeout
);
838 COMPAT_SYSCALL_DEFINE2(socketcall
, int, call
, u32 __user
*, args
)
845 if (call
< SYS_SOCKET
|| call
> SYS_SENDMMSG
)
851 if (copy_from_user(a
, args
, len
))
854 ret
= audit_socketcall_compat(len
/ sizeof(a
[0]), a
);
863 ret
= __sys_socket(a0
, a1
, a
[2]);
866 ret
= __sys_bind(a0
, compat_ptr(a1
), a
[2]);
869 ret
= __sys_connect(a0
, compat_ptr(a1
), a
[2]);
872 ret
= __sys_listen(a0
, a1
);
875 ret
= __sys_accept4(a0
, compat_ptr(a1
), compat_ptr(a
[2]), 0);
877 case SYS_GETSOCKNAME
:
878 ret
= __sys_getsockname(a0
, compat_ptr(a1
), compat_ptr(a
[2]));
880 case SYS_GETPEERNAME
:
881 ret
= __sys_getpeername(a0
, compat_ptr(a1
), compat_ptr(a
[2]));
884 ret
= __sys_socketpair(a0
, a1
, a
[2], compat_ptr(a
[3]));
887 ret
= __sys_sendto(a0
, compat_ptr(a1
), a
[2], a
[3], NULL
, 0);
890 ret
= __sys_sendto(a0
, compat_ptr(a1
), a
[2], a
[3],
891 compat_ptr(a
[4]), a
[5]);
894 ret
= __compat_sys_recvfrom(a0
, compat_ptr(a1
), a
[2], a
[3],
898 ret
= __compat_sys_recvfrom(a0
, compat_ptr(a1
), a
[2], a
[3],
903 ret
= __sys_shutdown(a0
, a1
);
906 ret
= __compat_sys_setsockopt(a0
, a1
, a
[2],
907 compat_ptr(a
[3]), a
[4]);
910 ret
= __compat_sys_getsockopt(a0
, a1
, a
[2],
915 ret
= __compat_sys_sendmsg(a0
, compat_ptr(a1
), a
[2]);
918 ret
= __compat_sys_sendmmsg(a0
, compat_ptr(a1
), a
[2], a
[3]);
921 ret
= __compat_sys_recvmsg(a0
, compat_ptr(a1
), a
[2]);
924 ret
= __sys_recvmmsg(a0
, compat_ptr(a1
), a
[2],
925 a
[3] | MSG_CMSG_COMPAT
, NULL
,
929 ret
= __sys_accept4(a0
, compat_ptr(a1
), compat_ptr(a
[2]), a
[3]);