~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/compat.c

Version: ~ [ linux-6.1-rc7 ] ~ [ linux-6.0.10 ] ~ [ linux-5.19.17 ] ~ [ linux-5.18.19 ] ~ [ linux-5.17.15 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.80 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.156 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.225 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.267 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.300 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.334 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * 32bit Socket syscall emulation. Based on arch/sparc64/kernel/sys_sparc32.c.
  3  *
  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
 12  */
 13 
 14 #include <linux/kernel.h>
 15 #include <linux/gfp.h>
 16 #include <linux/fs.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>
 27 
 28 #include <net/scm.h>
 29 #include <net/sock.h>
 30 #include <net/ip.h>
 31 #include <net/ipv6.h>
 32 #include <asm/uaccess.h>
 33 #include <net/compat.h>
 34 
 35 int get_compat_msghdr(struct msghdr *kmsg,
 36                       struct compat_msghdr __user *umsg,
 37                       struct sockaddr __user **save_addr,
 38                       struct iovec **iov)
 39 {
 40         compat_uptr_t uaddr, uiov, tmp3;
 41         compat_size_t nr_segs;
 42         ssize_t err;
 43 
 44         if (!access_ok(VERIFY_READ, umsg, sizeof(*umsg)) ||
 45             __get_user(uaddr, &umsg->msg_name) ||
 46             __get_user(kmsg->msg_namelen, &umsg->msg_namelen) ||
 47             __get_user(uiov, &umsg->msg_iov) ||
 48             __get_user(nr_segs, &umsg->msg_iovlen) ||
 49             __get_user(tmp3, &umsg->msg_control) ||
 50             __get_user(kmsg->msg_controllen, &umsg->msg_controllen) ||
 51             __get_user(kmsg->msg_flags, &umsg->msg_flags))
 52                 return -EFAULT;
 53 
 54         if (!uaddr)
 55                 kmsg->msg_namelen = 0;
 56 
 57         if (kmsg->msg_namelen < 0)
 58                 return -EINVAL;
 59 
 60         if (kmsg->msg_namelen > sizeof(struct sockaddr_storage))
 61                 kmsg->msg_namelen = sizeof(struct sockaddr_storage);
 62         kmsg->msg_control = compat_ptr(tmp3);
 63 
 64         if (save_addr)
 65                 *save_addr = compat_ptr(uaddr);
 66 
 67         if (uaddr && kmsg->msg_namelen) {
 68                 if (!save_addr) {
 69                         err = move_addr_to_kernel(compat_ptr(uaddr),
 70                                                   kmsg->msg_namelen,
 71                                                   kmsg->msg_name);
 72                         if (err < 0)
 73                                 return err;
 74                 }
 75         } else {
 76                 kmsg->msg_name = NULL;
 77                 kmsg->msg_namelen = 0;
 78         }
 79 
 80         if (nr_segs > UIO_MAXIOV)
 81                 return -EMSGSIZE;
 82 
 83         kmsg->msg_iocb = NULL;
 84 
 85         return compat_import_iovec(save_addr ? READ : WRITE,
 86                                    compat_ptr(uiov), nr_segs,
 87                                    UIO_FASTIOV, iov, &kmsg->msg_iter);
 88 }
 89 
 90 /* Bleech... */
 91 #define CMSG_COMPAT_ALIGN(len)  ALIGN((len), sizeof(s32))
 92 
 93 #define CMSG_COMPAT_DATA(cmsg)                          \
 94         ((void __user *)((char __user *)(cmsg) + CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr))))
 95 #define CMSG_COMPAT_SPACE(len)                          \
 96         (CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr)) + CMSG_COMPAT_ALIGN(len))
 97 #define CMSG_COMPAT_LEN(len)                            \
 98         (CMSG_COMPAT_ALIGN(sizeof(struct compat_cmsghdr)) + (len))
 99 
