1 files changed, 177 insertions, 57 deletions

diff --git a/net/socket.c b/net/socket.c
index 66c4a8cf6db9..1310a82cbba7 100644
--- a/net/socket.c
+++ b/net/socket.c
@@ -63,11 +63,13 @@
 #include <linux/file.h>
 #include <linux/net.h>
 #include <linux/interrupt.h>
+#include <linux/thread_info.h>
 #include <linux/rcupdate.h>
 #include <linux/netdevice.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
 #include <linux/mutex.h>
+#include <linux/thread_info.h>
 #include <linux/wanrouter.h>
 #include <linux/if_bridge.h>
 #include <linux/if_frad.h>
@@ -90,6 +92,7 @@
 #include <asm/unistd.h>
 
 #include <net/compat.h>
+#include <net/wext.h>
 
 #include <net/sock.h>
 #include <linux/netfilter.h>
@@ -179,9 +182,9 @@ static DEFINE_PER_CPU(int, sockets_in_use) = 0;
  *      invalid addresses -EFAULT is returned. On a success 0 is returned.
  */
 
-int move_addr_to_kernel(void __user *uaddr, int ulen, void *kaddr)
+int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr *kaddr)
 {
-        if (ulen < 0 || ulen > MAX_SOCK_ADDR)
+        if (ulen < 0 || ulen > sizeof(struct sockaddr_storage))
                 return -EINVAL;
         if (ulen == 0)
                 return 0;
@@ -207,7 +210,7 @@ int move_addr_to_kernel(void __user *uaddr, int ulen, void *kaddr)
  *      specified. Zero is returned for a success.
  */
 
-int move_addr_to_user(void *kaddr, int klen, void __user *uaddr,
+int move_addr_to_user(struct sockaddr *kaddr, int klen, void __user *uaddr,
                       int __user *ulen)
 {
         int err;
@@ -218,7 +221,7 @@ int move_addr_to_user(void *kaddr, int klen, void __user *uaddr,
                 return err;
         if (len > klen)
                 len = klen;
-        if (len < 0 || len > MAX_SOCK_ADDR)
+        if (len < 0 || len > sizeof(struct sockaddr_storage))
                 return -EINVAL;
         if (len) {
                 if (audit_sockaddr(klen, kaddr))
@@ -348,11 +351,11 @@ static struct dentry_operations sockfs_dentry_operations = {
  *      but we take care of internal coherence yet.
  */
 
-static int sock_alloc_fd(struct file **filep)
+static int sock_alloc_fd(struct file **filep, int flags)
 {
         int fd;
 
-        fd = get_unused_fd();
+        fd = get_unused_fd_flags(flags);
         if (likely(fd >= 0)) {
                 struct file *file = get_empty_filp();
 
@@ -366,7 +369,7 @@ static int sock_alloc_fd(struct file **filep)
         return fd;
 }
 
-static int sock_attach_fd(struct socket *sock, struct file *file)
+static int sock_attach_fd(struct socket *sock, struct file *file, int flags)
 {
         struct dentry *dentry;
         struct qstr name = { .name = "" };
@@ -388,20 +391,20 @@ static int sock_attach_fd(struct socket *sock, struct file *file)
         init_file(file, sock_mnt, dentry, FMODE_READ | FMODE_WRITE,
                   &socket_file_ops);
         SOCK_INODE(sock)->i_fop = &socket_file_ops;
-        file->f_flags = O_RDWR;
+        file->f_flags = O_RDWR | (flags & O_NONBLOCK);
         file->f_pos = 0;
         file->private_data = sock;
 
         return 0;
 }
 
-int sock_map_fd(struct socket *sock)
+int sock_map_fd(struct socket *sock, int flags)
 {
         struct file *newfile;
-        int fd = sock_alloc_fd(&newfile);
+        int fd = sock_alloc_fd(&newfile, flags);
 
         if (likely(fd >= 0)) {
-                int err = sock_attach_fd(sock, newfile);
+                int err = sock_attach_fd(sock, newfile, flags);
 
                 if (unlikely(err < 0)) {
                         put_filp(newfile);
@@ -1217,12 +1220,27 @@ asmlinkage long sys_socket(int family, int type, int protocol)
 {
         int retval;
         struct socket *sock;
+        int flags;
+
+        /* Check the SOCK_* constants for consistency.  */
+        BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);
+        BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK);
+        BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);
+        BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);
+
+        flags = type & ~SOCK_TYPE_MASK;
+        if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
+                return -EINVAL;
+        type &= SOCK_TYPE_MASK;
+
+        if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
+                flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
 
         retval = sock_create(family, type, protocol, &sock);
         if (retval < 0)
                 goto out;
 
-        retval = sock_map_fd(sock);
+        retval = sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));
         if (retval < 0)
                 goto out_release;
 
@@ -1245,6 +1263,15 @@ asmlinkage long sys_socketpair(int family, int type, int protocol,
         struct socket *sock1, *sock2;
         int fd1, fd2, err;
         struct file *newfile1, *newfile2;
+        int flags;
+
+        flags = type & ~SOCK_TYPE_MASK;
+        if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
+                return -EINVAL;
+        type &= SOCK_TYPE_MASK;
+
+        if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
+                flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
 
         /*
          * Obtain the first socket and check if the underlying protocol
@@ -1263,13 +1290,13 @@ asmlinkage long sys_socketpair(int family, int type, int protocol,
         if (err < 0)
                 goto out_release_both;
 
-        fd1 = sock_alloc_fd(&newfile1);
+        fd1 = sock_alloc_fd(&newfile1, flags & O_CLOEXEC);
         if (unlikely(fd1 < 0)) {
                 err = fd1;
                 goto out_release_both;
         }
 
-        fd2 = sock_alloc_fd(&newfile2);
+        fd2 = sock_alloc_fd(&newfile2, flags & O_CLOEXEC);
         if (unlikely(fd2 < 0)) {
                 err = fd2;
                 put_filp(newfile1);
@@ -1277,12 +1304,12 @@ asmlinkage long sys_socketpair(int family, int type, int protocol,
                 goto out_release_both;
         }
 
-        err = sock_attach_fd(sock1, newfile1);
+        err = sock_attach_fd(sock1, newfile1, flags & O_NONBLOCK);
         if (unlikely(err < 0)) {
                 goto out_fd2;
         }
 
-        err = sock_attach_fd(sock2, newfile2);
+        err = sock_attach_fd(sock2, newfile2, flags & O_NONBLOCK);
         if (unlikely(err < 0)) {
                 fput(newfile1);
                 goto out_fd1;
@@ -1341,20 +1368,20 @@ out_fd:
 asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen)
 {
         struct socket *sock;
-        char address[MAX_SOCK_ADDR];
+        struct sockaddr_storage address;
         int err, fput_needed;
 
         sock = sockfd_lookup_light(fd, &err, &fput_needed);
         if (sock) {
-                err = move_addr_to_kernel(umyaddr, addrlen, address);
+                err = move_addr_to_kernel(umyaddr, addrlen, (struct sockaddr *)&address);
                 if (err >= 0) {
                         err = security_socket_bind(sock,
-                                                   (struct sockaddr *)address,
+                                                   (struct sockaddr *)&address,
                                                    addrlen);
                         if (!err)
                                 err = sock->ops->bind(sock,
                                                       (struct sockaddr *)
-                                                      address, addrlen);
+                                                      &address, addrlen);
                 }
                 fput_light(sock->file, fput_needed);
         }
@@ -1400,13 +1427,19 @@ asmlinkage long sys_listen(int fd, int backlog)
  *      clean when we restucture accept also.
  */
 
-asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr,
-                           int __user *upeer_addrlen)
+long do_accept(int fd, struct sockaddr __user *upeer_sockaddr,
+               int __user *upeer_addrlen, int flags)
 {
         struct socket *sock, *newsock;
         struct file *newfile;
         int err, len, newfd, fput_needed;
-        char address[MAX_SOCK_ADDR];
+        struct sockaddr_storage address;
+
+        if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
+                return -EINVAL;
+
+        if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
+                flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
 
         sock = sockfd_lookup_light(fd, &err, &fput_needed);
         if (!sock)
@@ -1425,14 +1458,14 @@ asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr,
          */
         __module_get(newsock->ops->owner);
 
-        newfd = sock_alloc_fd(&newfile);
+        newfd = sock_alloc_fd(&newfile, flags & O_CLOEXEC);
         if (unlikely(newfd < 0)) {
                 err = newfd;
                 sock_release(newsock);
                 goto out_put;
         }
 
-        err = sock_attach_fd(newsock, newfile);
+        err = sock_attach_fd(newsock, newfile, flags & O_NONBLOCK);
         if (err < 0)
                 goto out_fd_simple;
 
@@ -1445,13 +1478,13 @@ asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr,
                 goto out_fd;
 
         if (upeer_sockaddr) {
-                if (newsock->ops->getname(newsock, (struct sockaddr *)address,
+                if (newsock->ops->getname(newsock, (struct sockaddr *)&address,
                                           &len, 2) < 0) {
                         err = -ECONNABORTED;
                         goto out_fd;
                 }
-                err = move_addr_to_user(address, len, upeer_sockaddr,
-                                        upeer_addrlen);
+                err = move_addr_to_user((struct sockaddr *)&address,
+                                        len, upeer_sockaddr, upeer_addrlen);
                 if (err < 0)
                         goto out_fd;
         }
@@ -1478,6 +1511,66 @@ out_fd:
         goto out_put;
 }
 
+#ifdef HAVE_SET_RESTORE_SIGMASK
+asmlinkage long sys_paccept(int fd, struct sockaddr __user *upeer_sockaddr,
+                            int __user *upeer_addrlen,
+                            const sigset_t __user *sigmask,
+                            size_t sigsetsize, int flags)
+{
+        sigset_t ksigmask, sigsaved;
+        int ret;
+
+        if (sigmask) {
+                /* XXX: Don't preclude handling different sized sigset_t's.  */
+                if (sigsetsize != sizeof(sigset_t))
+                        return -EINVAL;
+                if (copy_from_user(&ksigmask, sigmask, sizeof(ksigmask)))
+                        return -EFAULT;
+
+                sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
+                sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
+        }
+
+        ret = do_accept(fd, upeer_sockaddr, upeer_addrlen, flags);
+
+        if (ret < 0 && signal_pending(current)) {
+                /*
+                 * Don't restore the signal mask yet. Let do_signal() deliver
+                 * the signal on the way back to userspace, before the signal
+                 * mask is restored.
+                 */
+                if (sigmask) {
+                        memcpy(&current->saved_sigmask, &sigsaved,
+                               sizeof(sigsaved));
+                        set_restore_sigmask();
+                }
+        } else if (sigmask)
+                sigprocmask(SIG_SETMASK, &sigsaved, NULL);
+
+        return ret;
+}
+#else
+asmlinkage long sys_paccept(int fd, struct sockaddr __user *upeer_sockaddr,
+                            int __user *upeer_addrlen,
+                            const sigset_t __user *sigmask,
+                            size_t sigsetsize, int flags)
+{
+        /* The platform does not support restoring the signal mask in the
+         * return path.  So we do not allow using paccept() with a signal
+         * mask.  */
+        if (sigmask)
+                return -EINVAL;
+
+        return do_accept(fd, upeer_sockaddr, upeer_addrlen, flags);
+}
+#endif
+
+asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr,
+                           int __user *upeer_addrlen)
+{
+        return do_accept(fd, upeer_sockaddr, upeer_addrlen, 0);
+}
+
 /*
  *      Attempt to connect to a socket with the server address.  The address
  *      is in user space so we verify it is OK and move it to kernel space.
@@ -1494,22 +1587,22 @@ asmlinkage long sys_connect(int fd, struct sockaddr __user *uservaddr,
                             int addrlen)
 {
         struct socket *sock;
-        char address[MAX_SOCK_ADDR];
+        struct sockaddr_storage address;
         int err, fput_needed;
 
         sock = sockfd_lookup_light(fd, &err, &fput_needed);
         if (!sock)
                 goto out;
-        err = move_addr_to_kernel(uservaddr, addrlen, address);
+        err = move_addr_to_kernel(uservaddr, addrlen, (struct sockaddr *)&address);
         if (err < 0)
                 goto out_put;
 
         err =
-            security_socket_connect(sock, (struct sockaddr *)address, addrlen);
+            security_socket_connect(sock, (struct sockaddr *)&address, addrlen);
         if (err)
                 goto out_put;
 
-        err = sock->ops->connect(sock, (struct sockaddr *)address, addrlen,
+        err = sock->ops->connect(sock, (struct sockaddr *)&address, addrlen,
                                  sock->file->f_flags);
 out_put:
         fput_light(sock->file, fput_needed);
@@ -1526,7 +1619,7 @@ asmlinkage long sys_getsockname(int fd, struct sockaddr __user *usockaddr,
                                 int __user *usockaddr_len)
 {
         struct socket *sock;
-        char address[MAX_SOCK_ADDR];
+        struct sockaddr_storage address;
         int len, err, fput_needed;
 
         sock = sockfd_lookup_light(fd, &err, &fput_needed);
@@ -1537,10 +1630,10 @@ asmlinkage long sys_getsockname(int fd, struct sockaddr __user *usockaddr,
         if (err)
                 goto out_put;
 
-        err = sock->ops->getname(sock, (struct sockaddr *)address, &len, 0);
+        err = sock->ops->getname(sock, (struct sockaddr *)&address, &len, 0);
         if (err)
                 goto out_put;
-        err = move_addr_to_user(address, len, usockaddr, usockaddr_len);
+        err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr, usockaddr_len);
 
 out_put:
         fput_light(sock->file, fput_needed);
@@ -1557,7 +1650,7 @@ asmlinkage long sys_getpeername(int fd, struct sockaddr __user *usockaddr,
                                 int __user *usockaddr_len)
 {
         struct socket *sock;
-        char address[MAX_SOCK_ADDR];
+        struct sockaddr_storage address;
         int len, err, fput_needed;
 
         sock = sockfd_lookup_light(fd, &err, &fput_needed);
@@ -1569,10 +1662,10 @@ asmlinkage long sys_getpeername(int fd, struct sockaddr __user *usockaddr,
                 }
 
                 err =
-                    sock->ops->getname(sock, (struct sockaddr *)address, &len,
+                    sock->ops->getname(sock, (struct sockaddr *)&address, &len,
                                        1);
                 if (!err)
-                        err = move_addr_to_user(address, len, usockaddr,
+                        err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr,
                                                 usockaddr_len);
                 fput_light(sock->file, fput_needed);
         }
@@ -1590,7 +1683,7 @@ asmlinkage long sys_sendto(int fd, void __user *buff, size_t len,
                            int addr_len)
 {
         struct socket *sock;
-        char address[MAX_SOCK_ADDR];
+        struct sockaddr_storage address;
         int err;
         struct msghdr msg;
         struct iovec iov;
@@ -1609,10 +1702,10 @@ asmlinkage long sys_sendto(int fd, void __user *buff, size_t len,
         msg.msg_controllen = 0;
         msg.msg_namelen = 0;
         if (addr) {
-                err = move_addr_to_kernel(addr, addr_len, address);
+                err = move_addr_to_kernel(addr, addr_len, (struct sockaddr *)&address);
                 if (err < 0)
                         goto out_put;
-                msg.msg_name = address;
+                msg.msg_name = (struct sockaddr *)&address;
                 msg.msg_namelen = addr_len;
         }
         if (sock->file->f_flags & O_NONBLOCK)
@@ -1648,7 +1741,7 @@ asmlinkage long sys_recvfrom(int fd, void __user *ubuf, size_t size,
         struct socket *sock;
         struct iovec iov;
         struct msghdr msg;
-        char address[MAX_SOCK_ADDR];
+        struct sockaddr_storage address;
         int err, err2;
         int fput_needed;
 
@@ -1662,14 +1755,15 @@ asmlinkage long sys_recvfrom(int fd, void __user *ubuf, size_t size,
         msg.msg_iov = &iov;
         iov.iov_len = size;
         iov.iov_base = ubuf;
-        msg.msg_name = address;
-        msg.msg_namelen = MAX_SOCK_ADDR;
+        msg.msg_name = (struct sockaddr *)&address;
+        msg.msg_namelen = sizeof(address);
         if (sock->file->f_flags & O_NONBLOCK)
                 flags |= MSG_DONTWAIT;
         err = sock_recvmsg(sock, &msg, size, flags);
 
         if (err >= 0 && addr != NULL) {
-                err2 = move_addr_to_user(address, msg.msg_namelen, addr, addr_len);
+                err2 = move_addr_to_user((struct sockaddr *)&address,
+                                         msg.msg_namelen, addr, addr_len);
                 if (err2 < 0)
                         err = err2;
         }
@@ -1789,7 +1883,7 @@ asmlinkage long sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags)
         struct compat_msghdr __user *msg_compat =
             (struct compat_msghdr __user *)msg;
         struct socket *sock;
-        char address[MAX_SOCK_ADDR];
+        struct sockaddr_storage address;
         struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
         unsigned char ctl[sizeof(struct cmsghdr) + 20]
             __attribute__ ((aligned(sizeof(__kernel_size_t))));
@@ -1827,9 +1921,13 @@ asmlinkage long sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags)
 
         /* This will also move the address data into kernel space */
         if (MSG_CMSG_COMPAT & flags) {
-                err = verify_compat_iovec(&msg_sys, iov, address, VERIFY_READ);
+                err = verify_compat_iovec(&msg_sys, iov,
+                                          (struct sockaddr *)&address,
+                                          VERIFY_READ);
         } else
-                err = verify_iovec(&msg_sys, iov, address, VERIFY_READ);
+                err = verify_iovec(&msg_sys, iov,
+                                   (struct sockaddr *)&address,
+                                   VERIFY_READ);
         if (err < 0)
                 goto out_freeiov;
         total_len = err;
@@ -1900,7 +1998,7 @@ asmlinkage long sys_recvmsg(int fd, struct msghdr __user *msg,
         int fput_needed;
 
         /* kernel mode address */
-        char addr[MAX_SOCK_ADDR];
+        struct sockaddr_storage addr;
 
         /* user mode address pointers */
         struct sockaddr __user *uaddr;
@@ -1938,9 +2036,13 @@ asmlinkage long sys_recvmsg(int fd, struct msghdr __user *msg,
         uaddr = (__force void __user *)msg_sys.msg_name;
         uaddr_len = COMPAT_NAMELEN(msg);
         if (MSG_CMSG_COMPAT & flags) {
-                err = verify_compat_iovec(&msg_sys, iov, addr, VERIFY_WRITE);
+                err = verify_compat_iovec(&msg_sys, iov,
+                                          (struct sockaddr *)&addr,
+                                          VERIFY_WRITE);
         } else
-                err = verify_iovec(&msg_sys, iov, addr, VERIFY_WRITE);
+                err = verify_iovec(&msg_sys, iov,
+                                   (struct sockaddr *)&addr,
+                                   VERIFY_WRITE);
         if (err < 0)
                 goto out_freeiov;
         total_len = err;
@@ -1956,7 +2058,8 @@ asmlinkage long sys_recvmsg(int fd, struct msghdr __user *msg,
         len = err;
 
         if (uaddr != NULL) {
-                err = move_addr_to_user(addr, msg_sys.msg_namelen, uaddr,
+                err = move_addr_to_user((struct sockaddr *)&addr,
+                                        msg_sys.msg_namelen, uaddr,
                                         uaddr_len);
                 if (err < 0)
                         goto out_freeiov;
@@ -1988,10 +2091,11 @@ out:
 
 /* Argument list sizes for sys_socketcall */
 #define AL(x) ((x) * sizeof(unsigned long))
-static const unsigned char nargs[18]={
+static const unsigned char nargs[19]={
         AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
         AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
-        AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)
+        AL(6),AL(2),AL(5),AL(5),AL(3),AL(3),
+        AL(6)
 };
 
 #undef AL
@@ -2010,7 +2114,7 @@ asmlinkage long sys_socketcall(int call, unsigned long __user *args)
         unsigned long a0, a1;
         int err;
 
-        if (call < 1 || call > SYS_RECVMSG)
+        if (call < 1 || call > SYS_PACCEPT)
                 return -EINVAL;
 
         /* copy_from_user should be SMP safe. */
@@ -2039,8 +2143,8 @@ asmlinkage long sys_socketcall(int call, unsigned long __user *args)
                 break;
         case SYS_ACCEPT:
                 err =
-                    sys_accept(a0, (struct sockaddr __user *)a1,
-                               (int __user *)a[2]);
+                    do_accept(a0, (struct sockaddr __user *)a1,
+                              (int __user *)a[2], 0);
                 break;
         case SYS_GETSOCKNAME:
                 err =
@@ -2087,6 +2191,13 @@ asmlinkage long sys_socketcall(int call, unsigned long __user *args)
         case SYS_RECVMSG:
                 err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]);
                 break;
+        case SYS_PACCEPT:
+                err =
+                    sys_paccept(a0, (struct sockaddr __user *)a1,
+                                (int __user *)a[2],
+                                (const sigset_t __user *) a[3],
+                                a[4], a[5]);
+                break;
         default:
                 err = -EINVAL;
                 break;
@@ -2210,10 +2321,19 @@ static long compat_sock_ioctl(struct file *file, unsigned cmd,
 {
         struct socket *sock = file->private_data;
         int ret = -ENOIOCTLCMD;
+        struct sock *sk;
+        struct net *net;
+
+        sk = sock->sk;
+        net = sock_net(sk);
 
         if (sock->ops->compat_ioctl)
                 ret = sock->ops->compat_ioctl(sock, cmd, arg);
 
+        if (ret == -ENOIOCTLCMD &&
+            (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST))
+                ret = compat_wext_handle_ioctl(net, cmd, arg);
+
         return ret;
 }
 #endif