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 { 623842509b8SHagen Paul Pfeifer skb_get_timestampns(skb, &ts[0]); 62420d49473SPatrick Ohly put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS, 625842509b8SHagen Paul Pfeifer sizeof(ts[0]), &ts[0]); 62692f37fd2SEric Dumazet } 62792f37fd2SEric Dumazet } 62892f37fd2SEric Dumazet 62920d49473SPatrick Ohly 63020d49473SPatrick Ohly memset(ts, 0, sizeof(ts)); 63120d49473SPatrick Ohly if (skb->tstamp.tv64 && 63220d49473SPatrick Ohly sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE)) { 63320d49473SPatrick Ohly skb_get_timestampns(skb, ts + 0); 63420d49473SPatrick Ohly empty = 0; 63520d49473SPatrick Ohly } 63620d49473SPatrick Ohly if (shhwtstamps) { 63720d49473SPatrick Ohly if (sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE) && 63820d49473SPatrick Ohly ktime2ts(shhwtstamps->syststamp, ts + 1)) 63920d49473SPatrick Ohly empty = 0; 64020d49473SPatrick Ohly if (sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE) && 64120d49473SPatrick Ohly ktime2ts(shhwtstamps->hwtstamp, ts + 2)) 64220d49473SPatrick Ohly empty = 0; 64320d49473SPatrick Ohly } 64420d49473SPatrick Ohly if (!empty) 64520d49473SPatrick Ohly put_cmsg(msg, SOL_SOCKET, 64620d49473SPatrick Ohly SCM_TIMESTAMPING, sizeof(ts), &ts); 64720d49473SPatrick Ohly } 64820d49473SPatrick Ohly 6497c81fd8bSArnaldo Carvalho de Melo EXPORT_SYMBOL_GPL(__sock_recv_timestamp); 6507c81fd8bSArnaldo Carvalho de Melo 6513b885787SNeil Horman inline void sock_recv_drops(struct msghdr *msg, struct sock *sk, struct sk_buff *skb) 6523b885787SNeil Horman { 6533b885787SNeil Horman if (sock_flag(sk, SOCK_RXQ_OVFL) && skb && skb->dropcount) 6543b885787SNeil Horman put_cmsg(msg, SOL_SOCKET, SO_RXQ_OVFL, 6553b885787SNeil Horman sizeof(__u32), &skb->dropcount); 6563b885787SNeil Horman } 6573b885787SNeil Horman 658767dd033SEric Dumazet void __sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk, 6593b885787SNeil Horman struct sk_buff *skb) 6603b885787SNeil Horman { 6613b885787SNeil Horman sock_recv_timestamp(msg, sk, skb); 6623b885787SNeil Horman sock_recv_drops(msg, sk, skb); 6633b885787SNeil Horman } 664767dd033SEric Dumazet EXPORT_SYMBOL_GPL(__sock_recv_ts_and_drops); 6653b885787SNeil Horman 666a2e27255SArnaldo Carvalho de Melo static inline int __sock_recvmsg_nosec(struct kiocb *iocb, struct socket *sock, 6671da177e4SLinus Torvalds struct msghdr *msg, size_t size, int flags) 6681da177e4SLinus Torvalds { 6691da177e4SLinus Torvalds struct sock_iocb *si = kiocb_to_siocb(iocb); 6701da177e4SLinus Torvalds 6711da177e4SLinus Torvalds si->sock = sock; 6721da177e4SLinus Torvalds si->scm = NULL; 6731da177e4SLinus Torvalds si->msg = msg; 6741da177e4SLinus Torvalds si->size = size; 6751da177e4SLinus Torvalds si->flags = flags; 6761da177e4SLinus Torvalds 6771da177e4SLinus Torvalds return sock->ops->recvmsg(iocb, sock, msg, size, flags); 6781da177e4SLinus Torvalds } 6791da177e4SLinus Torvalds 680a2e27255SArnaldo Carvalho de Melo static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock, 681a2e27255SArnaldo Carvalho de Melo struct msghdr *msg, size_t size, int flags) 682a2e27255SArnaldo Carvalho de Melo { 683a2e27255SArnaldo Carvalho de Melo int err = security_socket_recvmsg(sock, msg, size, flags); 684a2e27255SArnaldo Carvalho de Melo 685a2e27255SArnaldo Carvalho de Melo return err ?: __sock_recvmsg_nosec(iocb, sock, msg, size, flags); 686a2e27255SArnaldo Carvalho de Melo } 687a2e27255SArnaldo Carvalho de Melo 6881da177e4SLinus Torvalds int sock_recvmsg(struct socket *sock, struct msghdr *msg, 6891da177e4SLinus Torvalds size_t size, int flags) 6901da177e4SLinus Torvalds { 6911da177e4SLinus Torvalds struct kiocb iocb; 6921da177e4SLinus Torvalds struct sock_iocb siocb; 6931da177e4SLinus Torvalds int ret; 6941da177e4SLinus Torvalds 6951da177e4SLinus Torvalds init_sync_kiocb(&iocb, NULL); 6961da177e4SLinus Torvalds iocb.private = &siocb; 6971da177e4SLinus Torvalds ret = __sock_recvmsg(&iocb, sock, msg, size, flags); 6981da177e4SLinus Torvalds if (-EIOCBQUEUED == ret) 6991da177e4SLinus Torvalds ret = wait_on_sync_kiocb(&iocb); 7001da177e4SLinus Torvalds return ret; 7011da177e4SLinus Torvalds } 7021da177e4SLinus Torvalds 703a2e27255SArnaldo Carvalho de Melo static int sock_recvmsg_nosec(struct socket *sock, struct msghdr *msg, 704a2e27255SArnaldo Carvalho de Melo size_t size, int flags) 705a2e27255SArnaldo Carvalho de Melo { 706a2e27255SArnaldo Carvalho de Melo struct kiocb iocb; 707a2e27255SArnaldo Carvalho de Melo struct sock_iocb siocb; 708a2e27255SArnaldo Carvalho de Melo int ret; 709a2e27255SArnaldo Carvalho de Melo 710a2e27255SArnaldo Carvalho de Melo init_sync_kiocb(&iocb, NULL); 711a2e27255SArnaldo Carvalho de Melo iocb.private = &siocb; 712a2e27255SArnaldo Carvalho de Melo ret = __sock_recvmsg_nosec(&iocb, sock, msg, size, flags); 713a2e27255SArnaldo Carvalho de Melo if (-EIOCBQUEUED == ret) 714a2e27255SArnaldo Carvalho de Melo ret = wait_on_sync_kiocb(&iocb); 715a2e27255SArnaldo Carvalho de Melo return ret; 716a2e27255SArnaldo Carvalho de Melo } 717a2e27255SArnaldo Carvalho de Melo 7181da177e4SLinus Torvalds int kernel_recvmsg(struct socket *sock, struct msghdr *msg, 71989bddce5SStephen Hemminger struct kvec *vec, size_t num, size_t size, int flags) 7201da177e4SLinus Torvalds { 7211da177e4SLinus Torvalds mm_segment_t oldfs = get_fs(); 7221da177e4SLinus Torvalds int result; 7231da177e4SLinus Torvalds 7241da177e4SLinus Torvalds set_fs(KERNEL_DS); 7251da177e4SLinus Torvalds /* 7261da177e4SLinus Torvalds * the following is safe, since for compiler definitions of kvec and 7271da177e4SLinus Torvalds * iovec are identical, yielding the same in-core layout and alignment 7281da177e4SLinus Torvalds */ 72989bddce5SStephen Hemminger msg->msg_iov = (struct iovec *)vec, msg->msg_iovlen = num; 7301da177e4SLinus Torvalds result = sock_recvmsg(sock, msg, size, flags); 7311da177e4SLinus Torvalds set_fs(oldfs); 7321da177e4SLinus Torvalds return result; 7331da177e4SLinus Torvalds } 7341da177e4SLinus Torvalds 7351da177e4SLinus Torvalds static void sock_aio_dtor(struct kiocb *iocb) 7361da177e4SLinus Torvalds { 7371da177e4SLinus Torvalds kfree(iocb->private); 7381da177e4SLinus Torvalds } 7391da177e4SLinus Torvalds 74020380731SArnaldo Carvalho de Melo static ssize_t sock_sendpage(struct file *file, struct page *page, 7411da177e4SLinus Torvalds int offset, size_t size, loff_t *ppos, int more) 7421da177e4SLinus Torvalds { 7431da177e4SLinus Torvalds struct socket *sock; 7441da177e4SLinus Torvalds int flags; 7451da177e4SLinus Torvalds 746b69aee04SEric Dumazet sock = file->private_data; 7471da177e4SLinus Torvalds 7481da177e4SLinus Torvalds flags = !(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT; 7491da177e4SLinus Torvalds if (more) 7501da177e4SLinus Torvalds flags |= MSG_MORE; 7511da177e4SLinus Torvalds 752e6949583SLinus Torvalds return kernel_sendpage(sock, page, offset, size, flags); 7531da177e4SLinus Torvalds } 7541da177e4SLinus Torvalds 7559c55e01cSJens Axboe static ssize_t sock_splice_read(struct file *file, loff_t *ppos, 7569c55e01cSJens Axboe struct pipe_inode_info *pipe, size_t len, 7579c55e01cSJens Axboe unsigned int flags) 7589c55e01cSJens Axboe { 7599c55e01cSJens Axboe struct socket *sock = file->private_data; 7609c55e01cSJens Axboe 761997b37daSRémi Denis-Courmont if (unlikely(!sock->ops->splice_read)) 762997b37daSRémi Denis-Courmont return -EINVAL; 763997b37daSRémi Denis-Courmont 7649c55e01cSJens Axboe return sock->ops->splice_read(sock, ppos, pipe, len, flags); 7659c55e01cSJens Axboe } 7669c55e01cSJens Axboe 767ce1d4d3eSChristoph Hellwig static struct sock_iocb *alloc_sock_iocb(struct kiocb *iocb, 76889bddce5SStephen Hemminger struct sock_iocb *siocb) 769ce1d4d3eSChristoph Hellwig { 770ce1d4d3eSChristoph Hellwig if (!is_sync_kiocb(iocb)) { 771ce1d4d3eSChristoph Hellwig siocb = kmalloc(sizeof(*siocb), GFP_KERNEL); 772ce1d4d3eSChristoph Hellwig if (!siocb) 773ce1d4d3eSChristoph Hellwig return NULL; 774ce1d4d3eSChristoph Hellwig iocb->ki_dtor = sock_aio_dtor; 775ce1d4d3eSChristoph Hellwig } 776ce1d4d3eSChristoph Hellwig 777ce1d4d3eSChristoph Hellwig siocb->kiocb = iocb; 778ce1d4d3eSChristoph Hellwig iocb->private = siocb; 779ce1d4d3eSChristoph Hellwig return siocb; 780ce1d4d3eSChristoph Hellwig } 781ce1d4d3eSChristoph Hellwig 782ce1d4d3eSChristoph Hellwig static ssize_t do_sock_read(struct msghdr *msg, struct kiocb *iocb, 783027445c3SBadari Pulavarty struct file *file, const struct iovec *iov, 78489bddce5SStephen Hemminger unsigned long nr_segs) 785ce1d4d3eSChristoph Hellwig { 786ce1d4d3eSChristoph Hellwig struct socket *sock = file->private_data; 787ce1d4d3eSChristoph Hellwig size_t size = 0; 788ce1d4d3eSChristoph Hellwig int i; 789ce1d4d3eSChristoph Hellwig 790ce1d4d3eSChristoph Hellwig for (i = 0; i < nr_segs; i++) 791ce1d4d3eSChristoph Hellwig size += iov[i].iov_len; 792ce1d4d3eSChristoph Hellwig 793ce1d4d3eSChristoph Hellwig msg->msg_name = NULL; 794ce1d4d3eSChristoph Hellwig msg->msg_namelen = 0; 795ce1d4d3eSChristoph Hellwig msg->msg_control = NULL; 796ce1d4d3eSChristoph Hellwig msg->msg_controllen = 0; 797ce1d4d3eSChristoph Hellwig msg->msg_iov = (struct iovec *)iov; 798ce1d4d3eSChristoph Hellwig msg->msg_iovlen = nr_segs; 799ce1d4d3eSChristoph Hellwig msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0; 800ce1d4d3eSChristoph Hellwig 801ce1d4d3eSChristoph Hellwig return __sock_recvmsg(iocb, sock, msg, size, msg->msg_flags); 802ce1d4d3eSChristoph Hellwig } 803ce1d4d3eSChristoph Hellwig 804027445c3SBadari Pulavarty static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov, 805027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos) 806ce1d4d3eSChristoph Hellwig { 807ce1d4d3eSChristoph Hellwig struct sock_iocb siocb, *x; 808ce1d4d3eSChristoph Hellwig 809ce1d4d3eSChristoph Hellwig if (pos != 0) 810ce1d4d3eSChristoph Hellwig return -ESPIPE; 811027445c3SBadari Pulavarty 812027445c3SBadari Pulavarty if (iocb->ki_left == 0) /* Match SYS5 behaviour */ 813ce1d4d3eSChristoph Hellwig return 0; 814ce1d4d3eSChristoph Hellwig 815027445c3SBadari Pulavarty 816027445c3SBadari Pulavarty x = alloc_sock_iocb(iocb, &siocb); 817ce1d4d3eSChristoph Hellwig if (!x) 818ce1d4d3eSChristoph Hellwig return -ENOMEM; 819027445c3SBadari Pulavarty return do_sock_read(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs); 820ce1d4d3eSChristoph Hellwig } 821ce1d4d3eSChristoph Hellwig 822ce1d4d3eSChristoph Hellwig static ssize_t do_sock_write(struct msghdr *msg, struct kiocb *iocb, 823027445c3SBadari Pulavarty struct file *file, const struct iovec *iov, 82489bddce5SStephen Hemminger unsigned long nr_segs) 825ce1d4d3eSChristoph Hellwig { 826ce1d4d3eSChristoph Hellwig struct socket *sock = file->private_data; 827ce1d4d3eSChristoph Hellwig size_t size = 0; 828ce1d4d3eSChristoph Hellwig int i; 829ce1d4d3eSChristoph Hellwig 830ce1d4d3eSChristoph Hellwig for (i = 0; i < nr_segs; i++) 831ce1d4d3eSChristoph Hellwig size += iov[i].iov_len; 832ce1d4d3eSChristoph Hellwig 833ce1d4d3eSChristoph Hellwig msg->msg_name = NULL; 834ce1d4d3eSChristoph Hellwig msg->msg_namelen = 0; 835ce1d4d3eSChristoph Hellwig msg->msg_control = NULL; 836ce1d4d3eSChristoph Hellwig msg->msg_controllen = 0; 837ce1d4d3eSChristoph Hellwig msg->msg_iov = (struct iovec *)iov; 838ce1d4d3eSChristoph Hellwig msg->msg_iovlen = nr_segs; 839ce1d4d3eSChristoph Hellwig msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0; 840ce1d4d3eSChristoph Hellwig if (sock->type == SOCK_SEQPACKET) 841ce1d4d3eSChristoph Hellwig msg->msg_flags |= MSG_EOR; 842ce1d4d3eSChristoph Hellwig 843ce1d4d3eSChristoph Hellwig return __sock_sendmsg(iocb, sock, msg, size); 844ce1d4d3eSChristoph Hellwig } 845ce1d4d3eSChristoph Hellwig 846027445c3SBadari Pulavarty static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov, 847027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos) 8481da177e4SLinus Torvalds { 849ce1d4d3eSChristoph Hellwig struct sock_iocb siocb, *x; 8501da177e4SLinus Torvalds 851ce1d4d3eSChristoph Hellwig if (pos != 0) 852ce1d4d3eSChristoph Hellwig return -ESPIPE; 853027445c3SBadari Pulavarty 854027445c3SBadari Pulavarty x = alloc_sock_iocb(iocb, &siocb); 855ce1d4d3eSChristoph Hellwig if (!x) 856ce1d4d3eSChristoph Hellwig return -ENOMEM; 857ce1d4d3eSChristoph Hellwig 858027445c3SBadari Pulavarty return do_sock_write(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs); 8591da177e4SLinus Torvalds } 8601da177e4SLinus Torvalds 8611da177e4SLinus Torvalds /* 8621da177e4SLinus Torvalds * Atomic setting of ioctl hooks to avoid race 8631da177e4SLinus Torvalds * with module unload. 8641da177e4SLinus Torvalds */ 8651da177e4SLinus Torvalds 8664a3e2f71SArjan van de Ven static DEFINE_MUTEX(br_ioctl_mutex); 867881d966bSEric W. Biederman static int (*br_ioctl_hook) (struct net *, unsigned int cmd, void __user *arg) = NULL; 8681da177e4SLinus Torvalds 869881d966bSEric W. Biederman void brioctl_set(int (*hook) (struct net *, unsigned int, void __user *)) 8701da177e4SLinus Torvalds { 8714a3e2f71SArjan van de Ven mutex_lock(&br_ioctl_mutex); 8721da177e4SLinus Torvalds br_ioctl_hook = hook; 8734a3e2f71SArjan van de Ven mutex_unlock(&br_ioctl_mutex); 8741da177e4SLinus Torvalds } 87589bddce5SStephen Hemminger 8761da177e4SLinus Torvalds EXPORT_SYMBOL(brioctl_set); 8771da177e4SLinus Torvalds 8784a3e2f71SArjan van de Ven static DEFINE_MUTEX(vlan_ioctl_mutex); 879881d966bSEric W. Biederman static int (*vlan_ioctl_hook) (struct net *, void __user *arg); 8801da177e4SLinus Torvalds 881881d966bSEric W. Biederman void vlan_ioctl_set(int (*hook) (struct net *, void __user *)) 8821da177e4SLinus Torvalds { 8834a3e2f71SArjan van de Ven mutex_lock(&vlan_ioctl_mutex); 8841da177e4SLinus Torvalds vlan_ioctl_hook = hook; 8854a3e2f71SArjan van de Ven mutex_unlock(&vlan_ioctl_mutex); 8861da177e4SLinus Torvalds } 88789bddce5SStephen Hemminger 8881da177e4SLinus Torvalds EXPORT_SYMBOL(vlan_ioctl_set); 8891da177e4SLinus Torvalds 8904a3e2f71SArjan van de Ven static DEFINE_MUTEX(dlci_ioctl_mutex); 8911da177e4SLinus Torvalds static int (*dlci_ioctl_hook) (unsigned int, void __user *); 8921da177e4SLinus Torvalds 8931da177e4SLinus Torvalds void dlci_ioctl_set(int (*hook) (unsigned int, void __user *)) 8941da177e4SLinus Torvalds { 8954a3e2f71SArjan van de Ven mutex_lock(&dlci_ioctl_mutex); 8961da177e4SLinus Torvalds dlci_ioctl_hook = hook; 8974a3e2f71SArjan van de Ven mutex_unlock(&dlci_ioctl_mutex); 8981da177e4SLinus Torvalds } 89989bddce5SStephen Hemminger 9001da177e4SLinus Torvalds EXPORT_SYMBOL(dlci_ioctl_set); 9011da177e4SLinus Torvalds 9026b96018bSArnd Bergmann static long sock_do_ioctl(struct net *net, struct socket *sock, 9036b96018bSArnd Bergmann unsigned int cmd, unsigned long arg) 9046b96018bSArnd Bergmann { 9056b96018bSArnd Bergmann int err; 9066b96018bSArnd Bergmann void __user *argp = (void __user *)arg; 9076b96018bSArnd Bergmann 9086b96018bSArnd Bergmann err = sock->ops->ioctl(sock, cmd, arg); 9096b96018bSArnd Bergmann 9106b96018bSArnd Bergmann /* 9116b96018bSArnd Bergmann * If this ioctl is unknown try to hand it down 9126b96018bSArnd Bergmann * to the NIC driver. 9136b96018bSArnd Bergmann */ 9146b96018bSArnd Bergmann if (err == -ENOIOCTLCMD) 9156b96018bSArnd Bergmann err = dev_ioctl(net, cmd, argp); 9166b96018bSArnd Bergmann 9176b96018bSArnd Bergmann return err; 9186b96018bSArnd Bergmann } 9196b96018bSArnd Bergmann 9201da177e4SLinus Torvalds /* 9211da177e4SLinus Torvalds * With an ioctl, arg may well be a user mode pointer, but we don't know 9221da177e4SLinus Torvalds * what to do with it - that's up to the protocol still. 9231da177e4SLinus Torvalds */ 9241da177e4SLinus Torvalds 9251da177e4SLinus Torvalds static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg) 9261da177e4SLinus Torvalds { 9271da177e4SLinus Torvalds struct socket *sock; 928881d966bSEric W. Biederman struct sock *sk; 9291da177e4SLinus Torvalds void __user *argp = (void __user *)arg; 9301da177e4SLinus Torvalds int pid, err; 931881d966bSEric W. Biederman struct net *net; 9321da177e4SLinus Torvalds 933b69aee04SEric Dumazet sock = file->private_data; 934881d966bSEric W. Biederman sk = sock->sk; 9353b1e0a65SYOSHIFUJI Hideaki net = sock_net(sk); 9361da177e4SLinus Torvalds if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) { 937881d966bSEric W. Biederman err = dev_ioctl(net, cmd, argp); 9381da177e4SLinus Torvalds } else 9393d23e349SJohannes Berg #ifdef CONFIG_WEXT_CORE 9401da177e4SLinus Torvalds if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) { 941881d966bSEric W. Biederman err = dev_ioctl(net, cmd, argp); 9421da177e4SLinus Torvalds } else 9433d23e349SJohannes Berg #endif 9441da177e4SLinus Torvalds switch (cmd) { 9451da177e4SLinus Torvalds case FIOSETOWN: 9461da177e4SLinus Torvalds case SIOCSPGRP: 9471da177e4SLinus Torvalds err = -EFAULT; 9481da177e4SLinus Torvalds if (get_user(pid, (int __user *)argp)) 9491da177e4SLinus Torvalds break; 9501da177e4SLinus Torvalds err = f_setown(sock->file, pid, 1); 9511da177e4SLinus Torvalds break; 9521da177e4SLinus Torvalds case FIOGETOWN: 9531da177e4SLinus Torvalds case SIOCGPGRP: 954609d7fa9SEric W. Biederman err = put_user(f_getown(sock->file), 95589bddce5SStephen Hemminger (int __user *)argp); 9561da177e4SLinus Torvalds break; 9571da177e4SLinus Torvalds case SIOCGIFBR: 9581da177e4SLinus Torvalds case SIOCSIFBR: 9591da177e4SLinus Torvalds case SIOCBRADDBR: 9601da177e4SLinus Torvalds case SIOCBRDELBR: 9611da177e4SLinus Torvalds err = -ENOPKG; 9621da177e4SLinus Torvalds if (!br_ioctl_hook) 9631da177e4SLinus Torvalds request_module("bridge"); 9641da177e4SLinus Torvalds 9654a3e2f71SArjan van de Ven mutex_lock(&br_ioctl_mutex); 9661da177e4SLinus Torvalds if (br_ioctl_hook) 967881d966bSEric W. Biederman err = br_ioctl_hook(net, cmd, argp); 9684a3e2f71SArjan van de Ven mutex_unlock(&br_ioctl_mutex); 9691da177e4SLinus Torvalds break; 9701da177e4SLinus Torvalds case SIOCGIFVLAN: 9711da177e4SLinus Torvalds case SIOCSIFVLAN: 9721da177e4SLinus Torvalds err = -ENOPKG; 9731da177e4SLinus Torvalds if (!vlan_ioctl_hook) 9741da177e4SLinus Torvalds request_module("8021q"); 9751da177e4SLinus Torvalds 9764a3e2f71SArjan van de Ven mutex_lock(&vlan_ioctl_mutex); 9771da177e4SLinus Torvalds if (vlan_ioctl_hook) 978881d966bSEric W. Biederman err = vlan_ioctl_hook(net, argp); 9794a3e2f71SArjan van de Ven mutex_unlock(&vlan_ioctl_mutex); 9801da177e4SLinus Torvalds break; 9811da177e4SLinus Torvalds case SIOCADDDLCI: 9821da177e4SLinus Torvalds case SIOCDELDLCI: 9831da177e4SLinus Torvalds err = -ENOPKG; 9841da177e4SLinus Torvalds if (!dlci_ioctl_hook) 9851da177e4SLinus Torvalds request_module("dlci"); 9861da177e4SLinus Torvalds 9874a3e2f71SArjan van de Ven mutex_lock(&dlci_ioctl_mutex); 9887512cbf6SPavel Emelyanov if (dlci_ioctl_hook) 9891da177e4SLinus Torvalds err = dlci_ioctl_hook(cmd, argp); 9904a3e2f71SArjan van de Ven mutex_unlock(&dlci_ioctl_mutex); 9911da177e4SLinus Torvalds break; 9921da177e4SLinus Torvalds default: 9936b96018bSArnd Bergmann err = sock_do_ioctl(net, sock, cmd, arg); 9941da177e4SLinus Torvalds break; 9951da177e4SLinus Torvalds } 9961da177e4SLinus Torvalds return err; 9971da177e4SLinus Torvalds } 9981da177e4SLinus Torvalds 9991da177e4SLinus Torvalds int sock_create_lite(int family, int type, int protocol, struct socket **res) 10001da177e4SLinus Torvalds { 10011da177e4SLinus Torvalds int err; 10021da177e4SLinus Torvalds struct socket *sock = NULL; 10031da177e4SLinus Torvalds 10041da177e4SLinus Torvalds err = security_socket_create(family, type, protocol, 1); 10051da177e4SLinus Torvalds if (err) 10061da177e4SLinus Torvalds goto out; 10071da177e4SLinus Torvalds 10081da177e4SLinus Torvalds sock = sock_alloc(); 10091da177e4SLinus Torvalds if (!sock) { 10101da177e4SLinus Torvalds err = -ENOMEM; 10111da177e4SLinus Torvalds goto out; 10121da177e4SLinus Torvalds } 10131da177e4SLinus Torvalds 10141da177e4SLinus Torvalds sock->type = type; 10157420ed23SVenkat Yekkirala err = security_socket_post_create(sock, family, type, protocol, 1); 10167420ed23SVenkat Yekkirala if (err) 10177420ed23SVenkat Yekkirala goto out_release; 10187420ed23SVenkat Yekkirala 10191da177e4SLinus Torvalds out: 10201da177e4SLinus Torvalds *res = sock; 10211da177e4SLinus Torvalds return err; 10227420ed23SVenkat Yekkirala out_release: 10237420ed23SVenkat Yekkirala sock_release(sock); 10247420ed23SVenkat Yekkirala sock = NULL; 10257420ed23SVenkat Yekkirala goto out; 10261da177e4SLinus Torvalds } 10271da177e4SLinus Torvalds 10281da177e4SLinus Torvalds /* No kernel lock held - perfect */ 10291da177e4SLinus Torvalds static unsigned int sock_poll(struct file *file, poll_table *wait) 10301da177e4SLinus Torvalds { 10311da177e4SLinus Torvalds struct socket *sock; 10321da177e4SLinus Torvalds 10331da177e4SLinus Torvalds /* 10341da177e4SLinus Torvalds * We can't return errors to poll, so it's either yes or no. 10351da177e4SLinus Torvalds */ 1036b69aee04SEric Dumazet sock = file->private_data; 10371da177e4SLinus Torvalds return sock->ops->poll(file, sock, wait); 10381da177e4SLinus Torvalds } 10391da177e4SLinus Torvalds 10401da177e4SLinus Torvalds static int sock_mmap(struct file *file, struct vm_area_struct *vma) 10411da177e4SLinus Torvalds { 1042b69aee04SEric Dumazet struct socket *sock = file->private_data; 10431da177e4SLinus Torvalds 10441da177e4SLinus Torvalds return sock->ops->mmap(file, sock, vma); 10451da177e4SLinus Torvalds } 10461da177e4SLinus Torvalds 104720380731SArnaldo Carvalho de Melo static int sock_close(struct inode *inode, struct file *filp) 10481da177e4SLinus Torvalds { 10491da177e4SLinus Torvalds /* 10501da177e4SLinus Torvalds * It was possible the inode is NULL we were 10511da177e4SLinus Torvalds * closing an unfinished socket. 10521da177e4SLinus Torvalds */ 10531da177e4SLinus Torvalds 105489bddce5SStephen Hemminger if (!inode) { 10551da177e4SLinus Torvalds printk(KERN_DEBUG "sock_close: NULL inode\n"); 10561da177e4SLinus Torvalds return 0; 10571da177e4SLinus Torvalds } 10581da177e4SLinus Torvalds sock_release(SOCKET_I(inode)); 10591da177e4SLinus Torvalds return 0; 10601da177e4SLinus Torvalds } 10611da177e4SLinus Torvalds 10621da177e4SLinus Torvalds /* 10631da177e4SLinus Torvalds * Update the socket async list 10641da177e4SLinus Torvalds * 10651da177e4SLinus Torvalds * Fasync_list locking strategy. 10661da177e4SLinus Torvalds * 10671da177e4SLinus Torvalds * 1. fasync_list is modified only under process context socket lock 10681da177e4SLinus Torvalds * i.e. under semaphore. 10691da177e4SLinus Torvalds * 2. fasync_list is used under read_lock(&sk->sk_callback_lock) 1070989a2979SEric Dumazet * or under socket lock 10711da177e4SLinus Torvalds */ 10721da177e4SLinus Torvalds 10731da177e4SLinus Torvalds static int sock_fasync(int fd, struct file *filp, int on) 10741da177e4SLinus Torvalds { 1075989a2979SEric Dumazet struct socket *sock = filp->private_data; 1076989a2979SEric Dumazet struct sock *sk = sock->sk; 10771da177e4SLinus Torvalds 1078989a2979SEric Dumazet if (sk == NULL) 10791da177e4SLinus Torvalds return -EINVAL; 10801da177e4SLinus Torvalds 10811da177e4SLinus Torvalds lock_sock(sk); 10821da177e4SLinus Torvalds 1083989a2979SEric Dumazet fasync_helper(fd, filp, on, &sock->fasync_list); 108476398425SJonathan Corbet 1085bcdce719SEric Dumazet if (!sock->fasync_list) 1086bcdce719SEric Dumazet sock_reset_flag(sk, SOCK_FASYNC); 1087989a2979SEric Dumazet else 1088989a2979SEric Dumazet sock_set_flag(sk, SOCK_FASYNC); 10891da177e4SLinus Torvalds 1090989a2979SEric Dumazet release_sock(sk); 10911da177e4SLinus Torvalds return 0; 10921da177e4SLinus Torvalds } 10931da177e4SLinus Torvalds 10941da177e4SLinus Torvalds /* This function may be called only under socket lock or callback_lock */ 10951da177e4SLinus Torvalds 10961da177e4SLinus Torvalds int sock_wake_async(struct socket *sock, int how, int band) 10971da177e4SLinus Torvalds { 10981da177e4SLinus Torvalds if (!sock || !sock->fasync_list) 10991da177e4SLinus Torvalds return -1; 110089bddce5SStephen Hemminger switch (how) { 11018d8ad9d7SPavel Emelyanov case SOCK_WAKE_WAITD: 11021da177e4SLinus Torvalds if (test_bit(SOCK_ASYNC_WAITDATA, &sock->flags)) 11031da177e4SLinus Torvalds break; 11041da177e4SLinus Torvalds goto call_kill; 11058d8ad9d7SPavel Emelyanov case SOCK_WAKE_SPACE: 11061da177e4SLinus Torvalds if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags)) 11071da177e4SLinus Torvalds break; 11081da177e4SLinus Torvalds /* fall through */ 11098d8ad9d7SPavel Emelyanov case SOCK_WAKE_IO: 11101da177e4SLinus Torvalds call_kill: 1111989a2979SEric Dumazet kill_fasync(&sock->fasync_list, SIGIO, band); 11121da177e4SLinus Torvalds break; 11138d8ad9d7SPavel Emelyanov case SOCK_WAKE_URG: 1114989a2979SEric Dumazet kill_fasync(&sock->fasync_list, SIGURG, band); 11151da177e4SLinus Torvalds } 11161da177e4SLinus Torvalds return 0; 11171da177e4SLinus Torvalds } 11181da177e4SLinus Torvalds 11191b8d7ae4SEric W. Biederman static int __sock_create(struct net *net, int family, int type, int protocol, 112089bddce5SStephen Hemminger struct socket **res, int kern) 11211da177e4SLinus Torvalds { 11221da177e4SLinus Torvalds int err; 11231da177e4SLinus Torvalds struct socket *sock; 112455737fdaSStephen Hemminger const struct net_proto_family *pf; 11251da177e4SLinus Torvalds 11261da177e4SLinus Torvalds /* 11271da177e4SLinus Torvalds * Check protocol is in range 11281da177e4SLinus Torvalds */ 11291da177e4SLinus Torvalds if (family < 0 || family >= NPROTO) 11301da177e4SLinus Torvalds return -EAFNOSUPPORT; 11311da177e4SLinus Torvalds if (type < 0 || type >= SOCK_MAX) 11321da177e4SLinus Torvalds return -EINVAL; 11331da177e4SLinus Torvalds 11341da177e4SLinus Torvalds /* Compatibility. 11351da177e4SLinus Torvalds 11361da177e4SLinus Torvalds This uglymoron is moved from INET layer to here to avoid 11371da177e4SLinus Torvalds deadlock in module load. 11381da177e4SLinus Torvalds */ 11391da177e4SLinus Torvalds if (family == PF_INET && type == SOCK_PACKET) { 11401da177e4SLinus Torvalds static int warned; 11411da177e4SLinus Torvalds if (!warned) { 11421da177e4SLinus Torvalds warned = 1; 114389bddce5SStephen Hemminger printk(KERN_INFO "%s uses obsolete (PF_INET,SOCK_PACKET)\n", 114489bddce5SStephen Hemminger current->comm); 11451da177e4SLinus Torvalds } 11461da177e4SLinus Torvalds family = PF_PACKET; 11471da177e4SLinus Torvalds } 11481da177e4SLinus Torvalds 11491da177e4SLinus Torvalds err = security_socket_create(family, type, protocol, kern); 11501da177e4SLinus Torvalds if (err) 11511da177e4SLinus Torvalds return err; 11521da177e4SLinus Torvalds 115355737fdaSStephen Hemminger /* 115455737fdaSStephen Hemminger * Allocate the socket and allow the family to set things up. if 115555737fdaSStephen Hemminger * the protocol is 0, the family is instructed to select an appropriate 115655737fdaSStephen Hemminger * default. 115755737fdaSStephen Hemminger */ 115855737fdaSStephen Hemminger sock = sock_alloc(); 115955737fdaSStephen Hemminger if (!sock) { 116055737fdaSStephen Hemminger if (net_ratelimit()) 116155737fdaSStephen Hemminger printk(KERN_WARNING "socket: no more sockets\n"); 116255737fdaSStephen Hemminger return -ENFILE; /* Not exactly a match, but its the 116355737fdaSStephen Hemminger closest posix thing */ 116455737fdaSStephen Hemminger } 116555737fdaSStephen Hemminger 116655737fdaSStephen Hemminger sock->type = type; 116755737fdaSStephen Hemminger 116895a5afcaSJohannes Berg #ifdef CONFIG_MODULES 11691da177e4SLinus Torvalds /* Attempt to load a protocol module if the find failed. 11701da177e4SLinus Torvalds * 11711da177e4SLinus Torvalds * 12/09/1996 Marcin: But! this makes REALLY only sense, if the user 11721da177e4SLinus Torvalds * requested real, full-featured networking support upon configuration. 11731da177e4SLinus Torvalds * Otherwise module support will break! 11741da177e4SLinus Torvalds */ 117555737fdaSStephen Hemminger if (net_families[family] == NULL) 11761da177e4SLinus Torvalds request_module("net-pf-%d", family); 11771da177e4SLinus Torvalds #endif 11781da177e4SLinus Torvalds 117955737fdaSStephen Hemminger rcu_read_lock(); 118055737fdaSStephen Hemminger pf = rcu_dereference(net_families[family]); 11811da177e4SLinus Torvalds err = -EAFNOSUPPORT; 118255737fdaSStephen Hemminger if (!pf) 118355737fdaSStephen Hemminger goto out_release; 11841da177e4SLinus Torvalds 11851da177e4SLinus Torvalds /* 11861da177e4SLinus Torvalds * We will call the ->create function, that possibly is in a loadable 11871da177e4SLinus Torvalds * module, so we have to bump that loadable module refcnt first. 11881da177e4SLinus Torvalds */ 118955737fdaSStephen Hemminger if (!try_module_get(pf->owner)) 11901da177e4SLinus Torvalds goto out_release; 11911da177e4SLinus Torvalds 119255737fdaSStephen Hemminger /* Now protected by module ref count */ 119355737fdaSStephen Hemminger rcu_read_unlock(); 119455737fdaSStephen Hemminger 11953f378b68SEric Paris err = pf->create(net, sock, protocol, kern); 119655737fdaSStephen Hemminger if (err < 0) 11971da177e4SLinus Torvalds goto out_module_put; 1198a79af59eSFrank Filz 11991da177e4SLinus Torvalds /* 12001da177e4SLinus Torvalds * Now to bump the refcnt of the [loadable] module that owns this 12011da177e4SLinus Torvalds * socket at sock_release time we decrement its refcnt. 12021da177e4SLinus Torvalds */ 120355737fdaSStephen Hemminger if (!try_module_get(sock->ops->owner)) 120455737fdaSStephen Hemminger goto out_module_busy; 120555737fdaSStephen Hemminger 12061da177e4SLinus Torvalds /* 12071da177e4SLinus Torvalds * Now that we're done with the ->create function, the [loadable] 12081da177e4SLinus Torvalds * module can have its refcnt decremented 12091da177e4SLinus Torvalds */ 121055737fdaSStephen Hemminger module_put(pf->owner); 12117420ed23SVenkat Yekkirala err = security_socket_post_create(sock, family, type, protocol, kern); 12127420ed23SVenkat Yekkirala if (err) 12133b185525SHerbert Xu goto out_sock_release; 121455737fdaSStephen Hemminger *res = sock; 12151da177e4SLinus Torvalds 121655737fdaSStephen Hemminger return 0; 121755737fdaSStephen Hemminger 121855737fdaSStephen Hemminger out_module_busy: 121955737fdaSStephen Hemminger err = -EAFNOSUPPORT; 12201da177e4SLinus Torvalds out_module_put: 122155737fdaSStephen Hemminger sock->ops = NULL; 122255737fdaSStephen Hemminger module_put(pf->owner); 122355737fdaSStephen Hemminger out_sock_release: 12241da177e4SLinus Torvalds sock_release(sock); 122555737fdaSStephen Hemminger return err; 122655737fdaSStephen Hemminger 122755737fdaSStephen Hemminger out_release: 122855737fdaSStephen Hemminger rcu_read_unlock(); 122955737fdaSStephen Hemminger goto out_sock_release; 12301da177e4SLinus Torvalds } 12311da177e4SLinus Torvalds 12321da177e4SLinus Torvalds int sock_create(int family, int type, int protocol, struct socket **res) 12331da177e4SLinus Torvalds { 12341b8d7ae4SEric W. Biederman return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0); 12351da177e4SLinus Torvalds } 12361da177e4SLinus Torvalds 12371da177e4SLinus Torvalds int sock_create_kern(int family, int type, int protocol, struct socket **res) 12381da177e4SLinus Torvalds { 12391b8d7ae4SEric W. Biederman return __sock_create(&init_net, family, type, protocol, res, 1); 12401da177e4SLinus Torvalds } 12411da177e4SLinus Torvalds 12423e0fa65fSHeiko Carstens SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol) 12431da177e4SLinus Torvalds { 12441da177e4SLinus Torvalds int retval; 12451da177e4SLinus Torvalds struct socket *sock; 1246a677a039SUlrich Drepper int flags; 1247a677a039SUlrich Drepper 1248e38b36f3SUlrich Drepper /* Check the SOCK_* constants for consistency. */ 1249e38b36f3SUlrich Drepper BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC); 1250e38b36f3SUlrich Drepper BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK); 1251e38b36f3SUlrich Drepper BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK); 1252e38b36f3SUlrich Drepper BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK); 1253e38b36f3SUlrich Drepper 1254a677a039SUlrich Drepper flags = type & ~SOCK_TYPE_MASK; 125577d27200SUlrich Drepper if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)) 1256a677a039SUlrich Drepper return -EINVAL; 1257a677a039SUlrich Drepper type &= SOCK_TYPE_MASK; 12581da177e4SLinus Torvalds 1259aaca0bdcSUlrich Drepper if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK)) 1260aaca0bdcSUlrich Drepper flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK; 1261aaca0bdcSUlrich Drepper 12621da177e4SLinus Torvalds retval = sock_create(family, type, protocol, &sock); 12631da177e4SLinus Torvalds if (retval < 0) 12641da177e4SLinus Torvalds goto out; 12651da177e4SLinus Torvalds 126677d27200SUlrich Drepper retval = sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK)); 12671da177e4SLinus Torvalds if (retval < 0) 12681da177e4SLinus Torvalds goto out_release; 12691da177e4SLinus Torvalds 12701da177e4SLinus Torvalds out: 12711da177e4SLinus Torvalds /* It may be already another descriptor 8) Not kernel problem. */ 12721da177e4SLinus Torvalds return retval; 12731da177e4SLinus Torvalds 12741da177e4SLinus Torvalds out_release: 12751da177e4SLinus Torvalds sock_release(sock); 12761da177e4SLinus Torvalds return retval; 12771da177e4SLinus Torvalds } 12781da177e4SLinus Torvalds 12791da177e4SLinus Torvalds /* 12801da177e4SLinus Torvalds * Create a pair of connected sockets. 12811da177e4SLinus Torvalds */ 12821da177e4SLinus Torvalds 12833e0fa65fSHeiko Carstens SYSCALL_DEFINE4(socketpair, int, family, int, type, int, protocol, 12843e0fa65fSHeiko Carstens int __user *, usockvec) 12851da177e4SLinus Torvalds { 12861da177e4SLinus Torvalds struct socket *sock1, *sock2; 12871da177e4SLinus Torvalds int fd1, fd2, err; 1288db349509SAl Viro struct file *newfile1, *newfile2; 1289a677a039SUlrich Drepper int flags; 1290a677a039SUlrich Drepper 1291a677a039SUlrich Drepper flags = type & ~SOCK_TYPE_MASK; 129277d27200SUlrich Drepper if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)) 1293a677a039SUlrich Drepper return -EINVAL; 1294a677a039SUlrich Drepper type &= SOCK_TYPE_MASK; 12951da177e4SLinus Torvalds 1296aaca0bdcSUlrich Drepper if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK)) 1297aaca0bdcSUlrich Drepper flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK; 1298aaca0bdcSUlrich Drepper 12991da177e4SLinus Torvalds /* 13001da177e4SLinus Torvalds * Obtain the first socket and check if the underlying protocol 13011da177e4SLinus Torvalds * supports the socketpair call. 13021da177e4SLinus Torvalds */ 13031da177e4SLinus Torvalds 13041da177e4SLinus Torvalds err = sock_create(family, type, protocol, &sock1); 13051da177e4SLinus Torvalds if (err < 0) 13061da177e4SLinus Torvalds goto out; 13071da177e4SLinus Torvalds 13081da177e4SLinus Torvalds err = sock_create(family, type, protocol, &sock2); 13091da177e4SLinus Torvalds if (err < 0) 13101da177e4SLinus Torvalds goto out_release_1; 13111da177e4SLinus Torvalds 13121da177e4SLinus Torvalds err = sock1->ops->socketpair(sock1, sock2); 13131da177e4SLinus Torvalds if (err < 0) 13141da177e4SLinus Torvalds goto out_release_both; 13151da177e4SLinus Torvalds 13167cbe66b6SAl Viro fd1 = sock_alloc_file(sock1, &newfile1, flags); 1317bf3c23d1SDavid S. Miller if (unlikely(fd1 < 0)) { 1318bf3c23d1SDavid S. Miller err = fd1; 13191da177e4SLinus Torvalds goto out_release_both; 1320bf3c23d1SDavid S. Miller } 13211da177e4SLinus Torvalds 13227cbe66b6SAl Viro fd2 = sock_alloc_file(sock2, &newfile2, flags); 1323198de4d7SAl Viro if (unlikely(fd2 < 0)) { 1324198de4d7SAl Viro err = fd2; 1325198de4d7SAl Viro fput(newfile1); 1326198de4d7SAl Viro put_unused_fd(fd1); 1327198de4d7SAl Viro sock_release(sock2); 1328198de4d7SAl Viro goto out; 1329db349509SAl Viro } 1330db349509SAl Viro 1331157cf649SAl Viro audit_fd_pair(fd1, fd2); 1332db349509SAl Viro fd_install(fd1, newfile1); 1333db349509SAl Viro fd_install(fd2, newfile2); 13341da177e4SLinus Torvalds /* fd1 and fd2 may be already another descriptors. 13351da177e4SLinus Torvalds * Not kernel problem. 13361da177e4SLinus Torvalds */ 13371da177e4SLinus Torvalds 13381da177e4SLinus Torvalds err = put_user(fd1, &usockvec[0]); 13391da177e4SLinus Torvalds if (!err) 13401da177e4SLinus Torvalds err = put_user(fd2, &usockvec[1]); 13411da177e4SLinus Torvalds if (!err) 13421da177e4SLinus Torvalds return 0; 13431da177e4SLinus Torvalds 13441da177e4SLinus Torvalds sys_close(fd2); 13451da177e4SLinus Torvalds sys_close(fd1); 13461da177e4SLinus Torvalds return err; 13471da177e4SLinus Torvalds 13481da177e4SLinus Torvalds out_release_both: 13491da177e4SLinus Torvalds sock_release(sock2); 13501da177e4SLinus Torvalds out_release_1: 13511da177e4SLinus Torvalds sock_release(sock1); 13521da177e4SLinus Torvalds out: 13531da177e4SLinus Torvalds return err; 13541da177e4SLinus Torvalds } 13551da177e4SLinus Torvalds 13561da177e4SLinus Torvalds /* 13571da177e4SLinus Torvalds * Bind a name to a socket. Nothing much to do here since it's 13581da177e4SLinus Torvalds * the protocol's responsibility to handle the local address. 13591da177e4SLinus Torvalds * 13601da177e4SLinus Torvalds * We move the socket address to kernel space before we call 13611da177e4SLinus Torvalds * the protocol layer (having also checked the address is ok). 13621da177e4SLinus Torvalds */ 13631da177e4SLinus Torvalds 136420f37034SHeiko Carstens SYSCALL_DEFINE3(bind, int, fd, struct sockaddr __user *, umyaddr, int, addrlen) 13651da177e4SLinus Torvalds { 13661da177e4SLinus Torvalds struct socket *sock; 1367230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 13686cb153caSBenjamin LaHaise int err, fput_needed; 13691da177e4SLinus Torvalds 137089bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 137189bddce5SStephen Hemminger if (sock) { 1372230b1839SYOSHIFUJI Hideaki err = move_addr_to_kernel(umyaddr, addrlen, (struct sockaddr *)&address); 137389bddce5SStephen Hemminger if (err >= 0) { 137489bddce5SStephen Hemminger err = security_socket_bind(sock, 1375230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&address, 137689bddce5SStephen Hemminger addrlen); 13776cb153caSBenjamin LaHaise if (!err) 13786cb153caSBenjamin LaHaise err = sock->ops->bind(sock, 137989bddce5SStephen Hemminger (struct sockaddr *) 1380230b1839SYOSHIFUJI Hideaki &address, addrlen); 13811da177e4SLinus Torvalds } 13826cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 13831da177e4SLinus Torvalds } 13841da177e4SLinus Torvalds return err; 13851da177e4SLinus Torvalds } 13861da177e4SLinus Torvalds 13871da177e4SLinus Torvalds /* 13881da177e4SLinus Torvalds * Perform a listen. Basically, we allow the protocol to do anything 13891da177e4SLinus Torvalds * necessary for a listen, and if that works, we mark the socket as 13901da177e4SLinus Torvalds * ready for listening. 13911da177e4SLinus Torvalds */ 13921da177e4SLinus Torvalds 13933e0fa65fSHeiko Carstens SYSCALL_DEFINE2(listen, int, fd, int, backlog) 13941da177e4SLinus Torvalds { 13951da177e4SLinus Torvalds struct socket *sock; 13966cb153caSBenjamin LaHaise int err, fput_needed; 1397b8e1f9b5SPavel Emelyanov int somaxconn; 13981da177e4SLinus Torvalds 139989bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 140089bddce5SStephen Hemminger if (sock) { 14018efa6e93SPavel Emelyanov somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn; 1402b8e1f9b5SPavel Emelyanov if ((unsigned)backlog > somaxconn) 1403b8e1f9b5SPavel Emelyanov backlog = somaxconn; 14041da177e4SLinus Torvalds 14051da177e4SLinus Torvalds err = security_socket_listen(sock, backlog); 14066cb153caSBenjamin LaHaise if (!err) 14071da177e4SLinus Torvalds err = sock->ops->listen(sock, backlog); 14086cb153caSBenjamin LaHaise 14096cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 14101da177e4SLinus Torvalds } 14111da177e4SLinus Torvalds return err; 14121da177e4SLinus Torvalds } 14131da177e4SLinus Torvalds 14141da177e4SLinus Torvalds /* 14151da177e4SLinus Torvalds * For accept, we attempt to create a new socket, set up the link 14161da177e4SLinus Torvalds * with the client, wake up the client, then return the new 14171da177e4SLinus Torvalds * connected fd. We collect the address of the connector in kernel 14181da177e4SLinus Torvalds * space and move it to user at the very end. This is unclean because 14191da177e4SLinus Torvalds * we open the socket then return an error. 14201da177e4SLinus Torvalds * 14211da177e4SLinus Torvalds * 1003.1g adds the ability to recvmsg() to query connection pending 14221da177e4SLinus Torvalds * status to recvmsg. We need to add that support in a way thats 14231da177e4SLinus Torvalds * clean when we restucture accept also. 14241da177e4SLinus Torvalds */ 14251da177e4SLinus Torvalds 142620f37034SHeiko Carstens SYSCALL_DEFINE4(accept4, int, fd, struct sockaddr __user *, upeer_sockaddr, 142720f37034SHeiko Carstens int __user *, upeer_addrlen, int, flags) 14281da177e4SLinus Torvalds { 14291da177e4SLinus Torvalds struct socket *sock, *newsock; 143039d8c1b6SDavid S. Miller struct file *newfile; 14316cb153caSBenjamin LaHaise int err, len, newfd, fput_needed; 1432230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 14331da177e4SLinus Torvalds 143477d27200SUlrich Drepper if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)) 1435aaca0bdcSUlrich Drepper return -EINVAL; 1436aaca0bdcSUlrich Drepper 1437aaca0bdcSUlrich Drepper if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK)) 1438aaca0bdcSUlrich Drepper flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK; 1439aaca0bdcSUlrich Drepper 14406cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 14411da177e4SLinus Torvalds if (!sock) 14421da177e4SLinus Torvalds goto out; 14431da177e4SLinus Torvalds 14441da177e4SLinus Torvalds err = -ENFILE; 14451da177e4SLinus Torvalds if (!(newsock = sock_alloc())) 14461da177e4SLinus Torvalds goto out_put; 14471da177e4SLinus Torvalds 14481da177e4SLinus Torvalds newsock->type = sock->type; 14491da177e4SLinus Torvalds newsock->ops = sock->ops; 14501da177e4SLinus Torvalds 14511da177e4SLinus Torvalds /* 14521da177e4SLinus Torvalds * We don't need try_module_get here, as the listening socket (sock) 14531da177e4SLinus Torvalds * has the protocol module (sock->ops->owner) held. 14541da177e4SLinus Torvalds */ 14551da177e4SLinus Torvalds __module_get(newsock->ops->owner); 14561da177e4SLinus Torvalds 14577cbe66b6SAl Viro newfd = sock_alloc_file(newsock, &newfile, flags); 145839d8c1b6SDavid S. Miller if (unlikely(newfd < 0)) { 145939d8c1b6SDavid S. Miller err = newfd; 14609a1875e6SDavid S. Miller sock_release(newsock); 14619a1875e6SDavid S. Miller goto out_put; 146239d8c1b6SDavid S. Miller } 146339d8c1b6SDavid S. Miller 1464a79af59eSFrank Filz err = security_socket_accept(sock, newsock); 1465a79af59eSFrank Filz if (err) 146639d8c1b6SDavid S. Miller goto out_fd; 1467a79af59eSFrank Filz 14681da177e4SLinus Torvalds err = sock->ops->accept(sock, newsock, sock->file->f_flags); 14691da177e4SLinus Torvalds if (err < 0) 147039d8c1b6SDavid S. Miller goto out_fd; 14711da177e4SLinus Torvalds 14721da177e4SLinus Torvalds if (upeer_sockaddr) { 1473230b1839SYOSHIFUJI Hideaki if (newsock->ops->getname(newsock, (struct sockaddr *)&address, 147489bddce5SStephen Hemminger &len, 2) < 0) { 14751da177e4SLinus Torvalds err = -ECONNABORTED; 147639d8c1b6SDavid S. Miller goto out_fd; 14771da177e4SLinus Torvalds } 1478230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&address, 1479230b1839SYOSHIFUJI Hideaki len, upeer_sockaddr, upeer_addrlen); 14801da177e4SLinus Torvalds if (err < 0) 148139d8c1b6SDavid S. Miller goto out_fd; 14821da177e4SLinus Torvalds } 14831da177e4SLinus Torvalds 14841da177e4SLinus Torvalds /* File flags are not inherited via accept() unlike another OSes. */ 14851da177e4SLinus Torvalds 148639d8c1b6SDavid S. Miller fd_install(newfd, newfile); 148739d8c1b6SDavid S. Miller err = newfd; 14881da177e4SLinus Torvalds 14891da177e4SLinus Torvalds out_put: 14906cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 14911da177e4SLinus Torvalds out: 14921da177e4SLinus Torvalds return err; 149339d8c1b6SDavid S. Miller out_fd: 14949606a216SDavid S. Miller fput(newfile); 149539d8c1b6SDavid S. Miller put_unused_fd(newfd); 14961da177e4SLinus Torvalds goto out_put; 14971da177e4SLinus Torvalds } 14981da177e4SLinus Torvalds 149920f37034SHeiko Carstens SYSCALL_DEFINE3(accept, int, fd, struct sockaddr __user *, upeer_sockaddr, 150020f37034SHeiko Carstens int __user *, upeer_addrlen) 1501aaca0bdcSUlrich Drepper { 1502de11defeSUlrich Drepper return sys_accept4(fd, upeer_sockaddr, upeer_addrlen, 0); 1503aaca0bdcSUlrich Drepper } 1504aaca0bdcSUlrich Drepper 15051da177e4SLinus Torvalds /* 15061da177e4SLinus Torvalds * Attempt to connect to a socket with the server address. The address 15071da177e4SLinus Torvalds * is in user space so we verify it is OK and move it to kernel space. 15081da177e4SLinus Torvalds * 15091da177e4SLinus Torvalds * For 1003.1g we need to add clean support for a bind to AF_UNSPEC to 15101da177e4SLinus Torvalds * break bindings 15111da177e4SLinus Torvalds * 15121da177e4SLinus Torvalds * NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and 15131da177e4SLinus Torvalds * other SEQPACKET protocols that take time to connect() as it doesn't 15141da177e4SLinus Torvalds * include the -EINPROGRESS status for such sockets. 15151da177e4SLinus Torvalds */ 15161da177e4SLinus Torvalds 151720f37034SHeiko Carstens SYSCALL_DEFINE3(connect, int, fd, struct sockaddr __user *, uservaddr, 151820f37034SHeiko Carstens int, addrlen) 15191da177e4SLinus Torvalds { 15201da177e4SLinus Torvalds struct socket *sock; 1521230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 15226cb153caSBenjamin LaHaise int err, fput_needed; 15231da177e4SLinus Torvalds 15246cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 15251da177e4SLinus Torvalds if (!sock) 15261da177e4SLinus Torvalds goto out; 1527230b1839SYOSHIFUJI Hideaki err = move_addr_to_kernel(uservaddr, addrlen, (struct sockaddr *)&address); 15281da177e4SLinus Torvalds if (err < 0) 15291da177e4SLinus Torvalds goto out_put; 15301da177e4SLinus Torvalds 153189bddce5SStephen Hemminger err = 1532230b1839SYOSHIFUJI Hideaki security_socket_connect(sock, (struct sockaddr *)&address, addrlen); 15331da177e4SLinus Torvalds if (err) 15341da177e4SLinus Torvalds goto out_put; 15351da177e4SLinus Torvalds 1536230b1839SYOSHIFUJI Hideaki err = sock->ops->connect(sock, (struct sockaddr *)&address, addrlen, 15371da177e4SLinus Torvalds sock->file->f_flags); 15381da177e4SLinus Torvalds out_put: 15396cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 15401da177e4SLinus Torvalds out: 15411da177e4SLinus Torvalds return err; 15421da177e4SLinus Torvalds } 15431da177e4SLinus Torvalds 15441da177e4SLinus Torvalds /* 15451da177e4SLinus Torvalds * Get the local address ('name') of a socket object. Move the obtained 15461da177e4SLinus Torvalds * name to user space. 15471da177e4SLinus Torvalds */ 15481da177e4SLinus Torvalds 154920f37034SHeiko Carstens SYSCALL_DEFINE3(getsockname, int, fd, struct sockaddr __user *, usockaddr, 155020f37034SHeiko Carstens int __user *, usockaddr_len) 15511da177e4SLinus Torvalds { 15521da177e4SLinus Torvalds struct socket *sock; 1553230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 15546cb153caSBenjamin LaHaise int len, err, fput_needed; 15551da177e4SLinus Torvalds 15566cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 15571da177e4SLinus Torvalds if (!sock) 15581da177e4SLinus Torvalds goto out; 15591da177e4SLinus Torvalds 15601da177e4SLinus Torvalds err = security_socket_getsockname(sock); 15611da177e4SLinus Torvalds if (err) 15621da177e4SLinus Torvalds goto out_put; 15631da177e4SLinus Torvalds 1564230b1839SYOSHIFUJI Hideaki err = sock->ops->getname(sock, (struct sockaddr *)&address, &len, 0); 15651da177e4SLinus Torvalds if (err) 15661da177e4SLinus Torvalds goto out_put; 1567230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr, usockaddr_len); 15681da177e4SLinus Torvalds 15691da177e4SLinus Torvalds out_put: 15706cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 15711da177e4SLinus Torvalds out: 15721da177e4SLinus Torvalds return err; 15731da177e4SLinus Torvalds } 15741da177e4SLinus Torvalds 15751da177e4SLinus Torvalds /* 15761da177e4SLinus Torvalds * Get the remote address ('name') of a socket object. Move the obtained 15771da177e4SLinus Torvalds * name to user space. 15781da177e4SLinus Torvalds */ 15791da177e4SLinus Torvalds 158020f37034SHeiko Carstens SYSCALL_DEFINE3(getpeername, int, fd, struct sockaddr __user *, usockaddr, 158120f37034SHeiko Carstens int __user *, usockaddr_len) 15821da177e4SLinus Torvalds { 15831da177e4SLinus Torvalds struct socket *sock; 1584230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 15856cb153caSBenjamin LaHaise int len, err, fput_needed; 15861da177e4SLinus Torvalds 158789bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 158889bddce5SStephen Hemminger if (sock != NULL) { 15891da177e4SLinus Torvalds err = security_socket_getpeername(sock); 15901da177e4SLinus Torvalds if (err) { 15916cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 15921da177e4SLinus Torvalds return err; 15931da177e4SLinus Torvalds } 15941da177e4SLinus Torvalds 159589bddce5SStephen Hemminger err = 1596230b1839SYOSHIFUJI Hideaki sock->ops->getname(sock, (struct sockaddr *)&address, &len, 159789bddce5SStephen Hemminger 1); 15981da177e4SLinus Torvalds if (!err) 1599230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr, 160089bddce5SStephen Hemminger usockaddr_len); 16016cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 16021da177e4SLinus Torvalds } 16031da177e4SLinus Torvalds return err; 16041da177e4SLinus Torvalds } 16051da177e4SLinus Torvalds 16061da177e4SLinus Torvalds /* 16071da177e4SLinus Torvalds * Send a datagram to a given address. We move the address into kernel 16081da177e4SLinus Torvalds * space and check the user space data area is readable before invoking 16091da177e4SLinus Torvalds * the protocol. 16101da177e4SLinus Torvalds */ 16111da177e4SLinus Torvalds 16123e0fa65fSHeiko Carstens SYSCALL_DEFINE6(sendto, int, fd, void __user *, buff, size_t, len, 16133e0fa65fSHeiko Carstens unsigned, flags, struct sockaddr __user *, addr, 16143e0fa65fSHeiko Carstens int, addr_len) 16151da177e4SLinus Torvalds { 16161da177e4SLinus Torvalds struct socket *sock; 1617230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 16181da177e4SLinus Torvalds int err; 16191da177e4SLinus Torvalds struct msghdr msg; 16201da177e4SLinus Torvalds struct iovec iov; 16216cb153caSBenjamin LaHaise int fput_needed; 16221da177e4SLinus Torvalds 1623de0fa95cSPavel Emelyanov sock = sockfd_lookup_light(fd, &err, &fput_needed); 1624de0fa95cSPavel Emelyanov if (!sock) 16254387ff75SDavid S. Miller goto out; 16266cb153caSBenjamin LaHaise 16271da177e4SLinus Torvalds iov.iov_base = buff; 16281da177e4SLinus Torvalds iov.iov_len = len; 16291da177e4SLinus Torvalds msg.msg_name = NULL; 16301da177e4SLinus Torvalds msg.msg_iov = &iov; 16311da177e4SLinus Torvalds msg.msg_iovlen = 1; 16321da177e4SLinus Torvalds msg.msg_control = NULL; 16331da177e4SLinus Torvalds msg.msg_controllen = 0; 16341da177e4SLinus Torvalds msg.msg_namelen = 0; 16356cb153caSBenjamin LaHaise if (addr) { 1636230b1839SYOSHIFUJI Hideaki err = move_addr_to_kernel(addr, addr_len, (struct sockaddr *)&address); 16371da177e4SLinus Torvalds if (err < 0) 16381da177e4SLinus Torvalds goto out_put; 1639230b1839SYOSHIFUJI Hideaki msg.msg_name = (struct sockaddr *)&address; 16401da177e4SLinus Torvalds msg.msg_namelen = addr_len; 16411da177e4SLinus Torvalds } 16421da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 16431da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 16441da177e4SLinus Torvalds msg.msg_flags = flags; 16451da177e4SLinus Torvalds err = sock_sendmsg(sock, &msg, len); 16461da177e4SLinus Torvalds 16471da177e4SLinus Torvalds out_put: 1648de0fa95cSPavel Emelyanov fput_light(sock->file, fput_needed); 16494387ff75SDavid S. Miller out: 16501da177e4SLinus Torvalds return err; 16511da177e4SLinus Torvalds } 16521da177e4SLinus Torvalds 16531da177e4SLinus Torvalds /* 16541da177e4SLinus Torvalds * Send a datagram down a socket. 16551da177e4SLinus Torvalds */ 16561da177e4SLinus Torvalds 16573e0fa65fSHeiko Carstens SYSCALL_DEFINE4(send, int, fd, void __user *, buff, size_t, len, 16583e0fa65fSHeiko Carstens unsigned, flags) 16591da177e4SLinus Torvalds { 16601da177e4SLinus Torvalds return sys_sendto(fd, buff, len, flags, NULL, 0); 16611da177e4SLinus Torvalds } 16621da177e4SLinus Torvalds 16631da177e4SLinus Torvalds /* 16641da177e4SLinus Torvalds * Receive a frame from the socket and optionally record the address of the 16651da177e4SLinus Torvalds * sender. We verify the buffers are writable and if needed move the 16661da177e4SLinus Torvalds * sender address from kernel to user space. 16671da177e4SLinus Torvalds */ 16681da177e4SLinus Torvalds 16693e0fa65fSHeiko Carstens SYSCALL_DEFINE6(recvfrom, int, fd, void __user *, ubuf, size_t, size, 16703e0fa65fSHeiko Carstens unsigned, flags, struct sockaddr __user *, addr, 16713e0fa65fSHeiko Carstens int __user *, addr_len) 16721da177e4SLinus Torvalds { 16731da177e4SLinus Torvalds struct socket *sock; 16741da177e4SLinus Torvalds struct iovec iov; 16751da177e4SLinus Torvalds struct msghdr msg; 1676230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 16771da177e4SLinus Torvalds int err, err2; 16786cb153caSBenjamin LaHaise int fput_needed; 16791da177e4SLinus Torvalds 1680de0fa95cSPavel Emelyanov sock = sockfd_lookup_light(fd, &err, &fput_needed); 16811da177e4SLinus Torvalds if (!sock) 1682de0fa95cSPavel Emelyanov goto out; 16831da177e4SLinus Torvalds 16841da177e4SLinus Torvalds msg.msg_control = NULL; 16851da177e4SLinus Torvalds msg.msg_controllen = 0; 16861da177e4SLinus Torvalds msg.msg_iovlen = 1; 16871da177e4SLinus Torvalds msg.msg_iov = &iov; 16881da177e4SLinus Torvalds iov.iov_len = size; 16891da177e4SLinus Torvalds iov.iov_base = ubuf; 1690230b1839SYOSHIFUJI Hideaki msg.msg_name = (struct sockaddr *)&address; 1691230b1839SYOSHIFUJI Hideaki msg.msg_namelen = sizeof(address); 16921da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 16931da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 16941da177e4SLinus Torvalds err = sock_recvmsg(sock, &msg, size, flags); 16951da177e4SLinus Torvalds 169689bddce5SStephen Hemminger if (err >= 0 && addr != NULL) { 1697230b1839SYOSHIFUJI Hideaki err2 = move_addr_to_user((struct sockaddr *)&address, 1698230b1839SYOSHIFUJI Hideaki msg.msg_namelen, addr, addr_len); 16991da177e4SLinus Torvalds if (err2 < 0) 17001da177e4SLinus Torvalds err = err2; 17011da177e4SLinus Torvalds } 1702de0fa95cSPavel Emelyanov 1703de0fa95cSPavel Emelyanov fput_light(sock->file, fput_needed); 17044387ff75SDavid S. Miller out: 17051da177e4SLinus Torvalds return err; 17061da177e4SLinus Torvalds } 17071da177e4SLinus Torvalds 17081da177e4SLinus Torvalds /* 17091da177e4SLinus Torvalds * Receive a datagram from a socket. 17101da177e4SLinus Torvalds */ 17111da177e4SLinus Torvalds 171289bddce5SStephen Hemminger asmlinkage long sys_recv(int fd, void __user *ubuf, size_t size, 171389bddce5SStephen Hemminger unsigned flags) 17141da177e4SLinus Torvalds { 17151da177e4SLinus Torvalds return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL); 17161da177e4SLinus Torvalds } 17171da177e4SLinus Torvalds 17181da177e4SLinus Torvalds /* 17191da177e4SLinus Torvalds * Set a socket option. Because we don't know the option lengths we have 17201da177e4SLinus Torvalds * to pass the user mode parameter for the protocols to sort out. 17211da177e4SLinus Torvalds */ 17221da177e4SLinus Torvalds 172320f37034SHeiko Carstens SYSCALL_DEFINE5(setsockopt, int, fd, int, level, int, optname, 172420f37034SHeiko Carstens char __user *, optval, int, optlen) 17251da177e4SLinus Torvalds { 17266cb153caSBenjamin LaHaise int err, fput_needed; 17271da177e4SLinus Torvalds struct socket *sock; 17281da177e4SLinus Torvalds 17291da177e4SLinus Torvalds if (optlen < 0) 17301da177e4SLinus Torvalds return -EINVAL; 17311da177e4SLinus Torvalds 173289bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 173389bddce5SStephen Hemminger if (sock != NULL) { 17341da177e4SLinus Torvalds err = security_socket_setsockopt(sock, level, optname); 17356cb153caSBenjamin LaHaise if (err) 17366cb153caSBenjamin LaHaise goto out_put; 17371da177e4SLinus Torvalds 17381da177e4SLinus Torvalds if (level == SOL_SOCKET) 173989bddce5SStephen Hemminger err = 174089bddce5SStephen Hemminger sock_setsockopt(sock, level, optname, optval, 174189bddce5SStephen Hemminger optlen); 17421da177e4SLinus Torvalds else 174389bddce5SStephen Hemminger err = 174489bddce5SStephen Hemminger sock->ops->setsockopt(sock, level, optname, optval, 174589bddce5SStephen Hemminger optlen); 17466cb153caSBenjamin LaHaise out_put: 17476cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 17481da177e4SLinus Torvalds } 17491da177e4SLinus Torvalds return err; 17501da177e4SLinus Torvalds } 17511da177e4SLinus Torvalds 17521da177e4SLinus Torvalds /* 17531da177e4SLinus Torvalds * Get a socket option. Because we don't know the option lengths we have 17541da177e4SLinus Torvalds * to pass a user mode parameter for the protocols to sort out. 17551da177e4SLinus Torvalds */ 17561da177e4SLinus Torvalds 175720f37034SHeiko Carstens SYSCALL_DEFINE5(getsockopt, int, fd, int, level, int, optname, 175820f37034SHeiko Carstens char __user *, optval, int __user *, optlen) 17591da177e4SLinus Torvalds { 17606cb153caSBenjamin LaHaise int err, fput_needed; 17611da177e4SLinus Torvalds struct socket *sock; 17621da177e4SLinus Torvalds 176389bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 176489bddce5SStephen Hemminger if (sock != NULL) { 17656cb153caSBenjamin LaHaise err = security_socket_getsockopt(sock, level, optname); 17666cb153caSBenjamin LaHaise if (err) 17676cb153caSBenjamin LaHaise goto out_put; 17681da177e4SLinus Torvalds 17691da177e4SLinus Torvalds if (level == SOL_SOCKET) 177089bddce5SStephen Hemminger err = 177189bddce5SStephen Hemminger sock_getsockopt(sock, level, optname, optval, 177289bddce5SStephen Hemminger optlen); 17731da177e4SLinus Torvalds else 177489bddce5SStephen Hemminger err = 177589bddce5SStephen Hemminger sock->ops->getsockopt(sock, level, optname, optval, 177689bddce5SStephen Hemminger optlen); 17776cb153caSBenjamin LaHaise out_put: 17786cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 17791da177e4SLinus Torvalds } 17801da177e4SLinus Torvalds return err; 17811da177e4SLinus Torvalds } 17821da177e4SLinus Torvalds 17831da177e4SLinus Torvalds /* 17841da177e4SLinus Torvalds * Shutdown a socket. 17851da177e4SLinus Torvalds */ 17861da177e4SLinus Torvalds 1787754fe8d2SHeiko Carstens SYSCALL_DEFINE2(shutdown, int, fd, int, how) 17881da177e4SLinus Torvalds { 17896cb153caSBenjamin LaHaise int err, fput_needed; 17901da177e4SLinus Torvalds struct socket *sock; 17911da177e4SLinus Torvalds 179289bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 179389bddce5SStephen Hemminger if (sock != NULL) { 17941da177e4SLinus Torvalds err = security_socket_shutdown(sock, how); 17956cb153caSBenjamin LaHaise if (!err) 17961da177e4SLinus Torvalds err = sock->ops->shutdown(sock, how); 17976cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 17981da177e4SLinus Torvalds } 17991da177e4SLinus Torvalds return err; 18001da177e4SLinus Torvalds } 18011da177e4SLinus Torvalds 18021da177e4SLinus Torvalds /* A couple of helpful macros for getting the address of the 32/64 bit 18031da177e4SLinus Torvalds * fields which are the same type (int / unsigned) on our platforms. 18041da177e4SLinus Torvalds */ 18051da177e4SLinus Torvalds #define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member) 18061da177e4SLinus Torvalds #define COMPAT_NAMELEN(msg) COMPAT_MSG(msg, msg_namelen) 18071da177e4SLinus Torvalds #define COMPAT_FLAGS(msg) COMPAT_MSG(msg, msg_flags) 18081da177e4SLinus Torvalds 18091da177e4SLinus Torvalds /* 18101da177e4SLinus Torvalds * BSD sendmsg interface 18111da177e4SLinus Torvalds */ 18121da177e4SLinus Torvalds 18133e0fa65fSHeiko Carstens SYSCALL_DEFINE3(sendmsg, int, fd, struct msghdr __user *, msg, unsigned, flags) 18141da177e4SLinus Torvalds { 181589bddce5SStephen Hemminger struct compat_msghdr __user *msg_compat = 181689bddce5SStephen Hemminger (struct compat_msghdr __user *)msg; 18171da177e4SLinus Torvalds struct socket *sock; 1818230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 18191da177e4SLinus Torvalds struct iovec iovstack[UIO_FASTIOV], *iov = iovstack; 1820b9d717a7SAlex Williamson unsigned char ctl[sizeof(struct cmsghdr) + 20] 1821b9d717a7SAlex Williamson __attribute__ ((aligned(sizeof(__kernel_size_t)))); 1822b9d717a7SAlex Williamson /* 20 is size of ipv6_pktinfo */ 18231da177e4SLinus Torvalds unsigned char *ctl_buf = ctl; 18241da177e4SLinus Torvalds struct msghdr msg_sys; 18251da177e4SLinus Torvalds int err, ctl_len, iov_size, total_len; 18266cb153caSBenjamin LaHaise int fput_needed; 18271da177e4SLinus Torvalds 18281da177e4SLinus Torvalds err = -EFAULT; 18291da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 18301da177e4SLinus Torvalds if (get_compat_msghdr(&msg_sys, msg_compat)) 18311da177e4SLinus Torvalds return -EFAULT; 183289bddce5SStephen Hemminger } 183389bddce5SStephen Hemminger else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr))) 18341da177e4SLinus Torvalds return -EFAULT; 18351da177e4SLinus Torvalds 18366cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 18371da177e4SLinus Torvalds if (!sock) 18381da177e4SLinus Torvalds goto out; 18391da177e4SLinus Torvalds 18401da177e4SLinus Torvalds /* do not move before msg_sys is valid */ 18411da177e4SLinus Torvalds err = -EMSGSIZE; 18421da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_MAXIOV) 18431da177e4SLinus Torvalds goto out_put; 18441da177e4SLinus Torvalds 18451da177e4SLinus Torvalds /* Check whether to allocate the iovec area */ 18461da177e4SLinus Torvalds err = -ENOMEM; 18471da177e4SLinus Torvalds iov_size = msg_sys.msg_iovlen * sizeof(struct iovec); 18481da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_FASTIOV) { 18491da177e4SLinus Torvalds iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL); 18501da177e4SLinus Torvalds if (!iov) 18511da177e4SLinus Torvalds goto out_put; 18521da177e4SLinus Torvalds } 18531da177e4SLinus Torvalds 18541da177e4SLinus Torvalds /* This will also move the address data into kernel space */ 18551da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 1856230b1839SYOSHIFUJI Hideaki err = verify_compat_iovec(&msg_sys, iov, 1857230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&address, 1858230b1839SYOSHIFUJI Hideaki VERIFY_READ); 18591da177e4SLinus Torvalds } else 1860230b1839SYOSHIFUJI Hideaki err = verify_iovec(&msg_sys, iov, 1861230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&address, 1862230b1839SYOSHIFUJI Hideaki VERIFY_READ); 18631da177e4SLinus Torvalds if (err < 0) 18641da177e4SLinus Torvalds goto out_freeiov; 18651da177e4SLinus Torvalds total_len = err; 18661da177e4SLinus Torvalds 18671da177e4SLinus Torvalds err = -ENOBUFS; 18681da177e4SLinus Torvalds 18691da177e4SLinus Torvalds if (msg_sys.msg_controllen > INT_MAX) 18701da177e4SLinus Torvalds goto out_freeiov; 18711da177e4SLinus Torvalds ctl_len = msg_sys.msg_controllen; 18721da177e4SLinus Torvalds if ((MSG_CMSG_COMPAT & flags) && ctl_len) { 187389bddce5SStephen Hemminger err = 187489bddce5SStephen Hemminger cmsghdr_from_user_compat_to_kern(&msg_sys, sock->sk, ctl, 187589bddce5SStephen Hemminger sizeof(ctl)); 18761da177e4SLinus Torvalds if (err) 18771da177e4SLinus Torvalds goto out_freeiov; 18781da177e4SLinus Torvalds ctl_buf = msg_sys.msg_control; 18798920e8f9SAl Viro ctl_len = msg_sys.msg_controllen; 18801da177e4SLinus Torvalds } else if (ctl_len) { 188189bddce5SStephen Hemminger if (ctl_len > sizeof(ctl)) { 18821da177e4SLinus Torvalds ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL); 18831da177e4SLinus Torvalds if (ctl_buf == NULL) 18841da177e4SLinus Torvalds goto out_freeiov; 18851da177e4SLinus Torvalds } 18861da177e4SLinus Torvalds err = -EFAULT; 18871da177e4SLinus Torvalds /* 18881da177e4SLinus Torvalds * Careful! Before this, msg_sys.msg_control contains a user pointer. 18891da177e4SLinus Torvalds * Afterwards, it will be a kernel pointer. Thus the compiler-assisted 18901da177e4SLinus Torvalds * checking falls down on this. 18911da177e4SLinus Torvalds */ 189289bddce5SStephen Hemminger if (copy_from_user(ctl_buf, (void __user *)msg_sys.msg_control, 189389bddce5SStephen Hemminger ctl_len)) 18941da177e4SLinus Torvalds goto out_freectl; 18951da177e4SLinus Torvalds msg_sys.msg_control = ctl_buf; 18961da177e4SLinus Torvalds } 18971da177e4SLinus Torvalds msg_sys.msg_flags = flags; 18981da177e4SLinus Torvalds 18991da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 19001da177e4SLinus Torvalds msg_sys.msg_flags |= MSG_DONTWAIT; 19011da177e4SLinus Torvalds err = sock_sendmsg(sock, &msg_sys, total_len); 19021da177e4SLinus Torvalds 19031da177e4SLinus Torvalds out_freectl: 19041da177e4SLinus Torvalds if (ctl_buf != ctl) 19051da177e4SLinus Torvalds sock_kfree_s(sock->sk, ctl_buf, ctl_len); 19061da177e4SLinus Torvalds out_freeiov: 19071da177e4SLinus Torvalds if (iov != iovstack) 19081da177e4SLinus Torvalds sock_kfree_s(sock->sk, iov, iov_size); 19091da177e4SLinus Torvalds out_put: 19106cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 19111da177e4SLinus Torvalds out: 19121da177e4SLinus Torvalds return err; 19131da177e4SLinus Torvalds } 19141da177e4SLinus Torvalds 1915a2e27255SArnaldo Carvalho de Melo static int __sys_recvmsg(struct socket *sock, struct msghdr __user *msg, 1916a2e27255SArnaldo Carvalho de Melo struct msghdr *msg_sys, unsigned flags, int nosec) 19171da177e4SLinus Torvalds { 191889bddce5SStephen Hemminger struct compat_msghdr __user *msg_compat = 191989bddce5SStephen Hemminger (struct compat_msghdr __user *)msg; 19201da177e4SLinus Torvalds struct iovec iovstack[UIO_FASTIOV]; 19211da177e4SLinus Torvalds struct iovec *iov = iovstack; 19221da177e4SLinus Torvalds unsigned long cmsg_ptr; 19231da177e4SLinus Torvalds int err, iov_size, total_len, len; 19241da177e4SLinus Torvalds 19251da177e4SLinus Torvalds /* kernel mode address */ 1926230b1839SYOSHIFUJI Hideaki struct sockaddr_storage addr; 19271da177e4SLinus Torvalds 19281da177e4SLinus Torvalds /* user mode address pointers */ 19291da177e4SLinus Torvalds struct sockaddr __user *uaddr; 19301da177e4SLinus Torvalds int __user *uaddr_len; 19311da177e4SLinus Torvalds 19321da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 1933a2e27255SArnaldo Carvalho de Melo if (get_compat_msghdr(msg_sys, msg_compat)) 19341da177e4SLinus Torvalds return -EFAULT; 193589bddce5SStephen Hemminger } 1936a2e27255SArnaldo Carvalho de Melo else if (copy_from_user(msg_sys, msg, sizeof(struct msghdr))) 19371da177e4SLinus Torvalds return -EFAULT; 19381da177e4SLinus Torvalds 19391da177e4SLinus Torvalds err = -EMSGSIZE; 1940a2e27255SArnaldo Carvalho de Melo if (msg_sys->msg_iovlen > UIO_MAXIOV) 1941a2e27255SArnaldo Carvalho de Melo goto out; 19421da177e4SLinus Torvalds 19431da177e4SLinus Torvalds /* Check whether to allocate the iovec area */ 19441da177e4SLinus Torvalds err = -ENOMEM; 1945a2e27255SArnaldo Carvalho de Melo iov_size = msg_sys->msg_iovlen * sizeof(struct iovec); 1946a2e27255SArnaldo Carvalho de Melo if (msg_sys->msg_iovlen > UIO_FASTIOV) { 19471da177e4SLinus Torvalds iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL); 19481da177e4SLinus Torvalds if (!iov) 1949a2e27255SArnaldo Carvalho de Melo goto out; 19501da177e4SLinus Torvalds } 19511da177e4SLinus Torvalds 19521da177e4SLinus Torvalds /* 19531da177e4SLinus Torvalds * Save the user-mode address (verify_iovec will change the 19541da177e4SLinus Torvalds * kernel msghdr to use the kernel address space) 19551da177e4SLinus Torvalds */ 19561da177e4SLinus Torvalds 1957a2e27255SArnaldo Carvalho de Melo uaddr = (__force void __user *)msg_sys->msg_name; 19581da177e4SLinus Torvalds uaddr_len = COMPAT_NAMELEN(msg); 19591da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 1960a2e27255SArnaldo Carvalho de Melo err = verify_compat_iovec(msg_sys, iov, 1961230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&addr, 1962230b1839SYOSHIFUJI Hideaki VERIFY_WRITE); 19631da177e4SLinus Torvalds } else 1964a2e27255SArnaldo Carvalho de Melo err = verify_iovec(msg_sys, iov, 1965230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&addr, 1966230b1839SYOSHIFUJI Hideaki VERIFY_WRITE); 19671da177e4SLinus Torvalds if (err < 0) 19681da177e4SLinus Torvalds goto out_freeiov; 19691da177e4SLinus Torvalds total_len = err; 19701da177e4SLinus Torvalds 1971a2e27255SArnaldo Carvalho de Melo cmsg_ptr = (unsigned long)msg_sys->msg_control; 1972a2e27255SArnaldo Carvalho de Melo msg_sys->msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT); 19731da177e4SLinus Torvalds 19741da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 19751da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 1976a2e27255SArnaldo Carvalho de Melo err = (nosec ? sock_recvmsg_nosec : sock_recvmsg)(sock, msg_sys, 1977a2e27255SArnaldo Carvalho de Melo total_len, flags); 19781da177e4SLinus Torvalds if (err < 0) 19791da177e4SLinus Torvalds goto out_freeiov; 19801da177e4SLinus Torvalds len = err; 19811da177e4SLinus Torvalds 19821da177e4SLinus Torvalds if (uaddr != NULL) { 1983230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&addr, 1984a2e27255SArnaldo Carvalho de Melo msg_sys->msg_namelen, uaddr, 198589bddce5SStephen Hemminger uaddr_len); 19861da177e4SLinus Torvalds if (err < 0) 19871da177e4SLinus Torvalds goto out_freeiov; 19881da177e4SLinus Torvalds } 1989a2e27255SArnaldo Carvalho de Melo err = __put_user((msg_sys->msg_flags & ~MSG_CMSG_COMPAT), 199037f7f421SDavid S. Miller COMPAT_FLAGS(msg)); 19911da177e4SLinus Torvalds if (err) 19921da177e4SLinus Torvalds goto out_freeiov; 19931da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) 1994a2e27255SArnaldo Carvalho de Melo err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr, 19951da177e4SLinus Torvalds &msg_compat->msg_controllen); 19961da177e4SLinus Torvalds else 1997a2e27255SArnaldo Carvalho de Melo err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr, 19981da177e4SLinus Torvalds &msg->msg_controllen); 19991da177e4SLinus Torvalds if (err) 20001da177e4SLinus Torvalds goto out_freeiov; 20011da177e4SLinus Torvalds err = len; 20021da177e4SLinus Torvalds 20031da177e4SLinus Torvalds out_freeiov: 20041da177e4SLinus Torvalds if (iov != iovstack) 20051da177e4SLinus Torvalds sock_kfree_s(sock->sk, iov, iov_size); 2006a2e27255SArnaldo Carvalho de Melo out: 2007a2e27255SArnaldo Carvalho de Melo return err; 2008a2e27255SArnaldo Carvalho de Melo } 2009a2e27255SArnaldo Carvalho de Melo 2010a2e27255SArnaldo Carvalho de Melo /* 2011a2e27255SArnaldo Carvalho de Melo * BSD recvmsg interface 2012a2e27255SArnaldo Carvalho de Melo */ 2013a2e27255SArnaldo Carvalho de Melo 2014a2e27255SArnaldo Carvalho de Melo SYSCALL_DEFINE3(recvmsg, int, fd, struct msghdr __user *, msg, 2015a2e27255SArnaldo Carvalho de Melo unsigned int, flags) 2016a2e27255SArnaldo Carvalho de Melo { 2017a2e27255SArnaldo Carvalho de Melo int fput_needed, err; 2018a2e27255SArnaldo Carvalho de Melo struct msghdr msg_sys; 2019a2e27255SArnaldo Carvalho de Melo struct socket *sock = sockfd_lookup_light(fd, &err, &fput_needed); 2020a2e27255SArnaldo Carvalho de Melo 2021a2e27255SArnaldo Carvalho de Melo if (!sock) 2022a2e27255SArnaldo Carvalho de Melo goto out; 2023a2e27255SArnaldo Carvalho de Melo 2024a2e27255SArnaldo Carvalho de Melo err = __sys_recvmsg(sock, msg, &msg_sys, flags, 0); 2025a2e27255SArnaldo Carvalho de Melo 20266cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 20271da177e4SLinus Torvalds out: 20281da177e4SLinus Torvalds return err; 20291da177e4SLinus Torvalds } 20301da177e4SLinus Torvalds 2031a2e27255SArnaldo Carvalho de Melo /* 2032a2e27255SArnaldo Carvalho de Melo * Linux recvmmsg interface 2033a2e27255SArnaldo Carvalho de Melo */ 20341da177e4SLinus Torvalds 2035a2e27255SArnaldo Carvalho de Melo int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen, 2036a2e27255SArnaldo Carvalho de Melo unsigned int flags, struct timespec *timeout) 2037a2e27255SArnaldo Carvalho de Melo { 2038a2e27255SArnaldo Carvalho de Melo int fput_needed, err, datagrams; 2039a2e27255SArnaldo Carvalho de Melo struct socket *sock; 2040a2e27255SArnaldo Carvalho de Melo struct mmsghdr __user *entry; 2041d7256d0eSJean-Mickael Guerin struct compat_mmsghdr __user *compat_entry; 2042a2e27255SArnaldo Carvalho de Melo struct msghdr msg_sys; 2043a2e27255SArnaldo Carvalho de Melo struct timespec end_time; 2044a2e27255SArnaldo Carvalho de Melo 2045a2e27255SArnaldo Carvalho de Melo if (timeout && 2046a2e27255SArnaldo Carvalho de Melo poll_select_set_timeout(&end_time, timeout->tv_sec, 2047a2e27255SArnaldo Carvalho de Melo timeout->tv_nsec)) 2048a2e27255SArnaldo Carvalho de Melo return -EINVAL; 2049a2e27255SArnaldo Carvalho de Melo 2050a2e27255SArnaldo Carvalho de Melo datagrams = 0; 2051a2e27255SArnaldo Carvalho de Melo 2052a2e27255SArnaldo Carvalho de Melo sock = sockfd_lookup_light(fd, &err, &fput_needed); 2053a2e27255SArnaldo Carvalho de Melo if (!sock) 2054a2e27255SArnaldo Carvalho de Melo return err; 2055a2e27255SArnaldo Carvalho de Melo 2056a2e27255SArnaldo Carvalho de Melo err = sock_error(sock->sk); 2057a2e27255SArnaldo Carvalho de Melo if (err) 2058a2e27255SArnaldo Carvalho de Melo goto out_put; 2059a2e27255SArnaldo Carvalho de Melo 2060a2e27255SArnaldo Carvalho de Melo entry = mmsg; 2061d7256d0eSJean-Mickael Guerin compat_entry = (struct compat_mmsghdr __user *)mmsg; 2062a2e27255SArnaldo Carvalho de Melo 2063a2e27255SArnaldo Carvalho de Melo while (datagrams < vlen) { 2064a2e27255SArnaldo Carvalho de Melo /* 2065a2e27255SArnaldo Carvalho de Melo * No need to ask LSM for more than the first datagram. 2066a2e27255SArnaldo Carvalho de Melo */ 2067d7256d0eSJean-Mickael Guerin if (MSG_CMSG_COMPAT & flags) { 2068d7256d0eSJean-Mickael Guerin err = __sys_recvmsg(sock, (struct msghdr __user *)compat_entry, 2069d7256d0eSJean-Mickael Guerin &msg_sys, flags, datagrams); 2070d7256d0eSJean-Mickael Guerin if (err < 0) 2071d7256d0eSJean-Mickael Guerin break; 2072d7256d0eSJean-Mickael Guerin err = __put_user(err, &compat_entry->msg_len); 2073d7256d0eSJean-Mickael Guerin ++compat_entry; 2074d7256d0eSJean-Mickael Guerin } else { 2075a2e27255SArnaldo Carvalho de Melo err = __sys_recvmsg(sock, (struct msghdr __user *)entry, 2076a2e27255SArnaldo Carvalho de Melo &msg_sys, flags, datagrams); 2077a2e27255SArnaldo Carvalho de Melo if (err < 0) 2078a2e27255SArnaldo Carvalho de Melo break; 2079a2e27255SArnaldo Carvalho de Melo err = put_user(err, &entry->msg_len); 2080d7256d0eSJean-Mickael Guerin ++entry; 2081d7256d0eSJean-Mickael Guerin } 2082d7256d0eSJean-Mickael Guerin 2083a2e27255SArnaldo Carvalho de Melo if (err) 2084a2e27255SArnaldo Carvalho de Melo break; 2085a2e27255SArnaldo Carvalho de Melo ++datagrams; 2086a2e27255SArnaldo Carvalho de Melo 208771c5c159SBrandon L Black /* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */ 208871c5c159SBrandon L Black if (flags & MSG_WAITFORONE) 208971c5c159SBrandon L Black flags |= MSG_DONTWAIT; 209071c5c159SBrandon L Black 2091a2e27255SArnaldo Carvalho de Melo if (timeout) { 2092a2e27255SArnaldo Carvalho de Melo ktime_get_ts(timeout); 2093a2e27255SArnaldo Carvalho de Melo *timeout = timespec_sub(end_time, *timeout); 2094a2e27255SArnaldo Carvalho de Melo if (timeout->tv_sec < 0) { 2095a2e27255SArnaldo Carvalho de Melo timeout->tv_sec = timeout->tv_nsec = 0; 2096a2e27255SArnaldo Carvalho de Melo break; 2097a2e27255SArnaldo Carvalho de Melo } 2098a2e27255SArnaldo Carvalho de Melo 2099a2e27255SArnaldo Carvalho de Melo /* Timeout, return less than vlen datagrams */ 2100a2e27255SArnaldo Carvalho de Melo if (timeout->tv_nsec == 0 && timeout->tv_sec == 0) 2101a2e27255SArnaldo Carvalho de Melo break; 2102a2e27255SArnaldo Carvalho de Melo } 2103a2e27255SArnaldo Carvalho de Melo 2104a2e27255SArnaldo Carvalho de Melo /* Out of band data, return right away */ 2105a2e27255SArnaldo Carvalho de Melo if (msg_sys.msg_flags & MSG_OOB) 2106a2e27255SArnaldo Carvalho de Melo break; 2107a2e27255SArnaldo Carvalho de Melo } 2108a2e27255SArnaldo Carvalho de Melo 2109a2e27255SArnaldo Carvalho de Melo out_put: 2110a2e27255SArnaldo Carvalho de Melo fput_light(sock->file, fput_needed); 2111a2e27255SArnaldo Carvalho de Melo 2112a2e27255SArnaldo Carvalho de Melo if (err == 0) 2113a2e27255SArnaldo Carvalho de Melo return datagrams; 2114a2e27255SArnaldo Carvalho de Melo 2115a2e27255SArnaldo Carvalho de Melo if (datagrams != 0) { 2116a2e27255SArnaldo Carvalho de Melo /* 2117a2e27255SArnaldo Carvalho de Melo * We may return less entries than requested (vlen) if the 2118a2e27255SArnaldo Carvalho de Melo * sock is non block and there aren't enough datagrams... 2119a2e27255SArnaldo Carvalho de Melo */ 2120a2e27255SArnaldo Carvalho de Melo if (err != -EAGAIN) { 2121a2e27255SArnaldo Carvalho de Melo /* 2122a2e27255SArnaldo Carvalho de Melo * ... or if recvmsg returns an error after we 2123a2e27255SArnaldo Carvalho de Melo * received some datagrams, where we record the 2124a2e27255SArnaldo Carvalho de Melo * error to return on the next call or if the 2125a2e27255SArnaldo Carvalho de Melo * app asks about it using getsockopt(SO_ERROR). 2126a2e27255SArnaldo Carvalho de Melo */ 2127a2e27255SArnaldo Carvalho de Melo sock->sk->sk_err = -err; 2128a2e27255SArnaldo Carvalho de Melo } 2129a2e27255SArnaldo Carvalho de Melo 2130a2e27255SArnaldo Carvalho de Melo return datagrams; 2131a2e27255SArnaldo Carvalho de Melo } 2132a2e27255SArnaldo Carvalho de Melo 2133a2e27255SArnaldo Carvalho de Melo return err; 2134a2e27255SArnaldo Carvalho de Melo } 2135a2e27255SArnaldo Carvalho de Melo 2136a2e27255SArnaldo Carvalho de Melo SYSCALL_DEFINE5(recvmmsg, int, fd, struct mmsghdr __user *, mmsg, 2137a2e27255SArnaldo Carvalho de Melo unsigned int, vlen, unsigned int, flags, 2138a2e27255SArnaldo Carvalho de Melo struct timespec __user *, timeout) 2139a2e27255SArnaldo Carvalho de Melo { 2140a2e27255SArnaldo Carvalho de Melo int datagrams; 2141a2e27255SArnaldo Carvalho de Melo struct timespec timeout_sys; 2142a2e27255SArnaldo Carvalho de Melo 2143a2e27255SArnaldo Carvalho de Melo if (!timeout) 2144a2e27255SArnaldo Carvalho de Melo return __sys_recvmmsg(fd, mmsg, vlen, flags, NULL); 2145a2e27255SArnaldo Carvalho de Melo 2146a2e27255SArnaldo Carvalho de Melo if (copy_from_user(&timeout_sys, timeout, sizeof(timeout_sys))) 2147a2e27255SArnaldo Carvalho de Melo return -EFAULT; 2148a2e27255SArnaldo Carvalho de Melo 2149a2e27255SArnaldo Carvalho de Melo datagrams = __sys_recvmmsg(fd, mmsg, vlen, flags, &timeout_sys); 2150a2e27255SArnaldo Carvalho de Melo 2151a2e27255SArnaldo Carvalho de Melo if (datagrams > 0 && 2152a2e27255SArnaldo Carvalho de Melo copy_to_user(timeout, &timeout_sys, sizeof(timeout_sys))) 2153a2e27255SArnaldo Carvalho de Melo datagrams = -EFAULT; 2154a2e27255SArnaldo Carvalho de Melo 2155a2e27255SArnaldo Carvalho de Melo return datagrams; 2156a2e27255SArnaldo Carvalho de Melo } 2157a2e27255SArnaldo Carvalho de Melo 2158a2e27255SArnaldo Carvalho de Melo #ifdef __ARCH_WANT_SYS_SOCKETCALL 21591da177e4SLinus Torvalds /* Argument list sizes for sys_socketcall */ 21601da177e4SLinus Torvalds #define AL(x) ((x) * sizeof(unsigned long)) 2161a2e27255SArnaldo Carvalho de Melo static const unsigned char nargs[20] = { 216289bddce5SStephen Hemminger AL(0),AL(3),AL(3),AL(3),AL(2),AL(3), 21631da177e4SLinus Torvalds AL(3),AL(3),AL(4),AL(4),AL(4),AL(6), 2164aaca0bdcSUlrich Drepper AL(6),AL(2),AL(5),AL(5),AL(3),AL(3), 2165a2e27255SArnaldo Carvalho de Melo AL(4),AL(5) 216689bddce5SStephen Hemminger }; 216789bddce5SStephen Hemminger 21681da177e4SLinus Torvalds #undef AL 21691da177e4SLinus Torvalds 21701da177e4SLinus Torvalds /* 21711da177e4SLinus Torvalds * System call vectors. 21721da177e4SLinus Torvalds * 21731da177e4SLinus Torvalds * Argument checking cleaned up. Saved 20% in size. 21741da177e4SLinus Torvalds * This function doesn't need to set the kernel lock because 21751da177e4SLinus Torvalds * it is set by the callees. 21761da177e4SLinus Torvalds */ 21771da177e4SLinus Torvalds 21783e0fa65fSHeiko Carstens SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args) 21791da177e4SLinus Torvalds { 21801da177e4SLinus Torvalds unsigned long a[6]; 21811da177e4SLinus Torvalds unsigned long a0, a1; 21821da177e4SLinus Torvalds int err; 218347379052SArjan van de Ven unsigned int len; 21841da177e4SLinus Torvalds 2185a2e27255SArnaldo Carvalho de Melo if (call < 1 || call > SYS_RECVMMSG) 21861da177e4SLinus Torvalds return -EINVAL; 21871da177e4SLinus Torvalds 218847379052SArjan van de Ven len = nargs[call]; 218947379052SArjan van de Ven if (len > sizeof(a)) 219047379052SArjan van de Ven return -EINVAL; 219147379052SArjan van de Ven 21921da177e4SLinus Torvalds /* copy_from_user should be SMP safe. */ 219347379052SArjan van de Ven if (copy_from_user(a, args, len)) 21941da177e4SLinus Torvalds return -EFAULT; 21951da177e4SLinus Torvalds 2196f3298dc4SAl Viro audit_socketcall(nargs[call] / sizeof(unsigned long), a); 21973ec3b2fbSDavid Woodhouse 21981da177e4SLinus Torvalds a0 = a[0]; 21991da177e4SLinus Torvalds a1 = a[1]; 22001da177e4SLinus Torvalds 220189bddce5SStephen Hemminger switch (call) { 22021da177e4SLinus Torvalds case SYS_SOCKET: 22031da177e4SLinus Torvalds err = sys_socket(a0, a1, a[2]); 22041da177e4SLinus Torvalds break; 22051da177e4SLinus Torvalds case SYS_BIND: 22061da177e4SLinus Torvalds err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]); 22071da177e4SLinus Torvalds break; 22081da177e4SLinus Torvalds case SYS_CONNECT: 22091da177e4SLinus Torvalds err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]); 22101da177e4SLinus Torvalds break; 22111da177e4SLinus Torvalds case SYS_LISTEN: 22121da177e4SLinus Torvalds err = sys_listen(a0, a1); 22131da177e4SLinus Torvalds break; 22141da177e4SLinus Torvalds case SYS_ACCEPT: 2215de11defeSUlrich Drepper err = sys_accept4(a0, (struct sockaddr __user *)a1, 2216aaca0bdcSUlrich Drepper (int __user *)a[2], 0); 22171da177e4SLinus Torvalds break; 22181da177e4SLinus Torvalds case SYS_GETSOCKNAME: 221989bddce5SStephen Hemminger err = 222089bddce5SStephen Hemminger sys_getsockname(a0, (struct sockaddr __user *)a1, 222189bddce5SStephen Hemminger (int __user *)a[2]); 22221da177e4SLinus Torvalds break; 22231da177e4SLinus Torvalds case SYS_GETPEERNAME: 222489bddce5SStephen Hemminger err = 222589bddce5SStephen Hemminger sys_getpeername(a0, (struct sockaddr __user *)a1, 222689bddce5SStephen Hemminger (int __user *)a[2]); 22271da177e4SLinus Torvalds break; 22281da177e4SLinus Torvalds case SYS_SOCKETPAIR: 22291da177e4SLinus Torvalds err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]); 22301da177e4SLinus Torvalds break; 22311da177e4SLinus Torvalds case SYS_SEND: 22321da177e4SLinus Torvalds err = sys_send(a0, (void __user *)a1, a[2], a[3]); 22331da177e4SLinus Torvalds break; 22341da177e4SLinus Torvalds case SYS_SENDTO: 22351da177e4SLinus Torvalds err = sys_sendto(a0, (void __user *)a1, a[2], a[3], 22361da177e4SLinus Torvalds (struct sockaddr __user *)a[4], a[5]); 22371da177e4SLinus Torvalds break; 22381da177e4SLinus Torvalds case SYS_RECV: 22391da177e4SLinus Torvalds err = sys_recv(a0, (void __user *)a1, a[2], a[3]); 22401da177e4SLinus Torvalds break; 22411da177e4SLinus Torvalds case SYS_RECVFROM: 22421da177e4SLinus Torvalds err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3], 224389bddce5SStephen Hemminger (struct sockaddr __user *)a[4], 224489bddce5SStephen Hemminger (int __user *)a[5]); 22451da177e4SLinus Torvalds break; 22461da177e4SLinus Torvalds case SYS_SHUTDOWN: 22471da177e4SLinus Torvalds err = sys_shutdown(a0, a1); 22481da177e4SLinus Torvalds break; 22491da177e4SLinus Torvalds case SYS_SETSOCKOPT: 22501da177e4SLinus Torvalds err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]); 22511da177e4SLinus Torvalds break; 22521da177e4SLinus Torvalds case SYS_GETSOCKOPT: 225389bddce5SStephen Hemminger err = 225489bddce5SStephen Hemminger sys_getsockopt(a0, a1, a[2], (char __user *)a[3], 225589bddce5SStephen Hemminger (int __user *)a[4]); 22561da177e4SLinus Torvalds break; 22571da177e4SLinus Torvalds case SYS_SENDMSG: 22581da177e4SLinus Torvalds err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]); 22591da177e4SLinus Torvalds break; 22601da177e4SLinus Torvalds case SYS_RECVMSG: 22611da177e4SLinus Torvalds err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]); 22621da177e4SLinus Torvalds break; 2263a2e27255SArnaldo Carvalho de Melo case SYS_RECVMMSG: 2264a2e27255SArnaldo Carvalho de Melo err = sys_recvmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3], 2265a2e27255SArnaldo Carvalho de Melo (struct timespec __user *)a[4]); 2266a2e27255SArnaldo Carvalho de Melo break; 2267de11defeSUlrich Drepper case SYS_ACCEPT4: 2268de11defeSUlrich Drepper err = sys_accept4(a0, (struct sockaddr __user *)a1, 2269de11defeSUlrich Drepper (int __user *)a[2], a[3]); 2270aaca0bdcSUlrich Drepper break; 22711da177e4SLinus Torvalds default: 22721da177e4SLinus Torvalds err = -EINVAL; 22731da177e4SLinus Torvalds break; 22741da177e4SLinus Torvalds } 22751da177e4SLinus Torvalds return err; 22761da177e4SLinus Torvalds } 22771da177e4SLinus Torvalds 22781da177e4SLinus Torvalds #endif /* __ARCH_WANT_SYS_SOCKETCALL */ 22791da177e4SLinus Torvalds 228055737fdaSStephen Hemminger /** 228155737fdaSStephen Hemminger * sock_register - add a socket protocol handler 228255737fdaSStephen Hemminger * @ops: description of protocol 228355737fdaSStephen Hemminger * 22841da177e4SLinus Torvalds * This function is called by a protocol handler that wants to 22851da177e4SLinus Torvalds * advertise its address family, and have it linked into the 228655737fdaSStephen Hemminger * socket interface. The value ops->family coresponds to the 228755737fdaSStephen Hemminger * socket system call protocol family. 22881da177e4SLinus Torvalds */ 2289f0fd27d4SStephen Hemminger int sock_register(const struct net_proto_family *ops) 22901da177e4SLinus Torvalds { 22911da177e4SLinus Torvalds int err; 22921da177e4SLinus Torvalds 22931da177e4SLinus Torvalds if (ops->family >= NPROTO) { 229489bddce5SStephen Hemminger printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family, 229589bddce5SStephen Hemminger NPROTO); 22961da177e4SLinus Torvalds return -ENOBUFS; 22971da177e4SLinus Torvalds } 229855737fdaSStephen Hemminger 229955737fdaSStephen Hemminger spin_lock(&net_family_lock); 230055737fdaSStephen Hemminger if (net_families[ops->family]) 23011da177e4SLinus Torvalds err = -EEXIST; 230255737fdaSStephen Hemminger else { 23031da177e4SLinus Torvalds net_families[ops->family] = ops; 23041da177e4SLinus Torvalds err = 0; 23051da177e4SLinus Torvalds } 230655737fdaSStephen Hemminger spin_unlock(&net_family_lock); 230755737fdaSStephen Hemminger 230889bddce5SStephen Hemminger printk(KERN_INFO "NET: Registered protocol family %d\n", ops->family); 23091da177e4SLinus Torvalds return err; 23101da177e4SLinus Torvalds } 23111da177e4SLinus Torvalds 231255737fdaSStephen Hemminger /** 231355737fdaSStephen Hemminger * sock_unregister - remove a protocol handler 231455737fdaSStephen Hemminger * @family: protocol family to remove 231555737fdaSStephen Hemminger * 23161da177e4SLinus Torvalds * This function is called by a protocol handler that wants to 23171da177e4SLinus Torvalds * remove its address family, and have it unlinked from the 231855737fdaSStephen Hemminger * new socket creation. 231955737fdaSStephen Hemminger * 232055737fdaSStephen Hemminger * If protocol handler is a module, then it can use module reference 232155737fdaSStephen Hemminger * counts to protect against new references. If protocol handler is not 232255737fdaSStephen Hemminger * a module then it needs to provide its own protection in 232355737fdaSStephen Hemminger * the ops->create routine. 23241da177e4SLinus Torvalds */ 2325f0fd27d4SStephen Hemminger void sock_unregister(int family) 23261da177e4SLinus Torvalds { 2327f0fd27d4SStephen Hemminger BUG_ON(family < 0 || family >= NPROTO); 23281da177e4SLinus Torvalds 232955737fdaSStephen Hemminger spin_lock(&net_family_lock); 23301da177e4SLinus Torvalds net_families[family] = NULL; 233155737fdaSStephen Hemminger spin_unlock(&net_family_lock); 233255737fdaSStephen Hemminger 233355737fdaSStephen Hemminger synchronize_rcu(); 233455737fdaSStephen Hemminger 233589bddce5SStephen Hemminger printk(KERN_INFO "NET: Unregistered protocol family %d\n", family); 23361da177e4SLinus Torvalds } 23371da177e4SLinus Torvalds 233877d76ea3SAndi Kleen static int __init sock_init(void) 23391da177e4SLinus Torvalds { 23401da177e4SLinus Torvalds /* 23411da177e4SLinus Torvalds * Initialize sock SLAB cache. 23421da177e4SLinus Torvalds */ 23431da177e4SLinus Torvalds 23441da177e4SLinus Torvalds sk_init(); 23451da177e4SLinus Torvalds 23461da177e4SLinus Torvalds /* 23471da177e4SLinus Torvalds * Initialize skbuff SLAB cache 23481da177e4SLinus Torvalds */ 23491da177e4SLinus Torvalds skb_init(); 23501da177e4SLinus Torvalds 23511da177e4SLinus Torvalds /* 23521da177e4SLinus Torvalds * Initialize the protocols module. 23531da177e4SLinus Torvalds */ 23541da177e4SLinus Torvalds 23551da177e4SLinus Torvalds init_inodecache(); 23561da177e4SLinus Torvalds register_filesystem(&sock_fs_type); 23571da177e4SLinus Torvalds sock_mnt = kern_mount(&sock_fs_type); 235877d76ea3SAndi Kleen 235977d76ea3SAndi Kleen /* The real protocol initialization is performed in later initcalls. 23601da177e4SLinus Torvalds */ 23611da177e4SLinus Torvalds 23621da177e4SLinus Torvalds #ifdef CONFIG_NETFILTER 23631da177e4SLinus Torvalds netfilter_init(); 23641da177e4SLinus Torvalds #endif 2365cbeb321aSDavid S. Miller 2366cbeb321aSDavid S. Miller return 0; 23671da177e4SLinus Torvalds } 23681da177e4SLinus Torvalds 236977d76ea3SAndi Kleen core_initcall(sock_init); /* early initcall */ 237077d76ea3SAndi Kleen 23711da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 23721da177e4SLinus Torvalds void socket_seq_show(struct seq_file *seq) 23731da177e4SLinus Torvalds { 23741da177e4SLinus Torvalds int cpu; 23751da177e4SLinus Torvalds int counter = 0; 23761da177e4SLinus Torvalds 23776f912042SKAMEZAWA Hiroyuki for_each_possible_cpu(cpu) 23781da177e4SLinus Torvalds counter += per_cpu(sockets_in_use, cpu); 23791da177e4SLinus Torvalds 23801da177e4SLinus Torvalds /* It can be negative, by the way. 8) */ 23811da177e4SLinus Torvalds if (counter < 0) 23821da177e4SLinus Torvalds counter = 0; 23831da177e4SLinus Torvalds 23841da177e4SLinus Torvalds seq_printf(seq, "sockets: used %d\n", counter); 23851da177e4SLinus Torvalds } 23861da177e4SLinus Torvalds #endif /* CONFIG_PROC_FS */ 23871da177e4SLinus Torvalds 238889bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 23896b96018bSArnd Bergmann static int do_siocgstamp(struct net *net, struct socket *sock, 23906b96018bSArnd Bergmann unsigned int cmd, struct compat_timeval __user *up) 23917a229387SArnd Bergmann { 23927a229387SArnd Bergmann mm_segment_t old_fs = get_fs(); 23937a229387SArnd Bergmann struct timeval ktv; 23947a229387SArnd Bergmann int err; 23957a229387SArnd Bergmann 23967a229387SArnd Bergmann set_fs(KERNEL_DS); 23976b96018bSArnd Bergmann err = sock_do_ioctl(net, sock, cmd, (unsigned long)&ktv); 23987a229387SArnd Bergmann set_fs(old_fs); 23997a229387SArnd Bergmann if (!err) { 24007a229387SArnd Bergmann err = put_user(ktv.tv_sec, &up->tv_sec); 24017a229387SArnd Bergmann err |= __put_user(ktv.tv_usec, &up->tv_usec); 24027a229387SArnd Bergmann } 24037a229387SArnd Bergmann return err; 24047a229387SArnd Bergmann } 24057a229387SArnd Bergmann 24066b96018bSArnd Bergmann static int do_siocgstampns(struct net *net, struct socket *sock, 24076b96018bSArnd Bergmann unsigned int cmd, struct compat_timespec __user *up) 24087a229387SArnd Bergmann { 24097a229387SArnd Bergmann mm_segment_t old_fs = get_fs(); 24107a229387SArnd Bergmann struct timespec kts; 24117a229387SArnd Bergmann int err; 24127a229387SArnd Bergmann 24137a229387SArnd Bergmann set_fs(KERNEL_DS); 24146b96018bSArnd Bergmann err = sock_do_ioctl(net, sock, cmd, (unsigned long)&kts); 24157a229387SArnd Bergmann set_fs(old_fs); 24167a229387SArnd Bergmann if (!err) { 24177a229387SArnd Bergmann err = put_user(kts.tv_sec, &up->tv_sec); 24187a229387SArnd Bergmann err |= __put_user(kts.tv_nsec, &up->tv_nsec); 24197a229387SArnd Bergmann } 24207a229387SArnd Bergmann return err; 24217a229387SArnd Bergmann } 24227a229387SArnd Bergmann 24236b96018bSArnd Bergmann static int dev_ifname32(struct net *net, struct compat_ifreq __user *uifr32) 24247a229387SArnd Bergmann { 24257a229387SArnd Bergmann struct ifreq __user *uifr; 24267a229387SArnd Bergmann int err; 24277a229387SArnd Bergmann 24287a229387SArnd Bergmann uifr = compat_alloc_user_space(sizeof(struct ifreq)); 24296b96018bSArnd Bergmann if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq))) 24307a229387SArnd Bergmann return -EFAULT; 24317a229387SArnd Bergmann 24326b96018bSArnd Bergmann err = dev_ioctl(net, SIOCGIFNAME, uifr); 24337a229387SArnd Bergmann if (err) 24347a229387SArnd Bergmann return err; 24357a229387SArnd Bergmann 24366b96018bSArnd Bergmann if (copy_in_user(uifr32, uifr, sizeof(struct compat_ifreq))) 24377a229387SArnd Bergmann return -EFAULT; 24387a229387SArnd Bergmann 24397a229387SArnd Bergmann return 0; 24407a229387SArnd Bergmann } 24417a229387SArnd Bergmann 24426b96018bSArnd Bergmann static int dev_ifconf(struct net *net, struct compat_ifconf __user *uifc32) 24437a229387SArnd Bergmann { 24446b96018bSArnd Bergmann struct compat_ifconf ifc32; 24457a229387SArnd Bergmann struct ifconf ifc; 24467a229387SArnd Bergmann struct ifconf __user *uifc; 24476b96018bSArnd Bergmann struct compat_ifreq __user *ifr32; 24487a229387SArnd Bergmann struct ifreq __user *ifr; 24497a229387SArnd Bergmann unsigned int i, j; 24507a229387SArnd Bergmann int err; 24517a229387SArnd Bergmann 24526b96018bSArnd Bergmann if (copy_from_user(&ifc32, uifc32, sizeof(struct compat_ifconf))) 24537a229387SArnd Bergmann return -EFAULT; 24547a229387SArnd Bergmann 24557a229387SArnd Bergmann if (ifc32.ifcbuf == 0) { 24567a229387SArnd Bergmann ifc32.ifc_len = 0; 24577a229387SArnd Bergmann ifc.ifc_len = 0; 24587a229387SArnd Bergmann ifc.ifc_req = NULL; 24597a229387SArnd Bergmann uifc = compat_alloc_user_space(sizeof(struct ifconf)); 24607a229387SArnd Bergmann } else { 24616b96018bSArnd Bergmann size_t len =((ifc32.ifc_len / sizeof (struct compat_ifreq)) + 1) * 24627a229387SArnd Bergmann sizeof (struct ifreq); 24637a229387SArnd Bergmann uifc = compat_alloc_user_space(sizeof(struct ifconf) + len); 24647a229387SArnd Bergmann ifc.ifc_len = len; 24657a229387SArnd Bergmann ifr = ifc.ifc_req = (void __user *)(uifc + 1); 24667a229387SArnd Bergmann ifr32 = compat_ptr(ifc32.ifcbuf); 24676b96018bSArnd Bergmann for (i = 0; i < ifc32.ifc_len; i += sizeof (struct compat_ifreq)) { 24686b96018bSArnd Bergmann if (copy_in_user(ifr, ifr32, sizeof(struct compat_ifreq))) 24697a229387SArnd Bergmann return -EFAULT; 24707a229387SArnd Bergmann ifr++; 24717a229387SArnd Bergmann ifr32++; 24727a229387SArnd Bergmann } 24737a229387SArnd Bergmann } 24747a229387SArnd Bergmann if (copy_to_user(uifc, &ifc, sizeof(struct ifconf))) 24757a229387SArnd Bergmann return -EFAULT; 24767a229387SArnd Bergmann 24776b96018bSArnd Bergmann err = dev_ioctl(net, SIOCGIFCONF, uifc); 24787a229387SArnd Bergmann if (err) 24797a229387SArnd Bergmann return err; 24807a229387SArnd Bergmann 24817a229387SArnd Bergmann if (copy_from_user(&ifc, uifc, sizeof(struct ifconf))) 24827a229387SArnd Bergmann return -EFAULT; 24837a229387SArnd Bergmann 24847a229387SArnd Bergmann ifr = ifc.ifc_req; 24857a229387SArnd Bergmann ifr32 = compat_ptr(ifc32.ifcbuf); 24867a229387SArnd Bergmann for (i = 0, j = 0; 24876b96018bSArnd Bergmann i + sizeof (struct compat_ifreq) <= ifc32.ifc_len && j < ifc.ifc_len; 24886b96018bSArnd Bergmann i += sizeof (struct compat_ifreq), j += sizeof (struct ifreq)) { 24896b96018bSArnd Bergmann if (copy_in_user(ifr32, ifr, sizeof (struct compat_ifreq))) 24907a229387SArnd Bergmann return -EFAULT; 24917a229387SArnd Bergmann ifr32++; 24927a229387SArnd Bergmann ifr++; 24937a229387SArnd Bergmann } 24947a229387SArnd Bergmann 24957a229387SArnd Bergmann if (ifc32.ifcbuf == 0) { 24967a229387SArnd Bergmann /* Translate from 64-bit structure multiple to 24977a229387SArnd Bergmann * a 32-bit one. 24987a229387SArnd Bergmann */ 24997a229387SArnd Bergmann i = ifc.ifc_len; 25006b96018bSArnd Bergmann i = ((i / sizeof(struct ifreq)) * sizeof(struct compat_ifreq)); 25017a229387SArnd Bergmann ifc32.ifc_len = i; 25027a229387SArnd Bergmann } else { 25037a229387SArnd Bergmann ifc32.ifc_len = i; 25047a229387SArnd Bergmann } 25056b96018bSArnd Bergmann if (copy_to_user(uifc32, &ifc32, sizeof(struct compat_ifconf))) 25067a229387SArnd Bergmann return -EFAULT; 25077a229387SArnd Bergmann 25087a229387SArnd Bergmann return 0; 25097a229387SArnd Bergmann } 25107a229387SArnd Bergmann 25116b96018bSArnd Bergmann static int ethtool_ioctl(struct net *net, struct compat_ifreq __user *ifr32) 25127a229387SArnd Bergmann { 25137a229387SArnd Bergmann struct ifreq __user *ifr; 25147a229387SArnd Bergmann u32 data; 25157a229387SArnd Bergmann void __user *datap; 25167a229387SArnd Bergmann 25177a229387SArnd Bergmann ifr = compat_alloc_user_space(sizeof(*ifr)); 25187a229387SArnd Bergmann 25197a229387SArnd Bergmann if (copy_in_user(&ifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ)) 25207a229387SArnd Bergmann return -EFAULT; 25217a229387SArnd Bergmann 25227a229387SArnd Bergmann if (get_user(data, &ifr32->ifr_ifru.ifru_data)) 25237a229387SArnd Bergmann return -EFAULT; 25247a229387SArnd Bergmann 25257a229387SArnd Bergmann datap = compat_ptr(data); 25267a229387SArnd Bergmann if (put_user(datap, &ifr->ifr_ifru.ifru_data)) 25277a229387SArnd Bergmann return -EFAULT; 25287a229387SArnd Bergmann 25296b96018bSArnd Bergmann return dev_ioctl(net, SIOCETHTOOL, ifr); 25307a229387SArnd Bergmann } 25317a229387SArnd Bergmann 25327a50a240SArnd Bergmann static int compat_siocwandev(struct net *net, struct compat_ifreq __user *uifr32) 25337a50a240SArnd Bergmann { 25347a50a240SArnd Bergmann void __user *uptr; 25357a50a240SArnd Bergmann compat_uptr_t uptr32; 25367a50a240SArnd Bergmann struct ifreq __user *uifr; 25377a50a240SArnd Bergmann 25387a50a240SArnd Bergmann uifr = compat_alloc_user_space(sizeof (*uifr)); 25397a50a240SArnd Bergmann if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq))) 25407a50a240SArnd Bergmann return -EFAULT; 25417a50a240SArnd Bergmann 25427a50a240SArnd Bergmann if (get_user(uptr32, &uifr32->ifr_settings.ifs_ifsu)) 25437a50a240SArnd Bergmann return -EFAULT; 25447a50a240SArnd Bergmann 25457a50a240SArnd Bergmann uptr = compat_ptr(uptr32); 25467a50a240SArnd Bergmann 25477a50a240SArnd Bergmann if (put_user(uptr, &uifr->ifr_settings.ifs_ifsu.raw_hdlc)) 25487a50a240SArnd Bergmann return -EFAULT; 25497a50a240SArnd Bergmann 25507a50a240SArnd Bergmann return dev_ioctl(net, SIOCWANDEV, uifr); 25517a50a240SArnd Bergmann } 25527a50a240SArnd Bergmann 25536b96018bSArnd Bergmann static int bond_ioctl(struct net *net, unsigned int cmd, 25546b96018bSArnd Bergmann struct compat_ifreq __user *ifr32) 25557a229387SArnd Bergmann { 25567a229387SArnd Bergmann struct ifreq kifr; 25577a229387SArnd Bergmann struct ifreq __user *uifr; 25587a229387SArnd Bergmann mm_segment_t old_fs; 25597a229387SArnd Bergmann int err; 25607a229387SArnd Bergmann u32 data; 25617a229387SArnd Bergmann void __user *datap; 25627a229387SArnd Bergmann 25637a229387SArnd Bergmann switch (cmd) { 25647a229387SArnd Bergmann case SIOCBONDENSLAVE: 25657a229387SArnd Bergmann case SIOCBONDRELEASE: 25667a229387SArnd Bergmann case SIOCBONDSETHWADDR: 25677a229387SArnd Bergmann case SIOCBONDCHANGEACTIVE: 25686b96018bSArnd Bergmann if (copy_from_user(&kifr, ifr32, sizeof(struct compat_ifreq))) 25697a229387SArnd Bergmann return -EFAULT; 25707a229387SArnd Bergmann 25717a229387SArnd Bergmann old_fs = get_fs(); 25727a229387SArnd Bergmann set_fs (KERNEL_DS); 25736b96018bSArnd Bergmann err = dev_ioctl(net, cmd, &kifr); 25747a229387SArnd Bergmann set_fs (old_fs); 25757a229387SArnd Bergmann 25767a229387SArnd Bergmann return err; 25777a229387SArnd Bergmann case SIOCBONDSLAVEINFOQUERY: 25787a229387SArnd Bergmann case SIOCBONDINFOQUERY: 25797a229387SArnd Bergmann uifr = compat_alloc_user_space(sizeof(*uifr)); 25807a229387SArnd Bergmann if (copy_in_user(&uifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ)) 25817a229387SArnd Bergmann return -EFAULT; 25827a229387SArnd Bergmann 25837a229387SArnd Bergmann if (get_user(data, &ifr32->ifr_ifru.ifru_data)) 25847a229387SArnd Bergmann return -EFAULT; 25857a229387SArnd Bergmann 25867a229387SArnd Bergmann datap = compat_ptr(data); 25877a229387SArnd Bergmann if (put_user(datap, &uifr->ifr_ifru.ifru_data)) 25887a229387SArnd Bergmann return -EFAULT; 25897a229387SArnd Bergmann 25906b96018bSArnd Bergmann return dev_ioctl(net, cmd, uifr); 25917a229387SArnd Bergmann default: 25927a229387SArnd Bergmann return -EINVAL; 25937a229387SArnd Bergmann }; 25947a229387SArnd Bergmann } 25957a229387SArnd Bergmann 25966b96018bSArnd Bergmann static int siocdevprivate_ioctl(struct net *net, unsigned int cmd, 25976b96018bSArnd Bergmann struct compat_ifreq __user *u_ifreq32) 25987a229387SArnd Bergmann { 25997a229387SArnd Bergmann struct ifreq __user *u_ifreq64; 26007a229387SArnd Bergmann char tmp_buf[IFNAMSIZ]; 26017a229387SArnd Bergmann void __user *data64; 26027a229387SArnd Bergmann u32 data32; 26037a229387SArnd Bergmann 26047a229387SArnd Bergmann if (copy_from_user(&tmp_buf[0], &(u_ifreq32->ifr_ifrn.ifrn_name[0]), 26057a229387SArnd Bergmann IFNAMSIZ)) 26067a229387SArnd Bergmann return -EFAULT; 26077a229387SArnd Bergmann if (__get_user(data32, &u_ifreq32->ifr_ifru.ifru_data)) 26087a229387SArnd Bergmann return -EFAULT; 26097a229387SArnd Bergmann data64 = compat_ptr(data32); 26107a229387SArnd Bergmann 26117a229387SArnd Bergmann u_ifreq64 = compat_alloc_user_space(sizeof(*u_ifreq64)); 26127a229387SArnd Bergmann 26137a229387SArnd Bergmann /* Don't check these user accesses, just let that get trapped 26147a229387SArnd Bergmann * in the ioctl handler instead. 26157a229387SArnd Bergmann */ 26167a229387SArnd Bergmann if (copy_to_user(&u_ifreq64->ifr_ifrn.ifrn_name[0], &tmp_buf[0], 26177a229387SArnd Bergmann IFNAMSIZ)) 26187a229387SArnd Bergmann return -EFAULT; 26197a229387SArnd Bergmann if (__put_user(data64, &u_ifreq64->ifr_ifru.ifru_data)) 26207a229387SArnd Bergmann return -EFAULT; 26217a229387SArnd Bergmann 26226b96018bSArnd Bergmann return dev_ioctl(net, cmd, u_ifreq64); 26237a229387SArnd Bergmann } 26247a229387SArnd Bergmann 26256b96018bSArnd Bergmann static int dev_ifsioc(struct net *net, struct socket *sock, 26266b96018bSArnd Bergmann unsigned int cmd, struct compat_ifreq __user *uifr32) 26277a229387SArnd Bergmann { 2628a2116ed2SArnd Bergmann struct ifreq __user *uifr; 26297a229387SArnd Bergmann int err; 26307a229387SArnd Bergmann 2631a2116ed2SArnd Bergmann uifr = compat_alloc_user_space(sizeof(*uifr)); 2632a2116ed2SArnd Bergmann if (copy_in_user(uifr, uifr32, sizeof(*uifr32))) 26337a229387SArnd Bergmann return -EFAULT; 2634a2116ed2SArnd Bergmann 2635a2116ed2SArnd Bergmann err = sock_do_ioctl(net, sock, cmd, (unsigned long)uifr); 2636a2116ed2SArnd Bergmann 26377a229387SArnd Bergmann if (!err) { 26387a229387SArnd Bergmann switch (cmd) { 26397a229387SArnd Bergmann case SIOCGIFFLAGS: 26407a229387SArnd Bergmann case SIOCGIFMETRIC: 26417a229387SArnd Bergmann case SIOCGIFMTU: 26427a229387SArnd Bergmann case SIOCGIFMEM: 26437a229387SArnd Bergmann case SIOCGIFHWADDR: 26447a229387SArnd Bergmann case SIOCGIFINDEX: 26457a229387SArnd Bergmann case SIOCGIFADDR: 26467a229387SArnd Bergmann case SIOCGIFBRDADDR: 26477a229387SArnd Bergmann case SIOCGIFDSTADDR: 26487a229387SArnd Bergmann case SIOCGIFNETMASK: 2649fab2532bSArnd Bergmann case SIOCGIFPFLAGS: 26507a229387SArnd Bergmann case SIOCGIFTXQLEN: 2651fab2532bSArnd Bergmann case SIOCGMIIPHY: 2652fab2532bSArnd Bergmann case SIOCGMIIREG: 2653a2116ed2SArnd Bergmann if (copy_in_user(uifr32, uifr, sizeof(*uifr32))) 2654a2116ed2SArnd Bergmann err = -EFAULT; 26557a229387SArnd Bergmann break; 2656a2116ed2SArnd Bergmann } 2657a2116ed2SArnd Bergmann } 2658a2116ed2SArnd Bergmann return err; 2659a2116ed2SArnd Bergmann } 2660a2116ed2SArnd Bergmann 2661a2116ed2SArnd Bergmann static int compat_sioc_ifmap(struct net *net, unsigned int cmd, 2662a2116ed2SArnd Bergmann struct compat_ifreq __user *uifr32) 2663a2116ed2SArnd Bergmann { 2664a2116ed2SArnd Bergmann struct ifreq ifr; 2665a2116ed2SArnd Bergmann struct compat_ifmap __user *uifmap32; 2666a2116ed2SArnd Bergmann mm_segment_t old_fs; 2667a2116ed2SArnd Bergmann int err; 2668a2116ed2SArnd Bergmann 2669a2116ed2SArnd Bergmann uifmap32 = &uifr32->ifr_ifru.ifru_map; 2670a2116ed2SArnd Bergmann err = copy_from_user(&ifr, uifr32, sizeof(ifr.ifr_name)); 2671a2116ed2SArnd Bergmann err |= __get_user(ifr.ifr_map.mem_start, &uifmap32->mem_start); 2672a2116ed2SArnd Bergmann err |= __get_user(ifr.ifr_map.mem_end, &uifmap32->mem_end); 2673a2116ed2SArnd Bergmann err |= __get_user(ifr.ifr_map.base_addr, &uifmap32->base_addr); 2674a2116ed2SArnd Bergmann err |= __get_user(ifr.ifr_map.irq, &uifmap32->irq); 2675a2116ed2SArnd Bergmann err |= __get_user(ifr.ifr_map.dma, &uifmap32->dma); 2676a2116ed2SArnd Bergmann err |= __get_user(ifr.ifr_map.port, &uifmap32->port); 2677a2116ed2SArnd Bergmann if (err) 2678a2116ed2SArnd Bergmann return -EFAULT; 2679a2116ed2SArnd Bergmann 2680a2116ed2SArnd Bergmann old_fs = get_fs(); 2681a2116ed2SArnd Bergmann set_fs (KERNEL_DS); 2682a2116ed2SArnd Bergmann err = dev_ioctl(net, cmd, (void __user *)&ifr); 2683a2116ed2SArnd Bergmann set_fs (old_fs); 2684a2116ed2SArnd Bergmann 2685a2116ed2SArnd Bergmann if (cmd == SIOCGIFMAP && !err) { 26867a229387SArnd Bergmann err = copy_to_user(uifr32, &ifr, sizeof(ifr.ifr_name)); 26877a229387SArnd Bergmann err |= __put_user(ifr.ifr_map.mem_start, &uifmap32->mem_start); 26887a229387SArnd Bergmann err |= __put_user(ifr.ifr_map.mem_end, &uifmap32->mem_end); 26897a229387SArnd Bergmann err |= __put_user(ifr.ifr_map.base_addr, &uifmap32->base_addr); 26907a229387SArnd Bergmann err |= __put_user(ifr.ifr_map.irq, &uifmap32->irq); 26917a229387SArnd Bergmann err |= __put_user(ifr.ifr_map.dma, &uifmap32->dma); 26927a229387SArnd Bergmann err |= __put_user(ifr.ifr_map.port, &uifmap32->port); 26937a229387SArnd Bergmann if (err) 26947a229387SArnd Bergmann err = -EFAULT; 26957a229387SArnd Bergmann } 26967a229387SArnd Bergmann return err; 26977a229387SArnd Bergmann } 26987a229387SArnd Bergmann 2699a2116ed2SArnd Bergmann static int compat_siocshwtstamp(struct net *net, struct compat_ifreq __user *uifr32) 2700a2116ed2SArnd Bergmann { 2701a2116ed2SArnd Bergmann void __user *uptr; 2702a2116ed2SArnd Bergmann compat_uptr_t uptr32; 2703a2116ed2SArnd Bergmann struct ifreq __user *uifr; 2704a2116ed2SArnd Bergmann 2705a2116ed2SArnd Bergmann uifr = compat_alloc_user_space(sizeof (*uifr)); 2706a2116ed2SArnd Bergmann if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq))) 2707a2116ed2SArnd Bergmann return -EFAULT; 2708a2116ed2SArnd Bergmann 2709a2116ed2SArnd Bergmann if (get_user(uptr32, &uifr32->ifr_data)) 2710a2116ed2SArnd Bergmann return -EFAULT; 2711a2116ed2SArnd Bergmann 2712a2116ed2SArnd Bergmann uptr = compat_ptr(uptr32); 2713a2116ed2SArnd Bergmann 2714a2116ed2SArnd Bergmann if (put_user(uptr, &uifr->ifr_data)) 2715a2116ed2SArnd Bergmann return -EFAULT; 2716a2116ed2SArnd Bergmann 2717a2116ed2SArnd Bergmann return dev_ioctl(net, SIOCSHWTSTAMP, uifr); 2718a2116ed2SArnd Bergmann } 2719a2116ed2SArnd Bergmann 27207a229387SArnd Bergmann struct rtentry32 { 27217a229387SArnd Bergmann u32 rt_pad1; 27227a229387SArnd Bergmann struct sockaddr rt_dst; /* target address */ 27237a229387SArnd Bergmann struct sockaddr rt_gateway; /* gateway addr (RTF_GATEWAY) */ 27247a229387SArnd Bergmann struct sockaddr rt_genmask; /* target network mask (IP) */ 27257a229387SArnd Bergmann unsigned short rt_flags; 27267a229387SArnd Bergmann short rt_pad2; 27277a229387SArnd Bergmann u32 rt_pad3; 27287a229387SArnd Bergmann unsigned char rt_tos; 27297a229387SArnd Bergmann unsigned char rt_class; 27307a229387SArnd Bergmann short rt_pad4; 27317a229387SArnd Bergmann short rt_metric; /* +1 for binary compatibility! */ 27327a229387SArnd Bergmann /* char * */ u32 rt_dev; /* forcing the device at add */ 27337a229387SArnd Bergmann u32 rt_mtu; /* per route MTU/Window */ 27347a229387SArnd Bergmann u32 rt_window; /* Window clamping */ 27357a229387SArnd Bergmann unsigned short rt_irtt; /* Initial RTT */ 27367a229387SArnd Bergmann }; 27377a229387SArnd Bergmann 27387a229387SArnd Bergmann struct in6_rtmsg32 { 27397a229387SArnd Bergmann struct in6_addr rtmsg_dst; 27407a229387SArnd Bergmann struct in6_addr rtmsg_src; 27417a229387SArnd Bergmann struct in6_addr rtmsg_gateway; 27427a229387SArnd Bergmann u32 rtmsg_type; 27437a229387SArnd Bergmann u16 rtmsg_dst_len; 27447a229387SArnd Bergmann u16 rtmsg_src_len; 27457a229387SArnd Bergmann u32 rtmsg_metric; 27467a229387SArnd Bergmann u32 rtmsg_info; 27477a229387SArnd Bergmann u32 rtmsg_flags; 27487a229387SArnd Bergmann s32 rtmsg_ifindex; 27497a229387SArnd Bergmann }; 27507a229387SArnd Bergmann 27516b96018bSArnd Bergmann static int routing_ioctl(struct net *net, struct socket *sock, 27526b96018bSArnd Bergmann unsigned int cmd, void __user *argp) 27537a229387SArnd Bergmann { 27547a229387SArnd Bergmann int ret; 27557a229387SArnd Bergmann void *r = NULL; 27567a229387SArnd Bergmann struct in6_rtmsg r6; 27577a229387SArnd Bergmann struct rtentry r4; 27587a229387SArnd Bergmann char devname[16]; 27597a229387SArnd Bergmann u32 rtdev; 27607a229387SArnd Bergmann mm_segment_t old_fs = get_fs(); 27617a229387SArnd Bergmann 27626b96018bSArnd Bergmann if (sock && sock->sk && sock->sk->sk_family == AF_INET6) { /* ipv6 */ 27636b96018bSArnd Bergmann struct in6_rtmsg32 __user *ur6 = argp; 27647a229387SArnd Bergmann ret = copy_from_user (&r6.rtmsg_dst, &(ur6->rtmsg_dst), 27657a229387SArnd Bergmann 3 * sizeof(struct in6_addr)); 27667a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_type, &(ur6->rtmsg_type)); 27677a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_dst_len, &(ur6->rtmsg_dst_len)); 27687a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_src_len, &(ur6->rtmsg_src_len)); 27697a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_metric, &(ur6->rtmsg_metric)); 27707a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_info, &(ur6->rtmsg_info)); 27717a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_flags, &(ur6->rtmsg_flags)); 27727a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_ifindex, &(ur6->rtmsg_ifindex)); 27737a229387SArnd Bergmann 27747a229387SArnd Bergmann r = (void *) &r6; 27757a229387SArnd Bergmann } else { /* ipv4 */ 27766b96018bSArnd Bergmann struct rtentry32 __user *ur4 = argp; 27777a229387SArnd Bergmann ret = copy_from_user (&r4.rt_dst, &(ur4->rt_dst), 27787a229387SArnd Bergmann 3 * sizeof(struct sockaddr)); 27797a229387SArnd Bergmann ret |= __get_user (r4.rt_flags, &(ur4->rt_flags)); 27807a229387SArnd Bergmann ret |= __get_user (r4.rt_metric, &(ur4->rt_metric)); 27817a229387SArnd Bergmann ret |= __get_user (r4.rt_mtu, &(ur4->rt_mtu)); 27827a229387SArnd Bergmann ret |= __get_user (r4.rt_window, &(ur4->rt_window)); 27837a229387SArnd Bergmann ret |= __get_user (r4.rt_irtt, &(ur4->rt_irtt)); 27847a229387SArnd Bergmann ret |= __get_user (rtdev, &(ur4->rt_dev)); 27857a229387SArnd Bergmann if (rtdev) { 27867a229387SArnd Bergmann ret |= copy_from_user (devname, compat_ptr(rtdev), 15); 27877a229387SArnd Bergmann r4.rt_dev = devname; devname[15] = 0; 27887a229387SArnd Bergmann } else 27897a229387SArnd Bergmann r4.rt_dev = NULL; 27907a229387SArnd Bergmann 27917a229387SArnd Bergmann r = (void *) &r4; 27927a229387SArnd Bergmann } 27937a229387SArnd Bergmann 27947a229387SArnd Bergmann if (ret) { 27957a229387SArnd Bergmann ret = -EFAULT; 27967a229387SArnd Bergmann goto out; 27977a229387SArnd Bergmann } 27987a229387SArnd Bergmann 27997a229387SArnd Bergmann set_fs (KERNEL_DS); 28006b96018bSArnd Bergmann ret = sock_do_ioctl(net, sock, cmd, (unsigned long) r); 28017a229387SArnd Bergmann set_fs (old_fs); 28027a229387SArnd Bergmann 28037a229387SArnd Bergmann out: 28047a229387SArnd Bergmann return ret; 28057a229387SArnd Bergmann } 28067a229387SArnd Bergmann 28077a229387SArnd Bergmann /* Since old style bridge ioctl's endup using SIOCDEVPRIVATE 28087a229387SArnd Bergmann * for some operations; this forces use of the newer bridge-utils that 28097a229387SArnd Bergmann * use compatiable ioctls 28107a229387SArnd Bergmann */ 28116b96018bSArnd Bergmann static int old_bridge_ioctl(compat_ulong_t __user *argp) 28127a229387SArnd Bergmann { 28136b96018bSArnd Bergmann compat_ulong_t tmp; 28147a229387SArnd Bergmann 28156b96018bSArnd Bergmann if (get_user(tmp, argp)) 28167a229387SArnd Bergmann return -EFAULT; 28177a229387SArnd Bergmann if (tmp == BRCTL_GET_VERSION) 28187a229387SArnd Bergmann return BRCTL_VERSION + 1; 28197a229387SArnd Bergmann return -EINVAL; 28207a229387SArnd Bergmann } 28217a229387SArnd Bergmann 28226b96018bSArnd Bergmann static int compat_sock_ioctl_trans(struct file *file, struct socket *sock, 28236b96018bSArnd Bergmann unsigned int cmd, unsigned long arg) 28246b96018bSArnd Bergmann { 28256b96018bSArnd Bergmann void __user *argp = compat_ptr(arg); 28266b96018bSArnd Bergmann struct sock *sk = sock->sk; 28276b96018bSArnd Bergmann struct net *net = sock_net(sk); 28287a229387SArnd Bergmann 28296b96018bSArnd Bergmann if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) 28306b96018bSArnd Bergmann return siocdevprivate_ioctl(net, cmd, argp); 28317a229387SArnd Bergmann 28326b96018bSArnd Bergmann switch (cmd) { 28336b96018bSArnd Bergmann case SIOCSIFBR: 28346b96018bSArnd Bergmann case SIOCGIFBR: 28356b96018bSArnd Bergmann return old_bridge_ioctl(argp); 28366b96018bSArnd Bergmann case SIOCGIFNAME: 28376b96018bSArnd Bergmann return dev_ifname32(net, argp); 28386b96018bSArnd Bergmann case SIOCGIFCONF: 28396b96018bSArnd Bergmann return dev_ifconf(net, argp); 28406b96018bSArnd Bergmann case SIOCETHTOOL: 28416b96018bSArnd Bergmann return ethtool_ioctl(net, argp); 28427a50a240SArnd Bergmann case SIOCWANDEV: 28437a50a240SArnd Bergmann return compat_siocwandev(net, argp); 2844a2116ed2SArnd Bergmann case SIOCGIFMAP: 2845a2116ed2SArnd Bergmann case SIOCSIFMAP: 2846a2116ed2SArnd Bergmann return compat_sioc_ifmap(net, cmd, argp); 28476b96018bSArnd Bergmann case SIOCBONDENSLAVE: 28486b96018bSArnd Bergmann case SIOCBONDRELEASE: 28496b96018bSArnd Bergmann case SIOCBONDSETHWADDR: 28506b96018bSArnd Bergmann case SIOCBONDSLAVEINFOQUERY: 28516b96018bSArnd Bergmann case SIOCBONDINFOQUERY: 28526b96018bSArnd Bergmann case SIOCBONDCHANGEACTIVE: 28536b96018bSArnd Bergmann return bond_ioctl(net, cmd, argp); 28546b96018bSArnd Bergmann case SIOCADDRT: 28556b96018bSArnd Bergmann case SIOCDELRT: 28566b96018bSArnd Bergmann return routing_ioctl(net, sock, cmd, argp); 28576b96018bSArnd Bergmann case SIOCGSTAMP: 28586b96018bSArnd Bergmann return do_siocgstamp(net, sock, cmd, argp); 28596b96018bSArnd Bergmann case SIOCGSTAMPNS: 28606b96018bSArnd Bergmann return do_siocgstampns(net, sock, cmd, argp); 2861a2116ed2SArnd Bergmann case SIOCSHWTSTAMP: 2862a2116ed2SArnd Bergmann return compat_siocshwtstamp(net, argp); 28637a229387SArnd Bergmann 28646b96018bSArnd Bergmann case FIOSETOWN: 28656b96018bSArnd Bergmann case SIOCSPGRP: 28666b96018bSArnd Bergmann case FIOGETOWN: 28676b96018bSArnd Bergmann case SIOCGPGRP: 28686b96018bSArnd Bergmann case SIOCBRADDBR: 28696b96018bSArnd Bergmann case SIOCBRDELBR: 28706b96018bSArnd Bergmann case SIOCGIFVLAN: 28716b96018bSArnd Bergmann case SIOCSIFVLAN: 28726b96018bSArnd Bergmann case SIOCADDDLCI: 28736b96018bSArnd Bergmann case SIOCDELDLCI: 28746b96018bSArnd Bergmann return sock_ioctl(file, cmd, arg); 28756b96018bSArnd Bergmann 28766b96018bSArnd Bergmann case SIOCGIFFLAGS: 28776b96018bSArnd Bergmann case SIOCSIFFLAGS: 28786b96018bSArnd Bergmann case SIOCGIFMETRIC: 28796b96018bSArnd Bergmann case SIOCSIFMETRIC: 28806b96018bSArnd Bergmann case SIOCGIFMTU: 28816b96018bSArnd Bergmann case SIOCSIFMTU: 28826b96018bSArnd Bergmann case SIOCGIFMEM: 28836b96018bSArnd Bergmann case SIOCSIFMEM: 28846b96018bSArnd Bergmann case SIOCGIFHWADDR: 28856b96018bSArnd Bergmann case SIOCSIFHWADDR: 28866b96018bSArnd Bergmann case SIOCADDMULTI: 28876b96018bSArnd Bergmann case SIOCDELMULTI: 28886b96018bSArnd Bergmann case SIOCGIFINDEX: 28896b96018bSArnd Bergmann case SIOCGIFADDR: 28906b96018bSArnd Bergmann case SIOCSIFADDR: 28916b96018bSArnd Bergmann case SIOCSIFHWBROADCAST: 28926b96018bSArnd Bergmann case SIOCDIFADDR: 28936b96018bSArnd Bergmann case SIOCGIFBRDADDR: 28946b96018bSArnd Bergmann case SIOCSIFBRDADDR: 28956b96018bSArnd Bergmann case SIOCGIFDSTADDR: 28966b96018bSArnd Bergmann case SIOCSIFDSTADDR: 28976b96018bSArnd Bergmann case SIOCGIFNETMASK: 28986b96018bSArnd Bergmann case SIOCSIFNETMASK: 28996b96018bSArnd Bergmann case SIOCSIFPFLAGS: 29006b96018bSArnd Bergmann case SIOCGIFPFLAGS: 29016b96018bSArnd Bergmann case SIOCGIFTXQLEN: 29026b96018bSArnd Bergmann case SIOCSIFTXQLEN: 29036b96018bSArnd Bergmann case SIOCBRADDIF: 29046b96018bSArnd Bergmann case SIOCBRDELIF: 29059177efd3SArnd Bergmann case SIOCSIFNAME: 29069177efd3SArnd Bergmann case SIOCGMIIPHY: 29079177efd3SArnd Bergmann case SIOCGMIIREG: 29089177efd3SArnd Bergmann case SIOCSMIIREG: 29096b96018bSArnd Bergmann return dev_ifsioc(net, sock, cmd, argp); 29109177efd3SArnd Bergmann 29116b96018bSArnd Bergmann case SIOCSARP: 29126b96018bSArnd Bergmann case SIOCGARP: 29136b96018bSArnd Bergmann case SIOCDARP: 29146b96018bSArnd Bergmann case SIOCATMARK: 29159177efd3SArnd Bergmann return sock_do_ioctl(net, sock, cmd, arg); 29169177efd3SArnd Bergmann } 29179177efd3SArnd Bergmann 29189177efd3SArnd Bergmann /* Prevent warning from compat_sys_ioctl, these always 29199177efd3SArnd Bergmann * result in -EINVAL in the native case anyway. */ 29209177efd3SArnd Bergmann switch (cmd) { 29219177efd3SArnd Bergmann case SIOCRTMSG: 29229177efd3SArnd Bergmann case SIOCGIFCOUNT: 29236b96018bSArnd Bergmann case SIOCSRARP: 29246b96018bSArnd Bergmann case SIOCGRARP: 29256b96018bSArnd Bergmann case SIOCDRARP: 29269177efd3SArnd Bergmann case SIOCSIFLINK: 29279177efd3SArnd Bergmann case SIOCGIFSLAVE: 29289177efd3SArnd Bergmann case SIOCSIFSLAVE: 29299177efd3SArnd Bergmann return -EINVAL; 29306b96018bSArnd Bergmann } 29316b96018bSArnd Bergmann 29326b96018bSArnd Bergmann return -ENOIOCTLCMD; 29336b96018bSArnd Bergmann } 29347a229387SArnd Bergmann 293589bbfc95SShaun Pereira static long compat_sock_ioctl(struct file *file, unsigned cmd, 293689bbfc95SShaun Pereira unsigned long arg) 293789bbfc95SShaun Pereira { 293889bbfc95SShaun Pereira struct socket *sock = file->private_data; 293989bbfc95SShaun Pereira int ret = -ENOIOCTLCMD; 294087de87d5SDavid S. Miller struct sock *sk; 294187de87d5SDavid S. Miller struct net *net; 294287de87d5SDavid S. Miller 294387de87d5SDavid S. Miller sk = sock->sk; 294487de87d5SDavid S. Miller net = sock_net(sk); 294589bbfc95SShaun Pereira 294689bbfc95SShaun Pereira if (sock->ops->compat_ioctl) 294789bbfc95SShaun Pereira ret = sock->ops->compat_ioctl(sock, cmd, arg); 294889bbfc95SShaun Pereira 294987de87d5SDavid S. Miller if (ret == -ENOIOCTLCMD && 295087de87d5SDavid S. Miller (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)) 295187de87d5SDavid S. Miller ret = compat_wext_handle_ioctl(net, cmd, arg); 295287de87d5SDavid S. Miller 29536b96018bSArnd Bergmann if (ret == -ENOIOCTLCMD) 29546b96018bSArnd Bergmann ret = compat_sock_ioctl_trans(file, sock, cmd, arg); 29556b96018bSArnd Bergmann 295689bbfc95SShaun Pereira return ret; 295789bbfc95SShaun Pereira } 295889bbfc95SShaun Pereira #endif 295989bbfc95SShaun Pereira 2960ac5a488eSSridhar Samudrala int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen) 2961ac5a488eSSridhar Samudrala { 2962ac5a488eSSridhar Samudrala return sock->ops->bind(sock, addr, addrlen); 2963ac5a488eSSridhar Samudrala } 2964ac5a488eSSridhar Samudrala 2965ac5a488eSSridhar Samudrala int kernel_listen(struct socket *sock, int backlog) 2966ac5a488eSSridhar Samudrala { 2967ac5a488eSSridhar Samudrala return sock->ops->listen(sock, backlog); 2968ac5a488eSSridhar Samudrala } 2969ac5a488eSSridhar Samudrala 2970ac5a488eSSridhar Samudrala int kernel_accept(struct socket *sock, struct socket **newsock, int flags) 2971ac5a488eSSridhar Samudrala { 2972ac5a488eSSridhar Samudrala struct sock *sk = sock->sk; 2973ac5a488eSSridhar Samudrala int err; 2974ac5a488eSSridhar Samudrala 2975ac5a488eSSridhar Samudrala err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 2976ac5a488eSSridhar Samudrala newsock); 2977ac5a488eSSridhar Samudrala if (err < 0) 2978ac5a488eSSridhar Samudrala goto done; 2979ac5a488eSSridhar Samudrala 2980ac5a488eSSridhar Samudrala err = sock->ops->accept(sock, *newsock, flags); 2981ac5a488eSSridhar Samudrala if (err < 0) { 2982ac5a488eSSridhar Samudrala sock_release(*newsock); 2983fa8705b0STony Battersby *newsock = NULL; 2984ac5a488eSSridhar Samudrala goto done; 2985ac5a488eSSridhar Samudrala } 2986ac5a488eSSridhar Samudrala 2987ac5a488eSSridhar Samudrala (*newsock)->ops = sock->ops; 29881b08534eSWei Yongjun __module_get((*newsock)->ops->owner); 2989ac5a488eSSridhar Samudrala 2990ac5a488eSSridhar Samudrala done: 2991ac5a488eSSridhar Samudrala return err; 2992ac5a488eSSridhar Samudrala } 2993ac5a488eSSridhar Samudrala 2994ac5a488eSSridhar Samudrala int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen, 2995ac5a488eSSridhar Samudrala int flags) 2996ac5a488eSSridhar Samudrala { 2997ac5a488eSSridhar Samudrala return sock->ops->connect(sock, addr, addrlen, flags); 2998ac5a488eSSridhar Samudrala } 2999ac5a488eSSridhar Samudrala 3000ac5a488eSSridhar Samudrala int kernel_getsockname(struct socket *sock, struct sockaddr *addr, 3001ac5a488eSSridhar Samudrala int *addrlen) 3002ac5a488eSSridhar Samudrala { 3003ac5a488eSSridhar Samudrala return sock->ops->getname(sock, addr, addrlen, 0); 3004ac5a488eSSridhar Samudrala } 3005ac5a488eSSridhar Samudrala 3006ac5a488eSSridhar Samudrala int kernel_getpeername(struct socket *sock, struct sockaddr *addr, 3007ac5a488eSSridhar Samudrala int *addrlen) 3008ac5a488eSSridhar Samudrala { 3009ac5a488eSSridhar Samudrala return sock->ops->getname(sock, addr, addrlen, 1); 3010ac5a488eSSridhar Samudrala } 3011ac5a488eSSridhar Samudrala 3012ac5a488eSSridhar Samudrala int kernel_getsockopt(struct socket *sock, int level, int optname, 3013ac5a488eSSridhar Samudrala char *optval, int *optlen) 3014ac5a488eSSridhar Samudrala { 3015ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 3016ac5a488eSSridhar Samudrala int err; 3017ac5a488eSSridhar Samudrala 3018ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 3019ac5a488eSSridhar Samudrala if (level == SOL_SOCKET) 3020ac5a488eSSridhar Samudrala err = sock_getsockopt(sock, level, optname, optval, optlen); 3021ac5a488eSSridhar Samudrala else 3022ac5a488eSSridhar Samudrala err = sock->ops->getsockopt(sock, level, optname, optval, 3023ac5a488eSSridhar Samudrala optlen); 3024ac5a488eSSridhar Samudrala set_fs(oldfs); 3025ac5a488eSSridhar Samudrala return err; 3026ac5a488eSSridhar Samudrala } 3027ac5a488eSSridhar Samudrala 3028ac5a488eSSridhar Samudrala int kernel_setsockopt(struct socket *sock, int level, int optname, 3029b7058842SDavid S. Miller char *optval, unsigned int optlen) 3030ac5a488eSSridhar Samudrala { 3031ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 3032ac5a488eSSridhar Samudrala int err; 3033ac5a488eSSridhar Samudrala 3034ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 3035ac5a488eSSridhar Samudrala if (level == SOL_SOCKET) 3036ac5a488eSSridhar Samudrala err = sock_setsockopt(sock, level, optname, optval, optlen); 3037ac5a488eSSridhar Samudrala else 3038ac5a488eSSridhar Samudrala err = sock->ops->setsockopt(sock, level, optname, optval, 3039ac5a488eSSridhar Samudrala optlen); 3040ac5a488eSSridhar Samudrala set_fs(oldfs); 3041ac5a488eSSridhar Samudrala return err; 3042ac5a488eSSridhar Samudrala } 3043ac5a488eSSridhar Samudrala 3044ac5a488eSSridhar Samudrala int kernel_sendpage(struct socket *sock, struct page *page, int offset, 3045ac5a488eSSridhar Samudrala size_t size, int flags) 3046ac5a488eSSridhar Samudrala { 3047ac5a488eSSridhar Samudrala if (sock->ops->sendpage) 3048ac5a488eSSridhar Samudrala return sock->ops->sendpage(sock, page, offset, size, flags); 3049ac5a488eSSridhar Samudrala 3050ac5a488eSSridhar Samudrala return sock_no_sendpage(sock, page, offset, size, flags); 3051ac5a488eSSridhar Samudrala } 3052ac5a488eSSridhar Samudrala 3053ac5a488eSSridhar Samudrala int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg) 3054ac5a488eSSridhar Samudrala { 3055ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 3056ac5a488eSSridhar Samudrala int err; 3057ac5a488eSSridhar Samudrala 3058ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 3059ac5a488eSSridhar Samudrala err = sock->ops->ioctl(sock, cmd, arg); 3060ac5a488eSSridhar Samudrala set_fs(oldfs); 3061ac5a488eSSridhar Samudrala 3062ac5a488eSSridhar Samudrala return err; 3063ac5a488eSSridhar Samudrala } 3064ac5a488eSSridhar Samudrala 306591cf45f0STrond Myklebust int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how) 306691cf45f0STrond Myklebust { 306791cf45f0STrond Myklebust return sock->ops->shutdown(sock, how); 306891cf45f0STrond Myklebust } 306991cf45f0STrond Myklebust 30701da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create); 30711da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create_kern); 30721da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create_lite); 30731da177e4SLinus Torvalds EXPORT_SYMBOL(sock_map_fd); 30741da177e4SLinus Torvalds EXPORT_SYMBOL(sock_recvmsg); 30751da177e4SLinus Torvalds EXPORT_SYMBOL(sock_register); 30761da177e4SLinus Torvalds EXPORT_SYMBOL(sock_release); 30771da177e4SLinus Torvalds EXPORT_SYMBOL(sock_sendmsg); 30781da177e4SLinus Torvalds EXPORT_SYMBOL(sock_unregister); 30791da177e4SLinus Torvalds EXPORT_SYMBOL(sock_wake_async); 30801da177e4SLinus Torvalds EXPORT_SYMBOL(sockfd_lookup); 30811da177e4SLinus Torvalds EXPORT_SYMBOL(kernel_sendmsg); 30821da177e4SLinus Torvalds EXPORT_SYMBOL(kernel_recvmsg); 3083ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_bind); 3084ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_listen); 3085ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_accept); 3086ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_connect); 3087ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getsockname); 3088ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getpeername); 3089ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getsockopt); 3090ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_setsockopt); 3091ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_sendpage); 3092ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_sock_ioctl); 309391cf45f0STrond Myklebust EXPORT_SYMBOL(kernel_sock_shutdown); 3094