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