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>
30 #include <asm/uaccess.h>
31 #include <net/compat.h>
33 static inline int iov_from_user_compat_to_kern(struct iovec
*kiov
,
34 struct compat_iovec __user
*uiov32
,
43 if (get_user(len
, &uiov32
->iov_len
) ||
44 get_user(buf
, &uiov32
->iov_base
)) {
49 kiov
->iov_base
= compat_ptr(buf
);
50 kiov
->iov_len
= (__kernel_size_t
) len
;
58 int get_compat_msghdr(struct msghdr
*kmsg
, struct compat_msghdr __user
*umsg
)
60 compat_uptr_t tmp1
, tmp2
, tmp3
;
62 if (!access_ok(VERIFY_READ
, umsg
, sizeof(*umsg
)) ||
63 __get_user(tmp1
, &umsg
->msg_name
) ||
64 __get_user(kmsg
->msg_namelen
, &umsg
->msg_namelen
) ||
65 __get_user(tmp2
, &umsg
->msg_iov
) ||
66 __get_user(kmsg
->msg_iovlen
, &umsg
->msg_iovlen
) ||
67 __get_user(tmp3
, &umsg
->msg_control
) ||
68 __get_user(kmsg
->msg_controllen
, &umsg
->msg_controllen
) ||
69 __get_user(kmsg
->msg_flags
, &umsg
->msg_flags
))
71 kmsg
->msg_name
= compat_ptr(tmp1
);
72 kmsg
->msg_iov
= compat_ptr(tmp2
);
73 kmsg
->msg_control
= compat_ptr(tmp3
);
77 /* I've named the args so it is easy to tell whose space the pointers are in. */
78 int verify_compat_iovec(struct msghdr
*kern_msg
, struct iovec
*kern_iov
,
79 struct sockaddr
*kern_address
, int mode
)
83 if (kern_msg
->msg_namelen
) {
84 if (mode
==VERIFY_READ
) {
85 int err
= move_addr_to_kernel(kern_msg
->msg_name
,
86 kern_msg
->msg_namelen
,
91 kern_msg
->msg_name
= kern_address
;
93 kern_msg
->msg_name
= NULL
;
95 tot_len
= iov_from_user_compat_to_kern(kern_iov
,
96 (struct compat_iovec __user
*)kern_msg
->msg_iov
,
97 kern_msg
->msg_iovlen
);
99 kern_msg
->msg_iov
= kern_iov
;
105 #define CMSG_COMPAT_ALIGN(len) ALIGN((len), sizeof(s32))
107 #define CMSG_COMPAT_DATA(cmsg) \
108 ((void __user *)((char __user *)(cmsg) + CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr))))
109 #define CMSG_COMPAT_SPACE(len) \
110 (CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr)) + CMSG_COMPAT_ALIGN(len))
111 #define CMSG_COMPAT_LEN(len) \
112 (CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr)) + (len))
114 #define CMSG_COMPAT_FIRSTHDR(msg) \
115 (((msg)->msg_controllen) >= sizeof(struct compat_cmsghdr) ? \
116 (struct compat_cmsghdr __user *)((msg)->msg_control) : \
117 (struct compat_cmsghdr __user *)NULL)
119 #define CMSG_COMPAT_OK(ucmlen, ucmsg, mhdr) \
120 ((ucmlen) >= sizeof(struct compat_cmsghdr) && \
121 (ucmlen) <= (unsigned long) \
122 ((mhdr)->msg_controllen - \
123 ((char *)(ucmsg) - (char *)(mhdr)->msg_control)))
125 static inline struct compat_cmsghdr __user
*cmsg_compat_nxthdr(struct msghdr
*msg
,
126 struct compat_cmsghdr __user
*cmsg
, int cmsg_len
)
128 char __user
*ptr
= (char __user
*)cmsg
+ CMSG_COMPAT_ALIGN(cmsg_len
);
129 if ((unsigned long)(ptr
+ 1 - (char __user
*)msg
->msg_control
) >
132 return (struct compat_cmsghdr __user
*)ptr
;
135 /* There is a lot of hair here because the alignment rules (and
136 * thus placement) of cmsg headers and length are different for
137 * 32-bit apps. -DaveM
139 int cmsghdr_from_user_compat_to_kern(struct msghdr
*kmsg
, struct sock
*sk
,
140 unsigned char *stackbuf
, int stackbuf_size
)
142 struct compat_cmsghdr __user
*ucmsg
;
143 struct cmsghdr
*kcmsg
, *kcmsg_base
;
144 compat_size_t ucmlen
;
145 __kernel_size_t kcmlen
, tmp
;
149 kcmsg_base
= kcmsg
= (struct cmsghdr
*)stackbuf
;
150 ucmsg
= CMSG_COMPAT_FIRSTHDR(kmsg
);
151 while (ucmsg
!= NULL
) {
152 if (get_user(ucmlen
, &ucmsg
->cmsg_len
))
156 if (!CMSG_COMPAT_OK(ucmlen
, ucmsg
, kmsg
))
159 tmp
= ((ucmlen
- CMSG_COMPAT_ALIGN(sizeof(*ucmsg
))) +
160 CMSG_ALIGN(sizeof(struct cmsghdr
)));
161 tmp
= CMSG_ALIGN(tmp
);
163 ucmsg
= cmsg_compat_nxthdr(kmsg
, ucmsg
, ucmlen
);
168 /* The kcmlen holds the 64-bit version of the control length.
169 * It may not be modified as we do not stick it into the kmsg
170 * until we have successfully copied over all of the data
173 if (kcmlen
> stackbuf_size
)
174 kcmsg_base
= kcmsg
= sock_kmalloc(sk
, kcmlen
, GFP_KERNEL
);
178 /* Now copy them over neatly. */
179 memset(kcmsg
, 0, kcmlen
);
180 ucmsg
= CMSG_COMPAT_FIRSTHDR(kmsg
);
181 while (ucmsg
!= NULL
) {
182 if (__get_user(ucmlen
, &ucmsg
->cmsg_len
))
184 if (!CMSG_COMPAT_OK(ucmlen
, ucmsg
, kmsg
))
186 tmp
= ((ucmlen
- CMSG_COMPAT_ALIGN(sizeof(*ucmsg
))) +
187 CMSG_ALIGN(sizeof(struct cmsghdr
)));
188 if ((char *)kcmsg_base
+ kcmlen
- (char *)kcmsg
< CMSG_ALIGN(tmp
))
190 kcmsg
->cmsg_len
= tmp
;
191 tmp
= CMSG_ALIGN(tmp
);
192 if (__get_user(kcmsg
->cmsg_level
, &ucmsg
->cmsg_level
) ||
193 __get_user(kcmsg
->cmsg_type
, &ucmsg
->cmsg_type
) ||
194 copy_from_user(CMSG_DATA(kcmsg
),
195 CMSG_COMPAT_DATA(ucmsg
),
196 (ucmlen
- CMSG_COMPAT_ALIGN(sizeof(*ucmsg
)))))
200 kcmsg
= (struct cmsghdr
*)((char *)kcmsg
+ tmp
);
201 ucmsg
= cmsg_compat_nxthdr(kmsg
, ucmsg
, ucmlen
);
204 /* Ok, looks like we made it. Hook it up and return success. */
205 kmsg
->msg_control
= kcmsg_base
;
206 kmsg
->msg_controllen
= kcmlen
;
212 if (kcmsg_base
!= (struct cmsghdr
*)stackbuf
)
213 sock_kfree_s(sk
, kcmsg_base
, kcmlen
);
217 int put_cmsg_compat(struct msghdr
*kmsg
, int level
, int type
, int len
, void *data
)
219 struct compat_timeval ctv
;
220 struct compat_timespec cts
[3];
221 struct compat_cmsghdr __user
*cm
= (struct compat_cmsghdr __user
*) kmsg
->msg_control
;
222 struct compat_cmsghdr cmhdr
;
225 if (cm
== NULL
|| kmsg
->msg_controllen
< sizeof(*cm
)) {
226 kmsg
->msg_flags
|= MSG_CTRUNC
;
227 return 0; /* XXX: return error? check spec. */
230 if (level
== SOL_SOCKET
&& type
== SCM_TIMESTAMP
) {
231 struct timeval
*tv
= (struct timeval
*)data
;
232 ctv
.tv_sec
= tv
->tv_sec
;
233 ctv
.tv_usec
= tv
->tv_usec
;
237 if (level
== SOL_SOCKET
&&
238 (type
== SCM_TIMESTAMPNS
|| type
== SCM_TIMESTAMPING
)) {
239 int count
= type
== SCM_TIMESTAMPNS
? 1 : 3;
241 struct timespec
*ts
= (struct timespec
*)data
;
242 for (i
= 0; i
< count
; i
++) {
243 cts
[i
].tv_sec
= ts
[i
].tv_sec
;
244 cts
[i
].tv_nsec
= ts
[i
].tv_nsec
;
247 len
= sizeof(cts
[0]) * count
;
250 cmlen
= CMSG_COMPAT_LEN(len
);
251 if (kmsg
->msg_controllen
< cmlen
) {
252 kmsg
->msg_flags
|= MSG_CTRUNC
;
253 cmlen
= kmsg
->msg_controllen
;
255 cmhdr
.cmsg_level
= level
;
256 cmhdr
.cmsg_type
= type
;
257 cmhdr
.cmsg_len
= cmlen
;
259 if (copy_to_user(cm
, &cmhdr
, sizeof cmhdr
))
261 if (copy_to_user(CMSG_COMPAT_DATA(cm
), data
, cmlen
- sizeof(struct compat_cmsghdr
)))
263 cmlen
= CMSG_COMPAT_SPACE(len
);
264 if (kmsg
->msg_controllen
< cmlen
)
265 cmlen
= kmsg
->msg_controllen
;
266 kmsg
->msg_control
+= cmlen
;
267 kmsg
->msg_controllen
-= cmlen
;
271 void scm_detach_fds_compat(struct msghdr
*kmsg
, struct scm_cookie
*scm
)
273 struct compat_cmsghdr __user
*cm
= (struct compat_cmsghdr __user
*) kmsg
->msg_control
;
274 int fdmax
= (kmsg
->msg_controllen
- sizeof(struct compat_cmsghdr
)) / sizeof(int);
275 int fdnum
= scm
->fp
->count
;
276 struct file
**fp
= scm
->fp
->fp
;
283 for (i
= 0, cmfptr
= (int __user
*) CMSG_COMPAT_DATA(cm
); i
< fdmax
; i
++, cmfptr
++) {
285 err
= security_file_receive(fp
[i
]);
288 err
= get_unused_fd_flags(MSG_CMSG_CLOEXEC
& kmsg
->msg_flags
293 err
= put_user(new_fd
, cmfptr
);
295 put_unused_fd(new_fd
);
298 /* Bump the usage count and install the file. */
300 fd_install(new_fd
, fp
[i
]);
304 int cmlen
= CMSG_COMPAT_LEN(i
* sizeof(int));
305 err
= put_user(SOL_SOCKET
, &cm
->cmsg_level
);
307 err
= put_user(SCM_RIGHTS
, &cm
->cmsg_type
);
309 err
= put_user(cmlen
, &cm
->cmsg_len
);
311 cmlen
= CMSG_COMPAT_SPACE(i
* sizeof(int));
312 kmsg
->msg_control
+= cmlen
;
313 kmsg
->msg_controllen
-= cmlen
;
317 kmsg
->msg_flags
|= MSG_CTRUNC
;
320 * All of the files that fit in the message have had their
321 * usage counts incremented, so we just free the list.
327 * A struct sock_filter is architecture independent.
329 struct compat_sock_fprog
{
331 compat_uptr_t filter
; /* struct sock_filter * */
334 static int do_set_attach_filter(struct socket
*sock
, int level
, int optname
,
335 char __user
*optval
, unsigned int optlen
)
337 struct compat_sock_fprog __user
*fprog32
= (struct compat_sock_fprog __user
*)optval
;
338 struct sock_fprog __user
*kfprog
= compat_alloc_user_space(sizeof(struct sock_fprog
));
342 if (!access_ok(VERIFY_READ
, fprog32
, sizeof(*fprog32
)) ||
343 !access_ok(VERIFY_WRITE
, kfprog
, sizeof(struct sock_fprog
)) ||
344 __get_user(len
, &fprog32
->len
) ||
345 __get_user(ptr
, &fprog32
->filter
) ||
346 __put_user(len
, &kfprog
->len
) ||
347 __put_user(compat_ptr(ptr
), &kfprog
->filter
))
350 return sock_setsockopt(sock
, level
, optname
, (char __user
*)kfprog
,
351 sizeof(struct sock_fprog
));
354 static int do_set_sock_timeout(struct socket
*sock
, int level
,
355 int optname
, char __user
*optval
, unsigned int optlen
)
357 struct compat_timeval __user
*up
= (struct compat_timeval __user
*) optval
;
358 struct timeval ktime
;
362 if (optlen
< sizeof(*up
))
364 if (!access_ok(VERIFY_READ
, up
, sizeof(*up
)) ||
365 __get_user(ktime
.tv_sec
, &up
->tv_sec
) ||
366 __get_user(ktime
.tv_usec
, &up
->tv_usec
))
370 err
= sock_setsockopt(sock
, level
, optname
, (char *) &ktime
, sizeof(ktime
));
376 static int compat_sock_setsockopt(struct socket
*sock
, int level
, int optname
,
377 char __user
*optval
, unsigned int optlen
)
379 if (optname
== SO_ATTACH_FILTER
)
380 return do_set_attach_filter(sock
, level
, optname
,
382 if (optname
== SO_RCVTIMEO
|| optname
== SO_SNDTIMEO
)
383 return do_set_sock_timeout(sock
, level
, optname
, optval
, optlen
);
385 return sock_setsockopt(sock
, level
, optname
, optval
, optlen
);
388 asmlinkage
long compat_sys_setsockopt(int fd
, int level
, int optname
,
389 char __user
*optval
, unsigned int optlen
)
394 if ((sock
= sockfd_lookup(fd
, &err
))!=NULL
)
396 err
= security_socket_setsockopt(sock
,level
,optname
);
402 if (level
== SOL_SOCKET
)
403 err
= compat_sock_setsockopt(sock
, level
,
404 optname
, optval
, optlen
);
405 else if (sock
->ops
->compat_setsockopt
)
406 err
= sock
->ops
->compat_setsockopt(sock
, level
,
407 optname
, optval
, optlen
);
409 err
= sock
->ops
->setsockopt(sock
, level
,
410 optname
, optval
, optlen
);
416 static int do_get_sock_timeout(struct socket
*sock
, int level
, int optname
,
417 char __user
*optval
, int __user
*optlen
)
419 struct compat_timeval __user
*up
;
420 struct timeval ktime
;
424 up
= (struct compat_timeval __user
*) optval
;
425 if (get_user(len
, optlen
))
427 if (len
< sizeof(*up
))
432 err
= sock_getsockopt(sock
, level
, optname
, (char *) &ktime
, &len
);
436 if (put_user(sizeof(*up
), optlen
) ||
437 !access_ok(VERIFY_WRITE
, up
, sizeof(*up
)) ||
438 __put_user(ktime
.tv_sec
, &up
->tv_sec
) ||
439 __put_user(ktime
.tv_usec
, &up
->tv_usec
))
445 static int compat_sock_getsockopt(struct socket
*sock
, int level
, int optname
,
446 char __user
*optval
, int __user
*optlen
)
448 if (optname
== SO_RCVTIMEO
|| optname
== SO_SNDTIMEO
)
449 return do_get_sock_timeout(sock
, level
, optname
, optval
, optlen
);
450 return sock_getsockopt(sock
, level
, optname
, optval
, optlen
);
453 int compat_sock_get_timestamp(struct sock
*sk
, struct timeval __user
*userstamp
)
455 struct compat_timeval __user
*ctv
=
456 (struct compat_timeval __user
*) userstamp
;
460 if (!sock_flag(sk
, SOCK_TIMESTAMP
))
461 sock_enable_timestamp(sk
, SOCK_TIMESTAMP
);
462 tv
= ktime_to_timeval(sk
->sk_stamp
);
465 if (tv
.tv_sec
== 0) {
466 sk
->sk_stamp
= ktime_get_real();
467 tv
= ktime_to_timeval(sk
->sk_stamp
);
470 if (put_user(tv
.tv_sec
, &ctv
->tv_sec
) ||
471 put_user(tv
.tv_usec
, &ctv
->tv_usec
))
475 EXPORT_SYMBOL(compat_sock_get_timestamp
);
477 int compat_sock_get_timestampns(struct sock
*sk
, struct timespec __user
*userstamp
)
479 struct compat_timespec __user
*ctv
=
480 (struct compat_timespec __user
*) userstamp
;
484 if (!sock_flag(sk
, SOCK_TIMESTAMP
))
485 sock_enable_timestamp(sk
, SOCK_TIMESTAMP
);
486 ts
= ktime_to_timespec(sk
->sk_stamp
);
489 if (ts
.tv_sec
== 0) {
490 sk
->sk_stamp
= ktime_get_real();
491 ts
= ktime_to_timespec(sk
->sk_stamp
);
494 if (put_user(ts
.tv_sec
, &ctv
->tv_sec
) ||
495 put_user(ts
.tv_nsec
, &ctv
->tv_nsec
))
499 EXPORT_SYMBOL(compat_sock_get_timestampns
);
501 asmlinkage
long compat_sys_getsockopt(int fd
, int level
, int optname
,
502 char __user
*optval
, int __user
*optlen
)
507 if ((sock
= sockfd_lookup(fd
, &err
))!=NULL
)
509 err
= security_socket_getsockopt(sock
, level
,
516 if (level
== SOL_SOCKET
)
517 err
= compat_sock_getsockopt(sock
, level
,
518 optname
, optval
, optlen
);
519 else if (sock
->ops
->compat_getsockopt
)
520 err
= sock
->ops
->compat_getsockopt(sock
, level
,
521 optname
, optval
, optlen
);
523 err
= sock
->ops
->getsockopt(sock
, level
,
524 optname
, optval
, optlen
);
530 struct compat_group_req
{
532 struct __kernel_sockaddr_storage gr_group
533 __attribute__ ((aligned(4)));
534 } __attribute__ ((packed
));
536 struct compat_group_source_req
{
538 struct __kernel_sockaddr_storage gsr_group
539 __attribute__ ((aligned(4)));
540 struct __kernel_sockaddr_storage gsr_source
541 __attribute__ ((aligned(4)));
542 } __attribute__ ((packed
));
544 struct compat_group_filter
{
546 struct __kernel_sockaddr_storage gf_group
547 __attribute__ ((aligned(4)));
550 struct __kernel_sockaddr_storage gf_slist
[1]
551 __attribute__ ((aligned(4)));
552 } __attribute__ ((packed
));
554 #define __COMPAT_GF0_SIZE (sizeof(struct compat_group_filter) - \
555 sizeof(struct __kernel_sockaddr_storage))
558 int compat_mc_setsockopt(struct sock
*sock
, int level
, int optname
,
559 char __user
*optval
, unsigned int optlen
,
560 int (*setsockopt
)(struct sock
*,int,int,char __user
*,unsigned int))
562 char __user
*koptval
= optval
;
563 int koptlen
= optlen
;
566 case MCAST_JOIN_GROUP
:
567 case MCAST_LEAVE_GROUP
:
569 struct compat_group_req __user
*gr32
= (void *)optval
;
570 struct group_req __user
*kgr
=
571 compat_alloc_user_space(sizeof(struct group_req
));
574 if (!access_ok(VERIFY_READ
, gr32
, sizeof(*gr32
)) ||
575 !access_ok(VERIFY_WRITE
, kgr
, sizeof(struct group_req
)) ||
576 __get_user(interface
, &gr32
->gr_interface
) ||
577 __put_user(interface
, &kgr
->gr_interface
) ||
578 copy_in_user(&kgr
->gr_group
, &gr32
->gr_group
,
579 sizeof(kgr
->gr_group
)))
581 koptval
= (char __user
*)kgr
;
582 koptlen
= sizeof(struct group_req
);
585 case MCAST_JOIN_SOURCE_GROUP
:
586 case MCAST_LEAVE_SOURCE_GROUP
:
587 case MCAST_BLOCK_SOURCE
:
588 case MCAST_UNBLOCK_SOURCE
:
590 struct compat_group_source_req __user
*gsr32
= (void *)optval
;
591 struct group_source_req __user
*kgsr
= compat_alloc_user_space(
592 sizeof(struct group_source_req
));
595 if (!access_ok(VERIFY_READ
, gsr32
, sizeof(*gsr32
)) ||
596 !access_ok(VERIFY_WRITE
, kgsr
,
597 sizeof(struct group_source_req
)) ||
598 __get_user(interface
, &gsr32
->gsr_interface
) ||
599 __put_user(interface
, &kgsr
->gsr_interface
) ||
600 copy_in_user(&kgsr
->gsr_group
, &gsr32
->gsr_group
,
601 sizeof(kgsr
->gsr_group
)) ||
602 copy_in_user(&kgsr
->gsr_source
, &gsr32
->gsr_source
,
603 sizeof(kgsr
->gsr_source
)))
605 koptval
= (char __user
*)kgsr
;
606 koptlen
= sizeof(struct group_source_req
);
611 struct compat_group_filter __user
*gf32
= (void *)optval
;
612 struct group_filter __user
*kgf
;
613 u32 interface
, fmode
, numsrc
;
615 if (!access_ok(VERIFY_READ
, gf32
, __COMPAT_GF0_SIZE
) ||
616 __get_user(interface
, &gf32
->gf_interface
) ||
617 __get_user(fmode
, &gf32
->gf_fmode
) ||
618 __get_user(numsrc
, &gf32
->gf_numsrc
))
620 koptlen
= optlen
+ sizeof(struct group_filter
) -
621 sizeof(struct compat_group_filter
);
622 if (koptlen
< GROUP_FILTER_SIZE(numsrc
))
624 kgf
= compat_alloc_user_space(koptlen
);
625 if (!access_ok(VERIFY_WRITE
, kgf
, koptlen
) ||
626 __put_user(interface
, &kgf
->gf_interface
) ||
627 __put_user(fmode
, &kgf
->gf_fmode
) ||
628 __put_user(numsrc
, &kgf
->gf_numsrc
) ||
629 copy_in_user(&kgf
->gf_group
, &gf32
->gf_group
,
630 sizeof(kgf
->gf_group
)) ||
631 (numsrc
&& copy_in_user(kgf
->gf_slist
, gf32
->gf_slist
,
632 numsrc
* sizeof(kgf
->gf_slist
[0]))))
634 koptval
= (char __user
*)kgf
;
641 return setsockopt(sock
, level
, optname
, koptval
, koptlen
);
644 EXPORT_SYMBOL(compat_mc_setsockopt
);
646 int compat_mc_getsockopt(struct sock
*sock
, int level
, int optname
,
647 char __user
*optval
, int __user
*optlen
,
648 int (*getsockopt
)(struct sock
*,int,int,char __user
*,int __user
*))
650 struct compat_group_filter __user
*gf32
= (void *)optval
;
651 struct group_filter __user
*kgf
;
653 u32 interface
, fmode
, numsrc
;
656 if (optname
!= MCAST_MSFILTER
)
657 return getsockopt(sock
, level
, optname
, optval
, optlen
);
659 koptlen
= compat_alloc_user_space(sizeof(*koptlen
));
660 if (!access_ok(VERIFY_READ
, optlen
, sizeof(*optlen
)) ||
661 __get_user(ulen
, optlen
))
664 /* adjust len for pad */
665 klen
= ulen
+ sizeof(*kgf
) - sizeof(*gf32
);
667 if (klen
< GROUP_FILTER_SIZE(0))
670 if (!access_ok(VERIFY_WRITE
, koptlen
, sizeof(*koptlen
)) ||
671 __put_user(klen
, koptlen
))
674 /* have to allow space for previous compat_alloc_user_space, too */
675 kgf
= compat_alloc_user_space(klen
+sizeof(*optlen
));
677 if (!access_ok(VERIFY_READ
, gf32
, __COMPAT_GF0_SIZE
) ||
678 __get_user(interface
, &gf32
->gf_interface
) ||
679 __get_user(fmode
, &gf32
->gf_fmode
) ||
680 __get_user(numsrc
, &gf32
->gf_numsrc
) ||
681 __put_user(interface
, &kgf
->gf_interface
) ||
682 __put_user(fmode
, &kgf
->gf_fmode
) ||
683 __put_user(numsrc
, &kgf
->gf_numsrc
) ||
684 copy_in_user(&kgf
->gf_group
,&gf32
->gf_group
,sizeof(kgf
->gf_group
)))
687 err
= getsockopt(sock
, level
, optname
, (char __user
*)kgf
, koptlen
);
691 if (!access_ok(VERIFY_READ
, koptlen
, sizeof(*koptlen
)) ||
692 __get_user(klen
, koptlen
))
695 ulen
= klen
- (sizeof(*kgf
)-sizeof(*gf32
));
697 if (!access_ok(VERIFY_WRITE
, optlen
, sizeof(*optlen
)) ||
698 __put_user(ulen
, optlen
))
701 if (!access_ok(VERIFY_READ
, kgf
, klen
) ||
702 !access_ok(VERIFY_WRITE
, gf32
, ulen
) ||
703 __get_user(interface
, &kgf
->gf_interface
) ||
704 __get_user(fmode
, &kgf
->gf_fmode
) ||
705 __get_user(numsrc
, &kgf
->gf_numsrc
) ||
706 __put_user(interface
, &gf32
->gf_interface
) ||
707 __put_user(fmode
, &gf32
->gf_fmode
) ||
708 __put_user(numsrc
, &gf32
->gf_numsrc
))
713 klen
-= GROUP_FILTER_SIZE(0);
714 copylen
= numsrc
* sizeof(gf32
->gf_slist
[0]);
717 if (copy_in_user(gf32
->gf_slist
, kgf
->gf_slist
, copylen
))
723 EXPORT_SYMBOL(compat_mc_getsockopt
);
726 /* Argument list sizes for compat_sys_socketcall */
727 #define AL(x) ((x) * sizeof(u32))
728 static unsigned char nas
[20]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
729 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
730 AL(6),AL(2),AL(5),AL(5),AL(3),AL(3),
734 asmlinkage
long compat_sys_sendmsg(int fd
, struct compat_msghdr __user
*msg
, unsigned flags
)
736 return sys_sendmsg(fd
, (struct msghdr __user
*)msg
, flags
| MSG_CMSG_COMPAT
);
739 asmlinkage
long compat_sys_recvmsg(int fd
, struct compat_msghdr __user
*msg
, unsigned int flags
)
741 return sys_recvmsg(fd
, (struct msghdr __user
*)msg
, flags
| MSG_CMSG_COMPAT
);
744 asmlinkage
long compat_sys_recv(int fd
, void __user
*buf
, size_t len
, unsigned flags
)
746 return sys_recv(fd
, buf
, len
, flags
| MSG_CMSG_COMPAT
);
749 asmlinkage
long compat_sys_recvfrom(int fd
, void __user
*buf
, size_t len
,
750 unsigned flags
, struct sockaddr __user
*addr
,
753 return sys_recvfrom(fd
, buf
, len
, flags
| MSG_CMSG_COMPAT
, addr
, addrlen
);
756 asmlinkage
long compat_sys_recvmmsg(int fd
, struct compat_mmsghdr __user
*mmsg
,
757 unsigned vlen
, unsigned int flags
,
758 struct compat_timespec __user
*timeout
)
761 struct timespec ktspec
;
764 return __sys_recvmmsg(fd
, (struct mmsghdr __user
*)mmsg
, vlen
,
765 flags
| MSG_CMSG_COMPAT
, NULL
);
767 if (get_compat_timespec(&ktspec
, timeout
))
770 datagrams
= __sys_recvmmsg(fd
, (struct mmsghdr __user
*)mmsg
, vlen
,
771 flags
| MSG_CMSG_COMPAT
, &ktspec
);
772 if (datagrams
> 0 && put_compat_timespec(&ktspec
, timeout
))
778 asmlinkage
long compat_sys_socketcall(int call
, u32 __user
*args
)
784 if (call
< SYS_SOCKET
|| call
> SYS_RECVMMSG
)
786 if (copy_from_user(a
, args
, nas
[call
]))
793 ret
= sys_socket(a0
, a1
, a
[2]);
796 ret
= sys_bind(a0
, compat_ptr(a1
), a
[2]);
799 ret
= sys_connect(a0
, compat_ptr(a1
), a
[2]);
802 ret
= sys_listen(a0
, a1
);
805 ret
= sys_accept4(a0
, compat_ptr(a1
), compat_ptr(a
[2]), 0);
807 case SYS_GETSOCKNAME
:
808 ret
= sys_getsockname(a0
, compat_ptr(a1
), compat_ptr(a
[2]));
810 case SYS_GETPEERNAME
:
811 ret
= sys_getpeername(a0
, compat_ptr(a1
), compat_ptr(a
[2]));
814 ret
= sys_socketpair(a0
, a1
, a
[2], compat_ptr(a
[3]));
817 ret
= sys_send(a0
, compat_ptr(a1
), a
[2], a
[3]);
820 ret
= sys_sendto(a0
, compat_ptr(a1
), a
[2], a
[3], compat_ptr(a
[4]), a
[5]);
823 ret
= compat_sys_recv(a0
, compat_ptr(a1
), a
[2], a
[3]);
826 ret
= compat_sys_recvfrom(a0
, compat_ptr(a1
), a
[2], a
[3],
827 compat_ptr(a
[4]), compat_ptr(a
[5]));
830 ret
= sys_shutdown(a0
,a1
);
833 ret
= compat_sys_setsockopt(a0
, a1
, a
[2],
834 compat_ptr(a
[3]), a
[4]);
837 ret
= compat_sys_getsockopt(a0
, a1
, a
[2],
838 compat_ptr(a
[3]), compat_ptr(a
[4]));
841 ret
= compat_sys_sendmsg(a0
, compat_ptr(a1
), a
[2]);
844 ret
= compat_sys_recvmsg(a0
, compat_ptr(a1
), a
[2]);
847 ret
= compat_sys_recvmmsg(a0
, compat_ptr(a1
), a
[2], a
[3],
851 ret
= sys_accept4(a0
, compat_ptr(a1
), compat_ptr(a
[2]), a
[3]);