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> 871b8d7ae4SEric W. Biederman #include <linux/nsproxy.h> 881da177e4SLinus Torvalds 891da177e4SLinus Torvalds #include <asm/uaccess.h> 901da177e4SLinus Torvalds #include <asm/unistd.h> 911da177e4SLinus Torvalds 921da177e4SLinus Torvalds #include <net/compat.h> 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds #include <net/sock.h> 951da177e4SLinus Torvalds #include <linux/netfilter.h> 961da177e4SLinus Torvalds 971da177e4SLinus Torvalds static int sock_no_open(struct inode *irrelevant, struct file *dontcare); 98027445c3SBadari Pulavarty static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov, 99027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos); 100027445c3SBadari Pulavarty static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov, 101027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos); 1021da177e4SLinus Torvalds static int sock_mmap(struct file *file, struct vm_area_struct *vma); 1031da177e4SLinus Torvalds 1041da177e4SLinus Torvalds static int sock_close(struct inode *inode, struct file *file); 1051da177e4SLinus Torvalds static unsigned int sock_poll(struct file *file, 1061da177e4SLinus Torvalds struct poll_table_struct *wait); 10789bddce5SStephen Hemminger static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg); 10889bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 10989bbfc95SShaun Pereira static long compat_sock_ioctl(struct file *file, 11089bbfc95SShaun Pereira unsigned int cmd, unsigned long arg); 11189bbfc95SShaun Pereira #endif 1121da177e4SLinus Torvalds static int sock_fasync(int fd, struct file *filp, int on); 1131da177e4SLinus Torvalds static ssize_t sock_sendpage(struct file *file, struct page *page, 1141da177e4SLinus Torvalds int offset, size_t size, loff_t *ppos, int more); 1159c55e01cSJens Axboe static ssize_t sock_splice_read(struct file *file, loff_t *ppos, 1169c55e01cSJens Axboe struct pipe_inode_info *pipe, size_t len, 1179c55e01cSJens Axboe unsigned int flags); 1181da177e4SLinus Torvalds 1191da177e4SLinus Torvalds /* 1201da177e4SLinus Torvalds * Socket files have a set of 'special' operations as well as the generic file ones. These don't appear 1211da177e4SLinus Torvalds * in the operation structures but are done directly via the socketcall() multiplexor. 1221da177e4SLinus Torvalds */ 1231da177e4SLinus Torvalds 124da7071d7SArjan van de Ven static const struct file_operations socket_file_ops = { 1251da177e4SLinus Torvalds .owner = THIS_MODULE, 1261da177e4SLinus Torvalds .llseek = no_llseek, 1271da177e4SLinus Torvalds .aio_read = sock_aio_read, 1281da177e4SLinus Torvalds .aio_write = sock_aio_write, 1291da177e4SLinus Torvalds .poll = sock_poll, 1301da177e4SLinus Torvalds .unlocked_ioctl = sock_ioctl, 13189bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 13289bbfc95SShaun Pereira .compat_ioctl = compat_sock_ioctl, 13389bbfc95SShaun Pereira #endif 1341da177e4SLinus Torvalds .mmap = sock_mmap, 1351da177e4SLinus Torvalds .open = sock_no_open, /* special open code to disallow open via /proc */ 1361da177e4SLinus Torvalds .release = sock_close, 1371da177e4SLinus Torvalds .fasync = sock_fasync, 1385274f052SJens Axboe .sendpage = sock_sendpage, 1395274f052SJens Axboe .splice_write = generic_splice_sendpage, 1409c55e01cSJens Axboe .splice_read = sock_splice_read, 1411da177e4SLinus Torvalds }; 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds /* 1441da177e4SLinus Torvalds * The protocol list. Each protocol is registered in here. 1451da177e4SLinus Torvalds */ 1461da177e4SLinus Torvalds 1471da177e4SLinus Torvalds static DEFINE_SPINLOCK(net_family_lock); 148f0fd27d4SStephen Hemminger static const struct net_proto_family *net_families[NPROTO] __read_mostly; 1491da177e4SLinus Torvalds 1501da177e4SLinus Torvalds /* 1511da177e4SLinus Torvalds * Statistics counters of the socket lists 1521da177e4SLinus Torvalds */ 1531da177e4SLinus Torvalds 1541da177e4SLinus Torvalds static DEFINE_PER_CPU(int, sockets_in_use) = 0; 1551da177e4SLinus Torvalds 1561da177e4SLinus Torvalds /* 15789bddce5SStephen Hemminger * Support routines. 15889bddce5SStephen Hemminger * Move socket addresses back and forth across the kernel/user 1591da177e4SLinus Torvalds * divide and look after the messy bits. 1601da177e4SLinus Torvalds */ 1611da177e4SLinus Torvalds 1621da177e4SLinus Torvalds #define MAX_SOCK_ADDR 128 /* 108 for Unix domain - 1631da177e4SLinus Torvalds 16 for IP, 16 for IPX, 1641da177e4SLinus Torvalds 24 for IPv6, 1651da177e4SLinus Torvalds about 80 for AX.25 1661da177e4SLinus Torvalds must be at least one bigger than 1671da177e4SLinus Torvalds the AF_UNIX size (see net/unix/af_unix.c 1681da177e4SLinus Torvalds :unix_mkname()). 1691da177e4SLinus Torvalds */ 1701da177e4SLinus Torvalds 1711da177e4SLinus Torvalds /** 1721da177e4SLinus Torvalds * move_addr_to_kernel - copy a socket address into kernel space 1731da177e4SLinus Torvalds * @uaddr: Address in user space 1741da177e4SLinus Torvalds * @kaddr: Address in kernel space 1751da177e4SLinus Torvalds * @ulen: Length in user space 1761da177e4SLinus Torvalds * 1771da177e4SLinus Torvalds * The address is copied into kernel space. If the provided address is 1781da177e4SLinus Torvalds * too long an error code of -EINVAL is returned. If the copy gives 1791da177e4SLinus Torvalds * invalid addresses -EFAULT is returned. On a success 0 is returned. 1801da177e4SLinus Torvalds */ 1811da177e4SLinus Torvalds 1821da177e4SLinus Torvalds int move_addr_to_kernel(void __user *uaddr, int ulen, void *kaddr) 1831da177e4SLinus Torvalds { 1841da177e4SLinus Torvalds if (ulen < 0 || ulen > MAX_SOCK_ADDR) 1851da177e4SLinus Torvalds return -EINVAL; 1861da177e4SLinus Torvalds if (ulen == 0) 1871da177e4SLinus Torvalds return 0; 1881da177e4SLinus Torvalds if (copy_from_user(kaddr, uaddr, ulen)) 1891da177e4SLinus Torvalds return -EFAULT; 1903ec3b2fbSDavid Woodhouse return audit_sockaddr(ulen, kaddr); 1911da177e4SLinus Torvalds } 1921da177e4SLinus Torvalds 1931da177e4SLinus Torvalds /** 1941da177e4SLinus Torvalds * move_addr_to_user - copy an address to user space 1951da177e4SLinus Torvalds * @kaddr: kernel space address 1961da177e4SLinus Torvalds * @klen: length of address in kernel 1971da177e4SLinus Torvalds * @uaddr: user space address 1981da177e4SLinus Torvalds * @ulen: pointer to user length field 1991da177e4SLinus Torvalds * 2001da177e4SLinus Torvalds * The value pointed to by ulen on entry is the buffer length available. 2011da177e4SLinus Torvalds * This is overwritten with the buffer space used. -EINVAL is returned 2021da177e4SLinus Torvalds * if an overlong buffer is specified or a negative buffer size. -EFAULT 2031da177e4SLinus Torvalds * is returned if either the buffer or the length field are not 2041da177e4SLinus Torvalds * accessible. 2051da177e4SLinus Torvalds * After copying the data up to the limit the user specifies, the true 2061da177e4SLinus Torvalds * length of the data is written over the length limit the user 2071da177e4SLinus Torvalds * specified. Zero is returned for a success. 2081da177e4SLinus Torvalds */ 2091da177e4SLinus Torvalds 21089bddce5SStephen Hemminger int move_addr_to_user(void *kaddr, int klen, void __user *uaddr, 21189bddce5SStephen Hemminger int __user *ulen) 2121da177e4SLinus Torvalds { 2131da177e4SLinus Torvalds int err; 2141da177e4SLinus Torvalds int len; 2151da177e4SLinus Torvalds 21689bddce5SStephen Hemminger err = get_user(len, ulen); 21789bddce5SStephen Hemminger if (err) 2181da177e4SLinus Torvalds return err; 2191da177e4SLinus Torvalds if (len > klen) 2201da177e4SLinus Torvalds len = klen; 2211da177e4SLinus Torvalds if (len < 0 || len > MAX_SOCK_ADDR) 2221da177e4SLinus Torvalds return -EINVAL; 22389bddce5SStephen Hemminger if (len) { 224d6fe3945SSteve Grubb if (audit_sockaddr(klen, kaddr)) 225d6fe3945SSteve Grubb return -ENOMEM; 2261da177e4SLinus Torvalds if (copy_to_user(uaddr, kaddr, len)) 2271da177e4SLinus Torvalds return -EFAULT; 2281da177e4SLinus Torvalds } 2291da177e4SLinus Torvalds /* 2301da177e4SLinus Torvalds * "fromlen shall refer to the value before truncation.." 2311da177e4SLinus Torvalds * 1003.1g 2321da177e4SLinus Torvalds */ 2331da177e4SLinus Torvalds return __put_user(klen, ulen); 2341da177e4SLinus Torvalds } 2351da177e4SLinus Torvalds 2361da177e4SLinus Torvalds #define SOCKFS_MAGIC 0x534F434B 2371da177e4SLinus Torvalds 238e18b890bSChristoph Lameter static struct kmem_cache *sock_inode_cachep __read_mostly; 2391da177e4SLinus Torvalds 2401da177e4SLinus Torvalds static struct inode *sock_alloc_inode(struct super_block *sb) 2411da177e4SLinus Torvalds { 2421da177e4SLinus Torvalds struct socket_alloc *ei; 24389bddce5SStephen Hemminger 244e94b1766SChristoph Lameter ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL); 2451da177e4SLinus Torvalds if (!ei) 2461da177e4SLinus Torvalds return NULL; 2471da177e4SLinus Torvalds init_waitqueue_head(&ei->socket.wait); 2481da177e4SLinus Torvalds 2491da177e4SLinus Torvalds ei->socket.fasync_list = NULL; 2501da177e4SLinus Torvalds ei->socket.state = SS_UNCONNECTED; 2511da177e4SLinus Torvalds ei->socket.flags = 0; 2521da177e4SLinus Torvalds ei->socket.ops = NULL; 2531da177e4SLinus Torvalds ei->socket.sk = NULL; 2541da177e4SLinus Torvalds ei->socket.file = NULL; 2551da177e4SLinus Torvalds 2561da177e4SLinus Torvalds return &ei->vfs_inode; 2571da177e4SLinus Torvalds } 2581da177e4SLinus Torvalds 2591da177e4SLinus Torvalds static void sock_destroy_inode(struct inode *inode) 2601da177e4SLinus Torvalds { 2611da177e4SLinus Torvalds kmem_cache_free(sock_inode_cachep, 2621da177e4SLinus Torvalds container_of(inode, struct socket_alloc, vfs_inode)); 2631da177e4SLinus Torvalds } 2641da177e4SLinus Torvalds 2654ba9b9d0SChristoph Lameter static void init_once(struct kmem_cache *cachep, void *foo) 2661da177e4SLinus Torvalds { 2671da177e4SLinus Torvalds struct socket_alloc *ei = (struct socket_alloc *)foo; 2681da177e4SLinus Torvalds 2691da177e4SLinus Torvalds inode_init_once(&ei->vfs_inode); 2701da177e4SLinus Torvalds } 2711da177e4SLinus Torvalds 2721da177e4SLinus Torvalds static int init_inodecache(void) 2731da177e4SLinus Torvalds { 2741da177e4SLinus Torvalds sock_inode_cachep = kmem_cache_create("sock_inode_cache", 2751da177e4SLinus Torvalds sizeof(struct socket_alloc), 27689bddce5SStephen Hemminger 0, 27789bddce5SStephen Hemminger (SLAB_HWCACHE_ALIGN | 27889bddce5SStephen Hemminger SLAB_RECLAIM_ACCOUNT | 279fffb60f9SPaul Jackson SLAB_MEM_SPREAD), 28020c2df83SPaul Mundt init_once); 2811da177e4SLinus Torvalds if (sock_inode_cachep == NULL) 2821da177e4SLinus Torvalds return -ENOMEM; 2831da177e4SLinus Torvalds return 0; 2841da177e4SLinus Torvalds } 2851da177e4SLinus Torvalds 2861da177e4SLinus Torvalds static struct super_operations sockfs_ops = { 2871da177e4SLinus Torvalds .alloc_inode = sock_alloc_inode, 2881da177e4SLinus Torvalds .destroy_inode =sock_destroy_inode, 2891da177e4SLinus Torvalds .statfs = simple_statfs, 2901da177e4SLinus Torvalds }; 2911da177e4SLinus Torvalds 292454e2398SDavid Howells static int sockfs_get_sb(struct file_system_type *fs_type, 29389bddce5SStephen Hemminger int flags, const char *dev_name, void *data, 29489bddce5SStephen Hemminger struct vfsmount *mnt) 2951da177e4SLinus Torvalds { 296454e2398SDavid Howells return get_sb_pseudo(fs_type, "socket:", &sockfs_ops, SOCKFS_MAGIC, 297454e2398SDavid Howells mnt); 2981da177e4SLinus Torvalds } 2991da177e4SLinus Torvalds 300ba89966cSEric Dumazet static struct vfsmount *sock_mnt __read_mostly; 3011da177e4SLinus Torvalds 3021da177e4SLinus Torvalds static struct file_system_type sock_fs_type = { 3031da177e4SLinus Torvalds .name = "sockfs", 3041da177e4SLinus Torvalds .get_sb = sockfs_get_sb, 3051da177e4SLinus Torvalds .kill_sb = kill_anon_super, 3061da177e4SLinus Torvalds }; 30789bddce5SStephen Hemminger 3081da177e4SLinus Torvalds static int sockfs_delete_dentry(struct dentry *dentry) 3091da177e4SLinus Torvalds { 310304e61e6SEric Dumazet /* 311304e61e6SEric Dumazet * At creation time, we pretended this dentry was hashed 312304e61e6SEric Dumazet * (by clearing DCACHE_UNHASHED bit in d_flags) 313304e61e6SEric Dumazet * At delete time, we restore the truth : not hashed. 314304e61e6SEric Dumazet * (so that dput() can proceed correctly) 315304e61e6SEric Dumazet */ 316304e61e6SEric Dumazet dentry->d_flags |= DCACHE_UNHASHED; 317304e61e6SEric Dumazet return 0; 3181da177e4SLinus Torvalds } 319c23fbb6bSEric Dumazet 320c23fbb6bSEric Dumazet /* 321c23fbb6bSEric Dumazet * sockfs_dname() is called from d_path(). 322c23fbb6bSEric Dumazet */ 323c23fbb6bSEric Dumazet static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen) 324c23fbb6bSEric Dumazet { 325c23fbb6bSEric Dumazet return dynamic_dname(dentry, buffer, buflen, "socket:[%lu]", 326c23fbb6bSEric Dumazet dentry->d_inode->i_ino); 327c23fbb6bSEric Dumazet } 328c23fbb6bSEric Dumazet 3291da177e4SLinus Torvalds static struct dentry_operations sockfs_dentry_operations = { 3301da177e4SLinus Torvalds .d_delete = sockfs_delete_dentry, 331c23fbb6bSEric Dumazet .d_dname = sockfs_dname, 3321da177e4SLinus Torvalds }; 3331da177e4SLinus Torvalds 3341da177e4SLinus Torvalds /* 3351da177e4SLinus Torvalds * Obtains the first available file descriptor and sets it up for use. 3361da177e4SLinus Torvalds * 33739d8c1b6SDavid S. Miller * These functions create file structures and maps them to fd space 33839d8c1b6SDavid S. Miller * of the current process. On success it returns file descriptor 3391da177e4SLinus Torvalds * and file struct implicitly stored in sock->file. 3401da177e4SLinus Torvalds * Note that another thread may close file descriptor before we return 3411da177e4SLinus Torvalds * from this function. We use the fact that now we do not refer 3421da177e4SLinus Torvalds * to socket after mapping. If one day we will need it, this 3431da177e4SLinus Torvalds * function will increment ref. count on file by 1. 3441da177e4SLinus Torvalds * 3451da177e4SLinus Torvalds * In any case returned fd MAY BE not valid! 3461da177e4SLinus Torvalds * This race condition is unavoidable 3471da177e4SLinus Torvalds * with shared fd spaces, we cannot solve it inside kernel, 3481da177e4SLinus Torvalds * but we take care of internal coherence yet. 3491da177e4SLinus Torvalds */ 3501da177e4SLinus Torvalds 35139d8c1b6SDavid S. Miller static int sock_alloc_fd(struct file **filep) 3521da177e4SLinus Torvalds { 3531da177e4SLinus Torvalds int fd; 3541da177e4SLinus Torvalds 3551da177e4SLinus Torvalds fd = get_unused_fd(); 35639d8c1b6SDavid S. Miller if (likely(fd >= 0)) { 3571da177e4SLinus Torvalds struct file *file = get_empty_filp(); 3581da177e4SLinus Torvalds 35939d8c1b6SDavid S. Miller *filep = file; 36039d8c1b6SDavid S. Miller if (unlikely(!file)) { 3611da177e4SLinus Torvalds put_unused_fd(fd); 36239d8c1b6SDavid S. Miller return -ENFILE; 3631da177e4SLinus Torvalds } 36439d8c1b6SDavid S. Miller } else 36539d8c1b6SDavid S. Miller *filep = NULL; 36639d8c1b6SDavid S. Miller return fd; 36739d8c1b6SDavid S. Miller } 36839d8c1b6SDavid S. Miller 36939d8c1b6SDavid S. Miller static int sock_attach_fd(struct socket *sock, struct file *file) 37039d8c1b6SDavid S. Miller { 371ce8d2cdfSDave Hansen struct dentry *dentry; 372c23fbb6bSEric Dumazet struct qstr name = { .name = "" }; 3731da177e4SLinus Torvalds 374ce8d2cdfSDave Hansen dentry = d_alloc(sock_mnt->mnt_sb->s_root, &name); 375ce8d2cdfSDave Hansen if (unlikely(!dentry)) 37639d8c1b6SDavid S. Miller return -ENOMEM; 37739d8c1b6SDavid S. Miller 378ce8d2cdfSDave Hansen dentry->d_op = &sockfs_dentry_operations; 379304e61e6SEric Dumazet /* 380304e61e6SEric Dumazet * We dont want to push this dentry into global dentry hash table. 381304e61e6SEric Dumazet * We pretend dentry is already hashed, by unsetting DCACHE_UNHASHED 382304e61e6SEric Dumazet * This permits a working /proc/$pid/fd/XXX on sockets 383304e61e6SEric Dumazet */ 384ce8d2cdfSDave Hansen dentry->d_flags &= ~DCACHE_UNHASHED; 385ce8d2cdfSDave Hansen d_instantiate(dentry, SOCK_INODE(sock)); 3861da177e4SLinus Torvalds 3871da177e4SLinus Torvalds sock->file = file; 388ce8d2cdfSDave Hansen init_file(file, sock_mnt, dentry, FMODE_READ | FMODE_WRITE, 389ce8d2cdfSDave Hansen &socket_file_ops); 390ce8d2cdfSDave Hansen SOCK_INODE(sock)->i_fop = &socket_file_ops; 3911da177e4SLinus Torvalds file->f_flags = O_RDWR; 3921da177e4SLinus Torvalds file->f_pos = 0; 39307dc3f07SBenjamin LaHaise file->private_data = sock; 39439d8c1b6SDavid S. Miller 39539d8c1b6SDavid S. Miller return 0; 3961da177e4SLinus Torvalds } 3971da177e4SLinus Torvalds 39839d8c1b6SDavid S. Miller int sock_map_fd(struct socket *sock) 39939d8c1b6SDavid S. Miller { 40039d8c1b6SDavid S. Miller struct file *newfile; 40139d8c1b6SDavid S. Miller int fd = sock_alloc_fd(&newfile); 40239d8c1b6SDavid S. Miller 40339d8c1b6SDavid S. Miller if (likely(fd >= 0)) { 40439d8c1b6SDavid S. Miller int err = sock_attach_fd(sock, newfile); 40539d8c1b6SDavid S. Miller 40639d8c1b6SDavid S. Miller if (unlikely(err < 0)) { 40739d8c1b6SDavid S. Miller put_filp(newfile); 40839d8c1b6SDavid S. Miller put_unused_fd(fd); 40939d8c1b6SDavid S. Miller return err; 41039d8c1b6SDavid S. Miller } 41139d8c1b6SDavid S. Miller fd_install(fd, newfile); 41239d8c1b6SDavid S. Miller } 4131da177e4SLinus Torvalds return fd; 4141da177e4SLinus Torvalds } 4151da177e4SLinus Torvalds 4166cb153caSBenjamin LaHaise static struct socket *sock_from_file(struct file *file, int *err) 4176cb153caSBenjamin LaHaise { 4186cb153caSBenjamin LaHaise if (file->f_op == &socket_file_ops) 4196cb153caSBenjamin LaHaise return file->private_data; /* set in sock_map_fd */ 4206cb153caSBenjamin LaHaise 4216cb153caSBenjamin LaHaise *err = -ENOTSOCK; 4226cb153caSBenjamin LaHaise return NULL; 4236cb153caSBenjamin LaHaise } 4246cb153caSBenjamin LaHaise 4251da177e4SLinus Torvalds /** 4261da177e4SLinus Torvalds * sockfd_lookup - Go from a file number to its socket slot 4271da177e4SLinus Torvalds * @fd: file handle 4281da177e4SLinus Torvalds * @err: pointer to an error code return 4291da177e4SLinus Torvalds * 4301da177e4SLinus Torvalds * The file handle passed in is locked and the socket it is bound 4311da177e4SLinus Torvalds * too is returned. If an error occurs the err pointer is overwritten 4321da177e4SLinus Torvalds * with a negative errno code and NULL is returned. The function checks 4331da177e4SLinus Torvalds * for both invalid handles and passing a handle which is not a socket. 4341da177e4SLinus Torvalds * 4351da177e4SLinus Torvalds * On a success the socket object pointer is returned. 4361da177e4SLinus Torvalds */ 4371da177e4SLinus Torvalds 4381da177e4SLinus Torvalds struct socket *sockfd_lookup(int fd, int *err) 4391da177e4SLinus Torvalds { 4401da177e4SLinus Torvalds struct file *file; 4411da177e4SLinus Torvalds struct socket *sock; 4421da177e4SLinus Torvalds 44389bddce5SStephen Hemminger file = fget(fd); 44489bddce5SStephen Hemminger if (!file) { 4451da177e4SLinus Torvalds *err = -EBADF; 4461da177e4SLinus Torvalds return NULL; 4471da177e4SLinus Torvalds } 44889bddce5SStephen Hemminger 4496cb153caSBenjamin LaHaise sock = sock_from_file(file, err); 4506cb153caSBenjamin LaHaise if (!sock) 4511da177e4SLinus Torvalds fput(file); 4526cb153caSBenjamin LaHaise return sock; 4531da177e4SLinus Torvalds } 4541da177e4SLinus Torvalds 4556cb153caSBenjamin LaHaise static struct socket *sockfd_lookup_light(int fd, int *err, int *fput_needed) 4566cb153caSBenjamin LaHaise { 4576cb153caSBenjamin LaHaise struct file *file; 4586cb153caSBenjamin LaHaise struct socket *sock; 4596cb153caSBenjamin LaHaise 4603672558cSHua Zhong *err = -EBADF; 4616cb153caSBenjamin LaHaise file = fget_light(fd, fput_needed); 4626cb153caSBenjamin LaHaise if (file) { 4636cb153caSBenjamin LaHaise sock = sock_from_file(file, err); 4646cb153caSBenjamin LaHaise if (sock) 4651da177e4SLinus Torvalds return sock; 4666cb153caSBenjamin LaHaise fput_light(file, *fput_needed); 4676cb153caSBenjamin LaHaise } 4686cb153caSBenjamin LaHaise return NULL; 4691da177e4SLinus Torvalds } 4701da177e4SLinus Torvalds 4711da177e4SLinus Torvalds /** 4721da177e4SLinus Torvalds * sock_alloc - allocate a socket 4731da177e4SLinus Torvalds * 4741da177e4SLinus Torvalds * Allocate a new inode and socket object. The two are bound together 4751da177e4SLinus Torvalds * and initialised. The socket is then returned. If we are out of inodes 4761da177e4SLinus Torvalds * NULL is returned. 4771da177e4SLinus Torvalds */ 4781da177e4SLinus Torvalds 4791da177e4SLinus Torvalds static struct socket *sock_alloc(void) 4801da177e4SLinus Torvalds { 4811da177e4SLinus Torvalds struct inode *inode; 4821da177e4SLinus Torvalds struct socket *sock; 4831da177e4SLinus Torvalds 4841da177e4SLinus Torvalds inode = new_inode(sock_mnt->mnt_sb); 4851da177e4SLinus Torvalds if (!inode) 4861da177e4SLinus Torvalds return NULL; 4871da177e4SLinus Torvalds 4881da177e4SLinus Torvalds sock = SOCKET_I(inode); 4891da177e4SLinus Torvalds 4901da177e4SLinus Torvalds inode->i_mode = S_IFSOCK | S_IRWXUGO; 4911da177e4SLinus Torvalds inode->i_uid = current->fsuid; 4921da177e4SLinus Torvalds inode->i_gid = current->fsgid; 4931da177e4SLinus Torvalds 4941da177e4SLinus Torvalds get_cpu_var(sockets_in_use)++; 4951da177e4SLinus Torvalds put_cpu_var(sockets_in_use); 4961da177e4SLinus Torvalds return sock; 4971da177e4SLinus Torvalds } 4981da177e4SLinus Torvalds 4991da177e4SLinus Torvalds /* 5001da177e4SLinus Torvalds * In theory you can't get an open on this inode, but /proc provides 5011da177e4SLinus Torvalds * a back door. Remember to keep it shut otherwise you'll let the 5021da177e4SLinus Torvalds * creepy crawlies in. 5031da177e4SLinus Torvalds */ 5041da177e4SLinus Torvalds 5051da177e4SLinus Torvalds static int sock_no_open(struct inode *irrelevant, struct file *dontcare) 5061da177e4SLinus Torvalds { 5071da177e4SLinus Torvalds return -ENXIO; 5081da177e4SLinus Torvalds } 5091da177e4SLinus Torvalds 5104b6f5d20SArjan van de Ven const struct file_operations bad_sock_fops = { 5111da177e4SLinus Torvalds .owner = THIS_MODULE, 5121da177e4SLinus Torvalds .open = sock_no_open, 5131da177e4SLinus Torvalds }; 5141da177e4SLinus Torvalds 5151da177e4SLinus Torvalds /** 5161da177e4SLinus Torvalds * sock_release - close a socket 5171da177e4SLinus Torvalds * @sock: socket to close 5181da177e4SLinus Torvalds * 5191da177e4SLinus Torvalds * The socket is released from the protocol stack if it has a release 5201da177e4SLinus Torvalds * callback, and the inode is then released if the socket is bound to 5211da177e4SLinus Torvalds * an inode not a file. 5221da177e4SLinus Torvalds */ 5231da177e4SLinus Torvalds 5241da177e4SLinus Torvalds void sock_release(struct socket *sock) 5251da177e4SLinus Torvalds { 5261da177e4SLinus Torvalds if (sock->ops) { 5271da177e4SLinus Torvalds struct module *owner = sock->ops->owner; 5281da177e4SLinus Torvalds 5291da177e4SLinus Torvalds sock->ops->release(sock); 5301da177e4SLinus Torvalds sock->ops = NULL; 5311da177e4SLinus Torvalds module_put(owner); 5321da177e4SLinus Torvalds } 5331da177e4SLinus Torvalds 5341da177e4SLinus Torvalds if (sock->fasync_list) 5351da177e4SLinus Torvalds printk(KERN_ERR "sock_release: fasync list not empty!\n"); 5361da177e4SLinus Torvalds 5371da177e4SLinus Torvalds get_cpu_var(sockets_in_use)--; 5381da177e4SLinus Torvalds put_cpu_var(sockets_in_use); 5391da177e4SLinus Torvalds if (!sock->file) { 5401da177e4SLinus Torvalds iput(SOCK_INODE(sock)); 5411da177e4SLinus Torvalds return; 5421da177e4SLinus Torvalds } 5431da177e4SLinus Torvalds sock->file = NULL; 5441da177e4SLinus Torvalds } 5451da177e4SLinus Torvalds 5461da177e4SLinus Torvalds static inline int __sock_sendmsg(struct kiocb *iocb, struct socket *sock, 5471da177e4SLinus Torvalds struct msghdr *msg, size_t size) 5481da177e4SLinus Torvalds { 5491da177e4SLinus Torvalds struct sock_iocb *si = kiocb_to_siocb(iocb); 5501da177e4SLinus Torvalds int err; 5511da177e4SLinus Torvalds 5521da177e4SLinus Torvalds si->sock = sock; 5531da177e4SLinus Torvalds si->scm = NULL; 5541da177e4SLinus Torvalds si->msg = msg; 5551da177e4SLinus Torvalds si->size = size; 5561da177e4SLinus Torvalds 5571da177e4SLinus Torvalds err = security_socket_sendmsg(sock, msg, size); 5581da177e4SLinus Torvalds if (err) 5591da177e4SLinus Torvalds return err; 5601da177e4SLinus Torvalds 5611da177e4SLinus Torvalds return sock->ops->sendmsg(iocb, sock, msg, size); 5621da177e4SLinus Torvalds } 5631da177e4SLinus Torvalds 5641da177e4SLinus Torvalds int sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t size) 5651da177e4SLinus Torvalds { 5661da177e4SLinus Torvalds struct kiocb iocb; 5671da177e4SLinus Torvalds struct sock_iocb siocb; 5681da177e4SLinus Torvalds int ret; 5691da177e4SLinus Torvalds 5701da177e4SLinus Torvalds init_sync_kiocb(&iocb, NULL); 5711da177e4SLinus Torvalds iocb.private = &siocb; 5721da177e4SLinus Torvalds ret = __sock_sendmsg(&iocb, sock, msg, size); 5731da177e4SLinus Torvalds if (-EIOCBQUEUED == ret) 5741da177e4SLinus Torvalds ret = wait_on_sync_kiocb(&iocb); 5751da177e4SLinus Torvalds return ret; 5761da177e4SLinus Torvalds } 5771da177e4SLinus Torvalds 5781da177e4SLinus Torvalds int kernel_sendmsg(struct socket *sock, struct msghdr *msg, 5791da177e4SLinus Torvalds struct kvec *vec, size_t num, size_t size) 5801da177e4SLinus Torvalds { 5811da177e4SLinus Torvalds mm_segment_t oldfs = get_fs(); 5821da177e4SLinus Torvalds int result; 5831da177e4SLinus Torvalds 5841da177e4SLinus Torvalds set_fs(KERNEL_DS); 5851da177e4SLinus Torvalds /* 5861da177e4SLinus Torvalds * the following is safe, since for compiler definitions of kvec and 5871da177e4SLinus Torvalds * iovec are identical, yielding the same in-core layout and alignment 5881da177e4SLinus Torvalds */ 58989bddce5SStephen Hemminger msg->msg_iov = (struct iovec *)vec; 5901da177e4SLinus Torvalds msg->msg_iovlen = num; 5911da177e4SLinus Torvalds result = sock_sendmsg(sock, msg, size); 5921da177e4SLinus Torvalds set_fs(oldfs); 5931da177e4SLinus Torvalds return result; 5941da177e4SLinus Torvalds } 5951da177e4SLinus Torvalds 59692f37fd2SEric Dumazet /* 59792f37fd2SEric Dumazet * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP) 59892f37fd2SEric Dumazet */ 59992f37fd2SEric Dumazet void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk, 60092f37fd2SEric Dumazet struct sk_buff *skb) 60192f37fd2SEric Dumazet { 60292f37fd2SEric Dumazet ktime_t kt = skb->tstamp; 60392f37fd2SEric Dumazet 60492f37fd2SEric Dumazet if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) { 60592f37fd2SEric Dumazet struct timeval tv; 60692f37fd2SEric Dumazet /* Race occurred between timestamp enabling and packet 60792f37fd2SEric Dumazet receiving. Fill in the current time for now. */ 60892f37fd2SEric Dumazet if (kt.tv64 == 0) 60992f37fd2SEric Dumazet kt = ktime_get_real(); 61092f37fd2SEric Dumazet skb->tstamp = kt; 61192f37fd2SEric Dumazet tv = ktime_to_timeval(kt); 61292f37fd2SEric Dumazet put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP, sizeof(tv), &tv); 61392f37fd2SEric Dumazet } else { 61492f37fd2SEric Dumazet struct timespec ts; 61592f37fd2SEric Dumazet /* Race occurred between timestamp enabling and packet 61692f37fd2SEric Dumazet receiving. Fill in the current time for now. */ 61792f37fd2SEric Dumazet if (kt.tv64 == 0) 61892f37fd2SEric Dumazet kt = ktime_get_real(); 61992f37fd2SEric Dumazet skb->tstamp = kt; 62092f37fd2SEric Dumazet ts = ktime_to_timespec(kt); 62192f37fd2SEric Dumazet put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS, sizeof(ts), &ts); 62292f37fd2SEric Dumazet } 62392f37fd2SEric Dumazet } 62492f37fd2SEric Dumazet 6257c81fd8bSArnaldo Carvalho de Melo EXPORT_SYMBOL_GPL(__sock_recv_timestamp); 6267c81fd8bSArnaldo Carvalho de Melo 6271da177e4SLinus Torvalds static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock, 6281da177e4SLinus Torvalds struct msghdr *msg, size_t size, int flags) 6291da177e4SLinus Torvalds { 6301da177e4SLinus Torvalds int err; 6311da177e4SLinus Torvalds struct sock_iocb *si = kiocb_to_siocb(iocb); 6321da177e4SLinus Torvalds 6331da177e4SLinus Torvalds si->sock = sock; 6341da177e4SLinus Torvalds si->scm = NULL; 6351da177e4SLinus Torvalds si->msg = msg; 6361da177e4SLinus Torvalds si->size = size; 6371da177e4SLinus Torvalds si->flags = flags; 6381da177e4SLinus Torvalds 6391da177e4SLinus Torvalds err = security_socket_recvmsg(sock, msg, size, flags); 6401da177e4SLinus Torvalds if (err) 6411da177e4SLinus Torvalds return err; 6421da177e4SLinus Torvalds 6431da177e4SLinus Torvalds return sock->ops->recvmsg(iocb, sock, msg, size, flags); 6441da177e4SLinus Torvalds } 6451da177e4SLinus Torvalds 6461da177e4SLinus Torvalds int sock_recvmsg(struct socket *sock, struct msghdr *msg, 6471da177e4SLinus Torvalds size_t size, int flags) 6481da177e4SLinus Torvalds { 6491da177e4SLinus Torvalds struct kiocb iocb; 6501da177e4SLinus Torvalds struct sock_iocb siocb; 6511da177e4SLinus Torvalds int ret; 6521da177e4SLinus Torvalds 6531da177e4SLinus Torvalds init_sync_kiocb(&iocb, NULL); 6541da177e4SLinus Torvalds iocb.private = &siocb; 6551da177e4SLinus Torvalds ret = __sock_recvmsg(&iocb, sock, msg, size, flags); 6561da177e4SLinus Torvalds if (-EIOCBQUEUED == ret) 6571da177e4SLinus Torvalds ret = wait_on_sync_kiocb(&iocb); 6581da177e4SLinus Torvalds return ret; 6591da177e4SLinus Torvalds } 6601da177e4SLinus Torvalds 6611da177e4SLinus Torvalds int kernel_recvmsg(struct socket *sock, struct msghdr *msg, 66289bddce5SStephen Hemminger struct kvec *vec, size_t num, size_t size, int flags) 6631da177e4SLinus Torvalds { 6641da177e4SLinus Torvalds mm_segment_t oldfs = get_fs(); 6651da177e4SLinus Torvalds int result; 6661da177e4SLinus Torvalds 6671da177e4SLinus Torvalds set_fs(KERNEL_DS); 6681da177e4SLinus Torvalds /* 6691da177e4SLinus Torvalds * the following is safe, since for compiler definitions of kvec and 6701da177e4SLinus Torvalds * iovec are identical, yielding the same in-core layout and alignment 6711da177e4SLinus Torvalds */ 67289bddce5SStephen Hemminger msg->msg_iov = (struct iovec *)vec, msg->msg_iovlen = num; 6731da177e4SLinus Torvalds result = sock_recvmsg(sock, msg, size, flags); 6741da177e4SLinus Torvalds set_fs(oldfs); 6751da177e4SLinus Torvalds return result; 6761da177e4SLinus Torvalds } 6771da177e4SLinus Torvalds 6781da177e4SLinus Torvalds static void sock_aio_dtor(struct kiocb *iocb) 6791da177e4SLinus Torvalds { 6801da177e4SLinus Torvalds kfree(iocb->private); 6811da177e4SLinus Torvalds } 6821da177e4SLinus Torvalds 68320380731SArnaldo Carvalho de Melo static ssize_t sock_sendpage(struct file *file, struct page *page, 6841da177e4SLinus Torvalds int offset, size_t size, loff_t *ppos, int more) 6851da177e4SLinus Torvalds { 6861da177e4SLinus Torvalds struct socket *sock; 6871da177e4SLinus Torvalds int flags; 6881da177e4SLinus Torvalds 689b69aee04SEric Dumazet sock = file->private_data; 6901da177e4SLinus Torvalds 6911da177e4SLinus Torvalds flags = !(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT; 6921da177e4SLinus Torvalds if (more) 6931da177e4SLinus Torvalds flags |= MSG_MORE; 6941da177e4SLinus Torvalds 6951da177e4SLinus Torvalds return sock->ops->sendpage(sock, page, offset, size, flags); 6961da177e4SLinus Torvalds } 6971da177e4SLinus Torvalds 6989c55e01cSJens Axboe static ssize_t sock_splice_read(struct file *file, loff_t *ppos, 6999c55e01cSJens Axboe struct pipe_inode_info *pipe, size_t len, 7009c55e01cSJens Axboe unsigned int flags) 7019c55e01cSJens Axboe { 7029c55e01cSJens Axboe struct socket *sock = file->private_data; 7039c55e01cSJens Axboe 704997b37daSRémi Denis-Courmont if (unlikely(!sock->ops->splice_read)) 705997b37daSRémi Denis-Courmont return -EINVAL; 706997b37daSRémi Denis-Courmont 7079c55e01cSJens Axboe return sock->ops->splice_read(sock, ppos, pipe, len, flags); 7089c55e01cSJens Axboe } 7099c55e01cSJens Axboe 710ce1d4d3eSChristoph Hellwig static struct sock_iocb *alloc_sock_iocb(struct kiocb *iocb, 71189bddce5SStephen Hemminger struct sock_iocb *siocb) 712ce1d4d3eSChristoph Hellwig { 713ce1d4d3eSChristoph Hellwig if (!is_sync_kiocb(iocb)) { 714ce1d4d3eSChristoph Hellwig siocb = kmalloc(sizeof(*siocb), GFP_KERNEL); 715ce1d4d3eSChristoph Hellwig if (!siocb) 716ce1d4d3eSChristoph Hellwig return NULL; 717ce1d4d3eSChristoph Hellwig iocb->ki_dtor = sock_aio_dtor; 718ce1d4d3eSChristoph Hellwig } 719ce1d4d3eSChristoph Hellwig 720ce1d4d3eSChristoph Hellwig siocb->kiocb = iocb; 721ce1d4d3eSChristoph Hellwig iocb->private = siocb; 722ce1d4d3eSChristoph Hellwig return siocb; 723ce1d4d3eSChristoph Hellwig } 724ce1d4d3eSChristoph Hellwig 725ce1d4d3eSChristoph Hellwig static ssize_t do_sock_read(struct msghdr *msg, struct kiocb *iocb, 726027445c3SBadari Pulavarty struct file *file, const struct iovec *iov, 72789bddce5SStephen Hemminger unsigned long nr_segs) 728ce1d4d3eSChristoph Hellwig { 729ce1d4d3eSChristoph Hellwig struct socket *sock = file->private_data; 730ce1d4d3eSChristoph Hellwig size_t size = 0; 731ce1d4d3eSChristoph Hellwig int i; 732ce1d4d3eSChristoph Hellwig 733ce1d4d3eSChristoph Hellwig for (i = 0; i < nr_segs; i++) 734ce1d4d3eSChristoph Hellwig size += iov[i].iov_len; 735ce1d4d3eSChristoph Hellwig 736ce1d4d3eSChristoph Hellwig msg->msg_name = NULL; 737ce1d4d3eSChristoph Hellwig msg->msg_namelen = 0; 738ce1d4d3eSChristoph Hellwig msg->msg_control = NULL; 739ce1d4d3eSChristoph Hellwig msg->msg_controllen = 0; 740ce1d4d3eSChristoph Hellwig msg->msg_iov = (struct iovec *)iov; 741ce1d4d3eSChristoph Hellwig msg->msg_iovlen = nr_segs; 742ce1d4d3eSChristoph Hellwig msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0; 743ce1d4d3eSChristoph Hellwig 744ce1d4d3eSChristoph Hellwig return __sock_recvmsg(iocb, sock, msg, size, msg->msg_flags); 745ce1d4d3eSChristoph Hellwig } 746ce1d4d3eSChristoph Hellwig 747027445c3SBadari Pulavarty static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov, 748027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos) 749ce1d4d3eSChristoph Hellwig { 750ce1d4d3eSChristoph Hellwig struct sock_iocb siocb, *x; 751ce1d4d3eSChristoph Hellwig 752ce1d4d3eSChristoph Hellwig if (pos != 0) 753ce1d4d3eSChristoph Hellwig return -ESPIPE; 754027445c3SBadari Pulavarty 755027445c3SBadari Pulavarty if (iocb->ki_left == 0) /* Match SYS5 behaviour */ 756ce1d4d3eSChristoph Hellwig return 0; 757ce1d4d3eSChristoph Hellwig 758027445c3SBadari Pulavarty 759027445c3SBadari Pulavarty x = alloc_sock_iocb(iocb, &siocb); 760ce1d4d3eSChristoph Hellwig if (!x) 761ce1d4d3eSChristoph Hellwig return -ENOMEM; 762027445c3SBadari Pulavarty return do_sock_read(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs); 763ce1d4d3eSChristoph Hellwig } 764ce1d4d3eSChristoph Hellwig 765ce1d4d3eSChristoph Hellwig static ssize_t do_sock_write(struct msghdr *msg, struct kiocb *iocb, 766027445c3SBadari Pulavarty struct file *file, const struct iovec *iov, 76789bddce5SStephen Hemminger unsigned long nr_segs) 768ce1d4d3eSChristoph Hellwig { 769ce1d4d3eSChristoph Hellwig struct socket *sock = file->private_data; 770ce1d4d3eSChristoph Hellwig size_t size = 0; 771ce1d4d3eSChristoph Hellwig int i; 772ce1d4d3eSChristoph Hellwig 773ce1d4d3eSChristoph Hellwig for (i = 0; i < nr_segs; i++) 774ce1d4d3eSChristoph Hellwig size += iov[i].iov_len; 775ce1d4d3eSChristoph Hellwig 776ce1d4d3eSChristoph Hellwig msg->msg_name = NULL; 777ce1d4d3eSChristoph Hellwig msg->msg_namelen = 0; 778ce1d4d3eSChristoph Hellwig msg->msg_control = NULL; 779ce1d4d3eSChristoph Hellwig msg->msg_controllen = 0; 780ce1d4d3eSChristoph Hellwig msg->msg_iov = (struct iovec *)iov; 781ce1d4d3eSChristoph Hellwig msg->msg_iovlen = nr_segs; 782ce1d4d3eSChristoph Hellwig msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0; 783ce1d4d3eSChristoph Hellwig if (sock->type == SOCK_SEQPACKET) 784ce1d4d3eSChristoph Hellwig msg->msg_flags |= MSG_EOR; 785ce1d4d3eSChristoph Hellwig 786ce1d4d3eSChristoph Hellwig return __sock_sendmsg(iocb, sock, msg, size); 787ce1d4d3eSChristoph Hellwig } 788ce1d4d3eSChristoph Hellwig 789027445c3SBadari Pulavarty static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov, 790027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos) 7911da177e4SLinus Torvalds { 792ce1d4d3eSChristoph Hellwig struct sock_iocb siocb, *x; 7931da177e4SLinus Torvalds 794ce1d4d3eSChristoph Hellwig if (pos != 0) 795ce1d4d3eSChristoph Hellwig return -ESPIPE; 796027445c3SBadari Pulavarty 797027445c3SBadari Pulavarty x = alloc_sock_iocb(iocb, &siocb); 798ce1d4d3eSChristoph Hellwig if (!x) 799ce1d4d3eSChristoph Hellwig return -ENOMEM; 800ce1d4d3eSChristoph Hellwig 801027445c3SBadari Pulavarty return do_sock_write(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs); 8021da177e4SLinus Torvalds } 8031da177e4SLinus Torvalds 8041da177e4SLinus Torvalds /* 8051da177e4SLinus Torvalds * Atomic setting of ioctl hooks to avoid race 8061da177e4SLinus Torvalds * with module unload. 8071da177e4SLinus Torvalds */ 8081da177e4SLinus Torvalds 8094a3e2f71SArjan van de Ven static DEFINE_MUTEX(br_ioctl_mutex); 810881d966bSEric W. Biederman static int (*br_ioctl_hook) (struct net *, unsigned int cmd, void __user *arg) = NULL; 8111da177e4SLinus Torvalds 812881d966bSEric W. Biederman void brioctl_set(int (*hook) (struct net *, unsigned int, void __user *)) 8131da177e4SLinus Torvalds { 8144a3e2f71SArjan van de Ven mutex_lock(&br_ioctl_mutex); 8151da177e4SLinus Torvalds br_ioctl_hook = hook; 8164a3e2f71SArjan van de Ven mutex_unlock(&br_ioctl_mutex); 8171da177e4SLinus Torvalds } 81889bddce5SStephen Hemminger 8191da177e4SLinus Torvalds EXPORT_SYMBOL(brioctl_set); 8201da177e4SLinus Torvalds 8214a3e2f71SArjan van de Ven static DEFINE_MUTEX(vlan_ioctl_mutex); 822881d966bSEric W. Biederman static int (*vlan_ioctl_hook) (struct net *, void __user *arg); 8231da177e4SLinus Torvalds 824881d966bSEric W. Biederman void vlan_ioctl_set(int (*hook) (struct net *, void __user *)) 8251da177e4SLinus Torvalds { 8264a3e2f71SArjan van de Ven mutex_lock(&vlan_ioctl_mutex); 8271da177e4SLinus Torvalds vlan_ioctl_hook = hook; 8284a3e2f71SArjan van de Ven mutex_unlock(&vlan_ioctl_mutex); 8291da177e4SLinus Torvalds } 83089bddce5SStephen Hemminger 8311da177e4SLinus Torvalds EXPORT_SYMBOL(vlan_ioctl_set); 8321da177e4SLinus Torvalds 8334a3e2f71SArjan van de Ven static DEFINE_MUTEX(dlci_ioctl_mutex); 8341da177e4SLinus Torvalds static int (*dlci_ioctl_hook) (unsigned int, void __user *); 8351da177e4SLinus Torvalds 8361da177e4SLinus Torvalds void dlci_ioctl_set(int (*hook) (unsigned int, void __user *)) 8371da177e4SLinus Torvalds { 8384a3e2f71SArjan van de Ven mutex_lock(&dlci_ioctl_mutex); 8391da177e4SLinus Torvalds dlci_ioctl_hook = hook; 8404a3e2f71SArjan van de Ven mutex_unlock(&dlci_ioctl_mutex); 8411da177e4SLinus Torvalds } 84289bddce5SStephen Hemminger 8431da177e4SLinus Torvalds EXPORT_SYMBOL(dlci_ioctl_set); 8441da177e4SLinus Torvalds 8451da177e4SLinus Torvalds /* 8461da177e4SLinus Torvalds * With an ioctl, arg may well be a user mode pointer, but we don't know 8471da177e4SLinus Torvalds * what to do with it - that's up to the protocol still. 8481da177e4SLinus Torvalds */ 8491da177e4SLinus Torvalds 8501da177e4SLinus Torvalds static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg) 8511da177e4SLinus Torvalds { 8521da177e4SLinus Torvalds struct socket *sock; 853881d966bSEric W. Biederman struct sock *sk; 8541da177e4SLinus Torvalds void __user *argp = (void __user *)arg; 8551da177e4SLinus Torvalds int pid, err; 856881d966bSEric W. Biederman struct net *net; 8571da177e4SLinus Torvalds 858b69aee04SEric Dumazet sock = file->private_data; 859881d966bSEric W. Biederman sk = sock->sk; 8603b1e0a65SYOSHIFUJI Hideaki net = sock_net(sk); 8611da177e4SLinus Torvalds if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) { 862881d966bSEric W. Biederman err = dev_ioctl(net, cmd, argp); 8631da177e4SLinus Torvalds } else 864d86b5e0eSAdrian Bunk #ifdef CONFIG_WIRELESS_EXT 8651da177e4SLinus Torvalds if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) { 866881d966bSEric W. Biederman err = dev_ioctl(net, cmd, argp); 8671da177e4SLinus Torvalds } else 868d86b5e0eSAdrian Bunk #endif /* CONFIG_WIRELESS_EXT */ 8691da177e4SLinus Torvalds switch (cmd) { 8701da177e4SLinus Torvalds case FIOSETOWN: 8711da177e4SLinus Torvalds case SIOCSPGRP: 8721da177e4SLinus Torvalds err = -EFAULT; 8731da177e4SLinus Torvalds if (get_user(pid, (int __user *)argp)) 8741da177e4SLinus Torvalds break; 8751da177e4SLinus Torvalds err = f_setown(sock->file, pid, 1); 8761da177e4SLinus Torvalds break; 8771da177e4SLinus Torvalds case FIOGETOWN: 8781da177e4SLinus Torvalds case SIOCGPGRP: 879609d7fa9SEric W. Biederman err = put_user(f_getown(sock->file), 88089bddce5SStephen Hemminger (int __user *)argp); 8811da177e4SLinus Torvalds break; 8821da177e4SLinus Torvalds case SIOCGIFBR: 8831da177e4SLinus Torvalds case SIOCSIFBR: 8841da177e4SLinus Torvalds case SIOCBRADDBR: 8851da177e4SLinus Torvalds case SIOCBRDELBR: 8861da177e4SLinus Torvalds err = -ENOPKG; 8871da177e4SLinus Torvalds if (!br_ioctl_hook) 8881da177e4SLinus Torvalds request_module("bridge"); 8891da177e4SLinus Torvalds 8904a3e2f71SArjan van de Ven mutex_lock(&br_ioctl_mutex); 8911da177e4SLinus Torvalds if (br_ioctl_hook) 892881d966bSEric W. Biederman err = br_ioctl_hook(net, cmd, argp); 8934a3e2f71SArjan van de Ven mutex_unlock(&br_ioctl_mutex); 8941da177e4SLinus Torvalds break; 8951da177e4SLinus Torvalds case SIOCGIFVLAN: 8961da177e4SLinus Torvalds case SIOCSIFVLAN: 8971da177e4SLinus Torvalds err = -ENOPKG; 8981da177e4SLinus Torvalds if (!vlan_ioctl_hook) 8991da177e4SLinus Torvalds request_module("8021q"); 9001da177e4SLinus Torvalds 9014a3e2f71SArjan van de Ven mutex_lock(&vlan_ioctl_mutex); 9021da177e4SLinus Torvalds if (vlan_ioctl_hook) 903881d966bSEric W. Biederman err = vlan_ioctl_hook(net, argp); 9044a3e2f71SArjan van de Ven mutex_unlock(&vlan_ioctl_mutex); 9051da177e4SLinus Torvalds break; 9061da177e4SLinus Torvalds case SIOCADDDLCI: 9071da177e4SLinus Torvalds case SIOCDELDLCI: 9081da177e4SLinus Torvalds err = -ENOPKG; 9091da177e4SLinus Torvalds if (!dlci_ioctl_hook) 9101da177e4SLinus Torvalds request_module("dlci"); 9111da177e4SLinus Torvalds 9124a3e2f71SArjan van de Ven mutex_lock(&dlci_ioctl_mutex); 9137512cbf6SPavel Emelyanov if (dlci_ioctl_hook) 9141da177e4SLinus Torvalds err = dlci_ioctl_hook(cmd, argp); 9154a3e2f71SArjan van de Ven mutex_unlock(&dlci_ioctl_mutex); 9161da177e4SLinus Torvalds break; 9171da177e4SLinus Torvalds default: 9181da177e4SLinus Torvalds err = sock->ops->ioctl(sock, cmd, arg); 919b5e5fa5eSChristoph Hellwig 920b5e5fa5eSChristoph Hellwig /* 921b5e5fa5eSChristoph Hellwig * If this ioctl is unknown try to hand it down 922b5e5fa5eSChristoph Hellwig * to the NIC driver. 923b5e5fa5eSChristoph Hellwig */ 924b5e5fa5eSChristoph Hellwig if (err == -ENOIOCTLCMD) 925881d966bSEric W. Biederman err = dev_ioctl(net, cmd, argp); 9261da177e4SLinus Torvalds break; 9271da177e4SLinus Torvalds } 9281da177e4SLinus Torvalds return err; 9291da177e4SLinus Torvalds } 9301da177e4SLinus Torvalds 9311da177e4SLinus Torvalds int sock_create_lite(int family, int type, int protocol, struct socket **res) 9321da177e4SLinus Torvalds { 9331da177e4SLinus Torvalds int err; 9341da177e4SLinus Torvalds struct socket *sock = NULL; 9351da177e4SLinus Torvalds 9361da177e4SLinus Torvalds err = security_socket_create(family, type, protocol, 1); 9371da177e4SLinus Torvalds if (err) 9381da177e4SLinus Torvalds goto out; 9391da177e4SLinus Torvalds 9401da177e4SLinus Torvalds sock = sock_alloc(); 9411da177e4SLinus Torvalds if (!sock) { 9421da177e4SLinus Torvalds err = -ENOMEM; 9431da177e4SLinus Torvalds goto out; 9441da177e4SLinus Torvalds } 9451da177e4SLinus Torvalds 9461da177e4SLinus Torvalds sock->type = type; 9477420ed23SVenkat Yekkirala err = security_socket_post_create(sock, family, type, protocol, 1); 9487420ed23SVenkat Yekkirala if (err) 9497420ed23SVenkat Yekkirala goto out_release; 9507420ed23SVenkat Yekkirala 9511da177e4SLinus Torvalds out: 9521da177e4SLinus Torvalds *res = sock; 9531da177e4SLinus Torvalds return err; 9547420ed23SVenkat Yekkirala out_release: 9557420ed23SVenkat Yekkirala sock_release(sock); 9567420ed23SVenkat Yekkirala sock = NULL; 9577420ed23SVenkat Yekkirala goto out; 9581da177e4SLinus Torvalds } 9591da177e4SLinus Torvalds 9601da177e4SLinus Torvalds /* No kernel lock held - perfect */ 9611da177e4SLinus Torvalds static unsigned int sock_poll(struct file *file, poll_table *wait) 9621da177e4SLinus Torvalds { 9631da177e4SLinus Torvalds struct socket *sock; 9641da177e4SLinus Torvalds 9651da177e4SLinus Torvalds /* 9661da177e4SLinus Torvalds * We can't return errors to poll, so it's either yes or no. 9671da177e4SLinus Torvalds */ 968b69aee04SEric Dumazet sock = file->private_data; 9691da177e4SLinus Torvalds return sock->ops->poll(file, sock, wait); 9701da177e4SLinus Torvalds } 9711da177e4SLinus Torvalds 9721da177e4SLinus Torvalds static int sock_mmap(struct file *file, struct vm_area_struct *vma) 9731da177e4SLinus Torvalds { 974b69aee04SEric Dumazet struct socket *sock = file->private_data; 9751da177e4SLinus Torvalds 9761da177e4SLinus Torvalds return sock->ops->mmap(file, sock, vma); 9771da177e4SLinus Torvalds } 9781da177e4SLinus Torvalds 97920380731SArnaldo Carvalho de Melo static int sock_close(struct inode *inode, struct file *filp) 9801da177e4SLinus Torvalds { 9811da177e4SLinus Torvalds /* 9821da177e4SLinus Torvalds * It was possible the inode is NULL we were 9831da177e4SLinus Torvalds * closing an unfinished socket. 9841da177e4SLinus Torvalds */ 9851da177e4SLinus Torvalds 98689bddce5SStephen Hemminger if (!inode) { 9871da177e4SLinus Torvalds printk(KERN_DEBUG "sock_close: NULL inode\n"); 9881da177e4SLinus Torvalds return 0; 9891da177e4SLinus Torvalds } 9901da177e4SLinus Torvalds sock_fasync(-1, filp, 0); 9911da177e4SLinus Torvalds sock_release(SOCKET_I(inode)); 9921da177e4SLinus Torvalds return 0; 9931da177e4SLinus Torvalds } 9941da177e4SLinus Torvalds 9951da177e4SLinus Torvalds /* 9961da177e4SLinus Torvalds * Update the socket async list 9971da177e4SLinus Torvalds * 9981da177e4SLinus Torvalds * Fasync_list locking strategy. 9991da177e4SLinus Torvalds * 10001da177e4SLinus Torvalds * 1. fasync_list is modified only under process context socket lock 10011da177e4SLinus Torvalds * i.e. under semaphore. 10021da177e4SLinus Torvalds * 2. fasync_list is used under read_lock(&sk->sk_callback_lock) 10031da177e4SLinus Torvalds * or under socket lock. 10041da177e4SLinus Torvalds * 3. fasync_list can be used from softirq context, so that 10051da177e4SLinus Torvalds * modification under socket lock have to be enhanced with 10061da177e4SLinus Torvalds * write_lock_bh(&sk->sk_callback_lock). 10071da177e4SLinus Torvalds * --ANK (990710) 10081da177e4SLinus Torvalds */ 10091da177e4SLinus Torvalds 10101da177e4SLinus Torvalds static int sock_fasync(int fd, struct file *filp, int on) 10111da177e4SLinus Torvalds { 10121da177e4SLinus Torvalds struct fasync_struct *fa, *fna = NULL, **prev; 10131da177e4SLinus Torvalds struct socket *sock; 10141da177e4SLinus Torvalds struct sock *sk; 10151da177e4SLinus Torvalds 101689bddce5SStephen Hemminger if (on) { 10178b3a7005SKris Katterjohn fna = kmalloc(sizeof(struct fasync_struct), GFP_KERNEL); 10181da177e4SLinus Torvalds if (fna == NULL) 10191da177e4SLinus Torvalds return -ENOMEM; 10201da177e4SLinus Torvalds } 10211da177e4SLinus Torvalds 1022b69aee04SEric Dumazet sock = filp->private_data; 10231da177e4SLinus Torvalds 102489bddce5SStephen Hemminger sk = sock->sk; 102589bddce5SStephen Hemminger if (sk == NULL) { 10261da177e4SLinus Torvalds kfree(fna); 10271da177e4SLinus Torvalds return -EINVAL; 10281da177e4SLinus Torvalds } 10291da177e4SLinus Torvalds 10301da177e4SLinus Torvalds lock_sock(sk); 10311da177e4SLinus Torvalds 10321da177e4SLinus Torvalds prev = &(sock->fasync_list); 10331da177e4SLinus Torvalds 10341da177e4SLinus Torvalds for (fa = *prev; fa != NULL; prev = &fa->fa_next, fa = *prev) 10351da177e4SLinus Torvalds if (fa->fa_file == filp) 10361da177e4SLinus Torvalds break; 10371da177e4SLinus Torvalds 103889bddce5SStephen Hemminger if (on) { 103989bddce5SStephen Hemminger if (fa != NULL) { 10401da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 10411da177e4SLinus Torvalds fa->fa_fd = fd; 10421da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 10431da177e4SLinus Torvalds 10441da177e4SLinus Torvalds kfree(fna); 10451da177e4SLinus Torvalds goto out; 10461da177e4SLinus Torvalds } 10471da177e4SLinus Torvalds fna->fa_file = filp; 10481da177e4SLinus Torvalds fna->fa_fd = fd; 10491da177e4SLinus Torvalds fna->magic = FASYNC_MAGIC; 10501da177e4SLinus Torvalds fna->fa_next = sock->fasync_list; 10511da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 10521da177e4SLinus Torvalds sock->fasync_list = fna; 10531da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 105489bddce5SStephen Hemminger } else { 105589bddce5SStephen Hemminger if (fa != NULL) { 10561da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 10571da177e4SLinus Torvalds *prev = fa->fa_next; 10581da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 10591da177e4SLinus Torvalds kfree(fa); 10601da177e4SLinus Torvalds } 10611da177e4SLinus Torvalds } 10621da177e4SLinus Torvalds 10631da177e4SLinus Torvalds out: 10641da177e4SLinus Torvalds release_sock(sock->sk); 10651da177e4SLinus Torvalds return 0; 10661da177e4SLinus Torvalds } 10671da177e4SLinus Torvalds 10681da177e4SLinus Torvalds /* This function may be called only under socket lock or callback_lock */ 10691da177e4SLinus Torvalds 10701da177e4SLinus Torvalds int sock_wake_async(struct socket *sock, int how, int band) 10711da177e4SLinus Torvalds { 10721da177e4SLinus Torvalds if (!sock || !sock->fasync_list) 10731da177e4SLinus Torvalds return -1; 107489bddce5SStephen Hemminger switch (how) { 10758d8ad9d7SPavel Emelyanov case SOCK_WAKE_WAITD: 10761da177e4SLinus Torvalds if (test_bit(SOCK_ASYNC_WAITDATA, &sock->flags)) 10771da177e4SLinus Torvalds break; 10781da177e4SLinus Torvalds goto call_kill; 10798d8ad9d7SPavel Emelyanov case SOCK_WAKE_SPACE: 10801da177e4SLinus Torvalds if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags)) 10811da177e4SLinus Torvalds break; 10821da177e4SLinus Torvalds /* fall through */ 10838d8ad9d7SPavel Emelyanov case SOCK_WAKE_IO: 10841da177e4SLinus Torvalds call_kill: 10851da177e4SLinus Torvalds __kill_fasync(sock->fasync_list, SIGIO, band); 10861da177e4SLinus Torvalds break; 10878d8ad9d7SPavel Emelyanov case SOCK_WAKE_URG: 10881da177e4SLinus Torvalds __kill_fasync(sock->fasync_list, SIGURG, band); 10891da177e4SLinus Torvalds } 10901da177e4SLinus Torvalds return 0; 10911da177e4SLinus Torvalds } 10921da177e4SLinus Torvalds 10931b8d7ae4SEric W. Biederman static int __sock_create(struct net *net, int family, int type, int protocol, 109489bddce5SStephen Hemminger struct socket **res, int kern) 10951da177e4SLinus Torvalds { 10961da177e4SLinus Torvalds int err; 10971da177e4SLinus Torvalds struct socket *sock; 109855737fdaSStephen Hemminger const struct net_proto_family *pf; 10991da177e4SLinus Torvalds 11001da177e4SLinus Torvalds /* 11011da177e4SLinus Torvalds * Check protocol is in range 11021da177e4SLinus Torvalds */ 11031da177e4SLinus Torvalds if (family < 0 || family >= NPROTO) 11041da177e4SLinus Torvalds return -EAFNOSUPPORT; 11051da177e4SLinus Torvalds if (type < 0 || type >= SOCK_MAX) 11061da177e4SLinus Torvalds return -EINVAL; 11071da177e4SLinus Torvalds 11081da177e4SLinus Torvalds /* Compatibility. 11091da177e4SLinus Torvalds 11101da177e4SLinus Torvalds This uglymoron is moved from INET layer to here to avoid 11111da177e4SLinus Torvalds deadlock in module load. 11121da177e4SLinus Torvalds */ 11131da177e4SLinus Torvalds if (family == PF_INET && type == SOCK_PACKET) { 11141da177e4SLinus Torvalds static int warned; 11151da177e4SLinus Torvalds if (!warned) { 11161da177e4SLinus Torvalds warned = 1; 111789bddce5SStephen Hemminger printk(KERN_INFO "%s uses obsolete (PF_INET,SOCK_PACKET)\n", 111889bddce5SStephen Hemminger current->comm); 11191da177e4SLinus Torvalds } 11201da177e4SLinus Torvalds family = PF_PACKET; 11211da177e4SLinus Torvalds } 11221da177e4SLinus Torvalds 11231da177e4SLinus Torvalds err = security_socket_create(family, type, protocol, kern); 11241da177e4SLinus Torvalds if (err) 11251da177e4SLinus Torvalds return err; 11261da177e4SLinus Torvalds 112755737fdaSStephen Hemminger /* 112855737fdaSStephen Hemminger * Allocate the socket and allow the family to set things up. if 112955737fdaSStephen Hemminger * the protocol is 0, the family is instructed to select an appropriate 113055737fdaSStephen Hemminger * default. 113155737fdaSStephen Hemminger */ 113255737fdaSStephen Hemminger sock = sock_alloc(); 113355737fdaSStephen Hemminger if (!sock) { 113455737fdaSStephen Hemminger if (net_ratelimit()) 113555737fdaSStephen Hemminger printk(KERN_WARNING "socket: no more sockets\n"); 113655737fdaSStephen Hemminger return -ENFILE; /* Not exactly a match, but its the 113755737fdaSStephen Hemminger closest posix thing */ 113855737fdaSStephen Hemminger } 113955737fdaSStephen Hemminger 114055737fdaSStephen Hemminger sock->type = type; 114155737fdaSStephen Hemminger 11421da177e4SLinus Torvalds #if defined(CONFIG_KMOD) 11431da177e4SLinus Torvalds /* Attempt to load a protocol module if the find failed. 11441da177e4SLinus Torvalds * 11451da177e4SLinus Torvalds * 12/09/1996 Marcin: But! this makes REALLY only sense, if the user 11461da177e4SLinus Torvalds * requested real, full-featured networking support upon configuration. 11471da177e4SLinus Torvalds * Otherwise module support will break! 11481da177e4SLinus Torvalds */ 114955737fdaSStephen Hemminger if (net_families[family] == NULL) 11501da177e4SLinus Torvalds request_module("net-pf-%d", family); 11511da177e4SLinus Torvalds #endif 11521da177e4SLinus Torvalds 115355737fdaSStephen Hemminger rcu_read_lock(); 115455737fdaSStephen Hemminger pf = rcu_dereference(net_families[family]); 11551da177e4SLinus Torvalds err = -EAFNOSUPPORT; 115655737fdaSStephen Hemminger if (!pf) 115755737fdaSStephen Hemminger goto out_release; 11581da177e4SLinus Torvalds 11591da177e4SLinus Torvalds /* 11601da177e4SLinus Torvalds * We will call the ->create function, that possibly is in a loadable 11611da177e4SLinus Torvalds * module, so we have to bump that loadable module refcnt first. 11621da177e4SLinus Torvalds */ 116355737fdaSStephen Hemminger if (!try_module_get(pf->owner)) 11641da177e4SLinus Torvalds goto out_release; 11651da177e4SLinus Torvalds 116655737fdaSStephen Hemminger /* Now protected by module ref count */ 116755737fdaSStephen Hemminger rcu_read_unlock(); 116855737fdaSStephen Hemminger 11691b8d7ae4SEric W. Biederman err = pf->create(net, sock, protocol); 117055737fdaSStephen Hemminger if (err < 0) 11711da177e4SLinus Torvalds goto out_module_put; 1172a79af59eSFrank Filz 11731da177e4SLinus Torvalds /* 11741da177e4SLinus Torvalds * Now to bump the refcnt of the [loadable] module that owns this 11751da177e4SLinus Torvalds * socket at sock_release time we decrement its refcnt. 11761da177e4SLinus Torvalds */ 117755737fdaSStephen Hemminger if (!try_module_get(sock->ops->owner)) 117855737fdaSStephen Hemminger goto out_module_busy; 117955737fdaSStephen Hemminger 11801da177e4SLinus Torvalds /* 11811da177e4SLinus Torvalds * Now that we're done with the ->create function, the [loadable] 11821da177e4SLinus Torvalds * module can have its refcnt decremented 11831da177e4SLinus Torvalds */ 118455737fdaSStephen Hemminger module_put(pf->owner); 11857420ed23SVenkat Yekkirala err = security_socket_post_create(sock, family, type, protocol, kern); 11867420ed23SVenkat Yekkirala if (err) 11873b185525SHerbert Xu goto out_sock_release; 118855737fdaSStephen Hemminger *res = sock; 11891da177e4SLinus Torvalds 119055737fdaSStephen Hemminger return 0; 119155737fdaSStephen Hemminger 119255737fdaSStephen Hemminger out_module_busy: 119355737fdaSStephen Hemminger err = -EAFNOSUPPORT; 11941da177e4SLinus Torvalds out_module_put: 119555737fdaSStephen Hemminger sock->ops = NULL; 119655737fdaSStephen Hemminger module_put(pf->owner); 119755737fdaSStephen Hemminger out_sock_release: 11981da177e4SLinus Torvalds sock_release(sock); 119955737fdaSStephen Hemminger return err; 120055737fdaSStephen Hemminger 120155737fdaSStephen Hemminger out_release: 120255737fdaSStephen Hemminger rcu_read_unlock(); 120355737fdaSStephen Hemminger goto out_sock_release; 12041da177e4SLinus Torvalds } 12051da177e4SLinus Torvalds 12061da177e4SLinus Torvalds int sock_create(int family, int type, int protocol, struct socket **res) 12071da177e4SLinus Torvalds { 12081b8d7ae4SEric W. Biederman return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0); 12091da177e4SLinus Torvalds } 12101da177e4SLinus Torvalds 12111da177e4SLinus Torvalds int sock_create_kern(int family, int type, int protocol, struct socket **res) 12121da177e4SLinus Torvalds { 12131b8d7ae4SEric W. Biederman return __sock_create(&init_net, family, type, protocol, res, 1); 12141da177e4SLinus Torvalds } 12151da177e4SLinus Torvalds 12161da177e4SLinus Torvalds asmlinkage long sys_socket(int family, int type, int protocol) 12171da177e4SLinus Torvalds { 12181da177e4SLinus Torvalds int retval; 12191da177e4SLinus Torvalds struct socket *sock; 12201da177e4SLinus Torvalds 12211da177e4SLinus Torvalds retval = sock_create(family, type, protocol, &sock); 12221da177e4SLinus Torvalds if (retval < 0) 12231da177e4SLinus Torvalds goto out; 12241da177e4SLinus Torvalds 12251da177e4SLinus Torvalds retval = sock_map_fd(sock); 12261da177e4SLinus Torvalds if (retval < 0) 12271da177e4SLinus Torvalds goto out_release; 12281da177e4SLinus Torvalds 12291da177e4SLinus Torvalds out: 12301da177e4SLinus Torvalds /* It may be already another descriptor 8) Not kernel problem. */ 12311da177e4SLinus Torvalds return retval; 12321da177e4SLinus Torvalds 12331da177e4SLinus Torvalds out_release: 12341da177e4SLinus Torvalds sock_release(sock); 12351da177e4SLinus Torvalds return retval; 12361da177e4SLinus Torvalds } 12371da177e4SLinus Torvalds 12381da177e4SLinus Torvalds /* 12391da177e4SLinus Torvalds * Create a pair of connected sockets. 12401da177e4SLinus Torvalds */ 12411da177e4SLinus Torvalds 124289bddce5SStephen Hemminger asmlinkage long sys_socketpair(int family, int type, int protocol, 124389bddce5SStephen Hemminger int __user *usockvec) 12441da177e4SLinus Torvalds { 12451da177e4SLinus Torvalds struct socket *sock1, *sock2; 12461da177e4SLinus Torvalds int fd1, fd2, err; 1247db349509SAl Viro struct file *newfile1, *newfile2; 12481da177e4SLinus Torvalds 12491da177e4SLinus Torvalds /* 12501da177e4SLinus Torvalds * Obtain the first socket and check if the underlying protocol 12511da177e4SLinus Torvalds * supports the socketpair call. 12521da177e4SLinus Torvalds */ 12531da177e4SLinus Torvalds 12541da177e4SLinus Torvalds err = sock_create(family, type, protocol, &sock1); 12551da177e4SLinus Torvalds if (err < 0) 12561da177e4SLinus Torvalds goto out; 12571da177e4SLinus Torvalds 12581da177e4SLinus Torvalds err = sock_create(family, type, protocol, &sock2); 12591da177e4SLinus Torvalds if (err < 0) 12601da177e4SLinus Torvalds goto out_release_1; 12611da177e4SLinus Torvalds 12621da177e4SLinus Torvalds err = sock1->ops->socketpair(sock1, sock2); 12631da177e4SLinus Torvalds if (err < 0) 12641da177e4SLinus Torvalds goto out_release_both; 12651da177e4SLinus Torvalds 1266db349509SAl Viro fd1 = sock_alloc_fd(&newfile1); 1267bf3c23d1SDavid S. Miller if (unlikely(fd1 < 0)) { 1268bf3c23d1SDavid S. Miller err = fd1; 12691da177e4SLinus Torvalds goto out_release_both; 1270bf3c23d1SDavid S. Miller } 12711da177e4SLinus Torvalds 1272db349509SAl Viro fd2 = sock_alloc_fd(&newfile2); 1273db349509SAl Viro if (unlikely(fd2 < 0)) { 1274bf3c23d1SDavid S. Miller err = fd2; 1275db349509SAl Viro put_filp(newfile1); 1276db349509SAl Viro put_unused_fd(fd1); 1277db349509SAl Viro goto out_release_both; 1278db349509SAl Viro } 12791da177e4SLinus Torvalds 1280db349509SAl Viro err = sock_attach_fd(sock1, newfile1); 1281db349509SAl Viro if (unlikely(err < 0)) { 1282db349509SAl Viro goto out_fd2; 1283db349509SAl Viro } 1284db349509SAl Viro 1285db349509SAl Viro err = sock_attach_fd(sock2, newfile2); 1286db349509SAl Viro if (unlikely(err < 0)) { 1287db349509SAl Viro fput(newfile1); 1288db349509SAl Viro goto out_fd1; 1289db349509SAl Viro } 1290db349509SAl Viro 1291db349509SAl Viro err = audit_fd_pair(fd1, fd2); 1292db349509SAl Viro if (err < 0) { 1293db349509SAl Viro fput(newfile1); 1294db349509SAl Viro fput(newfile2); 1295db349509SAl Viro goto out_fd; 1296db349509SAl Viro } 1297db349509SAl Viro 1298db349509SAl Viro fd_install(fd1, newfile1); 1299db349509SAl Viro fd_install(fd2, newfile2); 13001da177e4SLinus Torvalds /* fd1 and fd2 may be already another descriptors. 13011da177e4SLinus Torvalds * Not kernel problem. 13021da177e4SLinus Torvalds */ 13031da177e4SLinus Torvalds 13041da177e4SLinus Torvalds err = put_user(fd1, &usockvec[0]); 13051da177e4SLinus Torvalds if (!err) 13061da177e4SLinus Torvalds err = put_user(fd2, &usockvec[1]); 13071da177e4SLinus Torvalds if (!err) 13081da177e4SLinus Torvalds return 0; 13091da177e4SLinus Torvalds 13101da177e4SLinus Torvalds sys_close(fd2); 13111da177e4SLinus Torvalds sys_close(fd1); 13121da177e4SLinus Torvalds return err; 13131da177e4SLinus Torvalds 13141da177e4SLinus Torvalds out_release_both: 13151da177e4SLinus Torvalds sock_release(sock2); 13161da177e4SLinus Torvalds out_release_1: 13171da177e4SLinus Torvalds sock_release(sock1); 13181da177e4SLinus Torvalds out: 13191da177e4SLinus Torvalds return err; 1320db349509SAl Viro 1321db349509SAl Viro out_fd2: 1322db349509SAl Viro put_filp(newfile1); 1323db349509SAl Viro sock_release(sock1); 1324db349509SAl Viro out_fd1: 1325db349509SAl Viro put_filp(newfile2); 1326db349509SAl Viro sock_release(sock2); 1327db349509SAl Viro out_fd: 1328db349509SAl Viro put_unused_fd(fd1); 1329db349509SAl Viro put_unused_fd(fd2); 1330db349509SAl Viro goto out; 13311da177e4SLinus Torvalds } 13321da177e4SLinus Torvalds 13331da177e4SLinus Torvalds /* 13341da177e4SLinus Torvalds * Bind a name to a socket. Nothing much to do here since it's 13351da177e4SLinus Torvalds * the protocol's responsibility to handle the local address. 13361da177e4SLinus Torvalds * 13371da177e4SLinus Torvalds * We move the socket address to kernel space before we call 13381da177e4SLinus Torvalds * the protocol layer (having also checked the address is ok). 13391da177e4SLinus Torvalds */ 13401da177e4SLinus Torvalds 13411da177e4SLinus Torvalds asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen) 13421da177e4SLinus Torvalds { 13431da177e4SLinus Torvalds struct socket *sock; 13441da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 13456cb153caSBenjamin LaHaise int err, fput_needed; 13461da177e4SLinus Torvalds 134789bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 134889bddce5SStephen Hemminger if (sock) { 134989bddce5SStephen Hemminger err = move_addr_to_kernel(umyaddr, addrlen, address); 135089bddce5SStephen Hemminger if (err >= 0) { 135189bddce5SStephen Hemminger err = security_socket_bind(sock, 135289bddce5SStephen Hemminger (struct sockaddr *)address, 135389bddce5SStephen Hemminger addrlen); 13546cb153caSBenjamin LaHaise if (!err) 13556cb153caSBenjamin LaHaise err = sock->ops->bind(sock, 135689bddce5SStephen Hemminger (struct sockaddr *) 135789bddce5SStephen Hemminger address, addrlen); 13581da177e4SLinus Torvalds } 13596cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 13601da177e4SLinus Torvalds } 13611da177e4SLinus Torvalds return err; 13621da177e4SLinus Torvalds } 13631da177e4SLinus Torvalds 13641da177e4SLinus Torvalds /* 13651da177e4SLinus Torvalds * Perform a listen. Basically, we allow the protocol to do anything 13661da177e4SLinus Torvalds * necessary for a listen, and if that works, we mark the socket as 13671da177e4SLinus Torvalds * ready for listening. 13681da177e4SLinus Torvalds */ 13691da177e4SLinus Torvalds 13701da177e4SLinus Torvalds asmlinkage long sys_listen(int fd, int backlog) 13711da177e4SLinus Torvalds { 13721da177e4SLinus Torvalds struct socket *sock; 13736cb153caSBenjamin LaHaise int err, fput_needed; 1374b8e1f9b5SPavel Emelyanov int somaxconn; 13751da177e4SLinus Torvalds 137689bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 137789bddce5SStephen Hemminger if (sock) { 13783b1e0a65SYOSHIFUJI Hideaki somaxconn = sock_net(sock->sk)->sysctl_somaxconn; 1379b8e1f9b5SPavel Emelyanov if ((unsigned)backlog > somaxconn) 1380b8e1f9b5SPavel Emelyanov backlog = somaxconn; 13811da177e4SLinus Torvalds 13821da177e4SLinus Torvalds err = security_socket_listen(sock, backlog); 13836cb153caSBenjamin LaHaise if (!err) 13841da177e4SLinus Torvalds err = sock->ops->listen(sock, backlog); 13856cb153caSBenjamin LaHaise 13866cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 13871da177e4SLinus Torvalds } 13881da177e4SLinus Torvalds return err; 13891da177e4SLinus Torvalds } 13901da177e4SLinus Torvalds 13911da177e4SLinus Torvalds /* 13921da177e4SLinus Torvalds * For accept, we attempt to create a new socket, set up the link 13931da177e4SLinus Torvalds * with the client, wake up the client, then return the new 13941da177e4SLinus Torvalds * connected fd. We collect the address of the connector in kernel 13951da177e4SLinus Torvalds * space and move it to user at the very end. This is unclean because 13961da177e4SLinus Torvalds * we open the socket then return an error. 13971da177e4SLinus Torvalds * 13981da177e4SLinus Torvalds * 1003.1g adds the ability to recvmsg() to query connection pending 13991da177e4SLinus Torvalds * status to recvmsg. We need to add that support in a way thats 14001da177e4SLinus Torvalds * clean when we restucture accept also. 14011da177e4SLinus Torvalds */ 14021da177e4SLinus Torvalds 140389bddce5SStephen Hemminger asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr, 140489bddce5SStephen Hemminger int __user *upeer_addrlen) 14051da177e4SLinus Torvalds { 14061da177e4SLinus Torvalds struct socket *sock, *newsock; 140739d8c1b6SDavid S. Miller struct file *newfile; 14086cb153caSBenjamin LaHaise int err, len, newfd, fput_needed; 14091da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 14101da177e4SLinus Torvalds 14116cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 14121da177e4SLinus Torvalds if (!sock) 14131da177e4SLinus Torvalds goto out; 14141da177e4SLinus Torvalds 14151da177e4SLinus Torvalds err = -ENFILE; 14161da177e4SLinus Torvalds if (!(newsock = sock_alloc())) 14171da177e4SLinus Torvalds goto out_put; 14181da177e4SLinus Torvalds 14191da177e4SLinus Torvalds newsock->type = sock->type; 14201da177e4SLinus Torvalds newsock->ops = sock->ops; 14211da177e4SLinus Torvalds 14221da177e4SLinus Torvalds /* 14231da177e4SLinus Torvalds * We don't need try_module_get here, as the listening socket (sock) 14241da177e4SLinus Torvalds * has the protocol module (sock->ops->owner) held. 14251da177e4SLinus Torvalds */ 14261da177e4SLinus Torvalds __module_get(newsock->ops->owner); 14271da177e4SLinus Torvalds 142839d8c1b6SDavid S. Miller newfd = sock_alloc_fd(&newfile); 142939d8c1b6SDavid S. Miller if (unlikely(newfd < 0)) { 143039d8c1b6SDavid S. Miller err = newfd; 14319a1875e6SDavid S. Miller sock_release(newsock); 14329a1875e6SDavid S. Miller goto out_put; 143339d8c1b6SDavid S. Miller } 143439d8c1b6SDavid S. Miller 143539d8c1b6SDavid S. Miller err = sock_attach_fd(newsock, newfile); 143639d8c1b6SDavid S. Miller if (err < 0) 143779f4f642SAlexey Dobriyan goto out_fd_simple; 143839d8c1b6SDavid S. Miller 1439a79af59eSFrank Filz err = security_socket_accept(sock, newsock); 1440a79af59eSFrank Filz if (err) 144139d8c1b6SDavid S. Miller goto out_fd; 1442a79af59eSFrank Filz 14431da177e4SLinus Torvalds err = sock->ops->accept(sock, newsock, sock->file->f_flags); 14441da177e4SLinus Torvalds if (err < 0) 144539d8c1b6SDavid S. Miller goto out_fd; 14461da177e4SLinus Torvalds 14471da177e4SLinus Torvalds if (upeer_sockaddr) { 144889bddce5SStephen Hemminger if (newsock->ops->getname(newsock, (struct sockaddr *)address, 144989bddce5SStephen Hemminger &len, 2) < 0) { 14501da177e4SLinus Torvalds err = -ECONNABORTED; 145139d8c1b6SDavid S. Miller goto out_fd; 14521da177e4SLinus Torvalds } 145389bddce5SStephen Hemminger err = move_addr_to_user(address, len, upeer_sockaddr, 145489bddce5SStephen Hemminger upeer_addrlen); 14551da177e4SLinus Torvalds if (err < 0) 145639d8c1b6SDavid S. Miller goto out_fd; 14571da177e4SLinus Torvalds } 14581da177e4SLinus Torvalds 14591da177e4SLinus Torvalds /* File flags are not inherited via accept() unlike another OSes. */ 14601da177e4SLinus Torvalds 146139d8c1b6SDavid S. Miller fd_install(newfd, newfile); 146239d8c1b6SDavid S. Miller err = newfd; 14631da177e4SLinus Torvalds 14641da177e4SLinus Torvalds security_socket_post_accept(sock, newsock); 14651da177e4SLinus Torvalds 14661da177e4SLinus Torvalds out_put: 14676cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 14681da177e4SLinus Torvalds out: 14691da177e4SLinus Torvalds return err; 147079f4f642SAlexey Dobriyan out_fd_simple: 147179f4f642SAlexey Dobriyan sock_release(newsock); 147279f4f642SAlexey Dobriyan put_filp(newfile); 147379f4f642SAlexey Dobriyan put_unused_fd(newfd); 147479f4f642SAlexey Dobriyan goto out_put; 147539d8c1b6SDavid S. Miller out_fd: 14769606a216SDavid S. Miller fput(newfile); 147739d8c1b6SDavid S. Miller put_unused_fd(newfd); 14781da177e4SLinus Torvalds goto out_put; 14791da177e4SLinus Torvalds } 14801da177e4SLinus Torvalds 14811da177e4SLinus Torvalds /* 14821da177e4SLinus Torvalds * Attempt to connect to a socket with the server address. The address 14831da177e4SLinus Torvalds * is in user space so we verify it is OK and move it to kernel space. 14841da177e4SLinus Torvalds * 14851da177e4SLinus Torvalds * For 1003.1g we need to add clean support for a bind to AF_UNSPEC to 14861da177e4SLinus Torvalds * break bindings 14871da177e4SLinus Torvalds * 14881da177e4SLinus Torvalds * NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and 14891da177e4SLinus Torvalds * other SEQPACKET protocols that take time to connect() as it doesn't 14901da177e4SLinus Torvalds * include the -EINPROGRESS status for such sockets. 14911da177e4SLinus Torvalds */ 14921da177e4SLinus Torvalds 149389bddce5SStephen Hemminger asmlinkage long sys_connect(int fd, struct sockaddr __user *uservaddr, 149489bddce5SStephen Hemminger int addrlen) 14951da177e4SLinus Torvalds { 14961da177e4SLinus Torvalds struct socket *sock; 14971da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 14986cb153caSBenjamin LaHaise int err, fput_needed; 14991da177e4SLinus Torvalds 15006cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 15011da177e4SLinus Torvalds if (!sock) 15021da177e4SLinus Torvalds goto out; 15031da177e4SLinus Torvalds err = move_addr_to_kernel(uservaddr, addrlen, address); 15041da177e4SLinus Torvalds if (err < 0) 15051da177e4SLinus Torvalds goto out_put; 15061da177e4SLinus Torvalds 150789bddce5SStephen Hemminger err = 150889bddce5SStephen Hemminger security_socket_connect(sock, (struct sockaddr *)address, addrlen); 15091da177e4SLinus Torvalds if (err) 15101da177e4SLinus Torvalds goto out_put; 15111da177e4SLinus Torvalds 15121da177e4SLinus Torvalds err = sock->ops->connect(sock, (struct sockaddr *)address, addrlen, 15131da177e4SLinus Torvalds sock->file->f_flags); 15141da177e4SLinus Torvalds out_put: 15156cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 15161da177e4SLinus Torvalds out: 15171da177e4SLinus Torvalds return err; 15181da177e4SLinus Torvalds } 15191da177e4SLinus Torvalds 15201da177e4SLinus Torvalds /* 15211da177e4SLinus Torvalds * Get the local address ('name') of a socket object. Move the obtained 15221da177e4SLinus Torvalds * name to user space. 15231da177e4SLinus Torvalds */ 15241da177e4SLinus Torvalds 152589bddce5SStephen Hemminger asmlinkage long sys_getsockname(int fd, struct sockaddr __user *usockaddr, 152689bddce5SStephen Hemminger int __user *usockaddr_len) 15271da177e4SLinus Torvalds { 15281da177e4SLinus Torvalds struct socket *sock; 15291da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 15306cb153caSBenjamin LaHaise int len, err, fput_needed; 15311da177e4SLinus Torvalds 15326cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 15331da177e4SLinus Torvalds if (!sock) 15341da177e4SLinus Torvalds goto out; 15351da177e4SLinus Torvalds 15361da177e4SLinus Torvalds err = security_socket_getsockname(sock); 15371da177e4SLinus Torvalds if (err) 15381da177e4SLinus Torvalds goto out_put; 15391da177e4SLinus Torvalds 15401da177e4SLinus Torvalds err = sock->ops->getname(sock, (struct sockaddr *)address, &len, 0); 15411da177e4SLinus Torvalds if (err) 15421da177e4SLinus Torvalds goto out_put; 15431da177e4SLinus Torvalds err = move_addr_to_user(address, len, usockaddr, usockaddr_len); 15441da177e4SLinus Torvalds 15451da177e4SLinus Torvalds out_put: 15466cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 15471da177e4SLinus Torvalds out: 15481da177e4SLinus Torvalds return err; 15491da177e4SLinus Torvalds } 15501da177e4SLinus Torvalds 15511da177e4SLinus Torvalds /* 15521da177e4SLinus Torvalds * Get the remote address ('name') of a socket object. Move the obtained 15531da177e4SLinus Torvalds * name to user space. 15541da177e4SLinus Torvalds */ 15551da177e4SLinus Torvalds 155689bddce5SStephen Hemminger asmlinkage long sys_getpeername(int fd, struct sockaddr __user *usockaddr, 155789bddce5SStephen Hemminger int __user *usockaddr_len) 15581da177e4SLinus Torvalds { 15591da177e4SLinus Torvalds struct socket *sock; 15601da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 15616cb153caSBenjamin LaHaise int len, err, fput_needed; 15621da177e4SLinus Torvalds 156389bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 156489bddce5SStephen Hemminger if (sock != NULL) { 15651da177e4SLinus Torvalds err = security_socket_getpeername(sock); 15661da177e4SLinus Torvalds if (err) { 15676cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 15681da177e4SLinus Torvalds return err; 15691da177e4SLinus Torvalds } 15701da177e4SLinus Torvalds 157189bddce5SStephen Hemminger err = 157289bddce5SStephen Hemminger sock->ops->getname(sock, (struct sockaddr *)address, &len, 157389bddce5SStephen Hemminger 1); 15741da177e4SLinus Torvalds if (!err) 157589bddce5SStephen Hemminger err = move_addr_to_user(address, len, usockaddr, 157689bddce5SStephen Hemminger usockaddr_len); 15776cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 15781da177e4SLinus Torvalds } 15791da177e4SLinus Torvalds return err; 15801da177e4SLinus Torvalds } 15811da177e4SLinus Torvalds 15821da177e4SLinus Torvalds /* 15831da177e4SLinus Torvalds * Send a datagram to a given address. We move the address into kernel 15841da177e4SLinus Torvalds * space and check the user space data area is readable before invoking 15851da177e4SLinus Torvalds * the protocol. 15861da177e4SLinus Torvalds */ 15871da177e4SLinus Torvalds 158889bddce5SStephen Hemminger asmlinkage long sys_sendto(int fd, void __user *buff, size_t len, 158989bddce5SStephen Hemminger unsigned flags, struct sockaddr __user *addr, 159089bddce5SStephen Hemminger int addr_len) 15911da177e4SLinus Torvalds { 15921da177e4SLinus Torvalds struct socket *sock; 15931da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 15941da177e4SLinus Torvalds int err; 15951da177e4SLinus Torvalds struct msghdr msg; 15961da177e4SLinus Torvalds struct iovec iov; 15976cb153caSBenjamin LaHaise int fput_needed; 15981da177e4SLinus Torvalds 1599de0fa95cSPavel Emelyanov sock = sockfd_lookup_light(fd, &err, &fput_needed); 1600de0fa95cSPavel Emelyanov if (!sock) 16014387ff75SDavid S. Miller goto out; 16026cb153caSBenjamin LaHaise 16031da177e4SLinus Torvalds iov.iov_base = buff; 16041da177e4SLinus Torvalds iov.iov_len = len; 16051da177e4SLinus Torvalds msg.msg_name = NULL; 16061da177e4SLinus Torvalds msg.msg_iov = &iov; 16071da177e4SLinus Torvalds msg.msg_iovlen = 1; 16081da177e4SLinus Torvalds msg.msg_control = NULL; 16091da177e4SLinus Torvalds msg.msg_controllen = 0; 16101da177e4SLinus Torvalds msg.msg_namelen = 0; 16116cb153caSBenjamin LaHaise if (addr) { 16121da177e4SLinus Torvalds err = move_addr_to_kernel(addr, addr_len, address); 16131da177e4SLinus Torvalds if (err < 0) 16141da177e4SLinus Torvalds goto out_put; 16151da177e4SLinus Torvalds msg.msg_name = address; 16161da177e4SLinus Torvalds msg.msg_namelen = addr_len; 16171da177e4SLinus Torvalds } 16181da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 16191da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 16201da177e4SLinus Torvalds msg.msg_flags = flags; 16211da177e4SLinus Torvalds err = sock_sendmsg(sock, &msg, len); 16221da177e4SLinus Torvalds 16231da177e4SLinus Torvalds out_put: 1624de0fa95cSPavel Emelyanov fput_light(sock->file, fput_needed); 16254387ff75SDavid S. Miller out: 16261da177e4SLinus Torvalds return err; 16271da177e4SLinus Torvalds } 16281da177e4SLinus Torvalds 16291da177e4SLinus Torvalds /* 16301da177e4SLinus Torvalds * Send a datagram down a socket. 16311da177e4SLinus Torvalds */ 16321da177e4SLinus Torvalds 16331da177e4SLinus Torvalds asmlinkage long sys_send(int fd, void __user *buff, size_t len, unsigned flags) 16341da177e4SLinus Torvalds { 16351da177e4SLinus Torvalds return sys_sendto(fd, buff, len, flags, NULL, 0); 16361da177e4SLinus Torvalds } 16371da177e4SLinus Torvalds 16381da177e4SLinus Torvalds /* 16391da177e4SLinus Torvalds * Receive a frame from the socket and optionally record the address of the 16401da177e4SLinus Torvalds * sender. We verify the buffers are writable and if needed move the 16411da177e4SLinus Torvalds * sender address from kernel to user space. 16421da177e4SLinus Torvalds */ 16431da177e4SLinus Torvalds 164489bddce5SStephen Hemminger asmlinkage long sys_recvfrom(int fd, void __user *ubuf, size_t size, 164589bddce5SStephen Hemminger unsigned flags, struct sockaddr __user *addr, 164689bddce5SStephen Hemminger int __user *addr_len) 16471da177e4SLinus Torvalds { 16481da177e4SLinus Torvalds struct socket *sock; 16491da177e4SLinus Torvalds struct iovec iov; 16501da177e4SLinus Torvalds struct msghdr msg; 16511da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 16521da177e4SLinus Torvalds int err, err2; 16536cb153caSBenjamin LaHaise int fput_needed; 16541da177e4SLinus Torvalds 1655de0fa95cSPavel Emelyanov sock = sockfd_lookup_light(fd, &err, &fput_needed); 16561da177e4SLinus Torvalds if (!sock) 1657de0fa95cSPavel Emelyanov goto out; 16581da177e4SLinus Torvalds 16591da177e4SLinus Torvalds msg.msg_control = NULL; 16601da177e4SLinus Torvalds msg.msg_controllen = 0; 16611da177e4SLinus Torvalds msg.msg_iovlen = 1; 16621da177e4SLinus Torvalds msg.msg_iov = &iov; 16631da177e4SLinus Torvalds iov.iov_len = size; 16641da177e4SLinus Torvalds iov.iov_base = ubuf; 16651da177e4SLinus Torvalds msg.msg_name = address; 16661da177e4SLinus Torvalds msg.msg_namelen = MAX_SOCK_ADDR; 16671da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 16681da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 16691da177e4SLinus Torvalds err = sock_recvmsg(sock, &msg, size, flags); 16701da177e4SLinus Torvalds 167189bddce5SStephen Hemminger if (err >= 0 && addr != NULL) { 16721da177e4SLinus Torvalds err2 = move_addr_to_user(address, msg.msg_namelen, addr, addr_len); 16731da177e4SLinus Torvalds if (err2 < 0) 16741da177e4SLinus Torvalds err = err2; 16751da177e4SLinus Torvalds } 1676de0fa95cSPavel Emelyanov 1677de0fa95cSPavel Emelyanov fput_light(sock->file, fput_needed); 16784387ff75SDavid S. Miller out: 16791da177e4SLinus Torvalds return err; 16801da177e4SLinus Torvalds } 16811da177e4SLinus Torvalds 16821da177e4SLinus Torvalds /* 16831da177e4SLinus Torvalds * Receive a datagram from a socket. 16841da177e4SLinus Torvalds */ 16851da177e4SLinus Torvalds 168689bddce5SStephen Hemminger asmlinkage long sys_recv(int fd, void __user *ubuf, size_t size, 168789bddce5SStephen Hemminger unsigned flags) 16881da177e4SLinus Torvalds { 16891da177e4SLinus Torvalds return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL); 16901da177e4SLinus Torvalds } 16911da177e4SLinus Torvalds 16921da177e4SLinus Torvalds /* 16931da177e4SLinus Torvalds * Set a socket option. Because we don't know the option lengths we have 16941da177e4SLinus Torvalds * to pass the user mode parameter for the protocols to sort out. 16951da177e4SLinus Torvalds */ 16961da177e4SLinus Torvalds 169789bddce5SStephen Hemminger asmlinkage long sys_setsockopt(int fd, int level, int optname, 169889bddce5SStephen Hemminger char __user *optval, int optlen) 16991da177e4SLinus Torvalds { 17006cb153caSBenjamin LaHaise int err, fput_needed; 17011da177e4SLinus Torvalds struct socket *sock; 17021da177e4SLinus Torvalds 17031da177e4SLinus Torvalds if (optlen < 0) 17041da177e4SLinus Torvalds return -EINVAL; 17051da177e4SLinus Torvalds 170689bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 170789bddce5SStephen Hemminger if (sock != NULL) { 17081da177e4SLinus Torvalds err = security_socket_setsockopt(sock, level, optname); 17096cb153caSBenjamin LaHaise if (err) 17106cb153caSBenjamin LaHaise goto out_put; 17111da177e4SLinus Torvalds 17121da177e4SLinus Torvalds if (level == SOL_SOCKET) 171389bddce5SStephen Hemminger err = 171489bddce5SStephen Hemminger sock_setsockopt(sock, level, optname, optval, 171589bddce5SStephen Hemminger optlen); 17161da177e4SLinus Torvalds else 171789bddce5SStephen Hemminger err = 171889bddce5SStephen Hemminger sock->ops->setsockopt(sock, level, optname, optval, 171989bddce5SStephen Hemminger optlen); 17206cb153caSBenjamin LaHaise out_put: 17216cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 17221da177e4SLinus Torvalds } 17231da177e4SLinus Torvalds return err; 17241da177e4SLinus Torvalds } 17251da177e4SLinus Torvalds 17261da177e4SLinus Torvalds /* 17271da177e4SLinus Torvalds * Get a socket option. Because we don't know the option lengths we have 17281da177e4SLinus Torvalds * to pass a user mode parameter for the protocols to sort out. 17291da177e4SLinus Torvalds */ 17301da177e4SLinus Torvalds 173189bddce5SStephen Hemminger asmlinkage long sys_getsockopt(int fd, int level, int optname, 173289bddce5SStephen Hemminger char __user *optval, int __user *optlen) 17331da177e4SLinus Torvalds { 17346cb153caSBenjamin LaHaise int err, fput_needed; 17351da177e4SLinus Torvalds struct socket *sock; 17361da177e4SLinus Torvalds 173789bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 173889bddce5SStephen Hemminger if (sock != NULL) { 17396cb153caSBenjamin LaHaise err = security_socket_getsockopt(sock, level, optname); 17406cb153caSBenjamin LaHaise if (err) 17416cb153caSBenjamin LaHaise goto out_put; 17421da177e4SLinus Torvalds 17431da177e4SLinus Torvalds if (level == SOL_SOCKET) 174489bddce5SStephen Hemminger err = 174589bddce5SStephen Hemminger sock_getsockopt(sock, level, optname, optval, 174689bddce5SStephen Hemminger optlen); 17471da177e4SLinus Torvalds else 174889bddce5SStephen Hemminger err = 174989bddce5SStephen Hemminger sock->ops->getsockopt(sock, level, optname, optval, 175089bddce5SStephen Hemminger optlen); 17516cb153caSBenjamin LaHaise out_put: 17526cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 17531da177e4SLinus Torvalds } 17541da177e4SLinus Torvalds return err; 17551da177e4SLinus Torvalds } 17561da177e4SLinus Torvalds 17571da177e4SLinus Torvalds /* 17581da177e4SLinus Torvalds * Shutdown a socket. 17591da177e4SLinus Torvalds */ 17601da177e4SLinus Torvalds 17611da177e4SLinus Torvalds asmlinkage long sys_shutdown(int fd, int how) 17621da177e4SLinus Torvalds { 17636cb153caSBenjamin LaHaise int err, fput_needed; 17641da177e4SLinus Torvalds struct socket *sock; 17651da177e4SLinus Torvalds 176689bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 176789bddce5SStephen Hemminger if (sock != NULL) { 17681da177e4SLinus Torvalds err = security_socket_shutdown(sock, how); 17696cb153caSBenjamin LaHaise if (!err) 17701da177e4SLinus Torvalds err = sock->ops->shutdown(sock, how); 17716cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 17721da177e4SLinus Torvalds } 17731da177e4SLinus Torvalds return err; 17741da177e4SLinus Torvalds } 17751da177e4SLinus Torvalds 17761da177e4SLinus Torvalds /* A couple of helpful macros for getting the address of the 32/64 bit 17771da177e4SLinus Torvalds * fields which are the same type (int / unsigned) on our platforms. 17781da177e4SLinus Torvalds */ 17791da177e4SLinus Torvalds #define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member) 17801da177e4SLinus Torvalds #define COMPAT_NAMELEN(msg) COMPAT_MSG(msg, msg_namelen) 17811da177e4SLinus Torvalds #define COMPAT_FLAGS(msg) COMPAT_MSG(msg, msg_flags) 17821da177e4SLinus Torvalds 17831da177e4SLinus Torvalds /* 17841da177e4SLinus Torvalds * BSD sendmsg interface 17851da177e4SLinus Torvalds */ 17861da177e4SLinus Torvalds 17871da177e4SLinus Torvalds asmlinkage long sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags) 17881da177e4SLinus Torvalds { 178989bddce5SStephen Hemminger struct compat_msghdr __user *msg_compat = 179089bddce5SStephen Hemminger (struct compat_msghdr __user *)msg; 17911da177e4SLinus Torvalds struct socket *sock; 17921da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 17931da177e4SLinus Torvalds struct iovec iovstack[UIO_FASTIOV], *iov = iovstack; 1794b9d717a7SAlex Williamson unsigned char ctl[sizeof(struct cmsghdr) + 20] 1795b9d717a7SAlex Williamson __attribute__ ((aligned(sizeof(__kernel_size_t)))); 1796b9d717a7SAlex Williamson /* 20 is size of ipv6_pktinfo */ 17971da177e4SLinus Torvalds unsigned char *ctl_buf = ctl; 17981da177e4SLinus Torvalds struct msghdr msg_sys; 17991da177e4SLinus Torvalds int err, ctl_len, iov_size, total_len; 18006cb153caSBenjamin LaHaise int fput_needed; 18011da177e4SLinus Torvalds 18021da177e4SLinus Torvalds err = -EFAULT; 18031da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 18041da177e4SLinus Torvalds if (get_compat_msghdr(&msg_sys, msg_compat)) 18051da177e4SLinus Torvalds return -EFAULT; 180689bddce5SStephen Hemminger } 180789bddce5SStephen Hemminger else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr))) 18081da177e4SLinus Torvalds return -EFAULT; 18091da177e4SLinus Torvalds 18106cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 18111da177e4SLinus Torvalds if (!sock) 18121da177e4SLinus Torvalds goto out; 18131da177e4SLinus Torvalds 18141da177e4SLinus Torvalds /* do not move before msg_sys is valid */ 18151da177e4SLinus Torvalds err = -EMSGSIZE; 18161da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_MAXIOV) 18171da177e4SLinus Torvalds goto out_put; 18181da177e4SLinus Torvalds 18191da177e4SLinus Torvalds /* Check whether to allocate the iovec area */ 18201da177e4SLinus Torvalds err = -ENOMEM; 18211da177e4SLinus Torvalds iov_size = msg_sys.msg_iovlen * sizeof(struct iovec); 18221da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_FASTIOV) { 18231da177e4SLinus Torvalds iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL); 18241da177e4SLinus Torvalds if (!iov) 18251da177e4SLinus Torvalds goto out_put; 18261da177e4SLinus Torvalds } 18271da177e4SLinus Torvalds 18281da177e4SLinus Torvalds /* This will also move the address data into kernel space */ 18291da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 18301da177e4SLinus Torvalds err = verify_compat_iovec(&msg_sys, iov, address, VERIFY_READ); 18311da177e4SLinus Torvalds } else 18321da177e4SLinus Torvalds err = verify_iovec(&msg_sys, iov, address, VERIFY_READ); 18331da177e4SLinus Torvalds if (err < 0) 18341da177e4SLinus Torvalds goto out_freeiov; 18351da177e4SLinus Torvalds total_len = err; 18361da177e4SLinus Torvalds 18371da177e4SLinus Torvalds err = -ENOBUFS; 18381da177e4SLinus Torvalds 18391da177e4SLinus Torvalds if (msg_sys.msg_controllen > INT_MAX) 18401da177e4SLinus Torvalds goto out_freeiov; 18411da177e4SLinus Torvalds ctl_len = msg_sys.msg_controllen; 18421da177e4SLinus Torvalds if ((MSG_CMSG_COMPAT & flags) && ctl_len) { 184389bddce5SStephen Hemminger err = 184489bddce5SStephen Hemminger cmsghdr_from_user_compat_to_kern(&msg_sys, sock->sk, ctl, 184589bddce5SStephen Hemminger sizeof(ctl)); 18461da177e4SLinus Torvalds if (err) 18471da177e4SLinus Torvalds goto out_freeiov; 18481da177e4SLinus Torvalds ctl_buf = msg_sys.msg_control; 18498920e8f9SAl Viro ctl_len = msg_sys.msg_controllen; 18501da177e4SLinus Torvalds } else if (ctl_len) { 185189bddce5SStephen Hemminger if (ctl_len > sizeof(ctl)) { 18521da177e4SLinus Torvalds ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL); 18531da177e4SLinus Torvalds if (ctl_buf == NULL) 18541da177e4SLinus Torvalds goto out_freeiov; 18551da177e4SLinus Torvalds } 18561da177e4SLinus Torvalds err = -EFAULT; 18571da177e4SLinus Torvalds /* 18581da177e4SLinus Torvalds * Careful! Before this, msg_sys.msg_control contains a user pointer. 18591da177e4SLinus Torvalds * Afterwards, it will be a kernel pointer. Thus the compiler-assisted 18601da177e4SLinus Torvalds * checking falls down on this. 18611da177e4SLinus Torvalds */ 186289bddce5SStephen Hemminger if (copy_from_user(ctl_buf, (void __user *)msg_sys.msg_control, 186389bddce5SStephen Hemminger ctl_len)) 18641da177e4SLinus Torvalds goto out_freectl; 18651da177e4SLinus Torvalds msg_sys.msg_control = ctl_buf; 18661da177e4SLinus Torvalds } 18671da177e4SLinus Torvalds msg_sys.msg_flags = flags; 18681da177e4SLinus Torvalds 18691da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 18701da177e4SLinus Torvalds msg_sys.msg_flags |= MSG_DONTWAIT; 18711da177e4SLinus Torvalds err = sock_sendmsg(sock, &msg_sys, total_len); 18721da177e4SLinus Torvalds 18731da177e4SLinus Torvalds out_freectl: 18741da177e4SLinus Torvalds if (ctl_buf != ctl) 18751da177e4SLinus Torvalds sock_kfree_s(sock->sk, ctl_buf, ctl_len); 18761da177e4SLinus Torvalds out_freeiov: 18771da177e4SLinus Torvalds if (iov != iovstack) 18781da177e4SLinus Torvalds sock_kfree_s(sock->sk, iov, iov_size); 18791da177e4SLinus Torvalds out_put: 18806cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 18811da177e4SLinus Torvalds out: 18821da177e4SLinus Torvalds return err; 18831da177e4SLinus Torvalds } 18841da177e4SLinus Torvalds 18851da177e4SLinus Torvalds /* 18861da177e4SLinus Torvalds * BSD recvmsg interface 18871da177e4SLinus Torvalds */ 18881da177e4SLinus Torvalds 188989bddce5SStephen Hemminger asmlinkage long sys_recvmsg(int fd, struct msghdr __user *msg, 189089bddce5SStephen Hemminger unsigned int flags) 18911da177e4SLinus Torvalds { 189289bddce5SStephen Hemminger struct compat_msghdr __user *msg_compat = 189389bddce5SStephen Hemminger (struct compat_msghdr __user *)msg; 18941da177e4SLinus Torvalds struct socket *sock; 18951da177e4SLinus Torvalds struct iovec iovstack[UIO_FASTIOV]; 18961da177e4SLinus Torvalds struct iovec *iov = iovstack; 18971da177e4SLinus Torvalds struct msghdr msg_sys; 18981da177e4SLinus Torvalds unsigned long cmsg_ptr; 18991da177e4SLinus Torvalds int err, iov_size, total_len, len; 19006cb153caSBenjamin LaHaise int fput_needed; 19011da177e4SLinus Torvalds 19021da177e4SLinus Torvalds /* kernel mode address */ 19031da177e4SLinus Torvalds char addr[MAX_SOCK_ADDR]; 19041da177e4SLinus Torvalds 19051da177e4SLinus Torvalds /* user mode address pointers */ 19061da177e4SLinus Torvalds struct sockaddr __user *uaddr; 19071da177e4SLinus Torvalds int __user *uaddr_len; 19081da177e4SLinus Torvalds 19091da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 19101da177e4SLinus Torvalds if (get_compat_msghdr(&msg_sys, msg_compat)) 19111da177e4SLinus Torvalds return -EFAULT; 191289bddce5SStephen Hemminger } 191389bddce5SStephen Hemminger else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr))) 19141da177e4SLinus Torvalds return -EFAULT; 19151da177e4SLinus Torvalds 19166cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 19171da177e4SLinus Torvalds if (!sock) 19181da177e4SLinus Torvalds goto out; 19191da177e4SLinus Torvalds 19201da177e4SLinus Torvalds err = -EMSGSIZE; 19211da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_MAXIOV) 19221da177e4SLinus Torvalds goto out_put; 19231da177e4SLinus Torvalds 19241da177e4SLinus Torvalds /* Check whether to allocate the iovec area */ 19251da177e4SLinus Torvalds err = -ENOMEM; 19261da177e4SLinus Torvalds iov_size = msg_sys.msg_iovlen * sizeof(struct iovec); 19271da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_FASTIOV) { 19281da177e4SLinus Torvalds iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL); 19291da177e4SLinus Torvalds if (!iov) 19301da177e4SLinus Torvalds goto out_put; 19311da177e4SLinus Torvalds } 19321da177e4SLinus Torvalds 19331da177e4SLinus Torvalds /* 19341da177e4SLinus Torvalds * Save the user-mode address (verify_iovec will change the 19351da177e4SLinus Torvalds * kernel msghdr to use the kernel address space) 19361da177e4SLinus Torvalds */ 19371da177e4SLinus Torvalds 1938cfcabdccSStephen Hemminger uaddr = (__force void __user *)msg_sys.msg_name; 19391da177e4SLinus Torvalds uaddr_len = COMPAT_NAMELEN(msg); 19401da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 19411da177e4SLinus Torvalds err = verify_compat_iovec(&msg_sys, iov, addr, VERIFY_WRITE); 19421da177e4SLinus Torvalds } else 19431da177e4SLinus Torvalds err = verify_iovec(&msg_sys, iov, addr, VERIFY_WRITE); 19441da177e4SLinus Torvalds if (err < 0) 19451da177e4SLinus Torvalds goto out_freeiov; 19461da177e4SLinus Torvalds total_len = err; 19471da177e4SLinus Torvalds 19481da177e4SLinus Torvalds cmsg_ptr = (unsigned long)msg_sys.msg_control; 19494a19542eSUlrich Drepper msg_sys.msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT); 19501da177e4SLinus Torvalds 19511da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 19521da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 19531da177e4SLinus Torvalds err = sock_recvmsg(sock, &msg_sys, total_len, flags); 19541da177e4SLinus Torvalds if (err < 0) 19551da177e4SLinus Torvalds goto out_freeiov; 19561da177e4SLinus Torvalds len = err; 19571da177e4SLinus Torvalds 19581da177e4SLinus Torvalds if (uaddr != NULL) { 195989bddce5SStephen Hemminger err = move_addr_to_user(addr, msg_sys.msg_namelen, uaddr, 196089bddce5SStephen Hemminger uaddr_len); 19611da177e4SLinus Torvalds if (err < 0) 19621da177e4SLinus Torvalds goto out_freeiov; 19631da177e4SLinus Torvalds } 196437f7f421SDavid S. Miller err = __put_user((msg_sys.msg_flags & ~MSG_CMSG_COMPAT), 196537f7f421SDavid S. Miller COMPAT_FLAGS(msg)); 19661da177e4SLinus Torvalds if (err) 19671da177e4SLinus Torvalds goto out_freeiov; 19681da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) 19691da177e4SLinus Torvalds err = __put_user((unsigned long)msg_sys.msg_control - cmsg_ptr, 19701da177e4SLinus Torvalds &msg_compat->msg_controllen); 19711da177e4SLinus Torvalds else 19721da177e4SLinus Torvalds err = __put_user((unsigned long)msg_sys.msg_control - cmsg_ptr, 19731da177e4SLinus Torvalds &msg->msg_controllen); 19741da177e4SLinus Torvalds if (err) 19751da177e4SLinus Torvalds goto out_freeiov; 19761da177e4SLinus Torvalds err = len; 19771da177e4SLinus Torvalds 19781da177e4SLinus Torvalds out_freeiov: 19791da177e4SLinus Torvalds if (iov != iovstack) 19801da177e4SLinus Torvalds sock_kfree_s(sock->sk, iov, iov_size); 19811da177e4SLinus Torvalds out_put: 19826cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 19831da177e4SLinus Torvalds out: 19841da177e4SLinus Torvalds return err; 19851da177e4SLinus Torvalds } 19861da177e4SLinus Torvalds 19871da177e4SLinus Torvalds #ifdef __ARCH_WANT_SYS_SOCKETCALL 19881da177e4SLinus Torvalds 19891da177e4SLinus Torvalds /* Argument list sizes for sys_socketcall */ 19901da177e4SLinus Torvalds #define AL(x) ((x) * sizeof(unsigned long)) 199189bddce5SStephen Hemminger static const unsigned char nargs[18]={ 199289bddce5SStephen Hemminger AL(0),AL(3),AL(3),AL(3),AL(2),AL(3), 19931da177e4SLinus Torvalds AL(3),AL(3),AL(4),AL(4),AL(4),AL(6), 199489bddce5SStephen Hemminger AL(6),AL(2),AL(5),AL(5),AL(3),AL(3) 199589bddce5SStephen Hemminger }; 199689bddce5SStephen Hemminger 19971da177e4SLinus Torvalds #undef AL 19981da177e4SLinus Torvalds 19991da177e4SLinus Torvalds /* 20001da177e4SLinus Torvalds * System call vectors. 20011da177e4SLinus Torvalds * 20021da177e4SLinus Torvalds * Argument checking cleaned up. Saved 20% in size. 20031da177e4SLinus Torvalds * This function doesn't need to set the kernel lock because 20041da177e4SLinus Torvalds * it is set by the callees. 20051da177e4SLinus Torvalds */ 20061da177e4SLinus Torvalds 20071da177e4SLinus Torvalds asmlinkage long sys_socketcall(int call, unsigned long __user *args) 20081da177e4SLinus Torvalds { 20091da177e4SLinus Torvalds unsigned long a[6]; 20101da177e4SLinus Torvalds unsigned long a0, a1; 20111da177e4SLinus Torvalds int err; 20121da177e4SLinus Torvalds 20131da177e4SLinus Torvalds if (call < 1 || call > SYS_RECVMSG) 20141da177e4SLinus Torvalds return -EINVAL; 20151da177e4SLinus Torvalds 20161da177e4SLinus Torvalds /* copy_from_user should be SMP safe. */ 20171da177e4SLinus Torvalds if (copy_from_user(a, args, nargs[call])) 20181da177e4SLinus Torvalds return -EFAULT; 20191da177e4SLinus Torvalds 20204bcff1b3SDavid Woodhouse err = audit_socketcall(nargs[call] / sizeof(unsigned long), a); 20213ec3b2fbSDavid Woodhouse if (err) 20223ec3b2fbSDavid Woodhouse return err; 20233ec3b2fbSDavid Woodhouse 20241da177e4SLinus Torvalds a0 = a[0]; 20251da177e4SLinus Torvalds a1 = a[1]; 20261da177e4SLinus Torvalds 202789bddce5SStephen Hemminger switch (call) { 20281da177e4SLinus Torvalds case SYS_SOCKET: 20291da177e4SLinus Torvalds err = sys_socket(a0, a1, a[2]); 20301da177e4SLinus Torvalds break; 20311da177e4SLinus Torvalds case SYS_BIND: 20321da177e4SLinus Torvalds err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]); 20331da177e4SLinus Torvalds break; 20341da177e4SLinus Torvalds case SYS_CONNECT: 20351da177e4SLinus Torvalds err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]); 20361da177e4SLinus Torvalds break; 20371da177e4SLinus Torvalds case SYS_LISTEN: 20381da177e4SLinus Torvalds err = sys_listen(a0, a1); 20391da177e4SLinus Torvalds break; 20401da177e4SLinus Torvalds case SYS_ACCEPT: 204189bddce5SStephen Hemminger err = 204289bddce5SStephen Hemminger sys_accept(a0, (struct sockaddr __user *)a1, 204389bddce5SStephen Hemminger (int __user *)a[2]); 20441da177e4SLinus Torvalds break; 20451da177e4SLinus Torvalds case SYS_GETSOCKNAME: 204689bddce5SStephen Hemminger err = 204789bddce5SStephen Hemminger sys_getsockname(a0, (struct sockaddr __user *)a1, 204889bddce5SStephen Hemminger (int __user *)a[2]); 20491da177e4SLinus Torvalds break; 20501da177e4SLinus Torvalds case SYS_GETPEERNAME: 205189bddce5SStephen Hemminger err = 205289bddce5SStephen Hemminger sys_getpeername(a0, (struct sockaddr __user *)a1, 205389bddce5SStephen Hemminger (int __user *)a[2]); 20541da177e4SLinus Torvalds break; 20551da177e4SLinus Torvalds case SYS_SOCKETPAIR: 20561da177e4SLinus Torvalds err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]); 20571da177e4SLinus Torvalds break; 20581da177e4SLinus Torvalds case SYS_SEND: 20591da177e4SLinus Torvalds err = sys_send(a0, (void __user *)a1, a[2], a[3]); 20601da177e4SLinus Torvalds break; 20611da177e4SLinus Torvalds case SYS_SENDTO: 20621da177e4SLinus Torvalds err = sys_sendto(a0, (void __user *)a1, a[2], a[3], 20631da177e4SLinus Torvalds (struct sockaddr __user *)a[4], a[5]); 20641da177e4SLinus Torvalds break; 20651da177e4SLinus Torvalds case SYS_RECV: 20661da177e4SLinus Torvalds err = sys_recv(a0, (void __user *)a1, a[2], a[3]); 20671da177e4SLinus Torvalds break; 20681da177e4SLinus Torvalds case SYS_RECVFROM: 20691da177e4SLinus Torvalds err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3], 207089bddce5SStephen Hemminger (struct sockaddr __user *)a[4], 207189bddce5SStephen Hemminger (int __user *)a[5]); 20721da177e4SLinus Torvalds break; 20731da177e4SLinus Torvalds case SYS_SHUTDOWN: 20741da177e4SLinus Torvalds err = sys_shutdown(a0, a1); 20751da177e4SLinus Torvalds break; 20761da177e4SLinus Torvalds case SYS_SETSOCKOPT: 20771da177e4SLinus Torvalds err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]); 20781da177e4SLinus Torvalds break; 20791da177e4SLinus Torvalds case SYS_GETSOCKOPT: 208089bddce5SStephen Hemminger err = 208189bddce5SStephen Hemminger sys_getsockopt(a0, a1, a[2], (char __user *)a[3], 208289bddce5SStephen Hemminger (int __user *)a[4]); 20831da177e4SLinus Torvalds break; 20841da177e4SLinus Torvalds case SYS_SENDMSG: 20851da177e4SLinus Torvalds err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]); 20861da177e4SLinus Torvalds break; 20871da177e4SLinus Torvalds case SYS_RECVMSG: 20881da177e4SLinus Torvalds err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]); 20891da177e4SLinus Torvalds break; 20901da177e4SLinus Torvalds default: 20911da177e4SLinus Torvalds err = -EINVAL; 20921da177e4SLinus Torvalds break; 20931da177e4SLinus Torvalds } 20941da177e4SLinus Torvalds return err; 20951da177e4SLinus Torvalds } 20961da177e4SLinus Torvalds 20971da177e4SLinus Torvalds #endif /* __ARCH_WANT_SYS_SOCKETCALL */ 20981da177e4SLinus Torvalds 209955737fdaSStephen Hemminger /** 210055737fdaSStephen Hemminger * sock_register - add a socket protocol handler 210155737fdaSStephen Hemminger * @ops: description of protocol 210255737fdaSStephen Hemminger * 21031da177e4SLinus Torvalds * This function is called by a protocol handler that wants to 21041da177e4SLinus Torvalds * advertise its address family, and have it linked into the 210555737fdaSStephen Hemminger * socket interface. The value ops->family coresponds to the 210655737fdaSStephen Hemminger * socket system call protocol family. 21071da177e4SLinus Torvalds */ 2108f0fd27d4SStephen Hemminger int sock_register(const struct net_proto_family *ops) 21091da177e4SLinus Torvalds { 21101da177e4SLinus Torvalds int err; 21111da177e4SLinus Torvalds 21121da177e4SLinus Torvalds if (ops->family >= NPROTO) { 211389bddce5SStephen Hemminger printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family, 211489bddce5SStephen Hemminger NPROTO); 21151da177e4SLinus Torvalds return -ENOBUFS; 21161da177e4SLinus Torvalds } 211755737fdaSStephen Hemminger 211855737fdaSStephen Hemminger spin_lock(&net_family_lock); 211955737fdaSStephen Hemminger if (net_families[ops->family]) 21201da177e4SLinus Torvalds err = -EEXIST; 212155737fdaSStephen Hemminger else { 21221da177e4SLinus Torvalds net_families[ops->family] = ops; 21231da177e4SLinus Torvalds err = 0; 21241da177e4SLinus Torvalds } 212555737fdaSStephen Hemminger spin_unlock(&net_family_lock); 212655737fdaSStephen Hemminger 212789bddce5SStephen Hemminger printk(KERN_INFO "NET: Registered protocol family %d\n", ops->family); 21281da177e4SLinus Torvalds return err; 21291da177e4SLinus Torvalds } 21301da177e4SLinus Torvalds 213155737fdaSStephen Hemminger /** 213255737fdaSStephen Hemminger * sock_unregister - remove a protocol handler 213355737fdaSStephen Hemminger * @family: protocol family to remove 213455737fdaSStephen Hemminger * 21351da177e4SLinus Torvalds * This function is called by a protocol handler that wants to 21361da177e4SLinus Torvalds * remove its address family, and have it unlinked from the 213755737fdaSStephen Hemminger * new socket creation. 213855737fdaSStephen Hemminger * 213955737fdaSStephen Hemminger * If protocol handler is a module, then it can use module reference 214055737fdaSStephen Hemminger * counts to protect against new references. If protocol handler is not 214155737fdaSStephen Hemminger * a module then it needs to provide its own protection in 214255737fdaSStephen Hemminger * the ops->create routine. 21431da177e4SLinus Torvalds */ 2144f0fd27d4SStephen Hemminger void sock_unregister(int family) 21451da177e4SLinus Torvalds { 2146f0fd27d4SStephen Hemminger BUG_ON(family < 0 || family >= NPROTO); 21471da177e4SLinus Torvalds 214855737fdaSStephen Hemminger spin_lock(&net_family_lock); 21491da177e4SLinus Torvalds net_families[family] = NULL; 215055737fdaSStephen Hemminger spin_unlock(&net_family_lock); 215155737fdaSStephen Hemminger 215255737fdaSStephen Hemminger synchronize_rcu(); 215355737fdaSStephen Hemminger 215489bddce5SStephen Hemminger printk(KERN_INFO "NET: Unregistered protocol family %d\n", family); 21551da177e4SLinus Torvalds } 21561da177e4SLinus Torvalds 215777d76ea3SAndi Kleen static int __init sock_init(void) 21581da177e4SLinus Torvalds { 21591da177e4SLinus Torvalds /* 21601da177e4SLinus Torvalds * Initialize sock SLAB cache. 21611da177e4SLinus Torvalds */ 21621da177e4SLinus Torvalds 21631da177e4SLinus Torvalds sk_init(); 21641da177e4SLinus Torvalds 21651da177e4SLinus Torvalds /* 21661da177e4SLinus Torvalds * Initialize skbuff SLAB cache 21671da177e4SLinus Torvalds */ 21681da177e4SLinus Torvalds skb_init(); 21691da177e4SLinus Torvalds 21701da177e4SLinus Torvalds /* 21711da177e4SLinus Torvalds * Initialize the protocols module. 21721da177e4SLinus Torvalds */ 21731da177e4SLinus Torvalds 21741da177e4SLinus Torvalds init_inodecache(); 21751da177e4SLinus Torvalds register_filesystem(&sock_fs_type); 21761da177e4SLinus Torvalds sock_mnt = kern_mount(&sock_fs_type); 217777d76ea3SAndi Kleen 217877d76ea3SAndi Kleen /* The real protocol initialization is performed in later initcalls. 21791da177e4SLinus Torvalds */ 21801da177e4SLinus Torvalds 21811da177e4SLinus Torvalds #ifdef CONFIG_NETFILTER 21821da177e4SLinus Torvalds netfilter_init(); 21831da177e4SLinus Torvalds #endif 2184cbeb321aSDavid S. Miller 2185cbeb321aSDavid S. Miller return 0; 21861da177e4SLinus Torvalds } 21871da177e4SLinus Torvalds 218877d76ea3SAndi Kleen core_initcall(sock_init); /* early initcall */ 218977d76ea3SAndi Kleen 21901da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 21911da177e4SLinus Torvalds void socket_seq_show(struct seq_file *seq) 21921da177e4SLinus Torvalds { 21931da177e4SLinus Torvalds int cpu; 21941da177e4SLinus Torvalds int counter = 0; 21951da177e4SLinus Torvalds 21966f912042SKAMEZAWA Hiroyuki for_each_possible_cpu(cpu) 21971da177e4SLinus Torvalds counter += per_cpu(sockets_in_use, cpu); 21981da177e4SLinus Torvalds 21991da177e4SLinus Torvalds /* It can be negative, by the way. 8) */ 22001da177e4SLinus Torvalds if (counter < 0) 22011da177e4SLinus Torvalds counter = 0; 22021da177e4SLinus Torvalds 22031da177e4SLinus Torvalds seq_printf(seq, "sockets: used %d\n", counter); 22041da177e4SLinus Torvalds } 22051da177e4SLinus Torvalds #endif /* CONFIG_PROC_FS */ 22061da177e4SLinus Torvalds 220789bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 220889bbfc95SShaun Pereira static long compat_sock_ioctl(struct file *file, unsigned cmd, 220989bbfc95SShaun Pereira unsigned long arg) 221089bbfc95SShaun Pereira { 221189bbfc95SShaun Pereira struct socket *sock = file->private_data; 221289bbfc95SShaun Pereira int ret = -ENOIOCTLCMD; 221389bbfc95SShaun Pereira 221489bbfc95SShaun Pereira if (sock->ops->compat_ioctl) 221589bbfc95SShaun Pereira ret = sock->ops->compat_ioctl(sock, cmd, arg); 221689bbfc95SShaun Pereira 221789bbfc95SShaun Pereira return ret; 221889bbfc95SShaun Pereira } 221989bbfc95SShaun Pereira #endif 222089bbfc95SShaun Pereira 2221ac5a488eSSridhar Samudrala int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen) 2222ac5a488eSSridhar Samudrala { 2223ac5a488eSSridhar Samudrala return sock->ops->bind(sock, addr, addrlen); 2224ac5a488eSSridhar Samudrala } 2225ac5a488eSSridhar Samudrala 2226ac5a488eSSridhar Samudrala int kernel_listen(struct socket *sock, int backlog) 2227ac5a488eSSridhar Samudrala { 2228ac5a488eSSridhar Samudrala return sock->ops->listen(sock, backlog); 2229ac5a488eSSridhar Samudrala } 2230ac5a488eSSridhar Samudrala 2231ac5a488eSSridhar Samudrala int kernel_accept(struct socket *sock, struct socket **newsock, int flags) 2232ac5a488eSSridhar Samudrala { 2233ac5a488eSSridhar Samudrala struct sock *sk = sock->sk; 2234ac5a488eSSridhar Samudrala int err; 2235ac5a488eSSridhar Samudrala 2236ac5a488eSSridhar Samudrala err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 2237ac5a488eSSridhar Samudrala newsock); 2238ac5a488eSSridhar Samudrala if (err < 0) 2239ac5a488eSSridhar Samudrala goto done; 2240ac5a488eSSridhar Samudrala 2241ac5a488eSSridhar Samudrala err = sock->ops->accept(sock, *newsock, flags); 2242ac5a488eSSridhar Samudrala if (err < 0) { 2243ac5a488eSSridhar Samudrala sock_release(*newsock); 2244fa8705b0STony Battersby *newsock = NULL; 2245ac5a488eSSridhar Samudrala goto done; 2246ac5a488eSSridhar Samudrala } 2247ac5a488eSSridhar Samudrala 2248ac5a488eSSridhar Samudrala (*newsock)->ops = sock->ops; 2249ac5a488eSSridhar Samudrala 2250ac5a488eSSridhar Samudrala done: 2251ac5a488eSSridhar Samudrala return err; 2252ac5a488eSSridhar Samudrala } 2253ac5a488eSSridhar Samudrala 2254ac5a488eSSridhar Samudrala int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen, 2255ac5a488eSSridhar Samudrala int flags) 2256ac5a488eSSridhar Samudrala { 2257ac5a488eSSridhar Samudrala return sock->ops->connect(sock, addr, addrlen, flags); 2258ac5a488eSSridhar Samudrala } 2259ac5a488eSSridhar Samudrala 2260ac5a488eSSridhar Samudrala int kernel_getsockname(struct socket *sock, struct sockaddr *addr, 2261ac5a488eSSridhar Samudrala int *addrlen) 2262ac5a488eSSridhar Samudrala { 2263ac5a488eSSridhar Samudrala return sock->ops->getname(sock, addr, addrlen, 0); 2264ac5a488eSSridhar Samudrala } 2265ac5a488eSSridhar Samudrala 2266ac5a488eSSridhar Samudrala int kernel_getpeername(struct socket *sock, struct sockaddr *addr, 2267ac5a488eSSridhar Samudrala int *addrlen) 2268ac5a488eSSridhar Samudrala { 2269ac5a488eSSridhar Samudrala return sock->ops->getname(sock, addr, addrlen, 1); 2270ac5a488eSSridhar Samudrala } 2271ac5a488eSSridhar Samudrala 2272ac5a488eSSridhar Samudrala int kernel_getsockopt(struct socket *sock, int level, int optname, 2273ac5a488eSSridhar Samudrala char *optval, int *optlen) 2274ac5a488eSSridhar Samudrala { 2275ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 2276ac5a488eSSridhar Samudrala int err; 2277ac5a488eSSridhar Samudrala 2278ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 2279ac5a488eSSridhar Samudrala if (level == SOL_SOCKET) 2280ac5a488eSSridhar Samudrala err = sock_getsockopt(sock, level, optname, optval, optlen); 2281ac5a488eSSridhar Samudrala else 2282ac5a488eSSridhar Samudrala err = sock->ops->getsockopt(sock, level, optname, optval, 2283ac5a488eSSridhar Samudrala optlen); 2284ac5a488eSSridhar Samudrala set_fs(oldfs); 2285ac5a488eSSridhar Samudrala return err; 2286ac5a488eSSridhar Samudrala } 2287ac5a488eSSridhar Samudrala 2288ac5a488eSSridhar Samudrala int kernel_setsockopt(struct socket *sock, int level, int optname, 2289ac5a488eSSridhar Samudrala char *optval, int optlen) 2290ac5a488eSSridhar Samudrala { 2291ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 2292ac5a488eSSridhar Samudrala int err; 2293ac5a488eSSridhar Samudrala 2294ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 2295ac5a488eSSridhar Samudrala if (level == SOL_SOCKET) 2296ac5a488eSSridhar Samudrala err = sock_setsockopt(sock, level, optname, optval, optlen); 2297ac5a488eSSridhar Samudrala else 2298ac5a488eSSridhar Samudrala err = sock->ops->setsockopt(sock, level, optname, optval, 2299ac5a488eSSridhar Samudrala optlen); 2300ac5a488eSSridhar Samudrala set_fs(oldfs); 2301ac5a488eSSridhar Samudrala return err; 2302ac5a488eSSridhar Samudrala } 2303ac5a488eSSridhar Samudrala 2304ac5a488eSSridhar Samudrala int kernel_sendpage(struct socket *sock, struct page *page, int offset, 2305ac5a488eSSridhar Samudrala size_t size, int flags) 2306ac5a488eSSridhar Samudrala { 2307ac5a488eSSridhar Samudrala if (sock->ops->sendpage) 2308ac5a488eSSridhar Samudrala return sock->ops->sendpage(sock, page, offset, size, flags); 2309ac5a488eSSridhar Samudrala 2310ac5a488eSSridhar Samudrala return sock_no_sendpage(sock, page, offset, size, flags); 2311ac5a488eSSridhar Samudrala } 2312ac5a488eSSridhar Samudrala 2313ac5a488eSSridhar Samudrala int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg) 2314ac5a488eSSridhar Samudrala { 2315ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 2316ac5a488eSSridhar Samudrala int err; 2317ac5a488eSSridhar Samudrala 2318ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 2319ac5a488eSSridhar Samudrala err = sock->ops->ioctl(sock, cmd, arg); 2320ac5a488eSSridhar Samudrala set_fs(oldfs); 2321ac5a488eSSridhar Samudrala 2322ac5a488eSSridhar Samudrala return err; 2323ac5a488eSSridhar Samudrala } 2324ac5a488eSSridhar Samudrala 232591cf45f0STrond Myklebust int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how) 232691cf45f0STrond Myklebust { 232791cf45f0STrond Myklebust return sock->ops->shutdown(sock, how); 232891cf45f0STrond Myklebust } 232991cf45f0STrond Myklebust 23301da177e4SLinus Torvalds /* ABI emulation layers need these two */ 23311da177e4SLinus Torvalds EXPORT_SYMBOL(move_addr_to_kernel); 23321da177e4SLinus Torvalds EXPORT_SYMBOL(move_addr_to_user); 23331da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create); 23341da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create_kern); 23351da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create_lite); 23361da177e4SLinus Torvalds EXPORT_SYMBOL(sock_map_fd); 23371da177e4SLinus Torvalds EXPORT_SYMBOL(sock_recvmsg); 23381da177e4SLinus Torvalds EXPORT_SYMBOL(sock_register); 23391da177e4SLinus Torvalds EXPORT_SYMBOL(sock_release); 23401da177e4SLinus Torvalds EXPORT_SYMBOL(sock_sendmsg); 23411da177e4SLinus Torvalds EXPORT_SYMBOL(sock_unregister); 23421da177e4SLinus Torvalds EXPORT_SYMBOL(sock_wake_async); 23431da177e4SLinus Torvalds EXPORT_SYMBOL(sockfd_lookup); 23441da177e4SLinus Torvalds EXPORT_SYMBOL(kernel_sendmsg); 23451da177e4SLinus Torvalds EXPORT_SYMBOL(kernel_recvmsg); 2346ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_bind); 2347ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_listen); 2348ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_accept); 2349ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_connect); 2350ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getsockname); 2351ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getpeername); 2352ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getsockopt); 2353ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_setsockopt); 2354ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_sendpage); 2355ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_sock_ioctl); 235691cf45f0STrond Myklebust EXPORT_SYMBOL(kernel_sock_shutdown); 2357