100 #define CMSG_COMPAT_FIRSTHDR(msg)                       \
101         (((msg)->msg_controllen) >= sizeof(struct compat_cmsghdr) ?     \
102          (struct compat_cmsghdr __user *)((msg)->msg_control) :         \
103          (struct compat_cmsghdr __user *)NULL)
104 
105 #define CMSG_COMPAT_OK(ucmlen, ucmsg, mhdr) \
106         ((ucmlen) >= sizeof(struct compat_cmsghdr) && \
107          (ucmlen) <= (unsigned long) \
108          ((mhdr)->msg_controllen - \
109           ((char *)(ucmsg) - (char *)(mhdr)->msg_control)))
110 
111 static inline struct compat_cmsghdr __user *cmsg_compat_nxthdr(struct msghdr *msg,
112                 struct compat_cmsghdr __user *cmsg, int cmsg_len)
113 {
114         char __user *ptr = (char __user *)cmsg + CMSG_COMPAT_ALIGN(cmsg_len);
115         if ((unsigned long)(ptr + 1 - (char __user *)msg->msg_control) >
116                         msg->msg_controllen)
117                 return NULL;
118         return (struct compat_cmsghdr __user *)ptr;
119 }
120 
121 /* There is a lot of hair here because the alignment rules (and
122  * thus placement) of cmsg headers and length are different for
123  * 32-bit apps.  -DaveM
124  */
125 int cmsghdr_from_user_compat_to_kern(struct msghdr *kmsg, struct sock *sk,
126                                unsigned char *stackbuf, int stackbuf_size)
127 {
128         struct compat_cmsghdr __user *ucmsg;
129         struct cmsghdr *kcmsg, *kcmsg_base;
130         compat_size_t ucmlen;
131         __kernel_size_t kcmlen, tmp;
132         int err = -EFAULT;
133 
134         kcmlen = 0;
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))
139                         return -EFAULT;
140 
141                 /* Catch bogons. */
142                 if (!CMSG_COMPAT_OK(ucmlen, ucmsg, kmsg))
143                         return -EINVAL;
144 
145                 tmp = ((ucmlen - CMSG_COMPAT_ALIGN(sizeof(*ucmsg))) +
146                        CMSG_ALIGN(sizeof(struct cmsghdr)));
147                 tmp = CMSG_ALIGN(tmp);
148                 kcmlen += tmp;
149                 ucmsg = cmsg_compat_nxthdr(kmsg, ucmsg, ucmlen);
150         }
151         if (kcmlen == 0)
152                 return -EINVAL;
153 
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
157          * from the user.
158          */
159         if (kcmlen > stackbuf_size)
160                 kcmsg_base = kcmsg = sock_kmalloc(sk, kcmlen, GFP_KERNEL);
161         if (kcmsg == NULL)
162                 return -ENOMEM;
163 
164         /* Now copy them over neatly. */
165         memset(kcmsg, 0, kcmlen);
166         ucmsg = CMSG_COMPAT_FIRSTHDR(kmsg);
167         while (ucmsg != NULL) {
168                 if (__get_user(ucmlen, &ucmsg->cmsg_len))
169                         goto Efault;
170                 if (!CMSG_COMPAT_OK(ucmlen, ucmsg, kmsg))
171                         goto Einval;
172                 tmp = ((ucmlen - CMSG_COMPAT_ALIGN(sizeof(*ucmsg))) +
173                        CMSG_ALIGN(sizeof(struct cmsghdr)));
174                 if ((char *)kcmsg_base + kcmlen - (char *)kcmsg < CMSG_ALIGN(tmp))
175                         goto Einval;
176                 kcmsg->cmsg_len = tmp;
177                 tmp = CMSG_ALIGN(tmp);
178                 if (__get_user(kcmsg->cmsg_level, &ucmsg->cmsg_level) ||
179                     __get_user(kcmsg->cmsg_type, &ucmsg->cmsg_type) ||
180                     copy_from_user(CMSG_DATA(kcmsg),
181                                    CMSG_COMPAT_DATA(ucmsg),
182                                    (ucmlen - CMSG_COMPAT_ALIGN(sizeof(*ucmsg)))))
183                         goto Efault;
184 
185                 /* Advance. */
186                 kcmsg = (struct cmsghdr *)((char *)kcmsg + tmp);
187                 ucmsg = cmsg_compat_nxthdr(kmsg, ucmsg, ucmlen);
188         }
189 
190         /* Ok, looks like we made it.  Hook it up and return success. */
191         kmsg->msg_control = kcmsg_base;
192         kmsg->msg_controllen = kcmlen;
193         return 0;
194 
195 Einval:
196         err = -EINVAL;
197 Efault:
198         if (kcmsg_base != (struct cmsghdr *)stackbuf)
199                 sock_kfree_s(sk, kcmsg_base, kcmlen);
200         return err;
201 }
202 
203 int put_cmsg_compat(struct msghdr *kmsg, int level, int type, int len, void *data)
204 {
205         struct compat_cmsghdr __user *cm = (struct compat_cmsghdr __user *) kmsg->msg_control;
206         struct compat_cmsghdr cmhdr;
207         struct compat_timeval ctv;
208         struct compat_timespec cts[3];
209         int cmlen;
210 
211         if (cm == NULL || kmsg->msg_controllen < sizeof(*cm)) {
212                 kmsg->msg_flags |= MSG_CTRUNC;
213                 return 0; /* XXX: return error? check spec. */
214         }
215 
216         if (!COMPAT_USE_64BIT_TIME) {
217                 if (level == SOL_SOCKET && type == SCM_TIMESTAMP) {
218                         struct timeval *tv = (struct timeval *)data;
219                         ctv.tv_sec = tv->tv_sec;
220                         ctv.tv_usec = tv->tv_usec;
221                         data = &ctv;
222                         len = sizeof(ctv);
223                 }
224                 if (level == SOL_SOCKET &&
225                     (type == SCM_TIMESTAMPNS || type == SCM_TIMESTAMPING)) {
226                         int count = type == SCM_TIMESTAMPNS ? 1 : 3;
227                         int i;
228                         struct timespec *ts = (struct timespec *)data;
229                         for (i = 0; i < count; i++) {
230                                 cts[i].tv_sec = ts[i].tv_sec;
231                                 cts[i].tv_nsec = ts[i].tv_nsec;
232                         }
233                         data = &cts;
234                         len = sizeof(cts[0]) * count;
235                 }
236         }
237 
238         cmlen = CMSG_COMPAT_LEN(len);
239         if (kmsg->msg_controllen < cmlen) {
240                 kmsg->msg_flags |= MSG_CTRUNC;
241                 cmlen = kmsg->msg_controllen;
242         }
243         cmhdr.cmsg_level = level;
244         cmhdr.cmsg_type = type;
245         cmhdr.cmsg_len = cmlen;
246 
247         if (copy_to_user(cm, &cmhdr, sizeof cmhdr))
248                 return -EFAULT;
249         if (copy_to_user(CMSG_COMPAT_DATA(cm), data, cmlen - sizeof(struct compat_cmsghdr)))
250                 return -EFAULT;
251         cmlen = CMSG_COMPAT_SPACE(len);
252         if (kmsg->msg_controllen < cmlen)
253                 cmlen = kmsg->msg_controllen;
254         kmsg->msg_control += cmlen;
255         kmsg->msg_controllen -= cmlen;
256         return 0;
257 }
258 
259 void scm_detach_fds_compat(struct msghdr *kmsg, struct scm_cookie *scm)
260 {
261         struct compat_cmsghdr __user *cm = (struct compat_cmsghdr __user *) kmsg->msg_control;
262         int fdmax = (kmsg->msg_controllen - sizeof(struct compat_cmsghdr)) / sizeof(int);
263         int fdnum = scm->fp->count;
264         struct file **fp = scm->fp->fp;
265         int __user *cmfptr;
266         int err = 0, i;
267 
268         if (fdnum < fdmax)
269                 fdmax = fdnum;
270 
271         for (i = 0, cmfptr = (int __user *) CMSG_COMPAT_DATA(cm); i < fdmax; i++, cmfptr++) {
272                 int new_fd;
273                 err = security_file_receive(fp[i]);
274                 if (err)
275                         break;
276                 err = get_unused_fd_flags(MSG_CMSG_CLOEXEC & kmsg->msg_flags
277                                           ? O_CLOEXEC : 0);
278                 if (err < 0)
279                         break;
280                 new_fd = err;
281                 err = put_user(new_fd, cmfptr);
282                 if (err) {
283                         put_unused_fd(new_fd);
284                         break;
285                 }
286                 /* Bump the usage count and install the file. */
287                 __receive_sock(fp[i]);
288                 fd_install(new_fd, get_file(fp[i]));
289         }
290 
291         if (i > 0) {
292                 int cmlen = CMSG_COMPAT_LEN(i * sizeof(int));
293                 err = put_user(SOL_SOCKET, &cm->cmsg_level);
294                 if (!err)
295                         err = put_user(SCM_RIGHTS, &cm->cmsg_type);
296                 if (!err)
297                         err = put_user(cmlen, &cm->cmsg_len);
298                 if (!err) {
299                         cmlen = CMSG_COMPAT_SPACE(i * sizeof(int));
300                         kmsg->msg_control += cmlen;
301                         kmsg->msg_controllen -= cmlen;
302                 }
303         }
304         if (i < fdnum)
305                 kmsg->msg_flags |= MSG_CTRUNC;
306 
307         /*
308          * All of the files that fit in the message have had their
309          * usage counts incremented, so we just free the list.
310          */
311         __scm_destroy(scm);
312 }
313 
314 static int do_set_attach_filter(struct socket *sock, int level, int optname,
315                                 char __user *optval, unsigned int optlen)
316 {
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));
319         compat_uptr_t ptr;
320         u16 len;
321 
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))
328                 return -EFAULT;
329 
330         return sock_setsockopt(sock, level, optname, (char __user *)kfprog,
331                               sizeof(struct sock_fprog));
332 }
333 
334 static int do_set_sock_timeout(struct socket *sock, int level,
335                 int optname, char __user *optval, unsigned int optlen)
336 {
337         struct compat_timeval __user *up = (struct compat_timeval __user *)optval;
338         struct timeval ktime;
339         mm_segment_t old_fs;
340         int err;
341 
342         if (optlen < sizeof(*up))
343                 return -EINVAL;
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))
347                 return -EFAULT;
348         old_fs = get_fs();
349         set_fs(KERNEL_DS);
350         err = sock_setsockopt(sock, level, optname, (char *)&ktime, sizeof(ktime));
351         set_fs(old_fs);
352 
353         return err;
354 }
355 
356 static int compat_sock_setsockopt(struct socket *sock, int level, int optname,
357                                 char __user *optval, unsigned int optlen)
358 {
359         if (optname == SO_ATTACH_FILTER)
360                 return do_set_attach_filter(sock, level, optname,
361                                             optval, optlen);
362         if (!COMPAT_USE_64BIT_TIME &&
363             (optname == SO_RCVTIMEO || optname == SO_SNDTIMEO))
364                 return do_set_sock_timeout(sock, level, optname, optval, optlen);
365 
366         return sock_setsockopt(sock, level, optname, optval, optlen);
367 }
368 
369 COMPAT_SYSCALL_DEFINE5(setsockopt, int, fd, int, level, int, optname,
370                        char __user *, optval, unsigned int, optlen)
371 {
372         int err;
373         struct socket *sock = sockfd_lookup(fd, &err);
374 
375         if (sock) {
376                 err = security_socket_setsockopt(sock, level, optname);
377                 if (err) {
378                         sockfd_put(sock);
379                         return err;
380                 }
381 
382                 if (level == SOL_SOCKET)
383                         err = compat_sock_setsockopt(sock, level,
384                                         optname, optval, optlen);
385                 else if (sock->ops->compat_setsockopt)
386                         err = sock->ops->compat_setsockopt(sock, level,
387                                         optname, optval, optlen);
388                 else
389                         err = sock->ops->setsockopt(sock, level,
390                                         optname, optval, optlen);
391                 sockfd_put(sock);
392         }
393         return err;
394 }
395 
396 static int do_get_sock_timeout(struct socket *sock, int level, int optname,
397                 char __user *optval, int __user *optlen)
398 {
399         struct compat_timeval __user *up;
400         struct timeval ktime;
401         mm_segment_t old_fs;
402         int len, err;
403 
404         up = (struct compat_timeval __user *) optval;
405         if (get_user(len, optlen))
406                 return -EFAULT;
407         if (len < sizeof(*up))
408                 return -EINVAL;
409         len = sizeof(ktime);
410         old_fs = get_fs();
411         set_fs(KERNEL_DS);
412         err = sock_getsockopt(sock, level, optname, (char *) &ktime, &len);
413         set_fs(old_fs);
414 
415         if (!err) {
416                 if (put_user(sizeof(*up), optlen) ||
417                     !access_ok(VERIFY_WRITE, up, sizeof(*up)) ||
418                     __put_user(ktime.tv_sec, &up->tv_sec) ||
419                     __put_user(ktime.tv_usec, &up->tv_usec))
420                         err = -EFAULT;
421         }
422         return err;
423 }
424 
425 static int compat_sock_getsockopt(struct socket *sock, int level, int optname,
426                                 char __user *optval, int __user *optlen)
427 {
428         if (!COMPAT_USE_64BIT_TIME &&
429             (optname == SO_RCVTIMEO || optname == SO_SNDTIMEO))
430                 return do_get_sock_timeout(sock, level, optname, optval, optlen);
431         return sock_getsockopt(sock, level, optname, optval, optlen);
432 }
433 
434 int compat_sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
435 {
436         struct compat_timeval __user *ctv;
437         int err;
438         struct timeval tv;
439 
440         if (COMPAT_USE_64BIT_TIME)
441                 return sock_get_timestamp(sk, userstamp);
442 
443         ctv = (struct compat_timeval __user *) userstamp;
444         err = -ENOENT;
445         if (!sock_flag(sk, SOCK_TIMESTAMP))
446                 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
447         tv = ktime_to_timeval(sock_read_timestamp(sk));
448 
449         if (tv.tv_sec == -1)
450                 return err;
451         if (tv.tv_sec == 0) {
452                 ktime_t kt = ktime_get_real();
453                 sock_write_timestamp(sk, kt);
454                 tv = ktime_to_timeval(kt);
455         }
456         err = 0;
457         if (put_user(tv.tv_sec, &ctv->tv_sec) ||
458                         put_user(tv.tv_usec, &ctv->tv_usec))
459                 err = -EFAULT;
460         return err;
461 }
462 EXPORT_SYMBOL(compat_sock_get_timestamp);
463 
464 int compat_sock_get_timestampns(struct sock *sk, struct timespec __user *userstamp)
465 {
466         struct compat_timespec __user *ctv;
467         int err;
468         struct timespec ts;
469 
470         if (COMPAT_USE_64BIT_TIME)
471                 return sock_get_timestampns (sk, userstamp);
472 
473         ctv = (struct compat_timespec __user *) userstamp;
474         err = -ENOENT;
475         if (!sock_flag(sk, SOCK_TIMESTAMP))
476                 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
477         ts = ktime_to_timespec(sock_read_timestamp(sk));
478         if (ts.tv_sec == -1)
479                 return err;
480         if (ts.tv_sec == 0) {
481                 ktime_t kt = ktime_get_real();
482                 sock_write_timestamp(sk, kt);
483                 ts = ktime_to_timespec(kt);
484         }
485         err = 0;
486         if (put_user(ts.tv_sec, &ctv->tv_sec) ||
487                         put_user(ts.tv_nsec, &ctv->tv_nsec))
488                 err = -EFAULT;
489         return err;
490 }
491 EXPORT_SYMBOL(compat_sock_get_timestampns);
492 
493 COMPAT_SYSCALL_DEFINE5(getsockopt, int, fd, int, level, int, optname,
494                        char __user *, optval, int __user *, optlen)
495 {
496         int err;
497         struct socket *sock = sockfd_lookup(fd, &err);
498 
499         if (sock) {
500                 err = security_socket_getsockopt(sock, level, optname);
501                 if (err) {
502                         sockfd_put(sock);
503                         return err;
504                 }
505 
506                 if (level == SOL_SOCKET)
507                         err = compat_sock_getsockopt(sock, level,
508                                         optname, optval, optlen);
509                 else if (sock->ops->compat_getsockopt)
510                         err = sock->ops->compat_getsockopt(sock, level,
511                                         optname, optval, optlen);
512                 else
513                         err = sock->ops->getsockopt(sock, level,
514                                         optname, optval, optlen);
515                 sockfd_put(sock);
516         }
517         return err;
518 }
519 
520 struct compat_group_req {
521         __u32                            gr_interface;
522         struct __kernel_sockaddr_storage gr_group
523                 __aligned(4);
524 } __packed;
525 
526 struct compat_group_source_req {
527         __u32                            gsr_interface;
528         struct __kernel_sockaddr_storage gsr_group
529                 __aligned(4);
530         struct __kernel_sockaddr_storage gsr_source
531                 __aligned(4);
532 } __packed;
533 
534 struct compat_group_filter {
535         __u32                            gf_interface;
536         struct __kernel_sockaddr_storage gf_group
537                 __aligned(4);
538         __u32                            gf_fmode;
539         __u32                            gf_numsrc;
540         struct __kernel_sockaddr_storage gf_slist[1]
541                 __aligned(4);
542 } __packed;
543 
544 #define __COMPAT_GF0_SIZE (sizeof(struct compat_group_filter) - \
545                         sizeof(struct __kernel_sockaddr_storage))
546 
547 
548 int compat_mc_setsockopt(struct sock *sock, int level, int optname,
549         char __user *optval, unsigned int optlen,
550         int (*setsockopt)(struct sock *, int, int, char __user *, unsigned int))
551 {
552         char __user     *koptval = optval;
553         int             koptlen = optlen;
554 
555         switch (optname) {
556         case MCAST_JOIN_GROUP:
557         case MCAST_LEAVE_GROUP:
558         {
559                 struct compat_group_req __user *gr32 = (void *)optval;
560                 struct group_req __user *kgr =
561                         compat_alloc_user_space(sizeof(struct group_req));
562                 u32 interface;
563 
564                 if (!access_ok(VERIFY_READ, gr32, sizeof(*gr32)) ||
565                     !access_ok(VERIFY_WRITE, kgr, sizeof(struct group_req)) ||
566                     __get_user(interface, &gr32->gr_interface) ||
567                     __put_user(interface, &kgr->gr_interface) ||
568                     copy_in_user(&kgr->gr_group, &gr32->gr_group,
569                                 sizeof(kgr->gr_group)))
570                         return -EFAULT;
571                 koptval = (char __user *)kgr;
572                 koptlen = sizeof(struct group_req);
573                 break;
574         }
575         case MCAST_JOIN_SOURCE_GROUP:
576         case MCAST_LEAVE_SOURCE_GROUP:
577         case MCAST_BLOCK_SOURCE:
578         case MCAST_UNBLOCK_SOURCE:
579         {
580                 struct compat_group_source_req __user *gsr32 = (void *)optval;
581                 struct group_source_req __user *kgsr = compat_alloc_user_space(
582                         sizeof(struct group_source_req));
583                 u32 interface;
584 
585                 if (!access_ok(VERIFY_READ, gsr32, sizeof(*gsr32)) ||
586                     !access_ok(VERIFY_WRITE, kgsr,
587                         sizeof(struct group_source_req)) ||
588                     __get_user(interface, &gsr32->gsr_interface) ||
589                     __put_user(interface, &kgsr->gsr_interface) ||
590                     copy_in_user(&kgsr->gsr_group, &gsr32->gsr_group,
591                                 sizeof(kgsr->gsr_group)) ||
592                     copy_in_user(&kgsr->gsr_source, &gsr32->gsr_source,
593                                 sizeof(kgsr->gsr_source)))
594                         return -EFAULT;
595                 koptval = (char __user *)kgsr;
596                 koptlen = sizeof(struct group_source_req);
597                 break;
598         }
599         case MCAST_MSFILTER:
600         {
601                 struct compat_group_filter __user *gf32 = (void *)optval;
602                 struct group_filter __user *kgf;
603                 u32 interface, fmode, numsrc;
604 
605                 if (!access_ok(VERIFY_READ, gf32, __COMPAT_GF0_SIZE) ||
606                     __get_user(interface, &gf32->gf_interface) ||
607                     __get_user(fmode, &gf32->gf_fmode) ||
608                     __get_user(numsrc, &gf32->gf_numsrc))
609                         return -EFAULT;
610                 koptlen = optlen + sizeof(struct group_filter) -
611                                 sizeof(struct compat_group_filter);
612                 if (koptlen < GROUP_FILTER_SIZE(numsrc))
613                         return -EINVAL;
614                 kgf = compat_alloc_user_space(koptlen);
615                 if (!access_ok(VERIFY_WRITE, kgf, koptlen) ||
616                     __put_user(interface, &kgf->gf_interface) ||
617                     __put_user(fmode, &kgf->gf_fmode) ||
618                     __put_user(numsrc, &kgf->gf_numsrc) ||
619                     copy_in_user(&kgf->gf_group, &gf32->gf_group,
620                                 sizeof(kgf->gf_group)) ||
621                     (numsrc && copy_in_user(kgf->gf_slist, gf32->gf_slist,
622                                 numsrc * sizeof(kgf->gf_slist[0]))))
623                         return -EFAULT;
624                 koptval = (char __user *)kgf;
625                 break;
626         }
627 
628         default:
629                 break;
630         }
631         return setsockopt(sock, level, optname, koptval, koptlen);
632 }
633 EXPORT_SYMBOL(compat_mc_setsockopt);
634 
635 int compat_mc_getsockopt(struct sock *sock, int level, int optname,
636         char __user *optval, int __user *optlen,
637         int (*getsockopt)(struct sock *, int, int, char __user *, int __user *))
638 {
639         struct compat_group_filter __user *gf32 = (void *)optval;
640         struct group_filter __user *kgf;
641         int __user      *koptlen;
642         u32 interface, fmode, numsrc;
643         int klen, ulen, err;
644 
645         if (optname != MCAST_MSFILTER)
646                 return getsockopt(sock, level, optname, optval, optlen);
647 
648         koptlen = compat_alloc_user_space(sizeof(*koptlen));
649         if (!access_ok(VERIFY_READ, optlen, sizeof(*optlen)) ||
650             __get_user(ulen, optlen))
651                 return -EFAULT;
652 
653         /* adjust len for pad */
654         klen = ulen + sizeof(*kgf) - sizeof(*gf32);
655 
656         if (klen < GROUP_FILTER_SIZE(0))
657                 return -EINVAL;
658 
659         if (!access_ok(VERIFY_WRITE, koptlen, sizeof(*koptlen)) ||
660             __put_user(klen, koptlen))
661                 return -EFAULT;
662 
663         /* have to allow space for previous compat_alloc_user_space, too */
664         kgf = compat_alloc_user_space(klen+sizeof(*optlen));
665 
666         if (!access_ok(VERIFY_READ, gf32, __COMPAT_GF0_SIZE) ||
667             __get_user(interface, &gf32->gf_interface) ||
668             __get_user(fmode, &gf32->gf_fmode) ||
669             __get_user(numsrc, &gf32->gf_numsrc) ||
670             __put_user(interface, &kgf->gf_interface) ||
671             __put_user(fmode, &kgf->gf_fmode) ||
672             __put_user(numsrc, &kgf->gf_numsrc) ||
673             copy_in_user(&kgf->gf_group, &gf32->gf_group, sizeof(kgf->gf_group)))
674                 return -EFAULT;
675 
676         err = getsockopt(sock, level, optname, (char __user *)kgf, koptlen);
677         if (err)
678                 return err;
679 
680         if (!access_ok(VERIFY_READ, koptlen, sizeof(*koptlen)) ||
681             __get_user(klen, koptlen))
682                 return -EFAULT;
683 
684         ulen = klen - (sizeof(*kgf)-sizeof(*gf32));
685 
686         if (!access_ok(VERIFY_WRITE, optlen, sizeof(*optlen)) ||
687             __put_user(ulen, optlen))
688                 return -EFAULT;
689 
690         if (!access_ok(VERIFY_READ, kgf, klen) ||
691             !access_ok(VERIFY_WRITE, gf32, ulen) ||
692             __get_user(interface, &kgf->gf_interface) ||
693             __get_user(fmode, &kgf->gf_fmode) ||
694             __get_user(numsrc, &kgf->gf_numsrc) ||
695             __put_user(interface, &gf32->gf_interface) ||
696             __put_user(fmode, &gf32->gf_fmode) ||
697             __put_user(numsrc, &gf32->gf_numsrc))
698                 return -EFAULT;
699         if (numsrc) {
700                 int copylen;
701 
702                 klen -= GROUP_FILTER_SIZE(0);
703                 copylen = numsrc * sizeof(gf32->gf_slist[0]);
704                 if (copylen > klen)
705                         copylen = klen;
706                 if (copy_in_user(gf32->gf_slist, kgf->gf_slist, copylen))
707                         return -EFAULT;
708         }
709         return err;
710 }
711 EXPORT_SYMBOL(compat_mc_getsockopt);
712 
713 
714 /* Argument list sizes for compat_sys_socketcall */
715 #define AL(x) ((x) * sizeof(u32))
716 static unsigned char nas[21] = {
717         AL(0), AL(3), AL(3), AL(3), AL(2), AL(3),
718         AL(3), AL(3), AL(4), AL(4), AL(4), AL(6),
719         AL(6), AL(2), AL(5), AL(5), AL(3), AL(3),
720         AL(4), AL(5), AL(4)
721 };
722 #undef AL
723 
724 COMPAT_SYSCALL_DEFINE3(sendmsg, int, fd, struct compat_msghdr __user *, msg, unsigned int, flags)
725 {
726         return __sys_sendmsg(fd, (struct user_msghdr __user *)msg, flags | MSG_CMSG_COMPAT);
727 }
728 
729 COMPAT_SYSCALL_DEFINE4(sendmmsg, int, fd, struct compat_mmsghdr __user *, mmsg,
730                        unsigned int, vlen, unsigned int, flags)
731 {
732         return __sys_sendmmsg(fd, (struct mmsghdr __user *)mmsg, vlen,
733                               flags | MSG_CMSG_COMPAT);
734 }
735 
736 COMPAT_SYSCALL_DEFINE3(recvmsg, int, fd, struct compat_msghdr __user *, msg, unsigned int, flags)
737 {
738         return __sys_recvmsg(fd, (struct user_msghdr __user *)msg, flags | MSG_CMSG_COMPAT);
739 }
740 
741 COMPAT_SYSCALL_DEFINE4(recv, int, fd, void __user *, buf, compat_size_t, len, unsigned int, flags)
742 {
743         return sys_recv(fd, buf, len, flags | MSG_CMSG_COMPAT);
744 }
745 
746 COMPAT_SYSCALL_DEFINE6(recvfrom, int, fd, void __user *, buf, compat_size_t, len,
747                        unsigned int, flags, struct sockaddr __user *, addr,
748                        int __user *, addrlen)
749 {
750         return sys_recvfrom(fd, buf, len, flags | MSG_CMSG_COMPAT, addr, addrlen);
751 }
752 
753 COMPAT_SYSCALL_DEFINE5(recvmmsg, int, fd, struct compat_mmsghdr __user *, mmsg,
754                        unsigned int, vlen, unsigned int, flags,
755                        struct compat_timespec __user *, timeout)
756 {
757         int datagrams;
758         struct timespec ktspec;
759 
760         if (timeout == NULL)
761                 return __sys_recvmmsg(fd, (struct mmsghdr __user *)mmsg, vlen,
762                                       flags | MSG_CMSG_COMPAT, NULL);
763 
764         if (compat_get_timespec(&ktspec, timeout))
765                 return -EFAULT;
766 
767         datagrams = __sys_recvmmsg(fd, (struct mmsghdr __user *)mmsg, vlen,
768                                    flags | MSG_CMSG_COMPAT, &ktspec);
769         if (datagrams > 0 && compat_put_timespec(&ktspec, timeout))
770                 datagrams = -EFAULT;
771 
772         return datagrams;
773 }
774 
775 COMPAT_SYSCALL_DEFINE2(socketcall, int, call, u32 __user *, args)
776 {
777         u32 a[AUDITSC_ARGS];
778         unsigned int len;
779         u32 a0, a1;
780         int ret;
781 
782         if (call < SYS_SOCKET || call > SYS_SENDMMSG)
783                 return -EINVAL;
784         len = nas[call];
785         if (len > sizeof(a))
786                 return -EINVAL;
787 
788         if (copy_from_user(a, args, len))
789                 return -EFAULT;
790 
791         ret = audit_socketcall_compat(len / sizeof(a[0]), a);
792         if (ret)
793                 return ret;
794 
795         a0 = a[0];
796         a1 = a[1];
797 
798         switch (call) {
799         case SYS_SOCKET:
800                 ret = sys_socket(a0, a1, a[2]);
801                 break;
802         case SYS_BIND:
803                 ret = sys_bind(a0, compat_ptr(a1), a[2]);
804                 break;
805         case SYS_CONNECT:
806                 ret = sys_connect(a0, compat_ptr(a1), a[2]);
807                 break;
808         case SYS_LISTEN:
809                 ret = sys_listen(a0, a1);
810                 break;
811         case SYS_ACCEPT:
812                 ret = sys_accept4(a0, compat_ptr(a1), compat_ptr(a[2]), 0);
813                 break;
814         case SYS_GETSOCKNAME:
815                 ret = sys_getsockname(a0, compat_ptr(a1), compat_ptr(a[2]));
816                 break;
817         case SYS_GETPEERNAME:
818                 ret = sys_getpeername(a0, compat_ptr(a1), compat_ptr(a[2]));
819                 break;
820         case SYS_SOCKETPAIR:
821                 ret = sys_socketpair(a0, a1, a[2], compat_ptr(a[3]));
822                 break;
823         case SYS_SEND:
824                 ret = sys_send(a0, compat_ptr(a1), a[2], a[3]);
825                 break;
826         case SYS_SENDTO:
827                 ret = sys_sendto(a0, compat_ptr(a1), a[2], a[3], compat_ptr(a[4]), a[5]);
828                 break;
829         case SYS_RECV:
830                 ret = compat_sys_recv(a0, compat_ptr(a1), a[2], a[3]);
831                 break;
832         case SYS_RECVFROM:
833                 ret = compat_sys_recvfrom(a0, compat_ptr(a1), a[2], a[3],
834                                           compat_ptr(a[4]), compat_ptr(a[5]));
835                 break;
836         case SYS_SHUTDOWN:
837                 ret = sys_shutdown(a0, a1);
838                 break;
839         case SYS_SETSOCKOPT:
840                 ret = compat_sys_setsockopt(a0, a1, a[2],
841                                 compat_ptr(a[3]), a[4]);
842                 break;
843         case SYS_GETSOCKOPT:
844                 ret = compat_sys_getsockopt(a0, a1, a[2],
845                                 compat_ptr(a[3]), compat_ptr(a[4]));
846                 break;
847         case SYS_SENDMSG:
848                 ret = compat_sys_sendmsg(a0, compat_ptr(a1), a[2]);
849                 break;
850         case SYS_SENDMMSG:
851                 ret = compat_sys_sendmmsg(a0, compat_ptr(a1), a[2], a[3]);
852                 break;
853         case SYS_RECVMSG:
854                 ret = compat_sys_recvmsg(a0, compat_ptr(a1), a[2]);
855                 break;
856         case SYS_RECVMMSG:
857                 ret = compat_sys_recvmmsg(a0, compat_ptr(a1), a[2], a[3],
858                                           compat_ptr(a[4]));
859                 break;
860         case SYS_ACCEPT4:
861                 ret = sys_accept4(a0, compat_ptr(a1), compat_ptr(a[2]), a[3]);
862                 break;
863         default:
864                 ret = -EINVAL;
865                 break;
866         }
867         return ret;
868 }
869 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp