11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * NET An implementation of the SOCKET network access protocol. 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Version: @(#)socket.c 1.1.93 18/02/95 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Authors: Orest Zborowski, <obz@Kodak.COM> 702c30a84SJesper Juhl * Ross Biro 81da177e4SLinus Torvalds * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 91da177e4SLinus Torvalds * 101da177e4SLinus Torvalds * Fixes: 111da177e4SLinus Torvalds * Anonymous : NOTSOCK/BADF cleanup. Error fix in 121da177e4SLinus Torvalds * shutdown() 131da177e4SLinus Torvalds * Alan Cox : verify_area() fixes 141da177e4SLinus Torvalds * Alan Cox : Removed DDI 151da177e4SLinus Torvalds * Jonathan Kamens : SOCK_DGRAM reconnect bug 161da177e4SLinus Torvalds * Alan Cox : Moved a load of checks to the very 171da177e4SLinus Torvalds * top level. 181da177e4SLinus Torvalds * Alan Cox : Move address structures to/from user 191da177e4SLinus Torvalds * mode above the protocol layers. 201da177e4SLinus Torvalds * Rob Janssen : Allow 0 length sends. 211da177e4SLinus Torvalds * Alan Cox : Asynchronous I/O support (cribbed from the 221da177e4SLinus Torvalds * tty drivers). 231da177e4SLinus Torvalds * Niibe Yutaka : Asynchronous I/O for writes (4.4BSD style) 241da177e4SLinus Torvalds * Jeff Uphoff : Made max number of sockets command-line 251da177e4SLinus Torvalds * configurable. 261da177e4SLinus Torvalds * Matti Aarnio : Made the number of sockets dynamic, 271da177e4SLinus Torvalds * to be allocated when needed, and mr. 281da177e4SLinus Torvalds * Uphoff's max is used as max to be 291da177e4SLinus Torvalds * allowed to allocate. 301da177e4SLinus Torvalds * Linus : Argh. removed all the socket allocation 311da177e4SLinus Torvalds * altogether: it's in the inode now. 321da177e4SLinus Torvalds * Alan Cox : Made sock_alloc()/sock_release() public 331da177e4SLinus Torvalds * for NetROM and future kernel nfsd type 341da177e4SLinus Torvalds * stuff. 351da177e4SLinus Torvalds * Alan Cox : sendmsg/recvmsg basics. 361da177e4SLinus Torvalds * Tom Dyas : Export net symbols. 371da177e4SLinus Torvalds * Marcin Dalecki : Fixed problems with CONFIG_NET="n". 381da177e4SLinus Torvalds * Alan Cox : Added thread locking to sys_* calls 391da177e4SLinus Torvalds * for sockets. May have errors at the 401da177e4SLinus Torvalds * moment. 411da177e4SLinus Torvalds * Kevin Buhr : Fixed the dumb errors in the above. 421da177e4SLinus Torvalds * Andi Kleen : Some small cleanups, optimizations, 431da177e4SLinus Torvalds * and fixed a copy_from_user() bug. 441da177e4SLinus Torvalds * Tigran Aivazian : sys_send(args) calls sys_sendto(args, NULL, 0) 451da177e4SLinus Torvalds * Tigran Aivazian : Made listen(2) backlog sanity checks 461da177e4SLinus Torvalds * protocol-independent 471da177e4SLinus Torvalds * 481da177e4SLinus Torvalds * 491da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or 501da177e4SLinus Torvalds * modify it under the terms of the GNU General Public License 511da177e4SLinus Torvalds * as published by the Free Software Foundation; either version 521da177e4SLinus Torvalds * 2 of the License, or (at your option) any later version. 531da177e4SLinus Torvalds * 541da177e4SLinus Torvalds * 551da177e4SLinus Torvalds * This module is effectively the top level interface to the BSD socket 561da177e4SLinus Torvalds * paradigm. 571da177e4SLinus Torvalds * 581da177e4SLinus Torvalds * Based upon Swansea University Computer Society NET3.039 591da177e4SLinus Torvalds */ 601da177e4SLinus Torvalds 611da177e4SLinus Torvalds #include <linux/mm.h> 621da177e4SLinus Torvalds #include <linux/socket.h> 631da177e4SLinus Torvalds #include <linux/file.h> 641da177e4SLinus Torvalds #include <linux/net.h> 651da177e4SLinus Torvalds #include <linux/interrupt.h> 66aaca0bdcSUlrich Drepper #include <linux/thread_info.h> 6755737fdaSStephen Hemminger #include <linux/rcupdate.h> 681da177e4SLinus Torvalds #include <linux/netdevice.h> 691da177e4SLinus Torvalds #include <linux/proc_fs.h> 701da177e4SLinus Torvalds #include <linux/seq_file.h> 714a3e2f71SArjan van de Ven #include <linux/mutex.h> 721da177e4SLinus Torvalds #include <linux/wanrouter.h> 731da177e4SLinus Torvalds #include <linux/if_bridge.h> 7420380731SArnaldo Carvalho de Melo #include <linux/if_frad.h> 7520380731SArnaldo Carvalho de Melo #include <linux/if_vlan.h> 761da177e4SLinus Torvalds #include <linux/init.h> 771da177e4SLinus Torvalds #include <linux/poll.h> 781da177e4SLinus Torvalds #include <linux/cache.h> 791da177e4SLinus Torvalds #include <linux/module.h> 801da177e4SLinus Torvalds #include <linux/highmem.h> 811da177e4SLinus Torvalds #include <linux/mount.h> 821da177e4SLinus Torvalds #include <linux/security.h> 831da177e4SLinus Torvalds #include <linux/syscalls.h> 841da177e4SLinus Torvalds #include <linux/compat.h> 851da177e4SLinus Torvalds #include <linux/kmod.h> 863ec3b2fbSDavid Woodhouse #include <linux/audit.h> 87d86b5e0eSAdrian Bunk #include <linux/wireless.h> 881b8d7ae4SEric W. Biederman #include <linux/nsproxy.h> 891da177e4SLinus Torvalds 901da177e4SLinus Torvalds #include <asm/uaccess.h> 911da177e4SLinus Torvalds #include <asm/unistd.h> 921da177e4SLinus Torvalds 931da177e4SLinus Torvalds #include <net/compat.h> 9487de87d5SDavid S. Miller #include <net/wext.h> 951da177e4SLinus Torvalds 961da177e4SLinus Torvalds #include <net/sock.h> 971da177e4SLinus Torvalds #include <linux/netfilter.h> 981da177e4SLinus Torvalds 991da177e4SLinus Torvalds static int sock_no_open(struct inode *irrelevant, struct file *dontcare); 100027445c3SBadari Pulavarty static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov, 101027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos); 102027445c3SBadari Pulavarty static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov, 103027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos); 1041da177e4SLinus Torvalds static int sock_mmap(struct file *file, struct vm_area_struct *vma); 1051da177e4SLinus Torvalds 1061da177e4SLinus Torvalds static int sock_close(struct inode *inode, struct file *file); 1071da177e4SLinus Torvalds static unsigned int sock_poll(struct file *file, 1081da177e4SLinus Torvalds struct poll_table_struct *wait); 10989bddce5SStephen Hemminger static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg); 11089bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 11189bbfc95SShaun Pereira static long compat_sock_ioctl(struct file *file, 11289bbfc95SShaun Pereira unsigned int cmd, unsigned long arg); 11389bbfc95SShaun Pereira #endif 1141da177e4SLinus Torvalds static int sock_fasync(int fd, struct file *filp, int on); 1151da177e4SLinus Torvalds static ssize_t sock_sendpage(struct file *file, struct page *page, 1161da177e4SLinus Torvalds int offset, size_t size, loff_t *ppos, int more); 1179c55e01cSJens Axboe static ssize_t sock_splice_read(struct file *file, loff_t *ppos, 1189c55e01cSJens Axboe struct pipe_inode_info *pipe, size_t len, 1199c55e01cSJens Axboe unsigned int flags); 1201da177e4SLinus Torvalds 1211da177e4SLinus Torvalds /* 1221da177e4SLinus Torvalds * Socket files have a set of 'special' operations as well as the generic file ones. These don't appear 1231da177e4SLinus Torvalds * in the operation structures but are done directly via the socketcall() multiplexor. 1241da177e4SLinus Torvalds */ 1251da177e4SLinus Torvalds 126da7071d7SArjan van de Ven static const struct file_operations socket_file_ops = { 1271da177e4SLinus Torvalds .owner = THIS_MODULE, 1281da177e4SLinus Torvalds .llseek = no_llseek, 1291da177e4SLinus Torvalds .aio_read = sock_aio_read, 1301da177e4SLinus Torvalds .aio_write = sock_aio_write, 1311da177e4SLinus Torvalds .poll = sock_poll, 1321da177e4SLinus Torvalds .unlocked_ioctl = sock_ioctl, 13389bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 13489bbfc95SShaun Pereira .compat_ioctl = compat_sock_ioctl, 13589bbfc95SShaun Pereira #endif 1361da177e4SLinus Torvalds .mmap = sock_mmap, 1371da177e4SLinus Torvalds .open = sock_no_open, /* special open code to disallow open via /proc */ 1381da177e4SLinus Torvalds .release = sock_close, 1391da177e4SLinus Torvalds .fasync = sock_fasync, 1405274f052SJens Axboe .sendpage = sock_sendpage, 1415274f052SJens Axboe .splice_write = generic_splice_sendpage, 1429c55e01cSJens Axboe .splice_read = sock_splice_read, 1431da177e4SLinus Torvalds }; 1441da177e4SLinus Torvalds 1451da177e4SLinus Torvalds /* 1461da177e4SLinus Torvalds * The protocol list. Each protocol is registered in here. 1471da177e4SLinus Torvalds */ 1481da177e4SLinus Torvalds 1491da177e4SLinus Torvalds static DEFINE_SPINLOCK(net_family_lock); 150f0fd27d4SStephen Hemminger static const struct net_proto_family *net_families[NPROTO] __read_mostly; 1511da177e4SLinus Torvalds 1521da177e4SLinus Torvalds /* 1531da177e4SLinus Torvalds * Statistics counters of the socket lists 1541da177e4SLinus Torvalds */ 1551da177e4SLinus Torvalds 1561da177e4SLinus Torvalds static DEFINE_PER_CPU(int, sockets_in_use) = 0; 1571da177e4SLinus Torvalds 1581da177e4SLinus Torvalds /* 15989bddce5SStephen Hemminger * Support routines. 16089bddce5SStephen Hemminger * Move socket addresses back and forth across the kernel/user 1611da177e4SLinus Torvalds * divide and look after the messy bits. 1621da177e4SLinus Torvalds */ 1631da177e4SLinus Torvalds 1641da177e4SLinus Torvalds #define MAX_SOCK_ADDR 128 /* 108 for Unix domain - 1651da177e4SLinus Torvalds 16 for IP, 16 for IPX, 1661da177e4SLinus Torvalds 24 for IPv6, 1671da177e4SLinus Torvalds about 80 for AX.25 1681da177e4SLinus Torvalds must be at least one bigger than 1691da177e4SLinus Torvalds the AF_UNIX size (see net/unix/af_unix.c 1701da177e4SLinus Torvalds :unix_mkname()). 1711da177e4SLinus Torvalds */ 1721da177e4SLinus Torvalds 1731da177e4SLinus Torvalds /** 1741da177e4SLinus Torvalds * move_addr_to_kernel - copy a socket address into kernel space 1751da177e4SLinus Torvalds * @uaddr: Address in user space 1761da177e4SLinus Torvalds * @kaddr: Address in kernel space 1771da177e4SLinus Torvalds * @ulen: Length in user space 1781da177e4SLinus Torvalds * 1791da177e4SLinus Torvalds * The address is copied into kernel space. If the provided address is 1801da177e4SLinus Torvalds * too long an error code of -EINVAL is returned. If the copy gives 1811da177e4SLinus Torvalds * invalid addresses -EFAULT is returned. On a success 0 is returned. 1821da177e4SLinus Torvalds */ 1831da177e4SLinus Torvalds 184230b1839SYOSHIFUJI Hideaki int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr *kaddr) 1851da177e4SLinus Torvalds { 186230b1839SYOSHIFUJI Hideaki if (ulen < 0 || ulen > sizeof(struct sockaddr_storage)) 1871da177e4SLinus Torvalds return -EINVAL; 1881da177e4SLinus Torvalds if (ulen == 0) 1891da177e4SLinus Torvalds return 0; 1901da177e4SLinus Torvalds if (copy_from_user(kaddr, uaddr, ulen)) 1911da177e4SLinus Torvalds return -EFAULT; 1923ec3b2fbSDavid Woodhouse return audit_sockaddr(ulen, kaddr); 1931da177e4SLinus Torvalds } 1941da177e4SLinus Torvalds 1951da177e4SLinus Torvalds /** 1961da177e4SLinus Torvalds * move_addr_to_user - copy an address to user space 1971da177e4SLinus Torvalds * @kaddr: kernel space address 1981da177e4SLinus Torvalds * @klen: length of address in kernel 1991da177e4SLinus Torvalds * @uaddr: user space address 2001da177e4SLinus Torvalds * @ulen: pointer to user length field 2011da177e4SLinus Torvalds * 2021da177e4SLinus Torvalds * The value pointed to by ulen on entry is the buffer length available. 2031da177e4SLinus Torvalds * This is overwritten with the buffer space used. -EINVAL is returned 2041da177e4SLinus Torvalds * if an overlong buffer is specified or a negative buffer size. -EFAULT 2051da177e4SLinus Torvalds * is returned if either the buffer or the length field are not 2061da177e4SLinus Torvalds * accessible. 2071da177e4SLinus Torvalds * After copying the data up to the limit the user specifies, the true 2081da177e4SLinus Torvalds * length of the data is written over the length limit the user 2091da177e4SLinus Torvalds * specified. Zero is returned for a success. 2101da177e4SLinus Torvalds */ 2111da177e4SLinus Torvalds 212230b1839SYOSHIFUJI Hideaki int move_addr_to_user(struct sockaddr *kaddr, int klen, void __user *uaddr, 21389bddce5SStephen Hemminger int __user *ulen) 2141da177e4SLinus Torvalds { 2151da177e4SLinus Torvalds int err; 2161da177e4SLinus Torvalds int len; 2171da177e4SLinus Torvalds 21889bddce5SStephen Hemminger err = get_user(len, ulen); 21989bddce5SStephen Hemminger if (err) 2201da177e4SLinus Torvalds return err; 2211da177e4SLinus Torvalds if (len > klen) 2221da177e4SLinus Torvalds len = klen; 223230b1839SYOSHIFUJI Hideaki if (len < 0 || len > sizeof(struct sockaddr_storage)) 2241da177e4SLinus Torvalds return -EINVAL; 22589bddce5SStephen Hemminger if (len) { 226d6fe3945SSteve Grubb if (audit_sockaddr(klen, kaddr)) 227d6fe3945SSteve Grubb return -ENOMEM; 2281da177e4SLinus Torvalds if (copy_to_user(uaddr, kaddr, len)) 2291da177e4SLinus Torvalds return -EFAULT; 2301da177e4SLinus Torvalds } 2311da177e4SLinus Torvalds /* 2321da177e4SLinus Torvalds * "fromlen shall refer to the value before truncation.." 2331da177e4SLinus Torvalds * 1003.1g 2341da177e4SLinus Torvalds */ 2351da177e4SLinus Torvalds return __put_user(klen, ulen); 2361da177e4SLinus Torvalds } 2371da177e4SLinus Torvalds 2381da177e4SLinus Torvalds #define SOCKFS_MAGIC 0x534F434B 2391da177e4SLinus Torvalds 240e18b890bSChristoph Lameter static struct kmem_cache *sock_inode_cachep __read_mostly; 2411da177e4SLinus Torvalds 2421da177e4SLinus Torvalds static struct inode *sock_alloc_inode(struct super_block *sb) 2431da177e4SLinus Torvalds { 2441da177e4SLinus Torvalds struct socket_alloc *ei; 24589bddce5SStephen Hemminger 246e94b1766SChristoph Lameter ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL); 2471da177e4SLinus Torvalds if (!ei) 2481da177e4SLinus Torvalds return NULL; 2491da177e4SLinus Torvalds init_waitqueue_head(&ei->socket.wait); 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds ei->socket.fasync_list = NULL; 2521da177e4SLinus Torvalds ei->socket.state = SS_UNCONNECTED; 2531da177e4SLinus Torvalds ei->socket.flags = 0; 2541da177e4SLinus Torvalds ei->socket.ops = NULL; 2551da177e4SLinus Torvalds ei->socket.sk = NULL; 2561da177e4SLinus Torvalds ei->socket.file = NULL; 2571da177e4SLinus Torvalds 2581da177e4SLinus Torvalds return &ei->vfs_inode; 2591da177e4SLinus Torvalds } 2601da177e4SLinus Torvalds 2611da177e4SLinus Torvalds static void sock_destroy_inode(struct inode *inode) 2621da177e4SLinus Torvalds { 2631da177e4SLinus Torvalds kmem_cache_free(sock_inode_cachep, 2641da177e4SLinus Torvalds container_of(inode, struct socket_alloc, vfs_inode)); 2651da177e4SLinus Torvalds } 2661da177e4SLinus Torvalds 26751cc5068SAlexey Dobriyan static void init_once(void *foo) 2681da177e4SLinus Torvalds { 2691da177e4SLinus Torvalds struct socket_alloc *ei = (struct socket_alloc *)foo; 2701da177e4SLinus Torvalds 2711da177e4SLinus Torvalds inode_init_once(&ei->vfs_inode); 2721da177e4SLinus Torvalds } 2731da177e4SLinus Torvalds 2741da177e4SLinus Torvalds static int init_inodecache(void) 2751da177e4SLinus Torvalds { 2761da177e4SLinus Torvalds sock_inode_cachep = kmem_cache_create("sock_inode_cache", 2771da177e4SLinus Torvalds sizeof(struct socket_alloc), 27889bddce5SStephen Hemminger 0, 27989bddce5SStephen Hemminger (SLAB_HWCACHE_ALIGN | 28089bddce5SStephen Hemminger SLAB_RECLAIM_ACCOUNT | 281fffb60f9SPaul Jackson SLAB_MEM_SPREAD), 28220c2df83SPaul Mundt init_once); 2831da177e4SLinus Torvalds if (sock_inode_cachep == NULL) 2841da177e4SLinus Torvalds return -ENOMEM; 2851da177e4SLinus Torvalds return 0; 2861da177e4SLinus Torvalds } 2871da177e4SLinus Torvalds 2881da177e4SLinus Torvalds static struct super_operations sockfs_ops = { 2891da177e4SLinus Torvalds .alloc_inode = sock_alloc_inode, 2901da177e4SLinus Torvalds .destroy_inode =sock_destroy_inode, 2911da177e4SLinus Torvalds .statfs = simple_statfs, 2921da177e4SLinus Torvalds }; 2931da177e4SLinus Torvalds 294454e2398SDavid Howells static int sockfs_get_sb(struct file_system_type *fs_type, 29589bddce5SStephen Hemminger int flags, const char *dev_name, void *data, 29689bddce5SStephen Hemminger struct vfsmount *mnt) 2971da177e4SLinus Torvalds { 298454e2398SDavid Howells return get_sb_pseudo(fs_type, "socket:", &sockfs_ops, SOCKFS_MAGIC, 299454e2398SDavid Howells mnt); 3001da177e4SLinus Torvalds } 3011da177e4SLinus Torvalds 302ba89966cSEric Dumazet static struct vfsmount *sock_mnt __read_mostly; 3031da177e4SLinus Torvalds 3041da177e4SLinus Torvalds static struct file_system_type sock_fs_type = { 3051da177e4SLinus Torvalds .name = "sockfs", 3061da177e4SLinus Torvalds .get_sb = sockfs_get_sb, 3071da177e4SLinus Torvalds .kill_sb = kill_anon_super, 3081da177e4SLinus Torvalds }; 30989bddce5SStephen Hemminger 3101da177e4SLinus Torvalds static int sockfs_delete_dentry(struct dentry *dentry) 3111da177e4SLinus Torvalds { 312304e61e6SEric Dumazet /* 313304e61e6SEric Dumazet * At creation time, we pretended this dentry was hashed 314304e61e6SEric Dumazet * (by clearing DCACHE_UNHASHED bit in d_flags) 315304e61e6SEric Dumazet * At delete time, we restore the truth : not hashed. 316304e61e6SEric Dumazet * (so that dput() can proceed correctly) 317304e61e6SEric Dumazet */ 318304e61e6SEric Dumazet dentry->d_flags |= DCACHE_UNHASHED; 319304e61e6SEric Dumazet return 0; 3201da177e4SLinus Torvalds } 321c23fbb6bSEric Dumazet 322c23fbb6bSEric Dumazet /* 323c23fbb6bSEric Dumazet * sockfs_dname() is called from d_path(). 324c23fbb6bSEric Dumazet */ 325c23fbb6bSEric Dumazet static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen) 326c23fbb6bSEric Dumazet { 327c23fbb6bSEric Dumazet return dynamic_dname(dentry, buffer, buflen, "socket:[%lu]", 328c23fbb6bSEric Dumazet dentry->d_inode->i_ino); 329c23fbb6bSEric Dumazet } 330c23fbb6bSEric Dumazet 3311da177e4SLinus Torvalds static struct dentry_operations sockfs_dentry_operations = { 3321da177e4SLinus Torvalds .d_delete = sockfs_delete_dentry, 333c23fbb6bSEric Dumazet .d_dname = sockfs_dname, 3341da177e4SLinus Torvalds }; 3351da177e4SLinus Torvalds 3361da177e4SLinus Torvalds /* 3371da177e4SLinus Torvalds * Obtains the first available file descriptor and sets it up for use. 3381da177e4SLinus Torvalds * 33939d8c1b6SDavid S. Miller * These functions create file structures and maps them to fd space 34039d8c1b6SDavid S. Miller * of the current process. On success it returns file descriptor 3411da177e4SLinus Torvalds * and file struct implicitly stored in sock->file. 3421da177e4SLinus Torvalds * Note that another thread may close file descriptor before we return 3431da177e4SLinus Torvalds * from this function. We use the fact that now we do not refer 3441da177e4SLinus Torvalds * to socket after mapping. If one day we will need it, this 3451da177e4SLinus Torvalds * function will increment ref. count on file by 1. 3461da177e4SLinus Torvalds * 3471da177e4SLinus Torvalds * In any case returned fd MAY BE not valid! 3481da177e4SLinus Torvalds * This race condition is unavoidable 3491da177e4SLinus Torvalds * with shared fd spaces, we cannot solve it inside kernel, 3501da177e4SLinus Torvalds * but we take care of internal coherence yet. 3511da177e4SLinus Torvalds */ 3521da177e4SLinus Torvalds 353a677a039SUlrich Drepper static int sock_alloc_fd(struct file **filep, int flags) 3541da177e4SLinus Torvalds { 3551da177e4SLinus Torvalds int fd; 3561da177e4SLinus Torvalds 357a677a039SUlrich Drepper fd = get_unused_fd_flags(flags); 35839d8c1b6SDavid S. Miller if (likely(fd >= 0)) { 3591da177e4SLinus Torvalds struct file *file = get_empty_filp(); 3601da177e4SLinus Torvalds 36139d8c1b6SDavid S. Miller *filep = file; 36239d8c1b6SDavid S. Miller if (unlikely(!file)) { 3631da177e4SLinus Torvalds put_unused_fd(fd); 36439d8c1b6SDavid S. Miller return -ENFILE; 3651da177e4SLinus Torvalds } 36639d8c1b6SDavid S. Miller } else 36739d8c1b6SDavid S. Miller *filep = NULL; 36839d8c1b6SDavid S. Miller return fd; 36939d8c1b6SDavid S. Miller } 37039d8c1b6SDavid S. Miller 37177d27200SUlrich Drepper static int sock_attach_fd(struct socket *sock, struct file *file, int flags) 37239d8c1b6SDavid S. Miller { 373ce8d2cdfSDave Hansen struct dentry *dentry; 374c23fbb6bSEric Dumazet struct qstr name = { .name = "" }; 3751da177e4SLinus Torvalds 376ce8d2cdfSDave Hansen dentry = d_alloc(sock_mnt->mnt_sb->s_root, &name); 377ce8d2cdfSDave Hansen if (unlikely(!dentry)) 37839d8c1b6SDavid S. Miller return -ENOMEM; 37939d8c1b6SDavid S. Miller 380ce8d2cdfSDave Hansen dentry->d_op = &sockfs_dentry_operations; 381304e61e6SEric Dumazet /* 382304e61e6SEric Dumazet * We dont want to push this dentry into global dentry hash table. 383304e61e6SEric Dumazet * We pretend dentry is already hashed, by unsetting DCACHE_UNHASHED 384304e61e6SEric Dumazet * This permits a working /proc/$pid/fd/XXX on sockets 385304e61e6SEric Dumazet */ 386ce8d2cdfSDave Hansen dentry->d_flags &= ~DCACHE_UNHASHED; 387ce8d2cdfSDave Hansen d_instantiate(dentry, SOCK_INODE(sock)); 3881da177e4SLinus Torvalds 3891da177e4SLinus Torvalds sock->file = file; 390ce8d2cdfSDave Hansen init_file(file, sock_mnt, dentry, FMODE_READ | FMODE_WRITE, 391ce8d2cdfSDave Hansen &socket_file_ops); 392ce8d2cdfSDave Hansen SOCK_INODE(sock)->i_fop = &socket_file_ops; 39377d27200SUlrich Drepper file->f_flags = O_RDWR | (flags & O_NONBLOCK); 3941da177e4SLinus Torvalds file->f_pos = 0; 39507dc3f07SBenjamin LaHaise file->private_data = sock; 39639d8c1b6SDavid S. Miller 39739d8c1b6SDavid S. Miller return 0; 3981da177e4SLinus Torvalds } 3991da177e4SLinus Torvalds 400a677a039SUlrich Drepper int sock_map_fd(struct socket *sock, int flags) 40139d8c1b6SDavid S. Miller { 40239d8c1b6SDavid S. Miller struct file *newfile; 403a677a039SUlrich Drepper int fd = sock_alloc_fd(&newfile, flags); 40439d8c1b6SDavid S. Miller 40539d8c1b6SDavid S. Miller if (likely(fd >= 0)) { 40677d27200SUlrich Drepper int err = sock_attach_fd(sock, newfile, flags); 40739d8c1b6SDavid S. Miller 40839d8c1b6SDavid S. Miller if (unlikely(err < 0)) { 40939d8c1b6SDavid S. Miller put_filp(newfile); 41039d8c1b6SDavid S. Miller put_unused_fd(fd); 41139d8c1b6SDavid S. Miller return err; 41239d8c1b6SDavid S. Miller } 41339d8c1b6SDavid S. Miller fd_install(fd, newfile); 41439d8c1b6SDavid S. Miller } 4151da177e4SLinus Torvalds return fd; 4161da177e4SLinus Torvalds } 4171da177e4SLinus Torvalds 4186cb153caSBenjamin LaHaise static struct socket *sock_from_file(struct file *file, int *err) 4196cb153caSBenjamin LaHaise { 4206cb153caSBenjamin LaHaise if (file->f_op == &socket_file_ops) 4216cb153caSBenjamin LaHaise return file->private_data; /* set in sock_map_fd */ 4226cb153caSBenjamin LaHaise 4236cb153caSBenjamin LaHaise *err = -ENOTSOCK; 4246cb153caSBenjamin LaHaise return NULL; 4256cb153caSBenjamin LaHaise } 4266cb153caSBenjamin LaHaise 4271da177e4SLinus Torvalds /** 4281da177e4SLinus Torvalds * sockfd_lookup - Go from a file number to its socket slot 4291da177e4SLinus Torvalds * @fd: file handle 4301da177e4SLinus Torvalds * @err: pointer to an error code return 4311da177e4SLinus Torvalds * 4321da177e4SLinus Torvalds * The file handle passed in is locked and the socket it is bound 4331da177e4SLinus Torvalds * too is returned. If an error occurs the err pointer is overwritten 4341da177e4SLinus Torvalds * with a negative errno code and NULL is returned. The function checks 4351da177e4SLinus Torvalds * for both invalid handles and passing a handle which is not a socket. 4361da177e4SLinus Torvalds * 4371da177e4SLinus Torvalds * On a success the socket object pointer is returned. 4381da177e4SLinus Torvalds */ 4391da177e4SLinus Torvalds 4401da177e4SLinus Torvalds struct socket *sockfd_lookup(int fd, int *err) 4411da177e4SLinus Torvalds { 4421da177e4SLinus Torvalds struct file *file; 4431da177e4SLinus Torvalds struct socket *sock; 4441da177e4SLinus Torvalds 44589bddce5SStephen Hemminger file = fget(fd); 44689bddce5SStephen Hemminger if (!file) { 4471da177e4SLinus Torvalds *err = -EBADF; 4481da177e4SLinus Torvalds return NULL; 4491da177e4SLinus Torvalds } 45089bddce5SStephen Hemminger 4516cb153caSBenjamin LaHaise sock = sock_from_file(file, err); 4526cb153caSBenjamin LaHaise if (!sock) 4531da177e4SLinus Torvalds fput(file); 4546cb153caSBenjamin LaHaise return sock; 4551da177e4SLinus Torvalds } 4561da177e4SLinus Torvalds 4576cb153caSBenjamin LaHaise static struct socket *sockfd_lookup_light(int fd, int *err, int *fput_needed) 4586cb153caSBenjamin LaHaise { 4596cb153caSBenjamin LaHaise struct file *file; 4606cb153caSBenjamin LaHaise struct socket *sock; 4616cb153caSBenjamin LaHaise 4623672558cSHua Zhong *err = -EBADF; 4636cb153caSBenjamin LaHaise file = fget_light(fd, fput_needed); 4646cb153caSBenjamin LaHaise if (file) { 4656cb153caSBenjamin LaHaise sock = sock_from_file(file, err); 4666cb153caSBenjamin LaHaise if (sock) 4671da177e4SLinus Torvalds return sock; 4686cb153caSBenjamin LaHaise fput_light(file, *fput_needed); 4696cb153caSBenjamin LaHaise } 4706cb153caSBenjamin LaHaise return NULL; 4711da177e4SLinus Torvalds } 4721da177e4SLinus Torvalds 4731da177e4SLinus Torvalds /** 4741da177e4SLinus Torvalds * sock_alloc - allocate a socket 4751da177e4SLinus Torvalds * 4761da177e4SLinus Torvalds * Allocate a new inode and socket object. The two are bound together 4771da177e4SLinus Torvalds * and initialised. The socket is then returned. If we are out of inodes 4781da177e4SLinus Torvalds * NULL is returned. 4791da177e4SLinus Torvalds */ 4801da177e4SLinus Torvalds 4811da177e4SLinus Torvalds static struct socket *sock_alloc(void) 4821da177e4SLinus Torvalds { 4831da177e4SLinus Torvalds struct inode *inode; 4841da177e4SLinus Torvalds struct socket *sock; 4851da177e4SLinus Torvalds 4861da177e4SLinus Torvalds inode = new_inode(sock_mnt->mnt_sb); 4871da177e4SLinus Torvalds if (!inode) 4881da177e4SLinus Torvalds return NULL; 4891da177e4SLinus Torvalds 4901da177e4SLinus Torvalds sock = SOCKET_I(inode); 4911da177e4SLinus Torvalds 4921da177e4SLinus Torvalds inode->i_mode = S_IFSOCK | S_IRWXUGO; 4938192b0c4SDavid Howells inode->i_uid = current_fsuid(); 4948192b0c4SDavid Howells inode->i_gid = current_fsgid(); 4951da177e4SLinus Torvalds 4961da177e4SLinus Torvalds get_cpu_var(sockets_in_use)++; 4971da177e4SLinus Torvalds put_cpu_var(sockets_in_use); 4981da177e4SLinus Torvalds return sock; 4991da177e4SLinus Torvalds } 5001da177e4SLinus Torvalds 5011da177e4SLinus Torvalds /* 5021da177e4SLinus Torvalds * In theory you can't get an open on this inode, but /proc provides 5031da177e4SLinus Torvalds * a back door. Remember to keep it shut otherwise you'll let the 5041da177e4SLinus Torvalds * creepy crawlies in. 5051da177e4SLinus Torvalds */ 5061da177e4SLinus Torvalds 5071da177e4SLinus Torvalds static int sock_no_open(struct inode *irrelevant, struct file *dontcare) 5081da177e4SLinus Torvalds { 5091da177e4SLinus Torvalds return -ENXIO; 5101da177e4SLinus Torvalds } 5111da177e4SLinus Torvalds 5124b6f5d20SArjan van de Ven const struct file_operations bad_sock_fops = { 5131da177e4SLinus Torvalds .owner = THIS_MODULE, 5141da177e4SLinus Torvalds .open = sock_no_open, 5151da177e4SLinus Torvalds }; 5161da177e4SLinus Torvalds 5171da177e4SLinus Torvalds /** 5181da177e4SLinus Torvalds * sock_release - close a socket 5191da177e4SLinus Torvalds * @sock: socket to close 5201da177e4SLinus Torvalds * 5211da177e4SLinus Torvalds * The socket is released from the protocol stack if it has a release 5221da177e4SLinus Torvalds * callback, and the inode is then released if the socket is bound to 5231da177e4SLinus Torvalds * an inode not a file. 5241da177e4SLinus Torvalds */ 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds void sock_release(struct socket *sock) 5271da177e4SLinus Torvalds { 5281da177e4SLinus Torvalds if (sock->ops) { 5291da177e4SLinus Torvalds struct module *owner = sock->ops->owner; 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds sock->ops->release(sock); 5321da177e4SLinus Torvalds sock->ops = NULL; 5331da177e4SLinus Torvalds module_put(owner); 5341da177e4SLinus Torvalds } 5351da177e4SLinus Torvalds 5361da177e4SLinus Torvalds if (sock->fasync_list) 5371da177e4SLinus Torvalds printk(KERN_ERR "sock_release: fasync list not empty!\n"); 5381da177e4SLinus Torvalds 5391da177e4SLinus Torvalds get_cpu_var(sockets_in_use)--; 5401da177e4SLinus Torvalds put_cpu_var(sockets_in_use); 5411da177e4SLinus Torvalds if (!sock->file) { 5421da177e4SLinus Torvalds iput(SOCK_INODE(sock)); 5431da177e4SLinus Torvalds return; 5441da177e4SLinus Torvalds } 5451da177e4SLinus Torvalds sock->file = NULL; 5461da177e4SLinus Torvalds } 5471da177e4SLinus Torvalds 5481da177e4SLinus Torvalds static inline int __sock_sendmsg(struct kiocb *iocb, struct socket *sock, 5491da177e4SLinus Torvalds struct msghdr *msg, size_t size) 5501da177e4SLinus Torvalds { 5511da177e4SLinus Torvalds struct sock_iocb *si = kiocb_to_siocb(iocb); 5521da177e4SLinus Torvalds int err; 5531da177e4SLinus Torvalds 5541da177e4SLinus Torvalds si->sock = sock; 5551da177e4SLinus Torvalds si->scm = NULL; 5561da177e4SLinus Torvalds si->msg = msg; 5571da177e4SLinus Torvalds si->size = size; 5581da177e4SLinus Torvalds 5591da177e4SLinus Torvalds err = security_socket_sendmsg(sock, msg, size); 5601da177e4SLinus Torvalds if (err) 5611da177e4SLinus Torvalds return err; 5621da177e4SLinus Torvalds 5631da177e4SLinus Torvalds return sock->ops->sendmsg(iocb, sock, msg, size); 5641da177e4SLinus Torvalds } 5651da177e4SLinus Torvalds 5661da177e4SLinus Torvalds int sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t size) 5671da177e4SLinus Torvalds { 5681da177e4SLinus Torvalds struct kiocb iocb; 5691da177e4SLinus Torvalds struct sock_iocb siocb; 5701da177e4SLinus Torvalds int ret; 5711da177e4SLinus Torvalds 5721da177e4SLinus Torvalds init_sync_kiocb(&iocb, NULL); 5731da177e4SLinus Torvalds iocb.private = &siocb; 5741da177e4SLinus Torvalds ret = __sock_sendmsg(&iocb, sock, msg, size); 5751da177e4SLinus Torvalds if (-EIOCBQUEUED == ret) 5761da177e4SLinus Torvalds ret = wait_on_sync_kiocb(&iocb); 5771da177e4SLinus Torvalds return ret; 5781da177e4SLinus Torvalds } 5791da177e4SLinus Torvalds 5801da177e4SLinus Torvalds int kernel_sendmsg(struct socket *sock, struct msghdr *msg, 5811da177e4SLinus Torvalds struct kvec *vec, size_t num, size_t size) 5821da177e4SLinus Torvalds { 5831da177e4SLinus Torvalds mm_segment_t oldfs = get_fs(); 5841da177e4SLinus Torvalds int result; 5851da177e4SLinus Torvalds 5861da177e4SLinus Torvalds set_fs(KERNEL_DS); 5871da177e4SLinus Torvalds /* 5881da177e4SLinus Torvalds * the following is safe, since for compiler definitions of kvec and 5891da177e4SLinus Torvalds * iovec are identical, yielding the same in-core layout and alignment 5901da177e4SLinus Torvalds */ 59189bddce5SStephen Hemminger msg->msg_iov = (struct iovec *)vec; 5921da177e4SLinus Torvalds msg->msg_iovlen = num; 5931da177e4SLinus Torvalds result = sock_sendmsg(sock, msg, size); 5941da177e4SLinus Torvalds set_fs(oldfs); 5951da177e4SLinus Torvalds return result; 5961da177e4SLinus Torvalds } 5971da177e4SLinus Torvalds 59892f37fd2SEric Dumazet /* 59992f37fd2SEric Dumazet * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP) 60092f37fd2SEric Dumazet */ 60192f37fd2SEric Dumazet void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk, 60292f37fd2SEric Dumazet struct sk_buff *skb) 60392f37fd2SEric Dumazet { 60492f37fd2SEric Dumazet ktime_t kt = skb->tstamp; 60592f37fd2SEric Dumazet 60692f37fd2SEric Dumazet if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) { 60792f37fd2SEric Dumazet struct timeval tv; 60892f37fd2SEric Dumazet /* Race occurred between timestamp enabling and packet 60992f37fd2SEric Dumazet receiving. Fill in the current time for now. */ 61092f37fd2SEric Dumazet if (kt.tv64 == 0) 61192f37fd2SEric Dumazet kt = ktime_get_real(); 61292f37fd2SEric Dumazet skb->tstamp = kt; 61392f37fd2SEric Dumazet tv = ktime_to_timeval(kt); 61492f37fd2SEric Dumazet put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP, sizeof(tv), &tv); 61592f37fd2SEric Dumazet } else { 61692f37fd2SEric Dumazet struct timespec ts; 61792f37fd2SEric Dumazet /* Race occurred between timestamp enabling and packet 61892f37fd2SEric Dumazet receiving. Fill in the current time for now. */ 61992f37fd2SEric Dumazet if (kt.tv64 == 0) 62092f37fd2SEric Dumazet kt = ktime_get_real(); 62192f37fd2SEric Dumazet skb->tstamp = kt; 62292f37fd2SEric Dumazet ts = ktime_to_timespec(kt); 62392f37fd2SEric Dumazet put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS, sizeof(ts), &ts); 62492f37fd2SEric Dumazet } 62592f37fd2SEric Dumazet } 62692f37fd2SEric Dumazet 6277c81fd8bSArnaldo Carvalho de Melo EXPORT_SYMBOL_GPL(__sock_recv_timestamp); 6287c81fd8bSArnaldo Carvalho de Melo 6291da177e4SLinus Torvalds static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock, 6301da177e4SLinus Torvalds struct msghdr *msg, size_t size, int flags) 6311da177e4SLinus Torvalds { 6321da177e4SLinus Torvalds int err; 6331da177e4SLinus Torvalds struct sock_iocb *si = kiocb_to_siocb(iocb); 6341da177e4SLinus Torvalds 6351da177e4SLinus Torvalds si->sock = sock; 6361da177e4SLinus Torvalds si->scm = NULL; 6371da177e4SLinus Torvalds si->msg = msg; 6381da177e4SLinus Torvalds si->size = size; 6391da177e4SLinus Torvalds si->flags = flags; 6401da177e4SLinus Torvalds 6411da177e4SLinus Torvalds err = security_socket_recvmsg(sock, msg, size, flags); 6421da177e4SLinus Torvalds if (err) 6431da177e4SLinus Torvalds return err; 6441da177e4SLinus Torvalds 6451da177e4SLinus Torvalds return sock->ops->recvmsg(iocb, sock, msg, size, flags); 6461da177e4SLinus Torvalds } 6471da177e4SLinus Torvalds 6481da177e4SLinus Torvalds int sock_recvmsg(struct socket *sock, struct msghdr *msg, 6491da177e4SLinus Torvalds size_t size, int flags) 6501da177e4SLinus Torvalds { 6511da177e4SLinus Torvalds struct kiocb iocb; 6521da177e4SLinus Torvalds struct sock_iocb siocb; 6531da177e4SLinus Torvalds int ret; 6541da177e4SLinus Torvalds 6551da177e4SLinus Torvalds init_sync_kiocb(&iocb, NULL); 6561da177e4SLinus Torvalds iocb.private = &siocb; 6571da177e4SLinus Torvalds ret = __sock_recvmsg(&iocb, sock, msg, size, flags); 6581da177e4SLinus Torvalds if (-EIOCBQUEUED == ret) 6591da177e4SLinus Torvalds ret = wait_on_sync_kiocb(&iocb); 6601da177e4SLinus Torvalds return ret; 6611da177e4SLinus Torvalds } 6621da177e4SLinus Torvalds 6631da177e4SLinus Torvalds int kernel_recvmsg(struct socket *sock, struct msghdr *msg, 66489bddce5SStephen Hemminger struct kvec *vec, size_t num, size_t size, int flags) 6651da177e4SLinus Torvalds { 6661da177e4SLinus Torvalds mm_segment_t oldfs = get_fs(); 6671da177e4SLinus Torvalds int result; 6681da177e4SLinus Torvalds 6691da177e4SLinus Torvalds set_fs(KERNEL_DS); 6701da177e4SLinus Torvalds /* 6711da177e4SLinus Torvalds * the following is safe, since for compiler definitions of kvec and 6721da177e4SLinus Torvalds * iovec are identical, yielding the same in-core layout and alignment 6731da177e4SLinus Torvalds */ 67489bddce5SStephen Hemminger msg->msg_iov = (struct iovec *)vec, msg->msg_iovlen = num; 6751da177e4SLinus Torvalds result = sock_recvmsg(sock, msg, size, flags); 6761da177e4SLinus Torvalds set_fs(oldfs); 6771da177e4SLinus Torvalds return result; 6781da177e4SLinus Torvalds } 6791da177e4SLinus Torvalds 6801da177e4SLinus Torvalds static void sock_aio_dtor(struct kiocb *iocb) 6811da177e4SLinus Torvalds { 6821da177e4SLinus Torvalds kfree(iocb->private); 6831da177e4SLinus Torvalds } 6841da177e4SLinus Torvalds 68520380731SArnaldo Carvalho de Melo static ssize_t sock_sendpage(struct file *file, struct page *page, 6861da177e4SLinus Torvalds int offset, size_t size, loff_t *ppos, int more) 6871da177e4SLinus Torvalds { 6881da177e4SLinus Torvalds struct socket *sock; 6891da177e4SLinus Torvalds int flags; 6901da177e4SLinus Torvalds 691b69aee04SEric Dumazet sock = file->private_data; 6921da177e4SLinus Torvalds 6931da177e4SLinus Torvalds flags = !(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT; 6941da177e4SLinus Torvalds if (more) 6951da177e4SLinus Torvalds flags |= MSG_MORE; 6961da177e4SLinus Torvalds 6971da177e4SLinus Torvalds return sock->ops->sendpage(sock, page, offset, size, flags); 6981da177e4SLinus Torvalds } 6991da177e4SLinus Torvalds 7009c55e01cSJens Axboe static ssize_t sock_splice_read(struct file *file, loff_t *ppos, 7019c55e01cSJens Axboe struct pipe_inode_info *pipe, size_t len, 7029c55e01cSJens Axboe unsigned int flags) 7039c55e01cSJens Axboe { 7049c55e01cSJens Axboe struct socket *sock = file->private_data; 7059c55e01cSJens Axboe 706997b37daSRémi Denis-Courmont if (unlikely(!sock->ops->splice_read)) 707997b37daSRémi Denis-Courmont return -EINVAL; 708997b37daSRémi Denis-Courmont 7099c55e01cSJens Axboe return sock->ops->splice_read(sock, ppos, pipe, len, flags); 7109c55e01cSJens Axboe } 7119c55e01cSJens Axboe 712ce1d4d3eSChristoph Hellwig static struct sock_iocb *alloc_sock_iocb(struct kiocb *iocb, 71389bddce5SStephen Hemminger struct sock_iocb *siocb) 714ce1d4d3eSChristoph Hellwig { 715ce1d4d3eSChristoph Hellwig if (!is_sync_kiocb(iocb)) { 716ce1d4d3eSChristoph Hellwig siocb = kmalloc(sizeof(*siocb), GFP_KERNEL); 717ce1d4d3eSChristoph Hellwig if (!siocb) 718ce1d4d3eSChristoph Hellwig return NULL; 719ce1d4d3eSChristoph Hellwig iocb->ki_dtor = sock_aio_dtor; 720ce1d4d3eSChristoph Hellwig } 721ce1d4d3eSChristoph Hellwig 722ce1d4d3eSChristoph Hellwig siocb->kiocb = iocb; 723ce1d4d3eSChristoph Hellwig iocb->private = siocb; 724ce1d4d3eSChristoph Hellwig return siocb; 725ce1d4d3eSChristoph Hellwig } 726ce1d4d3eSChristoph Hellwig 727ce1d4d3eSChristoph Hellwig static ssize_t do_sock_read(struct msghdr *msg, struct kiocb *iocb, 728027445c3SBadari Pulavarty struct file *file, const struct iovec *iov, 72989bddce5SStephen Hemminger unsigned long nr_segs) 730ce1d4d3eSChristoph Hellwig { 731ce1d4d3eSChristoph Hellwig struct socket *sock = file->private_data; 732ce1d4d3eSChristoph Hellwig size_t size = 0; 733ce1d4d3eSChristoph Hellwig int i; 734ce1d4d3eSChristoph Hellwig 735ce1d4d3eSChristoph Hellwig for (i = 0; i < nr_segs; i++) 736ce1d4d3eSChristoph Hellwig size += iov[i].iov_len; 737ce1d4d3eSChristoph Hellwig 738ce1d4d3eSChristoph Hellwig msg->msg_name = NULL; 739ce1d4d3eSChristoph Hellwig msg->msg_namelen = 0; 740ce1d4d3eSChristoph Hellwig msg->msg_control = NULL; 741ce1d4d3eSChristoph Hellwig msg->msg_controllen = 0; 742ce1d4d3eSChristoph Hellwig msg->msg_iov = (struct iovec *)iov; 743ce1d4d3eSChristoph Hellwig msg->msg_iovlen = nr_segs; 744ce1d4d3eSChristoph Hellwig msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0; 745ce1d4d3eSChristoph Hellwig 746ce1d4d3eSChristoph Hellwig return __sock_recvmsg(iocb, sock, msg, size, msg->msg_flags); 747ce1d4d3eSChristoph Hellwig } 748ce1d4d3eSChristoph Hellwig 749027445c3SBadari Pulavarty static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov, 750027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos) 751ce1d4d3eSChristoph Hellwig { 752ce1d4d3eSChristoph Hellwig struct sock_iocb siocb, *x; 753ce1d4d3eSChristoph Hellwig 754ce1d4d3eSChristoph Hellwig if (pos != 0) 755ce1d4d3eSChristoph Hellwig return -ESPIPE; 756027445c3SBadari Pulavarty 757027445c3SBadari Pulavarty if (iocb->ki_left == 0) /* Match SYS5 behaviour */ 758ce1d4d3eSChristoph Hellwig return 0; 759ce1d4d3eSChristoph Hellwig 760027445c3SBadari Pulavarty 761027445c3SBadari Pulavarty x = alloc_sock_iocb(iocb, &siocb); 762ce1d4d3eSChristoph Hellwig if (!x) 763ce1d4d3eSChristoph Hellwig return -ENOMEM; 764027445c3SBadari Pulavarty return do_sock_read(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs); 765ce1d4d3eSChristoph Hellwig } 766ce1d4d3eSChristoph Hellwig 767ce1d4d3eSChristoph Hellwig static ssize_t do_sock_write(struct msghdr *msg, struct kiocb *iocb, 768027445c3SBadari Pulavarty struct file *file, const struct iovec *iov, 76989bddce5SStephen Hemminger unsigned long nr_segs) 770ce1d4d3eSChristoph Hellwig { 771ce1d4d3eSChristoph Hellwig struct socket *sock = file->private_data; 772ce1d4d3eSChristoph Hellwig size_t size = 0; 773ce1d4d3eSChristoph Hellwig int i; 774ce1d4d3eSChristoph Hellwig 775ce1d4d3eSChristoph Hellwig for (i = 0; i < nr_segs; i++) 776ce1d4d3eSChristoph Hellwig size += iov[i].iov_len; 777ce1d4d3eSChristoph Hellwig 778ce1d4d3eSChristoph Hellwig msg->msg_name = NULL; 779ce1d4d3eSChristoph Hellwig msg->msg_namelen = 0; 780ce1d4d3eSChristoph Hellwig msg->msg_control = NULL; 781ce1d4d3eSChristoph Hellwig msg->msg_controllen = 0; 782ce1d4d3eSChristoph Hellwig msg->msg_iov = (struct iovec *)iov; 783ce1d4d3eSChristoph Hellwig msg->msg_iovlen = nr_segs; 784ce1d4d3eSChristoph Hellwig msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0; 785ce1d4d3eSChristoph Hellwig if (sock->type == SOCK_SEQPACKET) 786ce1d4d3eSChristoph Hellwig msg->msg_flags |= MSG_EOR; 787ce1d4d3eSChristoph Hellwig 788ce1d4d3eSChristoph Hellwig return __sock_sendmsg(iocb, sock, msg, size); 789ce1d4d3eSChristoph Hellwig } 790ce1d4d3eSChristoph Hellwig 791027445c3SBadari Pulavarty static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov, 792027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos) 7931da177e4SLinus Torvalds { 794ce1d4d3eSChristoph Hellwig struct sock_iocb siocb, *x; 7951da177e4SLinus Torvalds 796ce1d4d3eSChristoph Hellwig if (pos != 0) 797ce1d4d3eSChristoph Hellwig return -ESPIPE; 798027445c3SBadari Pulavarty 799027445c3SBadari Pulavarty x = alloc_sock_iocb(iocb, &siocb); 800ce1d4d3eSChristoph Hellwig if (!x) 801ce1d4d3eSChristoph Hellwig return -ENOMEM; 802ce1d4d3eSChristoph Hellwig 803027445c3SBadari Pulavarty return do_sock_write(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs); 8041da177e4SLinus Torvalds } 8051da177e4SLinus Torvalds 8061da177e4SLinus Torvalds /* 8071da177e4SLinus Torvalds * Atomic setting of ioctl hooks to avoid race 8081da177e4SLinus Torvalds * with module unload. 8091da177e4SLinus Torvalds */ 8101da177e4SLinus Torvalds 8114a3e2f71SArjan van de Ven static DEFINE_MUTEX(br_ioctl_mutex); 812881d966bSEric W. Biederman static int (*br_ioctl_hook) (struct net *, unsigned int cmd, void __user *arg) = NULL; 8131da177e4SLinus Torvalds 814881d966bSEric W. Biederman void brioctl_set(int (*hook) (struct net *, unsigned int, void __user *)) 8151da177e4SLinus Torvalds { 8164a3e2f71SArjan van de Ven mutex_lock(&br_ioctl_mutex); 8171da177e4SLinus Torvalds br_ioctl_hook = hook; 8184a3e2f71SArjan van de Ven mutex_unlock(&br_ioctl_mutex); 8191da177e4SLinus Torvalds } 82089bddce5SStephen Hemminger 8211da177e4SLinus Torvalds EXPORT_SYMBOL(brioctl_set); 8221da177e4SLinus Torvalds 8234a3e2f71SArjan van de Ven static DEFINE_MUTEX(vlan_ioctl_mutex); 824881d966bSEric W. Biederman static int (*vlan_ioctl_hook) (struct net *, void __user *arg); 8251da177e4SLinus Torvalds 826881d966bSEric W. Biederman void vlan_ioctl_set(int (*hook) (struct net *, void __user *)) 8271da177e4SLinus Torvalds { 8284a3e2f71SArjan van de Ven mutex_lock(&vlan_ioctl_mutex); 8291da177e4SLinus Torvalds vlan_ioctl_hook = hook; 8304a3e2f71SArjan van de Ven mutex_unlock(&vlan_ioctl_mutex); 8311da177e4SLinus Torvalds } 83289bddce5SStephen Hemminger 8331da177e4SLinus Torvalds EXPORT_SYMBOL(vlan_ioctl_set); 8341da177e4SLinus Torvalds 8354a3e2f71SArjan van de Ven static DEFINE_MUTEX(dlci_ioctl_mutex); 8361da177e4SLinus Torvalds static int (*dlci_ioctl_hook) (unsigned int, void __user *); 8371da177e4SLinus Torvalds 8381da177e4SLinus Torvalds void dlci_ioctl_set(int (*hook) (unsigned int, void __user *)) 8391da177e4SLinus Torvalds { 8404a3e2f71SArjan van de Ven mutex_lock(&dlci_ioctl_mutex); 8411da177e4SLinus Torvalds dlci_ioctl_hook = hook; 8424a3e2f71SArjan van de Ven mutex_unlock(&dlci_ioctl_mutex); 8431da177e4SLinus Torvalds } 84489bddce5SStephen Hemminger 8451da177e4SLinus Torvalds EXPORT_SYMBOL(dlci_ioctl_set); 8461da177e4SLinus Torvalds 8471da177e4SLinus Torvalds /* 8481da177e4SLinus Torvalds * With an ioctl, arg may well be a user mode pointer, but we don't know 8491da177e4SLinus Torvalds * what to do with it - that's up to the protocol still. 8501da177e4SLinus Torvalds */ 8511da177e4SLinus Torvalds 8521da177e4SLinus Torvalds static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg) 8531da177e4SLinus Torvalds { 8541da177e4SLinus Torvalds struct socket *sock; 855881d966bSEric W. Biederman struct sock *sk; 8561da177e4SLinus Torvalds void __user *argp = (void __user *)arg; 8571da177e4SLinus Torvalds int pid, err; 858881d966bSEric W. Biederman struct net *net; 8591da177e4SLinus Torvalds 860b69aee04SEric Dumazet sock = file->private_data; 861881d966bSEric W. Biederman sk = sock->sk; 8623b1e0a65SYOSHIFUJI Hideaki net = sock_net(sk); 8631da177e4SLinus Torvalds if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) { 864881d966bSEric W. Biederman err = dev_ioctl(net, cmd, argp); 8651da177e4SLinus Torvalds } else 866d86b5e0eSAdrian Bunk #ifdef CONFIG_WIRELESS_EXT 8671da177e4SLinus Torvalds if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) { 868881d966bSEric W. Biederman err = dev_ioctl(net, cmd, argp); 8691da177e4SLinus Torvalds } else 870d86b5e0eSAdrian Bunk #endif /* CONFIG_WIRELESS_EXT */ 8711da177e4SLinus Torvalds switch (cmd) { 8721da177e4SLinus Torvalds case FIOSETOWN: 8731da177e4SLinus Torvalds case SIOCSPGRP: 8741da177e4SLinus Torvalds err = -EFAULT; 8751da177e4SLinus Torvalds if (get_user(pid, (int __user *)argp)) 8761da177e4SLinus Torvalds break; 8771da177e4SLinus Torvalds err = f_setown(sock->file, pid, 1); 8781da177e4SLinus Torvalds break; 8791da177e4SLinus Torvalds case FIOGETOWN: 8801da177e4SLinus Torvalds case SIOCGPGRP: 881609d7fa9SEric W. Biederman err = put_user(f_getown(sock->file), 88289bddce5SStephen Hemminger (int __user *)argp); 8831da177e4SLinus Torvalds break; 8841da177e4SLinus Torvalds case SIOCGIFBR: 8851da177e4SLinus Torvalds case SIOCSIFBR: 8861da177e4SLinus Torvalds case SIOCBRADDBR: 8871da177e4SLinus Torvalds case SIOCBRDELBR: 8881da177e4SLinus Torvalds err = -ENOPKG; 8891da177e4SLinus Torvalds if (!br_ioctl_hook) 8901da177e4SLinus Torvalds request_module("bridge"); 8911da177e4SLinus Torvalds 8924a3e2f71SArjan van de Ven mutex_lock(&br_ioctl_mutex); 8931da177e4SLinus Torvalds if (br_ioctl_hook) 894881d966bSEric W. Biederman err = br_ioctl_hook(net, cmd, argp); 8954a3e2f71SArjan van de Ven mutex_unlock(&br_ioctl_mutex); 8961da177e4SLinus Torvalds break; 8971da177e4SLinus Torvalds case SIOCGIFVLAN: 8981da177e4SLinus Torvalds case SIOCSIFVLAN: 8991da177e4SLinus Torvalds err = -ENOPKG; 9001da177e4SLinus Torvalds if (!vlan_ioctl_hook) 9011da177e4SLinus Torvalds request_module("8021q"); 9021da177e4SLinus Torvalds 9034a3e2f71SArjan van de Ven mutex_lock(&vlan_ioctl_mutex); 9041da177e4SLinus Torvalds if (vlan_ioctl_hook) 905881d966bSEric W. Biederman err = vlan_ioctl_hook(net, argp); 9064a3e2f71SArjan van de Ven mutex_unlock(&vlan_ioctl_mutex); 9071da177e4SLinus Torvalds break; 9081da177e4SLinus Torvalds case SIOCADDDLCI: 9091da177e4SLinus Torvalds case SIOCDELDLCI: 9101da177e4SLinus Torvalds err = -ENOPKG; 9111da177e4SLinus Torvalds if (!dlci_ioctl_hook) 9121da177e4SLinus Torvalds request_module("dlci"); 9131da177e4SLinus Torvalds 9144a3e2f71SArjan van de Ven mutex_lock(&dlci_ioctl_mutex); 9157512cbf6SPavel Emelyanov if (dlci_ioctl_hook) 9161da177e4SLinus Torvalds err = dlci_ioctl_hook(cmd, argp); 9174a3e2f71SArjan van de Ven mutex_unlock(&dlci_ioctl_mutex); 9181da177e4SLinus Torvalds break; 9191da177e4SLinus Torvalds default: 9201da177e4SLinus Torvalds err = sock->ops->ioctl(sock, cmd, arg); 921b5e5fa5eSChristoph Hellwig 922b5e5fa5eSChristoph Hellwig /* 923b5e5fa5eSChristoph Hellwig * If this ioctl is unknown try to hand it down 924b5e5fa5eSChristoph Hellwig * to the NIC driver. 925b5e5fa5eSChristoph Hellwig */ 926b5e5fa5eSChristoph Hellwig if (err == -ENOIOCTLCMD) 927881d966bSEric W. Biederman err = dev_ioctl(net, cmd, argp); 9281da177e4SLinus Torvalds break; 9291da177e4SLinus Torvalds } 9301da177e4SLinus Torvalds return err; 9311da177e4SLinus Torvalds } 9321da177e4SLinus Torvalds 9331da177e4SLinus Torvalds int sock_create_lite(int family, int type, int protocol, struct socket **res) 9341da177e4SLinus Torvalds { 9351da177e4SLinus Torvalds int err; 9361da177e4SLinus Torvalds struct socket *sock = NULL; 9371da177e4SLinus Torvalds 9381da177e4SLinus Torvalds err = security_socket_create(family, type, protocol, 1); 9391da177e4SLinus Torvalds if (err) 9401da177e4SLinus Torvalds goto out; 9411da177e4SLinus Torvalds 9421da177e4SLinus Torvalds sock = sock_alloc(); 9431da177e4SLinus Torvalds if (!sock) { 9441da177e4SLinus Torvalds err = -ENOMEM; 9451da177e4SLinus Torvalds goto out; 9461da177e4SLinus Torvalds } 9471da177e4SLinus Torvalds 9481da177e4SLinus Torvalds sock->type = type; 9497420ed23SVenkat Yekkirala err = security_socket_post_create(sock, family, type, protocol, 1); 9507420ed23SVenkat Yekkirala if (err) 9517420ed23SVenkat Yekkirala goto out_release; 9527420ed23SVenkat Yekkirala 9531da177e4SLinus Torvalds out: 9541da177e4SLinus Torvalds *res = sock; 9551da177e4SLinus Torvalds return err; 9567420ed23SVenkat Yekkirala out_release: 9577420ed23SVenkat Yekkirala sock_release(sock); 9587420ed23SVenkat Yekkirala sock = NULL; 9597420ed23SVenkat Yekkirala goto out; 9601da177e4SLinus Torvalds } 9611da177e4SLinus Torvalds 9621da177e4SLinus Torvalds /* No kernel lock held - perfect */ 9631da177e4SLinus Torvalds static unsigned int sock_poll(struct file *file, poll_table *wait) 9641da177e4SLinus Torvalds { 9651da177e4SLinus Torvalds struct socket *sock; 9661da177e4SLinus Torvalds 9671da177e4SLinus Torvalds /* 9681da177e4SLinus Torvalds * We can't return errors to poll, so it's either yes or no. 9691da177e4SLinus Torvalds */ 970b69aee04SEric Dumazet sock = file->private_data; 9711da177e4SLinus Torvalds return sock->ops->poll(file, sock, wait); 9721da177e4SLinus Torvalds } 9731da177e4SLinus Torvalds 9741da177e4SLinus Torvalds static int sock_mmap(struct file *file, struct vm_area_struct *vma) 9751da177e4SLinus Torvalds { 976b69aee04SEric Dumazet struct socket *sock = file->private_data; 9771da177e4SLinus Torvalds 9781da177e4SLinus Torvalds return sock->ops->mmap(file, sock, vma); 9791da177e4SLinus Torvalds } 9801da177e4SLinus Torvalds 98120380731SArnaldo Carvalho de Melo static int sock_close(struct inode *inode, struct file *filp) 9821da177e4SLinus Torvalds { 9831da177e4SLinus Torvalds /* 9841da177e4SLinus Torvalds * It was possible the inode is NULL we were 9851da177e4SLinus Torvalds * closing an unfinished socket. 9861da177e4SLinus Torvalds */ 9871da177e4SLinus Torvalds 98889bddce5SStephen Hemminger if (!inode) { 9891da177e4SLinus Torvalds printk(KERN_DEBUG "sock_close: NULL inode\n"); 9901da177e4SLinus Torvalds return 0; 9911da177e4SLinus Torvalds } 9921da177e4SLinus Torvalds sock_release(SOCKET_I(inode)); 9931da177e4SLinus Torvalds return 0; 9941da177e4SLinus Torvalds } 9951da177e4SLinus Torvalds 9961da177e4SLinus Torvalds /* 9971da177e4SLinus Torvalds * Update the socket async list 9981da177e4SLinus Torvalds * 9991da177e4SLinus Torvalds * Fasync_list locking strategy. 10001da177e4SLinus Torvalds * 10011da177e4SLinus Torvalds * 1. fasync_list is modified only under process context socket lock 10021da177e4SLinus Torvalds * i.e. under semaphore. 10031da177e4SLinus Torvalds * 2. fasync_list is used under read_lock(&sk->sk_callback_lock) 10041da177e4SLinus Torvalds * or under socket lock. 10051da177e4SLinus Torvalds * 3. fasync_list can be used from softirq context, so that 10061da177e4SLinus Torvalds * modification under socket lock have to be enhanced with 10071da177e4SLinus Torvalds * write_lock_bh(&sk->sk_callback_lock). 10081da177e4SLinus Torvalds * --ANK (990710) 10091da177e4SLinus Torvalds */ 10101da177e4SLinus Torvalds 10111da177e4SLinus Torvalds static int sock_fasync(int fd, struct file *filp, int on) 10121da177e4SLinus Torvalds { 10131da177e4SLinus Torvalds struct fasync_struct *fa, *fna = NULL, **prev; 10141da177e4SLinus Torvalds struct socket *sock; 10151da177e4SLinus Torvalds struct sock *sk; 10161da177e4SLinus Torvalds 101789bddce5SStephen Hemminger if (on) { 10188b3a7005SKris Katterjohn fna = kmalloc(sizeof(struct fasync_struct), GFP_KERNEL); 10191da177e4SLinus Torvalds if (fna == NULL) 10201da177e4SLinus Torvalds return -ENOMEM; 10211da177e4SLinus Torvalds } 10221da177e4SLinus Torvalds 1023b69aee04SEric Dumazet sock = filp->private_data; 10241da177e4SLinus Torvalds 102589bddce5SStephen Hemminger sk = sock->sk; 102689bddce5SStephen Hemminger if (sk == NULL) { 10271da177e4SLinus Torvalds kfree(fna); 10281da177e4SLinus Torvalds return -EINVAL; 10291da177e4SLinus Torvalds } 10301da177e4SLinus Torvalds 10311da177e4SLinus Torvalds lock_sock(sk); 10321da177e4SLinus Torvalds 10331da177e4SLinus Torvalds prev = &(sock->fasync_list); 10341da177e4SLinus Torvalds 10351da177e4SLinus Torvalds for (fa = *prev; fa != NULL; prev = &fa->fa_next, fa = *prev) 10361da177e4SLinus Torvalds if (fa->fa_file == filp) 10371da177e4SLinus Torvalds break; 10381da177e4SLinus Torvalds 103989bddce5SStephen Hemminger if (on) { 104089bddce5SStephen Hemminger if (fa != NULL) { 10411da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 10421da177e4SLinus Torvalds fa->fa_fd = fd; 10431da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 10441da177e4SLinus Torvalds 10451da177e4SLinus Torvalds kfree(fna); 10461da177e4SLinus Torvalds goto out; 10471da177e4SLinus Torvalds } 10481da177e4SLinus Torvalds fna->fa_file = filp; 10491da177e4SLinus Torvalds fna->fa_fd = fd; 10501da177e4SLinus Torvalds fna->magic = FASYNC_MAGIC; 10511da177e4SLinus Torvalds fna->fa_next = sock->fasync_list; 10521da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 10531da177e4SLinus Torvalds sock->fasync_list = fna; 10541da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 105589bddce5SStephen Hemminger } else { 105689bddce5SStephen Hemminger if (fa != NULL) { 10571da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 10581da177e4SLinus Torvalds *prev = fa->fa_next; 10591da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 10601da177e4SLinus Torvalds kfree(fa); 10611da177e4SLinus Torvalds } 10621da177e4SLinus Torvalds } 10631da177e4SLinus Torvalds 10641da177e4SLinus Torvalds out: 10651da177e4SLinus Torvalds release_sock(sock->sk); 10661da177e4SLinus Torvalds return 0; 10671da177e4SLinus Torvalds } 10681da177e4SLinus Torvalds 10691da177e4SLinus Torvalds /* This function may be called only under socket lock or callback_lock */ 10701da177e4SLinus Torvalds 10711da177e4SLinus Torvalds int sock_wake_async(struct socket *sock, int how, int band) 10721da177e4SLinus Torvalds { 10731da177e4SLinus Torvalds if (!sock || !sock->fasync_list) 10741da177e4SLinus Torvalds return -1; 107589bddce5SStephen Hemminger switch (how) { 10768d8ad9d7SPavel Emelyanov case SOCK_WAKE_WAITD: 10771da177e4SLinus Torvalds if (test_bit(SOCK_ASYNC_WAITDATA, &sock->flags)) 10781da177e4SLinus Torvalds break; 10791da177e4SLinus Torvalds goto call_kill; 10808d8ad9d7SPavel Emelyanov case SOCK_WAKE_SPACE: 10811da177e4SLinus Torvalds if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags)) 10821da177e4SLinus Torvalds break; 10831da177e4SLinus Torvalds /* fall through */ 10848d8ad9d7SPavel Emelyanov case SOCK_WAKE_IO: 10851da177e4SLinus Torvalds call_kill: 10861da177e4SLinus Torvalds __kill_fasync(sock->fasync_list, SIGIO, band); 10871da177e4SLinus Torvalds break; 10888d8ad9d7SPavel Emelyanov case SOCK_WAKE_URG: 10891da177e4SLinus Torvalds __kill_fasync(sock->fasync_list, SIGURG, band); 10901da177e4SLinus Torvalds } 10911da177e4SLinus Torvalds return 0; 10921da177e4SLinus Torvalds } 10931da177e4SLinus Torvalds 10941b8d7ae4SEric W. Biederman static int __sock_create(struct net *net, int family, int type, int protocol, 109589bddce5SStephen Hemminger struct socket **res, int kern) 10961da177e4SLinus Torvalds { 10971da177e4SLinus Torvalds int err; 10981da177e4SLinus Torvalds struct socket *sock; 109955737fdaSStephen Hemminger const struct net_proto_family *pf; 11001da177e4SLinus Torvalds 11011da177e4SLinus Torvalds /* 11021da177e4SLinus Torvalds * Check protocol is in range 11031da177e4SLinus Torvalds */ 11041da177e4SLinus Torvalds if (family < 0 || family >= NPROTO) 11051da177e4SLinus Torvalds return -EAFNOSUPPORT; 11061da177e4SLinus Torvalds if (type < 0 || type >= SOCK_MAX) 11071da177e4SLinus Torvalds return -EINVAL; 11081da177e4SLinus Torvalds 11091da177e4SLinus Torvalds /* Compatibility. 11101da177e4SLinus Torvalds 11111da177e4SLinus Torvalds This uglymoron is moved from INET layer to here to avoid 11121da177e4SLinus Torvalds deadlock in module load. 11131da177e4SLinus Torvalds */ 11141da177e4SLinus Torvalds if (family == PF_INET && type == SOCK_PACKET) { 11151da177e4SLinus Torvalds static int warned; 11161da177e4SLinus Torvalds if (!warned) { 11171da177e4SLinus Torvalds warned = 1; 111889bddce5SStephen Hemminger printk(KERN_INFO "%s uses obsolete (PF_INET,SOCK_PACKET)\n", 111989bddce5SStephen Hemminger current->comm); 11201da177e4SLinus Torvalds } 11211da177e4SLinus Torvalds family = PF_PACKET; 11221da177e4SLinus Torvalds } 11231da177e4SLinus Torvalds 11241da177e4SLinus Torvalds err = security_socket_create(family, type, protocol, kern); 11251da177e4SLinus Torvalds if (err) 11261da177e4SLinus Torvalds return err; 11271da177e4SLinus Torvalds 112855737fdaSStephen Hemminger /* 112955737fdaSStephen Hemminger * Allocate the socket and allow the family to set things up. if 113055737fdaSStephen Hemminger * the protocol is 0, the family is instructed to select an appropriate 113155737fdaSStephen Hemminger * default. 113255737fdaSStephen Hemminger */ 113355737fdaSStephen Hemminger sock = sock_alloc(); 113455737fdaSStephen Hemminger if (!sock) { 113555737fdaSStephen Hemminger if (net_ratelimit()) 113655737fdaSStephen Hemminger printk(KERN_WARNING "socket: no more sockets\n"); 113755737fdaSStephen Hemminger return -ENFILE; /* Not exactly a match, but its the 113855737fdaSStephen Hemminger closest posix thing */ 113955737fdaSStephen Hemminger } 114055737fdaSStephen Hemminger 114155737fdaSStephen Hemminger sock->type = type; 114255737fdaSStephen Hemminger 114395a5afcaSJohannes Berg #ifdef CONFIG_MODULES 11441da177e4SLinus Torvalds /* Attempt to load a protocol module if the find failed. 11451da177e4SLinus Torvalds * 11461da177e4SLinus Torvalds * 12/09/1996 Marcin: But! this makes REALLY only sense, if the user 11471da177e4SLinus Torvalds * requested real, full-featured networking support upon configuration. 11481da177e4SLinus Torvalds * Otherwise module support will break! 11491da177e4SLinus Torvalds */ 115055737fdaSStephen Hemminger if (net_families[family] == NULL) 11511da177e4SLinus Torvalds request_module("net-pf-%d", family); 11521da177e4SLinus Torvalds #endif 11531da177e4SLinus Torvalds 115455737fdaSStephen Hemminger rcu_read_lock(); 115555737fdaSStephen Hemminger pf = rcu_dereference(net_families[family]); 11561da177e4SLinus Torvalds err = -EAFNOSUPPORT; 115755737fdaSStephen Hemminger if (!pf) 115855737fdaSStephen Hemminger goto out_release; 11591da177e4SLinus Torvalds 11601da177e4SLinus Torvalds /* 11611da177e4SLinus Torvalds * We will call the ->create function, that possibly is in a loadable 11621da177e4SLinus Torvalds * module, so we have to bump that loadable module refcnt first. 11631da177e4SLinus Torvalds */ 116455737fdaSStephen Hemminger if (!try_module_get(pf->owner)) 11651da177e4SLinus Torvalds goto out_release; 11661da177e4SLinus Torvalds 116755737fdaSStephen Hemminger /* Now protected by module ref count */ 116855737fdaSStephen Hemminger rcu_read_unlock(); 116955737fdaSStephen Hemminger 11701b8d7ae4SEric W. Biederman err = pf->create(net, sock, protocol); 117155737fdaSStephen Hemminger if (err < 0) 11721da177e4SLinus Torvalds goto out_module_put; 1173a79af59eSFrank Filz 11741da177e4SLinus Torvalds /* 11751da177e4SLinus Torvalds * Now to bump the refcnt of the [loadable] module that owns this 11761da177e4SLinus Torvalds * socket at sock_release time we decrement its refcnt. 11771da177e4SLinus Torvalds */ 117855737fdaSStephen Hemminger if (!try_module_get(sock->ops->owner)) 117955737fdaSStephen Hemminger goto out_module_busy; 118055737fdaSStephen Hemminger 11811da177e4SLinus Torvalds /* 11821da177e4SLinus Torvalds * Now that we're done with the ->create function, the [loadable] 11831da177e4SLinus Torvalds * module can have its refcnt decremented 11841da177e4SLinus Torvalds */ 118555737fdaSStephen Hemminger module_put(pf->owner); 11867420ed23SVenkat Yekkirala err = security_socket_post_create(sock, family, type, protocol, kern); 11877420ed23SVenkat Yekkirala if (err) 11883b185525SHerbert Xu goto out_sock_release; 118955737fdaSStephen Hemminger *res = sock; 11901da177e4SLinus Torvalds 119155737fdaSStephen Hemminger return 0; 119255737fdaSStephen Hemminger 119355737fdaSStephen Hemminger out_module_busy: 119455737fdaSStephen Hemminger err = -EAFNOSUPPORT; 11951da177e4SLinus Torvalds out_module_put: 119655737fdaSStephen Hemminger sock->ops = NULL; 119755737fdaSStephen Hemminger module_put(pf->owner); 119855737fdaSStephen Hemminger out_sock_release: 11991da177e4SLinus Torvalds sock_release(sock); 120055737fdaSStephen Hemminger return err; 120155737fdaSStephen Hemminger 120255737fdaSStephen Hemminger out_release: 120355737fdaSStephen Hemminger rcu_read_unlock(); 120455737fdaSStephen Hemminger goto out_sock_release; 12051da177e4SLinus Torvalds } 12061da177e4SLinus Torvalds 12071da177e4SLinus Torvalds int sock_create(int family, int type, int protocol, struct socket **res) 12081da177e4SLinus Torvalds { 12091b8d7ae4SEric W. Biederman return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0); 12101da177e4SLinus Torvalds } 12111da177e4SLinus Torvalds 12121da177e4SLinus Torvalds int sock_create_kern(int family, int type, int protocol, struct socket **res) 12131da177e4SLinus Torvalds { 12141b8d7ae4SEric W. Biederman return __sock_create(&init_net, family, type, protocol, res, 1); 12151da177e4SLinus Torvalds } 12161da177e4SLinus Torvalds 12171da177e4SLinus Torvalds asmlinkage long sys_socket(int family, int type, int protocol) 12181da177e4SLinus Torvalds { 12191da177e4SLinus Torvalds int retval; 12201da177e4SLinus Torvalds struct socket *sock; 1221a677a039SUlrich Drepper int flags; 1222a677a039SUlrich Drepper 1223e38b36f3SUlrich Drepper /* Check the SOCK_* constants for consistency. */ 1224e38b36f3SUlrich Drepper BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC); 1225e38b36f3SUlrich Drepper BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK); 1226e38b36f3SUlrich Drepper BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK); 1227e38b36f3SUlrich Drepper BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK); 1228e38b36f3SUlrich Drepper 1229a677a039SUlrich Drepper flags = type & ~SOCK_TYPE_MASK; 123077d27200SUlrich Drepper if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)) 1231a677a039SUlrich Drepper return -EINVAL; 1232a677a039SUlrich Drepper type &= SOCK_TYPE_MASK; 12331da177e4SLinus Torvalds 1234aaca0bdcSUlrich Drepper if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK)) 1235aaca0bdcSUlrich Drepper flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK; 1236aaca0bdcSUlrich Drepper 12371da177e4SLinus Torvalds retval = sock_create(family, type, protocol, &sock); 12381da177e4SLinus Torvalds if (retval < 0) 12391da177e4SLinus Torvalds goto out; 12401da177e4SLinus Torvalds 124177d27200SUlrich Drepper retval = sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK)); 12421da177e4SLinus Torvalds if (retval < 0) 12431da177e4SLinus Torvalds goto out_release; 12441da177e4SLinus Torvalds 12451da177e4SLinus Torvalds out: 12461da177e4SLinus Torvalds /* It may be already another descriptor 8) Not kernel problem. */ 12471da177e4SLinus Torvalds return retval; 12481da177e4SLinus Torvalds 12491da177e4SLinus Torvalds out_release: 12501da177e4SLinus Torvalds sock_release(sock); 12511da177e4SLinus Torvalds return retval; 12521da177e4SLinus Torvalds } 12531da177e4SLinus Torvalds 12541da177e4SLinus Torvalds /* 12551da177e4SLinus Torvalds * Create a pair of connected sockets. 12561da177e4SLinus Torvalds */ 12571da177e4SLinus Torvalds 125889bddce5SStephen Hemminger asmlinkage long sys_socketpair(int family, int type, int protocol, 125989bddce5SStephen Hemminger int __user *usockvec) 12601da177e4SLinus Torvalds { 12611da177e4SLinus Torvalds struct socket *sock1, *sock2; 12621da177e4SLinus Torvalds int fd1, fd2, err; 1263db349509SAl Viro struct file *newfile1, *newfile2; 1264a677a039SUlrich Drepper int flags; 1265a677a039SUlrich Drepper 1266a677a039SUlrich Drepper flags = type & ~SOCK_TYPE_MASK; 126777d27200SUlrich Drepper if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)) 1268a677a039SUlrich Drepper return -EINVAL; 1269a677a039SUlrich Drepper type &= SOCK_TYPE_MASK; 12701da177e4SLinus Torvalds 1271aaca0bdcSUlrich Drepper if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK)) 1272aaca0bdcSUlrich Drepper flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK; 1273aaca0bdcSUlrich Drepper 12741da177e4SLinus Torvalds /* 12751da177e4SLinus Torvalds * Obtain the first socket and check if the underlying protocol 12761da177e4SLinus Torvalds * supports the socketpair call. 12771da177e4SLinus Torvalds */ 12781da177e4SLinus Torvalds 12791da177e4SLinus Torvalds err = sock_create(family, type, protocol, &sock1); 12801da177e4SLinus Torvalds if (err < 0) 12811da177e4SLinus Torvalds goto out; 12821da177e4SLinus Torvalds 12831da177e4SLinus Torvalds err = sock_create(family, type, protocol, &sock2); 12841da177e4SLinus Torvalds if (err < 0) 12851da177e4SLinus Torvalds goto out_release_1; 12861da177e4SLinus Torvalds 12871da177e4SLinus Torvalds err = sock1->ops->socketpair(sock1, sock2); 12881da177e4SLinus Torvalds if (err < 0) 12891da177e4SLinus Torvalds goto out_release_both; 12901da177e4SLinus Torvalds 1291a677a039SUlrich Drepper fd1 = sock_alloc_fd(&newfile1, flags & O_CLOEXEC); 1292bf3c23d1SDavid S. Miller if (unlikely(fd1 < 0)) { 1293bf3c23d1SDavid S. Miller err = fd1; 12941da177e4SLinus Torvalds goto out_release_both; 1295bf3c23d1SDavid S. Miller } 12961da177e4SLinus Torvalds 1297a677a039SUlrich Drepper fd2 = sock_alloc_fd(&newfile2, flags & O_CLOEXEC); 1298db349509SAl Viro if (unlikely(fd2 < 0)) { 1299bf3c23d1SDavid S. Miller err = fd2; 1300db349509SAl Viro put_filp(newfile1); 1301db349509SAl Viro put_unused_fd(fd1); 1302db349509SAl Viro goto out_release_both; 1303db349509SAl Viro } 13041da177e4SLinus Torvalds 130577d27200SUlrich Drepper err = sock_attach_fd(sock1, newfile1, flags & O_NONBLOCK); 1306db349509SAl Viro if (unlikely(err < 0)) { 1307db349509SAl Viro goto out_fd2; 1308db349509SAl Viro } 1309db349509SAl Viro 131077d27200SUlrich Drepper err = sock_attach_fd(sock2, newfile2, flags & O_NONBLOCK); 1311db349509SAl Viro if (unlikely(err < 0)) { 1312db349509SAl Viro fput(newfile1); 1313db349509SAl Viro goto out_fd1; 1314db349509SAl Viro } 1315db349509SAl Viro 1316db349509SAl Viro err = audit_fd_pair(fd1, fd2); 1317db349509SAl Viro if (err < 0) { 1318db349509SAl Viro fput(newfile1); 1319db349509SAl Viro fput(newfile2); 1320db349509SAl Viro goto out_fd; 1321db349509SAl Viro } 1322db349509SAl Viro 1323db349509SAl Viro fd_install(fd1, newfile1); 1324db349509SAl Viro fd_install(fd2, newfile2); 13251da177e4SLinus Torvalds /* fd1 and fd2 may be already another descriptors. 13261da177e4SLinus Torvalds * Not kernel problem. 13271da177e4SLinus Torvalds */ 13281da177e4SLinus Torvalds 13291da177e4SLinus Torvalds err = put_user(fd1, &usockvec[0]); 13301da177e4SLinus Torvalds if (!err) 13311da177e4SLinus Torvalds err = put_user(fd2, &usockvec[1]); 13321da177e4SLinus Torvalds if (!err) 13331da177e4SLinus Torvalds return 0; 13341da177e4SLinus Torvalds 13351da177e4SLinus Torvalds sys_close(fd2); 13361da177e4SLinus Torvalds sys_close(fd1); 13371da177e4SLinus Torvalds return err; 13381da177e4SLinus Torvalds 13391da177e4SLinus Torvalds out_release_both: 13401da177e4SLinus Torvalds sock_release(sock2); 13411da177e4SLinus Torvalds out_release_1: 13421da177e4SLinus Torvalds sock_release(sock1); 13431da177e4SLinus Torvalds out: 13441da177e4SLinus Torvalds return err; 1345db349509SAl Viro 1346db349509SAl Viro out_fd2: 1347db349509SAl Viro put_filp(newfile1); 1348db349509SAl Viro sock_release(sock1); 1349db349509SAl Viro out_fd1: 1350db349509SAl Viro put_filp(newfile2); 1351db349509SAl Viro sock_release(sock2); 1352db349509SAl Viro out_fd: 1353db349509SAl Viro put_unused_fd(fd1); 1354db349509SAl Viro put_unused_fd(fd2); 1355db349509SAl Viro goto out; 13561da177e4SLinus Torvalds } 13571da177e4SLinus Torvalds 13581da177e4SLinus Torvalds /* 13591da177e4SLinus Torvalds * Bind a name to a socket. Nothing much to do here since it's 13601da177e4SLinus Torvalds * the protocol's responsibility to handle the local address. 13611da177e4SLinus Torvalds * 13621da177e4SLinus Torvalds * We move the socket address to kernel space before we call 13631da177e4SLinus Torvalds * the protocol layer (having also checked the address is ok). 13641da177e4SLinus Torvalds */ 13651da177e4SLinus Torvalds 13661da177e4SLinus Torvalds asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen) 13671da177e4SLinus Torvalds { 13681da177e4SLinus Torvalds struct socket *sock; 1369230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 13706cb153caSBenjamin LaHaise int err, fput_needed; 13711da177e4SLinus Torvalds 137289bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 137389bddce5SStephen Hemminger if (sock) { 1374230b1839SYOSHIFUJI Hideaki err = move_addr_to_kernel(umyaddr, addrlen, (struct sockaddr *)&address); 137589bddce5SStephen Hemminger if (err >= 0) { 137689bddce5SStephen Hemminger err = security_socket_bind(sock, 1377230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&address, 137889bddce5SStephen Hemminger addrlen); 13796cb153caSBenjamin LaHaise if (!err) 13806cb153caSBenjamin LaHaise err = sock->ops->bind(sock, 138189bddce5SStephen Hemminger (struct sockaddr *) 1382230b1839SYOSHIFUJI Hideaki &address, addrlen); 13831da177e4SLinus Torvalds } 13846cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 13851da177e4SLinus Torvalds } 13861da177e4SLinus Torvalds return err; 13871da177e4SLinus Torvalds } 13881da177e4SLinus Torvalds 13891da177e4SLinus Torvalds /* 13901da177e4SLinus Torvalds * Perform a listen. Basically, we allow the protocol to do anything 13911da177e4SLinus Torvalds * necessary for a listen, and if that works, we mark the socket as 13921da177e4SLinus Torvalds * ready for listening. 13931da177e4SLinus Torvalds */ 13941da177e4SLinus Torvalds 13951da177e4SLinus Torvalds asmlinkage long sys_listen(int fd, int backlog) 13961da177e4SLinus Torvalds { 13971da177e4SLinus Torvalds struct socket *sock; 13986cb153caSBenjamin LaHaise int err, fput_needed; 1399b8e1f9b5SPavel Emelyanov int somaxconn; 14001da177e4SLinus Torvalds 140189bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 140289bddce5SStephen Hemminger if (sock) { 14038efa6e93SPavel Emelyanov somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn; 1404b8e1f9b5SPavel Emelyanov if ((unsigned)backlog > somaxconn) 1405b8e1f9b5SPavel Emelyanov backlog = somaxconn; 14061da177e4SLinus Torvalds 14071da177e4SLinus Torvalds err = security_socket_listen(sock, backlog); 14086cb153caSBenjamin LaHaise if (!err) 14091da177e4SLinus Torvalds err = sock->ops->listen(sock, backlog); 14106cb153caSBenjamin LaHaise 14116cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 14121da177e4SLinus Torvalds } 14131da177e4SLinus Torvalds return err; 14141da177e4SLinus Torvalds } 14151da177e4SLinus Torvalds 14161da177e4SLinus Torvalds /* 14171da177e4SLinus Torvalds * For accept, we attempt to create a new socket, set up the link 14181da177e4SLinus Torvalds * with the client, wake up the client, then return the new 14191da177e4SLinus Torvalds * connected fd. We collect the address of the connector in kernel 14201da177e4SLinus Torvalds * space and move it to user at the very end. This is unclean because 14211da177e4SLinus Torvalds * we open the socket then return an error. 14221da177e4SLinus Torvalds * 14231da177e4SLinus Torvalds * 1003.1g adds the ability to recvmsg() to query connection pending 14241da177e4SLinus Torvalds * status to recvmsg. We need to add that support in a way thats 14251da177e4SLinus Torvalds * clean when we restucture accept also. 14261da177e4SLinus Torvalds */ 14271da177e4SLinus Torvalds 1428de11defeSUlrich Drepper asmlinkage long sys_accept4(int fd, struct sockaddr __user *upeer_sockaddr, 1429aaca0bdcSUlrich Drepper int __user *upeer_addrlen, int flags) 14301da177e4SLinus Torvalds { 14311da177e4SLinus Torvalds struct socket *sock, *newsock; 143239d8c1b6SDavid S. Miller struct file *newfile; 14336cb153caSBenjamin LaHaise int err, len, newfd, fput_needed; 1434230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 14351da177e4SLinus Torvalds 143677d27200SUlrich Drepper if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)) 1437aaca0bdcSUlrich Drepper return -EINVAL; 1438aaca0bdcSUlrich Drepper 1439aaca0bdcSUlrich Drepper if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK)) 1440aaca0bdcSUlrich Drepper flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK; 1441aaca0bdcSUlrich Drepper 14426cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 14431da177e4SLinus Torvalds if (!sock) 14441da177e4SLinus Torvalds goto out; 14451da177e4SLinus Torvalds 14461da177e4SLinus Torvalds err = -ENFILE; 14471da177e4SLinus Torvalds if (!(newsock = sock_alloc())) 14481da177e4SLinus Torvalds goto out_put; 14491da177e4SLinus Torvalds 14501da177e4SLinus Torvalds newsock->type = sock->type; 14511da177e4SLinus Torvalds newsock->ops = sock->ops; 14521da177e4SLinus Torvalds 14531da177e4SLinus Torvalds /* 14541da177e4SLinus Torvalds * We don't need try_module_get here, as the listening socket (sock) 14551da177e4SLinus Torvalds * has the protocol module (sock->ops->owner) held. 14561da177e4SLinus Torvalds */ 14571da177e4SLinus Torvalds __module_get(newsock->ops->owner); 14581da177e4SLinus Torvalds 1459aaca0bdcSUlrich Drepper newfd = sock_alloc_fd(&newfile, flags & O_CLOEXEC); 146039d8c1b6SDavid S. Miller if (unlikely(newfd < 0)) { 146139d8c1b6SDavid S. Miller err = newfd; 14629a1875e6SDavid S. Miller sock_release(newsock); 14639a1875e6SDavid S. Miller goto out_put; 146439d8c1b6SDavid S. Miller } 146539d8c1b6SDavid S. Miller 146677d27200SUlrich Drepper err = sock_attach_fd(newsock, newfile, flags & O_NONBLOCK); 146739d8c1b6SDavid S. Miller if (err < 0) 146879f4f642SAlexey Dobriyan goto out_fd_simple; 146939d8c1b6SDavid S. Miller 1470a79af59eSFrank Filz err = security_socket_accept(sock, newsock); 1471a79af59eSFrank Filz if (err) 147239d8c1b6SDavid S. Miller goto out_fd; 1473a79af59eSFrank Filz 14741da177e4SLinus Torvalds err = sock->ops->accept(sock, newsock, sock->file->f_flags); 14751da177e4SLinus Torvalds if (err < 0) 147639d8c1b6SDavid S. Miller goto out_fd; 14771da177e4SLinus Torvalds 14781da177e4SLinus Torvalds if (upeer_sockaddr) { 1479230b1839SYOSHIFUJI Hideaki if (newsock->ops->getname(newsock, (struct sockaddr *)&address, 148089bddce5SStephen Hemminger &len, 2) < 0) { 14811da177e4SLinus Torvalds err = -ECONNABORTED; 148239d8c1b6SDavid S. Miller goto out_fd; 14831da177e4SLinus Torvalds } 1484230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&address, 1485230b1839SYOSHIFUJI Hideaki len, upeer_sockaddr, upeer_addrlen); 14861da177e4SLinus Torvalds if (err < 0) 148739d8c1b6SDavid S. Miller goto out_fd; 14881da177e4SLinus Torvalds } 14891da177e4SLinus Torvalds 14901da177e4SLinus Torvalds /* File flags are not inherited via accept() unlike another OSes. */ 14911da177e4SLinus Torvalds 149239d8c1b6SDavid S. Miller fd_install(newfd, newfile); 149339d8c1b6SDavid S. Miller err = newfd; 14941da177e4SLinus Torvalds 14951da177e4SLinus Torvalds security_socket_post_accept(sock, newsock); 14961da177e4SLinus Torvalds 14971da177e4SLinus Torvalds out_put: 14986cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 14991da177e4SLinus Torvalds out: 15001da177e4SLinus Torvalds return err; 150179f4f642SAlexey Dobriyan out_fd_simple: 150279f4f642SAlexey Dobriyan sock_release(newsock); 150379f4f642SAlexey Dobriyan put_filp(newfile); 150479f4f642SAlexey Dobriyan put_unused_fd(newfd); 150579f4f642SAlexey Dobriyan goto out_put; 150639d8c1b6SDavid S. Miller out_fd: 15079606a216SDavid S. Miller fput(newfile); 150839d8c1b6SDavid S. Miller put_unused_fd(newfd); 15091da177e4SLinus Torvalds goto out_put; 15101da177e4SLinus Torvalds } 15111da177e4SLinus Torvalds 1512aaca0bdcSUlrich Drepper asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr, 1513aaca0bdcSUlrich Drepper int __user *upeer_addrlen) 1514aaca0bdcSUlrich Drepper { 1515de11defeSUlrich Drepper return sys_accept4(fd, upeer_sockaddr, upeer_addrlen, 0); 1516aaca0bdcSUlrich Drepper } 1517aaca0bdcSUlrich Drepper 15181da177e4SLinus Torvalds /* 15191da177e4SLinus Torvalds * Attempt to connect to a socket with the server address. The address 15201da177e4SLinus Torvalds * is in user space so we verify it is OK and move it to kernel space. 15211da177e4SLinus Torvalds * 15221da177e4SLinus Torvalds * For 1003.1g we need to add clean support for a bind to AF_UNSPEC to 15231da177e4SLinus Torvalds * break bindings 15241da177e4SLinus Torvalds * 15251da177e4SLinus Torvalds * NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and 15261da177e4SLinus Torvalds * other SEQPACKET protocols that take time to connect() as it doesn't 15271da177e4SLinus Torvalds * include the -EINPROGRESS status for such sockets. 15281da177e4SLinus Torvalds */ 15291da177e4SLinus Torvalds 153089bddce5SStephen Hemminger asmlinkage long sys_connect(int fd, struct sockaddr __user *uservaddr, 153189bddce5SStephen Hemminger int addrlen) 15321da177e4SLinus Torvalds { 15331da177e4SLinus Torvalds struct socket *sock; 1534230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 15356cb153caSBenjamin LaHaise int err, fput_needed; 15361da177e4SLinus Torvalds 15376cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 15381da177e4SLinus Torvalds if (!sock) 15391da177e4SLinus Torvalds goto out; 1540230b1839SYOSHIFUJI Hideaki err = move_addr_to_kernel(uservaddr, addrlen, (struct sockaddr *)&address); 15411da177e4SLinus Torvalds if (err < 0) 15421da177e4SLinus Torvalds goto out_put; 15431da177e4SLinus Torvalds 154489bddce5SStephen Hemminger err = 1545230b1839SYOSHIFUJI Hideaki security_socket_connect(sock, (struct sockaddr *)&address, addrlen); 15461da177e4SLinus Torvalds if (err) 15471da177e4SLinus Torvalds goto out_put; 15481da177e4SLinus Torvalds 1549230b1839SYOSHIFUJI Hideaki err = sock->ops->connect(sock, (struct sockaddr *)&address, addrlen, 15501da177e4SLinus Torvalds sock->file->f_flags); 15511da177e4SLinus Torvalds out_put: 15526cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 15531da177e4SLinus Torvalds out: 15541da177e4SLinus Torvalds return err; 15551da177e4SLinus Torvalds } 15561da177e4SLinus Torvalds 15571da177e4SLinus Torvalds /* 15581da177e4SLinus Torvalds * Get the local address ('name') of a socket object. Move the obtained 15591da177e4SLinus Torvalds * name to user space. 15601da177e4SLinus Torvalds */ 15611da177e4SLinus Torvalds 156289bddce5SStephen Hemminger asmlinkage long sys_getsockname(int fd, struct sockaddr __user *usockaddr, 156389bddce5SStephen Hemminger int __user *usockaddr_len) 15641da177e4SLinus Torvalds { 15651da177e4SLinus Torvalds struct socket *sock; 1566230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 15676cb153caSBenjamin LaHaise int len, err, fput_needed; 15681da177e4SLinus Torvalds 15696cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 15701da177e4SLinus Torvalds if (!sock) 15711da177e4SLinus Torvalds goto out; 15721da177e4SLinus Torvalds 15731da177e4SLinus Torvalds err = security_socket_getsockname(sock); 15741da177e4SLinus Torvalds if (err) 15751da177e4SLinus Torvalds goto out_put; 15761da177e4SLinus Torvalds 1577230b1839SYOSHIFUJI Hideaki err = sock->ops->getname(sock, (struct sockaddr *)&address, &len, 0); 15781da177e4SLinus Torvalds if (err) 15791da177e4SLinus Torvalds goto out_put; 1580230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr, usockaddr_len); 15811da177e4SLinus Torvalds 15821da177e4SLinus Torvalds out_put: 15836cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 15841da177e4SLinus Torvalds out: 15851da177e4SLinus Torvalds return err; 15861da177e4SLinus Torvalds } 15871da177e4SLinus Torvalds 15881da177e4SLinus Torvalds /* 15891da177e4SLinus Torvalds * Get the remote address ('name') of a socket object. Move the obtained 15901da177e4SLinus Torvalds * name to user space. 15911da177e4SLinus Torvalds */ 15921da177e4SLinus Torvalds 159389bddce5SStephen Hemminger asmlinkage long sys_getpeername(int fd, struct sockaddr __user *usockaddr, 159489bddce5SStephen Hemminger int __user *usockaddr_len) 15951da177e4SLinus Torvalds { 15961da177e4SLinus Torvalds struct socket *sock; 1597230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 15986cb153caSBenjamin LaHaise int len, err, fput_needed; 15991da177e4SLinus Torvalds 160089bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 160189bddce5SStephen Hemminger if (sock != NULL) { 16021da177e4SLinus Torvalds err = security_socket_getpeername(sock); 16031da177e4SLinus Torvalds if (err) { 16046cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 16051da177e4SLinus Torvalds return err; 16061da177e4SLinus Torvalds } 16071da177e4SLinus Torvalds 160889bddce5SStephen Hemminger err = 1609230b1839SYOSHIFUJI Hideaki sock->ops->getname(sock, (struct sockaddr *)&address, &len, 161089bddce5SStephen Hemminger 1); 16111da177e4SLinus Torvalds if (!err) 1612230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr, 161389bddce5SStephen Hemminger usockaddr_len); 16146cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 16151da177e4SLinus Torvalds } 16161da177e4SLinus Torvalds return err; 16171da177e4SLinus Torvalds } 16181da177e4SLinus Torvalds 16191da177e4SLinus Torvalds /* 16201da177e4SLinus Torvalds * Send a datagram to a given address. We move the address into kernel 16211da177e4SLinus Torvalds * space and check the user space data area is readable before invoking 16221da177e4SLinus Torvalds * the protocol. 16231da177e4SLinus Torvalds */ 16241da177e4SLinus Torvalds 162589bddce5SStephen Hemminger asmlinkage long sys_sendto(int fd, void __user *buff, size_t len, 162689bddce5SStephen Hemminger unsigned flags, struct sockaddr __user *addr, 162789bddce5SStephen Hemminger int addr_len) 16281da177e4SLinus Torvalds { 16291da177e4SLinus Torvalds struct socket *sock; 1630230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 16311da177e4SLinus Torvalds int err; 16321da177e4SLinus Torvalds struct msghdr msg; 16331da177e4SLinus Torvalds struct iovec iov; 16346cb153caSBenjamin LaHaise int fput_needed; 16351da177e4SLinus Torvalds 1636de0fa95cSPavel Emelyanov sock = sockfd_lookup_light(fd, &err, &fput_needed); 1637de0fa95cSPavel Emelyanov if (!sock) 16384387ff75SDavid S. Miller goto out; 16396cb153caSBenjamin LaHaise 16401da177e4SLinus Torvalds iov.iov_base = buff; 16411da177e4SLinus Torvalds iov.iov_len = len; 16421da177e4SLinus Torvalds msg.msg_name = NULL; 16431da177e4SLinus Torvalds msg.msg_iov = &iov; 16441da177e4SLinus Torvalds msg.msg_iovlen = 1; 16451da177e4SLinus Torvalds msg.msg_control = NULL; 16461da177e4SLinus Torvalds msg.msg_controllen = 0; 16471da177e4SLinus Torvalds msg.msg_namelen = 0; 16486cb153caSBenjamin LaHaise if (addr) { 1649230b1839SYOSHIFUJI Hideaki err = move_addr_to_kernel(addr, addr_len, (struct sockaddr *)&address); 16501da177e4SLinus Torvalds if (err < 0) 16511da177e4SLinus Torvalds goto out_put; 1652230b1839SYOSHIFUJI Hideaki msg.msg_name = (struct sockaddr *)&address; 16531da177e4SLinus Torvalds msg.msg_namelen = addr_len; 16541da177e4SLinus Torvalds } 16551da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 16561da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 16571da177e4SLinus Torvalds msg.msg_flags = flags; 16581da177e4SLinus Torvalds err = sock_sendmsg(sock, &msg, len); 16591da177e4SLinus Torvalds 16601da177e4SLinus Torvalds out_put: 1661de0fa95cSPavel Emelyanov fput_light(sock->file, fput_needed); 16624387ff75SDavid S. Miller out: 16631da177e4SLinus Torvalds return err; 16641da177e4SLinus Torvalds } 16651da177e4SLinus Torvalds 16661da177e4SLinus Torvalds /* 16671da177e4SLinus Torvalds * Send a datagram down a socket. 16681da177e4SLinus Torvalds */ 16691da177e4SLinus Torvalds 16701da177e4SLinus Torvalds asmlinkage long sys_send(int fd, void __user *buff, size_t len, unsigned flags) 16711da177e4SLinus Torvalds { 16721da177e4SLinus Torvalds return sys_sendto(fd, buff, len, flags, NULL, 0); 16731da177e4SLinus Torvalds } 16741da177e4SLinus Torvalds 16751da177e4SLinus Torvalds /* 16761da177e4SLinus Torvalds * Receive a frame from the socket and optionally record the address of the 16771da177e4SLinus Torvalds * sender. We verify the buffers are writable and if needed move the 16781da177e4SLinus Torvalds * sender address from kernel to user space. 16791da177e4SLinus Torvalds */ 16801da177e4SLinus Torvalds 168189bddce5SStephen Hemminger asmlinkage long sys_recvfrom(int fd, void __user *ubuf, size_t size, 168289bddce5SStephen Hemminger unsigned flags, struct sockaddr __user *addr, 168389bddce5SStephen Hemminger int __user *addr_len) 16841da177e4SLinus Torvalds { 16851da177e4SLinus Torvalds struct socket *sock; 16861da177e4SLinus Torvalds struct iovec iov; 16871da177e4SLinus Torvalds struct msghdr msg; 1688230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 16891da177e4SLinus Torvalds int err, err2; 16906cb153caSBenjamin LaHaise int fput_needed; 16911da177e4SLinus Torvalds 1692de0fa95cSPavel Emelyanov sock = sockfd_lookup_light(fd, &err, &fput_needed); 16931da177e4SLinus Torvalds if (!sock) 1694de0fa95cSPavel Emelyanov goto out; 16951da177e4SLinus Torvalds 16961da177e4SLinus Torvalds msg.msg_control = NULL; 16971da177e4SLinus Torvalds msg.msg_controllen = 0; 16981da177e4SLinus Torvalds msg.msg_iovlen = 1; 16991da177e4SLinus Torvalds msg.msg_iov = &iov; 17001da177e4SLinus Torvalds iov.iov_len = size; 17011da177e4SLinus Torvalds iov.iov_base = ubuf; 1702230b1839SYOSHIFUJI Hideaki msg.msg_name = (struct sockaddr *)&address; 1703230b1839SYOSHIFUJI Hideaki msg.msg_namelen = sizeof(address); 17041da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 17051da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 17061da177e4SLinus Torvalds err = sock_recvmsg(sock, &msg, size, flags); 17071da177e4SLinus Torvalds 170889bddce5SStephen Hemminger if (err >= 0 && addr != NULL) { 1709230b1839SYOSHIFUJI Hideaki err2 = move_addr_to_user((struct sockaddr *)&address, 1710230b1839SYOSHIFUJI Hideaki msg.msg_namelen, addr, addr_len); 17111da177e4SLinus Torvalds if (err2 < 0) 17121da177e4SLinus Torvalds err = err2; 17131da177e4SLinus Torvalds } 1714de0fa95cSPavel Emelyanov 1715de0fa95cSPavel Emelyanov fput_light(sock->file, fput_needed); 17164387ff75SDavid S. Miller out: 17171da177e4SLinus Torvalds return err; 17181da177e4SLinus Torvalds } 17191da177e4SLinus Torvalds 17201da177e4SLinus Torvalds /* 17211da177e4SLinus Torvalds * Receive a datagram from a socket. 17221da177e4SLinus Torvalds */ 17231da177e4SLinus Torvalds 172489bddce5SStephen Hemminger asmlinkage long sys_recv(int fd, void __user *ubuf, size_t size, 172589bddce5SStephen Hemminger unsigned flags) 17261da177e4SLinus Torvalds { 17271da177e4SLinus Torvalds return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL); 17281da177e4SLinus Torvalds } 17291da177e4SLinus Torvalds 17301da177e4SLinus Torvalds /* 17311da177e4SLinus Torvalds * Set a socket option. Because we don't know the option lengths we have 17321da177e4SLinus Torvalds * to pass the user mode parameter for the protocols to sort out. 17331da177e4SLinus Torvalds */ 17341da177e4SLinus Torvalds 173589bddce5SStephen Hemminger asmlinkage long sys_setsockopt(int fd, int level, int optname, 173689bddce5SStephen Hemminger char __user *optval, int optlen) 17371da177e4SLinus Torvalds { 17386cb153caSBenjamin LaHaise int err, fput_needed; 17391da177e4SLinus Torvalds struct socket *sock; 17401da177e4SLinus Torvalds 17411da177e4SLinus Torvalds if (optlen < 0) 17421da177e4SLinus Torvalds return -EINVAL; 17431da177e4SLinus Torvalds 174489bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 174589bddce5SStephen Hemminger if (sock != NULL) { 17461da177e4SLinus Torvalds err = security_socket_setsockopt(sock, level, optname); 17476cb153caSBenjamin LaHaise if (err) 17486cb153caSBenjamin LaHaise goto out_put; 17491da177e4SLinus Torvalds 17501da177e4SLinus Torvalds if (level == SOL_SOCKET) 175189bddce5SStephen Hemminger err = 175289bddce5SStephen Hemminger sock_setsockopt(sock, level, optname, optval, 175389bddce5SStephen Hemminger optlen); 17541da177e4SLinus Torvalds else 175589bddce5SStephen Hemminger err = 175689bddce5SStephen Hemminger sock->ops->setsockopt(sock, level, optname, optval, 175789bddce5SStephen Hemminger optlen); 17586cb153caSBenjamin LaHaise out_put: 17596cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 17601da177e4SLinus Torvalds } 17611da177e4SLinus Torvalds return err; 17621da177e4SLinus Torvalds } 17631da177e4SLinus Torvalds 17641da177e4SLinus Torvalds /* 17651da177e4SLinus Torvalds * Get a socket option. Because we don't know the option lengths we have 17661da177e4SLinus Torvalds * to pass a user mode parameter for the protocols to sort out. 17671da177e4SLinus Torvalds */ 17681da177e4SLinus Torvalds 176989bddce5SStephen Hemminger asmlinkage long sys_getsockopt(int fd, int level, int optname, 177089bddce5SStephen Hemminger char __user *optval, int __user *optlen) 17711da177e4SLinus Torvalds { 17726cb153caSBenjamin LaHaise int err, fput_needed; 17731da177e4SLinus Torvalds struct socket *sock; 17741da177e4SLinus Torvalds 177589bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 177689bddce5SStephen Hemminger if (sock != NULL) { 17776cb153caSBenjamin LaHaise err = security_socket_getsockopt(sock, level, optname); 17786cb153caSBenjamin LaHaise if (err) 17796cb153caSBenjamin LaHaise goto out_put; 17801da177e4SLinus Torvalds 17811da177e4SLinus Torvalds if (level == SOL_SOCKET) 178289bddce5SStephen Hemminger err = 178389bddce5SStephen Hemminger sock_getsockopt(sock, level, optname, optval, 178489bddce5SStephen Hemminger optlen); 17851da177e4SLinus Torvalds else 178689bddce5SStephen Hemminger err = 178789bddce5SStephen Hemminger sock->ops->getsockopt(sock, level, optname, optval, 178889bddce5SStephen Hemminger optlen); 17896cb153caSBenjamin LaHaise out_put: 17906cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 17911da177e4SLinus Torvalds } 17921da177e4SLinus Torvalds return err; 17931da177e4SLinus Torvalds } 17941da177e4SLinus Torvalds 17951da177e4SLinus Torvalds /* 17961da177e4SLinus Torvalds * Shutdown a socket. 17971da177e4SLinus Torvalds */ 17981da177e4SLinus Torvalds 17991da177e4SLinus Torvalds asmlinkage long sys_shutdown(int fd, int how) 18001da177e4SLinus Torvalds { 18016cb153caSBenjamin LaHaise int err, fput_needed; 18021da177e4SLinus Torvalds struct socket *sock; 18031da177e4SLinus Torvalds 180489bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 180589bddce5SStephen Hemminger if (sock != NULL) { 18061da177e4SLinus Torvalds err = security_socket_shutdown(sock, how); 18076cb153caSBenjamin LaHaise if (!err) 18081da177e4SLinus Torvalds err = sock->ops->shutdown(sock, how); 18096cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 18101da177e4SLinus Torvalds } 18111da177e4SLinus Torvalds return err; 18121da177e4SLinus Torvalds } 18131da177e4SLinus Torvalds 18141da177e4SLinus Torvalds /* A couple of helpful macros for getting the address of the 32/64 bit 18151da177e4SLinus Torvalds * fields which are the same type (int / unsigned) on our platforms. 18161da177e4SLinus Torvalds */ 18171da177e4SLinus Torvalds #define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member) 18181da177e4SLinus Torvalds #define COMPAT_NAMELEN(msg) COMPAT_MSG(msg, msg_namelen) 18191da177e4SLinus Torvalds #define COMPAT_FLAGS(msg) COMPAT_MSG(msg, msg_flags) 18201da177e4SLinus Torvalds 18211da177e4SLinus Torvalds /* 18221da177e4SLinus Torvalds * BSD sendmsg interface 18231da177e4SLinus Torvalds */ 18241da177e4SLinus Torvalds 18251da177e4SLinus Torvalds asmlinkage long sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags) 18261da177e4SLinus Torvalds { 182789bddce5SStephen Hemminger struct compat_msghdr __user *msg_compat = 182889bddce5SStephen Hemminger (struct compat_msghdr __user *)msg; 18291da177e4SLinus Torvalds struct socket *sock; 1830230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 18311da177e4SLinus Torvalds struct iovec iovstack[UIO_FASTIOV], *iov = iovstack; 1832b9d717a7SAlex Williamson unsigned char ctl[sizeof(struct cmsghdr) + 20] 1833b9d717a7SAlex Williamson __attribute__ ((aligned(sizeof(__kernel_size_t)))); 1834b9d717a7SAlex Williamson /* 20 is size of ipv6_pktinfo */ 18351da177e4SLinus Torvalds unsigned char *ctl_buf = ctl; 18361da177e4SLinus Torvalds struct msghdr msg_sys; 18371da177e4SLinus Torvalds int err, ctl_len, iov_size, total_len; 18386cb153caSBenjamin LaHaise int fput_needed; 18391da177e4SLinus Torvalds 18401da177e4SLinus Torvalds err = -EFAULT; 18411da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 18421da177e4SLinus Torvalds if (get_compat_msghdr(&msg_sys, msg_compat)) 18431da177e4SLinus Torvalds return -EFAULT; 184489bddce5SStephen Hemminger } 184589bddce5SStephen Hemminger else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr))) 18461da177e4SLinus Torvalds return -EFAULT; 18471da177e4SLinus Torvalds 18486cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 18491da177e4SLinus Torvalds if (!sock) 18501da177e4SLinus Torvalds goto out; 18511da177e4SLinus Torvalds 18521da177e4SLinus Torvalds /* do not move before msg_sys is valid */ 18531da177e4SLinus Torvalds err = -EMSGSIZE; 18541da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_MAXIOV) 18551da177e4SLinus Torvalds goto out_put; 18561da177e4SLinus Torvalds 18571da177e4SLinus Torvalds /* Check whether to allocate the iovec area */ 18581da177e4SLinus Torvalds err = -ENOMEM; 18591da177e4SLinus Torvalds iov_size = msg_sys.msg_iovlen * sizeof(struct iovec); 18601da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_FASTIOV) { 18611da177e4SLinus Torvalds iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL); 18621da177e4SLinus Torvalds if (!iov) 18631da177e4SLinus Torvalds goto out_put; 18641da177e4SLinus Torvalds } 18651da177e4SLinus Torvalds 18661da177e4SLinus Torvalds /* This will also move the address data into kernel space */ 18671da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 1868230b1839SYOSHIFUJI Hideaki err = verify_compat_iovec(&msg_sys, iov, 1869230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&address, 1870230b1839SYOSHIFUJI Hideaki VERIFY_READ); 18711da177e4SLinus Torvalds } else 1872230b1839SYOSHIFUJI Hideaki err = verify_iovec(&msg_sys, iov, 1873230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&address, 1874230b1839SYOSHIFUJI Hideaki VERIFY_READ); 18751da177e4SLinus Torvalds if (err < 0) 18761da177e4SLinus Torvalds goto out_freeiov; 18771da177e4SLinus Torvalds total_len = err; 18781da177e4SLinus Torvalds 18791da177e4SLinus Torvalds err = -ENOBUFS; 18801da177e4SLinus Torvalds 18811da177e4SLinus Torvalds if (msg_sys.msg_controllen > INT_MAX) 18821da177e4SLinus Torvalds goto out_freeiov; 18831da177e4SLinus Torvalds ctl_len = msg_sys.msg_controllen; 18841da177e4SLinus Torvalds if ((MSG_CMSG_COMPAT & flags) && ctl_len) { 188589bddce5SStephen Hemminger err = 188689bddce5SStephen Hemminger cmsghdr_from_user_compat_to_kern(&msg_sys, sock->sk, ctl, 188789bddce5SStephen Hemminger sizeof(ctl)); 18881da177e4SLinus Torvalds if (err) 18891da177e4SLinus Torvalds goto out_freeiov; 18901da177e4SLinus Torvalds ctl_buf = msg_sys.msg_control; 18918920e8f9SAl Viro ctl_len = msg_sys.msg_controllen; 18921da177e4SLinus Torvalds } else if (ctl_len) { 189389bddce5SStephen Hemminger if (ctl_len > sizeof(ctl)) { 18941da177e4SLinus Torvalds ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL); 18951da177e4SLinus Torvalds if (ctl_buf == NULL) 18961da177e4SLinus Torvalds goto out_freeiov; 18971da177e4SLinus Torvalds } 18981da177e4SLinus Torvalds err = -EFAULT; 18991da177e4SLinus Torvalds /* 19001da177e4SLinus Torvalds * Careful! Before this, msg_sys.msg_control contains a user pointer. 19011da177e4SLinus Torvalds * Afterwards, it will be a kernel pointer. Thus the compiler-assisted 19021da177e4SLinus Torvalds * checking falls down on this. 19031da177e4SLinus Torvalds */ 190489bddce5SStephen Hemminger if (copy_from_user(ctl_buf, (void __user *)msg_sys.msg_control, 190589bddce5SStephen Hemminger ctl_len)) 19061da177e4SLinus Torvalds goto out_freectl; 19071da177e4SLinus Torvalds msg_sys.msg_control = ctl_buf; 19081da177e4SLinus Torvalds } 19091da177e4SLinus Torvalds msg_sys.msg_flags = flags; 19101da177e4SLinus Torvalds 19111da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 19121da177e4SLinus Torvalds msg_sys.msg_flags |= MSG_DONTWAIT; 19131da177e4SLinus Torvalds err = sock_sendmsg(sock, &msg_sys, total_len); 19141da177e4SLinus Torvalds 19151da177e4SLinus Torvalds out_freectl: 19161da177e4SLinus Torvalds if (ctl_buf != ctl) 19171da177e4SLinus Torvalds sock_kfree_s(sock->sk, ctl_buf, ctl_len); 19181da177e4SLinus Torvalds out_freeiov: 19191da177e4SLinus Torvalds if (iov != iovstack) 19201da177e4SLinus Torvalds sock_kfree_s(sock->sk, iov, iov_size); 19211da177e4SLinus Torvalds out_put: 19226cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 19231da177e4SLinus Torvalds out: 19241da177e4SLinus Torvalds return err; 19251da177e4SLinus Torvalds } 19261da177e4SLinus Torvalds 19271da177e4SLinus Torvalds /* 19281da177e4SLinus Torvalds * BSD recvmsg interface 19291da177e4SLinus Torvalds */ 19301da177e4SLinus Torvalds 193189bddce5SStephen Hemminger asmlinkage long sys_recvmsg(int fd, struct msghdr __user *msg, 193289bddce5SStephen Hemminger unsigned int flags) 19331da177e4SLinus Torvalds { 193489bddce5SStephen Hemminger struct compat_msghdr __user *msg_compat = 193589bddce5SStephen Hemminger (struct compat_msghdr __user *)msg; 19361da177e4SLinus Torvalds struct socket *sock; 19371da177e4SLinus Torvalds struct iovec iovstack[UIO_FASTIOV]; 19381da177e4SLinus Torvalds struct iovec *iov = iovstack; 19391da177e4SLinus Torvalds struct msghdr msg_sys; 19401da177e4SLinus Torvalds unsigned long cmsg_ptr; 19411da177e4SLinus Torvalds int err, iov_size, total_len, len; 19426cb153caSBenjamin LaHaise int fput_needed; 19431da177e4SLinus Torvalds 19441da177e4SLinus Torvalds /* kernel mode address */ 1945230b1839SYOSHIFUJI Hideaki struct sockaddr_storage addr; 19461da177e4SLinus Torvalds 19471da177e4SLinus Torvalds /* user mode address pointers */ 19481da177e4SLinus Torvalds struct sockaddr __user *uaddr; 19491da177e4SLinus Torvalds int __user *uaddr_len; 19501da177e4SLinus Torvalds 19511da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 19521da177e4SLinus Torvalds if (get_compat_msghdr(&msg_sys, msg_compat)) 19531da177e4SLinus Torvalds return -EFAULT; 195489bddce5SStephen Hemminger } 195589bddce5SStephen Hemminger else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr))) 19561da177e4SLinus Torvalds return -EFAULT; 19571da177e4SLinus Torvalds 19586cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 19591da177e4SLinus Torvalds if (!sock) 19601da177e4SLinus Torvalds goto out; 19611da177e4SLinus Torvalds 19621da177e4SLinus Torvalds err = -EMSGSIZE; 19631da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_MAXIOV) 19641da177e4SLinus Torvalds goto out_put; 19651da177e4SLinus Torvalds 19661da177e4SLinus Torvalds /* Check whether to allocate the iovec area */ 19671da177e4SLinus Torvalds err = -ENOMEM; 19681da177e4SLinus Torvalds iov_size = msg_sys.msg_iovlen * sizeof(struct iovec); 19691da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_FASTIOV) { 19701da177e4SLinus Torvalds iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL); 19711da177e4SLinus Torvalds if (!iov) 19721da177e4SLinus Torvalds goto out_put; 19731da177e4SLinus Torvalds } 19741da177e4SLinus Torvalds 19751da177e4SLinus Torvalds /* 19761da177e4SLinus Torvalds * Save the user-mode address (verify_iovec will change the 19771da177e4SLinus Torvalds * kernel msghdr to use the kernel address space) 19781da177e4SLinus Torvalds */ 19791da177e4SLinus Torvalds 1980cfcabdccSStephen Hemminger uaddr = (__force void __user *)msg_sys.msg_name; 19811da177e4SLinus Torvalds uaddr_len = COMPAT_NAMELEN(msg); 19821da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 1983230b1839SYOSHIFUJI Hideaki err = verify_compat_iovec(&msg_sys, iov, 1984230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&addr, 1985230b1839SYOSHIFUJI Hideaki VERIFY_WRITE); 19861da177e4SLinus Torvalds } else 1987230b1839SYOSHIFUJI Hideaki err = verify_iovec(&msg_sys, iov, 1988230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&addr, 1989230b1839SYOSHIFUJI Hideaki VERIFY_WRITE); 19901da177e4SLinus Torvalds if (err < 0) 19911da177e4SLinus Torvalds goto out_freeiov; 19921da177e4SLinus Torvalds total_len = err; 19931da177e4SLinus Torvalds 19941da177e4SLinus Torvalds cmsg_ptr = (unsigned long)msg_sys.msg_control; 19954a19542eSUlrich Drepper msg_sys.msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT); 19961da177e4SLinus Torvalds 19971da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 19981da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 19991da177e4SLinus Torvalds err = sock_recvmsg(sock, &msg_sys, total_len, flags); 20001da177e4SLinus Torvalds if (err < 0) 20011da177e4SLinus Torvalds goto out_freeiov; 20021da177e4SLinus Torvalds len = err; 20031da177e4SLinus Torvalds 20041da177e4SLinus Torvalds if (uaddr != NULL) { 2005230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&addr, 2006230b1839SYOSHIFUJI Hideaki msg_sys.msg_namelen, uaddr, 200789bddce5SStephen Hemminger uaddr_len); 20081da177e4SLinus Torvalds if (err < 0) 20091da177e4SLinus Torvalds goto out_freeiov; 20101da177e4SLinus Torvalds } 201137f7f421SDavid S. Miller err = __put_user((msg_sys.msg_flags & ~MSG_CMSG_COMPAT), 201237f7f421SDavid S. Miller COMPAT_FLAGS(msg)); 20131da177e4SLinus Torvalds if (err) 20141da177e4SLinus Torvalds goto out_freeiov; 20151da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) 20161da177e4SLinus Torvalds err = __put_user((unsigned long)msg_sys.msg_control - cmsg_ptr, 20171da177e4SLinus Torvalds &msg_compat->msg_controllen); 20181da177e4SLinus Torvalds else 20191da177e4SLinus Torvalds err = __put_user((unsigned long)msg_sys.msg_control - cmsg_ptr, 20201da177e4SLinus Torvalds &msg->msg_controllen); 20211da177e4SLinus Torvalds if (err) 20221da177e4SLinus Torvalds goto out_freeiov; 20231da177e4SLinus Torvalds err = len; 20241da177e4SLinus Torvalds 20251da177e4SLinus Torvalds out_freeiov: 20261da177e4SLinus Torvalds if (iov != iovstack) 20271da177e4SLinus Torvalds sock_kfree_s(sock->sk, iov, iov_size); 20281da177e4SLinus Torvalds out_put: 20296cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 20301da177e4SLinus Torvalds out: 20311da177e4SLinus Torvalds return err; 20321da177e4SLinus Torvalds } 20331da177e4SLinus Torvalds 20341da177e4SLinus Torvalds #ifdef __ARCH_WANT_SYS_SOCKETCALL 20351da177e4SLinus Torvalds 20361da177e4SLinus Torvalds /* Argument list sizes for sys_socketcall */ 20371da177e4SLinus Torvalds #define AL(x) ((x) * sizeof(unsigned long)) 2038aaca0bdcSUlrich Drepper static const unsigned char nargs[19]={ 203989bddce5SStephen Hemminger AL(0),AL(3),AL(3),AL(3),AL(2),AL(3), 20401da177e4SLinus Torvalds AL(3),AL(3),AL(4),AL(4),AL(4),AL(6), 2041aaca0bdcSUlrich Drepper AL(6),AL(2),AL(5),AL(5),AL(3),AL(3), 2042de11defeSUlrich Drepper AL(4) 204389bddce5SStephen Hemminger }; 204489bddce5SStephen Hemminger 20451da177e4SLinus Torvalds #undef AL 20461da177e4SLinus Torvalds 20471da177e4SLinus Torvalds /* 20481da177e4SLinus Torvalds * System call vectors. 20491da177e4SLinus Torvalds * 20501da177e4SLinus Torvalds * Argument checking cleaned up. Saved 20% in size. 20511da177e4SLinus Torvalds * This function doesn't need to set the kernel lock because 20521da177e4SLinus Torvalds * it is set by the callees. 20531da177e4SLinus Torvalds */ 20541da177e4SLinus Torvalds 20551da177e4SLinus Torvalds asmlinkage long sys_socketcall(int call, unsigned long __user *args) 20561da177e4SLinus Torvalds { 20571da177e4SLinus Torvalds unsigned long a[6]; 20581da177e4SLinus Torvalds unsigned long a0, a1; 20591da177e4SLinus Torvalds int err; 20601da177e4SLinus Torvalds 2061de11defeSUlrich Drepper if (call < 1 || call > SYS_ACCEPT4) 20621da177e4SLinus Torvalds return -EINVAL; 20631da177e4SLinus Torvalds 20641da177e4SLinus Torvalds /* copy_from_user should be SMP safe. */ 20651da177e4SLinus Torvalds if (copy_from_user(a, args, nargs[call])) 20661da177e4SLinus Torvalds return -EFAULT; 20671da177e4SLinus Torvalds 2068*f3298dc4SAl Viro audit_socketcall(nargs[call] / sizeof(unsigned long), a); 20693ec3b2fbSDavid Woodhouse 20701da177e4SLinus Torvalds a0 = a[0]; 20711da177e4SLinus Torvalds a1 = a[1]; 20721da177e4SLinus Torvalds 207389bddce5SStephen Hemminger switch (call) { 20741da177e4SLinus Torvalds case SYS_SOCKET: 20751da177e4SLinus Torvalds err = sys_socket(a0, a1, a[2]); 20761da177e4SLinus Torvalds break; 20771da177e4SLinus Torvalds case SYS_BIND: 20781da177e4SLinus Torvalds err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]); 20791da177e4SLinus Torvalds break; 20801da177e4SLinus Torvalds case SYS_CONNECT: 20811da177e4SLinus Torvalds err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]); 20821da177e4SLinus Torvalds break; 20831da177e4SLinus Torvalds case SYS_LISTEN: 20841da177e4SLinus Torvalds err = sys_listen(a0, a1); 20851da177e4SLinus Torvalds break; 20861da177e4SLinus Torvalds case SYS_ACCEPT: 2087de11defeSUlrich Drepper err = sys_accept4(a0, (struct sockaddr __user *)a1, 2088aaca0bdcSUlrich Drepper (int __user *)a[2], 0); 20891da177e4SLinus Torvalds break; 20901da177e4SLinus Torvalds case SYS_GETSOCKNAME: 209189bddce5SStephen Hemminger err = 209289bddce5SStephen Hemminger sys_getsockname(a0, (struct sockaddr __user *)a1, 209389bddce5SStephen Hemminger (int __user *)a[2]); 20941da177e4SLinus Torvalds break; 20951da177e4SLinus Torvalds case SYS_GETPEERNAME: 209689bddce5SStephen Hemminger err = 209789bddce5SStephen Hemminger sys_getpeername(a0, (struct sockaddr __user *)a1, 209889bddce5SStephen Hemminger (int __user *)a[2]); 20991da177e4SLinus Torvalds break; 21001da177e4SLinus Torvalds case SYS_SOCKETPAIR: 21011da177e4SLinus Torvalds err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]); 21021da177e4SLinus Torvalds break; 21031da177e4SLinus Torvalds case SYS_SEND: 21041da177e4SLinus Torvalds err = sys_send(a0, (void __user *)a1, a[2], a[3]); 21051da177e4SLinus Torvalds break; 21061da177e4SLinus Torvalds case SYS_SENDTO: 21071da177e4SLinus Torvalds err = sys_sendto(a0, (void __user *)a1, a[2], a[3], 21081da177e4SLinus Torvalds (struct sockaddr __user *)a[4], a[5]); 21091da177e4SLinus Torvalds break; 21101da177e4SLinus Torvalds case SYS_RECV: 21111da177e4SLinus Torvalds err = sys_recv(a0, (void __user *)a1, a[2], a[3]); 21121da177e4SLinus Torvalds break; 21131da177e4SLinus Torvalds case SYS_RECVFROM: 21141da177e4SLinus Torvalds err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3], 211589bddce5SStephen Hemminger (struct sockaddr __user *)a[4], 211689bddce5SStephen Hemminger (int __user *)a[5]); 21171da177e4SLinus Torvalds break; 21181da177e4SLinus Torvalds case SYS_SHUTDOWN: 21191da177e4SLinus Torvalds err = sys_shutdown(a0, a1); 21201da177e4SLinus Torvalds break; 21211da177e4SLinus Torvalds case SYS_SETSOCKOPT: 21221da177e4SLinus Torvalds err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]); 21231da177e4SLinus Torvalds break; 21241da177e4SLinus Torvalds case SYS_GETSOCKOPT: 212589bddce5SStephen Hemminger err = 212689bddce5SStephen Hemminger sys_getsockopt(a0, a1, a[2], (char __user *)a[3], 212789bddce5SStephen Hemminger (int __user *)a[4]); 21281da177e4SLinus Torvalds break; 21291da177e4SLinus Torvalds case SYS_SENDMSG: 21301da177e4SLinus Torvalds err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]); 21311da177e4SLinus Torvalds break; 21321da177e4SLinus Torvalds case SYS_RECVMSG: 21331da177e4SLinus Torvalds err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]); 21341da177e4SLinus Torvalds break; 2135de11defeSUlrich Drepper case SYS_ACCEPT4: 2136de11defeSUlrich Drepper err = sys_accept4(a0, (struct sockaddr __user *)a1, 2137de11defeSUlrich Drepper (int __user *)a[2], a[3]); 2138aaca0bdcSUlrich Drepper break; 21391da177e4SLinus Torvalds default: 21401da177e4SLinus Torvalds err = -EINVAL; 21411da177e4SLinus Torvalds break; 21421da177e4SLinus Torvalds } 21431da177e4SLinus Torvalds return err; 21441da177e4SLinus Torvalds } 21451da177e4SLinus Torvalds 21461da177e4SLinus Torvalds #endif /* __ARCH_WANT_SYS_SOCKETCALL */ 21471da177e4SLinus Torvalds 214855737fdaSStephen Hemminger /** 214955737fdaSStephen Hemminger * sock_register - add a socket protocol handler 215055737fdaSStephen Hemminger * @ops: description of protocol 215155737fdaSStephen Hemminger * 21521da177e4SLinus Torvalds * This function is called by a protocol handler that wants to 21531da177e4SLinus Torvalds * advertise its address family, and have it linked into the 215455737fdaSStephen Hemminger * socket interface. The value ops->family coresponds to the 215555737fdaSStephen Hemminger * socket system call protocol family. 21561da177e4SLinus Torvalds */ 2157f0fd27d4SStephen Hemminger int sock_register(const struct net_proto_family *ops) 21581da177e4SLinus Torvalds { 21591da177e4SLinus Torvalds int err; 21601da177e4SLinus Torvalds 21611da177e4SLinus Torvalds if (ops->family >= NPROTO) { 216289bddce5SStephen Hemminger printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family, 216389bddce5SStephen Hemminger NPROTO); 21641da177e4SLinus Torvalds return -ENOBUFS; 21651da177e4SLinus Torvalds } 216655737fdaSStephen Hemminger 216755737fdaSStephen Hemminger spin_lock(&net_family_lock); 216855737fdaSStephen Hemminger if (net_families[ops->family]) 21691da177e4SLinus Torvalds err = -EEXIST; 217055737fdaSStephen Hemminger else { 21711da177e4SLinus Torvalds net_families[ops->family] = ops; 21721da177e4SLinus Torvalds err = 0; 21731da177e4SLinus Torvalds } 217455737fdaSStephen Hemminger spin_unlock(&net_family_lock); 217555737fdaSStephen Hemminger 217689bddce5SStephen Hemminger printk(KERN_INFO "NET: Registered protocol family %d\n", ops->family); 21771da177e4SLinus Torvalds return err; 21781da177e4SLinus Torvalds } 21791da177e4SLinus Torvalds 218055737fdaSStephen Hemminger /** 218155737fdaSStephen Hemminger * sock_unregister - remove a protocol handler 218255737fdaSStephen Hemminger * @family: protocol family to remove 218355737fdaSStephen Hemminger * 21841da177e4SLinus Torvalds * This function is called by a protocol handler that wants to 21851da177e4SLinus Torvalds * remove its address family, and have it unlinked from the 218655737fdaSStephen Hemminger * new socket creation. 218755737fdaSStephen Hemminger * 218855737fdaSStephen Hemminger * If protocol handler is a module, then it can use module reference 218955737fdaSStephen Hemminger * counts to protect against new references. If protocol handler is not 219055737fdaSStephen Hemminger * a module then it needs to provide its own protection in 219155737fdaSStephen Hemminger * the ops->create routine. 21921da177e4SLinus Torvalds */ 2193f0fd27d4SStephen Hemminger void sock_unregister(int family) 21941da177e4SLinus Torvalds { 2195f0fd27d4SStephen Hemminger BUG_ON(family < 0 || family >= NPROTO); 21961da177e4SLinus Torvalds 219755737fdaSStephen Hemminger spin_lock(&net_family_lock); 21981da177e4SLinus Torvalds net_families[family] = NULL; 219955737fdaSStephen Hemminger spin_unlock(&net_family_lock); 220055737fdaSStephen Hemminger 220155737fdaSStephen Hemminger synchronize_rcu(); 220255737fdaSStephen Hemminger 220389bddce5SStephen Hemminger printk(KERN_INFO "NET: Unregistered protocol family %d\n", family); 22041da177e4SLinus Torvalds } 22051da177e4SLinus Torvalds 220677d76ea3SAndi Kleen static int __init sock_init(void) 22071da177e4SLinus Torvalds { 22081da177e4SLinus Torvalds /* 22091da177e4SLinus Torvalds * Initialize sock SLAB cache. 22101da177e4SLinus Torvalds */ 22111da177e4SLinus Torvalds 22121da177e4SLinus Torvalds sk_init(); 22131da177e4SLinus Torvalds 22141da177e4SLinus Torvalds /* 22151da177e4SLinus Torvalds * Initialize skbuff SLAB cache 22161da177e4SLinus Torvalds */ 22171da177e4SLinus Torvalds skb_init(); 22181da177e4SLinus Torvalds 22191da177e4SLinus Torvalds /* 22201da177e4SLinus Torvalds * Initialize the protocols module. 22211da177e4SLinus Torvalds */ 22221da177e4SLinus Torvalds 22231da177e4SLinus Torvalds init_inodecache(); 22241da177e4SLinus Torvalds register_filesystem(&sock_fs_type); 22251da177e4SLinus Torvalds sock_mnt = kern_mount(&sock_fs_type); 222677d76ea3SAndi Kleen 222777d76ea3SAndi Kleen /* The real protocol initialization is performed in later initcalls. 22281da177e4SLinus Torvalds */ 22291da177e4SLinus Torvalds 22301da177e4SLinus Torvalds #ifdef CONFIG_NETFILTER 22311da177e4SLinus Torvalds netfilter_init(); 22321da177e4SLinus Torvalds #endif 2233cbeb321aSDavid S. Miller 2234cbeb321aSDavid S. Miller return 0; 22351da177e4SLinus Torvalds } 22361da177e4SLinus Torvalds 223777d76ea3SAndi Kleen core_initcall(sock_init); /* early initcall */ 223877d76ea3SAndi Kleen 22391da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 22401da177e4SLinus Torvalds void socket_seq_show(struct seq_file *seq) 22411da177e4SLinus Torvalds { 22421da177e4SLinus Torvalds int cpu; 22431da177e4SLinus Torvalds int counter = 0; 22441da177e4SLinus Torvalds 22456f912042SKAMEZAWA Hiroyuki for_each_possible_cpu(cpu) 22461da177e4SLinus Torvalds counter += per_cpu(sockets_in_use, cpu); 22471da177e4SLinus Torvalds 22481da177e4SLinus Torvalds /* It can be negative, by the way. 8) */ 22491da177e4SLinus Torvalds if (counter < 0) 22501da177e4SLinus Torvalds counter = 0; 22511da177e4SLinus Torvalds 22521da177e4SLinus Torvalds seq_printf(seq, "sockets: used %d\n", counter); 22531da177e4SLinus Torvalds } 22541da177e4SLinus Torvalds #endif /* CONFIG_PROC_FS */ 22551da177e4SLinus Torvalds 225689bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 225789bbfc95SShaun Pereira static long compat_sock_ioctl(struct file *file, unsigned cmd, 225889bbfc95SShaun Pereira unsigned long arg) 225989bbfc95SShaun Pereira { 226089bbfc95SShaun Pereira struct socket *sock = file->private_data; 226189bbfc95SShaun Pereira int ret = -ENOIOCTLCMD; 226287de87d5SDavid S. Miller struct sock *sk; 226387de87d5SDavid S. Miller struct net *net; 226487de87d5SDavid S. Miller 226587de87d5SDavid S. Miller sk = sock->sk; 226687de87d5SDavid S. Miller net = sock_net(sk); 226789bbfc95SShaun Pereira 226889bbfc95SShaun Pereira if (sock->ops->compat_ioctl) 226989bbfc95SShaun Pereira ret = sock->ops->compat_ioctl(sock, cmd, arg); 227089bbfc95SShaun Pereira 227187de87d5SDavid S. Miller if (ret == -ENOIOCTLCMD && 227287de87d5SDavid S. Miller (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)) 227387de87d5SDavid S. Miller ret = compat_wext_handle_ioctl(net, cmd, arg); 227487de87d5SDavid S. Miller 227589bbfc95SShaun Pereira return ret; 227689bbfc95SShaun Pereira } 227789bbfc95SShaun Pereira #endif 227889bbfc95SShaun Pereira 2279ac5a488eSSridhar Samudrala int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen) 2280ac5a488eSSridhar Samudrala { 2281ac5a488eSSridhar Samudrala return sock->ops->bind(sock, addr, addrlen); 2282ac5a488eSSridhar Samudrala } 2283ac5a488eSSridhar Samudrala 2284ac5a488eSSridhar Samudrala int kernel_listen(struct socket *sock, int backlog) 2285ac5a488eSSridhar Samudrala { 2286ac5a488eSSridhar Samudrala return sock->ops->listen(sock, backlog); 2287ac5a488eSSridhar Samudrala } 2288ac5a488eSSridhar Samudrala 2289ac5a488eSSridhar Samudrala int kernel_accept(struct socket *sock, struct socket **newsock, int flags) 2290ac5a488eSSridhar Samudrala { 2291ac5a488eSSridhar Samudrala struct sock *sk = sock->sk; 2292ac5a488eSSridhar Samudrala int err; 2293ac5a488eSSridhar Samudrala 2294ac5a488eSSridhar Samudrala err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 2295ac5a488eSSridhar Samudrala newsock); 2296ac5a488eSSridhar Samudrala if (err < 0) 2297ac5a488eSSridhar Samudrala goto done; 2298ac5a488eSSridhar Samudrala 2299ac5a488eSSridhar Samudrala err = sock->ops->accept(sock, *newsock, flags); 2300ac5a488eSSridhar Samudrala if (err < 0) { 2301ac5a488eSSridhar Samudrala sock_release(*newsock); 2302fa8705b0STony Battersby *newsock = NULL; 2303ac5a488eSSridhar Samudrala goto done; 2304ac5a488eSSridhar Samudrala } 2305ac5a488eSSridhar Samudrala 2306ac5a488eSSridhar Samudrala (*newsock)->ops = sock->ops; 23071b08534eSWei Yongjun __module_get((*newsock)->ops->owner); 2308ac5a488eSSridhar Samudrala 2309ac5a488eSSridhar Samudrala done: 2310ac5a488eSSridhar Samudrala return err; 2311ac5a488eSSridhar Samudrala } 2312ac5a488eSSridhar Samudrala 2313ac5a488eSSridhar Samudrala int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen, 2314ac5a488eSSridhar Samudrala int flags) 2315ac5a488eSSridhar Samudrala { 2316ac5a488eSSridhar Samudrala return sock->ops->connect(sock, addr, addrlen, flags); 2317ac5a488eSSridhar Samudrala } 2318ac5a488eSSridhar Samudrala 2319ac5a488eSSridhar Samudrala int kernel_getsockname(struct socket *sock, struct sockaddr *addr, 2320ac5a488eSSridhar Samudrala int *addrlen) 2321ac5a488eSSridhar Samudrala { 2322ac5a488eSSridhar Samudrala return sock->ops->getname(sock, addr, addrlen, 0); 2323ac5a488eSSridhar Samudrala } 2324ac5a488eSSridhar Samudrala 2325ac5a488eSSridhar Samudrala int kernel_getpeername(struct socket *sock, struct sockaddr *addr, 2326ac5a488eSSridhar Samudrala int *addrlen) 2327ac5a488eSSridhar Samudrala { 2328ac5a488eSSridhar Samudrala return sock->ops->getname(sock, addr, addrlen, 1); 2329ac5a488eSSridhar Samudrala } 2330ac5a488eSSridhar Samudrala 2331ac5a488eSSridhar Samudrala int kernel_getsockopt(struct socket *sock, int level, int optname, 2332ac5a488eSSridhar Samudrala char *optval, int *optlen) 2333ac5a488eSSridhar Samudrala { 2334ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 2335ac5a488eSSridhar Samudrala int err; 2336ac5a488eSSridhar Samudrala 2337ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 2338ac5a488eSSridhar Samudrala if (level == SOL_SOCKET) 2339ac5a488eSSridhar Samudrala err = sock_getsockopt(sock, level, optname, optval, optlen); 2340ac5a488eSSridhar Samudrala else 2341ac5a488eSSridhar Samudrala err = sock->ops->getsockopt(sock, level, optname, optval, 2342ac5a488eSSridhar Samudrala optlen); 2343ac5a488eSSridhar Samudrala set_fs(oldfs); 2344ac5a488eSSridhar Samudrala return err; 2345ac5a488eSSridhar Samudrala } 2346ac5a488eSSridhar Samudrala 2347ac5a488eSSridhar Samudrala int kernel_setsockopt(struct socket *sock, int level, int optname, 2348ac5a488eSSridhar Samudrala char *optval, int optlen) 2349ac5a488eSSridhar Samudrala { 2350ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 2351ac5a488eSSridhar Samudrala int err; 2352ac5a488eSSridhar Samudrala 2353ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 2354ac5a488eSSridhar Samudrala if (level == SOL_SOCKET) 2355ac5a488eSSridhar Samudrala err = sock_setsockopt(sock, level, optname, optval, optlen); 2356ac5a488eSSridhar Samudrala else 2357ac5a488eSSridhar Samudrala err = sock->ops->setsockopt(sock, level, optname, optval, 2358ac5a488eSSridhar Samudrala optlen); 2359ac5a488eSSridhar Samudrala set_fs(oldfs); 2360ac5a488eSSridhar Samudrala return err; 2361ac5a488eSSridhar Samudrala } 2362ac5a488eSSridhar Samudrala 2363ac5a488eSSridhar Samudrala int kernel_sendpage(struct socket *sock, struct page *page, int offset, 2364ac5a488eSSridhar Samudrala size_t size, int flags) 2365ac5a488eSSridhar Samudrala { 2366ac5a488eSSridhar Samudrala if (sock->ops->sendpage) 2367ac5a488eSSridhar Samudrala return sock->ops->sendpage(sock, page, offset, size, flags); 2368ac5a488eSSridhar Samudrala 2369ac5a488eSSridhar Samudrala return sock_no_sendpage(sock, page, offset, size, flags); 2370ac5a488eSSridhar Samudrala } 2371ac5a488eSSridhar Samudrala 2372ac5a488eSSridhar Samudrala int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg) 2373ac5a488eSSridhar Samudrala { 2374ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 2375ac5a488eSSridhar Samudrala int err; 2376ac5a488eSSridhar Samudrala 2377ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 2378ac5a488eSSridhar Samudrala err = sock->ops->ioctl(sock, cmd, arg); 2379ac5a488eSSridhar Samudrala set_fs(oldfs); 2380ac5a488eSSridhar Samudrala 2381ac5a488eSSridhar Samudrala return err; 2382ac5a488eSSridhar Samudrala } 2383ac5a488eSSridhar Samudrala 238491cf45f0STrond Myklebust int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how) 238591cf45f0STrond Myklebust { 238691cf45f0STrond Myklebust return sock->ops->shutdown(sock, how); 238791cf45f0STrond Myklebust } 238891cf45f0STrond Myklebust 23891da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create); 23901da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create_kern); 23911da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create_lite); 23921da177e4SLinus Torvalds EXPORT_SYMBOL(sock_map_fd); 23931da177e4SLinus Torvalds EXPORT_SYMBOL(sock_recvmsg); 23941da177e4SLinus Torvalds EXPORT_SYMBOL(sock_register); 23951da177e4SLinus Torvalds EXPORT_SYMBOL(sock_release); 23961da177e4SLinus Torvalds EXPORT_SYMBOL(sock_sendmsg); 23971da177e4SLinus Torvalds EXPORT_SYMBOL(sock_unregister); 23981da177e4SLinus Torvalds EXPORT_SYMBOL(sock_wake_async); 23991da177e4SLinus Torvalds EXPORT_SYMBOL(sockfd_lookup); 24001da177e4SLinus Torvalds EXPORT_SYMBOL(kernel_sendmsg); 24011da177e4SLinus Torvalds EXPORT_SYMBOL(kernel_recvmsg); 2402ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_bind); 2403ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_listen); 2404ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_accept); 2405ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_connect); 2406ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getsockname); 2407ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getpeername); 2408ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getsockopt); 2409ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_setsockopt); 2410ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_sendpage); 2411ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_sock_ioctl); 241291cf45f0STrond Myklebust EXPORT_SYMBOL(kernel_sock_shutdown); 2413