11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * NET An implementation of the SOCKET network access protocol. 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Version: @(#)socket.c 1.1.93 18/02/95 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Authors: Orest Zborowski, <obz@Kodak.COM> 702c30a84SJesper Juhl * Ross Biro 81da177e4SLinus Torvalds * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 91da177e4SLinus Torvalds * 101da177e4SLinus Torvalds * Fixes: 111da177e4SLinus Torvalds * Anonymous : NOTSOCK/BADF cleanup. Error fix in 121da177e4SLinus Torvalds * shutdown() 131da177e4SLinus Torvalds * Alan Cox : verify_area() fixes 141da177e4SLinus Torvalds * Alan Cox : Removed DDI 151da177e4SLinus Torvalds * Jonathan Kamens : SOCK_DGRAM reconnect bug 161da177e4SLinus Torvalds * Alan Cox : Moved a load of checks to the very 171da177e4SLinus Torvalds * top level. 181da177e4SLinus Torvalds * Alan Cox : Move address structures to/from user 191da177e4SLinus Torvalds * mode above the protocol layers. 201da177e4SLinus Torvalds * Rob Janssen : Allow 0 length sends. 211da177e4SLinus Torvalds * Alan Cox : Asynchronous I/O support (cribbed from the 221da177e4SLinus Torvalds * tty drivers). 231da177e4SLinus Torvalds * Niibe Yutaka : Asynchronous I/O for writes (4.4BSD style) 241da177e4SLinus Torvalds * Jeff Uphoff : Made max number of sockets command-line 251da177e4SLinus Torvalds * configurable. 261da177e4SLinus Torvalds * Matti Aarnio : Made the number of sockets dynamic, 271da177e4SLinus Torvalds * to be allocated when needed, and mr. 281da177e4SLinus Torvalds * Uphoff's max is used as max to be 291da177e4SLinus Torvalds * allowed to allocate. 301da177e4SLinus Torvalds * Linus : Argh. removed all the socket allocation 311da177e4SLinus Torvalds * altogether: it's in the inode now. 321da177e4SLinus Torvalds * Alan Cox : Made sock_alloc()/sock_release() public 331da177e4SLinus Torvalds * for NetROM and future kernel nfsd type 341da177e4SLinus Torvalds * stuff. 351da177e4SLinus Torvalds * Alan Cox : sendmsg/recvmsg basics. 361da177e4SLinus Torvalds * Tom Dyas : Export net symbols. 371da177e4SLinus Torvalds * Marcin Dalecki : Fixed problems with CONFIG_NET="n". 381da177e4SLinus Torvalds * Alan Cox : Added thread locking to sys_* calls 391da177e4SLinus Torvalds * for sockets. May have errors at the 401da177e4SLinus Torvalds * moment. 411da177e4SLinus Torvalds * Kevin Buhr : Fixed the dumb errors in the above. 421da177e4SLinus Torvalds * Andi Kleen : Some small cleanups, optimizations, 431da177e4SLinus Torvalds * and fixed a copy_from_user() bug. 441da177e4SLinus Torvalds * Tigran Aivazian : sys_send(args) calls sys_sendto(args, NULL, 0) 451da177e4SLinus Torvalds * Tigran Aivazian : Made listen(2) backlog sanity checks 461da177e4SLinus Torvalds * protocol-independent 471da177e4SLinus Torvalds * 481da177e4SLinus Torvalds * 491da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or 501da177e4SLinus Torvalds * modify it under the terms of the GNU General Public License 511da177e4SLinus Torvalds * as published by the Free Software Foundation; either version 521da177e4SLinus Torvalds * 2 of the License, or (at your option) any later version. 531da177e4SLinus Torvalds * 541da177e4SLinus Torvalds * 551da177e4SLinus Torvalds * This module is effectively the top level interface to the BSD socket 561da177e4SLinus Torvalds * paradigm. 571da177e4SLinus Torvalds * 581da177e4SLinus Torvalds * Based upon Swansea University Computer Society NET3.039 591da177e4SLinus Torvalds */ 601da177e4SLinus Torvalds 611da177e4SLinus Torvalds #include <linux/mm.h> 621da177e4SLinus Torvalds #include <linux/socket.h> 631da177e4SLinus Torvalds #include <linux/file.h> 641da177e4SLinus Torvalds #include <linux/net.h> 651da177e4SLinus Torvalds #include <linux/interrupt.h> 66aaca0bdcSUlrich Drepper #include <linux/thread_info.h> 6755737fdaSStephen Hemminger #include <linux/rcupdate.h> 681da177e4SLinus Torvalds #include <linux/netdevice.h> 691da177e4SLinus Torvalds #include <linux/proc_fs.h> 701da177e4SLinus Torvalds #include <linux/seq_file.h> 714a3e2f71SArjan van de Ven #include <linux/mutex.h> 721da177e4SLinus Torvalds #include <linux/wanrouter.h> 731da177e4SLinus Torvalds #include <linux/if_bridge.h> 7420380731SArnaldo Carvalho de Melo #include <linux/if_frad.h> 7520380731SArnaldo Carvalho de Melo #include <linux/if_vlan.h> 761da177e4SLinus Torvalds #include <linux/init.h> 771da177e4SLinus Torvalds #include <linux/poll.h> 781da177e4SLinus Torvalds #include <linux/cache.h> 791da177e4SLinus Torvalds #include <linux/module.h> 801da177e4SLinus Torvalds #include <linux/highmem.h> 811da177e4SLinus Torvalds #include <linux/mount.h> 821da177e4SLinus Torvalds #include <linux/security.h> 831da177e4SLinus Torvalds #include <linux/syscalls.h> 841da177e4SLinus Torvalds #include <linux/compat.h> 851da177e4SLinus Torvalds #include <linux/kmod.h> 863ec3b2fbSDavid Woodhouse #include <linux/audit.h> 87d86b5e0eSAdrian Bunk #include <linux/wireless.h> 881b8d7ae4SEric W. Biederman #include <linux/nsproxy.h> 891fd7317dSNick Black #include <linux/magic.h> 905a0e3ad6STejun Heo #include <linux/slab.h> 911da177e4SLinus Torvalds 921da177e4SLinus Torvalds #include <asm/uaccess.h> 931da177e4SLinus Torvalds #include <asm/unistd.h> 941da177e4SLinus Torvalds 951da177e4SLinus Torvalds #include <net/compat.h> 9687de87d5SDavid S. Miller #include <net/wext.h> 971da177e4SLinus Torvalds 981da177e4SLinus Torvalds #include <net/sock.h> 991da177e4SLinus Torvalds #include <linux/netfilter.h> 1001da177e4SLinus Torvalds 1016b96018bSArnd Bergmann #include <linux/if_tun.h> 1026b96018bSArnd Bergmann #include <linux/ipv6_route.h> 1036b96018bSArnd Bergmann #include <linux/route.h> 1046b96018bSArnd Bergmann #include <linux/sockios.h> 1056b96018bSArnd Bergmann #include <linux/atalk.h> 1066b96018bSArnd Bergmann 1071da177e4SLinus Torvalds static int sock_no_open(struct inode *irrelevant, struct file *dontcare); 108027445c3SBadari Pulavarty static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov, 109027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos); 110027445c3SBadari Pulavarty static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov, 111027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos); 1121da177e4SLinus Torvalds static int sock_mmap(struct file *file, struct vm_area_struct *vma); 1131da177e4SLinus Torvalds 1141da177e4SLinus Torvalds static int sock_close(struct inode *inode, struct file *file); 1151da177e4SLinus Torvalds static unsigned int sock_poll(struct file *file, 1161da177e4SLinus Torvalds struct poll_table_struct *wait); 11789bddce5SStephen Hemminger static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg); 11889bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 11989bbfc95SShaun Pereira static long compat_sock_ioctl(struct file *file, 12089bbfc95SShaun Pereira unsigned int cmd, unsigned long arg); 12189bbfc95SShaun Pereira #endif 1221da177e4SLinus Torvalds static int sock_fasync(int fd, struct file *filp, int on); 1231da177e4SLinus Torvalds static ssize_t sock_sendpage(struct file *file, struct page *page, 1241da177e4SLinus Torvalds int offset, size_t size, loff_t *ppos, int more); 1259c55e01cSJens Axboe static ssize_t sock_splice_read(struct file *file, loff_t *ppos, 1269c55e01cSJens Axboe struct pipe_inode_info *pipe, size_t len, 1279c55e01cSJens Axboe unsigned int flags); 1281da177e4SLinus Torvalds 1291da177e4SLinus Torvalds /* 1301da177e4SLinus Torvalds * Socket files have a set of 'special' operations as well as the generic file ones. These don't appear 1311da177e4SLinus Torvalds * in the operation structures but are done directly via the socketcall() multiplexor. 1321da177e4SLinus Torvalds */ 1331da177e4SLinus Torvalds 134da7071d7SArjan van de Ven static const struct file_operations socket_file_ops = { 1351da177e4SLinus Torvalds .owner = THIS_MODULE, 1361da177e4SLinus Torvalds .llseek = no_llseek, 1371da177e4SLinus Torvalds .aio_read = sock_aio_read, 1381da177e4SLinus Torvalds .aio_write = sock_aio_write, 1391da177e4SLinus Torvalds .poll = sock_poll, 1401da177e4SLinus Torvalds .unlocked_ioctl = sock_ioctl, 14189bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 14289bbfc95SShaun Pereira .compat_ioctl = compat_sock_ioctl, 14389bbfc95SShaun Pereira #endif 1441da177e4SLinus Torvalds .mmap = sock_mmap, 1451da177e4SLinus Torvalds .open = sock_no_open, /* special open code to disallow open via /proc */ 1461da177e4SLinus Torvalds .release = sock_close, 1471da177e4SLinus Torvalds .fasync = sock_fasync, 1485274f052SJens Axboe .sendpage = sock_sendpage, 1495274f052SJens Axboe .splice_write = generic_splice_sendpage, 1509c55e01cSJens Axboe .splice_read = sock_splice_read, 1511da177e4SLinus Torvalds }; 1521da177e4SLinus Torvalds 1531da177e4SLinus Torvalds /* 1541da177e4SLinus Torvalds * The protocol list. Each protocol is registered in here. 1551da177e4SLinus Torvalds */ 1561da177e4SLinus Torvalds 1571da177e4SLinus Torvalds static DEFINE_SPINLOCK(net_family_lock); 158f0fd27d4SStephen Hemminger static const struct net_proto_family *net_families[NPROTO] __read_mostly; 1591da177e4SLinus Torvalds 1601da177e4SLinus Torvalds /* 1611da177e4SLinus Torvalds * Statistics counters of the socket lists 1621da177e4SLinus Torvalds */ 1631da177e4SLinus Torvalds 1641da177e4SLinus Torvalds static DEFINE_PER_CPU(int, sockets_in_use) = 0; 1651da177e4SLinus Torvalds 1661da177e4SLinus Torvalds /* 16789bddce5SStephen Hemminger * Support routines. 16889bddce5SStephen Hemminger * Move socket addresses back and forth across the kernel/user 1691da177e4SLinus Torvalds * divide and look after the messy bits. 1701da177e4SLinus Torvalds */ 1711da177e4SLinus Torvalds 1721da177e4SLinus Torvalds #define MAX_SOCK_ADDR 128 /* 108 for Unix domain - 1731da177e4SLinus Torvalds 16 for IP, 16 for IPX, 1741da177e4SLinus Torvalds 24 for IPv6, 1751da177e4SLinus Torvalds about 80 for AX.25 1761da177e4SLinus Torvalds must be at least one bigger than 1771da177e4SLinus Torvalds the AF_UNIX size (see net/unix/af_unix.c 1781da177e4SLinus Torvalds :unix_mkname()). 1791da177e4SLinus Torvalds */ 1801da177e4SLinus Torvalds 1811da177e4SLinus Torvalds /** 1821da177e4SLinus Torvalds * move_addr_to_kernel - copy a socket address into kernel space 1831da177e4SLinus Torvalds * @uaddr: Address in user space 1841da177e4SLinus Torvalds * @kaddr: Address in kernel space 1851da177e4SLinus Torvalds * @ulen: Length in user space 1861da177e4SLinus Torvalds * 1871da177e4SLinus Torvalds * The address is copied into kernel space. If the provided address is 1881da177e4SLinus Torvalds * too long an error code of -EINVAL is returned. If the copy gives 1891da177e4SLinus Torvalds * invalid addresses -EFAULT is returned. On a success 0 is returned. 1901da177e4SLinus Torvalds */ 1911da177e4SLinus Torvalds 192230b1839SYOSHIFUJI Hideaki int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr *kaddr) 1931da177e4SLinus Torvalds { 194230b1839SYOSHIFUJI Hideaki if (ulen < 0 || ulen > sizeof(struct sockaddr_storage)) 1951da177e4SLinus Torvalds return -EINVAL; 1961da177e4SLinus Torvalds if (ulen == 0) 1971da177e4SLinus Torvalds return 0; 1981da177e4SLinus Torvalds if (copy_from_user(kaddr, uaddr, ulen)) 1991da177e4SLinus Torvalds return -EFAULT; 2003ec3b2fbSDavid Woodhouse return audit_sockaddr(ulen, kaddr); 2011da177e4SLinus Torvalds } 2021da177e4SLinus Torvalds 2031da177e4SLinus Torvalds /** 2041da177e4SLinus Torvalds * move_addr_to_user - copy an address to user space 2051da177e4SLinus Torvalds * @kaddr: kernel space address 2061da177e4SLinus Torvalds * @klen: length of address in kernel 2071da177e4SLinus Torvalds * @uaddr: user space address 2081da177e4SLinus Torvalds * @ulen: pointer to user length field 2091da177e4SLinus Torvalds * 2101da177e4SLinus Torvalds * The value pointed to by ulen on entry is the buffer length available. 2111da177e4SLinus Torvalds * This is overwritten with the buffer space used. -EINVAL is returned 2121da177e4SLinus Torvalds * if an overlong buffer is specified or a negative buffer size. -EFAULT 2131da177e4SLinus Torvalds * is returned if either the buffer or the length field are not 2141da177e4SLinus Torvalds * accessible. 2151da177e4SLinus Torvalds * After copying the data up to the limit the user specifies, the true 2161da177e4SLinus Torvalds * length of the data is written over the length limit the user 2171da177e4SLinus Torvalds * specified. Zero is returned for a success. 2181da177e4SLinus Torvalds */ 2191da177e4SLinus Torvalds 220230b1839SYOSHIFUJI Hideaki int move_addr_to_user(struct sockaddr *kaddr, int klen, void __user *uaddr, 22189bddce5SStephen Hemminger int __user *ulen) 2221da177e4SLinus Torvalds { 2231da177e4SLinus Torvalds int err; 2241da177e4SLinus Torvalds int len; 2251da177e4SLinus Torvalds 22689bddce5SStephen Hemminger err = get_user(len, ulen); 22789bddce5SStephen Hemminger if (err) 2281da177e4SLinus Torvalds return err; 2291da177e4SLinus Torvalds if (len > klen) 2301da177e4SLinus Torvalds len = klen; 231230b1839SYOSHIFUJI Hideaki if (len < 0 || len > sizeof(struct sockaddr_storage)) 2321da177e4SLinus Torvalds return -EINVAL; 23389bddce5SStephen Hemminger if (len) { 234d6fe3945SSteve Grubb if (audit_sockaddr(klen, kaddr)) 235d6fe3945SSteve Grubb return -ENOMEM; 2361da177e4SLinus Torvalds if (copy_to_user(uaddr, kaddr, len)) 2371da177e4SLinus Torvalds return -EFAULT; 2381da177e4SLinus Torvalds } 2391da177e4SLinus Torvalds /* 2401da177e4SLinus Torvalds * "fromlen shall refer to the value before truncation.." 2411da177e4SLinus Torvalds * 1003.1g 2421da177e4SLinus Torvalds */ 2431da177e4SLinus Torvalds return __put_user(klen, ulen); 2441da177e4SLinus Torvalds } 2451da177e4SLinus Torvalds 246e18b890bSChristoph Lameter static struct kmem_cache *sock_inode_cachep __read_mostly; 2471da177e4SLinus Torvalds 2481da177e4SLinus Torvalds static struct inode *sock_alloc_inode(struct super_block *sb) 2491da177e4SLinus Torvalds { 2501da177e4SLinus Torvalds struct socket_alloc *ei; 25189bddce5SStephen Hemminger 252e94b1766SChristoph Lameter ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL); 2531da177e4SLinus Torvalds if (!ei) 2541da177e4SLinus Torvalds return NULL; 2551da177e4SLinus Torvalds init_waitqueue_head(&ei->socket.wait); 2561da177e4SLinus Torvalds 2571da177e4SLinus Torvalds ei->socket.fasync_list = NULL; 2581da177e4SLinus Torvalds ei->socket.state = SS_UNCONNECTED; 2591da177e4SLinus Torvalds ei->socket.flags = 0; 2601da177e4SLinus Torvalds ei->socket.ops = NULL; 2611da177e4SLinus Torvalds ei->socket.sk = NULL; 2621da177e4SLinus Torvalds ei->socket.file = NULL; 2631da177e4SLinus Torvalds 2641da177e4SLinus Torvalds return &ei->vfs_inode; 2651da177e4SLinus Torvalds } 2661da177e4SLinus Torvalds 2671da177e4SLinus Torvalds static void sock_destroy_inode(struct inode *inode) 2681da177e4SLinus Torvalds { 2691da177e4SLinus Torvalds kmem_cache_free(sock_inode_cachep, 2701da177e4SLinus Torvalds container_of(inode, struct socket_alloc, vfs_inode)); 2711da177e4SLinus Torvalds } 2721da177e4SLinus Torvalds 27351cc5068SAlexey Dobriyan static void init_once(void *foo) 2741da177e4SLinus Torvalds { 2751da177e4SLinus Torvalds struct socket_alloc *ei = (struct socket_alloc *)foo; 2761da177e4SLinus Torvalds 2771da177e4SLinus Torvalds inode_init_once(&ei->vfs_inode); 2781da177e4SLinus Torvalds } 2791da177e4SLinus Torvalds 2801da177e4SLinus Torvalds static int init_inodecache(void) 2811da177e4SLinus Torvalds { 2821da177e4SLinus Torvalds sock_inode_cachep = kmem_cache_create("sock_inode_cache", 2831da177e4SLinus Torvalds sizeof(struct socket_alloc), 28489bddce5SStephen Hemminger 0, 28589bddce5SStephen Hemminger (SLAB_HWCACHE_ALIGN | 28689bddce5SStephen Hemminger SLAB_RECLAIM_ACCOUNT | 287fffb60f9SPaul Jackson SLAB_MEM_SPREAD), 28820c2df83SPaul Mundt init_once); 2891da177e4SLinus Torvalds if (sock_inode_cachep == NULL) 2901da177e4SLinus Torvalds return -ENOMEM; 2911da177e4SLinus Torvalds return 0; 2921da177e4SLinus Torvalds } 2931da177e4SLinus Torvalds 294b87221deSAlexey Dobriyan static const struct super_operations sockfs_ops = { 2951da177e4SLinus Torvalds .alloc_inode = sock_alloc_inode, 2961da177e4SLinus Torvalds .destroy_inode =sock_destroy_inode, 2971da177e4SLinus Torvalds .statfs = simple_statfs, 2981da177e4SLinus Torvalds }; 2991da177e4SLinus Torvalds 300454e2398SDavid Howells static int sockfs_get_sb(struct file_system_type *fs_type, 30189bddce5SStephen Hemminger int flags, const char *dev_name, void *data, 30289bddce5SStephen Hemminger struct vfsmount *mnt) 3031da177e4SLinus Torvalds { 304454e2398SDavid Howells return get_sb_pseudo(fs_type, "socket:", &sockfs_ops, SOCKFS_MAGIC, 305454e2398SDavid Howells mnt); 3061da177e4SLinus Torvalds } 3071da177e4SLinus Torvalds 308ba89966cSEric Dumazet static struct vfsmount *sock_mnt __read_mostly; 3091da177e4SLinus Torvalds 3101da177e4SLinus Torvalds static struct file_system_type sock_fs_type = { 3111da177e4SLinus Torvalds .name = "sockfs", 3121da177e4SLinus Torvalds .get_sb = sockfs_get_sb, 3131da177e4SLinus Torvalds .kill_sb = kill_anon_super, 3141da177e4SLinus Torvalds }; 31589bddce5SStephen Hemminger 316c23fbb6bSEric Dumazet /* 317c23fbb6bSEric Dumazet * sockfs_dname() is called from d_path(). 318c23fbb6bSEric Dumazet */ 319c23fbb6bSEric Dumazet static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen) 320c23fbb6bSEric Dumazet { 321c23fbb6bSEric Dumazet return dynamic_dname(dentry, buffer, buflen, "socket:[%lu]", 322c23fbb6bSEric Dumazet dentry->d_inode->i_ino); 323c23fbb6bSEric Dumazet } 324c23fbb6bSEric Dumazet 3253ba13d17SAl Viro static const struct dentry_operations sockfs_dentry_operations = { 326c23fbb6bSEric Dumazet .d_dname = sockfs_dname, 3271da177e4SLinus Torvalds }; 3281da177e4SLinus Torvalds 3291da177e4SLinus Torvalds /* 3301da177e4SLinus Torvalds * Obtains the first available file descriptor and sets it up for use. 3311da177e4SLinus Torvalds * 33239d8c1b6SDavid S. Miller * These functions create file structures and maps them to fd space 33339d8c1b6SDavid S. Miller * of the current process. On success it returns file descriptor 3341da177e4SLinus Torvalds * and file struct implicitly stored in sock->file. 3351da177e4SLinus Torvalds * Note that another thread may close file descriptor before we return 3361da177e4SLinus Torvalds * from this function. We use the fact that now we do not refer 3371da177e4SLinus Torvalds * to socket after mapping. If one day we will need it, this 3381da177e4SLinus Torvalds * function will increment ref. count on file by 1. 3391da177e4SLinus Torvalds * 3401da177e4SLinus Torvalds * In any case returned fd MAY BE not valid! 3411da177e4SLinus Torvalds * This race condition is unavoidable 3421da177e4SLinus Torvalds * with shared fd spaces, we cannot solve it inside kernel, 3431da177e4SLinus Torvalds * but we take care of internal coherence yet. 3441da177e4SLinus Torvalds */ 3451da177e4SLinus Torvalds 3467cbe66b6SAl Viro static int sock_alloc_file(struct socket *sock, struct file **f, int flags) 3471da177e4SLinus Torvalds { 3487cbe66b6SAl Viro struct qstr name = { .name = "" }; 3492c48b9c4SAl Viro struct path path; 3507cbe66b6SAl Viro struct file *file; 3511da177e4SLinus Torvalds int fd; 3521da177e4SLinus Torvalds 353a677a039SUlrich Drepper fd = get_unused_fd_flags(flags); 3547cbe66b6SAl Viro if (unlikely(fd < 0)) 3557cbe66b6SAl Viro return fd; 3561da177e4SLinus Torvalds 3572c48b9c4SAl Viro path.dentry = d_alloc(sock_mnt->mnt_sb->s_root, &name); 3582c48b9c4SAl Viro if (unlikely(!path.dentry)) { 3597cbe66b6SAl Viro put_unused_fd(fd); 36039d8c1b6SDavid S. Miller return -ENOMEM; 3617cbe66b6SAl Viro } 3622c48b9c4SAl Viro path.mnt = mntget(sock_mnt); 36339d8c1b6SDavid S. Miller 3642c48b9c4SAl Viro path.dentry->d_op = &sockfs_dentry_operations; 3652c48b9c4SAl Viro d_instantiate(path.dentry, SOCK_INODE(sock)); 366cc3808f8SAl Viro SOCK_INODE(sock)->i_fop = &socket_file_ops; 367cc3808f8SAl Viro 3682c48b9c4SAl Viro file = alloc_file(&path, FMODE_READ | FMODE_WRITE, 369cc3808f8SAl Viro &socket_file_ops); 370cc3808f8SAl Viro if (unlikely(!file)) { 371cc3808f8SAl Viro /* drop dentry, keep inode */ 372cc3808f8SAl Viro atomic_inc(&path.dentry->d_inode->i_count); 3732c48b9c4SAl Viro path_put(&path); 374cc3808f8SAl Viro put_unused_fd(fd); 375cc3808f8SAl Viro return -ENFILE; 376cc3808f8SAl Viro } 3771da177e4SLinus Torvalds 3781da177e4SLinus Torvalds sock->file = file; 37977d27200SUlrich Drepper file->f_flags = O_RDWR | (flags & O_NONBLOCK); 3801da177e4SLinus Torvalds file->f_pos = 0; 38107dc3f07SBenjamin LaHaise file->private_data = sock; 38239d8c1b6SDavid S. Miller 3837cbe66b6SAl Viro *f = file; 3847cbe66b6SAl Viro return fd; 3851da177e4SLinus Torvalds } 3861da177e4SLinus Torvalds 387a677a039SUlrich Drepper int sock_map_fd(struct socket *sock, int flags) 38839d8c1b6SDavid S. Miller { 38939d8c1b6SDavid S. Miller struct file *newfile; 3907cbe66b6SAl Viro int fd = sock_alloc_file(sock, &newfile, flags); 39139d8c1b6SDavid S. Miller 3927cbe66b6SAl Viro if (likely(fd >= 0)) 39339d8c1b6SDavid S. Miller fd_install(fd, newfile); 3947cbe66b6SAl Viro 3951da177e4SLinus Torvalds return fd; 3961da177e4SLinus Torvalds } 3971da177e4SLinus Torvalds 3986cb153caSBenjamin LaHaise static struct socket *sock_from_file(struct file *file, int *err) 3996cb153caSBenjamin LaHaise { 4006cb153caSBenjamin LaHaise if (file->f_op == &socket_file_ops) 4016cb153caSBenjamin LaHaise return file->private_data; /* set in sock_map_fd */ 4026cb153caSBenjamin LaHaise 4036cb153caSBenjamin LaHaise *err = -ENOTSOCK; 4046cb153caSBenjamin LaHaise return NULL; 4056cb153caSBenjamin LaHaise } 4066cb153caSBenjamin LaHaise 4071da177e4SLinus Torvalds /** 4081da177e4SLinus Torvalds * sockfd_lookup - Go from a file number to its socket slot 4091da177e4SLinus Torvalds * @fd: file handle 4101da177e4SLinus Torvalds * @err: pointer to an error code return 4111da177e4SLinus Torvalds * 4121da177e4SLinus Torvalds * The file handle passed in is locked and the socket it is bound 4131da177e4SLinus Torvalds * too is returned. If an error occurs the err pointer is overwritten 4141da177e4SLinus Torvalds * with a negative errno code and NULL is returned. The function checks 4151da177e4SLinus Torvalds * for both invalid handles and passing a handle which is not a socket. 4161da177e4SLinus Torvalds * 4171da177e4SLinus Torvalds * On a success the socket object pointer is returned. 4181da177e4SLinus Torvalds */ 4191da177e4SLinus Torvalds 4201da177e4SLinus Torvalds struct socket *sockfd_lookup(int fd, int *err) 4211da177e4SLinus Torvalds { 4221da177e4SLinus Torvalds struct file *file; 4231da177e4SLinus Torvalds struct socket *sock; 4241da177e4SLinus Torvalds 42589bddce5SStephen Hemminger file = fget(fd); 42689bddce5SStephen Hemminger if (!file) { 4271da177e4SLinus Torvalds *err = -EBADF; 4281da177e4SLinus Torvalds return NULL; 4291da177e4SLinus Torvalds } 43089bddce5SStephen Hemminger 4316cb153caSBenjamin LaHaise sock = sock_from_file(file, err); 4326cb153caSBenjamin LaHaise if (!sock) 4331da177e4SLinus Torvalds fput(file); 4346cb153caSBenjamin LaHaise return sock; 4351da177e4SLinus Torvalds } 4361da177e4SLinus Torvalds 4376cb153caSBenjamin LaHaise static struct socket *sockfd_lookup_light(int fd, int *err, int *fput_needed) 4386cb153caSBenjamin LaHaise { 4396cb153caSBenjamin LaHaise struct file *file; 4406cb153caSBenjamin LaHaise struct socket *sock; 4416cb153caSBenjamin LaHaise 4423672558cSHua Zhong *err = -EBADF; 4436cb153caSBenjamin LaHaise file = fget_light(fd, fput_needed); 4446cb153caSBenjamin LaHaise if (file) { 4456cb153caSBenjamin LaHaise sock = sock_from_file(file, err); 4466cb153caSBenjamin LaHaise if (sock) 4471da177e4SLinus Torvalds return sock; 4486cb153caSBenjamin LaHaise fput_light(file, *fput_needed); 4496cb153caSBenjamin LaHaise } 4506cb153caSBenjamin LaHaise return NULL; 4511da177e4SLinus Torvalds } 4521da177e4SLinus Torvalds 4531da177e4SLinus Torvalds /** 4541da177e4SLinus Torvalds * sock_alloc - allocate a socket 4551da177e4SLinus Torvalds * 4561da177e4SLinus Torvalds * Allocate a new inode and socket object. The two are bound together 4571da177e4SLinus Torvalds * and initialised. The socket is then returned. If we are out of inodes 4581da177e4SLinus Torvalds * NULL is returned. 4591da177e4SLinus Torvalds */ 4601da177e4SLinus Torvalds 4611da177e4SLinus Torvalds static struct socket *sock_alloc(void) 4621da177e4SLinus Torvalds { 4631da177e4SLinus Torvalds struct inode *inode; 4641da177e4SLinus Torvalds struct socket *sock; 4651da177e4SLinus Torvalds 4661da177e4SLinus Torvalds inode = new_inode(sock_mnt->mnt_sb); 4671da177e4SLinus Torvalds if (!inode) 4681da177e4SLinus Torvalds return NULL; 4691da177e4SLinus Torvalds 4701da177e4SLinus Torvalds sock = SOCKET_I(inode); 4711da177e4SLinus Torvalds 47229a020d3SEric Dumazet kmemcheck_annotate_bitfield(sock, type); 4731da177e4SLinus Torvalds inode->i_mode = S_IFSOCK | S_IRWXUGO; 4748192b0c4SDavid Howells inode->i_uid = current_fsuid(); 4758192b0c4SDavid Howells inode->i_gid = current_fsgid(); 4761da177e4SLinus Torvalds 4774e69489aSEric Dumazet percpu_add(sockets_in_use, 1); 4781da177e4SLinus Torvalds return sock; 4791da177e4SLinus Torvalds } 4801da177e4SLinus Torvalds 4811da177e4SLinus Torvalds /* 4821da177e4SLinus Torvalds * In theory you can't get an open on this inode, but /proc provides 4831da177e4SLinus Torvalds * a back door. Remember to keep it shut otherwise you'll let the 4841da177e4SLinus Torvalds * creepy crawlies in. 4851da177e4SLinus Torvalds */ 4861da177e4SLinus Torvalds 4871da177e4SLinus Torvalds static int sock_no_open(struct inode *irrelevant, struct file *dontcare) 4881da177e4SLinus Torvalds { 4891da177e4SLinus Torvalds return -ENXIO; 4901da177e4SLinus Torvalds } 4911da177e4SLinus Torvalds 4924b6f5d20SArjan van de Ven const struct file_operations bad_sock_fops = { 4931da177e4SLinus Torvalds .owner = THIS_MODULE, 4941da177e4SLinus Torvalds .open = sock_no_open, 4951da177e4SLinus Torvalds }; 4961da177e4SLinus Torvalds 4971da177e4SLinus Torvalds /** 4981da177e4SLinus Torvalds * sock_release - close a socket 4991da177e4SLinus Torvalds * @sock: socket to close 5001da177e4SLinus Torvalds * 5011da177e4SLinus Torvalds * The socket is released from the protocol stack if it has a release 5021da177e4SLinus Torvalds * callback, and the inode is then released if the socket is bound to 5031da177e4SLinus Torvalds * an inode not a file. 5041da177e4SLinus Torvalds */ 5051da177e4SLinus Torvalds 5061da177e4SLinus Torvalds void sock_release(struct socket *sock) 5071da177e4SLinus Torvalds { 5081da177e4SLinus Torvalds if (sock->ops) { 5091da177e4SLinus Torvalds struct module *owner = sock->ops->owner; 5101da177e4SLinus Torvalds 5111da177e4SLinus Torvalds sock->ops->release(sock); 5121da177e4SLinus Torvalds sock->ops = NULL; 5131da177e4SLinus Torvalds module_put(owner); 5141da177e4SLinus Torvalds } 5151da177e4SLinus Torvalds 5161da177e4SLinus Torvalds if (sock->fasync_list) 5171da177e4SLinus Torvalds printk(KERN_ERR "sock_release: fasync list not empty!\n"); 5181da177e4SLinus Torvalds 5194e69489aSEric Dumazet percpu_sub(sockets_in_use, 1); 5201da177e4SLinus Torvalds if (!sock->file) { 5211da177e4SLinus Torvalds iput(SOCK_INODE(sock)); 5221da177e4SLinus Torvalds return; 5231da177e4SLinus Torvalds } 5241da177e4SLinus Torvalds sock->file = NULL; 5251da177e4SLinus Torvalds } 5261da177e4SLinus Torvalds 52720d49473SPatrick Ohly int sock_tx_timestamp(struct msghdr *msg, struct sock *sk, 52820d49473SPatrick Ohly union skb_shared_tx *shtx) 52920d49473SPatrick Ohly { 53020d49473SPatrick Ohly shtx->flags = 0; 53120d49473SPatrick Ohly if (sock_flag(sk, SOCK_TIMESTAMPING_TX_HARDWARE)) 53220d49473SPatrick Ohly shtx->hardware = 1; 53320d49473SPatrick Ohly if (sock_flag(sk, SOCK_TIMESTAMPING_TX_SOFTWARE)) 53420d49473SPatrick Ohly shtx->software = 1; 53520d49473SPatrick Ohly return 0; 53620d49473SPatrick Ohly } 53720d49473SPatrick Ohly EXPORT_SYMBOL(sock_tx_timestamp); 53820d49473SPatrick Ohly 5391da177e4SLinus Torvalds static inline int __sock_sendmsg(struct kiocb *iocb, struct socket *sock, 5401da177e4SLinus Torvalds struct msghdr *msg, size_t size) 5411da177e4SLinus Torvalds { 5421da177e4SLinus Torvalds struct sock_iocb *si = kiocb_to_siocb(iocb); 5431da177e4SLinus Torvalds int err; 5441da177e4SLinus Torvalds 5451da177e4SLinus Torvalds si->sock = sock; 5461da177e4SLinus Torvalds si->scm = NULL; 5471da177e4SLinus Torvalds si->msg = msg; 5481da177e4SLinus Torvalds si->size = size; 5491da177e4SLinus Torvalds 5501da177e4SLinus Torvalds err = security_socket_sendmsg(sock, msg, size); 5511da177e4SLinus Torvalds if (err) 5521da177e4SLinus Torvalds return err; 5531da177e4SLinus Torvalds 5541da177e4SLinus Torvalds return sock->ops->sendmsg(iocb, sock, msg, size); 5551da177e4SLinus Torvalds } 5561da177e4SLinus Torvalds 5571da177e4SLinus Torvalds int sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t size) 5581da177e4SLinus Torvalds { 5591da177e4SLinus Torvalds struct kiocb iocb; 5601da177e4SLinus Torvalds struct sock_iocb siocb; 5611da177e4SLinus Torvalds int ret; 5621da177e4SLinus Torvalds 5631da177e4SLinus Torvalds init_sync_kiocb(&iocb, NULL); 5641da177e4SLinus Torvalds iocb.private = &siocb; 5651da177e4SLinus Torvalds ret = __sock_sendmsg(&iocb, sock, msg, size); 5661da177e4SLinus Torvalds if (-EIOCBQUEUED == ret) 5671da177e4SLinus Torvalds ret = wait_on_sync_kiocb(&iocb); 5681da177e4SLinus Torvalds return ret; 5691da177e4SLinus Torvalds } 5701da177e4SLinus Torvalds 5711da177e4SLinus Torvalds int kernel_sendmsg(struct socket *sock, struct msghdr *msg, 5721da177e4SLinus Torvalds struct kvec *vec, size_t num, size_t size) 5731da177e4SLinus Torvalds { 5741da177e4SLinus Torvalds mm_segment_t oldfs = get_fs(); 5751da177e4SLinus Torvalds int result; 5761da177e4SLinus Torvalds 5771da177e4SLinus Torvalds set_fs(KERNEL_DS); 5781da177e4SLinus Torvalds /* 5791da177e4SLinus Torvalds * the following is safe, since for compiler definitions of kvec and 5801da177e4SLinus Torvalds * iovec are identical, yielding the same in-core layout and alignment 5811da177e4SLinus Torvalds */ 58289bddce5SStephen Hemminger msg->msg_iov = (struct iovec *)vec; 5831da177e4SLinus Torvalds msg->msg_iovlen = num; 5841da177e4SLinus Torvalds result = sock_sendmsg(sock, msg, size); 5851da177e4SLinus Torvalds set_fs(oldfs); 5861da177e4SLinus Torvalds return result; 5871da177e4SLinus Torvalds } 5881da177e4SLinus Torvalds 58920d49473SPatrick Ohly static int ktime2ts(ktime_t kt, struct timespec *ts) 59020d49473SPatrick Ohly { 59120d49473SPatrick Ohly if (kt.tv64) { 59220d49473SPatrick Ohly *ts = ktime_to_timespec(kt); 59320d49473SPatrick Ohly return 1; 59420d49473SPatrick Ohly } else { 59520d49473SPatrick Ohly return 0; 59620d49473SPatrick Ohly } 59720d49473SPatrick Ohly } 59820d49473SPatrick Ohly 59992f37fd2SEric Dumazet /* 60092f37fd2SEric Dumazet * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP) 60192f37fd2SEric Dumazet */ 60292f37fd2SEric Dumazet void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk, 60392f37fd2SEric Dumazet struct sk_buff *skb) 60492f37fd2SEric Dumazet { 60520d49473SPatrick Ohly int need_software_tstamp = sock_flag(sk, SOCK_RCVTSTAMP); 60620d49473SPatrick Ohly struct timespec ts[3]; 60720d49473SPatrick Ohly int empty = 1; 60820d49473SPatrick Ohly struct skb_shared_hwtstamps *shhwtstamps = 60920d49473SPatrick Ohly skb_hwtstamps(skb); 61092f37fd2SEric Dumazet 61120d49473SPatrick Ohly /* Race occurred between timestamp enabling and packet 61220d49473SPatrick Ohly receiving. Fill in the current time for now. */ 61320d49473SPatrick Ohly if (need_software_tstamp && skb->tstamp.tv64 == 0) 61420d49473SPatrick Ohly __net_timestamp(skb); 61520d49473SPatrick Ohly 61620d49473SPatrick Ohly if (need_software_tstamp) { 61792f37fd2SEric Dumazet if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) { 61892f37fd2SEric Dumazet struct timeval tv; 61920d49473SPatrick Ohly skb_get_timestamp(skb, &tv); 62020d49473SPatrick Ohly put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP, 62120d49473SPatrick Ohly sizeof(tv), &tv); 62292f37fd2SEric Dumazet } else { 62392f37fd2SEric Dumazet struct timespec ts; 62420d49473SPatrick Ohly skb_get_timestampns(skb, &ts); 62520d49473SPatrick Ohly put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS, 62620d49473SPatrick Ohly sizeof(ts), &ts); 62792f37fd2SEric Dumazet } 62892f37fd2SEric Dumazet } 62992f37fd2SEric Dumazet 63020d49473SPatrick Ohly 63120d49473SPatrick Ohly memset(ts, 0, sizeof(ts)); 63220d49473SPatrick Ohly if (skb->tstamp.tv64 && 63320d49473SPatrick Ohly sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE)) { 63420d49473SPatrick Ohly skb_get_timestampns(skb, ts + 0); 63520d49473SPatrick Ohly empty = 0; 63620d49473SPatrick Ohly } 63720d49473SPatrick Ohly if (shhwtstamps) { 63820d49473SPatrick Ohly if (sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE) && 63920d49473SPatrick Ohly ktime2ts(shhwtstamps->syststamp, ts + 1)) 64020d49473SPatrick Ohly empty = 0; 64120d49473SPatrick Ohly if (sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE) && 64220d49473SPatrick Ohly ktime2ts(shhwtstamps->hwtstamp, ts + 2)) 64320d49473SPatrick Ohly empty = 0; 64420d49473SPatrick Ohly } 64520d49473SPatrick Ohly if (!empty) 64620d49473SPatrick Ohly put_cmsg(msg, SOL_SOCKET, 64720d49473SPatrick Ohly SCM_TIMESTAMPING, sizeof(ts), &ts); 64820d49473SPatrick Ohly } 64920d49473SPatrick Ohly 6507c81fd8bSArnaldo Carvalho de Melo EXPORT_SYMBOL_GPL(__sock_recv_timestamp); 6517c81fd8bSArnaldo Carvalho de Melo 6523b885787SNeil Horman inline void sock_recv_drops(struct msghdr *msg, struct sock *sk, struct sk_buff *skb) 6533b885787SNeil Horman { 6543b885787SNeil Horman if (sock_flag(sk, SOCK_RXQ_OVFL) && skb && skb->dropcount) 6553b885787SNeil Horman put_cmsg(msg, SOL_SOCKET, SO_RXQ_OVFL, 6563b885787SNeil Horman sizeof(__u32), &skb->dropcount); 6573b885787SNeil Horman } 6583b885787SNeil Horman 6593b885787SNeil Horman void sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk, 6603b885787SNeil Horman struct sk_buff *skb) 6613b885787SNeil Horman { 6623b885787SNeil Horman sock_recv_timestamp(msg, sk, skb); 6633b885787SNeil Horman sock_recv_drops(msg, sk, skb); 6643b885787SNeil Horman } 6653b885787SNeil Horman EXPORT_SYMBOL_GPL(sock_recv_ts_and_drops); 6663b885787SNeil Horman 667a2e27255SArnaldo Carvalho de Melo static inline int __sock_recvmsg_nosec(struct kiocb *iocb, struct socket *sock, 6681da177e4SLinus Torvalds struct msghdr *msg, size_t size, int flags) 6691da177e4SLinus Torvalds { 6701da177e4SLinus Torvalds struct sock_iocb *si = kiocb_to_siocb(iocb); 6711da177e4SLinus Torvalds 6721da177e4SLinus Torvalds si->sock = sock; 6731da177e4SLinus Torvalds si->scm = NULL; 6741da177e4SLinus Torvalds si->msg = msg; 6751da177e4SLinus Torvalds si->size = size; 6761da177e4SLinus Torvalds si->flags = flags; 6771da177e4SLinus Torvalds 6781da177e4SLinus Torvalds return sock->ops->recvmsg(iocb, sock, msg, size, flags); 6791da177e4SLinus Torvalds } 6801da177e4SLinus Torvalds 681a2e27255SArnaldo Carvalho de Melo static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock, 682a2e27255SArnaldo Carvalho de Melo struct msghdr *msg, size_t size, int flags) 683a2e27255SArnaldo Carvalho de Melo { 684a2e27255SArnaldo Carvalho de Melo int err = security_socket_recvmsg(sock, msg, size, flags); 685a2e27255SArnaldo Carvalho de Melo 686a2e27255SArnaldo Carvalho de Melo return err ?: __sock_recvmsg_nosec(iocb, sock, msg, size, flags); 687a2e27255SArnaldo Carvalho de Melo } 688a2e27255SArnaldo Carvalho de Melo 6891da177e4SLinus Torvalds int sock_recvmsg(struct socket *sock, struct msghdr *msg, 6901da177e4SLinus Torvalds size_t size, int flags) 6911da177e4SLinus Torvalds { 6921da177e4SLinus Torvalds struct kiocb iocb; 6931da177e4SLinus Torvalds struct sock_iocb siocb; 6941da177e4SLinus Torvalds int ret; 6951da177e4SLinus Torvalds 6961da177e4SLinus Torvalds init_sync_kiocb(&iocb, NULL); 6971da177e4SLinus Torvalds iocb.private = &siocb; 6981da177e4SLinus Torvalds ret = __sock_recvmsg(&iocb, sock, msg, size, flags); 6991da177e4SLinus Torvalds if (-EIOCBQUEUED == ret) 7001da177e4SLinus Torvalds ret = wait_on_sync_kiocb(&iocb); 7011da177e4SLinus Torvalds return ret; 7021da177e4SLinus Torvalds } 7031da177e4SLinus Torvalds 704a2e27255SArnaldo Carvalho de Melo static int sock_recvmsg_nosec(struct socket *sock, struct msghdr *msg, 705a2e27255SArnaldo Carvalho de Melo size_t size, int flags) 706a2e27255SArnaldo Carvalho de Melo { 707a2e27255SArnaldo Carvalho de Melo struct kiocb iocb; 708a2e27255SArnaldo Carvalho de Melo struct sock_iocb siocb; 709a2e27255SArnaldo Carvalho de Melo int ret; 710a2e27255SArnaldo Carvalho de Melo 711a2e27255SArnaldo Carvalho de Melo init_sync_kiocb(&iocb, NULL); 712a2e27255SArnaldo Carvalho de Melo iocb.private = &siocb; 713a2e27255SArnaldo Carvalho de Melo ret = __sock_recvmsg_nosec(&iocb, sock, msg, size, flags); 714a2e27255SArnaldo Carvalho de Melo if (-EIOCBQUEUED == ret) 715a2e27255SArnaldo Carvalho de Melo ret = wait_on_sync_kiocb(&iocb); 716a2e27255SArnaldo Carvalho de Melo return ret; 717a2e27255SArnaldo Carvalho de Melo } 718a2e27255SArnaldo Carvalho de Melo 7191da177e4SLinus Torvalds int kernel_recvmsg(struct socket *sock, struct msghdr *msg, 72089bddce5SStephen Hemminger struct kvec *vec, size_t num, size_t size, int flags) 7211da177e4SLinus Torvalds { 7221da177e4SLinus Torvalds mm_segment_t oldfs = get_fs(); 7231da177e4SLinus Torvalds int result; 7241da177e4SLinus Torvalds 7251da177e4SLinus Torvalds set_fs(KERNEL_DS); 7261da177e4SLinus Torvalds /* 7271da177e4SLinus Torvalds * the following is safe, since for compiler definitions of kvec and 7281da177e4SLinus Torvalds * iovec are identical, yielding the same in-core layout and alignment 7291da177e4SLinus Torvalds */ 73089bddce5SStephen Hemminger msg->msg_iov = (struct iovec *)vec, msg->msg_iovlen = num; 7311da177e4SLinus Torvalds result = sock_recvmsg(sock, msg, size, flags); 7321da177e4SLinus Torvalds set_fs(oldfs); 7331da177e4SLinus Torvalds return result; 7341da177e4SLinus Torvalds } 7351da177e4SLinus Torvalds 7361da177e4SLinus Torvalds static void sock_aio_dtor(struct kiocb *iocb) 7371da177e4SLinus Torvalds { 7381da177e4SLinus Torvalds kfree(iocb->private); 7391da177e4SLinus Torvalds } 7401da177e4SLinus Torvalds 74120380731SArnaldo Carvalho de Melo static ssize_t sock_sendpage(struct file *file, struct page *page, 7421da177e4SLinus Torvalds int offset, size_t size, loff_t *ppos, int more) 7431da177e4SLinus Torvalds { 7441da177e4SLinus Torvalds struct socket *sock; 7451da177e4SLinus Torvalds int flags; 7461da177e4SLinus Torvalds 747b69aee04SEric Dumazet sock = file->private_data; 7481da177e4SLinus Torvalds 7491da177e4SLinus Torvalds flags = !(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT; 7501da177e4SLinus Torvalds if (more) 7511da177e4SLinus Torvalds flags |= MSG_MORE; 7521da177e4SLinus Torvalds 753e6949583SLinus Torvalds return kernel_sendpage(sock, page, offset, size, flags); 7541da177e4SLinus Torvalds } 7551da177e4SLinus Torvalds 7569c55e01cSJens Axboe static ssize_t sock_splice_read(struct file *file, loff_t *ppos, 7579c55e01cSJens Axboe struct pipe_inode_info *pipe, size_t len, 7589c55e01cSJens Axboe unsigned int flags) 7599c55e01cSJens Axboe { 7609c55e01cSJens Axboe struct socket *sock = file->private_data; 7619c55e01cSJens Axboe 762997b37daSRémi Denis-Courmont if (unlikely(!sock->ops->splice_read)) 763997b37daSRémi Denis-Courmont return -EINVAL; 764997b37daSRémi Denis-Courmont 7659c55e01cSJens Axboe return sock->ops->splice_read(sock, ppos, pipe, len, flags); 7669c55e01cSJens Axboe } 7679c55e01cSJens Axboe 768ce1d4d3eSChristoph Hellwig static struct sock_iocb *alloc_sock_iocb(struct kiocb *iocb, 76989bddce5SStephen Hemminger struct sock_iocb *siocb) 770ce1d4d3eSChristoph Hellwig { 771ce1d4d3eSChristoph Hellwig if (!is_sync_kiocb(iocb)) { 772ce1d4d3eSChristoph Hellwig siocb = kmalloc(sizeof(*siocb), GFP_KERNEL); 773ce1d4d3eSChristoph Hellwig if (!siocb) 774ce1d4d3eSChristoph Hellwig return NULL; 775ce1d4d3eSChristoph Hellwig iocb->ki_dtor = sock_aio_dtor; 776ce1d4d3eSChristoph Hellwig } 777ce1d4d3eSChristoph Hellwig 778ce1d4d3eSChristoph Hellwig siocb->kiocb = iocb; 779ce1d4d3eSChristoph Hellwig iocb->private = siocb; 780ce1d4d3eSChristoph Hellwig return siocb; 781ce1d4d3eSChristoph Hellwig } 782ce1d4d3eSChristoph Hellwig 783ce1d4d3eSChristoph Hellwig static ssize_t do_sock_read(struct msghdr *msg, struct kiocb *iocb, 784027445c3SBadari Pulavarty struct file *file, const struct iovec *iov, 78589bddce5SStephen Hemminger unsigned long nr_segs) 786ce1d4d3eSChristoph Hellwig { 787ce1d4d3eSChristoph Hellwig struct socket *sock = file->private_data; 788ce1d4d3eSChristoph Hellwig size_t size = 0; 789ce1d4d3eSChristoph Hellwig int i; 790ce1d4d3eSChristoph Hellwig 791ce1d4d3eSChristoph Hellwig for (i = 0; i < nr_segs; i++) 792ce1d4d3eSChristoph Hellwig size += iov[i].iov_len; 793ce1d4d3eSChristoph Hellwig 794ce1d4d3eSChristoph Hellwig msg->msg_name = NULL; 795ce1d4d3eSChristoph Hellwig msg->msg_namelen = 0; 796ce1d4d3eSChristoph Hellwig msg->msg_control = NULL; 797ce1d4d3eSChristoph Hellwig msg->msg_controllen = 0; 798ce1d4d3eSChristoph Hellwig msg->msg_iov = (struct iovec *)iov; 799ce1d4d3eSChristoph Hellwig msg->msg_iovlen = nr_segs; 800ce1d4d3eSChristoph Hellwig msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0; 801ce1d4d3eSChristoph Hellwig 802ce1d4d3eSChristoph Hellwig return __sock_recvmsg(iocb, sock, msg, size, msg->msg_flags); 803ce1d4d3eSChristoph Hellwig } 804ce1d4d3eSChristoph Hellwig 805027445c3SBadari Pulavarty static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov, 806027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos) 807ce1d4d3eSChristoph Hellwig { 808ce1d4d3eSChristoph Hellwig struct sock_iocb siocb, *x; 809ce1d4d3eSChristoph Hellwig 810ce1d4d3eSChristoph Hellwig if (pos != 0) 811ce1d4d3eSChristoph Hellwig return -ESPIPE; 812027445c3SBadari Pulavarty 813027445c3SBadari Pulavarty if (iocb->ki_left == 0) /* Match SYS5 behaviour */ 814ce1d4d3eSChristoph Hellwig return 0; 815ce1d4d3eSChristoph Hellwig 816027445c3SBadari Pulavarty 817027445c3SBadari Pulavarty x = alloc_sock_iocb(iocb, &siocb); 818ce1d4d3eSChristoph Hellwig if (!x) 819ce1d4d3eSChristoph Hellwig return -ENOMEM; 820027445c3SBadari Pulavarty return do_sock_read(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs); 821ce1d4d3eSChristoph Hellwig } 822ce1d4d3eSChristoph Hellwig 823ce1d4d3eSChristoph Hellwig static ssize_t do_sock_write(struct msghdr *msg, struct kiocb *iocb, 824027445c3SBadari Pulavarty struct file *file, const struct iovec *iov, 82589bddce5SStephen Hemminger unsigned long nr_segs) 826ce1d4d3eSChristoph Hellwig { 827ce1d4d3eSChristoph Hellwig struct socket *sock = file->private_data; 828ce1d4d3eSChristoph Hellwig size_t size = 0; 829ce1d4d3eSChristoph Hellwig int i; 830ce1d4d3eSChristoph Hellwig 831ce1d4d3eSChristoph Hellwig for (i = 0; i < nr_segs; i++) 832ce1d4d3eSChristoph Hellwig size += iov[i].iov_len; 833ce1d4d3eSChristoph Hellwig 834ce1d4d3eSChristoph Hellwig msg->msg_name = NULL; 835ce1d4d3eSChristoph Hellwig msg->msg_namelen = 0; 836ce1d4d3eSChristoph Hellwig msg->msg_control = NULL; 837ce1d4d3eSChristoph Hellwig msg->msg_controllen = 0; 838ce1d4d3eSChristoph Hellwig msg->msg_iov = (struct iovec *)iov; 839ce1d4d3eSChristoph Hellwig msg->msg_iovlen = nr_segs; 840ce1d4d3eSChristoph Hellwig msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0; 841ce1d4d3eSChristoph Hellwig if (sock->type == SOCK_SEQPACKET) 842ce1d4d3eSChristoph Hellwig msg->msg_flags |= MSG_EOR; 843ce1d4d3eSChristoph Hellwig 844ce1d4d3eSChristoph Hellwig return __sock_sendmsg(iocb, sock, msg, size); 845ce1d4d3eSChristoph Hellwig } 846ce1d4d3eSChristoph Hellwig 847027445c3SBadari Pulavarty static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov, 848027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos) 8491da177e4SLinus Torvalds { 850ce1d4d3eSChristoph Hellwig struct sock_iocb siocb, *x; 8511da177e4SLinus Torvalds 852ce1d4d3eSChristoph Hellwig if (pos != 0) 853ce1d4d3eSChristoph Hellwig return -ESPIPE; 854027445c3SBadari Pulavarty 855027445c3SBadari Pulavarty x = alloc_sock_iocb(iocb, &siocb); 856ce1d4d3eSChristoph Hellwig if (!x) 857ce1d4d3eSChristoph Hellwig return -ENOMEM; 858ce1d4d3eSChristoph Hellwig 859027445c3SBadari Pulavarty return do_sock_write(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs); 8601da177e4SLinus Torvalds } 8611da177e4SLinus Torvalds 8621da177e4SLinus Torvalds /* 8631da177e4SLinus Torvalds * Atomic setting of ioctl hooks to avoid race 8641da177e4SLinus Torvalds * with module unload. 8651da177e4SLinus Torvalds */ 8661da177e4SLinus Torvalds 8674a3e2f71SArjan van de Ven static DEFINE_MUTEX(br_ioctl_mutex); 868881d966bSEric W. Biederman static int (*br_ioctl_hook) (struct net *, unsigned int cmd, void __user *arg) = NULL; 8691da177e4SLinus Torvalds 870881d966bSEric W. Biederman void brioctl_set(int (*hook) (struct net *, unsigned int, void __user *)) 8711da177e4SLinus Torvalds { 8724a3e2f71SArjan van de Ven mutex_lock(&br_ioctl_mutex); 8731da177e4SLinus Torvalds br_ioctl_hook = hook; 8744a3e2f71SArjan van de Ven mutex_unlock(&br_ioctl_mutex); 8751da177e4SLinus Torvalds } 87689bddce5SStephen Hemminger 8771da177e4SLinus Torvalds EXPORT_SYMBOL(brioctl_set); 8781da177e4SLinus Torvalds 8794a3e2f71SArjan van de Ven static DEFINE_MUTEX(vlan_ioctl_mutex); 880881d966bSEric W. Biederman static int (*vlan_ioctl_hook) (struct net *, void __user *arg); 8811da177e4SLinus Torvalds 882881d966bSEric W. Biederman void vlan_ioctl_set(int (*hook) (struct net *, void __user *)) 8831da177e4SLinus Torvalds { 8844a3e2f71SArjan van de Ven mutex_lock(&vlan_ioctl_mutex); 8851da177e4SLinus Torvalds vlan_ioctl_hook = hook; 8864a3e2f71SArjan van de Ven mutex_unlock(&vlan_ioctl_mutex); 8871da177e4SLinus Torvalds } 88889bddce5SStephen Hemminger 8891da177e4SLinus Torvalds EXPORT_SYMBOL(vlan_ioctl_set); 8901da177e4SLinus Torvalds 8914a3e2f71SArjan van de Ven static DEFINE_MUTEX(dlci_ioctl_mutex); 8921da177e4SLinus Torvalds static int (*dlci_ioctl_hook) (unsigned int, void __user *); 8931da177e4SLinus Torvalds 8941da177e4SLinus Torvalds void dlci_ioctl_set(int (*hook) (unsigned int, void __user *)) 8951da177e4SLinus Torvalds { 8964a3e2f71SArjan van de Ven mutex_lock(&dlci_ioctl_mutex); 8971da177e4SLinus Torvalds dlci_ioctl_hook = hook; 8984a3e2f71SArjan van de Ven mutex_unlock(&dlci_ioctl_mutex); 8991da177e4SLinus Torvalds } 90089bddce5SStephen Hemminger 9011da177e4SLinus Torvalds EXPORT_SYMBOL(dlci_ioctl_set); 9021da177e4SLinus Torvalds 9036b96018bSArnd Bergmann static long sock_do_ioctl(struct net *net, struct socket *sock, 9046b96018bSArnd Bergmann unsigned int cmd, unsigned long arg) 9056b96018bSArnd Bergmann { 9066b96018bSArnd Bergmann int err; 9076b96018bSArnd Bergmann void __user *argp = (void __user *)arg; 9086b96018bSArnd Bergmann 9096b96018bSArnd Bergmann err = sock->ops->ioctl(sock, cmd, arg); 9106b96018bSArnd Bergmann 9116b96018bSArnd Bergmann /* 9126b96018bSArnd Bergmann * If this ioctl is unknown try to hand it down 9136b96018bSArnd Bergmann * to the NIC driver. 9146b96018bSArnd Bergmann */ 9156b96018bSArnd Bergmann if (err == -ENOIOCTLCMD) 9166b96018bSArnd Bergmann err = dev_ioctl(net, cmd, argp); 9176b96018bSArnd Bergmann 9186b96018bSArnd Bergmann return err; 9196b96018bSArnd Bergmann } 9206b96018bSArnd Bergmann 9211da177e4SLinus Torvalds /* 9221da177e4SLinus Torvalds * With an ioctl, arg may well be a user mode pointer, but we don't know 9231da177e4SLinus Torvalds * what to do with it - that's up to the protocol still. 9241da177e4SLinus Torvalds */ 9251da177e4SLinus Torvalds 9261da177e4SLinus Torvalds static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg) 9271da177e4SLinus Torvalds { 9281da177e4SLinus Torvalds struct socket *sock; 929881d966bSEric W. Biederman struct sock *sk; 9301da177e4SLinus Torvalds void __user *argp = (void __user *)arg; 9311da177e4SLinus Torvalds int pid, err; 932881d966bSEric W. Biederman struct net *net; 9331da177e4SLinus Torvalds 934b69aee04SEric Dumazet sock = file->private_data; 935881d966bSEric W. Biederman sk = sock->sk; 9363b1e0a65SYOSHIFUJI Hideaki net = sock_net(sk); 9371da177e4SLinus Torvalds if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) { 938881d966bSEric W. Biederman err = dev_ioctl(net, cmd, argp); 9391da177e4SLinus Torvalds } else 9403d23e349SJohannes Berg #ifdef CONFIG_WEXT_CORE 9411da177e4SLinus Torvalds if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) { 942881d966bSEric W. Biederman err = dev_ioctl(net, cmd, argp); 9431da177e4SLinus Torvalds } else 9443d23e349SJohannes Berg #endif 9451da177e4SLinus Torvalds switch (cmd) { 9461da177e4SLinus Torvalds case FIOSETOWN: 9471da177e4SLinus Torvalds case SIOCSPGRP: 9481da177e4SLinus Torvalds err = -EFAULT; 9491da177e4SLinus Torvalds if (get_user(pid, (int __user *)argp)) 9501da177e4SLinus Torvalds break; 9511da177e4SLinus Torvalds err = f_setown(sock->file, pid, 1); 9521da177e4SLinus Torvalds break; 9531da177e4SLinus Torvalds case FIOGETOWN: 9541da177e4SLinus Torvalds case SIOCGPGRP: 955609d7fa9SEric W. Biederman err = put_user(f_getown(sock->file), 95689bddce5SStephen Hemminger (int __user *)argp); 9571da177e4SLinus Torvalds break; 9581da177e4SLinus Torvalds case SIOCGIFBR: 9591da177e4SLinus Torvalds case SIOCSIFBR: 9601da177e4SLinus Torvalds case SIOCBRADDBR: 9611da177e4SLinus Torvalds case SIOCBRDELBR: 9621da177e4SLinus Torvalds err = -ENOPKG; 9631da177e4SLinus Torvalds if (!br_ioctl_hook) 9641da177e4SLinus Torvalds request_module("bridge"); 9651da177e4SLinus Torvalds 9664a3e2f71SArjan van de Ven mutex_lock(&br_ioctl_mutex); 9671da177e4SLinus Torvalds if (br_ioctl_hook) 968881d966bSEric W. Biederman err = br_ioctl_hook(net, cmd, argp); 9694a3e2f71SArjan van de Ven mutex_unlock(&br_ioctl_mutex); 9701da177e4SLinus Torvalds break; 9711da177e4SLinus Torvalds case SIOCGIFVLAN: 9721da177e4SLinus Torvalds case SIOCSIFVLAN: 9731da177e4SLinus Torvalds err = -ENOPKG; 9741da177e4SLinus Torvalds if (!vlan_ioctl_hook) 9751da177e4SLinus Torvalds request_module("8021q"); 9761da177e4SLinus Torvalds 9774a3e2f71SArjan van de Ven mutex_lock(&vlan_ioctl_mutex); 9781da177e4SLinus Torvalds if (vlan_ioctl_hook) 979881d966bSEric W. Biederman err = vlan_ioctl_hook(net, argp); 9804a3e2f71SArjan van de Ven mutex_unlock(&vlan_ioctl_mutex); 9811da177e4SLinus Torvalds break; 9821da177e4SLinus Torvalds case SIOCADDDLCI: 9831da177e4SLinus Torvalds case SIOCDELDLCI: 9841da177e4SLinus Torvalds err = -ENOPKG; 9851da177e4SLinus Torvalds if (!dlci_ioctl_hook) 9861da177e4SLinus Torvalds request_module("dlci"); 9871da177e4SLinus Torvalds 9884a3e2f71SArjan van de Ven mutex_lock(&dlci_ioctl_mutex); 9897512cbf6SPavel Emelyanov if (dlci_ioctl_hook) 9901da177e4SLinus Torvalds err = dlci_ioctl_hook(cmd, argp); 9914a3e2f71SArjan van de Ven mutex_unlock(&dlci_ioctl_mutex); 9921da177e4SLinus Torvalds break; 9931da177e4SLinus Torvalds default: 9946b96018bSArnd Bergmann err = sock_do_ioctl(net, sock, cmd, arg); 9951da177e4SLinus Torvalds break; 9961da177e4SLinus Torvalds } 9971da177e4SLinus Torvalds return err; 9981da177e4SLinus Torvalds } 9991da177e4SLinus Torvalds 10001da177e4SLinus Torvalds int sock_create_lite(int family, int type, int protocol, struct socket **res) 10011da177e4SLinus Torvalds { 10021da177e4SLinus Torvalds int err; 10031da177e4SLinus Torvalds struct socket *sock = NULL; 10041da177e4SLinus Torvalds 10051da177e4SLinus Torvalds err = security_socket_create(family, type, protocol, 1); 10061da177e4SLinus Torvalds if (err) 10071da177e4SLinus Torvalds goto out; 10081da177e4SLinus Torvalds 10091da177e4SLinus Torvalds sock = sock_alloc(); 10101da177e4SLinus Torvalds if (!sock) { 10111da177e4SLinus Torvalds err = -ENOMEM; 10121da177e4SLinus Torvalds goto out; 10131da177e4SLinus Torvalds } 10141da177e4SLinus Torvalds 10151da177e4SLinus Torvalds sock->type = type; 10167420ed23SVenkat Yekkirala err = security_socket_post_create(sock, family, type, protocol, 1); 10177420ed23SVenkat Yekkirala if (err) 10187420ed23SVenkat Yekkirala goto out_release; 10197420ed23SVenkat Yekkirala 10201da177e4SLinus Torvalds out: 10211da177e4SLinus Torvalds *res = sock; 10221da177e4SLinus Torvalds return err; 10237420ed23SVenkat Yekkirala out_release: 10247420ed23SVenkat Yekkirala sock_release(sock); 10257420ed23SVenkat Yekkirala sock = NULL; 10267420ed23SVenkat Yekkirala goto out; 10271da177e4SLinus Torvalds } 10281da177e4SLinus Torvalds 10291da177e4SLinus Torvalds /* No kernel lock held - perfect */ 10301da177e4SLinus Torvalds static unsigned int sock_poll(struct file *file, poll_table *wait) 10311da177e4SLinus Torvalds { 10321da177e4SLinus Torvalds struct socket *sock; 10331da177e4SLinus Torvalds 10341da177e4SLinus Torvalds /* 10351da177e4SLinus Torvalds * We can't return errors to poll, so it's either yes or no. 10361da177e4SLinus Torvalds */ 1037b69aee04SEric Dumazet sock = file->private_data; 10381da177e4SLinus Torvalds return sock->ops->poll(file, sock, wait); 10391da177e4SLinus Torvalds } 10401da177e4SLinus Torvalds 10411da177e4SLinus Torvalds static int sock_mmap(struct file *file, struct vm_area_struct *vma) 10421da177e4SLinus Torvalds { 1043b69aee04SEric Dumazet struct socket *sock = file->private_data; 10441da177e4SLinus Torvalds 10451da177e4SLinus Torvalds return sock->ops->mmap(file, sock, vma); 10461da177e4SLinus Torvalds } 10471da177e4SLinus Torvalds 104820380731SArnaldo Carvalho de Melo static int sock_close(struct inode *inode, struct file *filp) 10491da177e4SLinus Torvalds { 10501da177e4SLinus Torvalds /* 10511da177e4SLinus Torvalds * It was possible the inode is NULL we were 10521da177e4SLinus Torvalds * closing an unfinished socket. 10531da177e4SLinus Torvalds */ 10541da177e4SLinus Torvalds 105589bddce5SStephen Hemminger if (!inode) { 10561da177e4SLinus Torvalds printk(KERN_DEBUG "sock_close: NULL inode\n"); 10571da177e4SLinus Torvalds return 0; 10581da177e4SLinus Torvalds } 10591da177e4SLinus Torvalds sock_release(SOCKET_I(inode)); 10601da177e4SLinus Torvalds return 0; 10611da177e4SLinus Torvalds } 10621da177e4SLinus Torvalds 10631da177e4SLinus Torvalds /* 10641da177e4SLinus Torvalds * Update the socket async list 10651da177e4SLinus Torvalds * 10661da177e4SLinus Torvalds * Fasync_list locking strategy. 10671da177e4SLinus Torvalds * 10681da177e4SLinus Torvalds * 1. fasync_list is modified only under process context socket lock 10691da177e4SLinus Torvalds * i.e. under semaphore. 10701da177e4SLinus Torvalds * 2. fasync_list is used under read_lock(&sk->sk_callback_lock) 10711da177e4SLinus Torvalds * or under socket lock. 10721da177e4SLinus Torvalds * 3. fasync_list can be used from softirq context, so that 10731da177e4SLinus Torvalds * modification under socket lock have to be enhanced with 10741da177e4SLinus Torvalds * write_lock_bh(&sk->sk_callback_lock). 10751da177e4SLinus Torvalds * --ANK (990710) 10761da177e4SLinus Torvalds */ 10771da177e4SLinus Torvalds 10781da177e4SLinus Torvalds static int sock_fasync(int fd, struct file *filp, int on) 10791da177e4SLinus Torvalds { 10801da177e4SLinus Torvalds struct fasync_struct *fa, *fna = NULL, **prev; 10811da177e4SLinus Torvalds struct socket *sock; 10821da177e4SLinus Torvalds struct sock *sk; 10831da177e4SLinus Torvalds 108489bddce5SStephen Hemminger if (on) { 10858b3a7005SKris Katterjohn fna = kmalloc(sizeof(struct fasync_struct), GFP_KERNEL); 10861da177e4SLinus Torvalds if (fna == NULL) 10871da177e4SLinus Torvalds return -ENOMEM; 10881da177e4SLinus Torvalds } 10891da177e4SLinus Torvalds 1090b69aee04SEric Dumazet sock = filp->private_data; 10911da177e4SLinus Torvalds 109289bddce5SStephen Hemminger sk = sock->sk; 109389bddce5SStephen Hemminger if (sk == NULL) { 10941da177e4SLinus Torvalds kfree(fna); 10951da177e4SLinus Torvalds return -EINVAL; 10961da177e4SLinus Torvalds } 10971da177e4SLinus Torvalds 10981da177e4SLinus Torvalds lock_sock(sk); 10991da177e4SLinus Torvalds 110076398425SJonathan Corbet spin_lock(&filp->f_lock); 110176398425SJonathan Corbet if (on) 110276398425SJonathan Corbet filp->f_flags |= FASYNC; 110376398425SJonathan Corbet else 110476398425SJonathan Corbet filp->f_flags &= ~FASYNC; 110576398425SJonathan Corbet spin_unlock(&filp->f_lock); 110676398425SJonathan Corbet 11071da177e4SLinus Torvalds prev = &(sock->fasync_list); 11081da177e4SLinus Torvalds 11091da177e4SLinus Torvalds for (fa = *prev; fa != NULL; prev = &fa->fa_next, fa = *prev) 11101da177e4SLinus Torvalds if (fa->fa_file == filp) 11111da177e4SLinus Torvalds break; 11121da177e4SLinus Torvalds 111389bddce5SStephen Hemminger if (on) { 111489bddce5SStephen Hemminger if (fa != NULL) { 11151da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 11161da177e4SLinus Torvalds fa->fa_fd = fd; 11171da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 11181da177e4SLinus Torvalds 11191da177e4SLinus Torvalds kfree(fna); 11201da177e4SLinus Torvalds goto out; 11211da177e4SLinus Torvalds } 11221da177e4SLinus Torvalds fna->fa_file = filp; 11231da177e4SLinus Torvalds fna->fa_fd = fd; 11241da177e4SLinus Torvalds fna->magic = FASYNC_MAGIC; 11251da177e4SLinus Torvalds fna->fa_next = sock->fasync_list; 11261da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 11271da177e4SLinus Torvalds sock->fasync_list = fna; 1128bcdce719SEric Dumazet sock_set_flag(sk, SOCK_FASYNC); 11291da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 113089bddce5SStephen Hemminger } else { 113189bddce5SStephen Hemminger if (fa != NULL) { 11321da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 11331da177e4SLinus Torvalds *prev = fa->fa_next; 1134bcdce719SEric Dumazet if (!sock->fasync_list) 1135bcdce719SEric Dumazet sock_reset_flag(sk, SOCK_FASYNC); 11361da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 11371da177e4SLinus Torvalds kfree(fa); 11381da177e4SLinus Torvalds } 11391da177e4SLinus Torvalds } 11401da177e4SLinus Torvalds 11411da177e4SLinus Torvalds out: 11421da177e4SLinus Torvalds release_sock(sock->sk); 11431da177e4SLinus Torvalds return 0; 11441da177e4SLinus Torvalds } 11451da177e4SLinus Torvalds 11461da177e4SLinus Torvalds /* This function may be called only under socket lock or callback_lock */ 11471da177e4SLinus Torvalds 11481da177e4SLinus Torvalds int sock_wake_async(struct socket *sock, int how, int band) 11491da177e4SLinus Torvalds { 11501da177e4SLinus Torvalds if (!sock || !sock->fasync_list) 11511da177e4SLinus Torvalds return -1; 115289bddce5SStephen Hemminger switch (how) { 11538d8ad9d7SPavel Emelyanov case SOCK_WAKE_WAITD: 11541da177e4SLinus Torvalds if (test_bit(SOCK_ASYNC_WAITDATA, &sock->flags)) 11551da177e4SLinus Torvalds break; 11561da177e4SLinus Torvalds goto call_kill; 11578d8ad9d7SPavel Emelyanov case SOCK_WAKE_SPACE: 11581da177e4SLinus Torvalds if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags)) 11591da177e4SLinus Torvalds break; 11601da177e4SLinus Torvalds /* fall through */ 11618d8ad9d7SPavel Emelyanov case SOCK_WAKE_IO: 11621da177e4SLinus Torvalds call_kill: 11631da177e4SLinus Torvalds __kill_fasync(sock->fasync_list, SIGIO, band); 11641da177e4SLinus Torvalds break; 11658d8ad9d7SPavel Emelyanov case SOCK_WAKE_URG: 11661da177e4SLinus Torvalds __kill_fasync(sock->fasync_list, SIGURG, band); 11671da177e4SLinus Torvalds } 11681da177e4SLinus Torvalds return 0; 11691da177e4SLinus Torvalds } 11701da177e4SLinus Torvalds 11711b8d7ae4SEric W. Biederman static int __sock_create(struct net *net, int family, int type, int protocol, 117289bddce5SStephen Hemminger struct socket **res, int kern) 11731da177e4SLinus Torvalds { 11741da177e4SLinus Torvalds int err; 11751da177e4SLinus Torvalds struct socket *sock; 117655737fdaSStephen Hemminger const struct net_proto_family *pf; 11771da177e4SLinus Torvalds 11781da177e4SLinus Torvalds /* 11791da177e4SLinus Torvalds * Check protocol is in range 11801da177e4SLinus Torvalds */ 11811da177e4SLinus Torvalds if (family < 0 || family >= NPROTO) 11821da177e4SLinus Torvalds return -EAFNOSUPPORT; 11831da177e4SLinus Torvalds if (type < 0 || type >= SOCK_MAX) 11841da177e4SLinus Torvalds return -EINVAL; 11851da177e4SLinus Torvalds 11861da177e4SLinus Torvalds /* Compatibility. 11871da177e4SLinus Torvalds 11881da177e4SLinus Torvalds This uglymoron is moved from INET layer to here to avoid 11891da177e4SLinus Torvalds deadlock in module load. 11901da177e4SLinus Torvalds */ 11911da177e4SLinus Torvalds if (family == PF_INET && type == SOCK_PACKET) { 11921da177e4SLinus Torvalds static int warned; 11931da177e4SLinus Torvalds if (!warned) { 11941da177e4SLinus Torvalds warned = 1; 119589bddce5SStephen Hemminger printk(KERN_INFO "%s uses obsolete (PF_INET,SOCK_PACKET)\n", 119689bddce5SStephen Hemminger current->comm); 11971da177e4SLinus Torvalds } 11981da177e4SLinus Torvalds family = PF_PACKET; 11991da177e4SLinus Torvalds } 12001da177e4SLinus Torvalds 12011da177e4SLinus Torvalds err = security_socket_create(family, type, protocol, kern); 12021da177e4SLinus Torvalds if (err) 12031da177e4SLinus Torvalds return err; 12041da177e4SLinus Torvalds 120555737fdaSStephen Hemminger /* 120655737fdaSStephen Hemminger * Allocate the socket and allow the family to set things up. if 120755737fdaSStephen Hemminger * the protocol is 0, the family is instructed to select an appropriate 120855737fdaSStephen Hemminger * default. 120955737fdaSStephen Hemminger */ 121055737fdaSStephen Hemminger sock = sock_alloc(); 121155737fdaSStephen Hemminger if (!sock) { 121255737fdaSStephen Hemminger if (net_ratelimit()) 121355737fdaSStephen Hemminger printk(KERN_WARNING "socket: no more sockets\n"); 121455737fdaSStephen Hemminger return -ENFILE; /* Not exactly a match, but its the 121555737fdaSStephen Hemminger closest posix thing */ 121655737fdaSStephen Hemminger } 121755737fdaSStephen Hemminger 121855737fdaSStephen Hemminger sock->type = type; 121955737fdaSStephen Hemminger 122095a5afcaSJohannes Berg #ifdef CONFIG_MODULES 12211da177e4SLinus Torvalds /* Attempt to load a protocol module if the find failed. 12221da177e4SLinus Torvalds * 12231da177e4SLinus Torvalds * 12/09/1996 Marcin: But! this makes REALLY only sense, if the user 12241da177e4SLinus Torvalds * requested real, full-featured networking support upon configuration. 12251da177e4SLinus Torvalds * Otherwise module support will break! 12261da177e4SLinus Torvalds */ 122755737fdaSStephen Hemminger if (net_families[family] == NULL) 12281da177e4SLinus Torvalds request_module("net-pf-%d", family); 12291da177e4SLinus Torvalds #endif 12301da177e4SLinus Torvalds 123155737fdaSStephen Hemminger rcu_read_lock(); 123255737fdaSStephen Hemminger pf = rcu_dereference(net_families[family]); 12331da177e4SLinus Torvalds err = -EAFNOSUPPORT; 123455737fdaSStephen Hemminger if (!pf) 123555737fdaSStephen Hemminger goto out_release; 12361da177e4SLinus Torvalds 12371da177e4SLinus Torvalds /* 12381da177e4SLinus Torvalds * We will call the ->create function, that possibly is in a loadable 12391da177e4SLinus Torvalds * module, so we have to bump that loadable module refcnt first. 12401da177e4SLinus Torvalds */ 124155737fdaSStephen Hemminger if (!try_module_get(pf->owner)) 12421da177e4SLinus Torvalds goto out_release; 12431da177e4SLinus Torvalds 124455737fdaSStephen Hemminger /* Now protected by module ref count */ 124555737fdaSStephen Hemminger rcu_read_unlock(); 124655737fdaSStephen Hemminger 12473f378b68SEric Paris err = pf->create(net, sock, protocol, kern); 124855737fdaSStephen Hemminger if (err < 0) 12491da177e4SLinus Torvalds goto out_module_put; 1250a79af59eSFrank Filz 12511da177e4SLinus Torvalds /* 12521da177e4SLinus Torvalds * Now to bump the refcnt of the [loadable] module that owns this 12531da177e4SLinus Torvalds * socket at sock_release time we decrement its refcnt. 12541da177e4SLinus Torvalds */ 125555737fdaSStephen Hemminger if (!try_module_get(sock->ops->owner)) 125655737fdaSStephen Hemminger goto out_module_busy; 125755737fdaSStephen Hemminger 12581da177e4SLinus Torvalds /* 12591da177e4SLinus Torvalds * Now that we're done with the ->create function, the [loadable] 12601da177e4SLinus Torvalds * module can have its refcnt decremented 12611da177e4SLinus Torvalds */ 126255737fdaSStephen Hemminger module_put(pf->owner); 12637420ed23SVenkat Yekkirala err = security_socket_post_create(sock, family, type, protocol, kern); 12647420ed23SVenkat Yekkirala if (err) 12653b185525SHerbert Xu goto out_sock_release; 126655737fdaSStephen Hemminger *res = sock; 12671da177e4SLinus Torvalds 126855737fdaSStephen Hemminger return 0; 126955737fdaSStephen Hemminger 127055737fdaSStephen Hemminger out_module_busy: 127155737fdaSStephen Hemminger err = -EAFNOSUPPORT; 12721da177e4SLinus Torvalds out_module_put: 127355737fdaSStephen Hemminger sock->ops = NULL; 127455737fdaSStephen Hemminger module_put(pf->owner); 127555737fdaSStephen Hemminger out_sock_release: 12761da177e4SLinus Torvalds sock_release(sock); 127755737fdaSStephen Hemminger return err; 127855737fdaSStephen Hemminger 127955737fdaSStephen Hemminger out_release: 128055737fdaSStephen Hemminger rcu_read_unlock(); 128155737fdaSStephen Hemminger goto out_sock_release; 12821da177e4SLinus Torvalds } 12831da177e4SLinus Torvalds 12841da177e4SLinus Torvalds int sock_create(int family, int type, int protocol, struct socket **res) 12851da177e4SLinus Torvalds { 12861b8d7ae4SEric W. Biederman return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0); 12871da177e4SLinus Torvalds } 12881da177e4SLinus Torvalds 12891da177e4SLinus Torvalds int sock_create_kern(int family, int type, int protocol, struct socket **res) 12901da177e4SLinus Torvalds { 12911b8d7ae4SEric W. Biederman return __sock_create(&init_net, family, type, protocol, res, 1); 12921da177e4SLinus Torvalds } 12931da177e4SLinus Torvalds 12943e0fa65fSHeiko Carstens SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol) 12951da177e4SLinus Torvalds { 12961da177e4SLinus Torvalds int retval; 12971da177e4SLinus Torvalds struct socket *sock; 1298a677a039SUlrich Drepper int flags; 1299a677a039SUlrich Drepper 1300e38b36f3SUlrich Drepper /* Check the SOCK_* constants for consistency. */ 1301e38b36f3SUlrich Drepper BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC); 1302e38b36f3SUlrich Drepper BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK); 1303e38b36f3SUlrich Drepper BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK); 1304e38b36f3SUlrich Drepper BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK); 1305e38b36f3SUlrich Drepper 1306a677a039SUlrich Drepper flags = type & ~SOCK_TYPE_MASK; 130777d27200SUlrich Drepper if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)) 1308a677a039SUlrich Drepper return -EINVAL; 1309a677a039SUlrich Drepper type &= SOCK_TYPE_MASK; 13101da177e4SLinus Torvalds 1311aaca0bdcSUlrich Drepper if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK)) 1312aaca0bdcSUlrich Drepper flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK; 1313aaca0bdcSUlrich Drepper 13141da177e4SLinus Torvalds retval = sock_create(family, type, protocol, &sock); 13151da177e4SLinus Torvalds if (retval < 0) 13161da177e4SLinus Torvalds goto out; 13171da177e4SLinus Torvalds 131877d27200SUlrich Drepper retval = sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK)); 13191da177e4SLinus Torvalds if (retval < 0) 13201da177e4SLinus Torvalds goto out_release; 13211da177e4SLinus Torvalds 13221da177e4SLinus Torvalds out: 13231da177e4SLinus Torvalds /* It may be already another descriptor 8) Not kernel problem. */ 13241da177e4SLinus Torvalds return retval; 13251da177e4SLinus Torvalds 13261da177e4SLinus Torvalds out_release: 13271da177e4SLinus Torvalds sock_release(sock); 13281da177e4SLinus Torvalds return retval; 13291da177e4SLinus Torvalds } 13301da177e4SLinus Torvalds 13311da177e4SLinus Torvalds /* 13321da177e4SLinus Torvalds * Create a pair of connected sockets. 13331da177e4SLinus Torvalds */ 13341da177e4SLinus Torvalds 13353e0fa65fSHeiko Carstens SYSCALL_DEFINE4(socketpair, int, family, int, type, int, protocol, 13363e0fa65fSHeiko Carstens int __user *, usockvec) 13371da177e4SLinus Torvalds { 13381da177e4SLinus Torvalds struct socket *sock1, *sock2; 13391da177e4SLinus Torvalds int fd1, fd2, err; 1340db349509SAl Viro struct file *newfile1, *newfile2; 1341a677a039SUlrich Drepper int flags; 1342a677a039SUlrich Drepper 1343a677a039SUlrich Drepper flags = type & ~SOCK_TYPE_MASK; 134477d27200SUlrich Drepper if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)) 1345a677a039SUlrich Drepper return -EINVAL; 1346a677a039SUlrich Drepper type &= SOCK_TYPE_MASK; 13471da177e4SLinus Torvalds 1348aaca0bdcSUlrich Drepper if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK)) 1349aaca0bdcSUlrich Drepper flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK; 1350aaca0bdcSUlrich Drepper 13511da177e4SLinus Torvalds /* 13521da177e4SLinus Torvalds * Obtain the first socket and check if the underlying protocol 13531da177e4SLinus Torvalds * supports the socketpair call. 13541da177e4SLinus Torvalds */ 13551da177e4SLinus Torvalds 13561da177e4SLinus Torvalds err = sock_create(family, type, protocol, &sock1); 13571da177e4SLinus Torvalds if (err < 0) 13581da177e4SLinus Torvalds goto out; 13591da177e4SLinus Torvalds 13601da177e4SLinus Torvalds err = sock_create(family, type, protocol, &sock2); 13611da177e4SLinus Torvalds if (err < 0) 13621da177e4SLinus Torvalds goto out_release_1; 13631da177e4SLinus Torvalds 13641da177e4SLinus Torvalds err = sock1->ops->socketpair(sock1, sock2); 13651da177e4SLinus Torvalds if (err < 0) 13661da177e4SLinus Torvalds goto out_release_both; 13671da177e4SLinus Torvalds 13687cbe66b6SAl Viro fd1 = sock_alloc_file(sock1, &newfile1, flags); 1369bf3c23d1SDavid S. Miller if (unlikely(fd1 < 0)) { 1370bf3c23d1SDavid S. Miller err = fd1; 13711da177e4SLinus Torvalds goto out_release_both; 1372bf3c23d1SDavid S. Miller } 13731da177e4SLinus Torvalds 13747cbe66b6SAl Viro fd2 = sock_alloc_file(sock2, &newfile2, flags); 1375198de4d7SAl Viro if (unlikely(fd2 < 0)) { 1376198de4d7SAl Viro err = fd2; 1377198de4d7SAl Viro fput(newfile1); 1378198de4d7SAl Viro put_unused_fd(fd1); 1379198de4d7SAl Viro sock_release(sock2); 1380198de4d7SAl Viro goto out; 1381db349509SAl Viro } 1382db349509SAl Viro 1383157cf649SAl Viro audit_fd_pair(fd1, fd2); 1384db349509SAl Viro fd_install(fd1, newfile1); 1385db349509SAl Viro fd_install(fd2, newfile2); 13861da177e4SLinus Torvalds /* fd1 and fd2 may be already another descriptors. 13871da177e4SLinus Torvalds * Not kernel problem. 13881da177e4SLinus Torvalds */ 13891da177e4SLinus Torvalds 13901da177e4SLinus Torvalds err = put_user(fd1, &usockvec[0]); 13911da177e4SLinus Torvalds if (!err) 13921da177e4SLinus Torvalds err = put_user(fd2, &usockvec[1]); 13931da177e4SLinus Torvalds if (!err) 13941da177e4SLinus Torvalds return 0; 13951da177e4SLinus Torvalds 13961da177e4SLinus Torvalds sys_close(fd2); 13971da177e4SLinus Torvalds sys_close(fd1); 13981da177e4SLinus Torvalds return err; 13991da177e4SLinus Torvalds 14001da177e4SLinus Torvalds out_release_both: 14011da177e4SLinus Torvalds sock_release(sock2); 14021da177e4SLinus Torvalds out_release_1: 14031da177e4SLinus Torvalds sock_release(sock1); 14041da177e4SLinus Torvalds out: 14051da177e4SLinus Torvalds return err; 14061da177e4SLinus Torvalds } 14071da177e4SLinus Torvalds 14081da177e4SLinus Torvalds /* 14091da177e4SLinus Torvalds * Bind a name to a socket. Nothing much to do here since it's 14101da177e4SLinus Torvalds * the protocol's responsibility to handle the local address. 14111da177e4SLinus Torvalds * 14121da177e4SLinus Torvalds * We move the socket address to kernel space before we call 14131da177e4SLinus Torvalds * the protocol layer (having also checked the address is ok). 14141da177e4SLinus Torvalds */ 14151da177e4SLinus Torvalds 141620f37034SHeiko Carstens SYSCALL_DEFINE3(bind, int, fd, struct sockaddr __user *, umyaddr, int, addrlen) 14171da177e4SLinus Torvalds { 14181da177e4SLinus Torvalds struct socket *sock; 1419230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 14206cb153caSBenjamin LaHaise int err, fput_needed; 14211da177e4SLinus Torvalds 142289bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 142389bddce5SStephen Hemminger if (sock) { 1424230b1839SYOSHIFUJI Hideaki err = move_addr_to_kernel(umyaddr, addrlen, (struct sockaddr *)&address); 142589bddce5SStephen Hemminger if (err >= 0) { 142689bddce5SStephen Hemminger err = security_socket_bind(sock, 1427230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&address, 142889bddce5SStephen Hemminger addrlen); 14296cb153caSBenjamin LaHaise if (!err) 14306cb153caSBenjamin LaHaise err = sock->ops->bind(sock, 143189bddce5SStephen Hemminger (struct sockaddr *) 1432230b1839SYOSHIFUJI Hideaki &address, addrlen); 14331da177e4SLinus Torvalds } 14346cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 14351da177e4SLinus Torvalds } 14361da177e4SLinus Torvalds return err; 14371da177e4SLinus Torvalds } 14381da177e4SLinus Torvalds 14391da177e4SLinus Torvalds /* 14401da177e4SLinus Torvalds * Perform a listen. Basically, we allow the protocol to do anything 14411da177e4SLinus Torvalds * necessary for a listen, and if that works, we mark the socket as 14421da177e4SLinus Torvalds * ready for listening. 14431da177e4SLinus Torvalds */ 14441da177e4SLinus Torvalds 14453e0fa65fSHeiko Carstens SYSCALL_DEFINE2(listen, int, fd, int, backlog) 14461da177e4SLinus Torvalds { 14471da177e4SLinus Torvalds struct socket *sock; 14486cb153caSBenjamin LaHaise int err, fput_needed; 1449b8e1f9b5SPavel Emelyanov int somaxconn; 14501da177e4SLinus Torvalds 145189bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 145289bddce5SStephen Hemminger if (sock) { 14538efa6e93SPavel Emelyanov somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn; 1454b8e1f9b5SPavel Emelyanov if ((unsigned)backlog > somaxconn) 1455b8e1f9b5SPavel Emelyanov backlog = somaxconn; 14561da177e4SLinus Torvalds 14571da177e4SLinus Torvalds err = security_socket_listen(sock, backlog); 14586cb153caSBenjamin LaHaise if (!err) 14591da177e4SLinus Torvalds err = sock->ops->listen(sock, backlog); 14606cb153caSBenjamin LaHaise 14616cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 14621da177e4SLinus Torvalds } 14631da177e4SLinus Torvalds return err; 14641da177e4SLinus Torvalds } 14651da177e4SLinus Torvalds 14661da177e4SLinus Torvalds /* 14671da177e4SLinus Torvalds * For accept, we attempt to create a new socket, set up the link 14681da177e4SLinus Torvalds * with the client, wake up the client, then return the new 14691da177e4SLinus Torvalds * connected fd. We collect the address of the connector in kernel 14701da177e4SLinus Torvalds * space and move it to user at the very end. This is unclean because 14711da177e4SLinus Torvalds * we open the socket then return an error. 14721da177e4SLinus Torvalds * 14731da177e4SLinus Torvalds * 1003.1g adds the ability to recvmsg() to query connection pending 14741da177e4SLinus Torvalds * status to recvmsg. We need to add that support in a way thats 14751da177e4SLinus Torvalds * clean when we restucture accept also. 14761da177e4SLinus Torvalds */ 14771da177e4SLinus Torvalds 147820f37034SHeiko Carstens SYSCALL_DEFINE4(accept4, int, fd, struct sockaddr __user *, upeer_sockaddr, 147920f37034SHeiko Carstens int __user *, upeer_addrlen, int, flags) 14801da177e4SLinus Torvalds { 14811da177e4SLinus Torvalds struct socket *sock, *newsock; 148239d8c1b6SDavid S. Miller struct file *newfile; 14836cb153caSBenjamin LaHaise int err, len, newfd, fput_needed; 1484230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 14851da177e4SLinus Torvalds 148677d27200SUlrich Drepper if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)) 1487aaca0bdcSUlrich Drepper return -EINVAL; 1488aaca0bdcSUlrich Drepper 1489aaca0bdcSUlrich Drepper if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK)) 1490aaca0bdcSUlrich Drepper flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK; 1491aaca0bdcSUlrich Drepper 14926cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 14931da177e4SLinus Torvalds if (!sock) 14941da177e4SLinus Torvalds goto out; 14951da177e4SLinus Torvalds 14961da177e4SLinus Torvalds err = -ENFILE; 14971da177e4SLinus Torvalds if (!(newsock = sock_alloc())) 14981da177e4SLinus Torvalds goto out_put; 14991da177e4SLinus Torvalds 15001da177e4SLinus Torvalds newsock->type = sock->type; 15011da177e4SLinus Torvalds newsock->ops = sock->ops; 15021da177e4SLinus Torvalds 15031da177e4SLinus Torvalds /* 15041da177e4SLinus Torvalds * We don't need try_module_get here, as the listening socket (sock) 15051da177e4SLinus Torvalds * has the protocol module (sock->ops->owner) held. 15061da177e4SLinus Torvalds */ 15071da177e4SLinus Torvalds __module_get(newsock->ops->owner); 15081da177e4SLinus Torvalds 15097cbe66b6SAl Viro newfd = sock_alloc_file(newsock, &newfile, flags); 151039d8c1b6SDavid S. Miller if (unlikely(newfd < 0)) { 151139d8c1b6SDavid S. Miller err = newfd; 15129a1875e6SDavid S. Miller sock_release(newsock); 15139a1875e6SDavid S. Miller goto out_put; 151439d8c1b6SDavid S. Miller } 151539d8c1b6SDavid S. Miller 1516a79af59eSFrank Filz err = security_socket_accept(sock, newsock); 1517a79af59eSFrank Filz if (err) 151839d8c1b6SDavid S. Miller goto out_fd; 1519a79af59eSFrank Filz 15201da177e4SLinus Torvalds err = sock->ops->accept(sock, newsock, sock->file->f_flags); 15211da177e4SLinus Torvalds if (err < 0) 152239d8c1b6SDavid S. Miller goto out_fd; 15231da177e4SLinus Torvalds 15241da177e4SLinus Torvalds if (upeer_sockaddr) { 1525230b1839SYOSHIFUJI Hideaki if (newsock->ops->getname(newsock, (struct sockaddr *)&address, 152689bddce5SStephen Hemminger &len, 2) < 0) { 15271da177e4SLinus Torvalds err = -ECONNABORTED; 152839d8c1b6SDavid S. Miller goto out_fd; 15291da177e4SLinus Torvalds } 1530230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&address, 1531230b1839SYOSHIFUJI Hideaki len, upeer_sockaddr, upeer_addrlen); 15321da177e4SLinus Torvalds if (err < 0) 153339d8c1b6SDavid S. Miller goto out_fd; 15341da177e4SLinus Torvalds } 15351da177e4SLinus Torvalds 15361da177e4SLinus Torvalds /* File flags are not inherited via accept() unlike another OSes. */ 15371da177e4SLinus Torvalds 153839d8c1b6SDavid S. Miller fd_install(newfd, newfile); 153939d8c1b6SDavid S. Miller err = newfd; 15401da177e4SLinus Torvalds 15411da177e4SLinus Torvalds out_put: 15426cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 15431da177e4SLinus Torvalds out: 15441da177e4SLinus Torvalds return err; 154539d8c1b6SDavid S. Miller out_fd: 15469606a216SDavid S. Miller fput(newfile); 154739d8c1b6SDavid S. Miller put_unused_fd(newfd); 15481da177e4SLinus Torvalds goto out_put; 15491da177e4SLinus Torvalds } 15501da177e4SLinus Torvalds 155120f37034SHeiko Carstens SYSCALL_DEFINE3(accept, int, fd, struct sockaddr __user *, upeer_sockaddr, 155220f37034SHeiko Carstens int __user *, upeer_addrlen) 1553aaca0bdcSUlrich Drepper { 1554de11defeSUlrich Drepper return sys_accept4(fd, upeer_sockaddr, upeer_addrlen, 0); 1555aaca0bdcSUlrich Drepper } 1556aaca0bdcSUlrich Drepper 15571da177e4SLinus Torvalds /* 15581da177e4SLinus Torvalds * Attempt to connect to a socket with the server address. The address 15591da177e4SLinus Torvalds * is in user space so we verify it is OK and move it to kernel space. 15601da177e4SLinus Torvalds * 15611da177e4SLinus Torvalds * For 1003.1g we need to add clean support for a bind to AF_UNSPEC to 15621da177e4SLinus Torvalds * break bindings 15631da177e4SLinus Torvalds * 15641da177e4SLinus Torvalds * NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and 15651da177e4SLinus Torvalds * other SEQPACKET protocols that take time to connect() as it doesn't 15661da177e4SLinus Torvalds * include the -EINPROGRESS status for such sockets. 15671da177e4SLinus Torvalds */ 15681da177e4SLinus Torvalds 156920f37034SHeiko Carstens SYSCALL_DEFINE3(connect, int, fd, struct sockaddr __user *, uservaddr, 157020f37034SHeiko Carstens int, addrlen) 15711da177e4SLinus Torvalds { 15721da177e4SLinus Torvalds struct socket *sock; 1573230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 15746cb153caSBenjamin LaHaise int err, fput_needed; 15751da177e4SLinus Torvalds 15766cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 15771da177e4SLinus Torvalds if (!sock) 15781da177e4SLinus Torvalds goto out; 1579230b1839SYOSHIFUJI Hideaki err = move_addr_to_kernel(uservaddr, addrlen, (struct sockaddr *)&address); 15801da177e4SLinus Torvalds if (err < 0) 15811da177e4SLinus Torvalds goto out_put; 15821da177e4SLinus Torvalds 158389bddce5SStephen Hemminger err = 1584230b1839SYOSHIFUJI Hideaki security_socket_connect(sock, (struct sockaddr *)&address, addrlen); 15851da177e4SLinus Torvalds if (err) 15861da177e4SLinus Torvalds goto out_put; 15871da177e4SLinus Torvalds 1588230b1839SYOSHIFUJI Hideaki err = sock->ops->connect(sock, (struct sockaddr *)&address, addrlen, 15891da177e4SLinus Torvalds sock->file->f_flags); 15901da177e4SLinus Torvalds out_put: 15916cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 15921da177e4SLinus Torvalds out: 15931da177e4SLinus Torvalds return err; 15941da177e4SLinus Torvalds } 15951da177e4SLinus Torvalds 15961da177e4SLinus Torvalds /* 15971da177e4SLinus Torvalds * Get the local address ('name') of a socket object. Move the obtained 15981da177e4SLinus Torvalds * name to user space. 15991da177e4SLinus Torvalds */ 16001da177e4SLinus Torvalds 160120f37034SHeiko Carstens SYSCALL_DEFINE3(getsockname, int, fd, struct sockaddr __user *, usockaddr, 160220f37034SHeiko Carstens int __user *, usockaddr_len) 16031da177e4SLinus Torvalds { 16041da177e4SLinus Torvalds struct socket *sock; 1605230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 16066cb153caSBenjamin LaHaise int len, err, fput_needed; 16071da177e4SLinus Torvalds 16086cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 16091da177e4SLinus Torvalds if (!sock) 16101da177e4SLinus Torvalds goto out; 16111da177e4SLinus Torvalds 16121da177e4SLinus Torvalds err = security_socket_getsockname(sock); 16131da177e4SLinus Torvalds if (err) 16141da177e4SLinus Torvalds goto out_put; 16151da177e4SLinus Torvalds 1616230b1839SYOSHIFUJI Hideaki err = sock->ops->getname(sock, (struct sockaddr *)&address, &len, 0); 16171da177e4SLinus Torvalds if (err) 16181da177e4SLinus Torvalds goto out_put; 1619230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr, usockaddr_len); 16201da177e4SLinus Torvalds 16211da177e4SLinus Torvalds out_put: 16226cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 16231da177e4SLinus Torvalds out: 16241da177e4SLinus Torvalds return err; 16251da177e4SLinus Torvalds } 16261da177e4SLinus Torvalds 16271da177e4SLinus Torvalds /* 16281da177e4SLinus Torvalds * Get the remote address ('name') of a socket object. Move the obtained 16291da177e4SLinus Torvalds * name to user space. 16301da177e4SLinus Torvalds */ 16311da177e4SLinus Torvalds 163220f37034SHeiko Carstens SYSCALL_DEFINE3(getpeername, int, fd, struct sockaddr __user *, usockaddr, 163320f37034SHeiko Carstens int __user *, usockaddr_len) 16341da177e4SLinus Torvalds { 16351da177e4SLinus Torvalds struct socket *sock; 1636230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 16376cb153caSBenjamin LaHaise int len, err, fput_needed; 16381da177e4SLinus Torvalds 163989bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 164089bddce5SStephen Hemminger if (sock != NULL) { 16411da177e4SLinus Torvalds err = security_socket_getpeername(sock); 16421da177e4SLinus Torvalds if (err) { 16436cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 16441da177e4SLinus Torvalds return err; 16451da177e4SLinus Torvalds } 16461da177e4SLinus Torvalds 164789bddce5SStephen Hemminger err = 1648230b1839SYOSHIFUJI Hideaki sock->ops->getname(sock, (struct sockaddr *)&address, &len, 164989bddce5SStephen Hemminger 1); 16501da177e4SLinus Torvalds if (!err) 1651230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr, 165289bddce5SStephen Hemminger usockaddr_len); 16536cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 16541da177e4SLinus Torvalds } 16551da177e4SLinus Torvalds return err; 16561da177e4SLinus Torvalds } 16571da177e4SLinus Torvalds 16581da177e4SLinus Torvalds /* 16591da177e4SLinus Torvalds * Send a datagram to a given address. We move the address into kernel 16601da177e4SLinus Torvalds * space and check the user space data area is readable before invoking 16611da177e4SLinus Torvalds * the protocol. 16621da177e4SLinus Torvalds */ 16631da177e4SLinus Torvalds 16643e0fa65fSHeiko Carstens SYSCALL_DEFINE6(sendto, int, fd, void __user *, buff, size_t, len, 16653e0fa65fSHeiko Carstens unsigned, flags, struct sockaddr __user *, addr, 16663e0fa65fSHeiko Carstens int, addr_len) 16671da177e4SLinus Torvalds { 16681da177e4SLinus Torvalds struct socket *sock; 1669230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 16701da177e4SLinus Torvalds int err; 16711da177e4SLinus Torvalds struct msghdr msg; 16721da177e4SLinus Torvalds struct iovec iov; 16736cb153caSBenjamin LaHaise int fput_needed; 16741da177e4SLinus Torvalds 1675de0fa95cSPavel Emelyanov sock = sockfd_lookup_light(fd, &err, &fput_needed); 1676de0fa95cSPavel Emelyanov if (!sock) 16774387ff75SDavid S. Miller goto out; 16786cb153caSBenjamin LaHaise 16791da177e4SLinus Torvalds iov.iov_base = buff; 16801da177e4SLinus Torvalds iov.iov_len = len; 16811da177e4SLinus Torvalds msg.msg_name = NULL; 16821da177e4SLinus Torvalds msg.msg_iov = &iov; 16831da177e4SLinus Torvalds msg.msg_iovlen = 1; 16841da177e4SLinus Torvalds msg.msg_control = NULL; 16851da177e4SLinus Torvalds msg.msg_controllen = 0; 16861da177e4SLinus Torvalds msg.msg_namelen = 0; 16876cb153caSBenjamin LaHaise if (addr) { 1688230b1839SYOSHIFUJI Hideaki err = move_addr_to_kernel(addr, addr_len, (struct sockaddr *)&address); 16891da177e4SLinus Torvalds if (err < 0) 16901da177e4SLinus Torvalds goto out_put; 1691230b1839SYOSHIFUJI Hideaki msg.msg_name = (struct sockaddr *)&address; 16921da177e4SLinus Torvalds msg.msg_namelen = addr_len; 16931da177e4SLinus Torvalds } 16941da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 16951da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 16961da177e4SLinus Torvalds msg.msg_flags = flags; 16971da177e4SLinus Torvalds err = sock_sendmsg(sock, &msg, len); 16981da177e4SLinus Torvalds 16991da177e4SLinus Torvalds out_put: 1700de0fa95cSPavel Emelyanov fput_light(sock->file, fput_needed); 17014387ff75SDavid S. Miller out: 17021da177e4SLinus Torvalds return err; 17031da177e4SLinus Torvalds } 17041da177e4SLinus Torvalds 17051da177e4SLinus Torvalds /* 17061da177e4SLinus Torvalds * Send a datagram down a socket. 17071da177e4SLinus Torvalds */ 17081da177e4SLinus Torvalds 17093e0fa65fSHeiko Carstens SYSCALL_DEFINE4(send, int, fd, void __user *, buff, size_t, len, 17103e0fa65fSHeiko Carstens unsigned, flags) 17111da177e4SLinus Torvalds { 17121da177e4SLinus Torvalds return sys_sendto(fd, buff, len, flags, NULL, 0); 17131da177e4SLinus Torvalds } 17141da177e4SLinus Torvalds 17151da177e4SLinus Torvalds /* 17161da177e4SLinus Torvalds * Receive a frame from the socket and optionally record the address of the 17171da177e4SLinus Torvalds * sender. We verify the buffers are writable and if needed move the 17181da177e4SLinus Torvalds * sender address from kernel to user space. 17191da177e4SLinus Torvalds */ 17201da177e4SLinus Torvalds 17213e0fa65fSHeiko Carstens SYSCALL_DEFINE6(recvfrom, int, fd, void __user *, ubuf, size_t, size, 17223e0fa65fSHeiko Carstens unsigned, flags, struct sockaddr __user *, addr, 17233e0fa65fSHeiko Carstens int __user *, addr_len) 17241da177e4SLinus Torvalds { 17251da177e4SLinus Torvalds struct socket *sock; 17261da177e4SLinus Torvalds struct iovec iov; 17271da177e4SLinus Torvalds struct msghdr msg; 1728230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 17291da177e4SLinus Torvalds int err, err2; 17306cb153caSBenjamin LaHaise int fput_needed; 17311da177e4SLinus Torvalds 1732de0fa95cSPavel Emelyanov sock = sockfd_lookup_light(fd, &err, &fput_needed); 17331da177e4SLinus Torvalds if (!sock) 1734de0fa95cSPavel Emelyanov goto out; 17351da177e4SLinus Torvalds 17361da177e4SLinus Torvalds msg.msg_control = NULL; 17371da177e4SLinus Torvalds msg.msg_controllen = 0; 17381da177e4SLinus Torvalds msg.msg_iovlen = 1; 17391da177e4SLinus Torvalds msg.msg_iov = &iov; 17401da177e4SLinus Torvalds iov.iov_len = size; 17411da177e4SLinus Torvalds iov.iov_base = ubuf; 1742230b1839SYOSHIFUJI Hideaki msg.msg_name = (struct sockaddr *)&address; 1743230b1839SYOSHIFUJI Hideaki msg.msg_namelen = sizeof(address); 17441da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 17451da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 17461da177e4SLinus Torvalds err = sock_recvmsg(sock, &msg, size, flags); 17471da177e4SLinus Torvalds 174889bddce5SStephen Hemminger if (err >= 0 && addr != NULL) { 1749230b1839SYOSHIFUJI Hideaki err2 = move_addr_to_user((struct sockaddr *)&address, 1750230b1839SYOSHIFUJI Hideaki msg.msg_namelen, addr, addr_len); 17511da177e4SLinus Torvalds if (err2 < 0) 17521da177e4SLinus Torvalds err = err2; 17531da177e4SLinus Torvalds } 1754de0fa95cSPavel Emelyanov 1755de0fa95cSPavel Emelyanov fput_light(sock->file, fput_needed); 17564387ff75SDavid S. Miller out: 17571da177e4SLinus Torvalds return err; 17581da177e4SLinus Torvalds } 17591da177e4SLinus Torvalds 17601da177e4SLinus Torvalds /* 17611da177e4SLinus Torvalds * Receive a datagram from a socket. 17621da177e4SLinus Torvalds */ 17631da177e4SLinus Torvalds 176489bddce5SStephen Hemminger asmlinkage long sys_recv(int fd, void __user *ubuf, size_t size, 176589bddce5SStephen Hemminger unsigned flags) 17661da177e4SLinus Torvalds { 17671da177e4SLinus Torvalds return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL); 17681da177e4SLinus Torvalds } 17691da177e4SLinus Torvalds 17701da177e4SLinus Torvalds /* 17711da177e4SLinus Torvalds * Set a socket option. Because we don't know the option lengths we have 17721da177e4SLinus Torvalds * to pass the user mode parameter for the protocols to sort out. 17731da177e4SLinus Torvalds */ 17741da177e4SLinus Torvalds 177520f37034SHeiko Carstens SYSCALL_DEFINE5(setsockopt, int, fd, int, level, int, optname, 177620f37034SHeiko Carstens char __user *, optval, int, optlen) 17771da177e4SLinus Torvalds { 17786cb153caSBenjamin LaHaise int err, fput_needed; 17791da177e4SLinus Torvalds struct socket *sock; 17801da177e4SLinus Torvalds 17811da177e4SLinus Torvalds if (optlen < 0) 17821da177e4SLinus Torvalds return -EINVAL; 17831da177e4SLinus Torvalds 178489bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 178589bddce5SStephen Hemminger if (sock != NULL) { 17861da177e4SLinus Torvalds err = security_socket_setsockopt(sock, level, optname); 17876cb153caSBenjamin LaHaise if (err) 17886cb153caSBenjamin LaHaise goto out_put; 17891da177e4SLinus Torvalds 17901da177e4SLinus Torvalds if (level == SOL_SOCKET) 179189bddce5SStephen Hemminger err = 179289bddce5SStephen Hemminger sock_setsockopt(sock, level, optname, optval, 179389bddce5SStephen Hemminger optlen); 17941da177e4SLinus Torvalds else 179589bddce5SStephen Hemminger err = 179689bddce5SStephen Hemminger sock->ops->setsockopt(sock, level, optname, optval, 179789bddce5SStephen Hemminger optlen); 17986cb153caSBenjamin LaHaise out_put: 17996cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 18001da177e4SLinus Torvalds } 18011da177e4SLinus Torvalds return err; 18021da177e4SLinus Torvalds } 18031da177e4SLinus Torvalds 18041da177e4SLinus Torvalds /* 18051da177e4SLinus Torvalds * Get a socket option. Because we don't know the option lengths we have 18061da177e4SLinus Torvalds * to pass a user mode parameter for the protocols to sort out. 18071da177e4SLinus Torvalds */ 18081da177e4SLinus Torvalds 180920f37034SHeiko Carstens SYSCALL_DEFINE5(getsockopt, int, fd, int, level, int, optname, 181020f37034SHeiko Carstens char __user *, optval, int __user *, optlen) 18111da177e4SLinus Torvalds { 18126cb153caSBenjamin LaHaise int err, fput_needed; 18131da177e4SLinus Torvalds struct socket *sock; 18141da177e4SLinus Torvalds 181589bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 181689bddce5SStephen Hemminger if (sock != NULL) { 18176cb153caSBenjamin LaHaise err = security_socket_getsockopt(sock, level, optname); 18186cb153caSBenjamin LaHaise if (err) 18196cb153caSBenjamin LaHaise goto out_put; 18201da177e4SLinus Torvalds 18211da177e4SLinus Torvalds if (level == SOL_SOCKET) 182289bddce5SStephen Hemminger err = 182389bddce5SStephen Hemminger sock_getsockopt(sock, level, optname, optval, 182489bddce5SStephen Hemminger optlen); 18251da177e4SLinus Torvalds else 182689bddce5SStephen Hemminger err = 182789bddce5SStephen Hemminger sock->ops->getsockopt(sock, level, optname, optval, 182889bddce5SStephen Hemminger optlen); 18296cb153caSBenjamin LaHaise out_put: 18306cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 18311da177e4SLinus Torvalds } 18321da177e4SLinus Torvalds return err; 18331da177e4SLinus Torvalds } 18341da177e4SLinus Torvalds 18351da177e4SLinus Torvalds /* 18361da177e4SLinus Torvalds * Shutdown a socket. 18371da177e4SLinus Torvalds */ 18381da177e4SLinus Torvalds 1839754fe8d2SHeiko Carstens SYSCALL_DEFINE2(shutdown, int, fd, int, how) 18401da177e4SLinus Torvalds { 18416cb153caSBenjamin LaHaise int err, fput_needed; 18421da177e4SLinus Torvalds struct socket *sock; 18431da177e4SLinus Torvalds 184489bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 184589bddce5SStephen Hemminger if (sock != NULL) { 18461da177e4SLinus Torvalds err = security_socket_shutdown(sock, how); 18476cb153caSBenjamin LaHaise if (!err) 18481da177e4SLinus Torvalds err = sock->ops->shutdown(sock, how); 18496cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 18501da177e4SLinus Torvalds } 18511da177e4SLinus Torvalds return err; 18521da177e4SLinus Torvalds } 18531da177e4SLinus Torvalds 18541da177e4SLinus Torvalds /* A couple of helpful macros for getting the address of the 32/64 bit 18551da177e4SLinus Torvalds * fields which are the same type (int / unsigned) on our platforms. 18561da177e4SLinus Torvalds */ 18571da177e4SLinus Torvalds #define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member) 18581da177e4SLinus Torvalds #define COMPAT_NAMELEN(msg) COMPAT_MSG(msg, msg_namelen) 18591da177e4SLinus Torvalds #define COMPAT_FLAGS(msg) COMPAT_MSG(msg, msg_flags) 18601da177e4SLinus Torvalds 18611da177e4SLinus Torvalds /* 18621da177e4SLinus Torvalds * BSD sendmsg interface 18631da177e4SLinus Torvalds */ 18641da177e4SLinus Torvalds 18653e0fa65fSHeiko Carstens SYSCALL_DEFINE3(sendmsg, int, fd, struct msghdr __user *, msg, unsigned, flags) 18661da177e4SLinus Torvalds { 186789bddce5SStephen Hemminger struct compat_msghdr __user *msg_compat = 186889bddce5SStephen Hemminger (struct compat_msghdr __user *)msg; 18691da177e4SLinus Torvalds struct socket *sock; 1870230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 18711da177e4SLinus Torvalds struct iovec iovstack[UIO_FASTIOV], *iov = iovstack; 1872b9d717a7SAlex Williamson unsigned char ctl[sizeof(struct cmsghdr) + 20] 1873b9d717a7SAlex Williamson __attribute__ ((aligned(sizeof(__kernel_size_t)))); 1874b9d717a7SAlex Williamson /* 20 is size of ipv6_pktinfo */ 18751da177e4SLinus Torvalds unsigned char *ctl_buf = ctl; 18761da177e4SLinus Torvalds struct msghdr msg_sys; 18771da177e4SLinus Torvalds int err, ctl_len, iov_size, total_len; 18786cb153caSBenjamin LaHaise int fput_needed; 18791da177e4SLinus Torvalds 18801da177e4SLinus Torvalds err = -EFAULT; 18811da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 18821da177e4SLinus Torvalds if (get_compat_msghdr(&msg_sys, msg_compat)) 18831da177e4SLinus Torvalds return -EFAULT; 188489bddce5SStephen Hemminger } 188589bddce5SStephen Hemminger else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr))) 18861da177e4SLinus Torvalds return -EFAULT; 18871da177e4SLinus Torvalds 18886cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 18891da177e4SLinus Torvalds if (!sock) 18901da177e4SLinus Torvalds goto out; 18911da177e4SLinus Torvalds 18921da177e4SLinus Torvalds /* do not move before msg_sys is valid */ 18931da177e4SLinus Torvalds err = -EMSGSIZE; 18941da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_MAXIOV) 18951da177e4SLinus Torvalds goto out_put; 18961da177e4SLinus Torvalds 18971da177e4SLinus Torvalds /* Check whether to allocate the iovec area */ 18981da177e4SLinus Torvalds err = -ENOMEM; 18991da177e4SLinus Torvalds iov_size = msg_sys.msg_iovlen * sizeof(struct iovec); 19001da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_FASTIOV) { 19011da177e4SLinus Torvalds iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL); 19021da177e4SLinus Torvalds if (!iov) 19031da177e4SLinus Torvalds goto out_put; 19041da177e4SLinus Torvalds } 19051da177e4SLinus Torvalds 19061da177e4SLinus Torvalds /* This will also move the address data into kernel space */ 19071da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 1908230b1839SYOSHIFUJI Hideaki err = verify_compat_iovec(&msg_sys, iov, 1909230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&address, 1910230b1839SYOSHIFUJI Hideaki VERIFY_READ); 19111da177e4SLinus Torvalds } else 1912230b1839SYOSHIFUJI Hideaki err = verify_iovec(&msg_sys, iov, 1913230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&address, 1914230b1839SYOSHIFUJI Hideaki VERIFY_READ); 19151da177e4SLinus Torvalds if (err < 0) 19161da177e4SLinus Torvalds goto out_freeiov; 19171da177e4SLinus Torvalds total_len = err; 19181da177e4SLinus Torvalds 19191da177e4SLinus Torvalds err = -ENOBUFS; 19201da177e4SLinus Torvalds 19211da177e4SLinus Torvalds if (msg_sys.msg_controllen > INT_MAX) 19221da177e4SLinus Torvalds goto out_freeiov; 19231da177e4SLinus Torvalds ctl_len = msg_sys.msg_controllen; 19241da177e4SLinus Torvalds if ((MSG_CMSG_COMPAT & flags) && ctl_len) { 192589bddce5SStephen Hemminger err = 192689bddce5SStephen Hemminger cmsghdr_from_user_compat_to_kern(&msg_sys, sock->sk, ctl, 192789bddce5SStephen Hemminger sizeof(ctl)); 19281da177e4SLinus Torvalds if (err) 19291da177e4SLinus Torvalds goto out_freeiov; 19301da177e4SLinus Torvalds ctl_buf = msg_sys.msg_control; 19318920e8f9SAl Viro ctl_len = msg_sys.msg_controllen; 19321da177e4SLinus Torvalds } else if (ctl_len) { 193389bddce5SStephen Hemminger if (ctl_len > sizeof(ctl)) { 19341da177e4SLinus Torvalds ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL); 19351da177e4SLinus Torvalds if (ctl_buf == NULL) 19361da177e4SLinus Torvalds goto out_freeiov; 19371da177e4SLinus Torvalds } 19381da177e4SLinus Torvalds err = -EFAULT; 19391da177e4SLinus Torvalds /* 19401da177e4SLinus Torvalds * Careful! Before this, msg_sys.msg_control contains a user pointer. 19411da177e4SLinus Torvalds * Afterwards, it will be a kernel pointer. Thus the compiler-assisted 19421da177e4SLinus Torvalds * checking falls down on this. 19431da177e4SLinus Torvalds */ 194489bddce5SStephen Hemminger if (copy_from_user(ctl_buf, (void __user *)msg_sys.msg_control, 194589bddce5SStephen Hemminger ctl_len)) 19461da177e4SLinus Torvalds goto out_freectl; 19471da177e4SLinus Torvalds msg_sys.msg_control = ctl_buf; 19481da177e4SLinus Torvalds } 19491da177e4SLinus Torvalds msg_sys.msg_flags = flags; 19501da177e4SLinus Torvalds 19511da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 19521da177e4SLinus Torvalds msg_sys.msg_flags |= MSG_DONTWAIT; 19531da177e4SLinus Torvalds err = sock_sendmsg(sock, &msg_sys, total_len); 19541da177e4SLinus Torvalds 19551da177e4SLinus Torvalds out_freectl: 19561da177e4SLinus Torvalds if (ctl_buf != ctl) 19571da177e4SLinus Torvalds sock_kfree_s(sock->sk, ctl_buf, ctl_len); 19581da177e4SLinus Torvalds out_freeiov: 19591da177e4SLinus Torvalds if (iov != iovstack) 19601da177e4SLinus Torvalds sock_kfree_s(sock->sk, iov, iov_size); 19611da177e4SLinus Torvalds out_put: 19626cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 19631da177e4SLinus Torvalds out: 19641da177e4SLinus Torvalds return err; 19651da177e4SLinus Torvalds } 19661da177e4SLinus Torvalds 1967a2e27255SArnaldo Carvalho de Melo static int __sys_recvmsg(struct socket *sock, struct msghdr __user *msg, 1968a2e27255SArnaldo Carvalho de Melo struct msghdr *msg_sys, unsigned flags, int nosec) 19691da177e4SLinus Torvalds { 197089bddce5SStephen Hemminger struct compat_msghdr __user *msg_compat = 197189bddce5SStephen Hemminger (struct compat_msghdr __user *)msg; 19721da177e4SLinus Torvalds struct iovec iovstack[UIO_FASTIOV]; 19731da177e4SLinus Torvalds struct iovec *iov = iovstack; 19741da177e4SLinus Torvalds unsigned long cmsg_ptr; 19751da177e4SLinus Torvalds int err, iov_size, total_len, len; 19761da177e4SLinus Torvalds 19771da177e4SLinus Torvalds /* kernel mode address */ 1978230b1839SYOSHIFUJI Hideaki struct sockaddr_storage addr; 19791da177e4SLinus Torvalds 19801da177e4SLinus Torvalds /* user mode address pointers */ 19811da177e4SLinus Torvalds struct sockaddr __user *uaddr; 19821da177e4SLinus Torvalds int __user *uaddr_len; 19831da177e4SLinus Torvalds 19841da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 1985a2e27255SArnaldo Carvalho de Melo if (get_compat_msghdr(msg_sys, msg_compat)) 19861da177e4SLinus Torvalds return -EFAULT; 198789bddce5SStephen Hemminger } 1988a2e27255SArnaldo Carvalho de Melo else if (copy_from_user(msg_sys, msg, sizeof(struct msghdr))) 19891da177e4SLinus Torvalds return -EFAULT; 19901da177e4SLinus Torvalds 19911da177e4SLinus Torvalds err = -EMSGSIZE; 1992a2e27255SArnaldo Carvalho de Melo if (msg_sys->msg_iovlen > UIO_MAXIOV) 1993a2e27255SArnaldo Carvalho de Melo goto out; 19941da177e4SLinus Torvalds 19951da177e4SLinus Torvalds /* Check whether to allocate the iovec area */ 19961da177e4SLinus Torvalds err = -ENOMEM; 1997a2e27255SArnaldo Carvalho de Melo iov_size = msg_sys->msg_iovlen * sizeof(struct iovec); 1998a2e27255SArnaldo Carvalho de Melo if (msg_sys->msg_iovlen > UIO_FASTIOV) { 19991da177e4SLinus Torvalds iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL); 20001da177e4SLinus Torvalds if (!iov) 2001a2e27255SArnaldo Carvalho de Melo goto out; 20021da177e4SLinus Torvalds } 20031da177e4SLinus Torvalds 20041da177e4SLinus Torvalds /* 20051da177e4SLinus Torvalds * Save the user-mode address (verify_iovec will change the 20061da177e4SLinus Torvalds * kernel msghdr to use the kernel address space) 20071da177e4SLinus Torvalds */ 20081da177e4SLinus Torvalds 2009a2e27255SArnaldo Carvalho de Melo uaddr = (__force void __user *)msg_sys->msg_name; 20101da177e4SLinus Torvalds uaddr_len = COMPAT_NAMELEN(msg); 20111da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 2012a2e27255SArnaldo Carvalho de Melo err = verify_compat_iovec(msg_sys, iov, 2013230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&addr, 2014230b1839SYOSHIFUJI Hideaki VERIFY_WRITE); 20151da177e4SLinus Torvalds } else 2016a2e27255SArnaldo Carvalho de Melo err = verify_iovec(msg_sys, iov, 2017230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&addr, 2018230b1839SYOSHIFUJI Hideaki VERIFY_WRITE); 20191da177e4SLinus Torvalds if (err < 0) 20201da177e4SLinus Torvalds goto out_freeiov; 20211da177e4SLinus Torvalds total_len = err; 20221da177e4SLinus Torvalds 2023a2e27255SArnaldo Carvalho de Melo cmsg_ptr = (unsigned long)msg_sys->msg_control; 2024a2e27255SArnaldo Carvalho de Melo msg_sys->msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT); 20251da177e4SLinus Torvalds 20261da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 20271da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 2028a2e27255SArnaldo Carvalho de Melo err = (nosec ? sock_recvmsg_nosec : sock_recvmsg)(sock, msg_sys, 2029a2e27255SArnaldo Carvalho de Melo total_len, flags); 20301da177e4SLinus Torvalds if (err < 0) 20311da177e4SLinus Torvalds goto out_freeiov; 20321da177e4SLinus Torvalds len = err; 20331da177e4SLinus Torvalds 20341da177e4SLinus Torvalds if (uaddr != NULL) { 2035230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&addr, 2036a2e27255SArnaldo Carvalho de Melo msg_sys->msg_namelen, uaddr, 203789bddce5SStephen Hemminger uaddr_len); 20381da177e4SLinus Torvalds if (err < 0) 20391da177e4SLinus Torvalds goto out_freeiov; 20401da177e4SLinus Torvalds } 2041a2e27255SArnaldo Carvalho de Melo err = __put_user((msg_sys->msg_flags & ~MSG_CMSG_COMPAT), 204237f7f421SDavid S. Miller COMPAT_FLAGS(msg)); 20431da177e4SLinus Torvalds if (err) 20441da177e4SLinus Torvalds goto out_freeiov; 20451da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) 2046a2e27255SArnaldo Carvalho de Melo err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr, 20471da177e4SLinus Torvalds &msg_compat->msg_controllen); 20481da177e4SLinus Torvalds else 2049a2e27255SArnaldo Carvalho de Melo err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr, 20501da177e4SLinus Torvalds &msg->msg_controllen); 20511da177e4SLinus Torvalds if (err) 20521da177e4SLinus Torvalds goto out_freeiov; 20531da177e4SLinus Torvalds err = len; 20541da177e4SLinus Torvalds 20551da177e4SLinus Torvalds out_freeiov: 20561da177e4SLinus Torvalds if (iov != iovstack) 20571da177e4SLinus Torvalds sock_kfree_s(sock->sk, iov, iov_size); 2058a2e27255SArnaldo Carvalho de Melo out: 2059a2e27255SArnaldo Carvalho de Melo return err; 2060a2e27255SArnaldo Carvalho de Melo } 2061a2e27255SArnaldo Carvalho de Melo 2062a2e27255SArnaldo Carvalho de Melo /* 2063a2e27255SArnaldo Carvalho de Melo * BSD recvmsg interface 2064a2e27255SArnaldo Carvalho de Melo */ 2065a2e27255SArnaldo Carvalho de Melo 2066a2e27255SArnaldo Carvalho de Melo SYSCALL_DEFINE3(recvmsg, int, fd, struct msghdr __user *, msg, 2067a2e27255SArnaldo Carvalho de Melo unsigned int, flags) 2068a2e27255SArnaldo Carvalho de Melo { 2069a2e27255SArnaldo Carvalho de Melo int fput_needed, err; 2070a2e27255SArnaldo Carvalho de Melo struct msghdr msg_sys; 2071a2e27255SArnaldo Carvalho de Melo struct socket *sock = sockfd_lookup_light(fd, &err, &fput_needed); 2072a2e27255SArnaldo Carvalho de Melo 2073a2e27255SArnaldo Carvalho de Melo if (!sock) 2074a2e27255SArnaldo Carvalho de Melo goto out; 2075a2e27255SArnaldo Carvalho de Melo 2076a2e27255SArnaldo Carvalho de Melo err = __sys_recvmsg(sock, msg, &msg_sys, flags, 0); 2077a2e27255SArnaldo Carvalho de Melo 20786cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 20791da177e4SLinus Torvalds out: 20801da177e4SLinus Torvalds return err; 20811da177e4SLinus Torvalds } 20821da177e4SLinus Torvalds 2083a2e27255SArnaldo Carvalho de Melo /* 2084a2e27255SArnaldo Carvalho de Melo * Linux recvmmsg interface 2085a2e27255SArnaldo Carvalho de Melo */ 20861da177e4SLinus Torvalds 2087a2e27255SArnaldo Carvalho de Melo int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen, 2088a2e27255SArnaldo Carvalho de Melo unsigned int flags, struct timespec *timeout) 2089a2e27255SArnaldo Carvalho de Melo { 2090a2e27255SArnaldo Carvalho de Melo int fput_needed, err, datagrams; 2091a2e27255SArnaldo Carvalho de Melo struct socket *sock; 2092a2e27255SArnaldo Carvalho de Melo struct mmsghdr __user *entry; 2093d7256d0eSJean-Mickael Guerin struct compat_mmsghdr __user *compat_entry; 2094a2e27255SArnaldo Carvalho de Melo struct msghdr msg_sys; 2095a2e27255SArnaldo Carvalho de Melo struct timespec end_time; 2096a2e27255SArnaldo Carvalho de Melo 2097a2e27255SArnaldo Carvalho de Melo if (timeout && 2098a2e27255SArnaldo Carvalho de Melo poll_select_set_timeout(&end_time, timeout->tv_sec, 2099a2e27255SArnaldo Carvalho de Melo timeout->tv_nsec)) 2100a2e27255SArnaldo Carvalho de Melo return -EINVAL; 2101a2e27255SArnaldo Carvalho de Melo 2102a2e27255SArnaldo Carvalho de Melo datagrams = 0; 2103a2e27255SArnaldo Carvalho de Melo 2104a2e27255SArnaldo Carvalho de Melo sock = sockfd_lookup_light(fd, &err, &fput_needed); 2105a2e27255SArnaldo Carvalho de Melo if (!sock) 2106a2e27255SArnaldo Carvalho de Melo return err; 2107a2e27255SArnaldo Carvalho de Melo 2108a2e27255SArnaldo Carvalho de Melo err = sock_error(sock->sk); 2109a2e27255SArnaldo Carvalho de Melo if (err) 2110a2e27255SArnaldo Carvalho de Melo goto out_put; 2111a2e27255SArnaldo Carvalho de Melo 2112a2e27255SArnaldo Carvalho de Melo entry = mmsg; 2113d7256d0eSJean-Mickael Guerin compat_entry = (struct compat_mmsghdr __user *)mmsg; 2114a2e27255SArnaldo Carvalho de Melo 2115a2e27255SArnaldo Carvalho de Melo while (datagrams < vlen) { 2116a2e27255SArnaldo Carvalho de Melo /* 2117a2e27255SArnaldo Carvalho de Melo * No need to ask LSM for more than the first datagram. 2118a2e27255SArnaldo Carvalho de Melo */ 2119d7256d0eSJean-Mickael Guerin if (MSG_CMSG_COMPAT & flags) { 2120d7256d0eSJean-Mickael Guerin err = __sys_recvmsg(sock, (struct msghdr __user *)compat_entry, 2121d7256d0eSJean-Mickael Guerin &msg_sys, flags, datagrams); 2122d7256d0eSJean-Mickael Guerin if (err < 0) 2123d7256d0eSJean-Mickael Guerin break; 2124d7256d0eSJean-Mickael Guerin err = __put_user(err, &compat_entry->msg_len); 2125d7256d0eSJean-Mickael Guerin ++compat_entry; 2126d7256d0eSJean-Mickael Guerin } else { 2127a2e27255SArnaldo Carvalho de Melo err = __sys_recvmsg(sock, (struct msghdr __user *)entry, 2128a2e27255SArnaldo Carvalho de Melo &msg_sys, flags, datagrams); 2129a2e27255SArnaldo Carvalho de Melo if (err < 0) 2130a2e27255SArnaldo Carvalho de Melo break; 2131a2e27255SArnaldo Carvalho de Melo err = put_user(err, &entry->msg_len); 2132d7256d0eSJean-Mickael Guerin ++entry; 2133d7256d0eSJean-Mickael Guerin } 2134d7256d0eSJean-Mickael Guerin 2135a2e27255SArnaldo Carvalho de Melo if (err) 2136a2e27255SArnaldo Carvalho de Melo break; 2137a2e27255SArnaldo Carvalho de Melo ++datagrams; 2138a2e27255SArnaldo Carvalho de Melo 213971c5c159SBrandon L Black /* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */ 214071c5c159SBrandon L Black if (flags & MSG_WAITFORONE) 214171c5c159SBrandon L Black flags |= MSG_DONTWAIT; 214271c5c159SBrandon L Black 2143a2e27255SArnaldo Carvalho de Melo if (timeout) { 2144a2e27255SArnaldo Carvalho de Melo ktime_get_ts(timeout); 2145a2e27255SArnaldo Carvalho de Melo *timeout = timespec_sub(end_time, *timeout); 2146a2e27255SArnaldo Carvalho de Melo if (timeout->tv_sec < 0) { 2147a2e27255SArnaldo Carvalho de Melo timeout->tv_sec = timeout->tv_nsec = 0; 2148a2e27255SArnaldo Carvalho de Melo break; 2149a2e27255SArnaldo Carvalho de Melo } 2150a2e27255SArnaldo Carvalho de Melo 2151a2e27255SArnaldo Carvalho de Melo /* Timeout, return less than vlen datagrams */ 2152a2e27255SArnaldo Carvalho de Melo if (timeout->tv_nsec == 0 && timeout->tv_sec == 0) 2153a2e27255SArnaldo Carvalho de Melo break; 2154a2e27255SArnaldo Carvalho de Melo } 2155a2e27255SArnaldo Carvalho de Melo 2156a2e27255SArnaldo Carvalho de Melo /* Out of band data, return right away */ 2157a2e27255SArnaldo Carvalho de Melo if (msg_sys.msg_flags & MSG_OOB) 2158a2e27255SArnaldo Carvalho de Melo break; 2159a2e27255SArnaldo Carvalho de Melo } 2160a2e27255SArnaldo Carvalho de Melo 2161a2e27255SArnaldo Carvalho de Melo out_put: 2162a2e27255SArnaldo Carvalho de Melo fput_light(sock->file, fput_needed); 2163a2e27255SArnaldo Carvalho de Melo 2164a2e27255SArnaldo Carvalho de Melo if (err == 0) 2165a2e27255SArnaldo Carvalho de Melo return datagrams; 2166a2e27255SArnaldo Carvalho de Melo 2167a2e27255SArnaldo Carvalho de Melo if (datagrams != 0) { 2168a2e27255SArnaldo Carvalho de Melo /* 2169a2e27255SArnaldo Carvalho de Melo * We may return less entries than requested (vlen) if the 2170a2e27255SArnaldo Carvalho de Melo * sock is non block and there aren't enough datagrams... 2171a2e27255SArnaldo Carvalho de Melo */ 2172a2e27255SArnaldo Carvalho de Melo if (err != -EAGAIN) { 2173a2e27255SArnaldo Carvalho de Melo /* 2174a2e27255SArnaldo Carvalho de Melo * ... or if recvmsg returns an error after we 2175a2e27255SArnaldo Carvalho de Melo * received some datagrams, where we record the 2176a2e27255SArnaldo Carvalho de Melo * error to return on the next call or if the 2177a2e27255SArnaldo Carvalho de Melo * app asks about it using getsockopt(SO_ERROR). 2178a2e27255SArnaldo Carvalho de Melo */ 2179a2e27255SArnaldo Carvalho de Melo sock->sk->sk_err = -err; 2180a2e27255SArnaldo Carvalho de Melo } 2181a2e27255SArnaldo Carvalho de Melo 2182a2e27255SArnaldo Carvalho de Melo return datagrams; 2183a2e27255SArnaldo Carvalho de Melo } 2184a2e27255SArnaldo Carvalho de Melo 2185a2e27255SArnaldo Carvalho de Melo return err; 2186a2e27255SArnaldo Carvalho de Melo } 2187a2e27255SArnaldo Carvalho de Melo 2188a2e27255SArnaldo Carvalho de Melo SYSCALL_DEFINE5(recvmmsg, int, fd, struct mmsghdr __user *, mmsg, 2189a2e27255SArnaldo Carvalho de Melo unsigned int, vlen, unsigned int, flags, 2190a2e27255SArnaldo Carvalho de Melo struct timespec __user *, timeout) 2191a2e27255SArnaldo Carvalho de Melo { 2192a2e27255SArnaldo Carvalho de Melo int datagrams; 2193a2e27255SArnaldo Carvalho de Melo struct timespec timeout_sys; 2194a2e27255SArnaldo Carvalho de Melo 2195a2e27255SArnaldo Carvalho de Melo if (!timeout) 2196a2e27255SArnaldo Carvalho de Melo return __sys_recvmmsg(fd, mmsg, vlen, flags, NULL); 2197a2e27255SArnaldo Carvalho de Melo 2198a2e27255SArnaldo Carvalho de Melo if (copy_from_user(&timeout_sys, timeout, sizeof(timeout_sys))) 2199a2e27255SArnaldo Carvalho de Melo return -EFAULT; 2200a2e27255SArnaldo Carvalho de Melo 2201a2e27255SArnaldo Carvalho de Melo datagrams = __sys_recvmmsg(fd, mmsg, vlen, flags, &timeout_sys); 2202a2e27255SArnaldo Carvalho de Melo 2203a2e27255SArnaldo Carvalho de Melo if (datagrams > 0 && 2204a2e27255SArnaldo Carvalho de Melo copy_to_user(timeout, &timeout_sys, sizeof(timeout_sys))) 2205a2e27255SArnaldo Carvalho de Melo datagrams = -EFAULT; 2206a2e27255SArnaldo Carvalho de Melo 2207a2e27255SArnaldo Carvalho de Melo return datagrams; 2208a2e27255SArnaldo Carvalho de Melo } 2209a2e27255SArnaldo Carvalho de Melo 2210a2e27255SArnaldo Carvalho de Melo #ifdef __ARCH_WANT_SYS_SOCKETCALL 22111da177e4SLinus Torvalds /* Argument list sizes for sys_socketcall */ 22121da177e4SLinus Torvalds #define AL(x) ((x) * sizeof(unsigned long)) 2213a2e27255SArnaldo Carvalho de Melo static const unsigned char nargs[20] = { 221489bddce5SStephen Hemminger AL(0),AL(3),AL(3),AL(3),AL(2),AL(3), 22151da177e4SLinus Torvalds AL(3),AL(3),AL(4),AL(4),AL(4),AL(6), 2216aaca0bdcSUlrich Drepper AL(6),AL(2),AL(5),AL(5),AL(3),AL(3), 2217a2e27255SArnaldo Carvalho de Melo AL(4),AL(5) 221889bddce5SStephen Hemminger }; 221989bddce5SStephen Hemminger 22201da177e4SLinus Torvalds #undef AL 22211da177e4SLinus Torvalds 22221da177e4SLinus Torvalds /* 22231da177e4SLinus Torvalds * System call vectors. 22241da177e4SLinus Torvalds * 22251da177e4SLinus Torvalds * Argument checking cleaned up. Saved 20% in size. 22261da177e4SLinus Torvalds * This function doesn't need to set the kernel lock because 22271da177e4SLinus Torvalds * it is set by the callees. 22281da177e4SLinus Torvalds */ 22291da177e4SLinus Torvalds 22303e0fa65fSHeiko Carstens SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args) 22311da177e4SLinus Torvalds { 22321da177e4SLinus Torvalds unsigned long a[6]; 22331da177e4SLinus Torvalds unsigned long a0, a1; 22341da177e4SLinus Torvalds int err; 223547379052SArjan van de Ven unsigned int len; 22361da177e4SLinus Torvalds 2237a2e27255SArnaldo Carvalho de Melo if (call < 1 || call > SYS_RECVMMSG) 22381da177e4SLinus Torvalds return -EINVAL; 22391da177e4SLinus Torvalds 224047379052SArjan van de Ven len = nargs[call]; 224147379052SArjan van de Ven if (len > sizeof(a)) 224247379052SArjan van de Ven return -EINVAL; 224347379052SArjan van de Ven 22441da177e4SLinus Torvalds /* copy_from_user should be SMP safe. */ 224547379052SArjan van de Ven if (copy_from_user(a, args, len)) 22461da177e4SLinus Torvalds return -EFAULT; 22471da177e4SLinus Torvalds 2248f3298dc4SAl Viro audit_socketcall(nargs[call] / sizeof(unsigned long), a); 22493ec3b2fbSDavid Woodhouse 22501da177e4SLinus Torvalds a0 = a[0]; 22511da177e4SLinus Torvalds a1 = a[1]; 22521da177e4SLinus Torvalds 225389bddce5SStephen Hemminger switch (call) { 22541da177e4SLinus Torvalds case SYS_SOCKET: 22551da177e4SLinus Torvalds err = sys_socket(a0, a1, a[2]); 22561da177e4SLinus Torvalds break; 22571da177e4SLinus Torvalds case SYS_BIND: 22581da177e4SLinus Torvalds err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]); 22591da177e4SLinus Torvalds break; 22601da177e4SLinus Torvalds case SYS_CONNECT: 22611da177e4SLinus Torvalds err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]); 22621da177e4SLinus Torvalds break; 22631da177e4SLinus Torvalds case SYS_LISTEN: 22641da177e4SLinus Torvalds err = sys_listen(a0, a1); 22651da177e4SLinus Torvalds break; 22661da177e4SLinus Torvalds case SYS_ACCEPT: 2267de11defeSUlrich Drepper err = sys_accept4(a0, (struct sockaddr __user *)a1, 2268aaca0bdcSUlrich Drepper (int __user *)a[2], 0); 22691da177e4SLinus Torvalds break; 22701da177e4SLinus Torvalds case SYS_GETSOCKNAME: 227189bddce5SStephen Hemminger err = 227289bddce5SStephen Hemminger sys_getsockname(a0, (struct sockaddr __user *)a1, 227389bddce5SStephen Hemminger (int __user *)a[2]); 22741da177e4SLinus Torvalds break; 22751da177e4SLinus Torvalds case SYS_GETPEERNAME: 227689bddce5SStephen Hemminger err = 227789bddce5SStephen Hemminger sys_getpeername(a0, (struct sockaddr __user *)a1, 227889bddce5SStephen Hemminger (int __user *)a[2]); 22791da177e4SLinus Torvalds break; 22801da177e4SLinus Torvalds case SYS_SOCKETPAIR: 22811da177e4SLinus Torvalds err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]); 22821da177e4SLinus Torvalds break; 22831da177e4SLinus Torvalds case SYS_SEND: 22841da177e4SLinus Torvalds err = sys_send(a0, (void __user *)a1, a[2], a[3]); 22851da177e4SLinus Torvalds break; 22861da177e4SLinus Torvalds case SYS_SENDTO: 22871da177e4SLinus Torvalds err = sys_sendto(a0, (void __user *)a1, a[2], a[3], 22881da177e4SLinus Torvalds (struct sockaddr __user *)a[4], a[5]); 22891da177e4SLinus Torvalds break; 22901da177e4SLinus Torvalds case SYS_RECV: 22911da177e4SLinus Torvalds err = sys_recv(a0, (void __user *)a1, a[2], a[3]); 22921da177e4SLinus Torvalds break; 22931da177e4SLinus Torvalds case SYS_RECVFROM: 22941da177e4SLinus Torvalds err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3], 229589bddce5SStephen Hemminger (struct sockaddr __user *)a[4], 229689bddce5SStephen Hemminger (int __user *)a[5]); 22971da177e4SLinus Torvalds break; 22981da177e4SLinus Torvalds case SYS_SHUTDOWN: 22991da177e4SLinus Torvalds err = sys_shutdown(a0, a1); 23001da177e4SLinus Torvalds break; 23011da177e4SLinus Torvalds case SYS_SETSOCKOPT: 23021da177e4SLinus Torvalds err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]); 23031da177e4SLinus Torvalds break; 23041da177e4SLinus Torvalds case SYS_GETSOCKOPT: 230589bddce5SStephen Hemminger err = 230689bddce5SStephen Hemminger sys_getsockopt(a0, a1, a[2], (char __user *)a[3], 230789bddce5SStephen Hemminger (int __user *)a[4]); 23081da177e4SLinus Torvalds break; 23091da177e4SLinus Torvalds case SYS_SENDMSG: 23101da177e4SLinus Torvalds err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]); 23111da177e4SLinus Torvalds break; 23121da177e4SLinus Torvalds case SYS_RECVMSG: 23131da177e4SLinus Torvalds err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]); 23141da177e4SLinus Torvalds break; 2315a2e27255SArnaldo Carvalho de Melo case SYS_RECVMMSG: 2316a2e27255SArnaldo Carvalho de Melo err = sys_recvmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3], 2317a2e27255SArnaldo Carvalho de Melo (struct timespec __user *)a[4]); 2318a2e27255SArnaldo Carvalho de Melo break; 2319de11defeSUlrich Drepper case SYS_ACCEPT4: 2320de11defeSUlrich Drepper err = sys_accept4(a0, (struct sockaddr __user *)a1, 2321de11defeSUlrich Drepper (int __user *)a[2], a[3]); 2322aaca0bdcSUlrich Drepper break; 23231da177e4SLinus Torvalds default: 23241da177e4SLinus Torvalds err = -EINVAL; 23251da177e4SLinus Torvalds break; 23261da177e4SLinus Torvalds } 23271da177e4SLinus Torvalds return err; 23281da177e4SLinus Torvalds } 23291da177e4SLinus Torvalds 23301da177e4SLinus Torvalds #endif /* __ARCH_WANT_SYS_SOCKETCALL */ 23311da177e4SLinus Torvalds 233255737fdaSStephen Hemminger /** 233355737fdaSStephen Hemminger * sock_register - add a socket protocol handler 233455737fdaSStephen Hemminger * @ops: description of protocol 233555737fdaSStephen Hemminger * 23361da177e4SLinus Torvalds * This function is called by a protocol handler that wants to 23371da177e4SLinus Torvalds * advertise its address family, and have it linked into the 233855737fdaSStephen Hemminger * socket interface. The value ops->family coresponds to the 233955737fdaSStephen Hemminger * socket system call protocol family. 23401da177e4SLinus Torvalds */ 2341f0fd27d4SStephen Hemminger int sock_register(const struct net_proto_family *ops) 23421da177e4SLinus Torvalds { 23431da177e4SLinus Torvalds int err; 23441da177e4SLinus Torvalds 23451da177e4SLinus Torvalds if (ops->family >= NPROTO) { 234689bddce5SStephen Hemminger printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family, 234789bddce5SStephen Hemminger NPROTO); 23481da177e4SLinus Torvalds return -ENOBUFS; 23491da177e4SLinus Torvalds } 235055737fdaSStephen Hemminger 235155737fdaSStephen Hemminger spin_lock(&net_family_lock); 235255737fdaSStephen Hemminger if (net_families[ops->family]) 23531da177e4SLinus Torvalds err = -EEXIST; 235455737fdaSStephen Hemminger else { 23551da177e4SLinus Torvalds net_families[ops->family] = ops; 23561da177e4SLinus Torvalds err = 0; 23571da177e4SLinus Torvalds } 235855737fdaSStephen Hemminger spin_unlock(&net_family_lock); 235955737fdaSStephen Hemminger 236089bddce5SStephen Hemminger printk(KERN_INFO "NET: Registered protocol family %d\n", ops->family); 23611da177e4SLinus Torvalds return err; 23621da177e4SLinus Torvalds } 23631da177e4SLinus Torvalds 236455737fdaSStephen Hemminger /** 236555737fdaSStephen Hemminger * sock_unregister - remove a protocol handler 236655737fdaSStephen Hemminger * @family: protocol family to remove 236755737fdaSStephen Hemminger * 23681da177e4SLinus Torvalds * This function is called by a protocol handler that wants to 23691da177e4SLinus Torvalds * remove its address family, and have it unlinked from the 237055737fdaSStephen Hemminger * new socket creation. 237155737fdaSStephen Hemminger * 237255737fdaSStephen Hemminger * If protocol handler is a module, then it can use module reference 237355737fdaSStephen Hemminger * counts to protect against new references. If protocol handler is not 237455737fdaSStephen Hemminger * a module then it needs to provide its own protection in 237555737fdaSStephen Hemminger * the ops->create routine. 23761da177e4SLinus Torvalds */ 2377f0fd27d4SStephen Hemminger void sock_unregister(int family) 23781da177e4SLinus Torvalds { 2379f0fd27d4SStephen Hemminger BUG_ON(family < 0 || family >= NPROTO); 23801da177e4SLinus Torvalds 238155737fdaSStephen Hemminger spin_lock(&net_family_lock); 23821da177e4SLinus Torvalds net_families[family] = NULL; 238355737fdaSStephen Hemminger spin_unlock(&net_family_lock); 238455737fdaSStephen Hemminger 238555737fdaSStephen Hemminger synchronize_rcu(); 238655737fdaSStephen Hemminger 238789bddce5SStephen Hemminger printk(KERN_INFO "NET: Unregistered protocol family %d\n", family); 23881da177e4SLinus Torvalds } 23891da177e4SLinus Torvalds 239077d76ea3SAndi Kleen static int __init sock_init(void) 23911da177e4SLinus Torvalds { 23921da177e4SLinus Torvalds /* 23931da177e4SLinus Torvalds * Initialize sock SLAB cache. 23941da177e4SLinus Torvalds */ 23951da177e4SLinus Torvalds 23961da177e4SLinus Torvalds sk_init(); 23971da177e4SLinus Torvalds 23981da177e4SLinus Torvalds /* 23991da177e4SLinus Torvalds * Initialize skbuff SLAB cache 24001da177e4SLinus Torvalds */ 24011da177e4SLinus Torvalds skb_init(); 24021da177e4SLinus Torvalds 24031da177e4SLinus Torvalds /* 24041da177e4SLinus Torvalds * Initialize the protocols module. 24051da177e4SLinus Torvalds */ 24061da177e4SLinus Torvalds 24071da177e4SLinus Torvalds init_inodecache(); 24081da177e4SLinus Torvalds register_filesystem(&sock_fs_type); 24091da177e4SLinus Torvalds sock_mnt = kern_mount(&sock_fs_type); 241077d76ea3SAndi Kleen 241177d76ea3SAndi Kleen /* The real protocol initialization is performed in later initcalls. 24121da177e4SLinus Torvalds */ 24131da177e4SLinus Torvalds 24141da177e4SLinus Torvalds #ifdef CONFIG_NETFILTER 24151da177e4SLinus Torvalds netfilter_init(); 24161da177e4SLinus Torvalds #endif 2417cbeb321aSDavid S. Miller 2418cbeb321aSDavid S. Miller return 0; 24191da177e4SLinus Torvalds } 24201da177e4SLinus Torvalds 242177d76ea3SAndi Kleen core_initcall(sock_init); /* early initcall */ 242277d76ea3SAndi Kleen 24231da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 24241da177e4SLinus Torvalds void socket_seq_show(struct seq_file *seq) 24251da177e4SLinus Torvalds { 24261da177e4SLinus Torvalds int cpu; 24271da177e4SLinus Torvalds int counter = 0; 24281da177e4SLinus Torvalds 24296f912042SKAMEZAWA Hiroyuki for_each_possible_cpu(cpu) 24301da177e4SLinus Torvalds counter += per_cpu(sockets_in_use, cpu); 24311da177e4SLinus Torvalds 24321da177e4SLinus Torvalds /* It can be negative, by the way. 8) */ 24331da177e4SLinus Torvalds if (counter < 0) 24341da177e4SLinus Torvalds counter = 0; 24351da177e4SLinus Torvalds 24361da177e4SLinus Torvalds seq_printf(seq, "sockets: used %d\n", counter); 24371da177e4SLinus Torvalds } 24381da177e4SLinus Torvalds #endif /* CONFIG_PROC_FS */ 24391da177e4SLinus Torvalds 244089bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 24416b96018bSArnd Bergmann static int do_siocgstamp(struct net *net, struct socket *sock, 24426b96018bSArnd Bergmann unsigned int cmd, struct compat_timeval __user *up) 24437a229387SArnd Bergmann { 24447a229387SArnd Bergmann mm_segment_t old_fs = get_fs(); 24457a229387SArnd Bergmann struct timeval ktv; 24467a229387SArnd Bergmann int err; 24477a229387SArnd Bergmann 24487a229387SArnd Bergmann set_fs(KERNEL_DS); 24496b96018bSArnd Bergmann err = sock_do_ioctl(net, sock, cmd, (unsigned long)&ktv); 24507a229387SArnd Bergmann set_fs(old_fs); 24517a229387SArnd Bergmann if (!err) { 24527a229387SArnd Bergmann err = put_user(ktv.tv_sec, &up->tv_sec); 24537a229387SArnd Bergmann err |= __put_user(ktv.tv_usec, &up->tv_usec); 24547a229387SArnd Bergmann } 24557a229387SArnd Bergmann return err; 24567a229387SArnd Bergmann } 24577a229387SArnd Bergmann 24586b96018bSArnd Bergmann static int do_siocgstampns(struct net *net, struct socket *sock, 24596b96018bSArnd Bergmann unsigned int cmd, struct compat_timespec __user *up) 24607a229387SArnd Bergmann { 24617a229387SArnd Bergmann mm_segment_t old_fs = get_fs(); 24627a229387SArnd Bergmann struct timespec kts; 24637a229387SArnd Bergmann int err; 24647a229387SArnd Bergmann 24657a229387SArnd Bergmann set_fs(KERNEL_DS); 24666b96018bSArnd Bergmann err = sock_do_ioctl(net, sock, cmd, (unsigned long)&kts); 24677a229387SArnd Bergmann set_fs(old_fs); 24687a229387SArnd Bergmann if (!err) { 24697a229387SArnd Bergmann err = put_user(kts.tv_sec, &up->tv_sec); 24707a229387SArnd Bergmann err |= __put_user(kts.tv_nsec, &up->tv_nsec); 24717a229387SArnd Bergmann } 24727a229387SArnd Bergmann return err; 24737a229387SArnd Bergmann } 24747a229387SArnd Bergmann 24756b96018bSArnd Bergmann static int dev_ifname32(struct net *net, struct compat_ifreq __user *uifr32) 24767a229387SArnd Bergmann { 24777a229387SArnd Bergmann struct ifreq __user *uifr; 24787a229387SArnd Bergmann int err; 24797a229387SArnd Bergmann 24807a229387SArnd Bergmann uifr = compat_alloc_user_space(sizeof(struct ifreq)); 24816b96018bSArnd Bergmann if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq))) 24827a229387SArnd Bergmann return -EFAULT; 24837a229387SArnd Bergmann 24846b96018bSArnd Bergmann err = dev_ioctl(net, SIOCGIFNAME, uifr); 24857a229387SArnd Bergmann if (err) 24867a229387SArnd Bergmann return err; 24877a229387SArnd Bergmann 24886b96018bSArnd Bergmann if (copy_in_user(uifr32, uifr, sizeof(struct compat_ifreq))) 24897a229387SArnd Bergmann return -EFAULT; 24907a229387SArnd Bergmann 24917a229387SArnd Bergmann return 0; 24927a229387SArnd Bergmann } 24937a229387SArnd Bergmann 24946b96018bSArnd Bergmann static int dev_ifconf(struct net *net, struct compat_ifconf __user *uifc32) 24957a229387SArnd Bergmann { 24966b96018bSArnd Bergmann struct compat_ifconf ifc32; 24977a229387SArnd Bergmann struct ifconf ifc; 24987a229387SArnd Bergmann struct ifconf __user *uifc; 24996b96018bSArnd Bergmann struct compat_ifreq __user *ifr32; 25007a229387SArnd Bergmann struct ifreq __user *ifr; 25017a229387SArnd Bergmann unsigned int i, j; 25027a229387SArnd Bergmann int err; 25037a229387SArnd Bergmann 25046b96018bSArnd Bergmann if (copy_from_user(&ifc32, uifc32, sizeof(struct compat_ifconf))) 25057a229387SArnd Bergmann return -EFAULT; 25067a229387SArnd Bergmann 25077a229387SArnd Bergmann if (ifc32.ifcbuf == 0) { 25087a229387SArnd Bergmann ifc32.ifc_len = 0; 25097a229387SArnd Bergmann ifc.ifc_len = 0; 25107a229387SArnd Bergmann ifc.ifc_req = NULL; 25117a229387SArnd Bergmann uifc = compat_alloc_user_space(sizeof(struct ifconf)); 25127a229387SArnd Bergmann } else { 25136b96018bSArnd Bergmann size_t len =((ifc32.ifc_len / sizeof (struct compat_ifreq)) + 1) * 25147a229387SArnd Bergmann sizeof (struct ifreq); 25157a229387SArnd Bergmann uifc = compat_alloc_user_space(sizeof(struct ifconf) + len); 25167a229387SArnd Bergmann ifc.ifc_len = len; 25177a229387SArnd Bergmann ifr = ifc.ifc_req = (void __user *)(uifc + 1); 25187a229387SArnd Bergmann ifr32 = compat_ptr(ifc32.ifcbuf); 25196b96018bSArnd Bergmann for (i = 0; i < ifc32.ifc_len; i += sizeof (struct compat_ifreq)) { 25206b96018bSArnd Bergmann if (copy_in_user(ifr, ifr32, sizeof(struct compat_ifreq))) 25217a229387SArnd Bergmann return -EFAULT; 25227a229387SArnd Bergmann ifr++; 25237a229387SArnd Bergmann ifr32++; 25247a229387SArnd Bergmann } 25257a229387SArnd Bergmann } 25267a229387SArnd Bergmann if (copy_to_user(uifc, &ifc, sizeof(struct ifconf))) 25277a229387SArnd Bergmann return -EFAULT; 25287a229387SArnd Bergmann 25296b96018bSArnd Bergmann err = dev_ioctl(net, SIOCGIFCONF, uifc); 25307a229387SArnd Bergmann if (err) 25317a229387SArnd Bergmann return err; 25327a229387SArnd Bergmann 25337a229387SArnd Bergmann if (copy_from_user(&ifc, uifc, sizeof(struct ifconf))) 25347a229387SArnd Bergmann return -EFAULT; 25357a229387SArnd Bergmann 25367a229387SArnd Bergmann ifr = ifc.ifc_req; 25377a229387SArnd Bergmann ifr32 = compat_ptr(ifc32.ifcbuf); 25387a229387SArnd Bergmann for (i = 0, j = 0; 25396b96018bSArnd Bergmann i + sizeof (struct compat_ifreq) <= ifc32.ifc_len && j < ifc.ifc_len; 25406b96018bSArnd Bergmann i += sizeof (struct compat_ifreq), j += sizeof (struct ifreq)) { 25416b96018bSArnd Bergmann if (copy_in_user(ifr32, ifr, sizeof (struct compat_ifreq))) 25427a229387SArnd Bergmann return -EFAULT; 25437a229387SArnd Bergmann ifr32++; 25447a229387SArnd Bergmann ifr++; 25457a229387SArnd Bergmann } 25467a229387SArnd Bergmann 25477a229387SArnd Bergmann if (ifc32.ifcbuf == 0) { 25487a229387SArnd Bergmann /* Translate from 64-bit structure multiple to 25497a229387SArnd Bergmann * a 32-bit one. 25507a229387SArnd Bergmann */ 25517a229387SArnd Bergmann i = ifc.ifc_len; 25526b96018bSArnd Bergmann i = ((i / sizeof(struct ifreq)) * sizeof(struct compat_ifreq)); 25537a229387SArnd Bergmann ifc32.ifc_len = i; 25547a229387SArnd Bergmann } else { 25557a229387SArnd Bergmann ifc32.ifc_len = i; 25567a229387SArnd Bergmann } 25576b96018bSArnd Bergmann if (copy_to_user(uifc32, &ifc32, sizeof(struct compat_ifconf))) 25587a229387SArnd Bergmann return -EFAULT; 25597a229387SArnd Bergmann 25607a229387SArnd Bergmann return 0; 25617a229387SArnd Bergmann } 25627a229387SArnd Bergmann 25636b96018bSArnd Bergmann static int ethtool_ioctl(struct net *net, struct compat_ifreq __user *ifr32) 25647a229387SArnd Bergmann { 25657a229387SArnd Bergmann struct ifreq __user *ifr; 25667a229387SArnd Bergmann u32 data; 25677a229387SArnd Bergmann void __user *datap; 25687a229387SArnd Bergmann 25697a229387SArnd Bergmann ifr = compat_alloc_user_space(sizeof(*ifr)); 25707a229387SArnd Bergmann 25717a229387SArnd Bergmann if (copy_in_user(&ifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ)) 25727a229387SArnd Bergmann return -EFAULT; 25737a229387SArnd Bergmann 25747a229387SArnd Bergmann if (get_user(data, &ifr32->ifr_ifru.ifru_data)) 25757a229387SArnd Bergmann return -EFAULT; 25767a229387SArnd Bergmann 25777a229387SArnd Bergmann datap = compat_ptr(data); 25787a229387SArnd Bergmann if (put_user(datap, &ifr->ifr_ifru.ifru_data)) 25797a229387SArnd Bergmann return -EFAULT; 25807a229387SArnd Bergmann 25816b96018bSArnd Bergmann return dev_ioctl(net, SIOCETHTOOL, ifr); 25827a229387SArnd Bergmann } 25837a229387SArnd Bergmann 25847a50a240SArnd Bergmann static int compat_siocwandev(struct net *net, struct compat_ifreq __user *uifr32) 25857a50a240SArnd Bergmann { 25867a50a240SArnd Bergmann void __user *uptr; 25877a50a240SArnd Bergmann compat_uptr_t uptr32; 25887a50a240SArnd Bergmann struct ifreq __user *uifr; 25897a50a240SArnd Bergmann 25907a50a240SArnd Bergmann uifr = compat_alloc_user_space(sizeof (*uifr)); 25917a50a240SArnd Bergmann if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq))) 25927a50a240SArnd Bergmann return -EFAULT; 25937a50a240SArnd Bergmann 25947a50a240SArnd Bergmann if (get_user(uptr32, &uifr32->ifr_settings.ifs_ifsu)) 25957a50a240SArnd Bergmann return -EFAULT; 25967a50a240SArnd Bergmann 25977a50a240SArnd Bergmann uptr = compat_ptr(uptr32); 25987a50a240SArnd Bergmann 25997a50a240SArnd Bergmann if (put_user(uptr, &uifr->ifr_settings.ifs_ifsu.raw_hdlc)) 26007a50a240SArnd Bergmann return -EFAULT; 26017a50a240SArnd Bergmann 26027a50a240SArnd Bergmann return dev_ioctl(net, SIOCWANDEV, uifr); 26037a50a240SArnd Bergmann } 26047a50a240SArnd Bergmann 26056b96018bSArnd Bergmann static int bond_ioctl(struct net *net, unsigned int cmd, 26066b96018bSArnd Bergmann struct compat_ifreq __user *ifr32) 26077a229387SArnd Bergmann { 26087a229387SArnd Bergmann struct ifreq kifr; 26097a229387SArnd Bergmann struct ifreq __user *uifr; 26107a229387SArnd Bergmann mm_segment_t old_fs; 26117a229387SArnd Bergmann int err; 26127a229387SArnd Bergmann u32 data; 26137a229387SArnd Bergmann void __user *datap; 26147a229387SArnd Bergmann 26157a229387SArnd Bergmann switch (cmd) { 26167a229387SArnd Bergmann case SIOCBONDENSLAVE: 26177a229387SArnd Bergmann case SIOCBONDRELEASE: 26187a229387SArnd Bergmann case SIOCBONDSETHWADDR: 26197a229387SArnd Bergmann case SIOCBONDCHANGEACTIVE: 26206b96018bSArnd Bergmann if (copy_from_user(&kifr, ifr32, sizeof(struct compat_ifreq))) 26217a229387SArnd Bergmann return -EFAULT; 26227a229387SArnd Bergmann 26237a229387SArnd Bergmann old_fs = get_fs(); 26247a229387SArnd Bergmann set_fs (KERNEL_DS); 26256b96018bSArnd Bergmann err = dev_ioctl(net, cmd, &kifr); 26267a229387SArnd Bergmann set_fs (old_fs); 26277a229387SArnd Bergmann 26287a229387SArnd Bergmann return err; 26297a229387SArnd Bergmann case SIOCBONDSLAVEINFOQUERY: 26307a229387SArnd Bergmann case SIOCBONDINFOQUERY: 26317a229387SArnd Bergmann uifr = compat_alloc_user_space(sizeof(*uifr)); 26327a229387SArnd Bergmann if (copy_in_user(&uifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ)) 26337a229387SArnd Bergmann return -EFAULT; 26347a229387SArnd Bergmann 26357a229387SArnd Bergmann if (get_user(data, &ifr32->ifr_ifru.ifru_data)) 26367a229387SArnd Bergmann return -EFAULT; 26377a229387SArnd Bergmann 26387a229387SArnd Bergmann datap = compat_ptr(data); 26397a229387SArnd Bergmann if (put_user(datap, &uifr->ifr_ifru.ifru_data)) 26407a229387SArnd Bergmann return -EFAULT; 26417a229387SArnd Bergmann 26426b96018bSArnd Bergmann return dev_ioctl(net, cmd, uifr); 26437a229387SArnd Bergmann default: 26447a229387SArnd Bergmann return -EINVAL; 26457a229387SArnd Bergmann }; 26467a229387SArnd Bergmann } 26477a229387SArnd Bergmann 26486b96018bSArnd Bergmann static int siocdevprivate_ioctl(struct net *net, unsigned int cmd, 26496b96018bSArnd Bergmann struct compat_ifreq __user *u_ifreq32) 26507a229387SArnd Bergmann { 26517a229387SArnd Bergmann struct ifreq __user *u_ifreq64; 26527a229387SArnd Bergmann char tmp_buf[IFNAMSIZ]; 26537a229387SArnd Bergmann void __user *data64; 26547a229387SArnd Bergmann u32 data32; 26557a229387SArnd Bergmann 26567a229387SArnd Bergmann if (copy_from_user(&tmp_buf[0], &(u_ifreq32->ifr_ifrn.ifrn_name[0]), 26577a229387SArnd Bergmann IFNAMSIZ)) 26587a229387SArnd Bergmann return -EFAULT; 26597a229387SArnd Bergmann if (__get_user(data32, &u_ifreq32->ifr_ifru.ifru_data)) 26607a229387SArnd Bergmann return -EFAULT; 26617a229387SArnd Bergmann data64 = compat_ptr(data32); 26627a229387SArnd Bergmann 26637a229387SArnd Bergmann u_ifreq64 = compat_alloc_user_space(sizeof(*u_ifreq64)); 26647a229387SArnd Bergmann 26657a229387SArnd Bergmann /* Don't check these user accesses, just let that get trapped 26667a229387SArnd Bergmann * in the ioctl handler instead. 26677a229387SArnd Bergmann */ 26687a229387SArnd Bergmann if (copy_to_user(&u_ifreq64->ifr_ifrn.ifrn_name[0], &tmp_buf[0], 26697a229387SArnd Bergmann IFNAMSIZ)) 26707a229387SArnd Bergmann return -EFAULT; 26717a229387SArnd Bergmann if (__put_user(data64, &u_ifreq64->ifr_ifru.ifru_data)) 26727a229387SArnd Bergmann return -EFAULT; 26737a229387SArnd Bergmann 26746b96018bSArnd Bergmann return dev_ioctl(net, cmd, u_ifreq64); 26757a229387SArnd Bergmann } 26767a229387SArnd Bergmann 26776b96018bSArnd Bergmann static int dev_ifsioc(struct net *net, struct socket *sock, 26786b96018bSArnd Bergmann unsigned int cmd, struct compat_ifreq __user *uifr32) 26797a229387SArnd Bergmann { 2680a2116ed2SArnd Bergmann struct ifreq __user *uifr; 26817a229387SArnd Bergmann int err; 26827a229387SArnd Bergmann 2683a2116ed2SArnd Bergmann uifr = compat_alloc_user_space(sizeof(*uifr)); 2684a2116ed2SArnd Bergmann if (copy_in_user(uifr, uifr32, sizeof(*uifr32))) 26857a229387SArnd Bergmann return -EFAULT; 2686a2116ed2SArnd Bergmann 2687a2116ed2SArnd Bergmann err = sock_do_ioctl(net, sock, cmd, (unsigned long)uifr); 2688a2116ed2SArnd Bergmann 26897a229387SArnd Bergmann if (!err) { 26907a229387SArnd Bergmann switch (cmd) { 26917a229387SArnd Bergmann case SIOCGIFFLAGS: 26927a229387SArnd Bergmann case SIOCGIFMETRIC: 26937a229387SArnd Bergmann case SIOCGIFMTU: 26947a229387SArnd Bergmann case SIOCGIFMEM: 26957a229387SArnd Bergmann case SIOCGIFHWADDR: 26967a229387SArnd Bergmann case SIOCGIFINDEX: 26977a229387SArnd Bergmann case SIOCGIFADDR: 26987a229387SArnd Bergmann case SIOCGIFBRDADDR: 26997a229387SArnd Bergmann case SIOCGIFDSTADDR: 27007a229387SArnd Bergmann case SIOCGIFNETMASK: 2701fab2532bSArnd Bergmann case SIOCGIFPFLAGS: 27027a229387SArnd Bergmann case SIOCGIFTXQLEN: 2703fab2532bSArnd Bergmann case SIOCGMIIPHY: 2704fab2532bSArnd Bergmann case SIOCGMIIREG: 2705a2116ed2SArnd Bergmann if (copy_in_user(uifr32, uifr, sizeof(*uifr32))) 2706a2116ed2SArnd Bergmann err = -EFAULT; 27077a229387SArnd Bergmann break; 2708a2116ed2SArnd Bergmann } 2709a2116ed2SArnd Bergmann } 2710a2116ed2SArnd Bergmann return err; 2711a2116ed2SArnd Bergmann } 2712a2116ed2SArnd Bergmann 2713a2116ed2SArnd Bergmann static int compat_sioc_ifmap(struct net *net, unsigned int cmd, 2714a2116ed2SArnd Bergmann struct compat_ifreq __user *uifr32) 2715a2116ed2SArnd Bergmann { 2716a2116ed2SArnd Bergmann struct ifreq ifr; 2717a2116ed2SArnd Bergmann struct compat_ifmap __user *uifmap32; 2718a2116ed2SArnd Bergmann mm_segment_t old_fs; 2719a2116ed2SArnd Bergmann int err; 2720a2116ed2SArnd Bergmann 2721a2116ed2SArnd Bergmann uifmap32 = &uifr32->ifr_ifru.ifru_map; 2722a2116ed2SArnd Bergmann err = copy_from_user(&ifr, uifr32, sizeof(ifr.ifr_name)); 2723a2116ed2SArnd Bergmann err |= __get_user(ifr.ifr_map.mem_start, &uifmap32->mem_start); 2724a2116ed2SArnd Bergmann err |= __get_user(ifr.ifr_map.mem_end, &uifmap32->mem_end); 2725a2116ed2SArnd Bergmann err |= __get_user(ifr.ifr_map.base_addr, &uifmap32->base_addr); 2726a2116ed2SArnd Bergmann err |= __get_user(ifr.ifr_map.irq, &uifmap32->irq); 2727a2116ed2SArnd Bergmann err |= __get_user(ifr.ifr_map.dma, &uifmap32->dma); 2728a2116ed2SArnd Bergmann err |= __get_user(ifr.ifr_map.port, &uifmap32->port); 2729a2116ed2SArnd Bergmann if (err) 2730a2116ed2SArnd Bergmann return -EFAULT; 2731a2116ed2SArnd Bergmann 2732a2116ed2SArnd Bergmann old_fs = get_fs(); 2733a2116ed2SArnd Bergmann set_fs (KERNEL_DS); 2734a2116ed2SArnd Bergmann err = dev_ioctl(net, cmd, (void __user *)&ifr); 2735a2116ed2SArnd Bergmann set_fs (old_fs); 2736a2116ed2SArnd Bergmann 2737a2116ed2SArnd Bergmann if (cmd == SIOCGIFMAP && !err) { 27387a229387SArnd Bergmann err = copy_to_user(uifr32, &ifr, sizeof(ifr.ifr_name)); 27397a229387SArnd Bergmann err |= __put_user(ifr.ifr_map.mem_start, &uifmap32->mem_start); 27407a229387SArnd Bergmann err |= __put_user(ifr.ifr_map.mem_end, &uifmap32->mem_end); 27417a229387SArnd Bergmann err |= __put_user(ifr.ifr_map.base_addr, &uifmap32->base_addr); 27427a229387SArnd Bergmann err |= __put_user(ifr.ifr_map.irq, &uifmap32->irq); 27437a229387SArnd Bergmann err |= __put_user(ifr.ifr_map.dma, &uifmap32->dma); 27447a229387SArnd Bergmann err |= __put_user(ifr.ifr_map.port, &uifmap32->port); 27457a229387SArnd Bergmann if (err) 27467a229387SArnd Bergmann err = -EFAULT; 27477a229387SArnd Bergmann } 27487a229387SArnd Bergmann return err; 27497a229387SArnd Bergmann } 27507a229387SArnd Bergmann 2751a2116ed2SArnd Bergmann static int compat_siocshwtstamp(struct net *net, struct compat_ifreq __user *uifr32) 2752a2116ed2SArnd Bergmann { 2753a2116ed2SArnd Bergmann void __user *uptr; 2754a2116ed2SArnd Bergmann compat_uptr_t uptr32; 2755a2116ed2SArnd Bergmann struct ifreq __user *uifr; 2756a2116ed2SArnd Bergmann 2757a2116ed2SArnd Bergmann uifr = compat_alloc_user_space(sizeof (*uifr)); 2758a2116ed2SArnd Bergmann if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq))) 2759a2116ed2SArnd Bergmann return -EFAULT; 2760a2116ed2SArnd Bergmann 2761a2116ed2SArnd Bergmann if (get_user(uptr32, &uifr32->ifr_data)) 2762a2116ed2SArnd Bergmann return -EFAULT; 2763a2116ed2SArnd Bergmann 2764a2116ed2SArnd Bergmann uptr = compat_ptr(uptr32); 2765a2116ed2SArnd Bergmann 2766a2116ed2SArnd Bergmann if (put_user(uptr, &uifr->ifr_data)) 2767a2116ed2SArnd Bergmann return -EFAULT; 2768a2116ed2SArnd Bergmann 2769a2116ed2SArnd Bergmann return dev_ioctl(net, SIOCSHWTSTAMP, uifr); 2770a2116ed2SArnd Bergmann } 2771a2116ed2SArnd Bergmann 27727a229387SArnd Bergmann struct rtentry32 { 27737a229387SArnd Bergmann u32 rt_pad1; 27747a229387SArnd Bergmann struct sockaddr rt_dst; /* target address */ 27757a229387SArnd Bergmann struct sockaddr rt_gateway; /* gateway addr (RTF_GATEWAY) */ 27767a229387SArnd Bergmann struct sockaddr rt_genmask; /* target network mask (IP) */ 27777a229387SArnd Bergmann unsigned short rt_flags; 27787a229387SArnd Bergmann short rt_pad2; 27797a229387SArnd Bergmann u32 rt_pad3; 27807a229387SArnd Bergmann unsigned char rt_tos; 27817a229387SArnd Bergmann unsigned char rt_class; 27827a229387SArnd Bergmann short rt_pad4; 27837a229387SArnd Bergmann short rt_metric; /* +1 for binary compatibility! */ 27847a229387SArnd Bergmann /* char * */ u32 rt_dev; /* forcing the device at add */ 27857a229387SArnd Bergmann u32 rt_mtu; /* per route MTU/Window */ 27867a229387SArnd Bergmann u32 rt_window; /* Window clamping */ 27877a229387SArnd Bergmann unsigned short rt_irtt; /* Initial RTT */ 27887a229387SArnd Bergmann }; 27897a229387SArnd Bergmann 27907a229387SArnd Bergmann struct in6_rtmsg32 { 27917a229387SArnd Bergmann struct in6_addr rtmsg_dst; 27927a229387SArnd Bergmann struct in6_addr rtmsg_src; 27937a229387SArnd Bergmann struct in6_addr rtmsg_gateway; 27947a229387SArnd Bergmann u32 rtmsg_type; 27957a229387SArnd Bergmann u16 rtmsg_dst_len; 27967a229387SArnd Bergmann u16 rtmsg_src_len; 27977a229387SArnd Bergmann u32 rtmsg_metric; 27987a229387SArnd Bergmann u32 rtmsg_info; 27997a229387SArnd Bergmann u32 rtmsg_flags; 28007a229387SArnd Bergmann s32 rtmsg_ifindex; 28017a229387SArnd Bergmann }; 28027a229387SArnd Bergmann 28036b96018bSArnd Bergmann static int routing_ioctl(struct net *net, struct socket *sock, 28046b96018bSArnd Bergmann unsigned int cmd, void __user *argp) 28057a229387SArnd Bergmann { 28067a229387SArnd Bergmann int ret; 28077a229387SArnd Bergmann void *r = NULL; 28087a229387SArnd Bergmann struct in6_rtmsg r6; 28097a229387SArnd Bergmann struct rtentry r4; 28107a229387SArnd Bergmann char devname[16]; 28117a229387SArnd Bergmann u32 rtdev; 28127a229387SArnd Bergmann mm_segment_t old_fs = get_fs(); 28137a229387SArnd Bergmann 28146b96018bSArnd Bergmann if (sock && sock->sk && sock->sk->sk_family == AF_INET6) { /* ipv6 */ 28156b96018bSArnd Bergmann struct in6_rtmsg32 __user *ur6 = argp; 28167a229387SArnd Bergmann ret = copy_from_user (&r6.rtmsg_dst, &(ur6->rtmsg_dst), 28177a229387SArnd Bergmann 3 * sizeof(struct in6_addr)); 28187a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_type, &(ur6->rtmsg_type)); 28197a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_dst_len, &(ur6->rtmsg_dst_len)); 28207a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_src_len, &(ur6->rtmsg_src_len)); 28217a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_metric, &(ur6->rtmsg_metric)); 28227a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_info, &(ur6->rtmsg_info)); 28237a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_flags, &(ur6->rtmsg_flags)); 28247a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_ifindex, &(ur6->rtmsg_ifindex)); 28257a229387SArnd Bergmann 28267a229387SArnd Bergmann r = (void *) &r6; 28277a229387SArnd Bergmann } else { /* ipv4 */ 28286b96018bSArnd Bergmann struct rtentry32 __user *ur4 = argp; 28297a229387SArnd Bergmann ret = copy_from_user (&r4.rt_dst, &(ur4->rt_dst), 28307a229387SArnd Bergmann 3 * sizeof(struct sockaddr)); 28317a229387SArnd Bergmann ret |= __get_user (r4.rt_flags, &(ur4->rt_flags)); 28327a229387SArnd Bergmann ret |= __get_user (r4.rt_metric, &(ur4->rt_metric)); 28337a229387SArnd Bergmann ret |= __get_user (r4.rt_mtu, &(ur4->rt_mtu)); 28347a229387SArnd Bergmann ret |= __get_user (r4.rt_window, &(ur4->rt_window)); 28357a229387SArnd Bergmann ret |= __get_user (r4.rt_irtt, &(ur4->rt_irtt)); 28367a229387SArnd Bergmann ret |= __get_user (rtdev, &(ur4->rt_dev)); 28377a229387SArnd Bergmann if (rtdev) { 28387a229387SArnd Bergmann ret |= copy_from_user (devname, compat_ptr(rtdev), 15); 28397a229387SArnd Bergmann r4.rt_dev = devname; devname[15] = 0; 28407a229387SArnd Bergmann } else 28417a229387SArnd Bergmann r4.rt_dev = NULL; 28427a229387SArnd Bergmann 28437a229387SArnd Bergmann r = (void *) &r4; 28447a229387SArnd Bergmann } 28457a229387SArnd Bergmann 28467a229387SArnd Bergmann if (ret) { 28477a229387SArnd Bergmann ret = -EFAULT; 28487a229387SArnd Bergmann goto out; 28497a229387SArnd Bergmann } 28507a229387SArnd Bergmann 28517a229387SArnd Bergmann set_fs (KERNEL_DS); 28526b96018bSArnd Bergmann ret = sock_do_ioctl(net, sock, cmd, (unsigned long) r); 28537a229387SArnd Bergmann set_fs (old_fs); 28547a229387SArnd Bergmann 28557a229387SArnd Bergmann out: 28567a229387SArnd Bergmann return ret; 28577a229387SArnd Bergmann } 28587a229387SArnd Bergmann 28597a229387SArnd Bergmann /* Since old style bridge ioctl's endup using SIOCDEVPRIVATE 28607a229387SArnd Bergmann * for some operations; this forces use of the newer bridge-utils that 28617a229387SArnd Bergmann * use compatiable ioctls 28627a229387SArnd Bergmann */ 28636b96018bSArnd Bergmann static int old_bridge_ioctl(compat_ulong_t __user *argp) 28647a229387SArnd Bergmann { 28656b96018bSArnd Bergmann compat_ulong_t tmp; 28667a229387SArnd Bergmann 28676b96018bSArnd Bergmann if (get_user(tmp, argp)) 28687a229387SArnd Bergmann return -EFAULT; 28697a229387SArnd Bergmann if (tmp == BRCTL_GET_VERSION) 28707a229387SArnd Bergmann return BRCTL_VERSION + 1; 28717a229387SArnd Bergmann return -EINVAL; 28727a229387SArnd Bergmann } 28737a229387SArnd Bergmann 28746b96018bSArnd Bergmann static int compat_sock_ioctl_trans(struct file *file, struct socket *sock, 28756b96018bSArnd Bergmann unsigned int cmd, unsigned long arg) 28766b96018bSArnd Bergmann { 28776b96018bSArnd Bergmann void __user *argp = compat_ptr(arg); 28786b96018bSArnd Bergmann struct sock *sk = sock->sk; 28796b96018bSArnd Bergmann struct net *net = sock_net(sk); 28807a229387SArnd Bergmann 28816b96018bSArnd Bergmann if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) 28826b96018bSArnd Bergmann return siocdevprivate_ioctl(net, cmd, argp); 28837a229387SArnd Bergmann 28846b96018bSArnd Bergmann switch (cmd) { 28856b96018bSArnd Bergmann case SIOCSIFBR: 28866b96018bSArnd Bergmann case SIOCGIFBR: 28876b96018bSArnd Bergmann return old_bridge_ioctl(argp); 28886b96018bSArnd Bergmann case SIOCGIFNAME: 28896b96018bSArnd Bergmann return dev_ifname32(net, argp); 28906b96018bSArnd Bergmann case SIOCGIFCONF: 28916b96018bSArnd Bergmann return dev_ifconf(net, argp); 28926b96018bSArnd Bergmann case SIOCETHTOOL: 28936b96018bSArnd Bergmann return ethtool_ioctl(net, argp); 28947a50a240SArnd Bergmann case SIOCWANDEV: 28957a50a240SArnd Bergmann return compat_siocwandev(net, argp); 2896a2116ed2SArnd Bergmann case SIOCGIFMAP: 2897a2116ed2SArnd Bergmann case SIOCSIFMAP: 2898a2116ed2SArnd Bergmann return compat_sioc_ifmap(net, cmd, argp); 28996b96018bSArnd Bergmann case SIOCBONDENSLAVE: 29006b96018bSArnd Bergmann case SIOCBONDRELEASE: 29016b96018bSArnd Bergmann case SIOCBONDSETHWADDR: 29026b96018bSArnd Bergmann case SIOCBONDSLAVEINFOQUERY: 29036b96018bSArnd Bergmann case SIOCBONDINFOQUERY: 29046b96018bSArnd Bergmann case SIOCBONDCHANGEACTIVE: 29056b96018bSArnd Bergmann return bond_ioctl(net, cmd, argp); 29066b96018bSArnd Bergmann case SIOCADDRT: 29076b96018bSArnd Bergmann case SIOCDELRT: 29086b96018bSArnd Bergmann return routing_ioctl(net, sock, cmd, argp); 29096b96018bSArnd Bergmann case SIOCGSTAMP: 29106b96018bSArnd Bergmann return do_siocgstamp(net, sock, cmd, argp); 29116b96018bSArnd Bergmann case SIOCGSTAMPNS: 29126b96018bSArnd Bergmann return do_siocgstampns(net, sock, cmd, argp); 2913a2116ed2SArnd Bergmann case SIOCSHWTSTAMP: 2914a2116ed2SArnd Bergmann return compat_siocshwtstamp(net, argp); 29157a229387SArnd Bergmann 29166b96018bSArnd Bergmann case FIOSETOWN: 29176b96018bSArnd Bergmann case SIOCSPGRP: 29186b96018bSArnd Bergmann case FIOGETOWN: 29196b96018bSArnd Bergmann case SIOCGPGRP: 29206b96018bSArnd Bergmann case SIOCBRADDBR: 29216b96018bSArnd Bergmann case SIOCBRDELBR: 29226b96018bSArnd Bergmann case SIOCGIFVLAN: 29236b96018bSArnd Bergmann case SIOCSIFVLAN: 29246b96018bSArnd Bergmann case SIOCADDDLCI: 29256b96018bSArnd Bergmann case SIOCDELDLCI: 29266b96018bSArnd Bergmann return sock_ioctl(file, cmd, arg); 29276b96018bSArnd Bergmann 29286b96018bSArnd Bergmann case SIOCGIFFLAGS: 29296b96018bSArnd Bergmann case SIOCSIFFLAGS: 29306b96018bSArnd Bergmann case SIOCGIFMETRIC: 29316b96018bSArnd Bergmann case SIOCSIFMETRIC: 29326b96018bSArnd Bergmann case SIOCGIFMTU: 29336b96018bSArnd Bergmann case SIOCSIFMTU: 29346b96018bSArnd Bergmann case SIOCGIFMEM: 29356b96018bSArnd Bergmann case SIOCSIFMEM: 29366b96018bSArnd Bergmann case SIOCGIFHWADDR: 29376b96018bSArnd Bergmann case SIOCSIFHWADDR: 29386b96018bSArnd Bergmann case SIOCADDMULTI: 29396b96018bSArnd Bergmann case SIOCDELMULTI: 29406b96018bSArnd Bergmann case SIOCGIFINDEX: 29416b96018bSArnd Bergmann case SIOCGIFADDR: 29426b96018bSArnd Bergmann case SIOCSIFADDR: 29436b96018bSArnd Bergmann case SIOCSIFHWBROADCAST: 29446b96018bSArnd Bergmann case SIOCDIFADDR: 29456b96018bSArnd Bergmann case SIOCGIFBRDADDR: 29466b96018bSArnd Bergmann case SIOCSIFBRDADDR: 29476b96018bSArnd Bergmann case SIOCGIFDSTADDR: 29486b96018bSArnd Bergmann case SIOCSIFDSTADDR: 29496b96018bSArnd Bergmann case SIOCGIFNETMASK: 29506b96018bSArnd Bergmann case SIOCSIFNETMASK: 29516b96018bSArnd Bergmann case SIOCSIFPFLAGS: 29526b96018bSArnd Bergmann case SIOCGIFPFLAGS: 29536b96018bSArnd Bergmann case SIOCGIFTXQLEN: 29546b96018bSArnd Bergmann case SIOCSIFTXQLEN: 29556b96018bSArnd Bergmann case SIOCBRADDIF: 29566b96018bSArnd Bergmann case SIOCBRDELIF: 29579177efd3SArnd Bergmann case SIOCSIFNAME: 29589177efd3SArnd Bergmann case SIOCGMIIPHY: 29599177efd3SArnd Bergmann case SIOCGMIIREG: 29609177efd3SArnd Bergmann case SIOCSMIIREG: 29616b96018bSArnd Bergmann return dev_ifsioc(net, sock, cmd, argp); 29629177efd3SArnd Bergmann 29636b96018bSArnd Bergmann case SIOCSARP: 29646b96018bSArnd Bergmann case SIOCGARP: 29656b96018bSArnd Bergmann case SIOCDARP: 29666b96018bSArnd Bergmann case SIOCATMARK: 29679177efd3SArnd Bergmann return sock_do_ioctl(net, sock, cmd, arg); 29689177efd3SArnd Bergmann } 29699177efd3SArnd Bergmann 29709177efd3SArnd Bergmann /* Prevent warning from compat_sys_ioctl, these always 29719177efd3SArnd Bergmann * result in -EINVAL in the native case anyway. */ 29729177efd3SArnd Bergmann switch (cmd) { 29739177efd3SArnd Bergmann case SIOCRTMSG: 29749177efd3SArnd Bergmann case SIOCGIFCOUNT: 29756b96018bSArnd Bergmann case SIOCSRARP: 29766b96018bSArnd Bergmann case SIOCGRARP: 29776b96018bSArnd Bergmann case SIOCDRARP: 29789177efd3SArnd Bergmann case SIOCSIFLINK: 29799177efd3SArnd Bergmann case SIOCGIFSLAVE: 29809177efd3SArnd Bergmann case SIOCSIFSLAVE: 29819177efd3SArnd Bergmann return -EINVAL; 29826b96018bSArnd Bergmann } 29836b96018bSArnd Bergmann 29846b96018bSArnd Bergmann return -ENOIOCTLCMD; 29856b96018bSArnd Bergmann } 29867a229387SArnd Bergmann 298789bbfc95SShaun Pereira static long compat_sock_ioctl(struct file *file, unsigned cmd, 298889bbfc95SShaun Pereira unsigned long arg) 298989bbfc95SShaun Pereira { 299089bbfc95SShaun Pereira struct socket *sock = file->private_data; 299189bbfc95SShaun Pereira int ret = -ENOIOCTLCMD; 299287de87d5SDavid S. Miller struct sock *sk; 299387de87d5SDavid S. Miller struct net *net; 299487de87d5SDavid S. Miller 299587de87d5SDavid S. Miller sk = sock->sk; 299687de87d5SDavid S. Miller net = sock_net(sk); 299789bbfc95SShaun Pereira 299889bbfc95SShaun Pereira if (sock->ops->compat_ioctl) 299989bbfc95SShaun Pereira ret = sock->ops->compat_ioctl(sock, cmd, arg); 300089bbfc95SShaun Pereira 300187de87d5SDavid S. Miller if (ret == -ENOIOCTLCMD && 300287de87d5SDavid S. Miller (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)) 300387de87d5SDavid S. Miller ret = compat_wext_handle_ioctl(net, cmd, arg); 300487de87d5SDavid S. Miller 30056b96018bSArnd Bergmann if (ret == -ENOIOCTLCMD) 30066b96018bSArnd Bergmann ret = compat_sock_ioctl_trans(file, sock, cmd, arg); 30076b96018bSArnd Bergmann 300889bbfc95SShaun Pereira return ret; 300989bbfc95SShaun Pereira } 301089bbfc95SShaun Pereira #endif 301189bbfc95SShaun Pereira 3012ac5a488eSSridhar Samudrala int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen) 3013ac5a488eSSridhar Samudrala { 3014ac5a488eSSridhar Samudrala return sock->ops->bind(sock, addr, addrlen); 3015ac5a488eSSridhar Samudrala } 3016ac5a488eSSridhar Samudrala 3017ac5a488eSSridhar Samudrala int kernel_listen(struct socket *sock, int backlog) 3018ac5a488eSSridhar Samudrala { 3019ac5a488eSSridhar Samudrala return sock->ops->listen(sock, backlog); 3020ac5a488eSSridhar Samudrala } 3021ac5a488eSSridhar Samudrala 3022ac5a488eSSridhar Samudrala int kernel_accept(struct socket *sock, struct socket **newsock, int flags) 3023ac5a488eSSridhar Samudrala { 3024ac5a488eSSridhar Samudrala struct sock *sk = sock->sk; 3025ac5a488eSSridhar Samudrala int err; 3026ac5a488eSSridhar Samudrala 3027ac5a488eSSridhar Samudrala err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 3028ac5a488eSSridhar Samudrala newsock); 3029ac5a488eSSridhar Samudrala if (err < 0) 3030ac5a488eSSridhar Samudrala goto done; 3031ac5a488eSSridhar Samudrala 3032ac5a488eSSridhar Samudrala err = sock->ops->accept(sock, *newsock, flags); 3033ac5a488eSSridhar Samudrala if (err < 0) { 3034ac5a488eSSridhar Samudrala sock_release(*newsock); 3035fa8705b0STony Battersby *newsock = NULL; 3036ac5a488eSSridhar Samudrala goto done; 3037ac5a488eSSridhar Samudrala } 3038ac5a488eSSridhar Samudrala 3039ac5a488eSSridhar Samudrala (*newsock)->ops = sock->ops; 30401b08534eSWei Yongjun __module_get((*newsock)->ops->owner); 3041ac5a488eSSridhar Samudrala 3042ac5a488eSSridhar Samudrala done: 3043ac5a488eSSridhar Samudrala return err; 3044ac5a488eSSridhar Samudrala } 3045ac5a488eSSridhar Samudrala 3046ac5a488eSSridhar Samudrala int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen, 3047ac5a488eSSridhar Samudrala int flags) 3048ac5a488eSSridhar Samudrala { 3049ac5a488eSSridhar Samudrala return sock->ops->connect(sock, addr, addrlen, flags); 3050ac5a488eSSridhar Samudrala } 3051ac5a488eSSridhar Samudrala 3052ac5a488eSSridhar Samudrala int kernel_getsockname(struct socket *sock, struct sockaddr *addr, 3053ac5a488eSSridhar Samudrala int *addrlen) 3054ac5a488eSSridhar Samudrala { 3055ac5a488eSSridhar Samudrala return sock->ops->getname(sock, addr, addrlen, 0); 3056ac5a488eSSridhar Samudrala } 3057ac5a488eSSridhar Samudrala 3058ac5a488eSSridhar Samudrala int kernel_getpeername(struct socket *sock, struct sockaddr *addr, 3059ac5a488eSSridhar Samudrala int *addrlen) 3060ac5a488eSSridhar Samudrala { 3061ac5a488eSSridhar Samudrala return sock->ops->getname(sock, addr, addrlen, 1); 3062ac5a488eSSridhar Samudrala } 3063ac5a488eSSridhar Samudrala 3064ac5a488eSSridhar Samudrala int kernel_getsockopt(struct socket *sock, int level, int optname, 3065ac5a488eSSridhar Samudrala char *optval, int *optlen) 3066ac5a488eSSridhar Samudrala { 3067ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 3068ac5a488eSSridhar Samudrala int err; 3069ac5a488eSSridhar Samudrala 3070ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 3071ac5a488eSSridhar Samudrala if (level == SOL_SOCKET) 3072ac5a488eSSridhar Samudrala err = sock_getsockopt(sock, level, optname, optval, optlen); 3073ac5a488eSSridhar Samudrala else 3074ac5a488eSSridhar Samudrala err = sock->ops->getsockopt(sock, level, optname, optval, 3075ac5a488eSSridhar Samudrala optlen); 3076ac5a488eSSridhar Samudrala set_fs(oldfs); 3077ac5a488eSSridhar Samudrala return err; 3078ac5a488eSSridhar Samudrala } 3079ac5a488eSSridhar Samudrala 3080ac5a488eSSridhar Samudrala int kernel_setsockopt(struct socket *sock, int level, int optname, 3081b7058842SDavid S. Miller char *optval, unsigned int optlen) 3082ac5a488eSSridhar Samudrala { 3083ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 3084ac5a488eSSridhar Samudrala int err; 3085ac5a488eSSridhar Samudrala 3086ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 3087ac5a488eSSridhar Samudrala if (level == SOL_SOCKET) 3088ac5a488eSSridhar Samudrala err = sock_setsockopt(sock, level, optname, optval, optlen); 3089ac5a488eSSridhar Samudrala else 3090ac5a488eSSridhar Samudrala err = sock->ops->setsockopt(sock, level, optname, optval, 3091ac5a488eSSridhar Samudrala optlen); 3092ac5a488eSSridhar Samudrala set_fs(oldfs); 3093ac5a488eSSridhar Samudrala return err; 3094ac5a488eSSridhar Samudrala } 3095ac5a488eSSridhar Samudrala 3096ac5a488eSSridhar Samudrala int kernel_sendpage(struct socket *sock, struct page *page, int offset, 3097ac5a488eSSridhar Samudrala size_t size, int flags) 3098ac5a488eSSridhar Samudrala { 3099ac5a488eSSridhar Samudrala if (sock->ops->sendpage) 3100ac5a488eSSridhar Samudrala return sock->ops->sendpage(sock, page, offset, size, flags); 3101ac5a488eSSridhar Samudrala 3102ac5a488eSSridhar Samudrala return sock_no_sendpage(sock, page, offset, size, flags); 3103ac5a488eSSridhar Samudrala } 3104ac5a488eSSridhar Samudrala 3105ac5a488eSSridhar Samudrala int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg) 3106ac5a488eSSridhar Samudrala { 3107ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 3108ac5a488eSSridhar Samudrala int err; 3109ac5a488eSSridhar Samudrala 3110ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 3111ac5a488eSSridhar Samudrala err = sock->ops->ioctl(sock, cmd, arg); 3112ac5a488eSSridhar Samudrala set_fs(oldfs); 3113ac5a488eSSridhar Samudrala 3114ac5a488eSSridhar Samudrala return err; 3115ac5a488eSSridhar Samudrala } 3116ac5a488eSSridhar Samudrala 311791cf45f0STrond Myklebust int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how) 311891cf45f0STrond Myklebust { 311991cf45f0STrond Myklebust return sock->ops->shutdown(sock, how); 312091cf45f0STrond Myklebust } 312191cf45f0STrond Myklebust 31221da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create); 31231da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create_kern); 31241da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create_lite); 31251da177e4SLinus Torvalds EXPORT_SYMBOL(sock_map_fd); 31261da177e4SLinus Torvalds EXPORT_SYMBOL(sock_recvmsg); 31271da177e4SLinus Torvalds EXPORT_SYMBOL(sock_register); 31281da177e4SLinus Torvalds EXPORT_SYMBOL(sock_release); 31291da177e4SLinus Torvalds EXPORT_SYMBOL(sock_sendmsg); 31301da177e4SLinus Torvalds EXPORT_SYMBOL(sock_unregister); 31311da177e4SLinus Torvalds EXPORT_SYMBOL(sock_wake_async); 31321da177e4SLinus Torvalds EXPORT_SYMBOL(sockfd_lookup); 31331da177e4SLinus Torvalds EXPORT_SYMBOL(kernel_sendmsg); 31341da177e4SLinus Torvalds EXPORT_SYMBOL(kernel_recvmsg); 3135ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_bind); 3136ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_listen); 3137ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_accept); 3138ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_connect); 3139ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getsockname); 3140ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getpeername); 3141ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getsockopt); 3142ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_setsockopt); 3143ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_sendpage); 3144ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_sock_ioctl); 314591cf45f0STrond Myklebust EXPORT_SYMBOL(kernel_sock_shutdown); 3146