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> 6655737fdaSStephen Hemminger #include <linux/rcupdate.h> 671da177e4SLinus Torvalds #include <linux/netdevice.h> 681da177e4SLinus Torvalds #include <linux/proc_fs.h> 691da177e4SLinus Torvalds #include <linux/seq_file.h> 704a3e2f71SArjan van de Ven #include <linux/mutex.h> 711da177e4SLinus Torvalds #include <linux/wanrouter.h> 721da177e4SLinus Torvalds #include <linux/if_bridge.h> 7320380731SArnaldo Carvalho de Melo #include <linux/if_frad.h> 7420380731SArnaldo Carvalho de Melo #include <linux/if_vlan.h> 751da177e4SLinus Torvalds #include <linux/init.h> 761da177e4SLinus Torvalds #include <linux/poll.h> 771da177e4SLinus Torvalds #include <linux/cache.h> 781da177e4SLinus Torvalds #include <linux/module.h> 791da177e4SLinus Torvalds #include <linux/highmem.h> 801da177e4SLinus Torvalds #include <linux/mount.h> 811da177e4SLinus Torvalds #include <linux/security.h> 821da177e4SLinus Torvalds #include <linux/syscalls.h> 831da177e4SLinus Torvalds #include <linux/compat.h> 841da177e4SLinus Torvalds #include <linux/kmod.h> 853ec3b2fbSDavid Woodhouse #include <linux/audit.h> 86d86b5e0eSAdrian Bunk #include <linux/wireless.h> 871da177e4SLinus Torvalds 881da177e4SLinus Torvalds #include <asm/uaccess.h> 891da177e4SLinus Torvalds #include <asm/unistd.h> 901da177e4SLinus Torvalds 911da177e4SLinus Torvalds #include <net/compat.h> 921da177e4SLinus Torvalds 931da177e4SLinus Torvalds #include <net/sock.h> 941da177e4SLinus Torvalds #include <linux/netfilter.h> 951da177e4SLinus Torvalds 961da177e4SLinus Torvalds static int sock_no_open(struct inode *irrelevant, struct file *dontcare); 97027445c3SBadari Pulavarty static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov, 98027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos); 99027445c3SBadari Pulavarty static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov, 100027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos); 1011da177e4SLinus Torvalds static int sock_mmap(struct file *file, struct vm_area_struct *vma); 1021da177e4SLinus Torvalds 1031da177e4SLinus Torvalds static int sock_close(struct inode *inode, struct file *file); 1041da177e4SLinus Torvalds static unsigned int sock_poll(struct file *file, 1051da177e4SLinus Torvalds struct poll_table_struct *wait); 10689bddce5SStephen Hemminger static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg); 10789bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 10889bbfc95SShaun Pereira static long compat_sock_ioctl(struct file *file, 10989bbfc95SShaun Pereira unsigned int cmd, unsigned long arg); 11089bbfc95SShaun Pereira #endif 1111da177e4SLinus Torvalds static int sock_fasync(int fd, struct file *filp, int on); 1121da177e4SLinus Torvalds static ssize_t sock_sendpage(struct file *file, struct page *page, 1131da177e4SLinus Torvalds int offset, size_t size, loff_t *ppos, int more); 1141da177e4SLinus Torvalds 1151da177e4SLinus Torvalds /* 1161da177e4SLinus Torvalds * Socket files have a set of 'special' operations as well as the generic file ones. These don't appear 1171da177e4SLinus Torvalds * in the operation structures but are done directly via the socketcall() multiplexor. 1181da177e4SLinus Torvalds */ 1191da177e4SLinus Torvalds 1201da177e4SLinus Torvalds static struct file_operations socket_file_ops = { 1211da177e4SLinus Torvalds .owner = THIS_MODULE, 1221da177e4SLinus Torvalds .llseek = no_llseek, 1231da177e4SLinus Torvalds .aio_read = sock_aio_read, 1241da177e4SLinus Torvalds .aio_write = sock_aio_write, 1251da177e4SLinus Torvalds .poll = sock_poll, 1261da177e4SLinus Torvalds .unlocked_ioctl = sock_ioctl, 12789bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 12889bbfc95SShaun Pereira .compat_ioctl = compat_sock_ioctl, 12989bbfc95SShaun Pereira #endif 1301da177e4SLinus Torvalds .mmap = sock_mmap, 1311da177e4SLinus Torvalds .open = sock_no_open, /* special open code to disallow open via /proc */ 1321da177e4SLinus Torvalds .release = sock_close, 1331da177e4SLinus Torvalds .fasync = sock_fasync, 1345274f052SJens Axboe .sendpage = sock_sendpage, 1355274f052SJens Axboe .splice_write = generic_splice_sendpage, 1361da177e4SLinus Torvalds }; 1371da177e4SLinus Torvalds 1381da177e4SLinus Torvalds /* 1391da177e4SLinus Torvalds * The protocol list. Each protocol is registered in here. 1401da177e4SLinus Torvalds */ 1411da177e4SLinus Torvalds 1421da177e4SLinus Torvalds static DEFINE_SPINLOCK(net_family_lock); 143f0fd27d4SStephen Hemminger static const struct net_proto_family *net_families[NPROTO] __read_mostly; 1441da177e4SLinus Torvalds 1451da177e4SLinus Torvalds /* 1461da177e4SLinus Torvalds * Statistics counters of the socket lists 1471da177e4SLinus Torvalds */ 1481da177e4SLinus Torvalds 1491da177e4SLinus Torvalds static DEFINE_PER_CPU(int, sockets_in_use) = 0; 1501da177e4SLinus Torvalds 1511da177e4SLinus Torvalds /* 15289bddce5SStephen Hemminger * Support routines. 15389bddce5SStephen Hemminger * Move socket addresses back and forth across the kernel/user 1541da177e4SLinus Torvalds * divide and look after the messy bits. 1551da177e4SLinus Torvalds */ 1561da177e4SLinus Torvalds 1571da177e4SLinus Torvalds #define MAX_SOCK_ADDR 128 /* 108 for Unix domain - 1581da177e4SLinus Torvalds 16 for IP, 16 for IPX, 1591da177e4SLinus Torvalds 24 for IPv6, 1601da177e4SLinus Torvalds about 80 for AX.25 1611da177e4SLinus Torvalds must be at least one bigger than 1621da177e4SLinus Torvalds the AF_UNIX size (see net/unix/af_unix.c 1631da177e4SLinus Torvalds :unix_mkname()). 1641da177e4SLinus Torvalds */ 1651da177e4SLinus Torvalds 1661da177e4SLinus Torvalds /** 1671da177e4SLinus Torvalds * move_addr_to_kernel - copy a socket address into kernel space 1681da177e4SLinus Torvalds * @uaddr: Address in user space 1691da177e4SLinus Torvalds * @kaddr: Address in kernel space 1701da177e4SLinus Torvalds * @ulen: Length in user space 1711da177e4SLinus Torvalds * 1721da177e4SLinus Torvalds * The address is copied into kernel space. If the provided address is 1731da177e4SLinus Torvalds * too long an error code of -EINVAL is returned. If the copy gives 1741da177e4SLinus Torvalds * invalid addresses -EFAULT is returned. On a success 0 is returned. 1751da177e4SLinus Torvalds */ 1761da177e4SLinus Torvalds 1771da177e4SLinus Torvalds int move_addr_to_kernel(void __user *uaddr, int ulen, void *kaddr) 1781da177e4SLinus Torvalds { 1791da177e4SLinus Torvalds if (ulen < 0 || ulen > MAX_SOCK_ADDR) 1801da177e4SLinus Torvalds return -EINVAL; 1811da177e4SLinus Torvalds if (ulen == 0) 1821da177e4SLinus Torvalds return 0; 1831da177e4SLinus Torvalds if (copy_from_user(kaddr, uaddr, ulen)) 1841da177e4SLinus Torvalds return -EFAULT; 1853ec3b2fbSDavid Woodhouse return audit_sockaddr(ulen, kaddr); 1861da177e4SLinus Torvalds } 1871da177e4SLinus Torvalds 1881da177e4SLinus Torvalds /** 1891da177e4SLinus Torvalds * move_addr_to_user - copy an address to user space 1901da177e4SLinus Torvalds * @kaddr: kernel space address 1911da177e4SLinus Torvalds * @klen: length of address in kernel 1921da177e4SLinus Torvalds * @uaddr: user space address 1931da177e4SLinus Torvalds * @ulen: pointer to user length field 1941da177e4SLinus Torvalds * 1951da177e4SLinus Torvalds * The value pointed to by ulen on entry is the buffer length available. 1961da177e4SLinus Torvalds * This is overwritten with the buffer space used. -EINVAL is returned 1971da177e4SLinus Torvalds * if an overlong buffer is specified or a negative buffer size. -EFAULT 1981da177e4SLinus Torvalds * is returned if either the buffer or the length field are not 1991da177e4SLinus Torvalds * accessible. 2001da177e4SLinus Torvalds * After copying the data up to the limit the user specifies, the true 2011da177e4SLinus Torvalds * length of the data is written over the length limit the user 2021da177e4SLinus Torvalds * specified. Zero is returned for a success. 2031da177e4SLinus Torvalds */ 2041da177e4SLinus Torvalds 20589bddce5SStephen Hemminger int move_addr_to_user(void *kaddr, int klen, void __user *uaddr, 20689bddce5SStephen Hemminger int __user *ulen) 2071da177e4SLinus Torvalds { 2081da177e4SLinus Torvalds int err; 2091da177e4SLinus Torvalds int len; 2101da177e4SLinus Torvalds 21189bddce5SStephen Hemminger err = get_user(len, ulen); 21289bddce5SStephen Hemminger if (err) 2131da177e4SLinus Torvalds return err; 2141da177e4SLinus Torvalds if (len > klen) 2151da177e4SLinus Torvalds len = klen; 2161da177e4SLinus Torvalds if (len < 0 || len > MAX_SOCK_ADDR) 2171da177e4SLinus Torvalds return -EINVAL; 21889bddce5SStephen Hemminger if (len) { 219d6fe3945SSteve Grubb if (audit_sockaddr(klen, kaddr)) 220d6fe3945SSteve Grubb return -ENOMEM; 2211da177e4SLinus Torvalds if (copy_to_user(uaddr, kaddr, len)) 2221da177e4SLinus Torvalds return -EFAULT; 2231da177e4SLinus Torvalds } 2241da177e4SLinus Torvalds /* 2251da177e4SLinus Torvalds * "fromlen shall refer to the value before truncation.." 2261da177e4SLinus Torvalds * 1003.1g 2271da177e4SLinus Torvalds */ 2281da177e4SLinus Torvalds return __put_user(klen, ulen); 2291da177e4SLinus Torvalds } 2301da177e4SLinus Torvalds 2311da177e4SLinus Torvalds #define SOCKFS_MAGIC 0x534F434B 2321da177e4SLinus Torvalds 233e18b890bSChristoph Lameter static struct kmem_cache *sock_inode_cachep __read_mostly; 2341da177e4SLinus Torvalds 2351da177e4SLinus Torvalds static struct inode *sock_alloc_inode(struct super_block *sb) 2361da177e4SLinus Torvalds { 2371da177e4SLinus Torvalds struct socket_alloc *ei; 23889bddce5SStephen Hemminger 239e94b1766SChristoph Lameter ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL); 2401da177e4SLinus Torvalds if (!ei) 2411da177e4SLinus Torvalds return NULL; 2421da177e4SLinus Torvalds init_waitqueue_head(&ei->socket.wait); 2431da177e4SLinus Torvalds 2441da177e4SLinus Torvalds ei->socket.fasync_list = NULL; 2451da177e4SLinus Torvalds ei->socket.state = SS_UNCONNECTED; 2461da177e4SLinus Torvalds ei->socket.flags = 0; 2471da177e4SLinus Torvalds ei->socket.ops = NULL; 2481da177e4SLinus Torvalds ei->socket.sk = NULL; 2491da177e4SLinus Torvalds ei->socket.file = NULL; 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds return &ei->vfs_inode; 2521da177e4SLinus Torvalds } 2531da177e4SLinus Torvalds 2541da177e4SLinus Torvalds static void sock_destroy_inode(struct inode *inode) 2551da177e4SLinus Torvalds { 2561da177e4SLinus Torvalds kmem_cache_free(sock_inode_cachep, 2571da177e4SLinus Torvalds container_of(inode, struct socket_alloc, vfs_inode)); 2581da177e4SLinus Torvalds } 2591da177e4SLinus Torvalds 260e18b890bSChristoph Lameter static void init_once(void *foo, struct kmem_cache *cachep, unsigned long flags) 2611da177e4SLinus Torvalds { 2621da177e4SLinus Torvalds struct socket_alloc *ei = (struct socket_alloc *)foo; 2631da177e4SLinus Torvalds 26489bddce5SStephen Hemminger if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) 26589bddce5SStephen Hemminger == SLAB_CTOR_CONSTRUCTOR) 2661da177e4SLinus Torvalds inode_init_once(&ei->vfs_inode); 2671da177e4SLinus Torvalds } 2681da177e4SLinus Torvalds 2691da177e4SLinus Torvalds static int init_inodecache(void) 2701da177e4SLinus Torvalds { 2711da177e4SLinus Torvalds sock_inode_cachep = kmem_cache_create("sock_inode_cache", 2721da177e4SLinus Torvalds sizeof(struct socket_alloc), 27389bddce5SStephen Hemminger 0, 27489bddce5SStephen Hemminger (SLAB_HWCACHE_ALIGN | 27589bddce5SStephen Hemminger SLAB_RECLAIM_ACCOUNT | 276fffb60f9SPaul Jackson SLAB_MEM_SPREAD), 27789bddce5SStephen Hemminger init_once, 27889bddce5SStephen Hemminger NULL); 2791da177e4SLinus Torvalds if (sock_inode_cachep == NULL) 2801da177e4SLinus Torvalds return -ENOMEM; 2811da177e4SLinus Torvalds return 0; 2821da177e4SLinus Torvalds } 2831da177e4SLinus Torvalds 2841da177e4SLinus Torvalds static struct super_operations sockfs_ops = { 2851da177e4SLinus Torvalds .alloc_inode = sock_alloc_inode, 2861da177e4SLinus Torvalds .destroy_inode =sock_destroy_inode, 2871da177e4SLinus Torvalds .statfs = simple_statfs, 2881da177e4SLinus Torvalds }; 2891da177e4SLinus Torvalds 290454e2398SDavid Howells static int sockfs_get_sb(struct file_system_type *fs_type, 29189bddce5SStephen Hemminger int flags, const char *dev_name, void *data, 29289bddce5SStephen Hemminger struct vfsmount *mnt) 2931da177e4SLinus Torvalds { 294454e2398SDavid Howells return get_sb_pseudo(fs_type, "socket:", &sockfs_ops, SOCKFS_MAGIC, 295454e2398SDavid Howells mnt); 2961da177e4SLinus Torvalds } 2971da177e4SLinus Torvalds 298ba89966cSEric Dumazet static struct vfsmount *sock_mnt __read_mostly; 2991da177e4SLinus Torvalds 3001da177e4SLinus Torvalds static struct file_system_type sock_fs_type = { 3011da177e4SLinus Torvalds .name = "sockfs", 3021da177e4SLinus Torvalds .get_sb = sockfs_get_sb, 3031da177e4SLinus Torvalds .kill_sb = kill_anon_super, 3041da177e4SLinus Torvalds }; 30589bddce5SStephen Hemminger 3061da177e4SLinus Torvalds static int sockfs_delete_dentry(struct dentry *dentry) 3071da177e4SLinus Torvalds { 308304e61e6SEric Dumazet /* 309304e61e6SEric Dumazet * At creation time, we pretended this dentry was hashed 310304e61e6SEric Dumazet * (by clearing DCACHE_UNHASHED bit in d_flags) 311304e61e6SEric Dumazet * At delete time, we restore the truth : not hashed. 312304e61e6SEric Dumazet * (so that dput() can proceed correctly) 313304e61e6SEric Dumazet */ 314304e61e6SEric Dumazet dentry->d_flags |= DCACHE_UNHASHED; 315304e61e6SEric Dumazet return 0; 3161da177e4SLinus Torvalds } 3171da177e4SLinus Torvalds static struct dentry_operations sockfs_dentry_operations = { 3181da177e4SLinus Torvalds .d_delete = sockfs_delete_dentry, 3191da177e4SLinus Torvalds }; 3201da177e4SLinus Torvalds 3211da177e4SLinus Torvalds /* 3221da177e4SLinus Torvalds * Obtains the first available file descriptor and sets it up for use. 3231da177e4SLinus Torvalds * 32439d8c1b6SDavid S. Miller * These functions create file structures and maps them to fd space 32539d8c1b6SDavid S. Miller * of the current process. On success it returns file descriptor 3261da177e4SLinus Torvalds * and file struct implicitly stored in sock->file. 3271da177e4SLinus Torvalds * Note that another thread may close file descriptor before we return 3281da177e4SLinus Torvalds * from this function. We use the fact that now we do not refer 3291da177e4SLinus Torvalds * to socket after mapping. If one day we will need it, this 3301da177e4SLinus Torvalds * function will increment ref. count on file by 1. 3311da177e4SLinus Torvalds * 3321da177e4SLinus Torvalds * In any case returned fd MAY BE not valid! 3331da177e4SLinus Torvalds * This race condition is unavoidable 3341da177e4SLinus Torvalds * with shared fd spaces, we cannot solve it inside kernel, 3351da177e4SLinus Torvalds * but we take care of internal coherence yet. 3361da177e4SLinus Torvalds */ 3371da177e4SLinus Torvalds 33839d8c1b6SDavid S. Miller static int sock_alloc_fd(struct file **filep) 3391da177e4SLinus Torvalds { 3401da177e4SLinus Torvalds int fd; 3411da177e4SLinus Torvalds 3421da177e4SLinus Torvalds fd = get_unused_fd(); 34339d8c1b6SDavid S. Miller if (likely(fd >= 0)) { 3441da177e4SLinus Torvalds struct file *file = get_empty_filp(); 3451da177e4SLinus Torvalds 34639d8c1b6SDavid S. Miller *filep = file; 34739d8c1b6SDavid S. Miller if (unlikely(!file)) { 3481da177e4SLinus Torvalds put_unused_fd(fd); 34939d8c1b6SDavid S. Miller return -ENFILE; 3501da177e4SLinus Torvalds } 35139d8c1b6SDavid S. Miller } else 35239d8c1b6SDavid S. Miller *filep = NULL; 35339d8c1b6SDavid S. Miller return fd; 35439d8c1b6SDavid S. Miller } 35539d8c1b6SDavid S. Miller 35639d8c1b6SDavid S. Miller static int sock_attach_fd(struct socket *sock, struct file *file) 35739d8c1b6SDavid S. Miller { 35839d8c1b6SDavid S. Miller struct qstr this; 35939d8c1b6SDavid S. Miller char name[32]; 3601da177e4SLinus Torvalds 361f31f5f05SEric Dumazet this.len = sprintf(name, "[%lu]", SOCK_INODE(sock)->i_ino); 3621da177e4SLinus Torvalds this.name = name; 363304e61e6SEric Dumazet this.hash = 0; 3641da177e4SLinus Torvalds 3653126a42cSJosef Sipek file->f_path.dentry = d_alloc(sock_mnt->mnt_sb->s_root, &this); 3663126a42cSJosef Sipek if (unlikely(!file->f_path.dentry)) 36739d8c1b6SDavid S. Miller return -ENOMEM; 36839d8c1b6SDavid S. Miller 3693126a42cSJosef Sipek file->f_path.dentry->d_op = &sockfs_dentry_operations; 370304e61e6SEric Dumazet /* 371304e61e6SEric Dumazet * We dont want to push this dentry into global dentry hash table. 372304e61e6SEric Dumazet * We pretend dentry is already hashed, by unsetting DCACHE_UNHASHED 373304e61e6SEric Dumazet * This permits a working /proc/$pid/fd/XXX on sockets 374304e61e6SEric Dumazet */ 3753126a42cSJosef Sipek file->f_path.dentry->d_flags &= ~DCACHE_UNHASHED; 3763126a42cSJosef Sipek d_instantiate(file->f_path.dentry, SOCK_INODE(sock)); 3773126a42cSJosef Sipek file->f_path.mnt = mntget(sock_mnt); 3783126a42cSJosef Sipek file->f_mapping = file->f_path.dentry->d_inode->i_mapping; 3791da177e4SLinus Torvalds 3801da177e4SLinus Torvalds sock->file = file; 3811da177e4SLinus Torvalds file->f_op = SOCK_INODE(sock)->i_fop = &socket_file_ops; 3821da177e4SLinus Torvalds file->f_mode = FMODE_READ | FMODE_WRITE; 3831da177e4SLinus Torvalds file->f_flags = O_RDWR; 3841da177e4SLinus Torvalds file->f_pos = 0; 38507dc3f07SBenjamin LaHaise file->private_data = sock; 38639d8c1b6SDavid S. Miller 38739d8c1b6SDavid S. Miller return 0; 3881da177e4SLinus Torvalds } 3891da177e4SLinus Torvalds 39039d8c1b6SDavid S. Miller int sock_map_fd(struct socket *sock) 39139d8c1b6SDavid S. Miller { 39239d8c1b6SDavid S. Miller struct file *newfile; 39339d8c1b6SDavid S. Miller int fd = sock_alloc_fd(&newfile); 39439d8c1b6SDavid S. Miller 39539d8c1b6SDavid S. Miller if (likely(fd >= 0)) { 39639d8c1b6SDavid S. Miller int err = sock_attach_fd(sock, newfile); 39739d8c1b6SDavid S. Miller 39839d8c1b6SDavid S. Miller if (unlikely(err < 0)) { 39939d8c1b6SDavid S. Miller put_filp(newfile); 40039d8c1b6SDavid S. Miller put_unused_fd(fd); 40139d8c1b6SDavid S. Miller return err; 40239d8c1b6SDavid S. Miller } 40339d8c1b6SDavid S. Miller fd_install(fd, newfile); 40439d8c1b6SDavid S. Miller } 4051da177e4SLinus Torvalds return fd; 4061da177e4SLinus Torvalds } 4071da177e4SLinus Torvalds 4086cb153caSBenjamin LaHaise static struct socket *sock_from_file(struct file *file, int *err) 4096cb153caSBenjamin LaHaise { 4106cb153caSBenjamin LaHaise struct inode *inode; 4116cb153caSBenjamin LaHaise struct socket *sock; 4126cb153caSBenjamin LaHaise 4136cb153caSBenjamin LaHaise if (file->f_op == &socket_file_ops) 4146cb153caSBenjamin LaHaise return file->private_data; /* set in sock_map_fd */ 4156cb153caSBenjamin LaHaise 4163126a42cSJosef Sipek inode = file->f_path.dentry->d_inode; 4176cb153caSBenjamin LaHaise if (!S_ISSOCK(inode->i_mode)) { 4186cb153caSBenjamin LaHaise *err = -ENOTSOCK; 4196cb153caSBenjamin LaHaise return NULL; 4206cb153caSBenjamin LaHaise } 4216cb153caSBenjamin LaHaise 4226cb153caSBenjamin LaHaise sock = SOCKET_I(inode); 4236cb153caSBenjamin LaHaise if (sock->file != file) { 4246cb153caSBenjamin LaHaise printk(KERN_ERR "socki_lookup: socket file changed!\n"); 4256cb153caSBenjamin LaHaise sock->file = file; 4266cb153caSBenjamin LaHaise } 4276cb153caSBenjamin LaHaise return sock; 4286cb153caSBenjamin LaHaise } 4296cb153caSBenjamin LaHaise 4301da177e4SLinus Torvalds /** 4311da177e4SLinus Torvalds * sockfd_lookup - Go from a file number to its socket slot 4321da177e4SLinus Torvalds * @fd: file handle 4331da177e4SLinus Torvalds * @err: pointer to an error code return 4341da177e4SLinus Torvalds * 4351da177e4SLinus Torvalds * The file handle passed in is locked and the socket it is bound 4361da177e4SLinus Torvalds * too is returned. If an error occurs the err pointer is overwritten 4371da177e4SLinus Torvalds * with a negative errno code and NULL is returned. The function checks 4381da177e4SLinus Torvalds * for both invalid handles and passing a handle which is not a socket. 4391da177e4SLinus Torvalds * 4401da177e4SLinus Torvalds * On a success the socket object pointer is returned. 4411da177e4SLinus Torvalds */ 4421da177e4SLinus Torvalds 4431da177e4SLinus Torvalds struct socket *sockfd_lookup(int fd, int *err) 4441da177e4SLinus Torvalds { 4451da177e4SLinus Torvalds struct file *file; 4461da177e4SLinus Torvalds struct socket *sock; 4471da177e4SLinus Torvalds 44889bddce5SStephen Hemminger file = fget(fd); 44989bddce5SStephen Hemminger if (!file) { 4501da177e4SLinus Torvalds *err = -EBADF; 4511da177e4SLinus Torvalds return NULL; 4521da177e4SLinus Torvalds } 45389bddce5SStephen Hemminger 4546cb153caSBenjamin LaHaise sock = sock_from_file(file, err); 4556cb153caSBenjamin LaHaise if (!sock) 4561da177e4SLinus Torvalds fput(file); 4576cb153caSBenjamin LaHaise return sock; 4581da177e4SLinus Torvalds } 4591da177e4SLinus Torvalds 4606cb153caSBenjamin LaHaise static struct socket *sockfd_lookup_light(int fd, int *err, int *fput_needed) 4616cb153caSBenjamin LaHaise { 4626cb153caSBenjamin LaHaise struct file *file; 4636cb153caSBenjamin LaHaise struct socket *sock; 4646cb153caSBenjamin LaHaise 4653672558cSHua Zhong *err = -EBADF; 4666cb153caSBenjamin LaHaise file = fget_light(fd, fput_needed); 4676cb153caSBenjamin LaHaise if (file) { 4686cb153caSBenjamin LaHaise sock = sock_from_file(file, err); 4696cb153caSBenjamin LaHaise if (sock) 4701da177e4SLinus Torvalds return sock; 4716cb153caSBenjamin LaHaise fput_light(file, *fput_needed); 4726cb153caSBenjamin LaHaise } 4736cb153caSBenjamin LaHaise return NULL; 4741da177e4SLinus Torvalds } 4751da177e4SLinus Torvalds 4761da177e4SLinus Torvalds /** 4771da177e4SLinus Torvalds * sock_alloc - allocate a socket 4781da177e4SLinus Torvalds * 4791da177e4SLinus Torvalds * Allocate a new inode and socket object. The two are bound together 4801da177e4SLinus Torvalds * and initialised. The socket is then returned. If we are out of inodes 4811da177e4SLinus Torvalds * NULL is returned. 4821da177e4SLinus Torvalds */ 4831da177e4SLinus Torvalds 4841da177e4SLinus Torvalds static struct socket *sock_alloc(void) 4851da177e4SLinus Torvalds { 4861da177e4SLinus Torvalds struct inode *inode; 4871da177e4SLinus Torvalds struct socket *sock; 4881da177e4SLinus Torvalds 4891da177e4SLinus Torvalds inode = new_inode(sock_mnt->mnt_sb); 4901da177e4SLinus Torvalds if (!inode) 4911da177e4SLinus Torvalds return NULL; 4921da177e4SLinus Torvalds 4931da177e4SLinus Torvalds sock = SOCKET_I(inode); 4941da177e4SLinus Torvalds 4951da177e4SLinus Torvalds inode->i_mode = S_IFSOCK | S_IRWXUGO; 4961da177e4SLinus Torvalds inode->i_uid = current->fsuid; 4971da177e4SLinus Torvalds inode->i_gid = current->fsgid; 4981da177e4SLinus Torvalds 4991da177e4SLinus Torvalds get_cpu_var(sockets_in_use)++; 5001da177e4SLinus Torvalds put_cpu_var(sockets_in_use); 5011da177e4SLinus Torvalds return sock; 5021da177e4SLinus Torvalds } 5031da177e4SLinus Torvalds 5041da177e4SLinus Torvalds /* 5051da177e4SLinus Torvalds * In theory you can't get an open on this inode, but /proc provides 5061da177e4SLinus Torvalds * a back door. Remember to keep it shut otherwise you'll let the 5071da177e4SLinus Torvalds * creepy crawlies in. 5081da177e4SLinus Torvalds */ 5091da177e4SLinus Torvalds 5101da177e4SLinus Torvalds static int sock_no_open(struct inode *irrelevant, struct file *dontcare) 5111da177e4SLinus Torvalds { 5121da177e4SLinus Torvalds return -ENXIO; 5131da177e4SLinus Torvalds } 5141da177e4SLinus Torvalds 5154b6f5d20SArjan van de Ven const struct file_operations bad_sock_fops = { 5161da177e4SLinus Torvalds .owner = THIS_MODULE, 5171da177e4SLinus Torvalds .open = sock_no_open, 5181da177e4SLinus Torvalds }; 5191da177e4SLinus Torvalds 5201da177e4SLinus Torvalds /** 5211da177e4SLinus Torvalds * sock_release - close a socket 5221da177e4SLinus Torvalds * @sock: socket to close 5231da177e4SLinus Torvalds * 5241da177e4SLinus Torvalds * The socket is released from the protocol stack if it has a release 5251da177e4SLinus Torvalds * callback, and the inode is then released if the socket is bound to 5261da177e4SLinus Torvalds * an inode not a file. 5271da177e4SLinus Torvalds */ 5281da177e4SLinus Torvalds 5291da177e4SLinus Torvalds void sock_release(struct socket *sock) 5301da177e4SLinus Torvalds { 5311da177e4SLinus Torvalds if (sock->ops) { 5321da177e4SLinus Torvalds struct module *owner = sock->ops->owner; 5331da177e4SLinus Torvalds 5341da177e4SLinus Torvalds sock->ops->release(sock); 5351da177e4SLinus Torvalds sock->ops = NULL; 5361da177e4SLinus Torvalds module_put(owner); 5371da177e4SLinus Torvalds } 5381da177e4SLinus Torvalds 5391da177e4SLinus Torvalds if (sock->fasync_list) 5401da177e4SLinus Torvalds printk(KERN_ERR "sock_release: fasync list not empty!\n"); 5411da177e4SLinus Torvalds 5421da177e4SLinus Torvalds get_cpu_var(sockets_in_use)--; 5431da177e4SLinus Torvalds put_cpu_var(sockets_in_use); 5441da177e4SLinus Torvalds if (!sock->file) { 5451da177e4SLinus Torvalds iput(SOCK_INODE(sock)); 5461da177e4SLinus Torvalds return; 5471da177e4SLinus Torvalds } 5481da177e4SLinus Torvalds sock->file = NULL; 5491da177e4SLinus Torvalds } 5501da177e4SLinus Torvalds 5511da177e4SLinus Torvalds static inline int __sock_sendmsg(struct kiocb *iocb, struct socket *sock, 5521da177e4SLinus Torvalds struct msghdr *msg, size_t size) 5531da177e4SLinus Torvalds { 5541da177e4SLinus Torvalds struct sock_iocb *si = kiocb_to_siocb(iocb); 5551da177e4SLinus Torvalds int err; 5561da177e4SLinus Torvalds 5571da177e4SLinus Torvalds si->sock = sock; 5581da177e4SLinus Torvalds si->scm = NULL; 5591da177e4SLinus Torvalds si->msg = msg; 5601da177e4SLinus Torvalds si->size = size; 5611da177e4SLinus Torvalds 5621da177e4SLinus Torvalds err = security_socket_sendmsg(sock, msg, size); 5631da177e4SLinus Torvalds if (err) 5641da177e4SLinus Torvalds return err; 5651da177e4SLinus Torvalds 5661da177e4SLinus Torvalds return sock->ops->sendmsg(iocb, sock, msg, size); 5671da177e4SLinus Torvalds } 5681da177e4SLinus Torvalds 5691da177e4SLinus Torvalds int sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t size) 5701da177e4SLinus Torvalds { 5711da177e4SLinus Torvalds struct kiocb iocb; 5721da177e4SLinus Torvalds struct sock_iocb siocb; 5731da177e4SLinus Torvalds int ret; 5741da177e4SLinus Torvalds 5751da177e4SLinus Torvalds init_sync_kiocb(&iocb, NULL); 5761da177e4SLinus Torvalds iocb.private = &siocb; 5771da177e4SLinus Torvalds ret = __sock_sendmsg(&iocb, sock, msg, size); 5781da177e4SLinus Torvalds if (-EIOCBQUEUED == ret) 5791da177e4SLinus Torvalds ret = wait_on_sync_kiocb(&iocb); 5801da177e4SLinus Torvalds return ret; 5811da177e4SLinus Torvalds } 5821da177e4SLinus Torvalds 5831da177e4SLinus Torvalds int kernel_sendmsg(struct socket *sock, struct msghdr *msg, 5841da177e4SLinus Torvalds struct kvec *vec, size_t num, size_t size) 5851da177e4SLinus Torvalds { 5861da177e4SLinus Torvalds mm_segment_t oldfs = get_fs(); 5871da177e4SLinus Torvalds int result; 5881da177e4SLinus Torvalds 5891da177e4SLinus Torvalds set_fs(KERNEL_DS); 5901da177e4SLinus Torvalds /* 5911da177e4SLinus Torvalds * the following is safe, since for compiler definitions of kvec and 5921da177e4SLinus Torvalds * iovec are identical, yielding the same in-core layout and alignment 5931da177e4SLinus Torvalds */ 59489bddce5SStephen Hemminger msg->msg_iov = (struct iovec *)vec; 5951da177e4SLinus Torvalds msg->msg_iovlen = num; 5961da177e4SLinus Torvalds result = sock_sendmsg(sock, msg, size); 5971da177e4SLinus Torvalds set_fs(oldfs); 5981da177e4SLinus Torvalds return result; 5991da177e4SLinus Torvalds } 6001da177e4SLinus Torvalds 6011da177e4SLinus Torvalds static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock, 6021da177e4SLinus Torvalds struct msghdr *msg, size_t size, int flags) 6031da177e4SLinus Torvalds { 6041da177e4SLinus Torvalds int err; 6051da177e4SLinus Torvalds struct sock_iocb *si = kiocb_to_siocb(iocb); 6061da177e4SLinus Torvalds 6071da177e4SLinus Torvalds si->sock = sock; 6081da177e4SLinus Torvalds si->scm = NULL; 6091da177e4SLinus Torvalds si->msg = msg; 6101da177e4SLinus Torvalds si->size = size; 6111da177e4SLinus Torvalds si->flags = flags; 6121da177e4SLinus Torvalds 6131da177e4SLinus Torvalds err = security_socket_recvmsg(sock, msg, size, flags); 6141da177e4SLinus Torvalds if (err) 6151da177e4SLinus Torvalds return err; 6161da177e4SLinus Torvalds 6171da177e4SLinus Torvalds return sock->ops->recvmsg(iocb, sock, msg, size, flags); 6181da177e4SLinus Torvalds } 6191da177e4SLinus Torvalds 6201da177e4SLinus Torvalds int sock_recvmsg(struct socket *sock, struct msghdr *msg, 6211da177e4SLinus Torvalds size_t size, int flags) 6221da177e4SLinus Torvalds { 6231da177e4SLinus Torvalds struct kiocb iocb; 6241da177e4SLinus Torvalds struct sock_iocb siocb; 6251da177e4SLinus Torvalds int ret; 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds init_sync_kiocb(&iocb, NULL); 6281da177e4SLinus Torvalds iocb.private = &siocb; 6291da177e4SLinus Torvalds ret = __sock_recvmsg(&iocb, sock, msg, size, flags); 6301da177e4SLinus Torvalds if (-EIOCBQUEUED == ret) 6311da177e4SLinus Torvalds ret = wait_on_sync_kiocb(&iocb); 6321da177e4SLinus Torvalds return ret; 6331da177e4SLinus Torvalds } 6341da177e4SLinus Torvalds 6351da177e4SLinus Torvalds int kernel_recvmsg(struct socket *sock, struct msghdr *msg, 63689bddce5SStephen Hemminger struct kvec *vec, size_t num, size_t size, int flags) 6371da177e4SLinus Torvalds { 6381da177e4SLinus Torvalds mm_segment_t oldfs = get_fs(); 6391da177e4SLinus Torvalds int result; 6401da177e4SLinus Torvalds 6411da177e4SLinus Torvalds set_fs(KERNEL_DS); 6421da177e4SLinus Torvalds /* 6431da177e4SLinus Torvalds * the following is safe, since for compiler definitions of kvec and 6441da177e4SLinus Torvalds * iovec are identical, yielding the same in-core layout and alignment 6451da177e4SLinus Torvalds */ 64689bddce5SStephen Hemminger msg->msg_iov = (struct iovec *)vec, msg->msg_iovlen = num; 6471da177e4SLinus Torvalds result = sock_recvmsg(sock, msg, size, flags); 6481da177e4SLinus Torvalds set_fs(oldfs); 6491da177e4SLinus Torvalds return result; 6501da177e4SLinus Torvalds } 6511da177e4SLinus Torvalds 6521da177e4SLinus Torvalds static void sock_aio_dtor(struct kiocb *iocb) 6531da177e4SLinus Torvalds { 6541da177e4SLinus Torvalds kfree(iocb->private); 6551da177e4SLinus Torvalds } 6561da177e4SLinus Torvalds 65720380731SArnaldo Carvalho de Melo static ssize_t sock_sendpage(struct file *file, struct page *page, 6581da177e4SLinus Torvalds int offset, size_t size, loff_t *ppos, int more) 6591da177e4SLinus Torvalds { 6601da177e4SLinus Torvalds struct socket *sock; 6611da177e4SLinus Torvalds int flags; 6621da177e4SLinus Torvalds 663b69aee04SEric Dumazet sock = file->private_data; 6641da177e4SLinus Torvalds 6651da177e4SLinus Torvalds flags = !(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT; 6661da177e4SLinus Torvalds if (more) 6671da177e4SLinus Torvalds flags |= MSG_MORE; 6681da177e4SLinus Torvalds 6691da177e4SLinus Torvalds return sock->ops->sendpage(sock, page, offset, size, flags); 6701da177e4SLinus Torvalds } 6711da177e4SLinus Torvalds 672ce1d4d3eSChristoph Hellwig static struct sock_iocb *alloc_sock_iocb(struct kiocb *iocb, 67389bddce5SStephen Hemminger struct sock_iocb *siocb) 674ce1d4d3eSChristoph Hellwig { 675ce1d4d3eSChristoph Hellwig if (!is_sync_kiocb(iocb)) { 676ce1d4d3eSChristoph Hellwig siocb = kmalloc(sizeof(*siocb), GFP_KERNEL); 677ce1d4d3eSChristoph Hellwig if (!siocb) 678ce1d4d3eSChristoph Hellwig return NULL; 679ce1d4d3eSChristoph Hellwig iocb->ki_dtor = sock_aio_dtor; 680ce1d4d3eSChristoph Hellwig } 681ce1d4d3eSChristoph Hellwig 682ce1d4d3eSChristoph Hellwig siocb->kiocb = iocb; 683ce1d4d3eSChristoph Hellwig iocb->private = siocb; 684ce1d4d3eSChristoph Hellwig return siocb; 685ce1d4d3eSChristoph Hellwig } 686ce1d4d3eSChristoph Hellwig 687ce1d4d3eSChristoph Hellwig static ssize_t do_sock_read(struct msghdr *msg, struct kiocb *iocb, 688027445c3SBadari Pulavarty struct file *file, const struct iovec *iov, 68989bddce5SStephen Hemminger unsigned long nr_segs) 690ce1d4d3eSChristoph Hellwig { 691ce1d4d3eSChristoph Hellwig struct socket *sock = file->private_data; 692ce1d4d3eSChristoph Hellwig size_t size = 0; 693ce1d4d3eSChristoph Hellwig int i; 694ce1d4d3eSChristoph Hellwig 695ce1d4d3eSChristoph Hellwig for (i = 0; i < nr_segs; i++) 696ce1d4d3eSChristoph Hellwig size += iov[i].iov_len; 697ce1d4d3eSChristoph Hellwig 698ce1d4d3eSChristoph Hellwig msg->msg_name = NULL; 699ce1d4d3eSChristoph Hellwig msg->msg_namelen = 0; 700ce1d4d3eSChristoph Hellwig msg->msg_control = NULL; 701ce1d4d3eSChristoph Hellwig msg->msg_controllen = 0; 702ce1d4d3eSChristoph Hellwig msg->msg_iov = (struct iovec *)iov; 703ce1d4d3eSChristoph Hellwig msg->msg_iovlen = nr_segs; 704ce1d4d3eSChristoph Hellwig msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0; 705ce1d4d3eSChristoph Hellwig 706ce1d4d3eSChristoph Hellwig return __sock_recvmsg(iocb, sock, msg, size, msg->msg_flags); 707ce1d4d3eSChristoph Hellwig } 708ce1d4d3eSChristoph Hellwig 709027445c3SBadari Pulavarty static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov, 710027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos) 711ce1d4d3eSChristoph Hellwig { 712ce1d4d3eSChristoph Hellwig struct sock_iocb siocb, *x; 713ce1d4d3eSChristoph Hellwig 714ce1d4d3eSChristoph Hellwig if (pos != 0) 715ce1d4d3eSChristoph Hellwig return -ESPIPE; 716027445c3SBadari Pulavarty 717027445c3SBadari Pulavarty if (iocb->ki_left == 0) /* Match SYS5 behaviour */ 718ce1d4d3eSChristoph Hellwig return 0; 719ce1d4d3eSChristoph Hellwig 720027445c3SBadari Pulavarty 721027445c3SBadari Pulavarty x = alloc_sock_iocb(iocb, &siocb); 722ce1d4d3eSChristoph Hellwig if (!x) 723ce1d4d3eSChristoph Hellwig return -ENOMEM; 724027445c3SBadari Pulavarty return do_sock_read(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs); 725ce1d4d3eSChristoph Hellwig } 726ce1d4d3eSChristoph Hellwig 727ce1d4d3eSChristoph Hellwig static ssize_t do_sock_write(struct msghdr *msg, struct kiocb *iocb, 728027445c3SBadari Pulavarty struct file *file, const struct iovec *iov, 72989bddce5SStephen Hemminger unsigned long nr_segs) 730ce1d4d3eSChristoph Hellwig { 731ce1d4d3eSChristoph Hellwig struct socket *sock = file->private_data; 732ce1d4d3eSChristoph Hellwig size_t size = 0; 733ce1d4d3eSChristoph Hellwig int i; 734ce1d4d3eSChristoph Hellwig 735ce1d4d3eSChristoph Hellwig for (i = 0; i < nr_segs; i++) 736ce1d4d3eSChristoph Hellwig size += iov[i].iov_len; 737ce1d4d3eSChristoph Hellwig 738ce1d4d3eSChristoph Hellwig msg->msg_name = NULL; 739ce1d4d3eSChristoph Hellwig msg->msg_namelen = 0; 740ce1d4d3eSChristoph Hellwig msg->msg_control = NULL; 741ce1d4d3eSChristoph Hellwig msg->msg_controllen = 0; 742ce1d4d3eSChristoph Hellwig msg->msg_iov = (struct iovec *)iov; 743ce1d4d3eSChristoph Hellwig msg->msg_iovlen = nr_segs; 744ce1d4d3eSChristoph Hellwig msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0; 745ce1d4d3eSChristoph Hellwig if (sock->type == SOCK_SEQPACKET) 746ce1d4d3eSChristoph Hellwig msg->msg_flags |= MSG_EOR; 747ce1d4d3eSChristoph Hellwig 748ce1d4d3eSChristoph Hellwig return __sock_sendmsg(iocb, sock, msg, size); 749ce1d4d3eSChristoph Hellwig } 750ce1d4d3eSChristoph Hellwig 751027445c3SBadari Pulavarty static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov, 752027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos) 7531da177e4SLinus Torvalds { 754ce1d4d3eSChristoph Hellwig struct sock_iocb siocb, *x; 7551da177e4SLinus Torvalds 756ce1d4d3eSChristoph Hellwig if (pos != 0) 757ce1d4d3eSChristoph Hellwig return -ESPIPE; 758027445c3SBadari Pulavarty 759027445c3SBadari Pulavarty if (iocb->ki_left == 0) /* Match SYS5 behaviour */ 760ce1d4d3eSChristoph Hellwig return 0; 761ce1d4d3eSChristoph Hellwig 762027445c3SBadari Pulavarty x = alloc_sock_iocb(iocb, &siocb); 763ce1d4d3eSChristoph Hellwig if (!x) 764ce1d4d3eSChristoph Hellwig return -ENOMEM; 765ce1d4d3eSChristoph Hellwig 766027445c3SBadari Pulavarty return do_sock_write(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs); 7671da177e4SLinus Torvalds } 7681da177e4SLinus Torvalds 7691da177e4SLinus Torvalds /* 7701da177e4SLinus Torvalds * Atomic setting of ioctl hooks to avoid race 7711da177e4SLinus Torvalds * with module unload. 7721da177e4SLinus Torvalds */ 7731da177e4SLinus Torvalds 7744a3e2f71SArjan van de Ven static DEFINE_MUTEX(br_ioctl_mutex); 7751da177e4SLinus Torvalds static int (*br_ioctl_hook) (unsigned int cmd, void __user *arg) = NULL; 7761da177e4SLinus Torvalds 7771da177e4SLinus Torvalds void brioctl_set(int (*hook) (unsigned int, void __user *)) 7781da177e4SLinus Torvalds { 7794a3e2f71SArjan van de Ven mutex_lock(&br_ioctl_mutex); 7801da177e4SLinus Torvalds br_ioctl_hook = hook; 7814a3e2f71SArjan van de Ven mutex_unlock(&br_ioctl_mutex); 7821da177e4SLinus Torvalds } 78389bddce5SStephen Hemminger 7841da177e4SLinus Torvalds EXPORT_SYMBOL(brioctl_set); 7851da177e4SLinus Torvalds 7864a3e2f71SArjan van de Ven static DEFINE_MUTEX(vlan_ioctl_mutex); 7871da177e4SLinus Torvalds static int (*vlan_ioctl_hook) (void __user *arg); 7881da177e4SLinus Torvalds 7891da177e4SLinus Torvalds void vlan_ioctl_set(int (*hook) (void __user *)) 7901da177e4SLinus Torvalds { 7914a3e2f71SArjan van de Ven mutex_lock(&vlan_ioctl_mutex); 7921da177e4SLinus Torvalds vlan_ioctl_hook = hook; 7934a3e2f71SArjan van de Ven mutex_unlock(&vlan_ioctl_mutex); 7941da177e4SLinus Torvalds } 79589bddce5SStephen Hemminger 7961da177e4SLinus Torvalds EXPORT_SYMBOL(vlan_ioctl_set); 7971da177e4SLinus Torvalds 7984a3e2f71SArjan van de Ven static DEFINE_MUTEX(dlci_ioctl_mutex); 7991da177e4SLinus Torvalds static int (*dlci_ioctl_hook) (unsigned int, void __user *); 8001da177e4SLinus Torvalds 8011da177e4SLinus Torvalds void dlci_ioctl_set(int (*hook) (unsigned int, void __user *)) 8021da177e4SLinus Torvalds { 8034a3e2f71SArjan van de Ven mutex_lock(&dlci_ioctl_mutex); 8041da177e4SLinus Torvalds dlci_ioctl_hook = hook; 8054a3e2f71SArjan van de Ven mutex_unlock(&dlci_ioctl_mutex); 8061da177e4SLinus Torvalds } 80789bddce5SStephen Hemminger 8081da177e4SLinus Torvalds EXPORT_SYMBOL(dlci_ioctl_set); 8091da177e4SLinus Torvalds 8101da177e4SLinus Torvalds /* 8111da177e4SLinus Torvalds * With an ioctl, arg may well be a user mode pointer, but we don't know 8121da177e4SLinus Torvalds * what to do with it - that's up to the protocol still. 8131da177e4SLinus Torvalds */ 8141da177e4SLinus Torvalds 8151da177e4SLinus Torvalds static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg) 8161da177e4SLinus Torvalds { 8171da177e4SLinus Torvalds struct socket *sock; 8181da177e4SLinus Torvalds void __user *argp = (void __user *)arg; 8191da177e4SLinus Torvalds int pid, err; 8201da177e4SLinus Torvalds 821b69aee04SEric Dumazet sock = file->private_data; 8221da177e4SLinus Torvalds if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) { 8231da177e4SLinus Torvalds err = dev_ioctl(cmd, argp); 8241da177e4SLinus Torvalds } else 825d86b5e0eSAdrian Bunk #ifdef CONFIG_WIRELESS_EXT 8261da177e4SLinus Torvalds if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) { 8271da177e4SLinus Torvalds err = dev_ioctl(cmd, argp); 8281da177e4SLinus Torvalds } else 829d86b5e0eSAdrian Bunk #endif /* CONFIG_WIRELESS_EXT */ 8301da177e4SLinus Torvalds switch (cmd) { 8311da177e4SLinus Torvalds case FIOSETOWN: 8321da177e4SLinus Torvalds case SIOCSPGRP: 8331da177e4SLinus Torvalds err = -EFAULT; 8341da177e4SLinus Torvalds if (get_user(pid, (int __user *)argp)) 8351da177e4SLinus Torvalds break; 8361da177e4SLinus Torvalds err = f_setown(sock->file, pid, 1); 8371da177e4SLinus Torvalds break; 8381da177e4SLinus Torvalds case FIOGETOWN: 8391da177e4SLinus Torvalds case SIOCGPGRP: 840609d7fa9SEric W. Biederman err = put_user(f_getown(sock->file), 84189bddce5SStephen Hemminger (int __user *)argp); 8421da177e4SLinus Torvalds break; 8431da177e4SLinus Torvalds case SIOCGIFBR: 8441da177e4SLinus Torvalds case SIOCSIFBR: 8451da177e4SLinus Torvalds case SIOCBRADDBR: 8461da177e4SLinus Torvalds case SIOCBRDELBR: 8471da177e4SLinus Torvalds err = -ENOPKG; 8481da177e4SLinus Torvalds if (!br_ioctl_hook) 8491da177e4SLinus Torvalds request_module("bridge"); 8501da177e4SLinus Torvalds 8514a3e2f71SArjan van de Ven mutex_lock(&br_ioctl_mutex); 8521da177e4SLinus Torvalds if (br_ioctl_hook) 8531da177e4SLinus Torvalds err = br_ioctl_hook(cmd, argp); 8544a3e2f71SArjan van de Ven mutex_unlock(&br_ioctl_mutex); 8551da177e4SLinus Torvalds break; 8561da177e4SLinus Torvalds case SIOCGIFVLAN: 8571da177e4SLinus Torvalds case SIOCSIFVLAN: 8581da177e4SLinus Torvalds err = -ENOPKG; 8591da177e4SLinus Torvalds if (!vlan_ioctl_hook) 8601da177e4SLinus Torvalds request_module("8021q"); 8611da177e4SLinus Torvalds 8624a3e2f71SArjan van de Ven mutex_lock(&vlan_ioctl_mutex); 8631da177e4SLinus Torvalds if (vlan_ioctl_hook) 8641da177e4SLinus Torvalds err = vlan_ioctl_hook(argp); 8654a3e2f71SArjan van de Ven mutex_unlock(&vlan_ioctl_mutex); 8661da177e4SLinus Torvalds break; 8671da177e4SLinus Torvalds case SIOCADDDLCI: 8681da177e4SLinus Torvalds case SIOCDELDLCI: 8691da177e4SLinus Torvalds err = -ENOPKG; 8701da177e4SLinus Torvalds if (!dlci_ioctl_hook) 8711da177e4SLinus Torvalds request_module("dlci"); 8721da177e4SLinus Torvalds 8731da177e4SLinus Torvalds if (dlci_ioctl_hook) { 8744a3e2f71SArjan van de Ven mutex_lock(&dlci_ioctl_mutex); 8751da177e4SLinus Torvalds err = dlci_ioctl_hook(cmd, argp); 8764a3e2f71SArjan van de Ven mutex_unlock(&dlci_ioctl_mutex); 8771da177e4SLinus Torvalds } 8781da177e4SLinus Torvalds break; 8791da177e4SLinus Torvalds default: 8801da177e4SLinus Torvalds err = sock->ops->ioctl(sock, cmd, arg); 881b5e5fa5eSChristoph Hellwig 882b5e5fa5eSChristoph Hellwig /* 883b5e5fa5eSChristoph Hellwig * If this ioctl is unknown try to hand it down 884b5e5fa5eSChristoph Hellwig * to the NIC driver. 885b5e5fa5eSChristoph Hellwig */ 886b5e5fa5eSChristoph Hellwig if (err == -ENOIOCTLCMD) 887b5e5fa5eSChristoph Hellwig err = dev_ioctl(cmd, argp); 8881da177e4SLinus Torvalds break; 8891da177e4SLinus Torvalds } 8901da177e4SLinus Torvalds return err; 8911da177e4SLinus Torvalds } 8921da177e4SLinus Torvalds 8931da177e4SLinus Torvalds int sock_create_lite(int family, int type, int protocol, struct socket **res) 8941da177e4SLinus Torvalds { 8951da177e4SLinus Torvalds int err; 8961da177e4SLinus Torvalds struct socket *sock = NULL; 8971da177e4SLinus Torvalds 8981da177e4SLinus Torvalds err = security_socket_create(family, type, protocol, 1); 8991da177e4SLinus Torvalds if (err) 9001da177e4SLinus Torvalds goto out; 9011da177e4SLinus Torvalds 9021da177e4SLinus Torvalds sock = sock_alloc(); 9031da177e4SLinus Torvalds if (!sock) { 9041da177e4SLinus Torvalds err = -ENOMEM; 9051da177e4SLinus Torvalds goto out; 9061da177e4SLinus Torvalds } 9071da177e4SLinus Torvalds 9081da177e4SLinus Torvalds sock->type = type; 9097420ed23SVenkat Yekkirala err = security_socket_post_create(sock, family, type, protocol, 1); 9107420ed23SVenkat Yekkirala if (err) 9117420ed23SVenkat Yekkirala goto out_release; 9127420ed23SVenkat Yekkirala 9131da177e4SLinus Torvalds out: 9141da177e4SLinus Torvalds *res = sock; 9151da177e4SLinus Torvalds return err; 9167420ed23SVenkat Yekkirala out_release: 9177420ed23SVenkat Yekkirala sock_release(sock); 9187420ed23SVenkat Yekkirala sock = NULL; 9197420ed23SVenkat Yekkirala goto out; 9201da177e4SLinus Torvalds } 9211da177e4SLinus Torvalds 9221da177e4SLinus Torvalds /* No kernel lock held - perfect */ 9231da177e4SLinus Torvalds static unsigned int sock_poll(struct file *file, poll_table *wait) 9241da177e4SLinus Torvalds { 9251da177e4SLinus Torvalds struct socket *sock; 9261da177e4SLinus Torvalds 9271da177e4SLinus Torvalds /* 9281da177e4SLinus Torvalds * We can't return errors to poll, so it's either yes or no. 9291da177e4SLinus Torvalds */ 930b69aee04SEric Dumazet sock = file->private_data; 9311da177e4SLinus Torvalds return sock->ops->poll(file, sock, wait); 9321da177e4SLinus Torvalds } 9331da177e4SLinus Torvalds 9341da177e4SLinus Torvalds static int sock_mmap(struct file *file, struct vm_area_struct *vma) 9351da177e4SLinus Torvalds { 936b69aee04SEric Dumazet struct socket *sock = file->private_data; 9371da177e4SLinus Torvalds 9381da177e4SLinus Torvalds return sock->ops->mmap(file, sock, vma); 9391da177e4SLinus Torvalds } 9401da177e4SLinus Torvalds 94120380731SArnaldo Carvalho de Melo static int sock_close(struct inode *inode, struct file *filp) 9421da177e4SLinus Torvalds { 9431da177e4SLinus Torvalds /* 9441da177e4SLinus Torvalds * It was possible the inode is NULL we were 9451da177e4SLinus Torvalds * closing an unfinished socket. 9461da177e4SLinus Torvalds */ 9471da177e4SLinus Torvalds 94889bddce5SStephen Hemminger if (!inode) { 9491da177e4SLinus Torvalds printk(KERN_DEBUG "sock_close: NULL inode\n"); 9501da177e4SLinus Torvalds return 0; 9511da177e4SLinus Torvalds } 9521da177e4SLinus Torvalds sock_fasync(-1, filp, 0); 9531da177e4SLinus Torvalds sock_release(SOCKET_I(inode)); 9541da177e4SLinus Torvalds return 0; 9551da177e4SLinus Torvalds } 9561da177e4SLinus Torvalds 9571da177e4SLinus Torvalds /* 9581da177e4SLinus Torvalds * Update the socket async list 9591da177e4SLinus Torvalds * 9601da177e4SLinus Torvalds * Fasync_list locking strategy. 9611da177e4SLinus Torvalds * 9621da177e4SLinus Torvalds * 1. fasync_list is modified only under process context socket lock 9631da177e4SLinus Torvalds * i.e. under semaphore. 9641da177e4SLinus Torvalds * 2. fasync_list is used under read_lock(&sk->sk_callback_lock) 9651da177e4SLinus Torvalds * or under socket lock. 9661da177e4SLinus Torvalds * 3. fasync_list can be used from softirq context, so that 9671da177e4SLinus Torvalds * modification under socket lock have to be enhanced with 9681da177e4SLinus Torvalds * write_lock_bh(&sk->sk_callback_lock). 9691da177e4SLinus Torvalds * --ANK (990710) 9701da177e4SLinus Torvalds */ 9711da177e4SLinus Torvalds 9721da177e4SLinus Torvalds static int sock_fasync(int fd, struct file *filp, int on) 9731da177e4SLinus Torvalds { 9741da177e4SLinus Torvalds struct fasync_struct *fa, *fna = NULL, **prev; 9751da177e4SLinus Torvalds struct socket *sock; 9761da177e4SLinus Torvalds struct sock *sk; 9771da177e4SLinus Torvalds 97889bddce5SStephen Hemminger if (on) { 9798b3a7005SKris Katterjohn fna = kmalloc(sizeof(struct fasync_struct), GFP_KERNEL); 9801da177e4SLinus Torvalds if (fna == NULL) 9811da177e4SLinus Torvalds return -ENOMEM; 9821da177e4SLinus Torvalds } 9831da177e4SLinus Torvalds 984b69aee04SEric Dumazet sock = filp->private_data; 9851da177e4SLinus Torvalds 98689bddce5SStephen Hemminger sk = sock->sk; 98789bddce5SStephen Hemminger if (sk == NULL) { 9881da177e4SLinus Torvalds kfree(fna); 9891da177e4SLinus Torvalds return -EINVAL; 9901da177e4SLinus Torvalds } 9911da177e4SLinus Torvalds 9921da177e4SLinus Torvalds lock_sock(sk); 9931da177e4SLinus Torvalds 9941da177e4SLinus Torvalds prev = &(sock->fasync_list); 9951da177e4SLinus Torvalds 9961da177e4SLinus Torvalds for (fa = *prev; fa != NULL; prev = &fa->fa_next, fa = *prev) 9971da177e4SLinus Torvalds if (fa->fa_file == filp) 9981da177e4SLinus Torvalds break; 9991da177e4SLinus Torvalds 100089bddce5SStephen Hemminger if (on) { 100189bddce5SStephen Hemminger if (fa != NULL) { 10021da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 10031da177e4SLinus Torvalds fa->fa_fd = fd; 10041da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 10051da177e4SLinus Torvalds 10061da177e4SLinus Torvalds kfree(fna); 10071da177e4SLinus Torvalds goto out; 10081da177e4SLinus Torvalds } 10091da177e4SLinus Torvalds fna->fa_file = filp; 10101da177e4SLinus Torvalds fna->fa_fd = fd; 10111da177e4SLinus Torvalds fna->magic = FASYNC_MAGIC; 10121da177e4SLinus Torvalds fna->fa_next = sock->fasync_list; 10131da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 10141da177e4SLinus Torvalds sock->fasync_list = fna; 10151da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 101689bddce5SStephen Hemminger } else { 101789bddce5SStephen Hemminger if (fa != NULL) { 10181da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 10191da177e4SLinus Torvalds *prev = fa->fa_next; 10201da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 10211da177e4SLinus Torvalds kfree(fa); 10221da177e4SLinus Torvalds } 10231da177e4SLinus Torvalds } 10241da177e4SLinus Torvalds 10251da177e4SLinus Torvalds out: 10261da177e4SLinus Torvalds release_sock(sock->sk); 10271da177e4SLinus Torvalds return 0; 10281da177e4SLinus Torvalds } 10291da177e4SLinus Torvalds 10301da177e4SLinus Torvalds /* This function may be called only under socket lock or callback_lock */ 10311da177e4SLinus Torvalds 10321da177e4SLinus Torvalds int sock_wake_async(struct socket *sock, int how, int band) 10331da177e4SLinus Torvalds { 10341da177e4SLinus Torvalds if (!sock || !sock->fasync_list) 10351da177e4SLinus Torvalds return -1; 103689bddce5SStephen Hemminger switch (how) { 10371da177e4SLinus Torvalds case 1: 10381da177e4SLinus Torvalds 10391da177e4SLinus Torvalds if (test_bit(SOCK_ASYNC_WAITDATA, &sock->flags)) 10401da177e4SLinus Torvalds break; 10411da177e4SLinus Torvalds goto call_kill; 10421da177e4SLinus Torvalds case 2: 10431da177e4SLinus Torvalds if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags)) 10441da177e4SLinus Torvalds break; 10451da177e4SLinus Torvalds /* fall through */ 10461da177e4SLinus Torvalds case 0: 10471da177e4SLinus Torvalds call_kill: 10481da177e4SLinus Torvalds __kill_fasync(sock->fasync_list, SIGIO, band); 10491da177e4SLinus Torvalds break; 10501da177e4SLinus Torvalds case 3: 10511da177e4SLinus Torvalds __kill_fasync(sock->fasync_list, SIGURG, band); 10521da177e4SLinus Torvalds } 10531da177e4SLinus Torvalds return 0; 10541da177e4SLinus Torvalds } 10551da177e4SLinus Torvalds 105689bddce5SStephen Hemminger static int __sock_create(int family, int type, int protocol, 105789bddce5SStephen Hemminger struct socket **res, int kern) 10581da177e4SLinus Torvalds { 10591da177e4SLinus Torvalds int err; 10601da177e4SLinus Torvalds struct socket *sock; 106155737fdaSStephen Hemminger const struct net_proto_family *pf; 10621da177e4SLinus Torvalds 10631da177e4SLinus Torvalds /* 10641da177e4SLinus Torvalds * Check protocol is in range 10651da177e4SLinus Torvalds */ 10661da177e4SLinus Torvalds if (family < 0 || family >= NPROTO) 10671da177e4SLinus Torvalds return -EAFNOSUPPORT; 10681da177e4SLinus Torvalds if (type < 0 || type >= SOCK_MAX) 10691da177e4SLinus Torvalds return -EINVAL; 10701da177e4SLinus Torvalds 10711da177e4SLinus Torvalds /* Compatibility. 10721da177e4SLinus Torvalds 10731da177e4SLinus Torvalds This uglymoron is moved from INET layer to here to avoid 10741da177e4SLinus Torvalds deadlock in module load. 10751da177e4SLinus Torvalds */ 10761da177e4SLinus Torvalds if (family == PF_INET && type == SOCK_PACKET) { 10771da177e4SLinus Torvalds static int warned; 10781da177e4SLinus Torvalds if (!warned) { 10791da177e4SLinus Torvalds warned = 1; 108089bddce5SStephen Hemminger printk(KERN_INFO "%s uses obsolete (PF_INET,SOCK_PACKET)\n", 108189bddce5SStephen Hemminger current->comm); 10821da177e4SLinus Torvalds } 10831da177e4SLinus Torvalds family = PF_PACKET; 10841da177e4SLinus Torvalds } 10851da177e4SLinus Torvalds 10861da177e4SLinus Torvalds err = security_socket_create(family, type, protocol, kern); 10871da177e4SLinus Torvalds if (err) 10881da177e4SLinus Torvalds return err; 10891da177e4SLinus Torvalds 109055737fdaSStephen Hemminger /* 109155737fdaSStephen Hemminger * Allocate the socket and allow the family to set things up. if 109255737fdaSStephen Hemminger * the protocol is 0, the family is instructed to select an appropriate 109355737fdaSStephen Hemminger * default. 109455737fdaSStephen Hemminger */ 109555737fdaSStephen Hemminger sock = sock_alloc(); 109655737fdaSStephen Hemminger if (!sock) { 109755737fdaSStephen Hemminger if (net_ratelimit()) 109855737fdaSStephen Hemminger printk(KERN_WARNING "socket: no more sockets\n"); 109955737fdaSStephen Hemminger return -ENFILE; /* Not exactly a match, but its the 110055737fdaSStephen Hemminger closest posix thing */ 110155737fdaSStephen Hemminger } 110255737fdaSStephen Hemminger 110355737fdaSStephen Hemminger sock->type = type; 110455737fdaSStephen Hemminger 11051da177e4SLinus Torvalds #if defined(CONFIG_KMOD) 11061da177e4SLinus Torvalds /* Attempt to load a protocol module if the find failed. 11071da177e4SLinus Torvalds * 11081da177e4SLinus Torvalds * 12/09/1996 Marcin: But! this makes REALLY only sense, if the user 11091da177e4SLinus Torvalds * requested real, full-featured networking support upon configuration. 11101da177e4SLinus Torvalds * Otherwise module support will break! 11111da177e4SLinus Torvalds */ 111255737fdaSStephen Hemminger if (net_families[family] == NULL) 11131da177e4SLinus Torvalds request_module("net-pf-%d", family); 11141da177e4SLinus Torvalds #endif 11151da177e4SLinus Torvalds 111655737fdaSStephen Hemminger rcu_read_lock(); 111755737fdaSStephen Hemminger pf = rcu_dereference(net_families[family]); 11181da177e4SLinus Torvalds err = -EAFNOSUPPORT; 111955737fdaSStephen Hemminger if (!pf) 112055737fdaSStephen Hemminger goto out_release; 11211da177e4SLinus Torvalds 11221da177e4SLinus Torvalds /* 11231da177e4SLinus Torvalds * We will call the ->create function, that possibly is in a loadable 11241da177e4SLinus Torvalds * module, so we have to bump that loadable module refcnt first. 11251da177e4SLinus Torvalds */ 112655737fdaSStephen Hemminger if (!try_module_get(pf->owner)) 11271da177e4SLinus Torvalds goto out_release; 11281da177e4SLinus Torvalds 112955737fdaSStephen Hemminger /* Now protected by module ref count */ 113055737fdaSStephen Hemminger rcu_read_unlock(); 113155737fdaSStephen Hemminger 113255737fdaSStephen Hemminger err = pf->create(sock, protocol); 113355737fdaSStephen Hemminger if (err < 0) 11341da177e4SLinus Torvalds goto out_module_put; 1135a79af59eSFrank Filz 11361da177e4SLinus Torvalds /* 11371da177e4SLinus Torvalds * Now to bump the refcnt of the [loadable] module that owns this 11381da177e4SLinus Torvalds * socket at sock_release time we decrement its refcnt. 11391da177e4SLinus Torvalds */ 114055737fdaSStephen Hemminger if (!try_module_get(sock->ops->owner)) 114155737fdaSStephen Hemminger goto out_module_busy; 114255737fdaSStephen Hemminger 11431da177e4SLinus Torvalds /* 11441da177e4SLinus Torvalds * Now that we're done with the ->create function, the [loadable] 11451da177e4SLinus Torvalds * module can have its refcnt decremented 11461da177e4SLinus Torvalds */ 114755737fdaSStephen Hemminger module_put(pf->owner); 11487420ed23SVenkat Yekkirala err = security_socket_post_create(sock, family, type, protocol, kern); 11497420ed23SVenkat Yekkirala if (err) 11507420ed23SVenkat Yekkirala goto out_release; 115155737fdaSStephen Hemminger *res = sock; 11521da177e4SLinus Torvalds 115355737fdaSStephen Hemminger return 0; 115455737fdaSStephen Hemminger 115555737fdaSStephen Hemminger out_module_busy: 115655737fdaSStephen Hemminger err = -EAFNOSUPPORT; 11571da177e4SLinus Torvalds out_module_put: 115855737fdaSStephen Hemminger sock->ops = NULL; 115955737fdaSStephen Hemminger module_put(pf->owner); 116055737fdaSStephen Hemminger out_sock_release: 11611da177e4SLinus Torvalds sock_release(sock); 116255737fdaSStephen Hemminger return err; 116355737fdaSStephen Hemminger 116455737fdaSStephen Hemminger out_release: 116555737fdaSStephen Hemminger rcu_read_unlock(); 116655737fdaSStephen Hemminger goto out_sock_release; 11671da177e4SLinus Torvalds } 11681da177e4SLinus Torvalds 11691da177e4SLinus Torvalds int sock_create(int family, int type, int protocol, struct socket **res) 11701da177e4SLinus Torvalds { 11711da177e4SLinus Torvalds return __sock_create(family, type, protocol, res, 0); 11721da177e4SLinus Torvalds } 11731da177e4SLinus Torvalds 11741da177e4SLinus Torvalds int sock_create_kern(int family, int type, int protocol, struct socket **res) 11751da177e4SLinus Torvalds { 11761da177e4SLinus Torvalds return __sock_create(family, type, protocol, res, 1); 11771da177e4SLinus Torvalds } 11781da177e4SLinus Torvalds 11791da177e4SLinus Torvalds asmlinkage long sys_socket(int family, int type, int protocol) 11801da177e4SLinus Torvalds { 11811da177e4SLinus Torvalds int retval; 11821da177e4SLinus Torvalds struct socket *sock; 11831da177e4SLinus Torvalds 11841da177e4SLinus Torvalds retval = sock_create(family, type, protocol, &sock); 11851da177e4SLinus Torvalds if (retval < 0) 11861da177e4SLinus Torvalds goto out; 11871da177e4SLinus Torvalds 11881da177e4SLinus Torvalds retval = sock_map_fd(sock); 11891da177e4SLinus Torvalds if (retval < 0) 11901da177e4SLinus Torvalds goto out_release; 11911da177e4SLinus Torvalds 11921da177e4SLinus Torvalds out: 11931da177e4SLinus Torvalds /* It may be already another descriptor 8) Not kernel problem. */ 11941da177e4SLinus Torvalds return retval; 11951da177e4SLinus Torvalds 11961da177e4SLinus Torvalds out_release: 11971da177e4SLinus Torvalds sock_release(sock); 11981da177e4SLinus Torvalds return retval; 11991da177e4SLinus Torvalds } 12001da177e4SLinus Torvalds 12011da177e4SLinus Torvalds /* 12021da177e4SLinus Torvalds * Create a pair of connected sockets. 12031da177e4SLinus Torvalds */ 12041da177e4SLinus Torvalds 120589bddce5SStephen Hemminger asmlinkage long sys_socketpair(int family, int type, int protocol, 120689bddce5SStephen Hemminger int __user *usockvec) 12071da177e4SLinus Torvalds { 12081da177e4SLinus Torvalds struct socket *sock1, *sock2; 12091da177e4SLinus Torvalds int fd1, fd2, err; 12101da177e4SLinus Torvalds 12111da177e4SLinus Torvalds /* 12121da177e4SLinus Torvalds * Obtain the first socket and check if the underlying protocol 12131da177e4SLinus Torvalds * supports the socketpair call. 12141da177e4SLinus Torvalds */ 12151da177e4SLinus Torvalds 12161da177e4SLinus Torvalds err = sock_create(family, type, protocol, &sock1); 12171da177e4SLinus Torvalds if (err < 0) 12181da177e4SLinus Torvalds goto out; 12191da177e4SLinus Torvalds 12201da177e4SLinus Torvalds err = sock_create(family, type, protocol, &sock2); 12211da177e4SLinus Torvalds if (err < 0) 12221da177e4SLinus Torvalds goto out_release_1; 12231da177e4SLinus Torvalds 12241da177e4SLinus Torvalds err = sock1->ops->socketpair(sock1, sock2); 12251da177e4SLinus Torvalds if (err < 0) 12261da177e4SLinus Torvalds goto out_release_both; 12271da177e4SLinus Torvalds 12281da177e4SLinus Torvalds fd1 = fd2 = -1; 12291da177e4SLinus Torvalds 12301da177e4SLinus Torvalds err = sock_map_fd(sock1); 12311da177e4SLinus Torvalds if (err < 0) 12321da177e4SLinus Torvalds goto out_release_both; 12331da177e4SLinus Torvalds fd1 = err; 12341da177e4SLinus Torvalds 12351da177e4SLinus Torvalds err = sock_map_fd(sock2); 12361da177e4SLinus Torvalds if (err < 0) 12371da177e4SLinus Torvalds goto out_close_1; 12381da177e4SLinus Torvalds fd2 = err; 12391da177e4SLinus Torvalds 12401da177e4SLinus Torvalds /* fd1 and fd2 may be already another descriptors. 12411da177e4SLinus Torvalds * Not kernel problem. 12421da177e4SLinus Torvalds */ 12431da177e4SLinus Torvalds 12441da177e4SLinus Torvalds err = put_user(fd1, &usockvec[0]); 12451da177e4SLinus Torvalds if (!err) 12461da177e4SLinus Torvalds err = put_user(fd2, &usockvec[1]); 12471da177e4SLinus Torvalds if (!err) 12481da177e4SLinus Torvalds return 0; 12491da177e4SLinus Torvalds 12501da177e4SLinus Torvalds sys_close(fd2); 12511da177e4SLinus Torvalds sys_close(fd1); 12521da177e4SLinus Torvalds return err; 12531da177e4SLinus Torvalds 12541da177e4SLinus Torvalds out_close_1: 12551da177e4SLinus Torvalds sock_release(sock2); 12561da177e4SLinus Torvalds sys_close(fd1); 12571da177e4SLinus Torvalds return err; 12581da177e4SLinus Torvalds 12591da177e4SLinus Torvalds out_release_both: 12601da177e4SLinus Torvalds sock_release(sock2); 12611da177e4SLinus Torvalds out_release_1: 12621da177e4SLinus Torvalds sock_release(sock1); 12631da177e4SLinus Torvalds out: 12641da177e4SLinus Torvalds return err; 12651da177e4SLinus Torvalds } 12661da177e4SLinus Torvalds 12671da177e4SLinus Torvalds /* 12681da177e4SLinus Torvalds * Bind a name to a socket. Nothing much to do here since it's 12691da177e4SLinus Torvalds * the protocol's responsibility to handle the local address. 12701da177e4SLinus Torvalds * 12711da177e4SLinus Torvalds * We move the socket address to kernel space before we call 12721da177e4SLinus Torvalds * the protocol layer (having also checked the address is ok). 12731da177e4SLinus Torvalds */ 12741da177e4SLinus Torvalds 12751da177e4SLinus Torvalds asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen) 12761da177e4SLinus Torvalds { 12771da177e4SLinus Torvalds struct socket *sock; 12781da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 12796cb153caSBenjamin LaHaise int err, fput_needed; 12801da177e4SLinus Torvalds 128189bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 128289bddce5SStephen Hemminger if(sock) { 128389bddce5SStephen Hemminger err = move_addr_to_kernel(umyaddr, addrlen, address); 128489bddce5SStephen Hemminger if (err >= 0) { 128589bddce5SStephen Hemminger err = security_socket_bind(sock, 128689bddce5SStephen Hemminger (struct sockaddr *)address, 128789bddce5SStephen Hemminger addrlen); 12886cb153caSBenjamin LaHaise if (!err) 12896cb153caSBenjamin LaHaise err = sock->ops->bind(sock, 129089bddce5SStephen Hemminger (struct sockaddr *) 129189bddce5SStephen Hemminger address, addrlen); 12921da177e4SLinus Torvalds } 12936cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 12941da177e4SLinus Torvalds } 12951da177e4SLinus Torvalds return err; 12961da177e4SLinus Torvalds } 12971da177e4SLinus Torvalds 12981da177e4SLinus Torvalds /* 12991da177e4SLinus Torvalds * Perform a listen. Basically, we allow the protocol to do anything 13001da177e4SLinus Torvalds * necessary for a listen, and if that works, we mark the socket as 13011da177e4SLinus Torvalds * ready for listening. 13021da177e4SLinus Torvalds */ 13031da177e4SLinus Torvalds 13047a42c217SBrian Haley int sysctl_somaxconn __read_mostly = SOMAXCONN; 13051da177e4SLinus Torvalds 13061da177e4SLinus Torvalds asmlinkage long sys_listen(int fd, int backlog) 13071da177e4SLinus Torvalds { 13081da177e4SLinus Torvalds struct socket *sock; 13096cb153caSBenjamin LaHaise int err, fput_needed; 13101da177e4SLinus Torvalds 131189bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 131289bddce5SStephen Hemminger if (sock) { 13131da177e4SLinus Torvalds if ((unsigned)backlog > sysctl_somaxconn) 13141da177e4SLinus Torvalds backlog = sysctl_somaxconn; 13151da177e4SLinus Torvalds 13161da177e4SLinus Torvalds err = security_socket_listen(sock, backlog); 13176cb153caSBenjamin LaHaise if (!err) 13181da177e4SLinus Torvalds err = sock->ops->listen(sock, backlog); 13196cb153caSBenjamin LaHaise 13206cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 13211da177e4SLinus Torvalds } 13221da177e4SLinus Torvalds return err; 13231da177e4SLinus Torvalds } 13241da177e4SLinus Torvalds 13251da177e4SLinus Torvalds /* 13261da177e4SLinus Torvalds * For accept, we attempt to create a new socket, set up the link 13271da177e4SLinus Torvalds * with the client, wake up the client, then return the new 13281da177e4SLinus Torvalds * connected fd. We collect the address of the connector in kernel 13291da177e4SLinus Torvalds * space and move it to user at the very end. This is unclean because 13301da177e4SLinus Torvalds * we open the socket then return an error. 13311da177e4SLinus Torvalds * 13321da177e4SLinus Torvalds * 1003.1g adds the ability to recvmsg() to query connection pending 13331da177e4SLinus Torvalds * status to recvmsg. We need to add that support in a way thats 13341da177e4SLinus Torvalds * clean when we restucture accept also. 13351da177e4SLinus Torvalds */ 13361da177e4SLinus Torvalds 133789bddce5SStephen Hemminger asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr, 133889bddce5SStephen Hemminger int __user *upeer_addrlen) 13391da177e4SLinus Torvalds { 13401da177e4SLinus Torvalds struct socket *sock, *newsock; 134139d8c1b6SDavid S. Miller struct file *newfile; 13426cb153caSBenjamin LaHaise int err, len, newfd, fput_needed; 13431da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 13441da177e4SLinus Torvalds 13456cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 13461da177e4SLinus Torvalds if (!sock) 13471da177e4SLinus Torvalds goto out; 13481da177e4SLinus Torvalds 13491da177e4SLinus Torvalds err = -ENFILE; 13501da177e4SLinus Torvalds if (!(newsock = sock_alloc())) 13511da177e4SLinus Torvalds goto out_put; 13521da177e4SLinus Torvalds 13531da177e4SLinus Torvalds newsock->type = sock->type; 13541da177e4SLinus Torvalds newsock->ops = sock->ops; 13551da177e4SLinus Torvalds 13561da177e4SLinus Torvalds /* 13571da177e4SLinus Torvalds * We don't need try_module_get here, as the listening socket (sock) 13581da177e4SLinus Torvalds * has the protocol module (sock->ops->owner) held. 13591da177e4SLinus Torvalds */ 13601da177e4SLinus Torvalds __module_get(newsock->ops->owner); 13611da177e4SLinus Torvalds 136239d8c1b6SDavid S. Miller newfd = sock_alloc_fd(&newfile); 136339d8c1b6SDavid S. Miller if (unlikely(newfd < 0)) { 136439d8c1b6SDavid S. Miller err = newfd; 13659a1875e6SDavid S. Miller sock_release(newsock); 13669a1875e6SDavid S. Miller goto out_put; 136739d8c1b6SDavid S. Miller } 136839d8c1b6SDavid S. Miller 136939d8c1b6SDavid S. Miller err = sock_attach_fd(newsock, newfile); 137039d8c1b6SDavid S. Miller if (err < 0) 137139d8c1b6SDavid S. Miller goto out_fd; 137239d8c1b6SDavid S. Miller 1373a79af59eSFrank Filz err = security_socket_accept(sock, newsock); 1374a79af59eSFrank Filz if (err) 137539d8c1b6SDavid S. Miller goto out_fd; 1376a79af59eSFrank Filz 13771da177e4SLinus Torvalds err = sock->ops->accept(sock, newsock, sock->file->f_flags); 13781da177e4SLinus Torvalds if (err < 0) 137939d8c1b6SDavid S. Miller goto out_fd; 13801da177e4SLinus Torvalds 13811da177e4SLinus Torvalds if (upeer_sockaddr) { 138289bddce5SStephen Hemminger if (newsock->ops->getname(newsock, (struct sockaddr *)address, 138389bddce5SStephen Hemminger &len, 2) < 0) { 13841da177e4SLinus Torvalds err = -ECONNABORTED; 138539d8c1b6SDavid S. Miller goto out_fd; 13861da177e4SLinus Torvalds } 138789bddce5SStephen Hemminger err = move_addr_to_user(address, len, upeer_sockaddr, 138889bddce5SStephen Hemminger upeer_addrlen); 13891da177e4SLinus Torvalds if (err < 0) 139039d8c1b6SDavid S. Miller goto out_fd; 13911da177e4SLinus Torvalds } 13921da177e4SLinus Torvalds 13931da177e4SLinus Torvalds /* File flags are not inherited via accept() unlike another OSes. */ 13941da177e4SLinus Torvalds 139539d8c1b6SDavid S. Miller fd_install(newfd, newfile); 139639d8c1b6SDavid S. Miller err = newfd; 13971da177e4SLinus Torvalds 13981da177e4SLinus Torvalds security_socket_post_accept(sock, newsock); 13991da177e4SLinus Torvalds 14001da177e4SLinus Torvalds out_put: 14016cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 14021da177e4SLinus Torvalds out: 14031da177e4SLinus Torvalds return err; 140439d8c1b6SDavid S. Miller out_fd: 14059606a216SDavid S. Miller fput(newfile); 140639d8c1b6SDavid S. Miller put_unused_fd(newfd); 14071da177e4SLinus Torvalds goto out_put; 14081da177e4SLinus Torvalds } 14091da177e4SLinus Torvalds 14101da177e4SLinus Torvalds /* 14111da177e4SLinus Torvalds * Attempt to connect to a socket with the server address. The address 14121da177e4SLinus Torvalds * is in user space so we verify it is OK and move it to kernel space. 14131da177e4SLinus Torvalds * 14141da177e4SLinus Torvalds * For 1003.1g we need to add clean support for a bind to AF_UNSPEC to 14151da177e4SLinus Torvalds * break bindings 14161da177e4SLinus Torvalds * 14171da177e4SLinus Torvalds * NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and 14181da177e4SLinus Torvalds * other SEQPACKET protocols that take time to connect() as it doesn't 14191da177e4SLinus Torvalds * include the -EINPROGRESS status for such sockets. 14201da177e4SLinus Torvalds */ 14211da177e4SLinus Torvalds 142289bddce5SStephen Hemminger asmlinkage long sys_connect(int fd, struct sockaddr __user *uservaddr, 142389bddce5SStephen Hemminger int addrlen) 14241da177e4SLinus Torvalds { 14251da177e4SLinus Torvalds struct socket *sock; 14261da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 14276cb153caSBenjamin LaHaise int err, fput_needed; 14281da177e4SLinus Torvalds 14296cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 14301da177e4SLinus Torvalds if (!sock) 14311da177e4SLinus Torvalds goto out; 14321da177e4SLinus Torvalds err = move_addr_to_kernel(uservaddr, addrlen, address); 14331da177e4SLinus Torvalds if (err < 0) 14341da177e4SLinus Torvalds goto out_put; 14351da177e4SLinus Torvalds 143689bddce5SStephen Hemminger err = 143789bddce5SStephen Hemminger security_socket_connect(sock, (struct sockaddr *)address, addrlen); 14381da177e4SLinus Torvalds if (err) 14391da177e4SLinus Torvalds goto out_put; 14401da177e4SLinus Torvalds 14411da177e4SLinus Torvalds err = sock->ops->connect(sock, (struct sockaddr *)address, addrlen, 14421da177e4SLinus Torvalds sock->file->f_flags); 14431da177e4SLinus Torvalds out_put: 14446cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 14451da177e4SLinus Torvalds out: 14461da177e4SLinus Torvalds return err; 14471da177e4SLinus Torvalds } 14481da177e4SLinus Torvalds 14491da177e4SLinus Torvalds /* 14501da177e4SLinus Torvalds * Get the local address ('name') of a socket object. Move the obtained 14511da177e4SLinus Torvalds * name to user space. 14521da177e4SLinus Torvalds */ 14531da177e4SLinus Torvalds 145489bddce5SStephen Hemminger asmlinkage long sys_getsockname(int fd, struct sockaddr __user *usockaddr, 145589bddce5SStephen Hemminger int __user *usockaddr_len) 14561da177e4SLinus Torvalds { 14571da177e4SLinus Torvalds struct socket *sock; 14581da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 14596cb153caSBenjamin LaHaise int len, err, fput_needed; 14601da177e4SLinus Torvalds 14616cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 14621da177e4SLinus Torvalds if (!sock) 14631da177e4SLinus Torvalds goto out; 14641da177e4SLinus Torvalds 14651da177e4SLinus Torvalds err = security_socket_getsockname(sock); 14661da177e4SLinus Torvalds if (err) 14671da177e4SLinus Torvalds goto out_put; 14681da177e4SLinus Torvalds 14691da177e4SLinus Torvalds err = sock->ops->getname(sock, (struct sockaddr *)address, &len, 0); 14701da177e4SLinus Torvalds if (err) 14711da177e4SLinus Torvalds goto out_put; 14721da177e4SLinus Torvalds err = move_addr_to_user(address, len, usockaddr, usockaddr_len); 14731da177e4SLinus Torvalds 14741da177e4SLinus Torvalds out_put: 14756cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 14761da177e4SLinus Torvalds out: 14771da177e4SLinus Torvalds return err; 14781da177e4SLinus Torvalds } 14791da177e4SLinus Torvalds 14801da177e4SLinus Torvalds /* 14811da177e4SLinus Torvalds * Get the remote address ('name') of a socket object. Move the obtained 14821da177e4SLinus Torvalds * name to user space. 14831da177e4SLinus Torvalds */ 14841da177e4SLinus Torvalds 148589bddce5SStephen Hemminger asmlinkage long sys_getpeername(int fd, struct sockaddr __user *usockaddr, 148689bddce5SStephen Hemminger int __user *usockaddr_len) 14871da177e4SLinus Torvalds { 14881da177e4SLinus Torvalds struct socket *sock; 14891da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 14906cb153caSBenjamin LaHaise int len, err, fput_needed; 14911da177e4SLinus Torvalds 149289bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 149389bddce5SStephen Hemminger if (sock != NULL) { 14941da177e4SLinus Torvalds err = security_socket_getpeername(sock); 14951da177e4SLinus Torvalds if (err) { 14966cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 14971da177e4SLinus Torvalds return err; 14981da177e4SLinus Torvalds } 14991da177e4SLinus Torvalds 150089bddce5SStephen Hemminger err = 150189bddce5SStephen Hemminger sock->ops->getname(sock, (struct sockaddr *)address, &len, 150289bddce5SStephen Hemminger 1); 15031da177e4SLinus Torvalds if (!err) 150489bddce5SStephen Hemminger err = move_addr_to_user(address, len, usockaddr, 150589bddce5SStephen Hemminger usockaddr_len); 15066cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 15071da177e4SLinus Torvalds } 15081da177e4SLinus Torvalds return err; 15091da177e4SLinus Torvalds } 15101da177e4SLinus Torvalds 15111da177e4SLinus Torvalds /* 15121da177e4SLinus Torvalds * Send a datagram to a given address. We move the address into kernel 15131da177e4SLinus Torvalds * space and check the user space data area is readable before invoking 15141da177e4SLinus Torvalds * the protocol. 15151da177e4SLinus Torvalds */ 15161da177e4SLinus Torvalds 151789bddce5SStephen Hemminger asmlinkage long sys_sendto(int fd, void __user *buff, size_t len, 151889bddce5SStephen Hemminger unsigned flags, struct sockaddr __user *addr, 151989bddce5SStephen Hemminger int addr_len) 15201da177e4SLinus Torvalds { 15211da177e4SLinus Torvalds struct socket *sock; 15221da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 15231da177e4SLinus Torvalds int err; 15241da177e4SLinus Torvalds struct msghdr msg; 15251da177e4SLinus Torvalds struct iovec iov; 15266cb153caSBenjamin LaHaise int fput_needed; 15276cb153caSBenjamin LaHaise struct file *sock_file; 15281da177e4SLinus Torvalds 15296cb153caSBenjamin LaHaise sock_file = fget_light(fd, &fput_needed); 15306cb153caSBenjamin LaHaise if (!sock_file) 15316cb153caSBenjamin LaHaise return -EBADF; 15326cb153caSBenjamin LaHaise 15336cb153caSBenjamin LaHaise sock = sock_from_file(sock_file, &err); 15341da177e4SLinus Torvalds if (!sock) 15356cb153caSBenjamin LaHaise goto out_put; 15361da177e4SLinus Torvalds iov.iov_base = buff; 15371da177e4SLinus Torvalds iov.iov_len = len; 15381da177e4SLinus Torvalds msg.msg_name = NULL; 15391da177e4SLinus Torvalds msg.msg_iov = &iov; 15401da177e4SLinus Torvalds msg.msg_iovlen = 1; 15411da177e4SLinus Torvalds msg.msg_control = NULL; 15421da177e4SLinus Torvalds msg.msg_controllen = 0; 15431da177e4SLinus Torvalds msg.msg_namelen = 0; 15446cb153caSBenjamin LaHaise if (addr) { 15451da177e4SLinus Torvalds err = move_addr_to_kernel(addr, addr_len, address); 15461da177e4SLinus Torvalds if (err < 0) 15471da177e4SLinus Torvalds goto out_put; 15481da177e4SLinus Torvalds msg.msg_name = address; 15491da177e4SLinus Torvalds msg.msg_namelen = addr_len; 15501da177e4SLinus Torvalds } 15511da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 15521da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 15531da177e4SLinus Torvalds msg.msg_flags = flags; 15541da177e4SLinus Torvalds err = sock_sendmsg(sock, &msg, len); 15551da177e4SLinus Torvalds 15561da177e4SLinus Torvalds out_put: 15576cb153caSBenjamin LaHaise fput_light(sock_file, fput_needed); 15581da177e4SLinus Torvalds return err; 15591da177e4SLinus Torvalds } 15601da177e4SLinus Torvalds 15611da177e4SLinus Torvalds /* 15621da177e4SLinus Torvalds * Send a datagram down a socket. 15631da177e4SLinus Torvalds */ 15641da177e4SLinus Torvalds 15651da177e4SLinus Torvalds asmlinkage long sys_send(int fd, void __user *buff, size_t len, unsigned flags) 15661da177e4SLinus Torvalds { 15671da177e4SLinus Torvalds return sys_sendto(fd, buff, len, flags, NULL, 0); 15681da177e4SLinus Torvalds } 15691da177e4SLinus Torvalds 15701da177e4SLinus Torvalds /* 15711da177e4SLinus Torvalds * Receive a frame from the socket and optionally record the address of the 15721da177e4SLinus Torvalds * sender. We verify the buffers are writable and if needed move the 15731da177e4SLinus Torvalds * sender address from kernel to user space. 15741da177e4SLinus Torvalds */ 15751da177e4SLinus Torvalds 157689bddce5SStephen Hemminger asmlinkage long sys_recvfrom(int fd, void __user *ubuf, size_t size, 157789bddce5SStephen Hemminger unsigned flags, struct sockaddr __user *addr, 157889bddce5SStephen Hemminger int __user *addr_len) 15791da177e4SLinus Torvalds { 15801da177e4SLinus Torvalds struct socket *sock; 15811da177e4SLinus Torvalds struct iovec iov; 15821da177e4SLinus Torvalds struct msghdr msg; 15831da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 15841da177e4SLinus Torvalds int err, err2; 15856cb153caSBenjamin LaHaise struct file *sock_file; 15866cb153caSBenjamin LaHaise int fput_needed; 15871da177e4SLinus Torvalds 15886cb153caSBenjamin LaHaise sock_file = fget_light(fd, &fput_needed); 15896cb153caSBenjamin LaHaise if (!sock_file) 15906cb153caSBenjamin LaHaise return -EBADF; 15916cb153caSBenjamin LaHaise 15926cb153caSBenjamin LaHaise sock = sock_from_file(sock_file, &err); 15931da177e4SLinus Torvalds if (!sock) 15941da177e4SLinus Torvalds goto out; 15951da177e4SLinus Torvalds 15961da177e4SLinus Torvalds msg.msg_control = NULL; 15971da177e4SLinus Torvalds msg.msg_controllen = 0; 15981da177e4SLinus Torvalds msg.msg_iovlen = 1; 15991da177e4SLinus Torvalds msg.msg_iov = &iov; 16001da177e4SLinus Torvalds iov.iov_len = size; 16011da177e4SLinus Torvalds iov.iov_base = ubuf; 16021da177e4SLinus Torvalds msg.msg_name = address; 16031da177e4SLinus Torvalds msg.msg_namelen = MAX_SOCK_ADDR; 16041da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 16051da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 16061da177e4SLinus Torvalds err = sock_recvmsg(sock, &msg, size, flags); 16071da177e4SLinus Torvalds 160889bddce5SStephen Hemminger if (err >= 0 && addr != NULL) { 16091da177e4SLinus Torvalds err2 = move_addr_to_user(address, msg.msg_namelen, addr, addr_len); 16101da177e4SLinus Torvalds if (err2 < 0) 16111da177e4SLinus Torvalds err = err2; 16121da177e4SLinus Torvalds } 16131da177e4SLinus Torvalds out: 16146cb153caSBenjamin LaHaise fput_light(sock_file, fput_needed); 16151da177e4SLinus Torvalds return err; 16161da177e4SLinus Torvalds } 16171da177e4SLinus Torvalds 16181da177e4SLinus Torvalds /* 16191da177e4SLinus Torvalds * Receive a datagram from a socket. 16201da177e4SLinus Torvalds */ 16211da177e4SLinus Torvalds 162289bddce5SStephen Hemminger asmlinkage long sys_recv(int fd, void __user *ubuf, size_t size, 162389bddce5SStephen Hemminger unsigned flags) 16241da177e4SLinus Torvalds { 16251da177e4SLinus Torvalds return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL); 16261da177e4SLinus Torvalds } 16271da177e4SLinus Torvalds 16281da177e4SLinus Torvalds /* 16291da177e4SLinus Torvalds * Set a socket option. Because we don't know the option lengths we have 16301da177e4SLinus Torvalds * to pass the user mode parameter for the protocols to sort out. 16311da177e4SLinus Torvalds */ 16321da177e4SLinus Torvalds 163389bddce5SStephen Hemminger asmlinkage long sys_setsockopt(int fd, int level, int optname, 163489bddce5SStephen Hemminger char __user *optval, int optlen) 16351da177e4SLinus Torvalds { 16366cb153caSBenjamin LaHaise int err, fput_needed; 16371da177e4SLinus Torvalds struct socket *sock; 16381da177e4SLinus Torvalds 16391da177e4SLinus Torvalds if (optlen < 0) 16401da177e4SLinus Torvalds return -EINVAL; 16411da177e4SLinus Torvalds 164289bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 164389bddce5SStephen Hemminger if (sock != NULL) { 16441da177e4SLinus Torvalds err = security_socket_setsockopt(sock, level, optname); 16456cb153caSBenjamin LaHaise if (err) 16466cb153caSBenjamin LaHaise goto out_put; 16471da177e4SLinus Torvalds 16481da177e4SLinus Torvalds if (level == SOL_SOCKET) 164989bddce5SStephen Hemminger err = 165089bddce5SStephen Hemminger sock_setsockopt(sock, level, optname, optval, 165189bddce5SStephen Hemminger optlen); 16521da177e4SLinus Torvalds else 165389bddce5SStephen Hemminger err = 165489bddce5SStephen Hemminger sock->ops->setsockopt(sock, level, optname, optval, 165589bddce5SStephen Hemminger optlen); 16566cb153caSBenjamin LaHaise out_put: 16576cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 16581da177e4SLinus Torvalds } 16591da177e4SLinus Torvalds return err; 16601da177e4SLinus Torvalds } 16611da177e4SLinus Torvalds 16621da177e4SLinus Torvalds /* 16631da177e4SLinus Torvalds * Get a socket option. Because we don't know the option lengths we have 16641da177e4SLinus Torvalds * to pass a user mode parameter for the protocols to sort out. 16651da177e4SLinus Torvalds */ 16661da177e4SLinus Torvalds 166789bddce5SStephen Hemminger asmlinkage long sys_getsockopt(int fd, int level, int optname, 166889bddce5SStephen Hemminger char __user *optval, int __user *optlen) 16691da177e4SLinus Torvalds { 16706cb153caSBenjamin LaHaise int err, fput_needed; 16711da177e4SLinus Torvalds struct socket *sock; 16721da177e4SLinus Torvalds 167389bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 167489bddce5SStephen Hemminger if (sock != NULL) { 16756cb153caSBenjamin LaHaise err = security_socket_getsockopt(sock, level, optname); 16766cb153caSBenjamin LaHaise if (err) 16776cb153caSBenjamin LaHaise goto out_put; 16781da177e4SLinus Torvalds 16791da177e4SLinus Torvalds if (level == SOL_SOCKET) 168089bddce5SStephen Hemminger err = 168189bddce5SStephen Hemminger sock_getsockopt(sock, level, optname, optval, 168289bddce5SStephen Hemminger optlen); 16831da177e4SLinus Torvalds else 168489bddce5SStephen Hemminger err = 168589bddce5SStephen Hemminger sock->ops->getsockopt(sock, level, optname, optval, 168689bddce5SStephen Hemminger optlen); 16876cb153caSBenjamin LaHaise out_put: 16886cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 16891da177e4SLinus Torvalds } 16901da177e4SLinus Torvalds return err; 16911da177e4SLinus Torvalds } 16921da177e4SLinus Torvalds 16931da177e4SLinus Torvalds /* 16941da177e4SLinus Torvalds * Shutdown a socket. 16951da177e4SLinus Torvalds */ 16961da177e4SLinus Torvalds 16971da177e4SLinus Torvalds asmlinkage long sys_shutdown(int fd, int how) 16981da177e4SLinus Torvalds { 16996cb153caSBenjamin LaHaise int err, fput_needed; 17001da177e4SLinus Torvalds struct socket *sock; 17011da177e4SLinus Torvalds 170289bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 170389bddce5SStephen Hemminger if (sock != NULL) { 17041da177e4SLinus Torvalds err = security_socket_shutdown(sock, how); 17056cb153caSBenjamin LaHaise if (!err) 17061da177e4SLinus Torvalds err = sock->ops->shutdown(sock, how); 17076cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 17081da177e4SLinus Torvalds } 17091da177e4SLinus Torvalds return err; 17101da177e4SLinus Torvalds } 17111da177e4SLinus Torvalds 17121da177e4SLinus Torvalds /* A couple of helpful macros for getting the address of the 32/64 bit 17131da177e4SLinus Torvalds * fields which are the same type (int / unsigned) on our platforms. 17141da177e4SLinus Torvalds */ 17151da177e4SLinus Torvalds #define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member) 17161da177e4SLinus Torvalds #define COMPAT_NAMELEN(msg) COMPAT_MSG(msg, msg_namelen) 17171da177e4SLinus Torvalds #define COMPAT_FLAGS(msg) COMPAT_MSG(msg, msg_flags) 17181da177e4SLinus Torvalds 17191da177e4SLinus Torvalds /* 17201da177e4SLinus Torvalds * BSD sendmsg interface 17211da177e4SLinus Torvalds */ 17221da177e4SLinus Torvalds 17231da177e4SLinus Torvalds asmlinkage long sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags) 17241da177e4SLinus Torvalds { 172589bddce5SStephen Hemminger struct compat_msghdr __user *msg_compat = 172689bddce5SStephen Hemminger (struct compat_msghdr __user *)msg; 17271da177e4SLinus Torvalds struct socket *sock; 17281da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 17291da177e4SLinus Torvalds struct iovec iovstack[UIO_FASTIOV], *iov = iovstack; 1730b9d717a7SAlex Williamson unsigned char ctl[sizeof(struct cmsghdr) + 20] 1731b9d717a7SAlex Williamson __attribute__ ((aligned(sizeof(__kernel_size_t)))); 1732b9d717a7SAlex Williamson /* 20 is size of ipv6_pktinfo */ 17331da177e4SLinus Torvalds unsigned char *ctl_buf = ctl; 17341da177e4SLinus Torvalds struct msghdr msg_sys; 17351da177e4SLinus Torvalds int err, ctl_len, iov_size, total_len; 17366cb153caSBenjamin LaHaise int fput_needed; 17371da177e4SLinus Torvalds 17381da177e4SLinus Torvalds err = -EFAULT; 17391da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 17401da177e4SLinus Torvalds if (get_compat_msghdr(&msg_sys, msg_compat)) 17411da177e4SLinus Torvalds return -EFAULT; 174289bddce5SStephen Hemminger } 174389bddce5SStephen Hemminger else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr))) 17441da177e4SLinus Torvalds return -EFAULT; 17451da177e4SLinus Torvalds 17466cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 17471da177e4SLinus Torvalds if (!sock) 17481da177e4SLinus Torvalds goto out; 17491da177e4SLinus Torvalds 17501da177e4SLinus Torvalds /* do not move before msg_sys is valid */ 17511da177e4SLinus Torvalds err = -EMSGSIZE; 17521da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_MAXIOV) 17531da177e4SLinus Torvalds goto out_put; 17541da177e4SLinus Torvalds 17551da177e4SLinus Torvalds /* Check whether to allocate the iovec area */ 17561da177e4SLinus Torvalds err = -ENOMEM; 17571da177e4SLinus Torvalds iov_size = msg_sys.msg_iovlen * sizeof(struct iovec); 17581da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_FASTIOV) { 17591da177e4SLinus Torvalds iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL); 17601da177e4SLinus Torvalds if (!iov) 17611da177e4SLinus Torvalds goto out_put; 17621da177e4SLinus Torvalds } 17631da177e4SLinus Torvalds 17641da177e4SLinus Torvalds /* This will also move the address data into kernel space */ 17651da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 17661da177e4SLinus Torvalds err = verify_compat_iovec(&msg_sys, iov, address, VERIFY_READ); 17671da177e4SLinus Torvalds } else 17681da177e4SLinus Torvalds err = verify_iovec(&msg_sys, iov, address, VERIFY_READ); 17691da177e4SLinus Torvalds if (err < 0) 17701da177e4SLinus Torvalds goto out_freeiov; 17711da177e4SLinus Torvalds total_len = err; 17721da177e4SLinus Torvalds 17731da177e4SLinus Torvalds err = -ENOBUFS; 17741da177e4SLinus Torvalds 17751da177e4SLinus Torvalds if (msg_sys.msg_controllen > INT_MAX) 17761da177e4SLinus Torvalds goto out_freeiov; 17771da177e4SLinus Torvalds ctl_len = msg_sys.msg_controllen; 17781da177e4SLinus Torvalds if ((MSG_CMSG_COMPAT & flags) && ctl_len) { 177989bddce5SStephen Hemminger err = 178089bddce5SStephen Hemminger cmsghdr_from_user_compat_to_kern(&msg_sys, sock->sk, ctl, 178189bddce5SStephen Hemminger sizeof(ctl)); 17821da177e4SLinus Torvalds if (err) 17831da177e4SLinus Torvalds goto out_freeiov; 17841da177e4SLinus Torvalds ctl_buf = msg_sys.msg_control; 17858920e8f9SAl Viro ctl_len = msg_sys.msg_controllen; 17861da177e4SLinus Torvalds } else if (ctl_len) { 178789bddce5SStephen Hemminger if (ctl_len > sizeof(ctl)) { 17881da177e4SLinus Torvalds ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL); 17891da177e4SLinus Torvalds if (ctl_buf == NULL) 17901da177e4SLinus Torvalds goto out_freeiov; 17911da177e4SLinus Torvalds } 17921da177e4SLinus Torvalds err = -EFAULT; 17931da177e4SLinus Torvalds /* 17941da177e4SLinus Torvalds * Careful! Before this, msg_sys.msg_control contains a user pointer. 17951da177e4SLinus Torvalds * Afterwards, it will be a kernel pointer. Thus the compiler-assisted 17961da177e4SLinus Torvalds * checking falls down on this. 17971da177e4SLinus Torvalds */ 179889bddce5SStephen Hemminger if (copy_from_user(ctl_buf, (void __user *)msg_sys.msg_control, 179989bddce5SStephen Hemminger ctl_len)) 18001da177e4SLinus Torvalds goto out_freectl; 18011da177e4SLinus Torvalds msg_sys.msg_control = ctl_buf; 18021da177e4SLinus Torvalds } 18031da177e4SLinus Torvalds msg_sys.msg_flags = flags; 18041da177e4SLinus Torvalds 18051da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 18061da177e4SLinus Torvalds msg_sys.msg_flags |= MSG_DONTWAIT; 18071da177e4SLinus Torvalds err = sock_sendmsg(sock, &msg_sys, total_len); 18081da177e4SLinus Torvalds 18091da177e4SLinus Torvalds out_freectl: 18101da177e4SLinus Torvalds if (ctl_buf != ctl) 18111da177e4SLinus Torvalds sock_kfree_s(sock->sk, ctl_buf, ctl_len); 18121da177e4SLinus Torvalds out_freeiov: 18131da177e4SLinus Torvalds if (iov != iovstack) 18141da177e4SLinus Torvalds sock_kfree_s(sock->sk, iov, iov_size); 18151da177e4SLinus Torvalds out_put: 18166cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 18171da177e4SLinus Torvalds out: 18181da177e4SLinus Torvalds return err; 18191da177e4SLinus Torvalds } 18201da177e4SLinus Torvalds 18211da177e4SLinus Torvalds /* 18221da177e4SLinus Torvalds * BSD recvmsg interface 18231da177e4SLinus Torvalds */ 18241da177e4SLinus Torvalds 182589bddce5SStephen Hemminger asmlinkage long sys_recvmsg(int fd, struct msghdr __user *msg, 182689bddce5SStephen Hemminger unsigned int flags) 18271da177e4SLinus Torvalds { 182889bddce5SStephen Hemminger struct compat_msghdr __user *msg_compat = 182989bddce5SStephen Hemminger (struct compat_msghdr __user *)msg; 18301da177e4SLinus Torvalds struct socket *sock; 18311da177e4SLinus Torvalds struct iovec iovstack[UIO_FASTIOV]; 18321da177e4SLinus Torvalds struct iovec *iov = iovstack; 18331da177e4SLinus Torvalds struct msghdr msg_sys; 18341da177e4SLinus Torvalds unsigned long cmsg_ptr; 18351da177e4SLinus Torvalds int err, iov_size, total_len, len; 18366cb153caSBenjamin LaHaise int fput_needed; 18371da177e4SLinus Torvalds 18381da177e4SLinus Torvalds /* kernel mode address */ 18391da177e4SLinus Torvalds char addr[MAX_SOCK_ADDR]; 18401da177e4SLinus Torvalds 18411da177e4SLinus Torvalds /* user mode address pointers */ 18421da177e4SLinus Torvalds struct sockaddr __user *uaddr; 18431da177e4SLinus Torvalds int __user *uaddr_len; 18441da177e4SLinus Torvalds 18451da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 18461da177e4SLinus Torvalds if (get_compat_msghdr(&msg_sys, msg_compat)) 18471da177e4SLinus Torvalds return -EFAULT; 184889bddce5SStephen Hemminger } 184989bddce5SStephen Hemminger else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr))) 18501da177e4SLinus Torvalds return -EFAULT; 18511da177e4SLinus Torvalds 18526cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 18531da177e4SLinus Torvalds if (!sock) 18541da177e4SLinus Torvalds goto out; 18551da177e4SLinus Torvalds 18561da177e4SLinus Torvalds err = -EMSGSIZE; 18571da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_MAXIOV) 18581da177e4SLinus Torvalds goto out_put; 18591da177e4SLinus Torvalds 18601da177e4SLinus Torvalds /* Check whether to allocate the iovec area */ 18611da177e4SLinus Torvalds err = -ENOMEM; 18621da177e4SLinus Torvalds iov_size = msg_sys.msg_iovlen * sizeof(struct iovec); 18631da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_FASTIOV) { 18641da177e4SLinus Torvalds iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL); 18651da177e4SLinus Torvalds if (!iov) 18661da177e4SLinus Torvalds goto out_put; 18671da177e4SLinus Torvalds } 18681da177e4SLinus Torvalds 18691da177e4SLinus Torvalds /* 18701da177e4SLinus Torvalds * Save the user-mode address (verify_iovec will change the 18711da177e4SLinus Torvalds * kernel msghdr to use the kernel address space) 18721da177e4SLinus Torvalds */ 18731da177e4SLinus Torvalds 18741da177e4SLinus Torvalds uaddr = (void __user *)msg_sys.msg_name; 18751da177e4SLinus Torvalds uaddr_len = COMPAT_NAMELEN(msg); 18761da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 18771da177e4SLinus Torvalds err = verify_compat_iovec(&msg_sys, iov, addr, VERIFY_WRITE); 18781da177e4SLinus Torvalds } else 18791da177e4SLinus Torvalds err = verify_iovec(&msg_sys, iov, addr, VERIFY_WRITE); 18801da177e4SLinus Torvalds if (err < 0) 18811da177e4SLinus Torvalds goto out_freeiov; 18821da177e4SLinus Torvalds total_len = err; 18831da177e4SLinus Torvalds 18841da177e4SLinus Torvalds cmsg_ptr = (unsigned long)msg_sys.msg_control; 18851da177e4SLinus Torvalds msg_sys.msg_flags = 0; 18861da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) 18871da177e4SLinus Torvalds msg_sys.msg_flags = MSG_CMSG_COMPAT; 18881da177e4SLinus Torvalds 18891da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 18901da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 18911da177e4SLinus Torvalds err = sock_recvmsg(sock, &msg_sys, total_len, flags); 18921da177e4SLinus Torvalds if (err < 0) 18931da177e4SLinus Torvalds goto out_freeiov; 18941da177e4SLinus Torvalds len = err; 18951da177e4SLinus Torvalds 18961da177e4SLinus Torvalds if (uaddr != NULL) { 189789bddce5SStephen Hemminger err = move_addr_to_user(addr, msg_sys.msg_namelen, uaddr, 189889bddce5SStephen Hemminger uaddr_len); 18991da177e4SLinus Torvalds if (err < 0) 19001da177e4SLinus Torvalds goto out_freeiov; 19011da177e4SLinus Torvalds } 190237f7f421SDavid S. Miller err = __put_user((msg_sys.msg_flags & ~MSG_CMSG_COMPAT), 190337f7f421SDavid S. Miller COMPAT_FLAGS(msg)); 19041da177e4SLinus Torvalds if (err) 19051da177e4SLinus Torvalds goto out_freeiov; 19061da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) 19071da177e4SLinus Torvalds err = __put_user((unsigned long)msg_sys.msg_control - cmsg_ptr, 19081da177e4SLinus Torvalds &msg_compat->msg_controllen); 19091da177e4SLinus Torvalds else 19101da177e4SLinus Torvalds err = __put_user((unsigned long)msg_sys.msg_control - cmsg_ptr, 19111da177e4SLinus Torvalds &msg->msg_controllen); 19121da177e4SLinus Torvalds if (err) 19131da177e4SLinus Torvalds goto out_freeiov; 19141da177e4SLinus Torvalds err = len; 19151da177e4SLinus Torvalds 19161da177e4SLinus Torvalds out_freeiov: 19171da177e4SLinus Torvalds if (iov != iovstack) 19181da177e4SLinus Torvalds sock_kfree_s(sock->sk, iov, iov_size); 19191da177e4SLinus Torvalds out_put: 19206cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 19211da177e4SLinus Torvalds out: 19221da177e4SLinus Torvalds return err; 19231da177e4SLinus Torvalds } 19241da177e4SLinus Torvalds 19251da177e4SLinus Torvalds #ifdef __ARCH_WANT_SYS_SOCKETCALL 19261da177e4SLinus Torvalds 19271da177e4SLinus Torvalds /* Argument list sizes for sys_socketcall */ 19281da177e4SLinus Torvalds #define AL(x) ((x) * sizeof(unsigned long)) 192989bddce5SStephen Hemminger static const unsigned char nargs[18]={ 193089bddce5SStephen Hemminger AL(0),AL(3),AL(3),AL(3),AL(2),AL(3), 19311da177e4SLinus Torvalds AL(3),AL(3),AL(4),AL(4),AL(4),AL(6), 193289bddce5SStephen Hemminger AL(6),AL(2),AL(5),AL(5),AL(3),AL(3) 193389bddce5SStephen Hemminger }; 193489bddce5SStephen Hemminger 19351da177e4SLinus Torvalds #undef AL 19361da177e4SLinus Torvalds 19371da177e4SLinus Torvalds /* 19381da177e4SLinus Torvalds * System call vectors. 19391da177e4SLinus Torvalds * 19401da177e4SLinus Torvalds * Argument checking cleaned up. Saved 20% in size. 19411da177e4SLinus Torvalds * This function doesn't need to set the kernel lock because 19421da177e4SLinus Torvalds * it is set by the callees. 19431da177e4SLinus Torvalds */ 19441da177e4SLinus Torvalds 19451da177e4SLinus Torvalds asmlinkage long sys_socketcall(int call, unsigned long __user *args) 19461da177e4SLinus Torvalds { 19471da177e4SLinus Torvalds unsigned long a[6]; 19481da177e4SLinus Torvalds unsigned long a0, a1; 19491da177e4SLinus Torvalds int err; 19501da177e4SLinus Torvalds 19511da177e4SLinus Torvalds if (call < 1 || call > SYS_RECVMSG) 19521da177e4SLinus Torvalds return -EINVAL; 19531da177e4SLinus Torvalds 19541da177e4SLinus Torvalds /* copy_from_user should be SMP safe. */ 19551da177e4SLinus Torvalds if (copy_from_user(a, args, nargs[call])) 19561da177e4SLinus Torvalds return -EFAULT; 19571da177e4SLinus Torvalds 19584bcff1b3SDavid Woodhouse err = audit_socketcall(nargs[call] / sizeof(unsigned long), a); 19593ec3b2fbSDavid Woodhouse if (err) 19603ec3b2fbSDavid Woodhouse return err; 19613ec3b2fbSDavid Woodhouse 19621da177e4SLinus Torvalds a0 = a[0]; 19631da177e4SLinus Torvalds a1 = a[1]; 19641da177e4SLinus Torvalds 196589bddce5SStephen Hemminger switch (call) { 19661da177e4SLinus Torvalds case SYS_SOCKET: 19671da177e4SLinus Torvalds err = sys_socket(a0, a1, a[2]); 19681da177e4SLinus Torvalds break; 19691da177e4SLinus Torvalds case SYS_BIND: 19701da177e4SLinus Torvalds err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]); 19711da177e4SLinus Torvalds break; 19721da177e4SLinus Torvalds case SYS_CONNECT: 19731da177e4SLinus Torvalds err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]); 19741da177e4SLinus Torvalds break; 19751da177e4SLinus Torvalds case SYS_LISTEN: 19761da177e4SLinus Torvalds err = sys_listen(a0, a1); 19771da177e4SLinus Torvalds break; 19781da177e4SLinus Torvalds case SYS_ACCEPT: 197989bddce5SStephen Hemminger err = 198089bddce5SStephen Hemminger sys_accept(a0, (struct sockaddr __user *)a1, 198189bddce5SStephen Hemminger (int __user *)a[2]); 19821da177e4SLinus Torvalds break; 19831da177e4SLinus Torvalds case SYS_GETSOCKNAME: 198489bddce5SStephen Hemminger err = 198589bddce5SStephen Hemminger sys_getsockname(a0, (struct sockaddr __user *)a1, 198689bddce5SStephen Hemminger (int __user *)a[2]); 19871da177e4SLinus Torvalds break; 19881da177e4SLinus Torvalds case SYS_GETPEERNAME: 198989bddce5SStephen Hemminger err = 199089bddce5SStephen Hemminger sys_getpeername(a0, (struct sockaddr __user *)a1, 199189bddce5SStephen Hemminger (int __user *)a[2]); 19921da177e4SLinus Torvalds break; 19931da177e4SLinus Torvalds case SYS_SOCKETPAIR: 19941da177e4SLinus Torvalds err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]); 19951da177e4SLinus Torvalds break; 19961da177e4SLinus Torvalds case SYS_SEND: 19971da177e4SLinus Torvalds err = sys_send(a0, (void __user *)a1, a[2], a[3]); 19981da177e4SLinus Torvalds break; 19991da177e4SLinus Torvalds case SYS_SENDTO: 20001da177e4SLinus Torvalds err = sys_sendto(a0, (void __user *)a1, a[2], a[3], 20011da177e4SLinus Torvalds (struct sockaddr __user *)a[4], a[5]); 20021da177e4SLinus Torvalds break; 20031da177e4SLinus Torvalds case SYS_RECV: 20041da177e4SLinus Torvalds err = sys_recv(a0, (void __user *)a1, a[2], a[3]); 20051da177e4SLinus Torvalds break; 20061da177e4SLinus Torvalds case SYS_RECVFROM: 20071da177e4SLinus Torvalds err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3], 200889bddce5SStephen Hemminger (struct sockaddr __user *)a[4], 200989bddce5SStephen Hemminger (int __user *)a[5]); 20101da177e4SLinus Torvalds break; 20111da177e4SLinus Torvalds case SYS_SHUTDOWN: 20121da177e4SLinus Torvalds err = sys_shutdown(a0, a1); 20131da177e4SLinus Torvalds break; 20141da177e4SLinus Torvalds case SYS_SETSOCKOPT: 20151da177e4SLinus Torvalds err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]); 20161da177e4SLinus Torvalds break; 20171da177e4SLinus Torvalds case SYS_GETSOCKOPT: 201889bddce5SStephen Hemminger err = 201989bddce5SStephen Hemminger sys_getsockopt(a0, a1, a[2], (char __user *)a[3], 202089bddce5SStephen Hemminger (int __user *)a[4]); 20211da177e4SLinus Torvalds break; 20221da177e4SLinus Torvalds case SYS_SENDMSG: 20231da177e4SLinus Torvalds err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]); 20241da177e4SLinus Torvalds break; 20251da177e4SLinus Torvalds case SYS_RECVMSG: 20261da177e4SLinus Torvalds err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]); 20271da177e4SLinus Torvalds break; 20281da177e4SLinus Torvalds default: 20291da177e4SLinus Torvalds err = -EINVAL; 20301da177e4SLinus Torvalds break; 20311da177e4SLinus Torvalds } 20321da177e4SLinus Torvalds return err; 20331da177e4SLinus Torvalds } 20341da177e4SLinus Torvalds 20351da177e4SLinus Torvalds #endif /* __ARCH_WANT_SYS_SOCKETCALL */ 20361da177e4SLinus Torvalds 203755737fdaSStephen Hemminger /** 203855737fdaSStephen Hemminger * sock_register - add a socket protocol handler 203955737fdaSStephen Hemminger * @ops: description of protocol 204055737fdaSStephen Hemminger * 20411da177e4SLinus Torvalds * This function is called by a protocol handler that wants to 20421da177e4SLinus Torvalds * advertise its address family, and have it linked into the 204355737fdaSStephen Hemminger * socket interface. The value ops->family coresponds to the 204455737fdaSStephen Hemminger * socket system call protocol family. 20451da177e4SLinus Torvalds */ 2046f0fd27d4SStephen Hemminger int sock_register(const struct net_proto_family *ops) 20471da177e4SLinus Torvalds { 20481da177e4SLinus Torvalds int err; 20491da177e4SLinus Torvalds 20501da177e4SLinus Torvalds if (ops->family >= NPROTO) { 205189bddce5SStephen Hemminger printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family, 205289bddce5SStephen Hemminger NPROTO); 20531da177e4SLinus Torvalds return -ENOBUFS; 20541da177e4SLinus Torvalds } 205555737fdaSStephen Hemminger 205655737fdaSStephen Hemminger spin_lock(&net_family_lock); 205755737fdaSStephen Hemminger if (net_families[ops->family]) 20581da177e4SLinus Torvalds err = -EEXIST; 205955737fdaSStephen Hemminger else { 20601da177e4SLinus Torvalds net_families[ops->family] = ops; 20611da177e4SLinus Torvalds err = 0; 20621da177e4SLinus Torvalds } 206355737fdaSStephen Hemminger spin_unlock(&net_family_lock); 206455737fdaSStephen Hemminger 206589bddce5SStephen Hemminger printk(KERN_INFO "NET: Registered protocol family %d\n", ops->family); 20661da177e4SLinus Torvalds return err; 20671da177e4SLinus Torvalds } 20681da177e4SLinus Torvalds 206955737fdaSStephen Hemminger /** 207055737fdaSStephen Hemminger * sock_unregister - remove a protocol handler 207155737fdaSStephen Hemminger * @family: protocol family to remove 207255737fdaSStephen Hemminger * 20731da177e4SLinus Torvalds * This function is called by a protocol handler that wants to 20741da177e4SLinus Torvalds * remove its address family, and have it unlinked from the 207555737fdaSStephen Hemminger * new socket creation. 207655737fdaSStephen Hemminger * 207755737fdaSStephen Hemminger * If protocol handler is a module, then it can use module reference 207855737fdaSStephen Hemminger * counts to protect against new references. If protocol handler is not 207955737fdaSStephen Hemminger * a module then it needs to provide its own protection in 208055737fdaSStephen Hemminger * the ops->create routine. 20811da177e4SLinus Torvalds */ 2082f0fd27d4SStephen Hemminger void sock_unregister(int family) 20831da177e4SLinus Torvalds { 2084f0fd27d4SStephen Hemminger BUG_ON(family < 0 || family >= NPROTO); 20851da177e4SLinus Torvalds 208655737fdaSStephen Hemminger spin_lock(&net_family_lock); 20871da177e4SLinus Torvalds net_families[family] = NULL; 208855737fdaSStephen Hemminger spin_unlock(&net_family_lock); 208955737fdaSStephen Hemminger 209055737fdaSStephen Hemminger synchronize_rcu(); 209155737fdaSStephen Hemminger 209289bddce5SStephen Hemminger printk(KERN_INFO "NET: Unregistered protocol family %d\n", family); 20931da177e4SLinus Torvalds } 20941da177e4SLinus Torvalds 209577d76ea3SAndi Kleen static int __init sock_init(void) 20961da177e4SLinus Torvalds { 20971da177e4SLinus Torvalds /* 20981da177e4SLinus Torvalds * Initialize sock SLAB cache. 20991da177e4SLinus Torvalds */ 21001da177e4SLinus Torvalds 21011da177e4SLinus Torvalds sk_init(); 21021da177e4SLinus Torvalds 21031da177e4SLinus Torvalds /* 21041da177e4SLinus Torvalds * Initialize skbuff SLAB cache 21051da177e4SLinus Torvalds */ 21061da177e4SLinus Torvalds skb_init(); 21071da177e4SLinus Torvalds 21081da177e4SLinus Torvalds /* 21091da177e4SLinus Torvalds * Initialize the protocols module. 21101da177e4SLinus Torvalds */ 21111da177e4SLinus Torvalds 21121da177e4SLinus Torvalds init_inodecache(); 21131da177e4SLinus Torvalds register_filesystem(&sock_fs_type); 21141da177e4SLinus Torvalds sock_mnt = kern_mount(&sock_fs_type); 211577d76ea3SAndi Kleen 211677d76ea3SAndi Kleen /* The real protocol initialization is performed in later initcalls. 21171da177e4SLinus Torvalds */ 21181da177e4SLinus Torvalds 21191da177e4SLinus Torvalds #ifdef CONFIG_NETFILTER 21201da177e4SLinus Torvalds netfilter_init(); 21211da177e4SLinus Torvalds #endif 2122cbeb321aSDavid S. Miller 2123cbeb321aSDavid S. Miller return 0; 21241da177e4SLinus Torvalds } 21251da177e4SLinus Torvalds 212677d76ea3SAndi Kleen core_initcall(sock_init); /* early initcall */ 212777d76ea3SAndi Kleen 21281da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 21291da177e4SLinus Torvalds void socket_seq_show(struct seq_file *seq) 21301da177e4SLinus Torvalds { 21311da177e4SLinus Torvalds int cpu; 21321da177e4SLinus Torvalds int counter = 0; 21331da177e4SLinus Torvalds 21346f912042SKAMEZAWA Hiroyuki for_each_possible_cpu(cpu) 21351da177e4SLinus Torvalds counter += per_cpu(sockets_in_use, cpu); 21361da177e4SLinus Torvalds 21371da177e4SLinus Torvalds /* It can be negative, by the way. 8) */ 21381da177e4SLinus Torvalds if (counter < 0) 21391da177e4SLinus Torvalds counter = 0; 21401da177e4SLinus Torvalds 21411da177e4SLinus Torvalds seq_printf(seq, "sockets: used %d\n", counter); 21421da177e4SLinus Torvalds } 21431da177e4SLinus Torvalds #endif /* CONFIG_PROC_FS */ 21441da177e4SLinus Torvalds 214589bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 214689bbfc95SShaun Pereira static long compat_sock_ioctl(struct file *file, unsigned cmd, 214789bbfc95SShaun Pereira unsigned long arg) 214889bbfc95SShaun Pereira { 214989bbfc95SShaun Pereira struct socket *sock = file->private_data; 215089bbfc95SShaun Pereira int ret = -ENOIOCTLCMD; 215189bbfc95SShaun Pereira 215289bbfc95SShaun Pereira if (sock->ops->compat_ioctl) 215389bbfc95SShaun Pereira ret = sock->ops->compat_ioctl(sock, cmd, arg); 215489bbfc95SShaun Pereira 215589bbfc95SShaun Pereira return ret; 215689bbfc95SShaun Pereira } 215789bbfc95SShaun Pereira #endif 215889bbfc95SShaun Pereira 2159ac5a488eSSridhar Samudrala int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen) 2160ac5a488eSSridhar Samudrala { 2161ac5a488eSSridhar Samudrala return sock->ops->bind(sock, addr, addrlen); 2162ac5a488eSSridhar Samudrala } 2163ac5a488eSSridhar Samudrala 2164ac5a488eSSridhar Samudrala int kernel_listen(struct socket *sock, int backlog) 2165ac5a488eSSridhar Samudrala { 2166ac5a488eSSridhar Samudrala return sock->ops->listen(sock, backlog); 2167ac5a488eSSridhar Samudrala } 2168ac5a488eSSridhar Samudrala 2169ac5a488eSSridhar Samudrala int kernel_accept(struct socket *sock, struct socket **newsock, int flags) 2170ac5a488eSSridhar Samudrala { 2171ac5a488eSSridhar Samudrala struct sock *sk = sock->sk; 2172ac5a488eSSridhar Samudrala int err; 2173ac5a488eSSridhar Samudrala 2174ac5a488eSSridhar Samudrala err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 2175ac5a488eSSridhar Samudrala newsock); 2176ac5a488eSSridhar Samudrala if (err < 0) 2177ac5a488eSSridhar Samudrala goto done; 2178ac5a488eSSridhar Samudrala 2179ac5a488eSSridhar Samudrala err = sock->ops->accept(sock, *newsock, flags); 2180ac5a488eSSridhar Samudrala if (err < 0) { 2181ac5a488eSSridhar Samudrala sock_release(*newsock); 2182ac5a488eSSridhar Samudrala goto done; 2183ac5a488eSSridhar Samudrala } 2184ac5a488eSSridhar Samudrala 2185ac5a488eSSridhar Samudrala (*newsock)->ops = sock->ops; 2186ac5a488eSSridhar Samudrala 2187ac5a488eSSridhar Samudrala done: 2188ac5a488eSSridhar Samudrala return err; 2189ac5a488eSSridhar Samudrala } 2190ac5a488eSSridhar Samudrala 2191ac5a488eSSridhar Samudrala int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen, 2192ac5a488eSSridhar Samudrala int flags) 2193ac5a488eSSridhar Samudrala { 2194ac5a488eSSridhar Samudrala return sock->ops->connect(sock, addr, addrlen, flags); 2195ac5a488eSSridhar Samudrala } 2196ac5a488eSSridhar Samudrala 2197ac5a488eSSridhar Samudrala int kernel_getsockname(struct socket *sock, struct sockaddr *addr, 2198ac5a488eSSridhar Samudrala int *addrlen) 2199ac5a488eSSridhar Samudrala { 2200ac5a488eSSridhar Samudrala return sock->ops->getname(sock, addr, addrlen, 0); 2201ac5a488eSSridhar Samudrala } 2202ac5a488eSSridhar Samudrala 2203ac5a488eSSridhar Samudrala int kernel_getpeername(struct socket *sock, struct sockaddr *addr, 2204ac5a488eSSridhar Samudrala int *addrlen) 2205ac5a488eSSridhar Samudrala { 2206ac5a488eSSridhar Samudrala return sock->ops->getname(sock, addr, addrlen, 1); 2207ac5a488eSSridhar Samudrala } 2208ac5a488eSSridhar Samudrala 2209ac5a488eSSridhar Samudrala int kernel_getsockopt(struct socket *sock, int level, int optname, 2210ac5a488eSSridhar Samudrala char *optval, int *optlen) 2211ac5a488eSSridhar Samudrala { 2212ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 2213ac5a488eSSridhar Samudrala int err; 2214ac5a488eSSridhar Samudrala 2215ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 2216ac5a488eSSridhar Samudrala if (level == SOL_SOCKET) 2217ac5a488eSSridhar Samudrala err = sock_getsockopt(sock, level, optname, optval, optlen); 2218ac5a488eSSridhar Samudrala else 2219ac5a488eSSridhar Samudrala err = sock->ops->getsockopt(sock, level, optname, optval, 2220ac5a488eSSridhar Samudrala optlen); 2221ac5a488eSSridhar Samudrala set_fs(oldfs); 2222ac5a488eSSridhar Samudrala return err; 2223ac5a488eSSridhar Samudrala } 2224ac5a488eSSridhar Samudrala 2225ac5a488eSSridhar Samudrala int kernel_setsockopt(struct socket *sock, int level, int optname, 2226ac5a488eSSridhar Samudrala char *optval, int optlen) 2227ac5a488eSSridhar Samudrala { 2228ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 2229ac5a488eSSridhar Samudrala int err; 2230ac5a488eSSridhar Samudrala 2231ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 2232ac5a488eSSridhar Samudrala if (level == SOL_SOCKET) 2233ac5a488eSSridhar Samudrala err = sock_setsockopt(sock, level, optname, optval, optlen); 2234ac5a488eSSridhar Samudrala else 2235ac5a488eSSridhar Samudrala err = sock->ops->setsockopt(sock, level, optname, optval, 2236ac5a488eSSridhar Samudrala optlen); 2237ac5a488eSSridhar Samudrala set_fs(oldfs); 2238ac5a488eSSridhar Samudrala return err; 2239ac5a488eSSridhar Samudrala } 2240ac5a488eSSridhar Samudrala 2241ac5a488eSSridhar Samudrala int kernel_sendpage(struct socket *sock, struct page *page, int offset, 2242ac5a488eSSridhar Samudrala size_t size, int flags) 2243ac5a488eSSridhar Samudrala { 2244ac5a488eSSridhar Samudrala if (sock->ops->sendpage) 2245ac5a488eSSridhar Samudrala return sock->ops->sendpage(sock, page, offset, size, flags); 2246ac5a488eSSridhar Samudrala 2247ac5a488eSSridhar Samudrala return sock_no_sendpage(sock, page, offset, size, flags); 2248ac5a488eSSridhar Samudrala } 2249ac5a488eSSridhar Samudrala 2250ac5a488eSSridhar Samudrala int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg) 2251ac5a488eSSridhar Samudrala { 2252ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 2253ac5a488eSSridhar Samudrala int err; 2254ac5a488eSSridhar Samudrala 2255ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 2256ac5a488eSSridhar Samudrala err = sock->ops->ioctl(sock, cmd, arg); 2257ac5a488eSSridhar Samudrala set_fs(oldfs); 2258ac5a488eSSridhar Samudrala 2259ac5a488eSSridhar Samudrala return err; 2260ac5a488eSSridhar Samudrala } 2261ac5a488eSSridhar Samudrala 22621da177e4SLinus Torvalds /* ABI emulation layers need these two */ 22631da177e4SLinus Torvalds EXPORT_SYMBOL(move_addr_to_kernel); 22641da177e4SLinus Torvalds EXPORT_SYMBOL(move_addr_to_user); 22651da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create); 22661da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create_kern); 22671da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create_lite); 22681da177e4SLinus Torvalds EXPORT_SYMBOL(sock_map_fd); 22691da177e4SLinus Torvalds EXPORT_SYMBOL(sock_recvmsg); 22701da177e4SLinus Torvalds EXPORT_SYMBOL(sock_register); 22711da177e4SLinus Torvalds EXPORT_SYMBOL(sock_release); 22721da177e4SLinus Torvalds EXPORT_SYMBOL(sock_sendmsg); 22731da177e4SLinus Torvalds EXPORT_SYMBOL(sock_unregister); 22741da177e4SLinus Torvalds EXPORT_SYMBOL(sock_wake_async); 22751da177e4SLinus Torvalds EXPORT_SYMBOL(sockfd_lookup); 22761da177e4SLinus Torvalds EXPORT_SYMBOL(kernel_sendmsg); 22771da177e4SLinus Torvalds EXPORT_SYMBOL(kernel_recvmsg); 2278ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_bind); 2279ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_listen); 2280ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_accept); 2281ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_connect); 2282ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getsockname); 2283ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getpeername); 2284ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getsockopt); 2285ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_setsockopt); 2286ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_sendpage); 2287ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_sock_ioctl); 2288