11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * NET An implementation of the SOCKET network access protocol. 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Version: @(#)socket.c 1.1.93 18/02/95 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Authors: Orest Zborowski, <obz@Kodak.COM> 702c30a84SJesper Juhl * Ross Biro 81da177e4SLinus Torvalds * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 91da177e4SLinus Torvalds * 101da177e4SLinus Torvalds * Fixes: 111da177e4SLinus Torvalds * Anonymous : NOTSOCK/BADF cleanup. Error fix in 121da177e4SLinus Torvalds * shutdown() 131da177e4SLinus Torvalds * Alan Cox : verify_area() fixes 141da177e4SLinus Torvalds * Alan Cox : Removed DDI 151da177e4SLinus Torvalds * Jonathan Kamens : SOCK_DGRAM reconnect bug 161da177e4SLinus Torvalds * Alan Cox : Moved a load of checks to the very 171da177e4SLinus Torvalds * top level. 181da177e4SLinus Torvalds * Alan Cox : Move address structures to/from user 191da177e4SLinus Torvalds * mode above the protocol layers. 201da177e4SLinus Torvalds * Rob Janssen : Allow 0 length sends. 211da177e4SLinus Torvalds * Alan Cox : Asynchronous I/O support (cribbed from the 221da177e4SLinus Torvalds * tty drivers). 231da177e4SLinus Torvalds * Niibe Yutaka : Asynchronous I/O for writes (4.4BSD style) 241da177e4SLinus Torvalds * Jeff Uphoff : Made max number of sockets command-line 251da177e4SLinus Torvalds * configurable. 261da177e4SLinus Torvalds * Matti Aarnio : Made the number of sockets dynamic, 271da177e4SLinus Torvalds * to be allocated when needed, and mr. 281da177e4SLinus Torvalds * Uphoff's max is used as max to be 291da177e4SLinus Torvalds * allowed to allocate. 301da177e4SLinus Torvalds * Linus : Argh. removed all the socket allocation 311da177e4SLinus Torvalds * altogether: it's in the inode now. 321da177e4SLinus Torvalds * Alan Cox : Made sock_alloc()/sock_release() public 331da177e4SLinus Torvalds * for NetROM and future kernel nfsd type 341da177e4SLinus Torvalds * stuff. 351da177e4SLinus Torvalds * Alan Cox : sendmsg/recvmsg basics. 361da177e4SLinus Torvalds * Tom Dyas : Export net symbols. 371da177e4SLinus Torvalds * Marcin Dalecki : Fixed problems with CONFIG_NET="n". 381da177e4SLinus Torvalds * Alan Cox : Added thread locking to sys_* calls 391da177e4SLinus Torvalds * for sockets. May have errors at the 401da177e4SLinus Torvalds * moment. 411da177e4SLinus Torvalds * Kevin Buhr : Fixed the dumb errors in the above. 421da177e4SLinus Torvalds * Andi Kleen : Some small cleanups, optimizations, 431da177e4SLinus Torvalds * and fixed a copy_from_user() bug. 441da177e4SLinus Torvalds * Tigran Aivazian : sys_send(args) calls sys_sendto(args, NULL, 0) 451da177e4SLinus Torvalds * Tigran Aivazian : Made listen(2) backlog sanity checks 461da177e4SLinus Torvalds * protocol-independent 471da177e4SLinus Torvalds * 481da177e4SLinus Torvalds * 491da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or 501da177e4SLinus Torvalds * modify it under the terms of the GNU General Public License 511da177e4SLinus Torvalds * as published by the Free Software Foundation; either version 521da177e4SLinus Torvalds * 2 of the License, or (at your option) any later version. 531da177e4SLinus Torvalds * 541da177e4SLinus Torvalds * 551da177e4SLinus Torvalds * This module is effectively the top level interface to the BSD socket 561da177e4SLinus Torvalds * paradigm. 571da177e4SLinus Torvalds * 581da177e4SLinus Torvalds * Based upon Swansea University Computer Society NET3.039 591da177e4SLinus Torvalds */ 601da177e4SLinus Torvalds 611da177e4SLinus Torvalds #include <linux/mm.h> 621da177e4SLinus Torvalds #include <linux/socket.h> 631da177e4SLinus Torvalds #include <linux/file.h> 641da177e4SLinus Torvalds #include <linux/net.h> 651da177e4SLinus Torvalds #include <linux/interrupt.h> 6655737fdaSStephen Hemminger #include <linux/rcupdate.h> 671da177e4SLinus Torvalds #include <linux/netdevice.h> 681da177e4SLinus Torvalds #include <linux/proc_fs.h> 691da177e4SLinus Torvalds #include <linux/seq_file.h> 704a3e2f71SArjan van de Ven #include <linux/mutex.h> 711da177e4SLinus Torvalds #include <linux/wanrouter.h> 721da177e4SLinus Torvalds #include <linux/if_bridge.h> 7320380731SArnaldo Carvalho de Melo #include <linux/if_frad.h> 7420380731SArnaldo Carvalho de Melo #include <linux/if_vlan.h> 751da177e4SLinus Torvalds #include <linux/init.h> 761da177e4SLinus Torvalds #include <linux/poll.h> 771da177e4SLinus Torvalds #include <linux/cache.h> 781da177e4SLinus Torvalds #include <linux/module.h> 791da177e4SLinus Torvalds #include <linux/highmem.h> 801da177e4SLinus Torvalds #include <linux/mount.h> 811da177e4SLinus Torvalds #include <linux/security.h> 821da177e4SLinus Torvalds #include <linux/syscalls.h> 831da177e4SLinus Torvalds #include <linux/compat.h> 841da177e4SLinus Torvalds #include <linux/kmod.h> 853ec3b2fbSDavid Woodhouse #include <linux/audit.h> 86d86b5e0eSAdrian Bunk #include <linux/wireless.h> 871da177e4SLinus Torvalds 881da177e4SLinus Torvalds #include <asm/uaccess.h> 891da177e4SLinus Torvalds #include <asm/unistd.h> 901da177e4SLinus Torvalds 911da177e4SLinus Torvalds #include <net/compat.h> 921da177e4SLinus Torvalds 931da177e4SLinus Torvalds #include <net/sock.h> 941da177e4SLinus Torvalds #include <linux/netfilter.h> 951da177e4SLinus Torvalds 961da177e4SLinus Torvalds static int sock_no_open(struct inode *irrelevant, struct file *dontcare); 97027445c3SBadari Pulavarty static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov, 98027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos); 99027445c3SBadari Pulavarty static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov, 100027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos); 1011da177e4SLinus Torvalds static int sock_mmap(struct file *file, struct vm_area_struct *vma); 1021da177e4SLinus Torvalds 1031da177e4SLinus Torvalds static int sock_close(struct inode *inode, struct file *file); 1041da177e4SLinus Torvalds static unsigned int sock_poll(struct file *file, 1051da177e4SLinus Torvalds struct poll_table_struct *wait); 10689bddce5SStephen Hemminger static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg); 10789bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 10889bbfc95SShaun Pereira static long compat_sock_ioctl(struct file *file, 10989bbfc95SShaun Pereira unsigned int cmd, unsigned long arg); 11089bbfc95SShaun Pereira #endif 1111da177e4SLinus Torvalds static int sock_fasync(int fd, struct file *filp, int on); 1121da177e4SLinus Torvalds static ssize_t sock_sendpage(struct file *file, struct page *page, 1131da177e4SLinus Torvalds int offset, size_t size, loff_t *ppos, int more); 1141da177e4SLinus Torvalds 1151da177e4SLinus Torvalds /* 1161da177e4SLinus Torvalds * Socket files have a set of 'special' operations as well as the generic file ones. These don't appear 1171da177e4SLinus Torvalds * in the operation structures but are done directly via the socketcall() multiplexor. 1181da177e4SLinus Torvalds */ 1191da177e4SLinus Torvalds 120da7071d7SArjan van de Ven static const struct file_operations socket_file_ops = { 1211da177e4SLinus Torvalds .owner = THIS_MODULE, 1221da177e4SLinus Torvalds .llseek = no_llseek, 1231da177e4SLinus Torvalds .aio_read = sock_aio_read, 1241da177e4SLinus Torvalds .aio_write = sock_aio_write, 1251da177e4SLinus Torvalds .poll = sock_poll, 1261da177e4SLinus Torvalds .unlocked_ioctl = sock_ioctl, 12789bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 12889bbfc95SShaun Pereira .compat_ioctl = compat_sock_ioctl, 12989bbfc95SShaun Pereira #endif 1301da177e4SLinus Torvalds .mmap = sock_mmap, 1311da177e4SLinus Torvalds .open = sock_no_open, /* special open code to disallow open via /proc */ 1321da177e4SLinus Torvalds .release = sock_close, 1331da177e4SLinus Torvalds .fasync = sock_fasync, 1345274f052SJens Axboe .sendpage = sock_sendpage, 1355274f052SJens Axboe .splice_write = generic_splice_sendpage, 1361da177e4SLinus Torvalds }; 1371da177e4SLinus Torvalds 1381da177e4SLinus Torvalds /* 1391da177e4SLinus Torvalds * The protocol list. Each protocol is registered in here. 1401da177e4SLinus Torvalds */ 1411da177e4SLinus Torvalds 1421da177e4SLinus Torvalds static DEFINE_SPINLOCK(net_family_lock); 143f0fd27d4SStephen Hemminger static const struct net_proto_family *net_families[NPROTO] __read_mostly; 1441da177e4SLinus Torvalds 1451da177e4SLinus Torvalds /* 1461da177e4SLinus Torvalds * Statistics counters of the socket lists 1471da177e4SLinus Torvalds */ 1481da177e4SLinus Torvalds 1491da177e4SLinus Torvalds static DEFINE_PER_CPU(int, sockets_in_use) = 0; 1501da177e4SLinus Torvalds 1511da177e4SLinus Torvalds /* 15289bddce5SStephen Hemminger * Support routines. 15389bddce5SStephen Hemminger * Move socket addresses back and forth across the kernel/user 1541da177e4SLinus Torvalds * divide and look after the messy bits. 1551da177e4SLinus Torvalds */ 1561da177e4SLinus Torvalds 1571da177e4SLinus Torvalds #define MAX_SOCK_ADDR 128 /* 108 for Unix domain - 1581da177e4SLinus Torvalds 16 for IP, 16 for IPX, 1591da177e4SLinus Torvalds 24 for IPv6, 1601da177e4SLinus Torvalds about 80 for AX.25 1611da177e4SLinus Torvalds must be at least one bigger than 1621da177e4SLinus Torvalds the AF_UNIX size (see net/unix/af_unix.c 1631da177e4SLinus Torvalds :unix_mkname()). 1641da177e4SLinus Torvalds */ 1651da177e4SLinus Torvalds 1661da177e4SLinus Torvalds /** 1671da177e4SLinus Torvalds * move_addr_to_kernel - copy a socket address into kernel space 1681da177e4SLinus Torvalds * @uaddr: Address in user space 1691da177e4SLinus Torvalds * @kaddr: Address in kernel space 1701da177e4SLinus Torvalds * @ulen: Length in user space 1711da177e4SLinus Torvalds * 1721da177e4SLinus Torvalds * The address is copied into kernel space. If the provided address is 1731da177e4SLinus Torvalds * too long an error code of -EINVAL is returned. If the copy gives 1741da177e4SLinus Torvalds * invalid addresses -EFAULT is returned. On a success 0 is returned. 1751da177e4SLinus Torvalds */ 1761da177e4SLinus Torvalds 1771da177e4SLinus Torvalds int move_addr_to_kernel(void __user *uaddr, int ulen, void *kaddr) 1781da177e4SLinus Torvalds { 1791da177e4SLinus Torvalds if (ulen < 0 || ulen > MAX_SOCK_ADDR) 1801da177e4SLinus Torvalds return -EINVAL; 1811da177e4SLinus Torvalds if (ulen == 0) 1821da177e4SLinus Torvalds return 0; 1831da177e4SLinus Torvalds if (copy_from_user(kaddr, uaddr, ulen)) 1841da177e4SLinus Torvalds return -EFAULT; 1853ec3b2fbSDavid Woodhouse return audit_sockaddr(ulen, kaddr); 1861da177e4SLinus Torvalds } 1871da177e4SLinus Torvalds 1881da177e4SLinus Torvalds /** 1891da177e4SLinus Torvalds * move_addr_to_user - copy an address to user space 1901da177e4SLinus Torvalds * @kaddr: kernel space address 1911da177e4SLinus Torvalds * @klen: length of address in kernel 1921da177e4SLinus Torvalds * @uaddr: user space address 1931da177e4SLinus Torvalds * @ulen: pointer to user length field 1941da177e4SLinus Torvalds * 1951da177e4SLinus Torvalds * The value pointed to by ulen on entry is the buffer length available. 1961da177e4SLinus Torvalds * This is overwritten with the buffer space used. -EINVAL is returned 1971da177e4SLinus Torvalds * if an overlong buffer is specified or a negative buffer size. -EFAULT 1981da177e4SLinus Torvalds * is returned if either the buffer or the length field are not 1991da177e4SLinus Torvalds * accessible. 2001da177e4SLinus Torvalds * After copying the data up to the limit the user specifies, the true 2011da177e4SLinus Torvalds * length of the data is written over the length limit the user 2021da177e4SLinus Torvalds * specified. Zero is returned for a success. 2031da177e4SLinus Torvalds */ 2041da177e4SLinus Torvalds 20589bddce5SStephen Hemminger int move_addr_to_user(void *kaddr, int klen, void __user *uaddr, 20689bddce5SStephen Hemminger int __user *ulen) 2071da177e4SLinus Torvalds { 2081da177e4SLinus Torvalds int err; 2091da177e4SLinus Torvalds int len; 2101da177e4SLinus Torvalds 21189bddce5SStephen Hemminger err = get_user(len, ulen); 21289bddce5SStephen Hemminger if (err) 2131da177e4SLinus Torvalds return err; 2141da177e4SLinus Torvalds if (len > klen) 2151da177e4SLinus Torvalds len = klen; 2161da177e4SLinus Torvalds if (len < 0 || len > MAX_SOCK_ADDR) 2171da177e4SLinus Torvalds return -EINVAL; 21889bddce5SStephen Hemminger if (len) { 219d6fe3945SSteve Grubb if (audit_sockaddr(klen, kaddr)) 220d6fe3945SSteve Grubb return -ENOMEM; 2211da177e4SLinus Torvalds if (copy_to_user(uaddr, kaddr, len)) 2221da177e4SLinus Torvalds return -EFAULT; 2231da177e4SLinus Torvalds } 2241da177e4SLinus Torvalds /* 2251da177e4SLinus Torvalds * "fromlen shall refer to the value before truncation.." 2261da177e4SLinus Torvalds * 1003.1g 2271da177e4SLinus Torvalds */ 2281da177e4SLinus Torvalds return __put_user(klen, ulen); 2291da177e4SLinus Torvalds } 2301da177e4SLinus Torvalds 2311da177e4SLinus Torvalds #define SOCKFS_MAGIC 0x534F434B 2321da177e4SLinus Torvalds 233e18b890bSChristoph Lameter static struct kmem_cache *sock_inode_cachep __read_mostly; 2341da177e4SLinus Torvalds 2351da177e4SLinus Torvalds static struct inode *sock_alloc_inode(struct super_block *sb) 2361da177e4SLinus Torvalds { 2371da177e4SLinus Torvalds struct socket_alloc *ei; 23889bddce5SStephen Hemminger 239e94b1766SChristoph Lameter ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL); 2401da177e4SLinus Torvalds if (!ei) 2411da177e4SLinus Torvalds return NULL; 2421da177e4SLinus Torvalds init_waitqueue_head(&ei->socket.wait); 2431da177e4SLinus Torvalds 2441da177e4SLinus Torvalds ei->socket.fasync_list = NULL; 2451da177e4SLinus Torvalds ei->socket.state = SS_UNCONNECTED; 2461da177e4SLinus Torvalds ei->socket.flags = 0; 2471da177e4SLinus Torvalds ei->socket.ops = NULL; 2481da177e4SLinus Torvalds ei->socket.sk = NULL; 2491da177e4SLinus Torvalds ei->socket.file = NULL; 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds return &ei->vfs_inode; 2521da177e4SLinus Torvalds } 2531da177e4SLinus Torvalds 2541da177e4SLinus Torvalds static void sock_destroy_inode(struct inode *inode) 2551da177e4SLinus Torvalds { 2561da177e4SLinus Torvalds kmem_cache_free(sock_inode_cachep, 2571da177e4SLinus Torvalds container_of(inode, struct socket_alloc, vfs_inode)); 2581da177e4SLinus Torvalds } 2591da177e4SLinus Torvalds 260e18b890bSChristoph Lameter static void init_once(void *foo, struct kmem_cache *cachep, unsigned long flags) 2611da177e4SLinus Torvalds { 2621da177e4SLinus Torvalds struct socket_alloc *ei = (struct socket_alloc *)foo; 2631da177e4SLinus Torvalds 2641da177e4SLinus Torvalds inode_init_once(&ei->vfs_inode); 2651da177e4SLinus Torvalds } 2661da177e4SLinus Torvalds 2671da177e4SLinus Torvalds static int init_inodecache(void) 2681da177e4SLinus Torvalds { 2691da177e4SLinus Torvalds sock_inode_cachep = kmem_cache_create("sock_inode_cache", 2701da177e4SLinus Torvalds sizeof(struct socket_alloc), 27189bddce5SStephen Hemminger 0, 27289bddce5SStephen Hemminger (SLAB_HWCACHE_ALIGN | 27389bddce5SStephen Hemminger SLAB_RECLAIM_ACCOUNT | 274fffb60f9SPaul Jackson SLAB_MEM_SPREAD), 275*20c2df83SPaul Mundt init_once); 2761da177e4SLinus Torvalds if (sock_inode_cachep == NULL) 2771da177e4SLinus Torvalds return -ENOMEM; 2781da177e4SLinus Torvalds return 0; 2791da177e4SLinus Torvalds } 2801da177e4SLinus Torvalds 2811da177e4SLinus Torvalds static struct super_operations sockfs_ops = { 2821da177e4SLinus Torvalds .alloc_inode = sock_alloc_inode, 2831da177e4SLinus Torvalds .destroy_inode =sock_destroy_inode, 2841da177e4SLinus Torvalds .statfs = simple_statfs, 2851da177e4SLinus Torvalds }; 2861da177e4SLinus Torvalds 287454e2398SDavid Howells static int sockfs_get_sb(struct file_system_type *fs_type, 28889bddce5SStephen Hemminger int flags, const char *dev_name, void *data, 28989bddce5SStephen Hemminger struct vfsmount *mnt) 2901da177e4SLinus Torvalds { 291454e2398SDavid Howells return get_sb_pseudo(fs_type, "socket:", &sockfs_ops, SOCKFS_MAGIC, 292454e2398SDavid Howells mnt); 2931da177e4SLinus Torvalds } 2941da177e4SLinus Torvalds 295ba89966cSEric Dumazet static struct vfsmount *sock_mnt __read_mostly; 2961da177e4SLinus Torvalds 2971da177e4SLinus Torvalds static struct file_system_type sock_fs_type = { 2981da177e4SLinus Torvalds .name = "sockfs", 2991da177e4SLinus Torvalds .get_sb = sockfs_get_sb, 3001da177e4SLinus Torvalds .kill_sb = kill_anon_super, 3011da177e4SLinus Torvalds }; 30289bddce5SStephen Hemminger 3031da177e4SLinus Torvalds static int sockfs_delete_dentry(struct dentry *dentry) 3041da177e4SLinus Torvalds { 305304e61e6SEric Dumazet /* 306304e61e6SEric Dumazet * At creation time, we pretended this dentry was hashed 307304e61e6SEric Dumazet * (by clearing DCACHE_UNHASHED bit in d_flags) 308304e61e6SEric Dumazet * At delete time, we restore the truth : not hashed. 309304e61e6SEric Dumazet * (so that dput() can proceed correctly) 310304e61e6SEric Dumazet */ 311304e61e6SEric Dumazet dentry->d_flags |= DCACHE_UNHASHED; 312304e61e6SEric Dumazet return 0; 3131da177e4SLinus Torvalds } 314c23fbb6bSEric Dumazet 315c23fbb6bSEric Dumazet /* 316c23fbb6bSEric Dumazet * sockfs_dname() is called from d_path(). 317c23fbb6bSEric Dumazet */ 318c23fbb6bSEric Dumazet static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen) 319c23fbb6bSEric Dumazet { 320c23fbb6bSEric Dumazet return dynamic_dname(dentry, buffer, buflen, "socket:[%lu]", 321c23fbb6bSEric Dumazet dentry->d_inode->i_ino); 322c23fbb6bSEric Dumazet } 323c23fbb6bSEric Dumazet 3241da177e4SLinus Torvalds static struct dentry_operations sockfs_dentry_operations = { 3251da177e4SLinus Torvalds .d_delete = sockfs_delete_dentry, 326c23fbb6bSEric Dumazet .d_dname = sockfs_dname, 3271da177e4SLinus Torvalds }; 3281da177e4SLinus Torvalds 3291da177e4SLinus Torvalds /* 3301da177e4SLinus Torvalds * Obtains the first available file descriptor and sets it up for use. 3311da177e4SLinus Torvalds * 33239d8c1b6SDavid S. Miller * These functions create file structures and maps them to fd space 33339d8c1b6SDavid S. Miller * of the current process. On success it returns file descriptor 3341da177e4SLinus Torvalds * and file struct implicitly stored in sock->file. 3351da177e4SLinus Torvalds * Note that another thread may close file descriptor before we return 3361da177e4SLinus Torvalds * from this function. We use the fact that now we do not refer 3371da177e4SLinus Torvalds * to socket after mapping. If one day we will need it, this 3381da177e4SLinus Torvalds * function will increment ref. count on file by 1. 3391da177e4SLinus Torvalds * 3401da177e4SLinus Torvalds * In any case returned fd MAY BE not valid! 3411da177e4SLinus Torvalds * This race condition is unavoidable 3421da177e4SLinus Torvalds * with shared fd spaces, we cannot solve it inside kernel, 3431da177e4SLinus Torvalds * but we take care of internal coherence yet. 3441da177e4SLinus Torvalds */ 3451da177e4SLinus Torvalds 34639d8c1b6SDavid S. Miller static int sock_alloc_fd(struct file **filep) 3471da177e4SLinus Torvalds { 3481da177e4SLinus Torvalds int fd; 3491da177e4SLinus Torvalds 3501da177e4SLinus Torvalds fd = get_unused_fd(); 35139d8c1b6SDavid S. Miller if (likely(fd >= 0)) { 3521da177e4SLinus Torvalds struct file *file = get_empty_filp(); 3531da177e4SLinus Torvalds 35439d8c1b6SDavid S. Miller *filep = file; 35539d8c1b6SDavid S. Miller if (unlikely(!file)) { 3561da177e4SLinus Torvalds put_unused_fd(fd); 35739d8c1b6SDavid S. Miller return -ENFILE; 3581da177e4SLinus Torvalds } 35939d8c1b6SDavid S. Miller } else 36039d8c1b6SDavid S. Miller *filep = NULL; 36139d8c1b6SDavid S. Miller return fd; 36239d8c1b6SDavid S. Miller } 36339d8c1b6SDavid S. Miller 36439d8c1b6SDavid S. Miller static int sock_attach_fd(struct socket *sock, struct file *file) 36539d8c1b6SDavid S. Miller { 366c23fbb6bSEric Dumazet struct qstr name = { .name = "" }; 3671da177e4SLinus Torvalds 368c23fbb6bSEric Dumazet file->f_path.dentry = d_alloc(sock_mnt->mnt_sb->s_root, &name); 3693126a42cSJosef Sipek if (unlikely(!file->f_path.dentry)) 37039d8c1b6SDavid S. Miller return -ENOMEM; 37139d8c1b6SDavid S. Miller 3723126a42cSJosef Sipek file->f_path.dentry->d_op = &sockfs_dentry_operations; 373304e61e6SEric Dumazet /* 374304e61e6SEric Dumazet * We dont want to push this dentry into global dentry hash table. 375304e61e6SEric Dumazet * We pretend dentry is already hashed, by unsetting DCACHE_UNHASHED 376304e61e6SEric Dumazet * This permits a working /proc/$pid/fd/XXX on sockets 377304e61e6SEric Dumazet */ 3783126a42cSJosef Sipek file->f_path.dentry->d_flags &= ~DCACHE_UNHASHED; 3793126a42cSJosef Sipek d_instantiate(file->f_path.dentry, SOCK_INODE(sock)); 3803126a42cSJosef Sipek file->f_path.mnt = mntget(sock_mnt); 3813126a42cSJosef Sipek file->f_mapping = file->f_path.dentry->d_inode->i_mapping; 3821da177e4SLinus Torvalds 3831da177e4SLinus Torvalds sock->file = file; 3841da177e4SLinus Torvalds file->f_op = SOCK_INODE(sock)->i_fop = &socket_file_ops; 3851da177e4SLinus Torvalds file->f_mode = FMODE_READ | FMODE_WRITE; 3861da177e4SLinus Torvalds file->f_flags = O_RDWR; 3871da177e4SLinus Torvalds file->f_pos = 0; 38807dc3f07SBenjamin LaHaise file->private_data = sock; 38939d8c1b6SDavid S. Miller 39039d8c1b6SDavid S. Miller return 0; 3911da177e4SLinus Torvalds } 3921da177e4SLinus Torvalds 39339d8c1b6SDavid S. Miller int sock_map_fd(struct socket *sock) 39439d8c1b6SDavid S. Miller { 39539d8c1b6SDavid S. Miller struct file *newfile; 39639d8c1b6SDavid S. Miller int fd = sock_alloc_fd(&newfile); 39739d8c1b6SDavid S. Miller 39839d8c1b6SDavid S. Miller if (likely(fd >= 0)) { 39939d8c1b6SDavid S. Miller int err = sock_attach_fd(sock, newfile); 40039d8c1b6SDavid S. Miller 40139d8c1b6SDavid S. Miller if (unlikely(err < 0)) { 40239d8c1b6SDavid S. Miller put_filp(newfile); 40339d8c1b6SDavid S. Miller put_unused_fd(fd); 40439d8c1b6SDavid S. Miller return err; 40539d8c1b6SDavid S. Miller } 40639d8c1b6SDavid S. Miller fd_install(fd, newfile); 40739d8c1b6SDavid S. Miller } 4081da177e4SLinus Torvalds return fd; 4091da177e4SLinus Torvalds } 4101da177e4SLinus Torvalds 4116cb153caSBenjamin LaHaise static struct socket *sock_from_file(struct file *file, int *err) 4126cb153caSBenjamin LaHaise { 4136cb153caSBenjamin LaHaise if (file->f_op == &socket_file_ops) 4146cb153caSBenjamin LaHaise return file->private_data; /* set in sock_map_fd */ 4156cb153caSBenjamin LaHaise 4166cb153caSBenjamin LaHaise *err = -ENOTSOCK; 4176cb153caSBenjamin LaHaise return NULL; 4186cb153caSBenjamin LaHaise } 4196cb153caSBenjamin LaHaise 4201da177e4SLinus Torvalds /** 4211da177e4SLinus Torvalds * sockfd_lookup - Go from a file number to its socket slot 4221da177e4SLinus Torvalds * @fd: file handle 4231da177e4SLinus Torvalds * @err: pointer to an error code return 4241da177e4SLinus Torvalds * 4251da177e4SLinus Torvalds * The file handle passed in is locked and the socket it is bound 4261da177e4SLinus Torvalds * too is returned. If an error occurs the err pointer is overwritten 4271da177e4SLinus Torvalds * with a negative errno code and NULL is returned. The function checks 4281da177e4SLinus Torvalds * for both invalid handles and passing a handle which is not a socket. 4291da177e4SLinus Torvalds * 4301da177e4SLinus Torvalds * On a success the socket object pointer is returned. 4311da177e4SLinus Torvalds */ 4321da177e4SLinus Torvalds 4331da177e4SLinus Torvalds struct socket *sockfd_lookup(int fd, int *err) 4341da177e4SLinus Torvalds { 4351da177e4SLinus Torvalds struct file *file; 4361da177e4SLinus Torvalds struct socket *sock; 4371da177e4SLinus Torvalds 43889bddce5SStephen Hemminger file = fget(fd); 43989bddce5SStephen Hemminger if (!file) { 4401da177e4SLinus Torvalds *err = -EBADF; 4411da177e4SLinus Torvalds return NULL; 4421da177e4SLinus Torvalds } 44389bddce5SStephen Hemminger 4446cb153caSBenjamin LaHaise sock = sock_from_file(file, err); 4456cb153caSBenjamin LaHaise if (!sock) 4461da177e4SLinus Torvalds fput(file); 4476cb153caSBenjamin LaHaise return sock; 4481da177e4SLinus Torvalds } 4491da177e4SLinus Torvalds 4506cb153caSBenjamin LaHaise static struct socket *sockfd_lookup_light(int fd, int *err, int *fput_needed) 4516cb153caSBenjamin LaHaise { 4526cb153caSBenjamin LaHaise struct file *file; 4536cb153caSBenjamin LaHaise struct socket *sock; 4546cb153caSBenjamin LaHaise 4553672558cSHua Zhong *err = -EBADF; 4566cb153caSBenjamin LaHaise file = fget_light(fd, fput_needed); 4576cb153caSBenjamin LaHaise if (file) { 4586cb153caSBenjamin LaHaise sock = sock_from_file(file, err); 4596cb153caSBenjamin LaHaise if (sock) 4601da177e4SLinus Torvalds return sock; 4616cb153caSBenjamin LaHaise fput_light(file, *fput_needed); 4626cb153caSBenjamin LaHaise } 4636cb153caSBenjamin LaHaise return NULL; 4641da177e4SLinus Torvalds } 4651da177e4SLinus Torvalds 4661da177e4SLinus Torvalds /** 4671da177e4SLinus Torvalds * sock_alloc - allocate a socket 4681da177e4SLinus Torvalds * 4691da177e4SLinus Torvalds * Allocate a new inode and socket object. The two are bound together 4701da177e4SLinus Torvalds * and initialised. The socket is then returned. If we are out of inodes 4711da177e4SLinus Torvalds * NULL is returned. 4721da177e4SLinus Torvalds */ 4731da177e4SLinus Torvalds 4741da177e4SLinus Torvalds static struct socket *sock_alloc(void) 4751da177e4SLinus Torvalds { 4761da177e4SLinus Torvalds struct inode *inode; 4771da177e4SLinus Torvalds struct socket *sock; 4781da177e4SLinus Torvalds 4791da177e4SLinus Torvalds inode = new_inode(sock_mnt->mnt_sb); 4801da177e4SLinus Torvalds if (!inode) 4811da177e4SLinus Torvalds return NULL; 4821da177e4SLinus Torvalds 4831da177e4SLinus Torvalds sock = SOCKET_I(inode); 4841da177e4SLinus Torvalds 4851da177e4SLinus Torvalds inode->i_mode = S_IFSOCK | S_IRWXUGO; 4861da177e4SLinus Torvalds inode->i_uid = current->fsuid; 4871da177e4SLinus Torvalds inode->i_gid = current->fsgid; 4881da177e4SLinus Torvalds 4891da177e4SLinus Torvalds get_cpu_var(sockets_in_use)++; 4901da177e4SLinus Torvalds put_cpu_var(sockets_in_use); 4911da177e4SLinus Torvalds return sock; 4921da177e4SLinus Torvalds } 4931da177e4SLinus Torvalds 4941da177e4SLinus Torvalds /* 4951da177e4SLinus Torvalds * In theory you can't get an open on this inode, but /proc provides 4961da177e4SLinus Torvalds * a back door. Remember to keep it shut otherwise you'll let the 4971da177e4SLinus Torvalds * creepy crawlies in. 4981da177e4SLinus Torvalds */ 4991da177e4SLinus Torvalds 5001da177e4SLinus Torvalds static int sock_no_open(struct inode *irrelevant, struct file *dontcare) 5011da177e4SLinus Torvalds { 5021da177e4SLinus Torvalds return -ENXIO; 5031da177e4SLinus Torvalds } 5041da177e4SLinus Torvalds 5054b6f5d20SArjan van de Ven const struct file_operations bad_sock_fops = { 5061da177e4SLinus Torvalds .owner = THIS_MODULE, 5071da177e4SLinus Torvalds .open = sock_no_open, 5081da177e4SLinus Torvalds }; 5091da177e4SLinus Torvalds 5101da177e4SLinus Torvalds /** 5111da177e4SLinus Torvalds * sock_release - close a socket 5121da177e4SLinus Torvalds * @sock: socket to close 5131da177e4SLinus Torvalds * 5141da177e4SLinus Torvalds * The socket is released from the protocol stack if it has a release 5151da177e4SLinus Torvalds * callback, and the inode is then released if the socket is bound to 5161da177e4SLinus Torvalds * an inode not a file. 5171da177e4SLinus Torvalds */ 5181da177e4SLinus Torvalds 5191da177e4SLinus Torvalds void sock_release(struct socket *sock) 5201da177e4SLinus Torvalds { 5211da177e4SLinus Torvalds if (sock->ops) { 5221da177e4SLinus Torvalds struct module *owner = sock->ops->owner; 5231da177e4SLinus Torvalds 5241da177e4SLinus Torvalds sock->ops->release(sock); 5251da177e4SLinus Torvalds sock->ops = NULL; 5261da177e4SLinus Torvalds module_put(owner); 5271da177e4SLinus Torvalds } 5281da177e4SLinus Torvalds 5291da177e4SLinus Torvalds if (sock->fasync_list) 5301da177e4SLinus Torvalds printk(KERN_ERR "sock_release: fasync list not empty!\n"); 5311da177e4SLinus Torvalds 5321da177e4SLinus Torvalds get_cpu_var(sockets_in_use)--; 5331da177e4SLinus Torvalds put_cpu_var(sockets_in_use); 5341da177e4SLinus Torvalds if (!sock->file) { 5351da177e4SLinus Torvalds iput(SOCK_INODE(sock)); 5361da177e4SLinus Torvalds return; 5371da177e4SLinus Torvalds } 5381da177e4SLinus Torvalds sock->file = NULL; 5391da177e4SLinus Torvalds } 5401da177e4SLinus Torvalds 5411da177e4SLinus Torvalds static inline int __sock_sendmsg(struct kiocb *iocb, struct socket *sock, 5421da177e4SLinus Torvalds struct msghdr *msg, size_t size) 5431da177e4SLinus Torvalds { 5441da177e4SLinus Torvalds struct sock_iocb *si = kiocb_to_siocb(iocb); 5451da177e4SLinus Torvalds int err; 5461da177e4SLinus Torvalds 5471da177e4SLinus Torvalds si->sock = sock; 5481da177e4SLinus Torvalds si->scm = NULL; 5491da177e4SLinus Torvalds si->msg = msg; 5501da177e4SLinus Torvalds si->size = size; 5511da177e4SLinus Torvalds 5521da177e4SLinus Torvalds err = security_socket_sendmsg(sock, msg, size); 5531da177e4SLinus Torvalds if (err) 5541da177e4SLinus Torvalds return err; 5551da177e4SLinus Torvalds 5561da177e4SLinus Torvalds return sock->ops->sendmsg(iocb, sock, msg, size); 5571da177e4SLinus Torvalds } 5581da177e4SLinus Torvalds 5591da177e4SLinus Torvalds int sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t size) 5601da177e4SLinus Torvalds { 5611da177e4SLinus Torvalds struct kiocb iocb; 5621da177e4SLinus Torvalds struct sock_iocb siocb; 5631da177e4SLinus Torvalds int ret; 5641da177e4SLinus Torvalds 5651da177e4SLinus Torvalds init_sync_kiocb(&iocb, NULL); 5661da177e4SLinus Torvalds iocb.private = &siocb; 5671da177e4SLinus Torvalds ret = __sock_sendmsg(&iocb, sock, msg, size); 5681da177e4SLinus Torvalds if (-EIOCBQUEUED == ret) 5691da177e4SLinus Torvalds ret = wait_on_sync_kiocb(&iocb); 5701da177e4SLinus Torvalds return ret; 5711da177e4SLinus Torvalds } 5721da177e4SLinus Torvalds 5731da177e4SLinus Torvalds int kernel_sendmsg(struct socket *sock, struct msghdr *msg, 5741da177e4SLinus Torvalds struct kvec *vec, size_t num, size_t size) 5751da177e4SLinus Torvalds { 5761da177e4SLinus Torvalds mm_segment_t oldfs = get_fs(); 5771da177e4SLinus Torvalds int result; 5781da177e4SLinus Torvalds 5791da177e4SLinus Torvalds set_fs(KERNEL_DS); 5801da177e4SLinus Torvalds /* 5811da177e4SLinus Torvalds * the following is safe, since for compiler definitions of kvec and 5821da177e4SLinus Torvalds * iovec are identical, yielding the same in-core layout and alignment 5831da177e4SLinus Torvalds */ 58489bddce5SStephen Hemminger msg->msg_iov = (struct iovec *)vec; 5851da177e4SLinus Torvalds msg->msg_iovlen = num; 5861da177e4SLinus Torvalds result = sock_sendmsg(sock, msg, size); 5871da177e4SLinus Torvalds set_fs(oldfs); 5881da177e4SLinus Torvalds return result; 5891da177e4SLinus Torvalds } 5901da177e4SLinus Torvalds 59192f37fd2SEric Dumazet /* 59292f37fd2SEric Dumazet * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP) 59392f37fd2SEric Dumazet */ 59492f37fd2SEric Dumazet void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk, 59592f37fd2SEric Dumazet struct sk_buff *skb) 59692f37fd2SEric Dumazet { 59792f37fd2SEric Dumazet ktime_t kt = skb->tstamp; 59892f37fd2SEric Dumazet 59992f37fd2SEric Dumazet if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) { 60092f37fd2SEric Dumazet struct timeval tv; 60192f37fd2SEric Dumazet /* Race occurred between timestamp enabling and packet 60292f37fd2SEric Dumazet receiving. Fill in the current time for now. */ 60392f37fd2SEric Dumazet if (kt.tv64 == 0) 60492f37fd2SEric Dumazet kt = ktime_get_real(); 60592f37fd2SEric Dumazet skb->tstamp = kt; 60692f37fd2SEric Dumazet tv = ktime_to_timeval(kt); 60792f37fd2SEric Dumazet put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP, sizeof(tv), &tv); 60892f37fd2SEric Dumazet } else { 60992f37fd2SEric Dumazet struct timespec ts; 61092f37fd2SEric Dumazet /* Race occurred between timestamp enabling and packet 61192f37fd2SEric Dumazet receiving. Fill in the current time for now. */ 61292f37fd2SEric Dumazet if (kt.tv64 == 0) 61392f37fd2SEric Dumazet kt = ktime_get_real(); 61492f37fd2SEric Dumazet skb->tstamp = kt; 61592f37fd2SEric Dumazet ts = ktime_to_timespec(kt); 61692f37fd2SEric Dumazet put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS, sizeof(ts), &ts); 61792f37fd2SEric Dumazet } 61892f37fd2SEric Dumazet } 61992f37fd2SEric Dumazet 6207c81fd8bSArnaldo Carvalho de Melo EXPORT_SYMBOL_GPL(__sock_recv_timestamp); 6217c81fd8bSArnaldo Carvalho de Melo 6221da177e4SLinus Torvalds static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock, 6231da177e4SLinus Torvalds struct msghdr *msg, size_t size, int flags) 6241da177e4SLinus Torvalds { 6251da177e4SLinus Torvalds int err; 6261da177e4SLinus Torvalds struct sock_iocb *si = kiocb_to_siocb(iocb); 6271da177e4SLinus Torvalds 6281da177e4SLinus Torvalds si->sock = sock; 6291da177e4SLinus Torvalds si->scm = NULL; 6301da177e4SLinus Torvalds si->msg = msg; 6311da177e4SLinus Torvalds si->size = size; 6321da177e4SLinus Torvalds si->flags = flags; 6331da177e4SLinus Torvalds 6341da177e4SLinus Torvalds err = security_socket_recvmsg(sock, msg, size, flags); 6351da177e4SLinus Torvalds if (err) 6361da177e4SLinus Torvalds return err; 6371da177e4SLinus Torvalds 6381da177e4SLinus Torvalds return sock->ops->recvmsg(iocb, sock, msg, size, flags); 6391da177e4SLinus Torvalds } 6401da177e4SLinus Torvalds 6411da177e4SLinus Torvalds int sock_recvmsg(struct socket *sock, struct msghdr *msg, 6421da177e4SLinus Torvalds size_t size, int flags) 6431da177e4SLinus Torvalds { 6441da177e4SLinus Torvalds struct kiocb iocb; 6451da177e4SLinus Torvalds struct sock_iocb siocb; 6461da177e4SLinus Torvalds int ret; 6471da177e4SLinus Torvalds 6481da177e4SLinus Torvalds init_sync_kiocb(&iocb, NULL); 6491da177e4SLinus Torvalds iocb.private = &siocb; 6501da177e4SLinus Torvalds ret = __sock_recvmsg(&iocb, sock, msg, size, flags); 6511da177e4SLinus Torvalds if (-EIOCBQUEUED == ret) 6521da177e4SLinus Torvalds ret = wait_on_sync_kiocb(&iocb); 6531da177e4SLinus Torvalds return ret; 6541da177e4SLinus Torvalds } 6551da177e4SLinus Torvalds 6561da177e4SLinus Torvalds int kernel_recvmsg(struct socket *sock, struct msghdr *msg, 65789bddce5SStephen Hemminger struct kvec *vec, size_t num, size_t size, int flags) 6581da177e4SLinus Torvalds { 6591da177e4SLinus Torvalds mm_segment_t oldfs = get_fs(); 6601da177e4SLinus Torvalds int result; 6611da177e4SLinus Torvalds 6621da177e4SLinus Torvalds set_fs(KERNEL_DS); 6631da177e4SLinus Torvalds /* 6641da177e4SLinus Torvalds * the following is safe, since for compiler definitions of kvec and 6651da177e4SLinus Torvalds * iovec are identical, yielding the same in-core layout and alignment 6661da177e4SLinus Torvalds */ 66789bddce5SStephen Hemminger msg->msg_iov = (struct iovec *)vec, msg->msg_iovlen = num; 6681da177e4SLinus Torvalds result = sock_recvmsg(sock, msg, size, flags); 6691da177e4SLinus Torvalds set_fs(oldfs); 6701da177e4SLinus Torvalds return result; 6711da177e4SLinus Torvalds } 6721da177e4SLinus Torvalds 6731da177e4SLinus Torvalds static void sock_aio_dtor(struct kiocb *iocb) 6741da177e4SLinus Torvalds { 6751da177e4SLinus Torvalds kfree(iocb->private); 6761da177e4SLinus Torvalds } 6771da177e4SLinus Torvalds 67820380731SArnaldo Carvalho de Melo static ssize_t sock_sendpage(struct file *file, struct page *page, 6791da177e4SLinus Torvalds int offset, size_t size, loff_t *ppos, int more) 6801da177e4SLinus Torvalds { 6811da177e4SLinus Torvalds struct socket *sock; 6821da177e4SLinus Torvalds int flags; 6831da177e4SLinus Torvalds 684b69aee04SEric Dumazet sock = file->private_data; 6851da177e4SLinus Torvalds 6861da177e4SLinus Torvalds flags = !(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT; 6871da177e4SLinus Torvalds if (more) 6881da177e4SLinus Torvalds flags |= MSG_MORE; 6891da177e4SLinus Torvalds 6901da177e4SLinus Torvalds return sock->ops->sendpage(sock, page, offset, size, flags); 6911da177e4SLinus Torvalds } 6921da177e4SLinus Torvalds 693ce1d4d3eSChristoph Hellwig static struct sock_iocb *alloc_sock_iocb(struct kiocb *iocb, 69489bddce5SStephen Hemminger struct sock_iocb *siocb) 695ce1d4d3eSChristoph Hellwig { 696ce1d4d3eSChristoph Hellwig if (!is_sync_kiocb(iocb)) { 697ce1d4d3eSChristoph Hellwig siocb = kmalloc(sizeof(*siocb), GFP_KERNEL); 698ce1d4d3eSChristoph Hellwig if (!siocb) 699ce1d4d3eSChristoph Hellwig return NULL; 700ce1d4d3eSChristoph Hellwig iocb->ki_dtor = sock_aio_dtor; 701ce1d4d3eSChristoph Hellwig } 702ce1d4d3eSChristoph Hellwig 703ce1d4d3eSChristoph Hellwig siocb->kiocb = iocb; 704ce1d4d3eSChristoph Hellwig iocb->private = siocb; 705ce1d4d3eSChristoph Hellwig return siocb; 706ce1d4d3eSChristoph Hellwig } 707ce1d4d3eSChristoph Hellwig 708ce1d4d3eSChristoph Hellwig static ssize_t do_sock_read(struct msghdr *msg, struct kiocb *iocb, 709027445c3SBadari Pulavarty struct file *file, const struct iovec *iov, 71089bddce5SStephen Hemminger unsigned long nr_segs) 711ce1d4d3eSChristoph Hellwig { 712ce1d4d3eSChristoph Hellwig struct socket *sock = file->private_data; 713ce1d4d3eSChristoph Hellwig size_t size = 0; 714ce1d4d3eSChristoph Hellwig int i; 715ce1d4d3eSChristoph Hellwig 716ce1d4d3eSChristoph Hellwig for (i = 0; i < nr_segs; i++) 717ce1d4d3eSChristoph Hellwig size += iov[i].iov_len; 718ce1d4d3eSChristoph Hellwig 719ce1d4d3eSChristoph Hellwig msg->msg_name = NULL; 720ce1d4d3eSChristoph Hellwig msg->msg_namelen = 0; 721ce1d4d3eSChristoph Hellwig msg->msg_control = NULL; 722ce1d4d3eSChristoph Hellwig msg->msg_controllen = 0; 723ce1d4d3eSChristoph Hellwig msg->msg_iov = (struct iovec *)iov; 724ce1d4d3eSChristoph Hellwig msg->msg_iovlen = nr_segs; 725ce1d4d3eSChristoph Hellwig msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0; 726ce1d4d3eSChristoph Hellwig 727ce1d4d3eSChristoph Hellwig return __sock_recvmsg(iocb, sock, msg, size, msg->msg_flags); 728ce1d4d3eSChristoph Hellwig } 729ce1d4d3eSChristoph Hellwig 730027445c3SBadari Pulavarty static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov, 731027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos) 732ce1d4d3eSChristoph Hellwig { 733ce1d4d3eSChristoph Hellwig struct sock_iocb siocb, *x; 734ce1d4d3eSChristoph Hellwig 735ce1d4d3eSChristoph Hellwig if (pos != 0) 736ce1d4d3eSChristoph Hellwig return -ESPIPE; 737027445c3SBadari Pulavarty 738027445c3SBadari Pulavarty if (iocb->ki_left == 0) /* Match SYS5 behaviour */ 739ce1d4d3eSChristoph Hellwig return 0; 740ce1d4d3eSChristoph Hellwig 741027445c3SBadari Pulavarty 742027445c3SBadari Pulavarty x = alloc_sock_iocb(iocb, &siocb); 743ce1d4d3eSChristoph Hellwig if (!x) 744ce1d4d3eSChristoph Hellwig return -ENOMEM; 745027445c3SBadari Pulavarty return do_sock_read(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs); 746ce1d4d3eSChristoph Hellwig } 747ce1d4d3eSChristoph Hellwig 748ce1d4d3eSChristoph Hellwig static ssize_t do_sock_write(struct msghdr *msg, struct kiocb *iocb, 749027445c3SBadari Pulavarty struct file *file, const struct iovec *iov, 75089bddce5SStephen Hemminger unsigned long nr_segs) 751ce1d4d3eSChristoph Hellwig { 752ce1d4d3eSChristoph Hellwig struct socket *sock = file->private_data; 753ce1d4d3eSChristoph Hellwig size_t size = 0; 754ce1d4d3eSChristoph Hellwig int i; 755ce1d4d3eSChristoph Hellwig 756ce1d4d3eSChristoph Hellwig for (i = 0; i < nr_segs; i++) 757ce1d4d3eSChristoph Hellwig size += iov[i].iov_len; 758ce1d4d3eSChristoph Hellwig 759ce1d4d3eSChristoph Hellwig msg->msg_name = NULL; 760ce1d4d3eSChristoph Hellwig msg->msg_namelen = 0; 761ce1d4d3eSChristoph Hellwig msg->msg_control = NULL; 762ce1d4d3eSChristoph Hellwig msg->msg_controllen = 0; 763ce1d4d3eSChristoph Hellwig msg->msg_iov = (struct iovec *)iov; 764ce1d4d3eSChristoph Hellwig msg->msg_iovlen = nr_segs; 765ce1d4d3eSChristoph Hellwig msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0; 766ce1d4d3eSChristoph Hellwig if (sock->type == SOCK_SEQPACKET) 767ce1d4d3eSChristoph Hellwig msg->msg_flags |= MSG_EOR; 768ce1d4d3eSChristoph Hellwig 769ce1d4d3eSChristoph Hellwig return __sock_sendmsg(iocb, sock, msg, size); 770ce1d4d3eSChristoph Hellwig } 771ce1d4d3eSChristoph Hellwig 772027445c3SBadari Pulavarty static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov, 773027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos) 7741da177e4SLinus Torvalds { 775ce1d4d3eSChristoph Hellwig struct sock_iocb siocb, *x; 7761da177e4SLinus Torvalds 777ce1d4d3eSChristoph Hellwig if (pos != 0) 778ce1d4d3eSChristoph Hellwig return -ESPIPE; 779027445c3SBadari Pulavarty 780027445c3SBadari Pulavarty if (iocb->ki_left == 0) /* Match SYS5 behaviour */ 781ce1d4d3eSChristoph Hellwig return 0; 782ce1d4d3eSChristoph Hellwig 783027445c3SBadari Pulavarty x = alloc_sock_iocb(iocb, &siocb); 784ce1d4d3eSChristoph Hellwig if (!x) 785ce1d4d3eSChristoph Hellwig return -ENOMEM; 786ce1d4d3eSChristoph Hellwig 787027445c3SBadari Pulavarty return do_sock_write(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs); 7881da177e4SLinus Torvalds } 7891da177e4SLinus Torvalds 7901da177e4SLinus Torvalds /* 7911da177e4SLinus Torvalds * Atomic setting of ioctl hooks to avoid race 7921da177e4SLinus Torvalds * with module unload. 7931da177e4SLinus Torvalds */ 7941da177e4SLinus Torvalds 7954a3e2f71SArjan van de Ven static DEFINE_MUTEX(br_ioctl_mutex); 7961da177e4SLinus Torvalds static int (*br_ioctl_hook) (unsigned int cmd, void __user *arg) = NULL; 7971da177e4SLinus Torvalds 7981da177e4SLinus Torvalds void brioctl_set(int (*hook) (unsigned int, void __user *)) 7991da177e4SLinus Torvalds { 8004a3e2f71SArjan van de Ven mutex_lock(&br_ioctl_mutex); 8011da177e4SLinus Torvalds br_ioctl_hook = hook; 8024a3e2f71SArjan van de Ven mutex_unlock(&br_ioctl_mutex); 8031da177e4SLinus Torvalds } 80489bddce5SStephen Hemminger 8051da177e4SLinus Torvalds EXPORT_SYMBOL(brioctl_set); 8061da177e4SLinus Torvalds 8074a3e2f71SArjan van de Ven static DEFINE_MUTEX(vlan_ioctl_mutex); 8081da177e4SLinus Torvalds static int (*vlan_ioctl_hook) (void __user *arg); 8091da177e4SLinus Torvalds 8101da177e4SLinus Torvalds void vlan_ioctl_set(int (*hook) (void __user *)) 8111da177e4SLinus Torvalds { 8124a3e2f71SArjan van de Ven mutex_lock(&vlan_ioctl_mutex); 8131da177e4SLinus Torvalds vlan_ioctl_hook = hook; 8144a3e2f71SArjan van de Ven mutex_unlock(&vlan_ioctl_mutex); 8151da177e4SLinus Torvalds } 81689bddce5SStephen Hemminger 8171da177e4SLinus Torvalds EXPORT_SYMBOL(vlan_ioctl_set); 8181da177e4SLinus Torvalds 8194a3e2f71SArjan van de Ven static DEFINE_MUTEX(dlci_ioctl_mutex); 8201da177e4SLinus Torvalds static int (*dlci_ioctl_hook) (unsigned int, void __user *); 8211da177e4SLinus Torvalds 8221da177e4SLinus Torvalds void dlci_ioctl_set(int (*hook) (unsigned int, void __user *)) 8231da177e4SLinus Torvalds { 8244a3e2f71SArjan van de Ven mutex_lock(&dlci_ioctl_mutex); 8251da177e4SLinus Torvalds dlci_ioctl_hook = hook; 8264a3e2f71SArjan van de Ven mutex_unlock(&dlci_ioctl_mutex); 8271da177e4SLinus Torvalds } 82889bddce5SStephen Hemminger 8291da177e4SLinus Torvalds EXPORT_SYMBOL(dlci_ioctl_set); 8301da177e4SLinus Torvalds 8311da177e4SLinus Torvalds /* 8321da177e4SLinus Torvalds * With an ioctl, arg may well be a user mode pointer, but we don't know 8331da177e4SLinus Torvalds * what to do with it - that's up to the protocol still. 8341da177e4SLinus Torvalds */ 8351da177e4SLinus Torvalds 8361da177e4SLinus Torvalds static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg) 8371da177e4SLinus Torvalds { 8381da177e4SLinus Torvalds struct socket *sock; 8391da177e4SLinus Torvalds void __user *argp = (void __user *)arg; 8401da177e4SLinus Torvalds int pid, err; 8411da177e4SLinus Torvalds 842b69aee04SEric Dumazet sock = file->private_data; 8431da177e4SLinus Torvalds if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) { 8441da177e4SLinus Torvalds err = dev_ioctl(cmd, argp); 8451da177e4SLinus Torvalds } else 846d86b5e0eSAdrian Bunk #ifdef CONFIG_WIRELESS_EXT 8471da177e4SLinus Torvalds if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) { 8481da177e4SLinus Torvalds err = dev_ioctl(cmd, argp); 8491da177e4SLinus Torvalds } else 850d86b5e0eSAdrian Bunk #endif /* CONFIG_WIRELESS_EXT */ 8511da177e4SLinus Torvalds switch (cmd) { 8521da177e4SLinus Torvalds case FIOSETOWN: 8531da177e4SLinus Torvalds case SIOCSPGRP: 8541da177e4SLinus Torvalds err = -EFAULT; 8551da177e4SLinus Torvalds if (get_user(pid, (int __user *)argp)) 8561da177e4SLinus Torvalds break; 8571da177e4SLinus Torvalds err = f_setown(sock->file, pid, 1); 8581da177e4SLinus Torvalds break; 8591da177e4SLinus Torvalds case FIOGETOWN: 8601da177e4SLinus Torvalds case SIOCGPGRP: 861609d7fa9SEric W. Biederman err = put_user(f_getown(sock->file), 86289bddce5SStephen Hemminger (int __user *)argp); 8631da177e4SLinus Torvalds break; 8641da177e4SLinus Torvalds case SIOCGIFBR: 8651da177e4SLinus Torvalds case SIOCSIFBR: 8661da177e4SLinus Torvalds case SIOCBRADDBR: 8671da177e4SLinus Torvalds case SIOCBRDELBR: 8681da177e4SLinus Torvalds err = -ENOPKG; 8691da177e4SLinus Torvalds if (!br_ioctl_hook) 8701da177e4SLinus Torvalds request_module("bridge"); 8711da177e4SLinus Torvalds 8724a3e2f71SArjan van de Ven mutex_lock(&br_ioctl_mutex); 8731da177e4SLinus Torvalds if (br_ioctl_hook) 8741da177e4SLinus Torvalds err = br_ioctl_hook(cmd, argp); 8754a3e2f71SArjan van de Ven mutex_unlock(&br_ioctl_mutex); 8761da177e4SLinus Torvalds break; 8771da177e4SLinus Torvalds case SIOCGIFVLAN: 8781da177e4SLinus Torvalds case SIOCSIFVLAN: 8791da177e4SLinus Torvalds err = -ENOPKG; 8801da177e4SLinus Torvalds if (!vlan_ioctl_hook) 8811da177e4SLinus Torvalds request_module("8021q"); 8821da177e4SLinus Torvalds 8834a3e2f71SArjan van de Ven mutex_lock(&vlan_ioctl_mutex); 8841da177e4SLinus Torvalds if (vlan_ioctl_hook) 8851da177e4SLinus Torvalds err = vlan_ioctl_hook(argp); 8864a3e2f71SArjan van de Ven mutex_unlock(&vlan_ioctl_mutex); 8871da177e4SLinus Torvalds break; 8881da177e4SLinus Torvalds case SIOCADDDLCI: 8891da177e4SLinus Torvalds case SIOCDELDLCI: 8901da177e4SLinus Torvalds err = -ENOPKG; 8911da177e4SLinus Torvalds if (!dlci_ioctl_hook) 8921da177e4SLinus Torvalds request_module("dlci"); 8931da177e4SLinus Torvalds 8941da177e4SLinus Torvalds if (dlci_ioctl_hook) { 8954a3e2f71SArjan van de Ven mutex_lock(&dlci_ioctl_mutex); 8961da177e4SLinus Torvalds err = dlci_ioctl_hook(cmd, argp); 8974a3e2f71SArjan van de Ven mutex_unlock(&dlci_ioctl_mutex); 8981da177e4SLinus Torvalds } 8991da177e4SLinus Torvalds break; 9001da177e4SLinus Torvalds default: 9011da177e4SLinus Torvalds err = sock->ops->ioctl(sock, cmd, arg); 902b5e5fa5eSChristoph Hellwig 903b5e5fa5eSChristoph Hellwig /* 904b5e5fa5eSChristoph Hellwig * If this ioctl is unknown try to hand it down 905b5e5fa5eSChristoph Hellwig * to the NIC driver. 906b5e5fa5eSChristoph Hellwig */ 907b5e5fa5eSChristoph Hellwig if (err == -ENOIOCTLCMD) 908b5e5fa5eSChristoph Hellwig err = dev_ioctl(cmd, argp); 9091da177e4SLinus Torvalds break; 9101da177e4SLinus Torvalds } 9111da177e4SLinus Torvalds return err; 9121da177e4SLinus Torvalds } 9131da177e4SLinus Torvalds 9141da177e4SLinus Torvalds int sock_create_lite(int family, int type, int protocol, struct socket **res) 9151da177e4SLinus Torvalds { 9161da177e4SLinus Torvalds int err; 9171da177e4SLinus Torvalds struct socket *sock = NULL; 9181da177e4SLinus Torvalds 9191da177e4SLinus Torvalds err = security_socket_create(family, type, protocol, 1); 9201da177e4SLinus Torvalds if (err) 9211da177e4SLinus Torvalds goto out; 9221da177e4SLinus Torvalds 9231da177e4SLinus Torvalds sock = sock_alloc(); 9241da177e4SLinus Torvalds if (!sock) { 9251da177e4SLinus Torvalds err = -ENOMEM; 9261da177e4SLinus Torvalds goto out; 9271da177e4SLinus Torvalds } 9281da177e4SLinus Torvalds 9291da177e4SLinus Torvalds sock->type = type; 9307420ed23SVenkat Yekkirala err = security_socket_post_create(sock, family, type, protocol, 1); 9317420ed23SVenkat Yekkirala if (err) 9327420ed23SVenkat Yekkirala goto out_release; 9337420ed23SVenkat Yekkirala 9341da177e4SLinus Torvalds out: 9351da177e4SLinus Torvalds *res = sock; 9361da177e4SLinus Torvalds return err; 9377420ed23SVenkat Yekkirala out_release: 9387420ed23SVenkat Yekkirala sock_release(sock); 9397420ed23SVenkat Yekkirala sock = NULL; 9407420ed23SVenkat Yekkirala goto out; 9411da177e4SLinus Torvalds } 9421da177e4SLinus Torvalds 9431da177e4SLinus Torvalds /* No kernel lock held - perfect */ 9441da177e4SLinus Torvalds static unsigned int sock_poll(struct file *file, poll_table *wait) 9451da177e4SLinus Torvalds { 9461da177e4SLinus Torvalds struct socket *sock; 9471da177e4SLinus Torvalds 9481da177e4SLinus Torvalds /* 9491da177e4SLinus Torvalds * We can't return errors to poll, so it's either yes or no. 9501da177e4SLinus Torvalds */ 951b69aee04SEric Dumazet sock = file->private_data; 9521da177e4SLinus Torvalds return sock->ops->poll(file, sock, wait); 9531da177e4SLinus Torvalds } 9541da177e4SLinus Torvalds 9551da177e4SLinus Torvalds static int sock_mmap(struct file *file, struct vm_area_struct *vma) 9561da177e4SLinus Torvalds { 957b69aee04SEric Dumazet struct socket *sock = file->private_data; 9581da177e4SLinus Torvalds 9591da177e4SLinus Torvalds return sock->ops->mmap(file, sock, vma); 9601da177e4SLinus Torvalds } 9611da177e4SLinus Torvalds 96220380731SArnaldo Carvalho de Melo static int sock_close(struct inode *inode, struct file *filp) 9631da177e4SLinus Torvalds { 9641da177e4SLinus Torvalds /* 9651da177e4SLinus Torvalds * It was possible the inode is NULL we were 9661da177e4SLinus Torvalds * closing an unfinished socket. 9671da177e4SLinus Torvalds */ 9681da177e4SLinus Torvalds 96989bddce5SStephen Hemminger if (!inode) { 9701da177e4SLinus Torvalds printk(KERN_DEBUG "sock_close: NULL inode\n"); 9711da177e4SLinus Torvalds return 0; 9721da177e4SLinus Torvalds } 9731da177e4SLinus Torvalds sock_fasync(-1, filp, 0); 9741da177e4SLinus Torvalds sock_release(SOCKET_I(inode)); 9751da177e4SLinus Torvalds return 0; 9761da177e4SLinus Torvalds } 9771da177e4SLinus Torvalds 9781da177e4SLinus Torvalds /* 9791da177e4SLinus Torvalds * Update the socket async list 9801da177e4SLinus Torvalds * 9811da177e4SLinus Torvalds * Fasync_list locking strategy. 9821da177e4SLinus Torvalds * 9831da177e4SLinus Torvalds * 1. fasync_list is modified only under process context socket lock 9841da177e4SLinus Torvalds * i.e. under semaphore. 9851da177e4SLinus Torvalds * 2. fasync_list is used under read_lock(&sk->sk_callback_lock) 9861da177e4SLinus Torvalds * or under socket lock. 9871da177e4SLinus Torvalds * 3. fasync_list can be used from softirq context, so that 9881da177e4SLinus Torvalds * modification under socket lock have to be enhanced with 9891da177e4SLinus Torvalds * write_lock_bh(&sk->sk_callback_lock). 9901da177e4SLinus Torvalds * --ANK (990710) 9911da177e4SLinus Torvalds */ 9921da177e4SLinus Torvalds 9931da177e4SLinus Torvalds static int sock_fasync(int fd, struct file *filp, int on) 9941da177e4SLinus Torvalds { 9951da177e4SLinus Torvalds struct fasync_struct *fa, *fna = NULL, **prev; 9961da177e4SLinus Torvalds struct socket *sock; 9971da177e4SLinus Torvalds struct sock *sk; 9981da177e4SLinus Torvalds 99989bddce5SStephen Hemminger if (on) { 10008b3a7005SKris Katterjohn fna = kmalloc(sizeof(struct fasync_struct), GFP_KERNEL); 10011da177e4SLinus Torvalds if (fna == NULL) 10021da177e4SLinus Torvalds return -ENOMEM; 10031da177e4SLinus Torvalds } 10041da177e4SLinus Torvalds 1005b69aee04SEric Dumazet sock = filp->private_data; 10061da177e4SLinus Torvalds 100789bddce5SStephen Hemminger sk = sock->sk; 100889bddce5SStephen Hemminger if (sk == NULL) { 10091da177e4SLinus Torvalds kfree(fna); 10101da177e4SLinus Torvalds return -EINVAL; 10111da177e4SLinus Torvalds } 10121da177e4SLinus Torvalds 10131da177e4SLinus Torvalds lock_sock(sk); 10141da177e4SLinus Torvalds 10151da177e4SLinus Torvalds prev = &(sock->fasync_list); 10161da177e4SLinus Torvalds 10171da177e4SLinus Torvalds for (fa = *prev; fa != NULL; prev = &fa->fa_next, fa = *prev) 10181da177e4SLinus Torvalds if (fa->fa_file == filp) 10191da177e4SLinus Torvalds break; 10201da177e4SLinus Torvalds 102189bddce5SStephen Hemminger if (on) { 102289bddce5SStephen Hemminger if (fa != NULL) { 10231da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 10241da177e4SLinus Torvalds fa->fa_fd = fd; 10251da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 10261da177e4SLinus Torvalds 10271da177e4SLinus Torvalds kfree(fna); 10281da177e4SLinus Torvalds goto out; 10291da177e4SLinus Torvalds } 10301da177e4SLinus Torvalds fna->fa_file = filp; 10311da177e4SLinus Torvalds fna->fa_fd = fd; 10321da177e4SLinus Torvalds fna->magic = FASYNC_MAGIC; 10331da177e4SLinus Torvalds fna->fa_next = sock->fasync_list; 10341da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 10351da177e4SLinus Torvalds sock->fasync_list = fna; 10361da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 103789bddce5SStephen Hemminger } else { 103889bddce5SStephen Hemminger if (fa != NULL) { 10391da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 10401da177e4SLinus Torvalds *prev = fa->fa_next; 10411da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 10421da177e4SLinus Torvalds kfree(fa); 10431da177e4SLinus Torvalds } 10441da177e4SLinus Torvalds } 10451da177e4SLinus Torvalds 10461da177e4SLinus Torvalds out: 10471da177e4SLinus Torvalds release_sock(sock->sk); 10481da177e4SLinus Torvalds return 0; 10491da177e4SLinus Torvalds } 10501da177e4SLinus Torvalds 10511da177e4SLinus Torvalds /* This function may be called only under socket lock or callback_lock */ 10521da177e4SLinus Torvalds 10531da177e4SLinus Torvalds int sock_wake_async(struct socket *sock, int how, int band) 10541da177e4SLinus Torvalds { 10551da177e4SLinus Torvalds if (!sock || !sock->fasync_list) 10561da177e4SLinus Torvalds return -1; 105789bddce5SStephen Hemminger switch (how) { 10581da177e4SLinus Torvalds case 1: 10591da177e4SLinus Torvalds 10601da177e4SLinus Torvalds if (test_bit(SOCK_ASYNC_WAITDATA, &sock->flags)) 10611da177e4SLinus Torvalds break; 10621da177e4SLinus Torvalds goto call_kill; 10631da177e4SLinus Torvalds case 2: 10641da177e4SLinus Torvalds if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags)) 10651da177e4SLinus Torvalds break; 10661da177e4SLinus Torvalds /* fall through */ 10671da177e4SLinus Torvalds case 0: 10681da177e4SLinus Torvalds call_kill: 10691da177e4SLinus Torvalds __kill_fasync(sock->fasync_list, SIGIO, band); 10701da177e4SLinus Torvalds break; 10711da177e4SLinus Torvalds case 3: 10721da177e4SLinus Torvalds __kill_fasync(sock->fasync_list, SIGURG, band); 10731da177e4SLinus Torvalds } 10741da177e4SLinus Torvalds return 0; 10751da177e4SLinus Torvalds } 10761da177e4SLinus Torvalds 107789bddce5SStephen Hemminger static int __sock_create(int family, int type, int protocol, 107889bddce5SStephen Hemminger struct socket **res, int kern) 10791da177e4SLinus Torvalds { 10801da177e4SLinus Torvalds int err; 10811da177e4SLinus Torvalds struct socket *sock; 108255737fdaSStephen Hemminger const struct net_proto_family *pf; 10831da177e4SLinus Torvalds 10841da177e4SLinus Torvalds /* 10851da177e4SLinus Torvalds * Check protocol is in range 10861da177e4SLinus Torvalds */ 10871da177e4SLinus Torvalds if (family < 0 || family >= NPROTO) 10881da177e4SLinus Torvalds return -EAFNOSUPPORT; 10891da177e4SLinus Torvalds if (type < 0 || type >= SOCK_MAX) 10901da177e4SLinus Torvalds return -EINVAL; 10911da177e4SLinus Torvalds 10921da177e4SLinus Torvalds /* Compatibility. 10931da177e4SLinus Torvalds 10941da177e4SLinus Torvalds This uglymoron is moved from INET layer to here to avoid 10951da177e4SLinus Torvalds deadlock in module load. 10961da177e4SLinus Torvalds */ 10971da177e4SLinus Torvalds if (family == PF_INET && type == SOCK_PACKET) { 10981da177e4SLinus Torvalds static int warned; 10991da177e4SLinus Torvalds if (!warned) { 11001da177e4SLinus Torvalds warned = 1; 110189bddce5SStephen Hemminger printk(KERN_INFO "%s uses obsolete (PF_INET,SOCK_PACKET)\n", 110289bddce5SStephen Hemminger current->comm); 11031da177e4SLinus Torvalds } 11041da177e4SLinus Torvalds family = PF_PACKET; 11051da177e4SLinus Torvalds } 11061da177e4SLinus Torvalds 11071da177e4SLinus Torvalds err = security_socket_create(family, type, protocol, kern); 11081da177e4SLinus Torvalds if (err) 11091da177e4SLinus Torvalds return err; 11101da177e4SLinus Torvalds 111155737fdaSStephen Hemminger /* 111255737fdaSStephen Hemminger * Allocate the socket and allow the family to set things up. if 111355737fdaSStephen Hemminger * the protocol is 0, the family is instructed to select an appropriate 111455737fdaSStephen Hemminger * default. 111555737fdaSStephen Hemminger */ 111655737fdaSStephen Hemminger sock = sock_alloc(); 111755737fdaSStephen Hemminger if (!sock) { 111855737fdaSStephen Hemminger if (net_ratelimit()) 111955737fdaSStephen Hemminger printk(KERN_WARNING "socket: no more sockets\n"); 112055737fdaSStephen Hemminger return -ENFILE; /* Not exactly a match, but its the 112155737fdaSStephen Hemminger closest posix thing */ 112255737fdaSStephen Hemminger } 112355737fdaSStephen Hemminger 112455737fdaSStephen Hemminger sock->type = type; 112555737fdaSStephen Hemminger 11261da177e4SLinus Torvalds #if defined(CONFIG_KMOD) 11271da177e4SLinus Torvalds /* Attempt to load a protocol module if the find failed. 11281da177e4SLinus Torvalds * 11291da177e4SLinus Torvalds * 12/09/1996 Marcin: But! this makes REALLY only sense, if the user 11301da177e4SLinus Torvalds * requested real, full-featured networking support upon configuration. 11311da177e4SLinus Torvalds * Otherwise module support will break! 11321da177e4SLinus Torvalds */ 113355737fdaSStephen Hemminger if (net_families[family] == NULL) 11341da177e4SLinus Torvalds request_module("net-pf-%d", family); 11351da177e4SLinus Torvalds #endif 11361da177e4SLinus Torvalds 113755737fdaSStephen Hemminger rcu_read_lock(); 113855737fdaSStephen Hemminger pf = rcu_dereference(net_families[family]); 11391da177e4SLinus Torvalds err = -EAFNOSUPPORT; 114055737fdaSStephen Hemminger if (!pf) 114155737fdaSStephen Hemminger goto out_release; 11421da177e4SLinus Torvalds 11431da177e4SLinus Torvalds /* 11441da177e4SLinus Torvalds * We will call the ->create function, that possibly is in a loadable 11451da177e4SLinus Torvalds * module, so we have to bump that loadable module refcnt first. 11461da177e4SLinus Torvalds */ 114755737fdaSStephen Hemminger if (!try_module_get(pf->owner)) 11481da177e4SLinus Torvalds goto out_release; 11491da177e4SLinus Torvalds 115055737fdaSStephen Hemminger /* Now protected by module ref count */ 115155737fdaSStephen Hemminger rcu_read_unlock(); 115255737fdaSStephen Hemminger 115355737fdaSStephen Hemminger err = pf->create(sock, protocol); 115455737fdaSStephen Hemminger if (err < 0) 11551da177e4SLinus Torvalds goto out_module_put; 1156a79af59eSFrank Filz 11571da177e4SLinus Torvalds /* 11581da177e4SLinus Torvalds * Now to bump the refcnt of the [loadable] module that owns this 11591da177e4SLinus Torvalds * socket at sock_release time we decrement its refcnt. 11601da177e4SLinus Torvalds */ 116155737fdaSStephen Hemminger if (!try_module_get(sock->ops->owner)) 116255737fdaSStephen Hemminger goto out_module_busy; 116355737fdaSStephen Hemminger 11641da177e4SLinus Torvalds /* 11651da177e4SLinus Torvalds * Now that we're done with the ->create function, the [loadable] 11661da177e4SLinus Torvalds * module can have its refcnt decremented 11671da177e4SLinus Torvalds */ 116855737fdaSStephen Hemminger module_put(pf->owner); 11697420ed23SVenkat Yekkirala err = security_socket_post_create(sock, family, type, protocol, kern); 11707420ed23SVenkat Yekkirala if (err) 11717420ed23SVenkat Yekkirala goto out_release; 117255737fdaSStephen Hemminger *res = sock; 11731da177e4SLinus Torvalds 117455737fdaSStephen Hemminger return 0; 117555737fdaSStephen Hemminger 117655737fdaSStephen Hemminger out_module_busy: 117755737fdaSStephen Hemminger err = -EAFNOSUPPORT; 11781da177e4SLinus Torvalds out_module_put: 117955737fdaSStephen Hemminger sock->ops = NULL; 118055737fdaSStephen Hemminger module_put(pf->owner); 118155737fdaSStephen Hemminger out_sock_release: 11821da177e4SLinus Torvalds sock_release(sock); 118355737fdaSStephen Hemminger return err; 118455737fdaSStephen Hemminger 118555737fdaSStephen Hemminger out_release: 118655737fdaSStephen Hemminger rcu_read_unlock(); 118755737fdaSStephen Hemminger goto out_sock_release; 11881da177e4SLinus Torvalds } 11891da177e4SLinus Torvalds 11901da177e4SLinus Torvalds int sock_create(int family, int type, int protocol, struct socket **res) 11911da177e4SLinus Torvalds { 11921da177e4SLinus Torvalds return __sock_create(family, type, protocol, res, 0); 11931da177e4SLinus Torvalds } 11941da177e4SLinus Torvalds 11951da177e4SLinus Torvalds int sock_create_kern(int family, int type, int protocol, struct socket **res) 11961da177e4SLinus Torvalds { 11971da177e4SLinus Torvalds return __sock_create(family, type, protocol, res, 1); 11981da177e4SLinus Torvalds } 11991da177e4SLinus Torvalds 12001da177e4SLinus Torvalds asmlinkage long sys_socket(int family, int type, int protocol) 12011da177e4SLinus Torvalds { 12021da177e4SLinus Torvalds int retval; 12031da177e4SLinus Torvalds struct socket *sock; 12041da177e4SLinus Torvalds 12051da177e4SLinus Torvalds retval = sock_create(family, type, protocol, &sock); 12061da177e4SLinus Torvalds if (retval < 0) 12071da177e4SLinus Torvalds goto out; 12081da177e4SLinus Torvalds 12091da177e4SLinus Torvalds retval = sock_map_fd(sock); 12101da177e4SLinus Torvalds if (retval < 0) 12111da177e4SLinus Torvalds goto out_release; 12121da177e4SLinus Torvalds 12131da177e4SLinus Torvalds out: 12141da177e4SLinus Torvalds /* It may be already another descriptor 8) Not kernel problem. */ 12151da177e4SLinus Torvalds return retval; 12161da177e4SLinus Torvalds 12171da177e4SLinus Torvalds out_release: 12181da177e4SLinus Torvalds sock_release(sock); 12191da177e4SLinus Torvalds return retval; 12201da177e4SLinus Torvalds } 12211da177e4SLinus Torvalds 12221da177e4SLinus Torvalds /* 12231da177e4SLinus Torvalds * Create a pair of connected sockets. 12241da177e4SLinus Torvalds */ 12251da177e4SLinus Torvalds 122689bddce5SStephen Hemminger asmlinkage long sys_socketpair(int family, int type, int protocol, 122789bddce5SStephen Hemminger int __user *usockvec) 12281da177e4SLinus Torvalds { 12291da177e4SLinus Torvalds struct socket *sock1, *sock2; 12301da177e4SLinus Torvalds int fd1, fd2, err; 1231db349509SAl Viro struct file *newfile1, *newfile2; 12321da177e4SLinus Torvalds 12331da177e4SLinus Torvalds /* 12341da177e4SLinus Torvalds * Obtain the first socket and check if the underlying protocol 12351da177e4SLinus Torvalds * supports the socketpair call. 12361da177e4SLinus Torvalds */ 12371da177e4SLinus Torvalds 12381da177e4SLinus Torvalds err = sock_create(family, type, protocol, &sock1); 12391da177e4SLinus Torvalds if (err < 0) 12401da177e4SLinus Torvalds goto out; 12411da177e4SLinus Torvalds 12421da177e4SLinus Torvalds err = sock_create(family, type, protocol, &sock2); 12431da177e4SLinus Torvalds if (err < 0) 12441da177e4SLinus Torvalds goto out_release_1; 12451da177e4SLinus Torvalds 12461da177e4SLinus Torvalds err = sock1->ops->socketpair(sock1, sock2); 12471da177e4SLinus Torvalds if (err < 0) 12481da177e4SLinus Torvalds goto out_release_both; 12491da177e4SLinus Torvalds 1250db349509SAl Viro fd1 = sock_alloc_fd(&newfile1); 1251db349509SAl Viro if (unlikely(fd1 < 0)) 12521da177e4SLinus Torvalds goto out_release_both; 12531da177e4SLinus Torvalds 1254db349509SAl Viro fd2 = sock_alloc_fd(&newfile2); 1255db349509SAl Viro if (unlikely(fd2 < 0)) { 1256db349509SAl Viro put_filp(newfile1); 1257db349509SAl Viro put_unused_fd(fd1); 1258db349509SAl Viro goto out_release_both; 1259db349509SAl Viro } 12601da177e4SLinus Torvalds 1261db349509SAl Viro err = sock_attach_fd(sock1, newfile1); 1262db349509SAl Viro if (unlikely(err < 0)) { 1263db349509SAl Viro goto out_fd2; 1264db349509SAl Viro } 1265db349509SAl Viro 1266db349509SAl Viro err = sock_attach_fd(sock2, newfile2); 1267db349509SAl Viro if (unlikely(err < 0)) { 1268db349509SAl Viro fput(newfile1); 1269db349509SAl Viro goto out_fd1; 1270db349509SAl Viro } 1271db349509SAl Viro 1272db349509SAl Viro err = audit_fd_pair(fd1, fd2); 1273db349509SAl Viro if (err < 0) { 1274db349509SAl Viro fput(newfile1); 1275db349509SAl Viro fput(newfile2); 1276db349509SAl Viro goto out_fd; 1277db349509SAl Viro } 1278db349509SAl Viro 1279db349509SAl Viro fd_install(fd1, newfile1); 1280db349509SAl Viro fd_install(fd2, newfile2); 12811da177e4SLinus Torvalds /* fd1 and fd2 may be already another descriptors. 12821da177e4SLinus Torvalds * Not kernel problem. 12831da177e4SLinus Torvalds */ 12841da177e4SLinus Torvalds 12851da177e4SLinus Torvalds err = put_user(fd1, &usockvec[0]); 12861da177e4SLinus Torvalds if (!err) 12871da177e4SLinus Torvalds err = put_user(fd2, &usockvec[1]); 12881da177e4SLinus Torvalds if (!err) 12891da177e4SLinus Torvalds return 0; 12901da177e4SLinus Torvalds 12911da177e4SLinus Torvalds sys_close(fd2); 12921da177e4SLinus Torvalds sys_close(fd1); 12931da177e4SLinus Torvalds return err; 12941da177e4SLinus Torvalds 12951da177e4SLinus Torvalds out_release_both: 12961da177e4SLinus Torvalds sock_release(sock2); 12971da177e4SLinus Torvalds out_release_1: 12981da177e4SLinus Torvalds sock_release(sock1); 12991da177e4SLinus Torvalds out: 13001da177e4SLinus Torvalds return err; 1301db349509SAl Viro 1302db349509SAl Viro out_fd2: 1303db349509SAl Viro put_filp(newfile1); 1304db349509SAl Viro sock_release(sock1); 1305db349509SAl Viro out_fd1: 1306db349509SAl Viro put_filp(newfile2); 1307db349509SAl Viro sock_release(sock2); 1308db349509SAl Viro out_fd: 1309db349509SAl Viro put_unused_fd(fd1); 1310db349509SAl Viro put_unused_fd(fd2); 1311db349509SAl Viro goto out; 13121da177e4SLinus Torvalds } 13131da177e4SLinus Torvalds 13141da177e4SLinus Torvalds /* 13151da177e4SLinus Torvalds * Bind a name to a socket. Nothing much to do here since it's 13161da177e4SLinus Torvalds * the protocol's responsibility to handle the local address. 13171da177e4SLinus Torvalds * 13181da177e4SLinus Torvalds * We move the socket address to kernel space before we call 13191da177e4SLinus Torvalds * the protocol layer (having also checked the address is ok). 13201da177e4SLinus Torvalds */ 13211da177e4SLinus Torvalds 13221da177e4SLinus Torvalds asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen) 13231da177e4SLinus Torvalds { 13241da177e4SLinus Torvalds struct socket *sock; 13251da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 13266cb153caSBenjamin LaHaise int err, fput_needed; 13271da177e4SLinus Torvalds 132889bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 132989bddce5SStephen Hemminger if (sock) { 133089bddce5SStephen Hemminger err = move_addr_to_kernel(umyaddr, addrlen, address); 133189bddce5SStephen Hemminger if (err >= 0) { 133289bddce5SStephen Hemminger err = security_socket_bind(sock, 133389bddce5SStephen Hemminger (struct sockaddr *)address, 133489bddce5SStephen Hemminger addrlen); 13356cb153caSBenjamin LaHaise if (!err) 13366cb153caSBenjamin LaHaise err = sock->ops->bind(sock, 133789bddce5SStephen Hemminger (struct sockaddr *) 133889bddce5SStephen Hemminger address, addrlen); 13391da177e4SLinus Torvalds } 13406cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 13411da177e4SLinus Torvalds } 13421da177e4SLinus Torvalds return err; 13431da177e4SLinus Torvalds } 13441da177e4SLinus Torvalds 13451da177e4SLinus Torvalds /* 13461da177e4SLinus Torvalds * Perform a listen. Basically, we allow the protocol to do anything 13471da177e4SLinus Torvalds * necessary for a listen, and if that works, we mark the socket as 13481da177e4SLinus Torvalds * ready for listening. 13491da177e4SLinus Torvalds */ 13501da177e4SLinus Torvalds 13517a42c217SBrian Haley int sysctl_somaxconn __read_mostly = SOMAXCONN; 13521da177e4SLinus Torvalds 13531da177e4SLinus Torvalds asmlinkage long sys_listen(int fd, int backlog) 13541da177e4SLinus Torvalds { 13551da177e4SLinus Torvalds struct socket *sock; 13566cb153caSBenjamin LaHaise int err, fput_needed; 13571da177e4SLinus Torvalds 135889bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 135989bddce5SStephen Hemminger if (sock) { 13601da177e4SLinus Torvalds if ((unsigned)backlog > sysctl_somaxconn) 13611da177e4SLinus Torvalds backlog = sysctl_somaxconn; 13621da177e4SLinus Torvalds 13631da177e4SLinus Torvalds err = security_socket_listen(sock, backlog); 13646cb153caSBenjamin LaHaise if (!err) 13651da177e4SLinus Torvalds err = sock->ops->listen(sock, backlog); 13666cb153caSBenjamin LaHaise 13676cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 13681da177e4SLinus Torvalds } 13691da177e4SLinus Torvalds return err; 13701da177e4SLinus Torvalds } 13711da177e4SLinus Torvalds 13721da177e4SLinus Torvalds /* 13731da177e4SLinus Torvalds * For accept, we attempt to create a new socket, set up the link 13741da177e4SLinus Torvalds * with the client, wake up the client, then return the new 13751da177e4SLinus Torvalds * connected fd. We collect the address of the connector in kernel 13761da177e4SLinus Torvalds * space and move it to user at the very end. This is unclean because 13771da177e4SLinus Torvalds * we open the socket then return an error. 13781da177e4SLinus Torvalds * 13791da177e4SLinus Torvalds * 1003.1g adds the ability to recvmsg() to query connection pending 13801da177e4SLinus Torvalds * status to recvmsg. We need to add that support in a way thats 13811da177e4SLinus Torvalds * clean when we restucture accept also. 13821da177e4SLinus Torvalds */ 13831da177e4SLinus Torvalds 138489bddce5SStephen Hemminger asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr, 138589bddce5SStephen Hemminger int __user *upeer_addrlen) 13861da177e4SLinus Torvalds { 13871da177e4SLinus Torvalds struct socket *sock, *newsock; 138839d8c1b6SDavid S. Miller struct file *newfile; 13896cb153caSBenjamin LaHaise int err, len, newfd, fput_needed; 13901da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 13911da177e4SLinus Torvalds 13926cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 13931da177e4SLinus Torvalds if (!sock) 13941da177e4SLinus Torvalds goto out; 13951da177e4SLinus Torvalds 13961da177e4SLinus Torvalds err = -ENFILE; 13971da177e4SLinus Torvalds if (!(newsock = sock_alloc())) 13981da177e4SLinus Torvalds goto out_put; 13991da177e4SLinus Torvalds 14001da177e4SLinus Torvalds newsock->type = sock->type; 14011da177e4SLinus Torvalds newsock->ops = sock->ops; 14021da177e4SLinus Torvalds 14031da177e4SLinus Torvalds /* 14041da177e4SLinus Torvalds * We don't need try_module_get here, as the listening socket (sock) 14051da177e4SLinus Torvalds * has the protocol module (sock->ops->owner) held. 14061da177e4SLinus Torvalds */ 14071da177e4SLinus Torvalds __module_get(newsock->ops->owner); 14081da177e4SLinus Torvalds 140939d8c1b6SDavid S. Miller newfd = sock_alloc_fd(&newfile); 141039d8c1b6SDavid S. Miller if (unlikely(newfd < 0)) { 141139d8c1b6SDavid S. Miller err = newfd; 14129a1875e6SDavid S. Miller sock_release(newsock); 14139a1875e6SDavid S. Miller goto out_put; 141439d8c1b6SDavid S. Miller } 141539d8c1b6SDavid S. Miller 141639d8c1b6SDavid S. Miller err = sock_attach_fd(newsock, newfile); 141739d8c1b6SDavid S. Miller if (err < 0) 141879f4f642SAlexey Dobriyan goto out_fd_simple; 141939d8c1b6SDavid S. Miller 1420a79af59eSFrank Filz err = security_socket_accept(sock, newsock); 1421a79af59eSFrank Filz if (err) 142239d8c1b6SDavid S. Miller goto out_fd; 1423a79af59eSFrank Filz 14241da177e4SLinus Torvalds err = sock->ops->accept(sock, newsock, sock->file->f_flags); 14251da177e4SLinus Torvalds if (err < 0) 142639d8c1b6SDavid S. Miller goto out_fd; 14271da177e4SLinus Torvalds 14281da177e4SLinus Torvalds if (upeer_sockaddr) { 142989bddce5SStephen Hemminger if (newsock->ops->getname(newsock, (struct sockaddr *)address, 143089bddce5SStephen Hemminger &len, 2) < 0) { 14311da177e4SLinus Torvalds err = -ECONNABORTED; 143239d8c1b6SDavid S. Miller goto out_fd; 14331da177e4SLinus Torvalds } 143489bddce5SStephen Hemminger err = move_addr_to_user(address, len, upeer_sockaddr, 143589bddce5SStephen Hemminger upeer_addrlen); 14361da177e4SLinus Torvalds if (err < 0) 143739d8c1b6SDavid S. Miller goto out_fd; 14381da177e4SLinus Torvalds } 14391da177e4SLinus Torvalds 14401da177e4SLinus Torvalds /* File flags are not inherited via accept() unlike another OSes. */ 14411da177e4SLinus Torvalds 144239d8c1b6SDavid S. Miller fd_install(newfd, newfile); 144339d8c1b6SDavid S. Miller err = newfd; 14441da177e4SLinus Torvalds 14451da177e4SLinus Torvalds security_socket_post_accept(sock, newsock); 14461da177e4SLinus Torvalds 14471da177e4SLinus Torvalds out_put: 14486cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 14491da177e4SLinus Torvalds out: 14501da177e4SLinus Torvalds return err; 145179f4f642SAlexey Dobriyan out_fd_simple: 145279f4f642SAlexey Dobriyan sock_release(newsock); 145379f4f642SAlexey Dobriyan put_filp(newfile); 145479f4f642SAlexey Dobriyan put_unused_fd(newfd); 145579f4f642SAlexey Dobriyan goto out_put; 145639d8c1b6SDavid S. Miller out_fd: 14579606a216SDavid S. Miller fput(newfile); 145839d8c1b6SDavid S. Miller put_unused_fd(newfd); 14591da177e4SLinus Torvalds goto out_put; 14601da177e4SLinus Torvalds } 14611da177e4SLinus Torvalds 14621da177e4SLinus Torvalds /* 14631da177e4SLinus Torvalds * Attempt to connect to a socket with the server address. The address 14641da177e4SLinus Torvalds * is in user space so we verify it is OK and move it to kernel space. 14651da177e4SLinus Torvalds * 14661da177e4SLinus Torvalds * For 1003.1g we need to add clean support for a bind to AF_UNSPEC to 14671da177e4SLinus Torvalds * break bindings 14681da177e4SLinus Torvalds * 14691da177e4SLinus Torvalds * NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and 14701da177e4SLinus Torvalds * other SEQPACKET protocols that take time to connect() as it doesn't 14711da177e4SLinus Torvalds * include the -EINPROGRESS status for such sockets. 14721da177e4SLinus Torvalds */ 14731da177e4SLinus Torvalds 147489bddce5SStephen Hemminger asmlinkage long sys_connect(int fd, struct sockaddr __user *uservaddr, 147589bddce5SStephen Hemminger int addrlen) 14761da177e4SLinus Torvalds { 14771da177e4SLinus Torvalds struct socket *sock; 14781da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 14796cb153caSBenjamin LaHaise int err, fput_needed; 14801da177e4SLinus Torvalds 14816cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 14821da177e4SLinus Torvalds if (!sock) 14831da177e4SLinus Torvalds goto out; 14841da177e4SLinus Torvalds err = move_addr_to_kernel(uservaddr, addrlen, address); 14851da177e4SLinus Torvalds if (err < 0) 14861da177e4SLinus Torvalds goto out_put; 14871da177e4SLinus Torvalds 148889bddce5SStephen Hemminger err = 148989bddce5SStephen Hemminger security_socket_connect(sock, (struct sockaddr *)address, addrlen); 14901da177e4SLinus Torvalds if (err) 14911da177e4SLinus Torvalds goto out_put; 14921da177e4SLinus Torvalds 14931da177e4SLinus Torvalds err = sock->ops->connect(sock, (struct sockaddr *)address, addrlen, 14941da177e4SLinus Torvalds sock->file->f_flags); 14951da177e4SLinus Torvalds out_put: 14966cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 14971da177e4SLinus Torvalds out: 14981da177e4SLinus Torvalds return err; 14991da177e4SLinus Torvalds } 15001da177e4SLinus Torvalds 15011da177e4SLinus Torvalds /* 15021da177e4SLinus Torvalds * Get the local address ('name') of a socket object. Move the obtained 15031da177e4SLinus Torvalds * name to user space. 15041da177e4SLinus Torvalds */ 15051da177e4SLinus Torvalds 150689bddce5SStephen Hemminger asmlinkage long sys_getsockname(int fd, struct sockaddr __user *usockaddr, 150789bddce5SStephen Hemminger int __user *usockaddr_len) 15081da177e4SLinus Torvalds { 15091da177e4SLinus Torvalds struct socket *sock; 15101da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 15116cb153caSBenjamin LaHaise int len, err, fput_needed; 15121da177e4SLinus Torvalds 15136cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 15141da177e4SLinus Torvalds if (!sock) 15151da177e4SLinus Torvalds goto out; 15161da177e4SLinus Torvalds 15171da177e4SLinus Torvalds err = security_socket_getsockname(sock); 15181da177e4SLinus Torvalds if (err) 15191da177e4SLinus Torvalds goto out_put; 15201da177e4SLinus Torvalds 15211da177e4SLinus Torvalds err = sock->ops->getname(sock, (struct sockaddr *)address, &len, 0); 15221da177e4SLinus Torvalds if (err) 15231da177e4SLinus Torvalds goto out_put; 15241da177e4SLinus Torvalds err = move_addr_to_user(address, len, usockaddr, usockaddr_len); 15251da177e4SLinus Torvalds 15261da177e4SLinus Torvalds out_put: 15276cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 15281da177e4SLinus Torvalds out: 15291da177e4SLinus Torvalds return err; 15301da177e4SLinus Torvalds } 15311da177e4SLinus Torvalds 15321da177e4SLinus Torvalds /* 15331da177e4SLinus Torvalds * Get the remote address ('name') of a socket object. Move the obtained 15341da177e4SLinus Torvalds * name to user space. 15351da177e4SLinus Torvalds */ 15361da177e4SLinus Torvalds 153789bddce5SStephen Hemminger asmlinkage long sys_getpeername(int fd, struct sockaddr __user *usockaddr, 153889bddce5SStephen Hemminger int __user *usockaddr_len) 15391da177e4SLinus Torvalds { 15401da177e4SLinus Torvalds struct socket *sock; 15411da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 15426cb153caSBenjamin LaHaise int len, err, fput_needed; 15431da177e4SLinus Torvalds 154489bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 154589bddce5SStephen Hemminger if (sock != NULL) { 15461da177e4SLinus Torvalds err = security_socket_getpeername(sock); 15471da177e4SLinus Torvalds if (err) { 15486cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 15491da177e4SLinus Torvalds return err; 15501da177e4SLinus Torvalds } 15511da177e4SLinus Torvalds 155289bddce5SStephen Hemminger err = 155389bddce5SStephen Hemminger sock->ops->getname(sock, (struct sockaddr *)address, &len, 155489bddce5SStephen Hemminger 1); 15551da177e4SLinus Torvalds if (!err) 155689bddce5SStephen Hemminger err = move_addr_to_user(address, len, usockaddr, 155789bddce5SStephen Hemminger usockaddr_len); 15586cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 15591da177e4SLinus Torvalds } 15601da177e4SLinus Torvalds return err; 15611da177e4SLinus Torvalds } 15621da177e4SLinus Torvalds 15631da177e4SLinus Torvalds /* 15641da177e4SLinus Torvalds * Send a datagram to a given address. We move the address into kernel 15651da177e4SLinus Torvalds * space and check the user space data area is readable before invoking 15661da177e4SLinus Torvalds * the protocol. 15671da177e4SLinus Torvalds */ 15681da177e4SLinus Torvalds 156989bddce5SStephen Hemminger asmlinkage long sys_sendto(int fd, void __user *buff, size_t len, 157089bddce5SStephen Hemminger unsigned flags, struct sockaddr __user *addr, 157189bddce5SStephen Hemminger int addr_len) 15721da177e4SLinus Torvalds { 15731da177e4SLinus Torvalds struct socket *sock; 15741da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 15751da177e4SLinus Torvalds int err; 15761da177e4SLinus Torvalds struct msghdr msg; 15771da177e4SLinus Torvalds struct iovec iov; 15786cb153caSBenjamin LaHaise int fput_needed; 15796cb153caSBenjamin LaHaise struct file *sock_file; 15801da177e4SLinus Torvalds 15816cb153caSBenjamin LaHaise sock_file = fget_light(fd, &fput_needed); 15824387ff75SDavid S. Miller err = -EBADF; 15836cb153caSBenjamin LaHaise if (!sock_file) 15844387ff75SDavid S. Miller goto out; 15856cb153caSBenjamin LaHaise 15866cb153caSBenjamin LaHaise sock = sock_from_file(sock_file, &err); 15871da177e4SLinus Torvalds if (!sock) 15886cb153caSBenjamin LaHaise goto out_put; 15891da177e4SLinus Torvalds iov.iov_base = buff; 15901da177e4SLinus Torvalds iov.iov_len = len; 15911da177e4SLinus Torvalds msg.msg_name = NULL; 15921da177e4SLinus Torvalds msg.msg_iov = &iov; 15931da177e4SLinus Torvalds msg.msg_iovlen = 1; 15941da177e4SLinus Torvalds msg.msg_control = NULL; 15951da177e4SLinus Torvalds msg.msg_controllen = 0; 15961da177e4SLinus Torvalds msg.msg_namelen = 0; 15976cb153caSBenjamin LaHaise if (addr) { 15981da177e4SLinus Torvalds err = move_addr_to_kernel(addr, addr_len, address); 15991da177e4SLinus Torvalds if (err < 0) 16001da177e4SLinus Torvalds goto out_put; 16011da177e4SLinus Torvalds msg.msg_name = address; 16021da177e4SLinus Torvalds msg.msg_namelen = addr_len; 16031da177e4SLinus Torvalds } 16041da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 16051da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 16061da177e4SLinus Torvalds msg.msg_flags = flags; 16071da177e4SLinus Torvalds err = sock_sendmsg(sock, &msg, len); 16081da177e4SLinus Torvalds 16091da177e4SLinus Torvalds out_put: 16106cb153caSBenjamin LaHaise fput_light(sock_file, fput_needed); 16114387ff75SDavid S. Miller out: 16121da177e4SLinus Torvalds return err; 16131da177e4SLinus Torvalds } 16141da177e4SLinus Torvalds 16151da177e4SLinus Torvalds /* 16161da177e4SLinus Torvalds * Send a datagram down a socket. 16171da177e4SLinus Torvalds */ 16181da177e4SLinus Torvalds 16191da177e4SLinus Torvalds asmlinkage long sys_send(int fd, void __user *buff, size_t len, unsigned flags) 16201da177e4SLinus Torvalds { 16211da177e4SLinus Torvalds return sys_sendto(fd, buff, len, flags, NULL, 0); 16221da177e4SLinus Torvalds } 16231da177e4SLinus Torvalds 16241da177e4SLinus Torvalds /* 16251da177e4SLinus Torvalds * Receive a frame from the socket and optionally record the address of the 16261da177e4SLinus Torvalds * sender. We verify the buffers are writable and if needed move the 16271da177e4SLinus Torvalds * sender address from kernel to user space. 16281da177e4SLinus Torvalds */ 16291da177e4SLinus Torvalds 163089bddce5SStephen Hemminger asmlinkage long sys_recvfrom(int fd, void __user *ubuf, size_t size, 163189bddce5SStephen Hemminger unsigned flags, struct sockaddr __user *addr, 163289bddce5SStephen Hemminger int __user *addr_len) 16331da177e4SLinus Torvalds { 16341da177e4SLinus Torvalds struct socket *sock; 16351da177e4SLinus Torvalds struct iovec iov; 16361da177e4SLinus Torvalds struct msghdr msg; 16371da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 16381da177e4SLinus Torvalds int err, err2; 16396cb153caSBenjamin LaHaise struct file *sock_file; 16406cb153caSBenjamin LaHaise int fput_needed; 16411da177e4SLinus Torvalds 16426cb153caSBenjamin LaHaise sock_file = fget_light(fd, &fput_needed); 16434387ff75SDavid S. Miller err = -EBADF; 16446cb153caSBenjamin LaHaise if (!sock_file) 16454387ff75SDavid S. Miller goto out; 16466cb153caSBenjamin LaHaise 16476cb153caSBenjamin LaHaise sock = sock_from_file(sock_file, &err); 16481da177e4SLinus Torvalds if (!sock) 16494387ff75SDavid S. Miller goto out_put; 16501da177e4SLinus Torvalds 16511da177e4SLinus Torvalds msg.msg_control = NULL; 16521da177e4SLinus Torvalds msg.msg_controllen = 0; 16531da177e4SLinus Torvalds msg.msg_iovlen = 1; 16541da177e4SLinus Torvalds msg.msg_iov = &iov; 16551da177e4SLinus Torvalds iov.iov_len = size; 16561da177e4SLinus Torvalds iov.iov_base = ubuf; 16571da177e4SLinus Torvalds msg.msg_name = address; 16581da177e4SLinus Torvalds msg.msg_namelen = MAX_SOCK_ADDR; 16591da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 16601da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 16611da177e4SLinus Torvalds err = sock_recvmsg(sock, &msg, size, flags); 16621da177e4SLinus Torvalds 166389bddce5SStephen Hemminger if (err >= 0 && addr != NULL) { 16641da177e4SLinus Torvalds err2 = move_addr_to_user(address, msg.msg_namelen, addr, addr_len); 16651da177e4SLinus Torvalds if (err2 < 0) 16661da177e4SLinus Torvalds err = err2; 16671da177e4SLinus Torvalds } 16684387ff75SDavid S. Miller out_put: 16696cb153caSBenjamin LaHaise fput_light(sock_file, fput_needed); 16704387ff75SDavid S. Miller out: 16711da177e4SLinus Torvalds return err; 16721da177e4SLinus Torvalds } 16731da177e4SLinus Torvalds 16741da177e4SLinus Torvalds /* 16751da177e4SLinus Torvalds * Receive a datagram from a socket. 16761da177e4SLinus Torvalds */ 16771da177e4SLinus Torvalds 167889bddce5SStephen Hemminger asmlinkage long sys_recv(int fd, void __user *ubuf, size_t size, 167989bddce5SStephen Hemminger unsigned flags) 16801da177e4SLinus Torvalds { 16811da177e4SLinus Torvalds return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL); 16821da177e4SLinus Torvalds } 16831da177e4SLinus Torvalds 16841da177e4SLinus Torvalds /* 16851da177e4SLinus Torvalds * Set a socket option. Because we don't know the option lengths we have 16861da177e4SLinus Torvalds * to pass the user mode parameter for the protocols to sort out. 16871da177e4SLinus Torvalds */ 16881da177e4SLinus Torvalds 168989bddce5SStephen Hemminger asmlinkage long sys_setsockopt(int fd, int level, int optname, 169089bddce5SStephen Hemminger char __user *optval, int optlen) 16911da177e4SLinus Torvalds { 16926cb153caSBenjamin LaHaise int err, fput_needed; 16931da177e4SLinus Torvalds struct socket *sock; 16941da177e4SLinus Torvalds 16951da177e4SLinus Torvalds if (optlen < 0) 16961da177e4SLinus Torvalds return -EINVAL; 16971da177e4SLinus Torvalds 169889bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 169989bddce5SStephen Hemminger if (sock != NULL) { 17001da177e4SLinus Torvalds err = security_socket_setsockopt(sock, level, optname); 17016cb153caSBenjamin LaHaise if (err) 17026cb153caSBenjamin LaHaise goto out_put; 17031da177e4SLinus Torvalds 17041da177e4SLinus Torvalds if (level == SOL_SOCKET) 170589bddce5SStephen Hemminger err = 170689bddce5SStephen Hemminger sock_setsockopt(sock, level, optname, optval, 170789bddce5SStephen Hemminger optlen); 17081da177e4SLinus Torvalds else 170989bddce5SStephen Hemminger err = 171089bddce5SStephen Hemminger sock->ops->setsockopt(sock, level, optname, optval, 171189bddce5SStephen Hemminger optlen); 17126cb153caSBenjamin LaHaise out_put: 17136cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 17141da177e4SLinus Torvalds } 17151da177e4SLinus Torvalds return err; 17161da177e4SLinus Torvalds } 17171da177e4SLinus Torvalds 17181da177e4SLinus Torvalds /* 17191da177e4SLinus Torvalds * Get a socket option. Because we don't know the option lengths we have 17201da177e4SLinus Torvalds * to pass a user mode parameter for the protocols to sort out. 17211da177e4SLinus Torvalds */ 17221da177e4SLinus Torvalds 172389bddce5SStephen Hemminger asmlinkage long sys_getsockopt(int fd, int level, int optname, 172489bddce5SStephen Hemminger char __user *optval, int __user *optlen) 17251da177e4SLinus Torvalds { 17266cb153caSBenjamin LaHaise int err, fput_needed; 17271da177e4SLinus Torvalds struct socket *sock; 17281da177e4SLinus Torvalds 172989bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 173089bddce5SStephen Hemminger if (sock != NULL) { 17316cb153caSBenjamin LaHaise err = security_socket_getsockopt(sock, level, optname); 17326cb153caSBenjamin LaHaise if (err) 17336cb153caSBenjamin LaHaise goto out_put; 17341da177e4SLinus Torvalds 17351da177e4SLinus Torvalds if (level == SOL_SOCKET) 173689bddce5SStephen Hemminger err = 173789bddce5SStephen Hemminger sock_getsockopt(sock, level, optname, optval, 173889bddce5SStephen Hemminger optlen); 17391da177e4SLinus Torvalds else 174089bddce5SStephen Hemminger err = 174189bddce5SStephen Hemminger sock->ops->getsockopt(sock, level, optname, optval, 174289bddce5SStephen Hemminger optlen); 17436cb153caSBenjamin LaHaise out_put: 17446cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 17451da177e4SLinus Torvalds } 17461da177e4SLinus Torvalds return err; 17471da177e4SLinus Torvalds } 17481da177e4SLinus Torvalds 17491da177e4SLinus Torvalds /* 17501da177e4SLinus Torvalds * Shutdown a socket. 17511da177e4SLinus Torvalds */ 17521da177e4SLinus Torvalds 17531da177e4SLinus Torvalds asmlinkage long sys_shutdown(int fd, int how) 17541da177e4SLinus Torvalds { 17556cb153caSBenjamin LaHaise int err, fput_needed; 17561da177e4SLinus Torvalds struct socket *sock; 17571da177e4SLinus Torvalds 175889bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 175989bddce5SStephen Hemminger if (sock != NULL) { 17601da177e4SLinus Torvalds err = security_socket_shutdown(sock, how); 17616cb153caSBenjamin LaHaise if (!err) 17621da177e4SLinus Torvalds err = sock->ops->shutdown(sock, how); 17636cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 17641da177e4SLinus Torvalds } 17651da177e4SLinus Torvalds return err; 17661da177e4SLinus Torvalds } 17671da177e4SLinus Torvalds 17681da177e4SLinus Torvalds /* A couple of helpful macros for getting the address of the 32/64 bit 17691da177e4SLinus Torvalds * fields which are the same type (int / unsigned) on our platforms. 17701da177e4SLinus Torvalds */ 17711da177e4SLinus Torvalds #define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member) 17721da177e4SLinus Torvalds #define COMPAT_NAMELEN(msg) COMPAT_MSG(msg, msg_namelen) 17731da177e4SLinus Torvalds #define COMPAT_FLAGS(msg) COMPAT_MSG(msg, msg_flags) 17741da177e4SLinus Torvalds 17751da177e4SLinus Torvalds /* 17761da177e4SLinus Torvalds * BSD sendmsg interface 17771da177e4SLinus Torvalds */ 17781da177e4SLinus Torvalds 17791da177e4SLinus Torvalds asmlinkage long sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags) 17801da177e4SLinus Torvalds { 178189bddce5SStephen Hemminger struct compat_msghdr __user *msg_compat = 178289bddce5SStephen Hemminger (struct compat_msghdr __user *)msg; 17831da177e4SLinus Torvalds struct socket *sock; 17841da177e4SLinus Torvalds char address[MAX_SOCK_ADDR]; 17851da177e4SLinus Torvalds struct iovec iovstack[UIO_FASTIOV], *iov = iovstack; 1786b9d717a7SAlex Williamson unsigned char ctl[sizeof(struct cmsghdr) + 20] 1787b9d717a7SAlex Williamson __attribute__ ((aligned(sizeof(__kernel_size_t)))); 1788b9d717a7SAlex Williamson /* 20 is size of ipv6_pktinfo */ 17891da177e4SLinus Torvalds unsigned char *ctl_buf = ctl; 17901da177e4SLinus Torvalds struct msghdr msg_sys; 17911da177e4SLinus Torvalds int err, ctl_len, iov_size, total_len; 17926cb153caSBenjamin LaHaise int fput_needed; 17931da177e4SLinus Torvalds 17941da177e4SLinus Torvalds err = -EFAULT; 17951da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 17961da177e4SLinus Torvalds if (get_compat_msghdr(&msg_sys, msg_compat)) 17971da177e4SLinus Torvalds return -EFAULT; 179889bddce5SStephen Hemminger } 179989bddce5SStephen Hemminger else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr))) 18001da177e4SLinus Torvalds return -EFAULT; 18011da177e4SLinus Torvalds 18026cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 18031da177e4SLinus Torvalds if (!sock) 18041da177e4SLinus Torvalds goto out; 18051da177e4SLinus Torvalds 18061da177e4SLinus Torvalds /* do not move before msg_sys is valid */ 18071da177e4SLinus Torvalds err = -EMSGSIZE; 18081da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_MAXIOV) 18091da177e4SLinus Torvalds goto out_put; 18101da177e4SLinus Torvalds 18111da177e4SLinus Torvalds /* Check whether to allocate the iovec area */ 18121da177e4SLinus Torvalds err = -ENOMEM; 18131da177e4SLinus Torvalds iov_size = msg_sys.msg_iovlen * sizeof(struct iovec); 18141da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_FASTIOV) { 18151da177e4SLinus Torvalds iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL); 18161da177e4SLinus Torvalds if (!iov) 18171da177e4SLinus Torvalds goto out_put; 18181da177e4SLinus Torvalds } 18191da177e4SLinus Torvalds 18201da177e4SLinus Torvalds /* This will also move the address data into kernel space */ 18211da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 18221da177e4SLinus Torvalds err = verify_compat_iovec(&msg_sys, iov, address, VERIFY_READ); 18231da177e4SLinus Torvalds } else 18241da177e4SLinus Torvalds err = verify_iovec(&msg_sys, iov, address, VERIFY_READ); 18251da177e4SLinus Torvalds if (err < 0) 18261da177e4SLinus Torvalds goto out_freeiov; 18271da177e4SLinus Torvalds total_len = err; 18281da177e4SLinus Torvalds 18291da177e4SLinus Torvalds err = -ENOBUFS; 18301da177e4SLinus Torvalds 18311da177e4SLinus Torvalds if (msg_sys.msg_controllen > INT_MAX) 18321da177e4SLinus Torvalds goto out_freeiov; 18331da177e4SLinus Torvalds ctl_len = msg_sys.msg_controllen; 18341da177e4SLinus Torvalds if ((MSG_CMSG_COMPAT & flags) && ctl_len) { 183589bddce5SStephen Hemminger err = 183689bddce5SStephen Hemminger cmsghdr_from_user_compat_to_kern(&msg_sys, sock->sk, ctl, 183789bddce5SStephen Hemminger sizeof(ctl)); 18381da177e4SLinus Torvalds if (err) 18391da177e4SLinus Torvalds goto out_freeiov; 18401da177e4SLinus Torvalds ctl_buf = msg_sys.msg_control; 18418920e8f9SAl Viro ctl_len = msg_sys.msg_controllen; 18421da177e4SLinus Torvalds } else if (ctl_len) { 184389bddce5SStephen Hemminger if (ctl_len > sizeof(ctl)) { 18441da177e4SLinus Torvalds ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL); 18451da177e4SLinus Torvalds if (ctl_buf == NULL) 18461da177e4SLinus Torvalds goto out_freeiov; 18471da177e4SLinus Torvalds } 18481da177e4SLinus Torvalds err = -EFAULT; 18491da177e4SLinus Torvalds /* 18501da177e4SLinus Torvalds * Careful! Before this, msg_sys.msg_control contains a user pointer. 18511da177e4SLinus Torvalds * Afterwards, it will be a kernel pointer. Thus the compiler-assisted 18521da177e4SLinus Torvalds * checking falls down on this. 18531da177e4SLinus Torvalds */ 185489bddce5SStephen Hemminger if (copy_from_user(ctl_buf, (void __user *)msg_sys.msg_control, 185589bddce5SStephen Hemminger ctl_len)) 18561da177e4SLinus Torvalds goto out_freectl; 18571da177e4SLinus Torvalds msg_sys.msg_control = ctl_buf; 18581da177e4SLinus Torvalds } 18591da177e4SLinus Torvalds msg_sys.msg_flags = flags; 18601da177e4SLinus Torvalds 18611da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 18621da177e4SLinus Torvalds msg_sys.msg_flags |= MSG_DONTWAIT; 18631da177e4SLinus Torvalds err = sock_sendmsg(sock, &msg_sys, total_len); 18641da177e4SLinus Torvalds 18651da177e4SLinus Torvalds out_freectl: 18661da177e4SLinus Torvalds if (ctl_buf != ctl) 18671da177e4SLinus Torvalds sock_kfree_s(sock->sk, ctl_buf, ctl_len); 18681da177e4SLinus Torvalds out_freeiov: 18691da177e4SLinus Torvalds if (iov != iovstack) 18701da177e4SLinus Torvalds sock_kfree_s(sock->sk, iov, iov_size); 18711da177e4SLinus Torvalds out_put: 18726cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 18731da177e4SLinus Torvalds out: 18741da177e4SLinus Torvalds return err; 18751da177e4SLinus Torvalds } 18761da177e4SLinus Torvalds 18771da177e4SLinus Torvalds /* 18781da177e4SLinus Torvalds * BSD recvmsg interface 18791da177e4SLinus Torvalds */ 18801da177e4SLinus Torvalds 188189bddce5SStephen Hemminger asmlinkage long sys_recvmsg(int fd, struct msghdr __user *msg, 188289bddce5SStephen Hemminger unsigned int flags) 18831da177e4SLinus Torvalds { 188489bddce5SStephen Hemminger struct compat_msghdr __user *msg_compat = 188589bddce5SStephen Hemminger (struct compat_msghdr __user *)msg; 18861da177e4SLinus Torvalds struct socket *sock; 18871da177e4SLinus Torvalds struct iovec iovstack[UIO_FASTIOV]; 18881da177e4SLinus Torvalds struct iovec *iov = iovstack; 18891da177e4SLinus Torvalds struct msghdr msg_sys; 18901da177e4SLinus Torvalds unsigned long cmsg_ptr; 18911da177e4SLinus Torvalds int err, iov_size, total_len, len; 18926cb153caSBenjamin LaHaise int fput_needed; 18931da177e4SLinus Torvalds 18941da177e4SLinus Torvalds /* kernel mode address */ 18951da177e4SLinus Torvalds char addr[MAX_SOCK_ADDR]; 18961da177e4SLinus Torvalds 18971da177e4SLinus Torvalds /* user mode address pointers */ 18981da177e4SLinus Torvalds struct sockaddr __user *uaddr; 18991da177e4SLinus Torvalds int __user *uaddr_len; 19001da177e4SLinus Torvalds 19011da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 19021da177e4SLinus Torvalds if (get_compat_msghdr(&msg_sys, msg_compat)) 19031da177e4SLinus Torvalds return -EFAULT; 190489bddce5SStephen Hemminger } 190589bddce5SStephen Hemminger else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr))) 19061da177e4SLinus Torvalds return -EFAULT; 19071da177e4SLinus Torvalds 19086cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 19091da177e4SLinus Torvalds if (!sock) 19101da177e4SLinus Torvalds goto out; 19111da177e4SLinus Torvalds 19121da177e4SLinus Torvalds err = -EMSGSIZE; 19131da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_MAXIOV) 19141da177e4SLinus Torvalds goto out_put; 19151da177e4SLinus Torvalds 19161da177e4SLinus Torvalds /* Check whether to allocate the iovec area */ 19171da177e4SLinus Torvalds err = -ENOMEM; 19181da177e4SLinus Torvalds iov_size = msg_sys.msg_iovlen * sizeof(struct iovec); 19191da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_FASTIOV) { 19201da177e4SLinus Torvalds iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL); 19211da177e4SLinus Torvalds if (!iov) 19221da177e4SLinus Torvalds goto out_put; 19231da177e4SLinus Torvalds } 19241da177e4SLinus Torvalds 19251da177e4SLinus Torvalds /* 19261da177e4SLinus Torvalds * Save the user-mode address (verify_iovec will change the 19271da177e4SLinus Torvalds * kernel msghdr to use the kernel address space) 19281da177e4SLinus Torvalds */ 19291da177e4SLinus Torvalds 19301da177e4SLinus Torvalds uaddr = (void __user *)msg_sys.msg_name; 19311da177e4SLinus Torvalds uaddr_len = COMPAT_NAMELEN(msg); 19321da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 19331da177e4SLinus Torvalds err = verify_compat_iovec(&msg_sys, iov, addr, VERIFY_WRITE); 19341da177e4SLinus Torvalds } else 19351da177e4SLinus Torvalds err = verify_iovec(&msg_sys, iov, addr, VERIFY_WRITE); 19361da177e4SLinus Torvalds if (err < 0) 19371da177e4SLinus Torvalds goto out_freeiov; 19381da177e4SLinus Torvalds total_len = err; 19391da177e4SLinus Torvalds 19401da177e4SLinus Torvalds cmsg_ptr = (unsigned long)msg_sys.msg_control; 19414a19542eSUlrich Drepper msg_sys.msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT); 19421da177e4SLinus Torvalds 19431da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 19441da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 19451da177e4SLinus Torvalds err = sock_recvmsg(sock, &msg_sys, total_len, flags); 19461da177e4SLinus Torvalds if (err < 0) 19471da177e4SLinus Torvalds goto out_freeiov; 19481da177e4SLinus Torvalds len = err; 19491da177e4SLinus Torvalds 19501da177e4SLinus Torvalds if (uaddr != NULL) { 195189bddce5SStephen Hemminger err = move_addr_to_user(addr, msg_sys.msg_namelen, uaddr, 195289bddce5SStephen Hemminger uaddr_len); 19531da177e4SLinus Torvalds if (err < 0) 19541da177e4SLinus Torvalds goto out_freeiov; 19551da177e4SLinus Torvalds } 195637f7f421SDavid S. Miller err = __put_user((msg_sys.msg_flags & ~MSG_CMSG_COMPAT), 195737f7f421SDavid S. Miller COMPAT_FLAGS(msg)); 19581da177e4SLinus Torvalds if (err) 19591da177e4SLinus Torvalds goto out_freeiov; 19601da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) 19611da177e4SLinus Torvalds err = __put_user((unsigned long)msg_sys.msg_control - cmsg_ptr, 19621da177e4SLinus Torvalds &msg_compat->msg_controllen); 19631da177e4SLinus Torvalds else 19641da177e4SLinus Torvalds err = __put_user((unsigned long)msg_sys.msg_control - cmsg_ptr, 19651da177e4SLinus Torvalds &msg->msg_controllen); 19661da177e4SLinus Torvalds if (err) 19671da177e4SLinus Torvalds goto out_freeiov; 19681da177e4SLinus Torvalds err = len; 19691da177e4SLinus Torvalds 19701da177e4SLinus Torvalds out_freeiov: 19711da177e4SLinus Torvalds if (iov != iovstack) 19721da177e4SLinus Torvalds sock_kfree_s(sock->sk, iov, iov_size); 19731da177e4SLinus Torvalds out_put: 19746cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 19751da177e4SLinus Torvalds out: 19761da177e4SLinus Torvalds return err; 19771da177e4SLinus Torvalds } 19781da177e4SLinus Torvalds 19791da177e4SLinus Torvalds #ifdef __ARCH_WANT_SYS_SOCKETCALL 19801da177e4SLinus Torvalds 19811da177e4SLinus Torvalds /* Argument list sizes for sys_socketcall */ 19821da177e4SLinus Torvalds #define AL(x) ((x) * sizeof(unsigned long)) 198389bddce5SStephen Hemminger static const unsigned char nargs[18]={ 198489bddce5SStephen Hemminger AL(0),AL(3),AL(3),AL(3),AL(2),AL(3), 19851da177e4SLinus Torvalds AL(3),AL(3),AL(4),AL(4),AL(4),AL(6), 198689bddce5SStephen Hemminger AL(6),AL(2),AL(5),AL(5),AL(3),AL(3) 198789bddce5SStephen Hemminger }; 198889bddce5SStephen Hemminger 19891da177e4SLinus Torvalds #undef AL 19901da177e4SLinus Torvalds 19911da177e4SLinus Torvalds /* 19921da177e4SLinus Torvalds * System call vectors. 19931da177e4SLinus Torvalds * 19941da177e4SLinus Torvalds * Argument checking cleaned up. Saved 20% in size. 19951da177e4SLinus Torvalds * This function doesn't need to set the kernel lock because 19961da177e4SLinus Torvalds * it is set by the callees. 19971da177e4SLinus Torvalds */ 19981da177e4SLinus Torvalds 19991da177e4SLinus Torvalds asmlinkage long sys_socketcall(int call, unsigned long __user *args) 20001da177e4SLinus Torvalds { 20011da177e4SLinus Torvalds unsigned long a[6]; 20021da177e4SLinus Torvalds unsigned long a0, a1; 20031da177e4SLinus Torvalds int err; 20041da177e4SLinus Torvalds 20051da177e4SLinus Torvalds if (call < 1 || call > SYS_RECVMSG) 20061da177e4SLinus Torvalds return -EINVAL; 20071da177e4SLinus Torvalds 20081da177e4SLinus Torvalds /* copy_from_user should be SMP safe. */ 20091da177e4SLinus Torvalds if (copy_from_user(a, args, nargs[call])) 20101da177e4SLinus Torvalds return -EFAULT; 20111da177e4SLinus Torvalds 20124bcff1b3SDavid Woodhouse err = audit_socketcall(nargs[call] / sizeof(unsigned long), a); 20133ec3b2fbSDavid Woodhouse if (err) 20143ec3b2fbSDavid Woodhouse return err; 20153ec3b2fbSDavid Woodhouse 20161da177e4SLinus Torvalds a0 = a[0]; 20171da177e4SLinus Torvalds a1 = a[1]; 20181da177e4SLinus Torvalds 201989bddce5SStephen Hemminger switch (call) { 20201da177e4SLinus Torvalds case SYS_SOCKET: 20211da177e4SLinus Torvalds err = sys_socket(a0, a1, a[2]); 20221da177e4SLinus Torvalds break; 20231da177e4SLinus Torvalds case SYS_BIND: 20241da177e4SLinus Torvalds err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]); 20251da177e4SLinus Torvalds break; 20261da177e4SLinus Torvalds case SYS_CONNECT: 20271da177e4SLinus Torvalds err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]); 20281da177e4SLinus Torvalds break; 20291da177e4SLinus Torvalds case SYS_LISTEN: 20301da177e4SLinus Torvalds err = sys_listen(a0, a1); 20311da177e4SLinus Torvalds break; 20321da177e4SLinus Torvalds case SYS_ACCEPT: 203389bddce5SStephen Hemminger err = 203489bddce5SStephen Hemminger sys_accept(a0, (struct sockaddr __user *)a1, 203589bddce5SStephen Hemminger (int __user *)a[2]); 20361da177e4SLinus Torvalds break; 20371da177e4SLinus Torvalds case SYS_GETSOCKNAME: 203889bddce5SStephen Hemminger err = 203989bddce5SStephen Hemminger sys_getsockname(a0, (struct sockaddr __user *)a1, 204089bddce5SStephen Hemminger (int __user *)a[2]); 20411da177e4SLinus Torvalds break; 20421da177e4SLinus Torvalds case SYS_GETPEERNAME: 204389bddce5SStephen Hemminger err = 204489bddce5SStephen Hemminger sys_getpeername(a0, (struct sockaddr __user *)a1, 204589bddce5SStephen Hemminger (int __user *)a[2]); 20461da177e4SLinus Torvalds break; 20471da177e4SLinus Torvalds case SYS_SOCKETPAIR: 20481da177e4SLinus Torvalds err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]); 20491da177e4SLinus Torvalds break; 20501da177e4SLinus Torvalds case SYS_SEND: 20511da177e4SLinus Torvalds err = sys_send(a0, (void __user *)a1, a[2], a[3]); 20521da177e4SLinus Torvalds break; 20531da177e4SLinus Torvalds case SYS_SENDTO: 20541da177e4SLinus Torvalds err = sys_sendto(a0, (void __user *)a1, a[2], a[3], 20551da177e4SLinus Torvalds (struct sockaddr __user *)a[4], a[5]); 20561da177e4SLinus Torvalds break; 20571da177e4SLinus Torvalds case SYS_RECV: 20581da177e4SLinus Torvalds err = sys_recv(a0, (void __user *)a1, a[2], a[3]); 20591da177e4SLinus Torvalds break; 20601da177e4SLinus Torvalds case SYS_RECVFROM: 20611da177e4SLinus Torvalds err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3], 206289bddce5SStephen Hemminger (struct sockaddr __user *)a[4], 206389bddce5SStephen Hemminger (int __user *)a[5]); 20641da177e4SLinus Torvalds break; 20651da177e4SLinus Torvalds case SYS_SHUTDOWN: 20661da177e4SLinus Torvalds err = sys_shutdown(a0, a1); 20671da177e4SLinus Torvalds break; 20681da177e4SLinus Torvalds case SYS_SETSOCKOPT: 20691da177e4SLinus Torvalds err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]); 20701da177e4SLinus Torvalds break; 20711da177e4SLinus Torvalds case SYS_GETSOCKOPT: 207289bddce5SStephen Hemminger err = 207389bddce5SStephen Hemminger sys_getsockopt(a0, a1, a[2], (char __user *)a[3], 207489bddce5SStephen Hemminger (int __user *)a[4]); 20751da177e4SLinus Torvalds break; 20761da177e4SLinus Torvalds case SYS_SENDMSG: 20771da177e4SLinus Torvalds err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]); 20781da177e4SLinus Torvalds break; 20791da177e4SLinus Torvalds case SYS_RECVMSG: 20801da177e4SLinus Torvalds err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]); 20811da177e4SLinus Torvalds break; 20821da177e4SLinus Torvalds default: 20831da177e4SLinus Torvalds err = -EINVAL; 20841da177e4SLinus Torvalds break; 20851da177e4SLinus Torvalds } 20861da177e4SLinus Torvalds return err; 20871da177e4SLinus Torvalds } 20881da177e4SLinus Torvalds 20891da177e4SLinus Torvalds #endif /* __ARCH_WANT_SYS_SOCKETCALL */ 20901da177e4SLinus Torvalds 209155737fdaSStephen Hemminger /** 209255737fdaSStephen Hemminger * sock_register - add a socket protocol handler 209355737fdaSStephen Hemminger * @ops: description of protocol 209455737fdaSStephen Hemminger * 20951da177e4SLinus Torvalds * This function is called by a protocol handler that wants to 20961da177e4SLinus Torvalds * advertise its address family, and have it linked into the 209755737fdaSStephen Hemminger * socket interface. The value ops->family coresponds to the 209855737fdaSStephen Hemminger * socket system call protocol family. 20991da177e4SLinus Torvalds */ 2100f0fd27d4SStephen Hemminger int sock_register(const struct net_proto_family *ops) 21011da177e4SLinus Torvalds { 21021da177e4SLinus Torvalds int err; 21031da177e4SLinus Torvalds 21041da177e4SLinus Torvalds if (ops->family >= NPROTO) { 210589bddce5SStephen Hemminger printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family, 210689bddce5SStephen Hemminger NPROTO); 21071da177e4SLinus Torvalds return -ENOBUFS; 21081da177e4SLinus Torvalds } 210955737fdaSStephen Hemminger 211055737fdaSStephen Hemminger spin_lock(&net_family_lock); 211155737fdaSStephen Hemminger if (net_families[ops->family]) 21121da177e4SLinus Torvalds err = -EEXIST; 211355737fdaSStephen Hemminger else { 21141da177e4SLinus Torvalds net_families[ops->family] = ops; 21151da177e4SLinus Torvalds err = 0; 21161da177e4SLinus Torvalds } 211755737fdaSStephen Hemminger spin_unlock(&net_family_lock); 211855737fdaSStephen Hemminger 211989bddce5SStephen Hemminger printk(KERN_INFO "NET: Registered protocol family %d\n", ops->family); 21201da177e4SLinus Torvalds return err; 21211da177e4SLinus Torvalds } 21221da177e4SLinus Torvalds 212355737fdaSStephen Hemminger /** 212455737fdaSStephen Hemminger * sock_unregister - remove a protocol handler 212555737fdaSStephen Hemminger * @family: protocol family to remove 212655737fdaSStephen Hemminger * 21271da177e4SLinus Torvalds * This function is called by a protocol handler that wants to 21281da177e4SLinus Torvalds * remove its address family, and have it unlinked from the 212955737fdaSStephen Hemminger * new socket creation. 213055737fdaSStephen Hemminger * 213155737fdaSStephen Hemminger * If protocol handler is a module, then it can use module reference 213255737fdaSStephen Hemminger * counts to protect against new references. If protocol handler is not 213355737fdaSStephen Hemminger * a module then it needs to provide its own protection in 213455737fdaSStephen Hemminger * the ops->create routine. 21351da177e4SLinus Torvalds */ 2136f0fd27d4SStephen Hemminger void sock_unregister(int family) 21371da177e4SLinus Torvalds { 2138f0fd27d4SStephen Hemminger BUG_ON(family < 0 || family >= NPROTO); 21391da177e4SLinus Torvalds 214055737fdaSStephen Hemminger spin_lock(&net_family_lock); 21411da177e4SLinus Torvalds net_families[family] = NULL; 214255737fdaSStephen Hemminger spin_unlock(&net_family_lock); 214355737fdaSStephen Hemminger 214455737fdaSStephen Hemminger synchronize_rcu(); 214555737fdaSStephen Hemminger 214689bddce5SStephen Hemminger printk(KERN_INFO "NET: Unregistered protocol family %d\n", family); 21471da177e4SLinus Torvalds } 21481da177e4SLinus Torvalds 214977d76ea3SAndi Kleen static int __init sock_init(void) 21501da177e4SLinus Torvalds { 21511da177e4SLinus Torvalds /* 21521da177e4SLinus Torvalds * Initialize sock SLAB cache. 21531da177e4SLinus Torvalds */ 21541da177e4SLinus Torvalds 21551da177e4SLinus Torvalds sk_init(); 21561da177e4SLinus Torvalds 21571da177e4SLinus Torvalds /* 21581da177e4SLinus Torvalds * Initialize skbuff SLAB cache 21591da177e4SLinus Torvalds */ 21601da177e4SLinus Torvalds skb_init(); 21611da177e4SLinus Torvalds 21621da177e4SLinus Torvalds /* 21631da177e4SLinus Torvalds * Initialize the protocols module. 21641da177e4SLinus Torvalds */ 21651da177e4SLinus Torvalds 21661da177e4SLinus Torvalds init_inodecache(); 21671da177e4SLinus Torvalds register_filesystem(&sock_fs_type); 21681da177e4SLinus Torvalds sock_mnt = kern_mount(&sock_fs_type); 216977d76ea3SAndi Kleen 217077d76ea3SAndi Kleen /* The real protocol initialization is performed in later initcalls. 21711da177e4SLinus Torvalds */ 21721da177e4SLinus Torvalds 21731da177e4SLinus Torvalds #ifdef CONFIG_NETFILTER 21741da177e4SLinus Torvalds netfilter_init(); 21751da177e4SLinus Torvalds #endif 2176cbeb321aSDavid S. Miller 2177cbeb321aSDavid S. Miller return 0; 21781da177e4SLinus Torvalds } 21791da177e4SLinus Torvalds 218077d76ea3SAndi Kleen core_initcall(sock_init); /* early initcall */ 218177d76ea3SAndi Kleen 21821da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 21831da177e4SLinus Torvalds void socket_seq_show(struct seq_file *seq) 21841da177e4SLinus Torvalds { 21851da177e4SLinus Torvalds int cpu; 21861da177e4SLinus Torvalds int counter = 0; 21871da177e4SLinus Torvalds 21886f912042SKAMEZAWA Hiroyuki for_each_possible_cpu(cpu) 21891da177e4SLinus Torvalds counter += per_cpu(sockets_in_use, cpu); 21901da177e4SLinus Torvalds 21911da177e4SLinus Torvalds /* It can be negative, by the way. 8) */ 21921da177e4SLinus Torvalds if (counter < 0) 21931da177e4SLinus Torvalds counter = 0; 21941da177e4SLinus Torvalds 21951da177e4SLinus Torvalds seq_printf(seq, "sockets: used %d\n", counter); 21961da177e4SLinus Torvalds } 21971da177e4SLinus Torvalds #endif /* CONFIG_PROC_FS */ 21981da177e4SLinus Torvalds 219989bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 220089bbfc95SShaun Pereira static long compat_sock_ioctl(struct file *file, unsigned cmd, 220189bbfc95SShaun Pereira unsigned long arg) 220289bbfc95SShaun Pereira { 220389bbfc95SShaun Pereira struct socket *sock = file->private_data; 220489bbfc95SShaun Pereira int ret = -ENOIOCTLCMD; 220589bbfc95SShaun Pereira 220689bbfc95SShaun Pereira if (sock->ops->compat_ioctl) 220789bbfc95SShaun Pereira ret = sock->ops->compat_ioctl(sock, cmd, arg); 220889bbfc95SShaun Pereira 220989bbfc95SShaun Pereira return ret; 221089bbfc95SShaun Pereira } 221189bbfc95SShaun Pereira #endif 221289bbfc95SShaun Pereira 2213ac5a488eSSridhar Samudrala int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen) 2214ac5a488eSSridhar Samudrala { 2215ac5a488eSSridhar Samudrala return sock->ops->bind(sock, addr, addrlen); 2216ac5a488eSSridhar Samudrala } 2217ac5a488eSSridhar Samudrala 2218ac5a488eSSridhar Samudrala int kernel_listen(struct socket *sock, int backlog) 2219ac5a488eSSridhar Samudrala { 2220ac5a488eSSridhar Samudrala return sock->ops->listen(sock, backlog); 2221ac5a488eSSridhar Samudrala } 2222ac5a488eSSridhar Samudrala 2223ac5a488eSSridhar Samudrala int kernel_accept(struct socket *sock, struct socket **newsock, int flags) 2224ac5a488eSSridhar Samudrala { 2225ac5a488eSSridhar Samudrala struct sock *sk = sock->sk; 2226ac5a488eSSridhar Samudrala int err; 2227ac5a488eSSridhar Samudrala 2228ac5a488eSSridhar Samudrala err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 2229ac5a488eSSridhar Samudrala newsock); 2230ac5a488eSSridhar Samudrala if (err < 0) 2231ac5a488eSSridhar Samudrala goto done; 2232ac5a488eSSridhar Samudrala 2233ac5a488eSSridhar Samudrala err = sock->ops->accept(sock, *newsock, flags); 2234ac5a488eSSridhar Samudrala if (err < 0) { 2235ac5a488eSSridhar Samudrala sock_release(*newsock); 2236ac5a488eSSridhar Samudrala goto done; 2237ac5a488eSSridhar Samudrala } 2238ac5a488eSSridhar Samudrala 2239ac5a488eSSridhar Samudrala (*newsock)->ops = sock->ops; 2240ac5a488eSSridhar Samudrala 2241ac5a488eSSridhar Samudrala done: 2242ac5a488eSSridhar Samudrala return err; 2243ac5a488eSSridhar Samudrala } 2244ac5a488eSSridhar Samudrala 2245ac5a488eSSridhar Samudrala int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen, 2246ac5a488eSSridhar Samudrala int flags) 2247ac5a488eSSridhar Samudrala { 2248ac5a488eSSridhar Samudrala return sock->ops->connect(sock, addr, addrlen, flags); 2249ac5a488eSSridhar Samudrala } 2250ac5a488eSSridhar Samudrala 2251ac5a488eSSridhar Samudrala int kernel_getsockname(struct socket *sock, struct sockaddr *addr, 2252ac5a488eSSridhar Samudrala int *addrlen) 2253ac5a488eSSridhar Samudrala { 2254ac5a488eSSridhar Samudrala return sock->ops->getname(sock, addr, addrlen, 0); 2255ac5a488eSSridhar Samudrala } 2256ac5a488eSSridhar Samudrala 2257ac5a488eSSridhar Samudrala int kernel_getpeername(struct socket *sock, struct sockaddr *addr, 2258ac5a488eSSridhar Samudrala int *addrlen) 2259ac5a488eSSridhar Samudrala { 2260ac5a488eSSridhar Samudrala return sock->ops->getname(sock, addr, addrlen, 1); 2261ac5a488eSSridhar Samudrala } 2262ac5a488eSSridhar Samudrala 2263ac5a488eSSridhar Samudrala int kernel_getsockopt(struct socket *sock, int level, int optname, 2264ac5a488eSSridhar Samudrala char *optval, int *optlen) 2265ac5a488eSSridhar Samudrala { 2266ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 2267ac5a488eSSridhar Samudrala int err; 2268ac5a488eSSridhar Samudrala 2269ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 2270ac5a488eSSridhar Samudrala if (level == SOL_SOCKET) 2271ac5a488eSSridhar Samudrala err = sock_getsockopt(sock, level, optname, optval, optlen); 2272ac5a488eSSridhar Samudrala else 2273ac5a488eSSridhar Samudrala err = sock->ops->getsockopt(sock, level, optname, optval, 2274ac5a488eSSridhar Samudrala optlen); 2275ac5a488eSSridhar Samudrala set_fs(oldfs); 2276ac5a488eSSridhar Samudrala return err; 2277ac5a488eSSridhar Samudrala } 2278ac5a488eSSridhar Samudrala 2279ac5a488eSSridhar Samudrala int kernel_setsockopt(struct socket *sock, int level, int optname, 2280ac5a488eSSridhar Samudrala char *optval, int optlen) 2281ac5a488eSSridhar Samudrala { 2282ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 2283ac5a488eSSridhar Samudrala int err; 2284ac5a488eSSridhar Samudrala 2285ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 2286ac5a488eSSridhar Samudrala if (level == SOL_SOCKET) 2287ac5a488eSSridhar Samudrala err = sock_setsockopt(sock, level, optname, optval, optlen); 2288ac5a488eSSridhar Samudrala else 2289ac5a488eSSridhar Samudrala err = sock->ops->setsockopt(sock, level, optname, optval, 2290ac5a488eSSridhar Samudrala optlen); 2291ac5a488eSSridhar Samudrala set_fs(oldfs); 2292ac5a488eSSridhar Samudrala return err; 2293ac5a488eSSridhar Samudrala } 2294ac5a488eSSridhar Samudrala 2295ac5a488eSSridhar Samudrala int kernel_sendpage(struct socket *sock, struct page *page, int offset, 2296ac5a488eSSridhar Samudrala size_t size, int flags) 2297ac5a488eSSridhar Samudrala { 2298ac5a488eSSridhar Samudrala if (sock->ops->sendpage) 2299ac5a488eSSridhar Samudrala return sock->ops->sendpage(sock, page, offset, size, flags); 2300ac5a488eSSridhar Samudrala 2301ac5a488eSSridhar Samudrala return sock_no_sendpage(sock, page, offset, size, flags); 2302ac5a488eSSridhar Samudrala } 2303ac5a488eSSridhar Samudrala 2304ac5a488eSSridhar Samudrala int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg) 2305ac5a488eSSridhar Samudrala { 2306ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 2307ac5a488eSSridhar Samudrala int err; 2308ac5a488eSSridhar Samudrala 2309ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 2310ac5a488eSSridhar Samudrala err = sock->ops->ioctl(sock, cmd, arg); 2311ac5a488eSSridhar Samudrala set_fs(oldfs); 2312ac5a488eSSridhar Samudrala 2313ac5a488eSSridhar Samudrala return err; 2314ac5a488eSSridhar Samudrala } 2315ac5a488eSSridhar Samudrala 23161da177e4SLinus Torvalds /* ABI emulation layers need these two */ 23171da177e4SLinus Torvalds EXPORT_SYMBOL(move_addr_to_kernel); 23181da177e4SLinus Torvalds EXPORT_SYMBOL(move_addr_to_user); 23191da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create); 23201da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create_kern); 23211da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create_lite); 23221da177e4SLinus Torvalds EXPORT_SYMBOL(sock_map_fd); 23231da177e4SLinus Torvalds EXPORT_SYMBOL(sock_recvmsg); 23241da177e4SLinus Torvalds EXPORT_SYMBOL(sock_register); 23251da177e4SLinus Torvalds EXPORT_SYMBOL(sock_release); 23261da177e4SLinus Torvalds EXPORT_SYMBOL(sock_sendmsg); 23271da177e4SLinus Torvalds EXPORT_SYMBOL(sock_unregister); 23281da177e4SLinus Torvalds EXPORT_SYMBOL(sock_wake_async); 23291da177e4SLinus Torvalds EXPORT_SYMBOL(sockfd_lookup); 23301da177e4SLinus Torvalds EXPORT_SYMBOL(kernel_sendmsg); 23311da177e4SLinus Torvalds EXPORT_SYMBOL(kernel_recvmsg); 2332ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_bind); 2333ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_listen); 2334ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_accept); 2335ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_connect); 2336ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getsockname); 2337ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getpeername); 2338ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getsockopt); 2339ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_setsockopt); 2340ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_sendpage); 2341ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_sock_ioctl); 2342