aboutsummaryrefslogtreecommitdiffstats
path: root/net/socket.c
diff options
context:
space:
mode:
Diffstat (limited to 'net/socket.c')
-rw-r--r--net/socket.c951
1 files changed, 826 insertions, 125 deletions
diff --git a/net/socket.c b/net/socket.c
index 75655365b5fd..dbfdfa96d29b 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -97,6 +97,12 @@
97#include <net/sock.h> 97#include <net/sock.h>
98#include <linux/netfilter.h> 98#include <linux/netfilter.h>
99 99
100#include <linux/if_tun.h>
101#include <linux/ipv6_route.h>
102#include <linux/route.h>
103#include <linux/sockios.h>
104#include <linux/atalk.h>
105
100static int sock_no_open(struct inode *irrelevant, struct file *dontcare); 106static int sock_no_open(struct inode *irrelevant, struct file *dontcare);
101static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov, 107static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov,
102 unsigned long nr_segs, loff_t pos); 108 unsigned long nr_segs, loff_t pos);
@@ -349,68 +355,61 @@ static const struct dentry_operations sockfs_dentry_operations = {
349 * but we take care of internal coherence yet. 355 * but we take care of internal coherence yet.
350 */ 356 */
351 357
352static int sock_alloc_fd(struct file **filep, int flags) 358static int sock_alloc_file(struct socket *sock, struct file **f, int flags)
353{ 359{
360 struct qstr name = { .name = "" };
361 struct path path;
362 struct file *file;
354 int fd; 363 int fd;
355 364
356 fd = get_unused_fd_flags(flags); 365 fd = get_unused_fd_flags(flags);
357 if (likely(fd >= 0)) { 366 if (unlikely(fd < 0))
358 struct file *file = get_empty_filp(); 367 return fd;
359
360 *filep = file;
361 if (unlikely(!file)) {
362 put_unused_fd(fd);
363 return -ENFILE;
364 }
365 } else
366 *filep = NULL;
367 return fd;
368}
369
370static int sock_attach_fd(struct socket *sock, struct file *file, int flags)
371{
372 struct dentry *dentry;
373 struct qstr name = { .name = "" };
374 368
375 dentry = d_alloc(sock_mnt->mnt_sb->s_root, &name); 369 path.dentry = d_alloc(sock_mnt->mnt_sb->s_root, &name);
376 if (unlikely(!dentry)) 370 if (unlikely(!path.dentry)) {
371 put_unused_fd(fd);
377 return -ENOMEM; 372 return -ENOMEM;
373 }
374 path.mnt = mntget(sock_mnt);
378 375
379 dentry->d_op = &sockfs_dentry_operations; 376 path.dentry->d_op = &sockfs_dentry_operations;
380 /* 377 /*
381 * We dont want to push this dentry into global dentry hash table. 378 * We dont want to push this dentry into global dentry hash table.
382 * We pretend dentry is already hashed, by unsetting DCACHE_UNHASHED 379 * We pretend dentry is already hashed, by unsetting DCACHE_UNHASHED
383 * This permits a working /proc/$pid/fd/XXX on sockets 380 * This permits a working /proc/$pid/fd/XXX on sockets
384 */ 381 */
385 dentry->d_flags &= ~DCACHE_UNHASHED; 382 path.dentry->d_flags &= ~DCACHE_UNHASHED;
386 d_instantiate(dentry, SOCK_INODE(sock)); 383 d_instantiate(path.dentry, SOCK_INODE(sock));
384 SOCK_INODE(sock)->i_fop = &socket_file_ops;
387 385
388 sock->file = file; 386 file = alloc_file(&path, FMODE_READ | FMODE_WRITE,
389 init_file(file, sock_mnt, dentry, FMODE_READ | FMODE_WRITE,
390 &socket_file_ops); 387 &socket_file_ops);
391 SOCK_INODE(sock)->i_fop = &socket_file_ops; 388 if (unlikely(!file)) {
389 /* drop dentry, keep inode */
390 atomic_inc(&path.dentry->d_inode->i_count);
391 path_put(&path);
392 put_unused_fd(fd);
393 return -ENFILE;
394 }
395
396 sock->file = file;
392 file->f_flags = O_RDWR | (flags & O_NONBLOCK); 397 file->f_flags = O_RDWR | (flags & O_NONBLOCK);
393 file->f_pos = 0; 398 file->f_pos = 0;
394 file->private_data = sock; 399 file->private_data = sock;
395 400
396 return 0; 401 *f = file;
402 return fd;
397} 403}
398 404
399int sock_map_fd(struct socket *sock, int flags) 405int sock_map_fd(struct socket *sock, int flags)
400{ 406{
401 struct file *newfile; 407 struct file *newfile;
402 int fd = sock_alloc_fd(&newfile, flags); 408 int fd = sock_alloc_file(sock, &newfile, flags);
403
404 if (likely(fd >= 0)) {
405 int err = sock_attach_fd(sock, newfile, flags);
406 409
407 if (unlikely(err < 0)) { 410 if (likely(fd >= 0))
408 put_filp(newfile);
409 put_unused_fd(fd);
410 return err;
411 }
412 fd_install(fd, newfile); 411 fd_install(fd, newfile);
413 } 412
414 return fd; 413 return fd;
415} 414}
416 415
@@ -668,10 +667,24 @@ void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
668 667
669EXPORT_SYMBOL_GPL(__sock_recv_timestamp); 668EXPORT_SYMBOL_GPL(__sock_recv_timestamp);
670 669
671static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock, 670inline void sock_recv_drops(struct msghdr *msg, struct sock *sk, struct sk_buff *skb)
672 struct msghdr *msg, size_t size, int flags) 671{
672 if (sock_flag(sk, SOCK_RXQ_OVFL) && skb && skb->dropcount)
673 put_cmsg(msg, SOL_SOCKET, SO_RXQ_OVFL,
674 sizeof(__u32), &skb->dropcount);
675}
676
677void sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
678 struct sk_buff *skb)
679{
680 sock_recv_timestamp(msg, sk, skb);
681 sock_recv_drops(msg, sk, skb);
682}
683EXPORT_SYMBOL_GPL(sock_recv_ts_and_drops);
684
685static inline int __sock_recvmsg_nosec(struct kiocb *iocb, struct socket *sock,
686 struct msghdr *msg, size_t size, int flags)
673{ 687{
674 int err;
675 struct sock_iocb *si = kiocb_to_siocb(iocb); 688 struct sock_iocb *si = kiocb_to_siocb(iocb);
676 689
677 si->sock = sock; 690 si->sock = sock;
@@ -680,13 +693,17 @@ static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock,
680 si->size = size; 693 si->size = size;
681 si->flags = flags; 694 si->flags = flags;
682 695
683 err = security_socket_recvmsg(sock, msg, size, flags);
684 if (err)
685 return err;
686
687 return sock->ops->recvmsg(iocb, sock, msg, size, flags); 696 return sock->ops->recvmsg(iocb, sock, msg, size, flags);
688} 697}
689 698
699static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock,
700 struct msghdr *msg, size_t size, int flags)
701{
702 int err = security_socket_recvmsg(sock, msg, size, flags);
703
704 return err ?: __sock_recvmsg_nosec(iocb, sock, msg, size, flags);
705}
706
690int sock_recvmsg(struct socket *sock, struct msghdr *msg, 707int sock_recvmsg(struct socket *sock, struct msghdr *msg,
691 size_t size, int flags) 708 size_t size, int flags)
692{ 709{
@@ -702,6 +719,21 @@ int sock_recvmsg(struct socket *sock, struct msghdr *msg,
702 return ret; 719 return ret;
703} 720}
704 721
722static int sock_recvmsg_nosec(struct socket *sock, struct msghdr *msg,
723 size_t size, int flags)
724{
725 struct kiocb iocb;
726 struct sock_iocb siocb;
727 int ret;
728
729 init_sync_kiocb(&iocb, NULL);
730 iocb.private = &siocb;
731 ret = __sock_recvmsg_nosec(&iocb, sock, msg, size, flags);
732 if (-EIOCBQUEUED == ret)
733 ret = wait_on_sync_kiocb(&iocb);
734 return ret;
735}
736
705int kernel_recvmsg(struct socket *sock, struct msghdr *msg, 737int kernel_recvmsg(struct socket *sock, struct msghdr *msg,
706 struct kvec *vec, size_t num, size_t size, int flags) 738 struct kvec *vec, size_t num, size_t size, int flags)
707{ 739{
@@ -886,6 +918,24 @@ void dlci_ioctl_set(int (*hook) (unsigned int, void __user *))
886 918
887EXPORT_SYMBOL(dlci_ioctl_set); 919EXPORT_SYMBOL(dlci_ioctl_set);
888 920
921static long sock_do_ioctl(struct net *net, struct socket *sock,
922 unsigned int cmd, unsigned long arg)
923{
924 int err;
925 void __user *argp = (void __user *)arg;
926
927 err = sock->ops->ioctl(sock, cmd, arg);
928
929 /*
930 * If this ioctl is unknown try to hand it down
931 * to the NIC driver.
932 */
933 if (err == -ENOIOCTLCMD)
934 err = dev_ioctl(net, cmd, argp);
935
936 return err;
937}
938
889/* 939/*
890 * With an ioctl, arg may well be a user mode pointer, but we don't know 940 * With an ioctl, arg may well be a user mode pointer, but we don't know
891 * what to do with it - that's up to the protocol still. 941 * what to do with it - that's up to the protocol still.
@@ -905,11 +955,11 @@ static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
905 if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) { 955 if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) {
906 err = dev_ioctl(net, cmd, argp); 956 err = dev_ioctl(net, cmd, argp);
907 } else 957 } else
908#ifdef CONFIG_WIRELESS_EXT 958#ifdef CONFIG_WEXT_CORE
909 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) { 959 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {
910 err = dev_ioctl(net, cmd, argp); 960 err = dev_ioctl(net, cmd, argp);
911 } else 961 } else
912#endif /* CONFIG_WIRELESS_EXT */ 962#endif
913 switch (cmd) { 963 switch (cmd) {
914 case FIOSETOWN: 964 case FIOSETOWN:
915 case SIOCSPGRP: 965 case SIOCSPGRP:
@@ -959,14 +1009,7 @@ static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
959 mutex_unlock(&dlci_ioctl_mutex); 1009 mutex_unlock(&dlci_ioctl_mutex);
960 break; 1010 break;
961 default: 1011 default:
962 err = sock->ops->ioctl(sock, cmd, arg); 1012 err = sock_do_ioctl(net, sock, cmd, arg);
963
964 /*
965 * If this ioctl is unknown try to hand it down
966 * to the NIC driver.
967 */
968 if (err == -ENOIOCTLCMD)
969 err = dev_ioctl(net, cmd, argp);
970 break; 1013 break;
971 } 1014 }
972 return err; 1015 return err;
@@ -1100,11 +1143,14 @@ static int sock_fasync(int fd, struct file *filp, int on)
1100 fna->fa_next = sock->fasync_list; 1143 fna->fa_next = sock->fasync_list;
1101 write_lock_bh(&sk->sk_callback_lock); 1144 write_lock_bh(&sk->sk_callback_lock);
1102 sock->fasync_list = fna; 1145 sock->fasync_list = fna;
1146 sock_set_flag(sk, SOCK_FASYNC);
1103 write_unlock_bh(&sk->sk_callback_lock); 1147 write_unlock_bh(&sk->sk_callback_lock);
1104 } else { 1148 } else {
1105 if (fa != NULL) { 1149 if (fa != NULL) {
1106 write_lock_bh(&sk->sk_callback_lock); 1150 write_lock_bh(&sk->sk_callback_lock);
1107 *prev = fa->fa_next; 1151 *prev = fa->fa_next;
1152 if (!sock->fasync_list)
1153 sock_reset_flag(sk, SOCK_FASYNC);
1108 write_unlock_bh(&sk->sk_callback_lock); 1154 write_unlock_bh(&sk->sk_callback_lock);
1109 kfree(fa); 1155 kfree(fa);
1110 } 1156 }
@@ -1216,7 +1262,7 @@ static int __sock_create(struct net *net, int family, int type, int protocol,
1216 /* Now protected by module ref count */ 1262 /* Now protected by module ref count */
1217 rcu_read_unlock(); 1263 rcu_read_unlock();
1218 1264
1219 err = pf->create(net, sock, protocol); 1265 err = pf->create(net, sock, protocol, kern);
1220 if (err < 0) 1266 if (err < 0)
1221 goto out_module_put; 1267 goto out_module_put;
1222 1268
@@ -1337,29 +1383,19 @@ SYSCALL_DEFINE4(socketpair, int, family, int, type, int, protocol,
1337 if (err < 0) 1383 if (err < 0)
1338 goto out_release_both; 1384 goto out_release_both;
1339 1385
1340 fd1 = sock_alloc_fd(&newfile1, flags & O_CLOEXEC); 1386 fd1 = sock_alloc_file(sock1, &newfile1, flags);
1341 if (unlikely(fd1 < 0)) { 1387 if (unlikely(fd1 < 0)) {
1342 err = fd1; 1388 err = fd1;
1343 goto out_release_both; 1389 goto out_release_both;
1344 } 1390 }
1345 1391
1346 fd2 = sock_alloc_fd(&newfile2, flags & O_CLOEXEC); 1392 fd2 = sock_alloc_file(sock2, &newfile2, flags);
1347 if (unlikely(fd2 < 0)) { 1393 if (unlikely(fd2 < 0)) {
1348 err = fd2; 1394 err = fd2;
1349 put_filp(newfile1);
1350 put_unused_fd(fd1);
1351 goto out_release_both;
1352 }
1353
1354 err = sock_attach_fd(sock1, newfile1, flags & O_NONBLOCK);
1355 if (unlikely(err < 0)) {
1356 goto out_fd2;
1357 }
1358
1359 err = sock_attach_fd(sock2, newfile2, flags & O_NONBLOCK);
1360 if (unlikely(err < 0)) {
1361 fput(newfile1); 1395 fput(newfile1);
1362 goto out_fd1; 1396 put_unused_fd(fd1);
1397 sock_release(sock2);
1398 goto out;
1363 } 1399 }
1364 1400
1365 audit_fd_pair(fd1, fd2); 1401 audit_fd_pair(fd1, fd2);
@@ -1385,16 +1421,6 @@ out_release_1:
1385 sock_release(sock1); 1421 sock_release(sock1);
1386out: 1422out:
1387 return err; 1423 return err;
1388
1389out_fd2:
1390 put_filp(newfile1);
1391 sock_release(sock1);
1392out_fd1:
1393 put_filp(newfile2);
1394 sock_release(sock2);
1395 put_unused_fd(fd1);
1396 put_unused_fd(fd2);
1397 goto out;
1398} 1424}
1399 1425
1400/* 1426/*
@@ -1498,17 +1524,13 @@ SYSCALL_DEFINE4(accept4, int, fd, struct sockaddr __user *, upeer_sockaddr,
1498 */ 1524 */
1499 __module_get(newsock->ops->owner); 1525 __module_get(newsock->ops->owner);
1500 1526
1501 newfd = sock_alloc_fd(&newfile, flags & O_CLOEXEC); 1527 newfd = sock_alloc_file(newsock, &newfile, flags);
1502 if (unlikely(newfd < 0)) { 1528 if (unlikely(newfd < 0)) {
1503 err = newfd; 1529 err = newfd;
1504 sock_release(newsock); 1530 sock_release(newsock);
1505 goto out_put; 1531 goto out_put;
1506 } 1532 }
1507 1533
1508 err = sock_attach_fd(newsock, newfile, flags & O_NONBLOCK);
1509 if (err < 0)
1510 goto out_fd_simple;
1511
1512 err = security_socket_accept(sock, newsock); 1534 err = security_socket_accept(sock, newsock);
1513 if (err) 1535 if (err)
1514 goto out_fd; 1536 goto out_fd;
@@ -1538,11 +1560,6 @@ out_put:
1538 fput_light(sock->file, fput_needed); 1560 fput_light(sock->file, fput_needed);
1539out: 1561out:
1540 return err; 1562 return err;
1541out_fd_simple:
1542 sock_release(newsock);
1543 put_filp(newfile);
1544 put_unused_fd(newfd);
1545 goto out_put;
1546out_fd: 1563out_fd:
1547 fput(newfile); 1564 fput(newfile);
1548 put_unused_fd(newfd); 1565 put_unused_fd(newfd);
@@ -1965,22 +1982,15 @@ out:
1965 return err; 1982 return err;
1966} 1983}
1967 1984
1968/* 1985static int __sys_recvmsg(struct socket *sock, struct msghdr __user *msg,
1969 * BSD recvmsg interface 1986 struct msghdr *msg_sys, unsigned flags, int nosec)
1970 */
1971
1972SYSCALL_DEFINE3(recvmsg, int, fd, struct msghdr __user *, msg,
1973 unsigned int, flags)
1974{ 1987{
1975 struct compat_msghdr __user *msg_compat = 1988 struct compat_msghdr __user *msg_compat =
1976 (struct compat_msghdr __user *)msg; 1989 (struct compat_msghdr __user *)msg;
1977 struct socket *sock;
1978 struct iovec iovstack[UIO_FASTIOV]; 1990 struct iovec iovstack[UIO_FASTIOV];
1979 struct iovec *iov = iovstack; 1991 struct iovec *iov = iovstack;
1980 struct msghdr msg_sys;
1981 unsigned long cmsg_ptr; 1992 unsigned long cmsg_ptr;
1982 int err, iov_size, total_len, len; 1993 int err, iov_size, total_len, len;
1983 int fput_needed;
1984 1994
1985 /* kernel mode address */ 1995 /* kernel mode address */
1986 struct sockaddr_storage addr; 1996 struct sockaddr_storage addr;
@@ -1990,27 +2000,23 @@ SYSCALL_DEFINE3(recvmsg, int, fd, struct msghdr __user *, msg,
1990 int __user *uaddr_len; 2000 int __user *uaddr_len;
1991 2001
1992 if (MSG_CMSG_COMPAT & flags) { 2002 if (MSG_CMSG_COMPAT & flags) {
1993 if (get_compat_msghdr(&msg_sys, msg_compat)) 2003 if (get_compat_msghdr(msg_sys, msg_compat))
1994 return -EFAULT; 2004 return -EFAULT;
1995 } 2005 }
1996 else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr))) 2006 else if (copy_from_user(msg_sys, msg, sizeof(struct msghdr)))
1997 return -EFAULT; 2007 return -EFAULT;
1998 2008
1999 sock = sockfd_lookup_light(fd, &err, &fput_needed);
2000 if (!sock)
2001 goto out;
2002
2003 err = -EMSGSIZE; 2009 err = -EMSGSIZE;
2004 if (msg_sys.msg_iovlen > UIO_MAXIOV) 2010 if (msg_sys->msg_iovlen > UIO_MAXIOV)
2005 goto out_put; 2011 goto out;
2006 2012
2007 /* Check whether to allocate the iovec area */ 2013 /* Check whether to allocate the iovec area */
2008 err = -ENOMEM; 2014 err = -ENOMEM;
2009 iov_size = msg_sys.msg_iovlen * sizeof(struct iovec); 2015 iov_size = msg_sys->msg_iovlen * sizeof(struct iovec);
2010 if (msg_sys.msg_iovlen > UIO_FASTIOV) { 2016 if (msg_sys->msg_iovlen > UIO_FASTIOV) {
2011 iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL); 2017 iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
2012 if (!iov) 2018 if (!iov)
2013 goto out_put; 2019 goto out;
2014 } 2020 }
2015 2021
2016 /* 2022 /*
@@ -2018,46 +2024,47 @@ SYSCALL_DEFINE3(recvmsg, int, fd, struct msghdr __user *, msg,
2018 * kernel msghdr to use the kernel address space) 2024 * kernel msghdr to use the kernel address space)
2019 */ 2025 */
2020 2026
2021 uaddr = (__force void __user *)msg_sys.msg_name; 2027 uaddr = (__force void __user *)msg_sys->msg_name;
2022 uaddr_len = COMPAT_NAMELEN(msg); 2028 uaddr_len = COMPAT_NAMELEN(msg);
2023 if (MSG_CMSG_COMPAT & flags) { 2029 if (MSG_CMSG_COMPAT & flags) {
2024 err = verify_compat_iovec(&msg_sys, iov, 2030 err = verify_compat_iovec(msg_sys, iov,
2025 (struct sockaddr *)&addr, 2031 (struct sockaddr *)&addr,
2026 VERIFY_WRITE); 2032 VERIFY_WRITE);
2027 } else 2033 } else
2028 err = verify_iovec(&msg_sys, iov, 2034 err = verify_iovec(msg_sys, iov,
2029 (struct sockaddr *)&addr, 2035 (struct sockaddr *)&addr,
2030 VERIFY_WRITE); 2036 VERIFY_WRITE);
2031 if (err < 0) 2037 if (err < 0)
2032 goto out_freeiov; 2038 goto out_freeiov;
2033 total_len = err; 2039 total_len = err;
2034 2040
2035 cmsg_ptr = (unsigned long)msg_sys.msg_control; 2041 cmsg_ptr = (unsigned long)msg_sys->msg_control;
2036 msg_sys.msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT); 2042 msg_sys->msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT);
2037 2043
2038 if (sock->file->f_flags & O_NONBLOCK) 2044 if (sock->file->f_flags & O_NONBLOCK)
2039 flags |= MSG_DONTWAIT; 2045 flags |= MSG_DONTWAIT;
2040 err = sock_recvmsg(sock, &msg_sys, total_len, flags); 2046 err = (nosec ? sock_recvmsg_nosec : sock_recvmsg)(sock, msg_sys,
2047 total_len, flags);
2041 if (err < 0) 2048 if (err < 0)
2042 goto out_freeiov; 2049 goto out_freeiov;
2043 len = err; 2050 len = err;
2044 2051
2045 if (uaddr != NULL) { 2052 if (uaddr != NULL) {
2046 err = move_addr_to_user((struct sockaddr *)&addr, 2053 err = move_addr_to_user((struct sockaddr *)&addr,
2047 msg_sys.msg_namelen, uaddr, 2054 msg_sys->msg_namelen, uaddr,
2048 uaddr_len); 2055 uaddr_len);
2049 if (err < 0) 2056 if (err < 0)
2050 goto out_freeiov; 2057 goto out_freeiov;
2051 } 2058 }
2052 err = __put_user((msg_sys.msg_flags & ~MSG_CMSG_COMPAT), 2059 err = __put_user((msg_sys->msg_flags & ~MSG_CMSG_COMPAT),
2053 COMPAT_FLAGS(msg)); 2060 COMPAT_FLAGS(msg));
2054 if (err) 2061 if (err)
2055 goto out_freeiov; 2062 goto out_freeiov;
2056 if (MSG_CMSG_COMPAT & flags) 2063 if (MSG_CMSG_COMPAT & flags)
2057 err = __put_user((unsigned long)msg_sys.msg_control - cmsg_ptr, 2064 err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,
2058 &msg_compat->msg_controllen); 2065 &msg_compat->msg_controllen);
2059 else 2066 else
2060 err = __put_user((unsigned long)msg_sys.msg_control - cmsg_ptr, 2067 err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,
2061 &msg->msg_controllen); 2068 &msg->msg_controllen);
2062 if (err) 2069 if (err)
2063 goto out_freeiov; 2070 goto out_freeiov;
@@ -2066,21 +2073,162 @@ SYSCALL_DEFINE3(recvmsg, int, fd, struct msghdr __user *, msg,
2066out_freeiov: 2073out_freeiov:
2067 if (iov != iovstack) 2074 if (iov != iovstack)
2068 sock_kfree_s(sock->sk, iov, iov_size); 2075 sock_kfree_s(sock->sk, iov, iov_size);
2069out_put: 2076out:
2077 return err;
2078}
2079
2080/*
2081 * BSD recvmsg interface
2082 */
2083
2084SYSCALL_DEFINE3(recvmsg, int, fd, struct msghdr __user *, msg,
2085 unsigned int, flags)
2086{
2087 int fput_needed, err;
2088 struct msghdr msg_sys;
2089 struct socket *sock = sockfd_lookup_light(fd, &err, &fput_needed);
2090
2091 if (!sock)
2092 goto out;
2093
2094 err = __sys_recvmsg(sock, msg, &msg_sys, flags, 0);
2095
2070 fput_light(sock->file, fput_needed); 2096 fput_light(sock->file, fput_needed);
2071out: 2097out:
2072 return err; 2098 return err;
2073} 2099}
2074 2100
2075#ifdef __ARCH_WANT_SYS_SOCKETCALL 2101/*
2102 * Linux recvmmsg interface
2103 */
2104
2105int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
2106 unsigned int flags, struct timespec *timeout)
2107{
2108 int fput_needed, err, datagrams;
2109 struct socket *sock;
2110 struct mmsghdr __user *entry;
2111 struct compat_mmsghdr __user *compat_entry;
2112 struct msghdr msg_sys;
2113 struct timespec end_time;
2114
2115 if (timeout &&
2116 poll_select_set_timeout(&end_time, timeout->tv_sec,
2117 timeout->tv_nsec))
2118 return -EINVAL;
2119
2120 datagrams = 0;
2121
2122 sock = sockfd_lookup_light(fd, &err, &fput_needed);
2123 if (!sock)
2124 return err;
2125
2126 err = sock_error(sock->sk);
2127 if (err)
2128 goto out_put;
2129
2130 entry = mmsg;
2131 compat_entry = (struct compat_mmsghdr __user *)mmsg;
2132
2133 while (datagrams < vlen) {
2134 /*
2135 * No need to ask LSM for more than the first datagram.
2136 */
2137 if (MSG_CMSG_COMPAT & flags) {
2138 err = __sys_recvmsg(sock, (struct msghdr __user *)compat_entry,
2139 &msg_sys, flags, datagrams);
2140 if (err < 0)
2141 break;
2142 err = __put_user(err, &compat_entry->msg_len);
2143 ++compat_entry;
2144 } else {
2145 err = __sys_recvmsg(sock, (struct msghdr __user *)entry,
2146 &msg_sys, flags, datagrams);
2147 if (err < 0)
2148 break;
2149 err = put_user(err, &entry->msg_len);
2150 ++entry;
2151 }
2152
2153 if (err)
2154 break;
2155 ++datagrams;
2156
2157 if (timeout) {
2158 ktime_get_ts(timeout);
2159 *timeout = timespec_sub(end_time, *timeout);
2160 if (timeout->tv_sec < 0) {
2161 timeout->tv_sec = timeout->tv_nsec = 0;
2162 break;
2163 }
2164
2165 /* Timeout, return less than vlen datagrams */
2166 if (timeout->tv_nsec == 0 && timeout->tv_sec == 0)
2167 break;
2168 }
2169
2170 /* Out of band data, return right away */
2171 if (msg_sys.msg_flags & MSG_OOB)
2172 break;
2173 }
2174
2175out_put:
2176 fput_light(sock->file, fput_needed);
2177
2178 if (err == 0)
2179 return datagrams;
2180
2181 if (datagrams != 0) {
2182 /*
2183 * We may return less entries than requested (vlen) if the
2184 * sock is non block and there aren't enough datagrams...
2185 */
2186 if (err != -EAGAIN) {
2187 /*
2188 * ... or if recvmsg returns an error after we
2189 * received some datagrams, where we record the
2190 * error to return on the next call or if the
2191 * app asks about it using getsockopt(SO_ERROR).
2192 */
2193 sock->sk->sk_err = -err;
2194 }
2195
2196 return datagrams;
2197 }
2198
2199 return err;
2200}
2076 2201
2202SYSCALL_DEFINE5(recvmmsg, int, fd, struct mmsghdr __user *, mmsg,
2203 unsigned int, vlen, unsigned int, flags,
2204 struct timespec __user *, timeout)
2205{
2206 int datagrams;
2207 struct timespec timeout_sys;
2208
2209 if (!timeout)
2210 return __sys_recvmmsg(fd, mmsg, vlen, flags, NULL);
2211
2212 if (copy_from_user(&timeout_sys, timeout, sizeof(timeout_sys)))
2213 return -EFAULT;
2214
2215 datagrams = __sys_recvmmsg(fd, mmsg, vlen, flags, &timeout_sys);
2216
2217 if (datagrams > 0 &&
2218 copy_to_user(timeout, &timeout_sys, sizeof(timeout_sys)))
2219 datagrams = -EFAULT;
2220
2221 return datagrams;
2222}
2223
2224#ifdef __ARCH_WANT_SYS_SOCKETCALL
2077/* Argument list sizes for sys_socketcall */ 2225/* Argument list sizes for sys_socketcall */
2078#define AL(x) ((x) * sizeof(unsigned long)) 2226#define AL(x) ((x) * sizeof(unsigned long))
2079static const unsigned char nargs[19]={ 2227static const unsigned char nargs[20] = {
2080 AL(0),AL(3),AL(3),AL(3),AL(2),AL(3), 2228 AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
2081 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6), 2229 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
2082 AL(6),AL(2),AL(5),AL(5),AL(3),AL(3), 2230 AL(6),AL(2),AL(5),AL(5),AL(3),AL(3),
2083 AL(4) 2231 AL(4),AL(5)
2084}; 2232};
2085 2233
2086#undef AL 2234#undef AL
@@ -2100,7 +2248,7 @@ SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)
2100 int err; 2248 int err;
2101 unsigned int len; 2249 unsigned int len;
2102 2250
2103 if (call < 1 || call > SYS_ACCEPT4) 2251 if (call < 1 || call > SYS_RECVMMSG)
2104 return -EINVAL; 2252 return -EINVAL;
2105 2253
2106 len = nargs[call]; 2254 len = nargs[call];
@@ -2178,6 +2326,10 @@ SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)
2178 case SYS_RECVMSG: 2326 case SYS_RECVMSG:
2179 err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]); 2327 err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]);
2180 break; 2328 break;
2329 case SYS_RECVMMSG:
2330 err = sys_recvmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3],
2331 (struct timespec __user *)a[4]);
2332 break;
2181 case SYS_ACCEPT4: 2333 case SYS_ACCEPT4:
2182 err = sys_accept4(a0, (struct sockaddr __user *)a1, 2334 err = sys_accept4(a0, (struct sockaddr __user *)a1,
2183 (int __user *)a[2], a[3]); 2335 (int __user *)a[2], a[3]);
@@ -2300,6 +2452,552 @@ void socket_seq_show(struct seq_file *seq)
2300#endif /* CONFIG_PROC_FS */ 2452#endif /* CONFIG_PROC_FS */
2301 2453
2302#ifdef CONFIG_COMPAT 2454#ifdef CONFIG_COMPAT
2455static int do_siocgstamp(struct net *net, struct socket *sock,
2456 unsigned int cmd, struct compat_timeval __user *up)
2457{
2458 mm_segment_t old_fs = get_fs();
2459 struct timeval ktv;
2460 int err;
2461
2462 set_fs(KERNEL_DS);
2463 err = sock_do_ioctl(net, sock, cmd, (unsigned long)&ktv);
2464 set_fs(old_fs);
2465 if (!err) {
2466 err = put_user(ktv.tv_sec, &up->tv_sec);
2467 err |= __put_user(ktv.tv_usec, &up->tv_usec);
2468 }
2469 return err;
2470}
2471
2472static int do_siocgstampns(struct net *net, struct socket *sock,
2473 unsigned int cmd, struct compat_timespec __user *up)
2474{
2475 mm_segment_t old_fs = get_fs();
2476 struct timespec kts;
2477 int err;
2478
2479 set_fs(KERNEL_DS);
2480 err = sock_do_ioctl(net, sock, cmd, (unsigned long)&kts);
2481 set_fs(old_fs);
2482 if (!err) {
2483 err = put_user(kts.tv_sec, &up->tv_sec);
2484 err |= __put_user(kts.tv_nsec, &up->tv_nsec);
2485 }
2486 return err;
2487}
2488
2489static int dev_ifname32(struct net *net, struct compat_ifreq __user *uifr32)
2490{
2491 struct ifreq __user *uifr;
2492 int err;
2493
2494 uifr = compat_alloc_user_space(sizeof(struct ifreq));
2495 if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))
2496 return -EFAULT;
2497
2498 err = dev_ioctl(net, SIOCGIFNAME, uifr);
2499 if (err)
2500 return err;
2501
2502 if (copy_in_user(uifr32, uifr, sizeof(struct compat_ifreq)))
2503 return -EFAULT;
2504
2505 return 0;
2506}
2507
2508static int dev_ifconf(struct net *net, struct compat_ifconf __user *uifc32)
2509{
2510 struct compat_ifconf ifc32;
2511 struct ifconf ifc;
2512 struct ifconf __user *uifc;
2513 struct compat_ifreq __user *ifr32;
2514 struct ifreq __user *ifr;
2515 unsigned int i, j;
2516 int err;
2517
2518 if (copy_from_user(&ifc32, uifc32, sizeof(struct compat_ifconf)))
2519 return -EFAULT;
2520
2521 if (ifc32.ifcbuf == 0) {
2522 ifc32.ifc_len = 0;
2523 ifc.ifc_len = 0;
2524 ifc.ifc_req = NULL;
2525 uifc = compat_alloc_user_space(sizeof(struct ifconf));
2526 } else {
2527 size_t len =((ifc32.ifc_len / sizeof (struct compat_ifreq)) + 1) *
2528 sizeof (struct ifreq);
2529 uifc = compat_alloc_user_space(sizeof(struct ifconf) + len);
2530 ifc.ifc_len = len;
2531 ifr = ifc.ifc_req = (void __user *)(uifc + 1);
2532 ifr32 = compat_ptr(ifc32.ifcbuf);
2533 for (i = 0; i < ifc32.ifc_len; i += sizeof (struct compat_ifreq)) {
2534 if (copy_in_user(ifr, ifr32, sizeof(struct compat_ifreq)))
2535 return -EFAULT;
2536 ifr++;
2537 ifr32++;
2538 }
2539 }
2540 if (copy_to_user(uifc, &ifc, sizeof(struct ifconf)))
2541 return -EFAULT;
2542
2543 err = dev_ioctl(net, SIOCGIFCONF, uifc);
2544 if (err)
2545 return err;
2546
2547 if (copy_from_user(&ifc, uifc, sizeof(struct ifconf)))
2548 return -EFAULT;
2549
2550 ifr = ifc.ifc_req;
2551 ifr32 = compat_ptr(ifc32.ifcbuf);
2552 for (i = 0, j = 0;
2553 i + sizeof (struct compat_ifreq) <= ifc32.ifc_len && j < ifc.ifc_len;
2554 i += sizeof (struct compat_ifreq), j += sizeof (struct ifreq)) {
2555 if (copy_in_user(ifr32, ifr, sizeof (struct compat_ifreq)))
2556 return -EFAULT;
2557 ifr32++;
2558 ifr++;
2559 }
2560
2561 if (ifc32.ifcbuf == 0) {
2562 /* Translate from 64-bit structure multiple to
2563 * a 32-bit one.
2564 */
2565 i = ifc.ifc_len;
2566 i = ((i / sizeof(struct ifreq)) * sizeof(struct compat_ifreq));
2567 ifc32.ifc_len = i;
2568 } else {
2569 ifc32.ifc_len = i;
2570 }
2571 if (copy_to_user(uifc32, &ifc32, sizeof(struct compat_ifconf)))
2572 return -EFAULT;
2573
2574 return 0;
2575}
2576
2577static int ethtool_ioctl(struct net *net, struct compat_ifreq __user *ifr32)
2578{
2579 struct ifreq __user *ifr;
2580 u32 data;
2581 void __user *datap;
2582
2583 ifr = compat_alloc_user_space(sizeof(*ifr));
2584
2585 if (copy_in_user(&ifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ))
2586 return -EFAULT;
2587
2588 if (get_user(data, &ifr32->ifr_ifru.ifru_data))
2589 return -EFAULT;
2590
2591 datap = compat_ptr(data);
2592 if (put_user(datap, &ifr->ifr_ifru.ifru_data))
2593 return -EFAULT;
2594
2595 return dev_ioctl(net, SIOCETHTOOL, ifr);
2596}
2597
2598static int compat_siocwandev(struct net *net, struct compat_ifreq __user *uifr32)
2599{
2600 void __user *uptr;
2601 compat_uptr_t uptr32;
2602 struct ifreq __user *uifr;
2603
2604 uifr = compat_alloc_user_space(sizeof (*uifr));
2605 if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))
2606 return -EFAULT;
2607
2608 if (get_user(uptr32, &uifr32->ifr_settings.ifs_ifsu))
2609 return -EFAULT;
2610
2611 uptr = compat_ptr(uptr32);
2612
2613 if (put_user(uptr, &uifr->ifr_settings.ifs_ifsu.raw_hdlc))
2614 return -EFAULT;
2615
2616 return dev_ioctl(net, SIOCWANDEV, uifr);
2617}
2618
2619static int bond_ioctl(struct net *net, unsigned int cmd,
2620 struct compat_ifreq __user *ifr32)
2621{
2622 struct ifreq kifr;
2623 struct ifreq __user *uifr;
2624 mm_segment_t old_fs;
2625 int err;
2626 u32 data;
2627 void __user *datap;
2628
2629 switch (cmd) {
2630 case SIOCBONDENSLAVE:
2631 case SIOCBONDRELEASE:
2632 case SIOCBONDSETHWADDR:
2633 case SIOCBONDCHANGEACTIVE:
2634 if (copy_from_user(&kifr, ifr32, sizeof(struct compat_ifreq)))
2635 return -EFAULT;
2636
2637 old_fs = get_fs();
2638 set_fs (KERNEL_DS);
2639 err = dev_ioctl(net, cmd, &kifr);
2640 set_fs (old_fs);
2641
2642 return err;
2643 case SIOCBONDSLAVEINFOQUERY:
2644 case SIOCBONDINFOQUERY:
2645 uifr = compat_alloc_user_space(sizeof(*uifr));
2646 if (copy_in_user(&uifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ))
2647 return -EFAULT;
2648
2649 if (get_user(data, &ifr32->ifr_ifru.ifru_data))
2650 return -EFAULT;
2651
2652 datap = compat_ptr(data);
2653 if (put_user(datap, &uifr->ifr_ifru.ifru_data))
2654 return -EFAULT;
2655
2656 return dev_ioctl(net, cmd, uifr);
2657 default:
2658 return -EINVAL;
2659 };
2660}
2661
2662static int siocdevprivate_ioctl(struct net *net, unsigned int cmd,
2663 struct compat_ifreq __user *u_ifreq32)
2664{
2665 struct ifreq __user *u_ifreq64;
2666 char tmp_buf[IFNAMSIZ];
2667 void __user *data64;
2668 u32 data32;
2669
2670 if (copy_from_user(&tmp_buf[0], &(u_ifreq32->ifr_ifrn.ifrn_name[0]),
2671 IFNAMSIZ))
2672 return -EFAULT;
2673 if (__get_user(data32, &u_ifreq32->ifr_ifru.ifru_data))
2674 return -EFAULT;
2675 data64 = compat_ptr(data32);
2676
2677 u_ifreq64 = compat_alloc_user_space(sizeof(*u_ifreq64));
2678
2679 /* Don't check these user accesses, just let that get trapped
2680 * in the ioctl handler instead.
2681 */
2682 if (copy_to_user(&u_ifreq64->ifr_ifrn.ifrn_name[0], &tmp_buf[0],
2683 IFNAMSIZ))
2684 return -EFAULT;
2685 if (__put_user(data64, &u_ifreq64->ifr_ifru.ifru_data))
2686 return -EFAULT;
2687
2688 return dev_ioctl(net, cmd, u_ifreq64);
2689}
2690
2691static int dev_ifsioc(struct net *net, struct socket *sock,
2692 unsigned int cmd, struct compat_ifreq __user *uifr32)
2693{
2694 struct ifreq __user *uifr;
2695 int err;
2696
2697 uifr = compat_alloc_user_space(sizeof(*uifr));
2698 if (copy_in_user(uifr, uifr32, sizeof(*uifr32)))
2699 return -EFAULT;
2700
2701 err = sock_do_ioctl(net, sock, cmd, (unsigned long)uifr);
2702
2703 if (!err) {
2704 switch (cmd) {
2705 case SIOCGIFFLAGS:
2706 case SIOCGIFMETRIC:
2707 case SIOCGIFMTU:
2708 case SIOCGIFMEM:
2709 case SIOCGIFHWADDR:
2710 case SIOCGIFINDEX:
2711 case SIOCGIFADDR:
2712 case SIOCGIFBRDADDR:
2713 case SIOCGIFDSTADDR:
2714 case SIOCGIFNETMASK:
2715 case SIOCGIFPFLAGS:
2716 case SIOCGIFTXQLEN:
2717 case SIOCGMIIPHY:
2718 case SIOCGMIIREG:
2719 if (copy_in_user(uifr32, uifr, sizeof(*uifr32)))
2720 err = -EFAULT;
2721 break;
2722 }
2723 }
2724 return err;
2725}
2726
2727static int compat_sioc_ifmap(struct net *net, unsigned int cmd,
2728 struct compat_ifreq __user *uifr32)
2729{
2730 struct ifreq ifr;
2731 struct compat_ifmap __user *uifmap32;
2732 mm_segment_t old_fs;
2733 int err;
2734
2735 uifmap32 = &uifr32->ifr_ifru.ifru_map;
2736 err = copy_from_user(&ifr, uifr32, sizeof(ifr.ifr_name));
2737 err |= __get_user(ifr.ifr_map.mem_start, &uifmap32->mem_start);
2738 err |= __get_user(ifr.ifr_map.mem_end, &uifmap32->mem_end);
2739 err |= __get_user(ifr.ifr_map.base_addr, &uifmap32->base_addr);
2740 err |= __get_user(ifr.ifr_map.irq, &uifmap32->irq);
2741 err |= __get_user(ifr.ifr_map.dma, &uifmap32->dma);
2742 err |= __get_user(ifr.ifr_map.port, &uifmap32->port);
2743 if (err)
2744 return -EFAULT;
2745
2746 old_fs = get_fs();
2747 set_fs (KERNEL_DS);
2748 err = dev_ioctl(net, cmd, (void __user *)&ifr);
2749 set_fs (old_fs);
2750
2751 if (cmd == SIOCGIFMAP && !err) {
2752 err = copy_to_user(uifr32, &ifr, sizeof(ifr.ifr_name));
2753 err |= __put_user(ifr.ifr_map.mem_start, &uifmap32->mem_start);
2754 err |= __put_user(ifr.ifr_map.mem_end, &uifmap32->mem_end);
2755 err |= __put_user(ifr.ifr_map.base_addr, &uifmap32->base_addr);
2756 err |= __put_user(ifr.ifr_map.irq, &uifmap32->irq);
2757 err |= __put_user(ifr.ifr_map.dma, &uifmap32->dma);
2758 err |= __put_user(ifr.ifr_map.port, &uifmap32->port);
2759 if (err)
2760 err = -EFAULT;
2761 }
2762 return err;
2763}
2764
2765static int compat_siocshwtstamp(struct net *net, struct compat_ifreq __user *uifr32)
2766{
2767 void __user *uptr;
2768 compat_uptr_t uptr32;
2769 struct ifreq __user *uifr;
2770
2771 uifr = compat_alloc_user_space(sizeof (*uifr));
2772 if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))
2773 return -EFAULT;
2774
2775 if (get_user(uptr32, &uifr32->ifr_data))
2776 return -EFAULT;
2777
2778 uptr = compat_ptr(uptr32);
2779
2780 if (put_user(uptr, &uifr->ifr_data))
2781 return -EFAULT;
2782
2783 return dev_ioctl(net, SIOCSHWTSTAMP, uifr);
2784}
2785
2786struct rtentry32 {
2787 u32 rt_pad1;
2788 struct sockaddr rt_dst; /* target address */
2789 struct sockaddr rt_gateway; /* gateway addr (RTF_GATEWAY) */
2790 struct sockaddr rt_genmask; /* target network mask (IP) */
2791 unsigned short rt_flags;
2792 short rt_pad2;
2793 u32 rt_pad3;
2794 unsigned char rt_tos;
2795 unsigned char rt_class;
2796 short rt_pad4;
2797 short rt_metric; /* +1 for binary compatibility! */
2798 /* char * */ u32 rt_dev; /* forcing the device at add */
2799 u32 rt_mtu; /* per route MTU/Window */
2800 u32 rt_window; /* Window clamping */
2801 unsigned short rt_irtt; /* Initial RTT */
2802};
2803
2804struct in6_rtmsg32 {
2805 struct in6_addr rtmsg_dst;
2806 struct in6_addr rtmsg_src;
2807 struct in6_addr rtmsg_gateway;
2808 u32 rtmsg_type;
2809 u16 rtmsg_dst_len;
2810 u16 rtmsg_src_len;
2811 u32 rtmsg_metric;
2812 u32 rtmsg_info;
2813 u32 rtmsg_flags;
2814 s32 rtmsg_ifindex;
2815};
2816
2817static int routing_ioctl(struct net *net, struct socket *sock,
2818 unsigned int cmd, void __user *argp)
2819{
2820 int ret;
2821 void *r = NULL;
2822 struct in6_rtmsg r6;
2823 struct rtentry r4;
2824 char devname[16];
2825 u32 rtdev;
2826 mm_segment_t old_fs = get_fs();
2827
2828 if (sock && sock->sk && sock->sk->sk_family == AF_INET6) { /* ipv6 */
2829 struct in6_rtmsg32 __user *ur6 = argp;
2830 ret = copy_from_user (&r6.rtmsg_dst, &(ur6->rtmsg_dst),
2831 3 * sizeof(struct in6_addr));
2832 ret |= __get_user (r6.rtmsg_type, &(ur6->rtmsg_type));
2833 ret |= __get_user (r6.rtmsg_dst_len, &(ur6->rtmsg_dst_len));
2834 ret |= __get_user (r6.rtmsg_src_len, &(ur6->rtmsg_src_len));
2835 ret |= __get_user (r6.rtmsg_metric, &(ur6->rtmsg_metric));
2836 ret |= __get_user (r6.rtmsg_info, &(ur6->rtmsg_info));
2837 ret |= __get_user (r6.rtmsg_flags, &(ur6->rtmsg_flags));
2838 ret |= __get_user (r6.rtmsg_ifindex, &(ur6->rtmsg_ifindex));
2839
2840 r = (void *) &r6;
2841 } else { /* ipv4 */
2842 struct rtentry32 __user *ur4 = argp;
2843 ret = copy_from_user (&r4.rt_dst, &(ur4->rt_dst),
2844 3 * sizeof(struct sockaddr));
2845 ret |= __get_user (r4.rt_flags, &(ur4->rt_flags));
2846 ret |= __get_user (r4.rt_metric, &(ur4->rt_metric));
2847 ret |= __get_user (r4.rt_mtu, &(ur4->rt_mtu));
2848 ret |= __get_user (r4.rt_window, &(ur4->rt_window));
2849 ret |= __get_user (r4.rt_irtt, &(ur4->rt_irtt));
2850 ret |= __get_user (rtdev, &(ur4->rt_dev));
2851 if (rtdev) {
2852 ret |= copy_from_user (devname, compat_ptr(rtdev), 15);
2853 r4.rt_dev = devname; devname[15] = 0;
2854 } else
2855 r4.rt_dev = NULL;
2856
2857 r = (void *) &r4;
2858 }
2859
2860 if (ret) {
2861 ret = -EFAULT;
2862 goto out;
2863 }
2864
2865 set_fs (KERNEL_DS);
2866 ret = sock_do_ioctl(net, sock, cmd, (unsigned long) r);
2867 set_fs (old_fs);
2868
2869out:
2870 return ret;
2871}
2872
2873/* Since old style bridge ioctl's endup using SIOCDEVPRIVATE
2874 * for some operations; this forces use of the newer bridge-utils that
2875 * use compatiable ioctls
2876 */
2877static int old_bridge_ioctl(compat_ulong_t __user *argp)
2878{
2879 compat_ulong_t tmp;
2880
2881 if (get_user(tmp, argp))
2882 return -EFAULT;
2883 if (tmp == BRCTL_GET_VERSION)
2884 return BRCTL_VERSION + 1;
2885 return -EINVAL;
2886}
2887
2888static int compat_sock_ioctl_trans(struct file *file, struct socket *sock,
2889 unsigned int cmd, unsigned long arg)
2890{
2891 void __user *argp = compat_ptr(arg);
2892 struct sock *sk = sock->sk;
2893 struct net *net = sock_net(sk);
2894
2895 if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15))
2896 return siocdevprivate_ioctl(net, cmd, argp);
2897
2898 switch (cmd) {
2899 case SIOCSIFBR:
2900 case SIOCGIFBR:
2901 return old_bridge_ioctl(argp);
2902 case SIOCGIFNAME:
2903 return dev_ifname32(net, argp);
2904 case SIOCGIFCONF:
2905 return dev_ifconf(net, argp);
2906 case SIOCETHTOOL:
2907 return ethtool_ioctl(net, argp);
2908 case SIOCWANDEV:
2909 return compat_siocwandev(net, argp);
2910 case SIOCGIFMAP:
2911 case SIOCSIFMAP:
2912 return compat_sioc_ifmap(net, cmd, argp);
2913 case SIOCBONDENSLAVE:
2914 case SIOCBONDRELEASE:
2915 case SIOCBONDSETHWADDR:
2916 case SIOCBONDSLAVEINFOQUERY:
2917 case SIOCBONDINFOQUERY:
2918 case SIOCBONDCHANGEACTIVE:
2919 return bond_ioctl(net, cmd, argp);
2920 case SIOCADDRT:
2921 case SIOCDELRT:
2922 return routing_ioctl(net, sock, cmd, argp);
2923 case SIOCGSTAMP:
2924 return do_siocgstamp(net, sock, cmd, argp);
2925 case SIOCGSTAMPNS:
2926 return do_siocgstampns(net, sock, cmd, argp);
2927 case SIOCSHWTSTAMP:
2928 return compat_siocshwtstamp(net, argp);
2929
2930 case FIOSETOWN:
2931 case SIOCSPGRP:
2932 case FIOGETOWN:
2933 case SIOCGPGRP:
2934 case SIOCBRADDBR:
2935 case SIOCBRDELBR:
2936 case SIOCGIFVLAN:
2937 case SIOCSIFVLAN:
2938 case SIOCADDDLCI:
2939 case SIOCDELDLCI:
2940 return sock_ioctl(file, cmd, arg);
2941
2942 case SIOCGIFFLAGS:
2943 case SIOCSIFFLAGS:
2944 case SIOCGIFMETRIC:
2945 case SIOCSIFMETRIC:
2946 case SIOCGIFMTU:
2947 case SIOCSIFMTU:
2948 case SIOCGIFMEM:
2949 case SIOCSIFMEM:
2950 case SIOCGIFHWADDR:
2951 case SIOCSIFHWADDR:
2952 case SIOCADDMULTI:
2953 case SIOCDELMULTI:
2954 case SIOCGIFINDEX:
2955 case SIOCGIFADDR:
2956 case SIOCSIFADDR:
2957 case SIOCSIFHWBROADCAST:
2958 case SIOCDIFADDR:
2959 case SIOCGIFBRDADDR:
2960 case SIOCSIFBRDADDR:
2961 case SIOCGIFDSTADDR:
2962 case SIOCSIFDSTADDR:
2963 case SIOCGIFNETMASK:
2964 case SIOCSIFNETMASK:
2965 case SIOCSIFPFLAGS:
2966 case SIOCGIFPFLAGS:
2967 case SIOCGIFTXQLEN:
2968 case SIOCSIFTXQLEN:
2969 case SIOCBRADDIF:
2970 case SIOCBRDELIF:
2971 case SIOCSIFNAME:
2972 case SIOCGMIIPHY:
2973 case SIOCGMIIREG:
2974 case SIOCSMIIREG:
2975 return dev_ifsioc(net, sock, cmd, argp);
2976
2977 case SIOCSARP:
2978 case SIOCGARP:
2979 case SIOCDARP:
2980 case SIOCATMARK:
2981 return sock_do_ioctl(net, sock, cmd, arg);
2982 }
2983
2984 /* Prevent warning from compat_sys_ioctl, these always
2985 * result in -EINVAL in the native case anyway. */
2986 switch (cmd) {
2987 case SIOCRTMSG:
2988 case SIOCGIFCOUNT:
2989 case SIOCSRARP:
2990 case SIOCGRARP:
2991 case SIOCDRARP:
2992 case SIOCSIFLINK:
2993 case SIOCGIFSLAVE:
2994 case SIOCSIFSLAVE:
2995 return -EINVAL;
2996 }
2997
2998 return -ENOIOCTLCMD;
2999}
3000
2303static long compat_sock_ioctl(struct file *file, unsigned cmd, 3001static long compat_sock_ioctl(struct file *file, unsigned cmd,
2304 unsigned long arg) 3002 unsigned long arg)
2305{ 3003{
@@ -2318,6 +3016,9 @@ static long compat_sock_ioctl(struct file *file, unsigned cmd,
2318 (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)) 3016 (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST))
2319 ret = compat_wext_handle_ioctl(net, cmd, arg); 3017 ret = compat_wext_handle_ioctl(net, cmd, arg);
2320 3018
3019 if (ret == -ENOIOCTLCMD)
3020 ret = compat_sock_ioctl_trans(file, sock, cmd, arg);
3021
2321 return ret; 3022 return ret;
2322} 3023}
2323#endif 3024#endif
generated by cgit v1.2.2 (git 2.25.0) at 2025-05-05 16:26:51 -0400