11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * NET An implementation of the SOCKET network access protocol. 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Version: @(#)socket.c 1.1.93 18/02/95 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Authors: Orest Zborowski, <obz@Kodak.COM> 702c30a84SJesper Juhl * Ross Biro 81da177e4SLinus Torvalds * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 91da177e4SLinus Torvalds * 101da177e4SLinus Torvalds * Fixes: 111da177e4SLinus Torvalds * Anonymous : NOTSOCK/BADF cleanup. Error fix in 121da177e4SLinus Torvalds * shutdown() 131da177e4SLinus Torvalds * Alan Cox : verify_area() fixes 141da177e4SLinus Torvalds * Alan Cox : Removed DDI 151da177e4SLinus Torvalds * Jonathan Kamens : SOCK_DGRAM reconnect bug 161da177e4SLinus Torvalds * Alan Cox : Moved a load of checks to the very 171da177e4SLinus Torvalds * top level. 181da177e4SLinus Torvalds * Alan Cox : Move address structures to/from user 191da177e4SLinus Torvalds * mode above the protocol layers. 201da177e4SLinus Torvalds * Rob Janssen : Allow 0 length sends. 211da177e4SLinus Torvalds * Alan Cox : Asynchronous I/O support (cribbed from the 221da177e4SLinus Torvalds * tty drivers). 231da177e4SLinus Torvalds * Niibe Yutaka : Asynchronous I/O for writes (4.4BSD style) 241da177e4SLinus Torvalds * Jeff Uphoff : Made max number of sockets command-line 251da177e4SLinus Torvalds * configurable. 261da177e4SLinus Torvalds * Matti Aarnio : Made the number of sockets dynamic, 271da177e4SLinus Torvalds * to be allocated when needed, and mr. 281da177e4SLinus Torvalds * Uphoff's max is used as max to be 291da177e4SLinus Torvalds * allowed to allocate. 301da177e4SLinus Torvalds * Linus : Argh. removed all the socket allocation 311da177e4SLinus Torvalds * altogether: it's in the inode now. 321da177e4SLinus Torvalds * Alan Cox : Made sock_alloc()/sock_release() public 331da177e4SLinus Torvalds * for NetROM and future kernel nfsd type 341da177e4SLinus Torvalds * stuff. 351da177e4SLinus Torvalds * Alan Cox : sendmsg/recvmsg basics. 361da177e4SLinus Torvalds * Tom Dyas : Export net symbols. 371da177e4SLinus Torvalds * Marcin Dalecki : Fixed problems with CONFIG_NET="n". 381da177e4SLinus Torvalds * Alan Cox : Added thread locking to sys_* calls 391da177e4SLinus Torvalds * for sockets. May have errors at the 401da177e4SLinus Torvalds * moment. 411da177e4SLinus Torvalds * Kevin Buhr : Fixed the dumb errors in the above. 421da177e4SLinus Torvalds * Andi Kleen : Some small cleanups, optimizations, 431da177e4SLinus Torvalds * and fixed a copy_from_user() bug. 441da177e4SLinus Torvalds * Tigran Aivazian : sys_send(args) calls sys_sendto(args, NULL, 0) 451da177e4SLinus Torvalds * Tigran Aivazian : Made listen(2) backlog sanity checks 461da177e4SLinus Torvalds * protocol-independent 471da177e4SLinus Torvalds * 481da177e4SLinus Torvalds * 491da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or 501da177e4SLinus Torvalds * modify it under the terms of the GNU General Public License 511da177e4SLinus Torvalds * as published by the Free Software Foundation; either version 521da177e4SLinus Torvalds * 2 of the License, or (at your option) any later version. 531da177e4SLinus Torvalds * 541da177e4SLinus Torvalds * 551da177e4SLinus Torvalds * This module is effectively the top level interface to the BSD socket 561da177e4SLinus Torvalds * paradigm. 571da177e4SLinus Torvalds * 581da177e4SLinus Torvalds * Based upon Swansea University Computer Society NET3.039 591da177e4SLinus Torvalds */ 601da177e4SLinus Torvalds 611da177e4SLinus Torvalds #include <linux/mm.h> 621da177e4SLinus Torvalds #include <linux/socket.h> 631da177e4SLinus Torvalds #include <linux/file.h> 641da177e4SLinus Torvalds #include <linux/net.h> 651da177e4SLinus Torvalds #include <linux/interrupt.h> 66aaca0bdcSUlrich Drepper #include <linux/thread_info.h> 6755737fdaSStephen Hemminger #include <linux/rcupdate.h> 681da177e4SLinus Torvalds #include <linux/netdevice.h> 691da177e4SLinus Torvalds #include <linux/proc_fs.h> 701da177e4SLinus Torvalds #include <linux/seq_file.h> 714a3e2f71SArjan van de Ven #include <linux/mutex.h> 72c019bbc6SUlrich Drepper #include <linux/thread_info.h> 731da177e4SLinus Torvalds #include <linux/wanrouter.h> 741da177e4SLinus Torvalds #include <linux/if_bridge.h> 7520380731SArnaldo Carvalho de Melo #include <linux/if_frad.h> 7620380731SArnaldo Carvalho de Melo #include <linux/if_vlan.h> 771da177e4SLinus Torvalds #include <linux/init.h> 781da177e4SLinus Torvalds #include <linux/poll.h> 791da177e4SLinus Torvalds #include <linux/cache.h> 801da177e4SLinus Torvalds #include <linux/module.h> 811da177e4SLinus Torvalds #include <linux/highmem.h> 821da177e4SLinus Torvalds #include <linux/mount.h> 831da177e4SLinus Torvalds #include <linux/security.h> 841da177e4SLinus Torvalds #include <linux/syscalls.h> 851da177e4SLinus Torvalds #include <linux/compat.h> 861da177e4SLinus Torvalds #include <linux/kmod.h> 873ec3b2fbSDavid Woodhouse #include <linux/audit.h> 88d86b5e0eSAdrian Bunk #include <linux/wireless.h> 891b8d7ae4SEric W. Biederman #include <linux/nsproxy.h> 901da177e4SLinus Torvalds 911da177e4SLinus Torvalds #include <asm/uaccess.h> 921da177e4SLinus Torvalds #include <asm/unistd.h> 931da177e4SLinus Torvalds 941da177e4SLinus Torvalds #include <net/compat.h> 9587de87d5SDavid S. Miller #include <net/wext.h> 961da177e4SLinus Torvalds 971da177e4SLinus Torvalds #include <net/sock.h> 981da177e4SLinus Torvalds #include <linux/netfilter.h> 991da177e4SLinus Torvalds 1001da177e4SLinus Torvalds static int sock_no_open(struct inode *irrelevant, struct file *dontcare); 101027445c3SBadari Pulavarty static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov, 102027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos); 103027445c3SBadari Pulavarty static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov, 104027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos); 1051da177e4SLinus Torvalds static int sock_mmap(struct file *file, struct vm_area_struct *vma); 1061da177e4SLinus Torvalds 1071da177e4SLinus Torvalds static int sock_close(struct inode *inode, struct file *file); 1081da177e4SLinus Torvalds static unsigned int sock_poll(struct file *file, 1091da177e4SLinus Torvalds struct poll_table_struct *wait); 11089bddce5SStephen Hemminger static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg); 11189bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 11289bbfc95SShaun Pereira static long compat_sock_ioctl(struct file *file, 11389bbfc95SShaun Pereira unsigned int cmd, unsigned long arg); 11489bbfc95SShaun Pereira #endif 1151da177e4SLinus Torvalds static int sock_fasync(int fd, struct file *filp, int on); 1161da177e4SLinus Torvalds static ssize_t sock_sendpage(struct file *file, struct page *page, 1171da177e4SLinus Torvalds int offset, size_t size, loff_t *ppos, int more); 1189c55e01cSJens Axboe static ssize_t sock_splice_read(struct file *file, loff_t *ppos, 1199c55e01cSJens Axboe struct pipe_inode_info *pipe, size_t len, 1209c55e01cSJens Axboe unsigned int flags); 1211da177e4SLinus Torvalds 1221da177e4SLinus Torvalds /* 1231da177e4SLinus Torvalds * Socket files have a set of 'special' operations as well as the generic file ones. These don't appear 1241da177e4SLinus Torvalds * in the operation structures but are done directly via the socketcall() multiplexor. 1251da177e4SLinus Torvalds */ 1261da177e4SLinus Torvalds 127da7071d7SArjan van de Ven static const struct file_operations socket_file_ops = { 1281da177e4SLinus Torvalds .owner = THIS_MODULE, 1291da177e4SLinus Torvalds .llseek = no_llseek, 1301da177e4SLinus Torvalds .aio_read = sock_aio_read, 1311da177e4SLinus Torvalds .aio_write = sock_aio_write, 1321da177e4SLinus Torvalds .poll = sock_poll, 1331da177e4SLinus Torvalds .unlocked_ioctl = sock_ioctl, 13489bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 13589bbfc95SShaun Pereira .compat_ioctl = compat_sock_ioctl, 13689bbfc95SShaun Pereira #endif 1371da177e4SLinus Torvalds .mmap = sock_mmap, 1381da177e4SLinus Torvalds .open = sock_no_open, /* special open code to disallow open via /proc */ 1391da177e4SLinus Torvalds .release = sock_close, 1401da177e4SLinus Torvalds .fasync = sock_fasync, 1415274f052SJens Axboe .sendpage = sock_sendpage, 1425274f052SJens Axboe .splice_write = generic_splice_sendpage, 1439c55e01cSJens Axboe .splice_read = sock_splice_read, 1441da177e4SLinus Torvalds }; 1451da177e4SLinus Torvalds 1461da177e4SLinus Torvalds /* 1471da177e4SLinus Torvalds * The protocol list. Each protocol is registered in here. 1481da177e4SLinus Torvalds */ 1491da177e4SLinus Torvalds 1501da177e4SLinus Torvalds static DEFINE_SPINLOCK(net_family_lock); 151f0fd27d4SStephen Hemminger static const struct net_proto_family *net_families[NPROTO] __read_mostly; 1521da177e4SLinus Torvalds 1531da177e4SLinus Torvalds /* 1541da177e4SLinus Torvalds * Statistics counters of the socket lists 1551da177e4SLinus Torvalds */ 1561da177e4SLinus Torvalds 1571da177e4SLinus Torvalds static DEFINE_PER_CPU(int, sockets_in_use) = 0; 1581da177e4SLinus Torvalds 1591da177e4SLinus Torvalds /* 16089bddce5SStephen Hemminger * Support routines. 16189bddce5SStephen Hemminger * Move socket addresses back and forth across the kernel/user 1621da177e4SLinus Torvalds * divide and look after the messy bits. 1631da177e4SLinus Torvalds */ 1641da177e4SLinus Torvalds 1651da177e4SLinus Torvalds #define MAX_SOCK_ADDR 128 /* 108 for Unix domain - 1661da177e4SLinus Torvalds 16 for IP, 16 for IPX, 1671da177e4SLinus Torvalds 24 for IPv6, 1681da177e4SLinus Torvalds about 80 for AX.25 1691da177e4SLinus Torvalds must be at least one bigger than 1701da177e4SLinus Torvalds the AF_UNIX size (see net/unix/af_unix.c 1711da177e4SLinus Torvalds :unix_mkname()). 1721da177e4SLinus Torvalds */ 1731da177e4SLinus Torvalds 1741da177e4SLinus Torvalds /** 1751da177e4SLinus Torvalds * move_addr_to_kernel - copy a socket address into kernel space 1761da177e4SLinus Torvalds * @uaddr: Address in user space 1771da177e4SLinus Torvalds * @kaddr: Address in kernel space 1781da177e4SLinus Torvalds * @ulen: Length in user space 1791da177e4SLinus Torvalds * 1801da177e4SLinus Torvalds * The address is copied into kernel space. If the provided address is 1811da177e4SLinus Torvalds * too long an error code of -EINVAL is returned. If the copy gives 1821da177e4SLinus Torvalds * invalid addresses -EFAULT is returned. On a success 0 is returned. 1831da177e4SLinus Torvalds */ 1841da177e4SLinus Torvalds 185230b1839SYOSHIFUJI Hideaki int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr *kaddr) 1861da177e4SLinus Torvalds { 187230b1839SYOSHIFUJI Hideaki if (ulen < 0 || ulen > sizeof(struct sockaddr_storage)) 1881da177e4SLinus Torvalds return -EINVAL; 1891da177e4SLinus Torvalds if (ulen == 0) 1901da177e4SLinus Torvalds return 0; 1911da177e4SLinus Torvalds if (copy_from_user(kaddr, uaddr, ulen)) 1921da177e4SLinus Torvalds return -EFAULT; 1933ec3b2fbSDavid Woodhouse return audit_sockaddr(ulen, kaddr); 1941da177e4SLinus Torvalds } 1951da177e4SLinus Torvalds 1961da177e4SLinus Torvalds /** 1971da177e4SLinus Torvalds * move_addr_to_user - copy an address to user space 1981da177e4SLinus Torvalds * @kaddr: kernel space address 1991da177e4SLinus Torvalds * @klen: length of address in kernel 2001da177e4SLinus Torvalds * @uaddr: user space address 2011da177e4SLinus Torvalds * @ulen: pointer to user length field 2021da177e4SLinus Torvalds * 2031da177e4SLinus Torvalds * The value pointed to by ulen on entry is the buffer length available. 2041da177e4SLinus Torvalds * This is overwritten with the buffer space used. -EINVAL is returned 2051da177e4SLinus Torvalds * if an overlong buffer is specified or a negative buffer size. -EFAULT 2061da177e4SLinus Torvalds * is returned if either the buffer or the length field are not 2071da177e4SLinus Torvalds * accessible. 2081da177e4SLinus Torvalds * After copying the data up to the limit the user specifies, the true 2091da177e4SLinus Torvalds * length of the data is written over the length limit the user 2101da177e4SLinus Torvalds * specified. Zero is returned for a success. 2111da177e4SLinus Torvalds */ 2121da177e4SLinus Torvalds 213230b1839SYOSHIFUJI Hideaki int move_addr_to_user(struct sockaddr *kaddr, int klen, void __user *uaddr, 21489bddce5SStephen Hemminger int __user *ulen) 2151da177e4SLinus Torvalds { 2161da177e4SLinus Torvalds int err; 2171da177e4SLinus Torvalds int len; 2181da177e4SLinus Torvalds 21989bddce5SStephen Hemminger err = get_user(len, ulen); 22089bddce5SStephen Hemminger if (err) 2211da177e4SLinus Torvalds return err; 2221da177e4SLinus Torvalds if (len > klen) 2231da177e4SLinus Torvalds len = klen; 224230b1839SYOSHIFUJI Hideaki if (len < 0 || len > sizeof(struct sockaddr_storage)) 2251da177e4SLinus Torvalds return -EINVAL; 22689bddce5SStephen Hemminger if (len) { 227d6fe3945SSteve Grubb if (audit_sockaddr(klen, kaddr)) 228d6fe3945SSteve Grubb return -ENOMEM; 2291da177e4SLinus Torvalds if (copy_to_user(uaddr, kaddr, len)) 2301da177e4SLinus Torvalds return -EFAULT; 2311da177e4SLinus Torvalds } 2321da177e4SLinus Torvalds /* 2331da177e4SLinus Torvalds * "fromlen shall refer to the value before truncation.." 2341da177e4SLinus Torvalds * 1003.1g 2351da177e4SLinus Torvalds */ 2361da177e4SLinus Torvalds return __put_user(klen, ulen); 2371da177e4SLinus Torvalds } 2381da177e4SLinus Torvalds 2391da177e4SLinus Torvalds #define SOCKFS_MAGIC 0x534F434B 2401da177e4SLinus Torvalds 241e18b890bSChristoph Lameter static struct kmem_cache *sock_inode_cachep __read_mostly; 2421da177e4SLinus Torvalds 2431da177e4SLinus Torvalds static struct inode *sock_alloc_inode(struct super_block *sb) 2441da177e4SLinus Torvalds { 2451da177e4SLinus Torvalds struct socket_alloc *ei; 24689bddce5SStephen Hemminger 247e94b1766SChristoph Lameter ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL); 2481da177e4SLinus Torvalds if (!ei) 2491da177e4SLinus Torvalds return NULL; 2501da177e4SLinus Torvalds init_waitqueue_head(&ei->socket.wait); 2511da177e4SLinus Torvalds 2521da177e4SLinus Torvalds ei->socket.fasync_list = NULL; 2531da177e4SLinus Torvalds ei->socket.state = SS_UNCONNECTED; 2541da177e4SLinus Torvalds ei->socket.flags = 0; 2551da177e4SLinus Torvalds ei->socket.ops = NULL; 2561da177e4SLinus Torvalds ei->socket.sk = NULL; 2571da177e4SLinus Torvalds ei->socket.file = NULL; 2581da177e4SLinus Torvalds 2591da177e4SLinus Torvalds return &ei->vfs_inode; 2601da177e4SLinus Torvalds } 2611da177e4SLinus Torvalds 2621da177e4SLinus Torvalds static void sock_destroy_inode(struct inode *inode) 2631da177e4SLinus Torvalds { 2641da177e4SLinus Torvalds kmem_cache_free(sock_inode_cachep, 2651da177e4SLinus Torvalds container_of(inode, struct socket_alloc, vfs_inode)); 2661da177e4SLinus Torvalds } 2671da177e4SLinus Torvalds 2684ba9b9d0SChristoph Lameter static void init_once(struct kmem_cache *cachep, void *foo) 2691da177e4SLinus Torvalds { 2701da177e4SLinus Torvalds struct socket_alloc *ei = (struct socket_alloc *)foo; 2711da177e4SLinus Torvalds 2721da177e4SLinus Torvalds inode_init_once(&ei->vfs_inode); 2731da177e4SLinus Torvalds } 2741da177e4SLinus Torvalds 2751da177e4SLinus Torvalds static int init_inodecache(void) 2761da177e4SLinus Torvalds { 2771da177e4SLinus Torvalds sock_inode_cachep = kmem_cache_create("sock_inode_cache", 2781da177e4SLinus Torvalds sizeof(struct socket_alloc), 27989bddce5SStephen Hemminger 0, 28089bddce5SStephen Hemminger (SLAB_HWCACHE_ALIGN | 28189bddce5SStephen Hemminger SLAB_RECLAIM_ACCOUNT | 282fffb60f9SPaul Jackson SLAB_MEM_SPREAD), 28320c2df83SPaul Mundt init_once); 2841da177e4SLinus Torvalds if (sock_inode_cachep == NULL) 2851da177e4SLinus Torvalds return -ENOMEM; 2861da177e4SLinus Torvalds return 0; 2871da177e4SLinus Torvalds } 2881da177e4SLinus Torvalds 2891da177e4SLinus Torvalds static struct super_operations sockfs_ops = { 2901da177e4SLinus Torvalds .alloc_inode = sock_alloc_inode, 2911da177e4SLinus Torvalds .destroy_inode =sock_destroy_inode, 2921da177e4SLinus Torvalds .statfs = simple_statfs, 2931da177e4SLinus Torvalds }; 2941da177e4SLinus Torvalds 295454e2398SDavid Howells static int sockfs_get_sb(struct file_system_type *fs_type, 29689bddce5SStephen Hemminger int flags, const char *dev_name, void *data, 29789bddce5SStephen Hemminger struct vfsmount *mnt) 2981da177e4SLinus Torvalds { 299454e2398SDavid Howells return get_sb_pseudo(fs_type, "socket:", &sockfs_ops, SOCKFS_MAGIC, 300454e2398SDavid Howells mnt); 3011da177e4SLinus Torvalds } 3021da177e4SLinus Torvalds 303ba89966cSEric Dumazet static struct vfsmount *sock_mnt __read_mostly; 3041da177e4SLinus Torvalds 3051da177e4SLinus Torvalds static struct file_system_type sock_fs_type = { 3061da177e4SLinus Torvalds .name = "sockfs", 3071da177e4SLinus Torvalds .get_sb = sockfs_get_sb, 3081da177e4SLinus Torvalds .kill_sb = kill_anon_super, 3091da177e4SLinus Torvalds }; 31089bddce5SStephen Hemminger 3111da177e4SLinus Torvalds static int sockfs_delete_dentry(struct dentry *dentry) 3121da177e4SLinus Torvalds { 313304e61e6SEric Dumazet /* 314304e61e6SEric Dumazet * At creation time, we pretended this dentry was hashed 315304e61e6SEric Dumazet * (by clearing DCACHE_UNHASHED bit in d_flags) 316304e61e6SEric Dumazet * At delete time, we restore the truth : not hashed. 317304e61e6SEric Dumazet * (so that dput() can proceed correctly) 318304e61e6SEric Dumazet */ 319304e61e6SEric Dumazet dentry->d_flags |= DCACHE_UNHASHED; 320304e61e6SEric Dumazet return 0; 3211da177e4SLinus Torvalds } 322c23fbb6bSEric Dumazet 323c23fbb6bSEric Dumazet /* 324c23fbb6bSEric Dumazet * sockfs_dname() is called from d_path(). 325c23fbb6bSEric Dumazet */ 326c23fbb6bSEric Dumazet static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen) 327c23fbb6bSEric Dumazet { 328c23fbb6bSEric Dumazet return dynamic_dname(dentry, buffer, buflen, "socket:[%lu]", 329c23fbb6bSEric Dumazet dentry->d_inode->i_ino); 330c23fbb6bSEric Dumazet } 331c23fbb6bSEric Dumazet 3321da177e4SLinus Torvalds static struct dentry_operations sockfs_dentry_operations = { 3331da177e4SLinus Torvalds .d_delete = sockfs_delete_dentry, 334c23fbb6bSEric Dumazet .d_dname = sockfs_dname, 3351da177e4SLinus Torvalds }; 3361da177e4SLinus Torvalds 3371da177e4SLinus Torvalds /* 3381da177e4SLinus Torvalds * Obtains the first available file descriptor and sets it up for use. 3391da177e4SLinus Torvalds * 34039d8c1b6SDavid S. Miller * These functions create file structures and maps them to fd space 34139d8c1b6SDavid S. Miller * of the current process. On success it returns file descriptor 3421da177e4SLinus Torvalds * and file struct implicitly stored in sock->file. 3431da177e4SLinus Torvalds * Note that another thread may close file descriptor before we return 3441da177e4SLinus Torvalds * from this function. We use the fact that now we do not refer 3451da177e4SLinus Torvalds * to socket after mapping. If one day we will need it, this 3461da177e4SLinus Torvalds * function will increment ref. count on file by 1. 3471da177e4SLinus Torvalds * 3481da177e4SLinus Torvalds * In any case returned fd MAY BE not valid! 3491da177e4SLinus Torvalds * This race condition is unavoidable 3501da177e4SLinus Torvalds * with shared fd spaces, we cannot solve it inside kernel, 3511da177e4SLinus Torvalds * but we take care of internal coherence yet. 3521da177e4SLinus Torvalds */ 3531da177e4SLinus Torvalds 354a677a039SUlrich Drepper static int sock_alloc_fd(struct file **filep, int flags) 3551da177e4SLinus Torvalds { 3561da177e4SLinus Torvalds int fd; 3571da177e4SLinus Torvalds 358a677a039SUlrich Drepper fd = get_unused_fd_flags(flags); 35939d8c1b6SDavid S. Miller if (likely(fd >= 0)) { 3601da177e4SLinus Torvalds struct file *file = get_empty_filp(); 3611da177e4SLinus Torvalds 36239d8c1b6SDavid S. Miller *filep = file; 36339d8c1b6SDavid S. Miller if (unlikely(!file)) { 3641da177e4SLinus Torvalds put_unused_fd(fd); 36539d8c1b6SDavid S. Miller return -ENFILE; 3661da177e4SLinus Torvalds } 36739d8c1b6SDavid S. Miller } else 36839d8c1b6SDavid S. Miller *filep = NULL; 36939d8c1b6SDavid S. Miller return fd; 37039d8c1b6SDavid S. Miller } 37139d8c1b6SDavid S. Miller 37277d27200SUlrich Drepper static int sock_attach_fd(struct socket *sock, struct file *file, int flags) 37339d8c1b6SDavid S. Miller { 374ce8d2cdfSDave Hansen struct dentry *dentry; 375c23fbb6bSEric Dumazet struct qstr name = { .name = "" }; 3761da177e4SLinus Torvalds 377ce8d2cdfSDave Hansen dentry = d_alloc(sock_mnt->mnt_sb->s_root, &name); 378ce8d2cdfSDave Hansen if (unlikely(!dentry)) 37939d8c1b6SDavid S. Miller return -ENOMEM; 38039d8c1b6SDavid S. Miller 381ce8d2cdfSDave Hansen dentry->d_op = &sockfs_dentry_operations; 382304e61e6SEric Dumazet /* 383304e61e6SEric Dumazet * We dont want to push this dentry into global dentry hash table. 384304e61e6SEric Dumazet * We pretend dentry is already hashed, by unsetting DCACHE_UNHASHED 385304e61e6SEric Dumazet * This permits a working /proc/$pid/fd/XXX on sockets 386304e61e6SEric Dumazet */ 387ce8d2cdfSDave Hansen dentry->d_flags &= ~DCACHE_UNHASHED; 388ce8d2cdfSDave Hansen d_instantiate(dentry, SOCK_INODE(sock)); 3891da177e4SLinus Torvalds 3901da177e4SLinus Torvalds sock->file = file; 391ce8d2cdfSDave Hansen init_file(file, sock_mnt, dentry, FMODE_READ | FMODE_WRITE, 392ce8d2cdfSDave Hansen &socket_file_ops); 393ce8d2cdfSDave Hansen SOCK_INODE(sock)->i_fop = &socket_file_ops; 39477d27200SUlrich Drepper file->f_flags = O_RDWR | (flags & O_NONBLOCK); 3951da177e4SLinus Torvalds file->f_pos = 0; 39607dc3f07SBenjamin LaHaise file->private_data = sock; 39739d8c1b6SDavid S. Miller 39839d8c1b6SDavid S. Miller return 0; 3991da177e4SLinus Torvalds } 4001da177e4SLinus Torvalds 401a677a039SUlrich Drepper int sock_map_fd(struct socket *sock, int flags) 40239d8c1b6SDavid S. Miller { 40339d8c1b6SDavid S. Miller struct file *newfile; 404a677a039SUlrich Drepper int fd = sock_alloc_fd(&newfile, flags); 40539d8c1b6SDavid S. Miller 40639d8c1b6SDavid S. Miller if (likely(fd >= 0)) { 40777d27200SUlrich Drepper int err = sock_attach_fd(sock, newfile, flags); 40839d8c1b6SDavid S. Miller 40939d8c1b6SDavid S. Miller if (unlikely(err < 0)) { 41039d8c1b6SDavid S. Miller put_filp(newfile); 41139d8c1b6SDavid S. Miller put_unused_fd(fd); 41239d8c1b6SDavid S. Miller return err; 41339d8c1b6SDavid S. Miller } 41439d8c1b6SDavid S. Miller fd_install(fd, newfile); 41539d8c1b6SDavid S. Miller } 4161da177e4SLinus Torvalds return fd; 4171da177e4SLinus Torvalds } 4181da177e4SLinus Torvalds 4196cb153caSBenjamin LaHaise static struct socket *sock_from_file(struct file *file, int *err) 4206cb153caSBenjamin LaHaise { 4216cb153caSBenjamin LaHaise if (file->f_op == &socket_file_ops) 4226cb153caSBenjamin LaHaise return file->private_data; /* set in sock_map_fd */ 4236cb153caSBenjamin LaHaise 4246cb153caSBenjamin LaHaise *err = -ENOTSOCK; 4256cb153caSBenjamin LaHaise return NULL; 4266cb153caSBenjamin LaHaise } 4276cb153caSBenjamin LaHaise 4281da177e4SLinus Torvalds /** 4291da177e4SLinus Torvalds * sockfd_lookup - Go from a file number to its socket slot 4301da177e4SLinus Torvalds * @fd: file handle 4311da177e4SLinus Torvalds * @err: pointer to an error code return 4321da177e4SLinus Torvalds * 4331da177e4SLinus Torvalds * The file handle passed in is locked and the socket it is bound 4341da177e4SLinus Torvalds * too is returned. If an error occurs the err pointer is overwritten 4351da177e4SLinus Torvalds * with a negative errno code and NULL is returned. The function checks 4361da177e4SLinus Torvalds * for both invalid handles and passing a handle which is not a socket. 4371da177e4SLinus Torvalds * 4381da177e4SLinus Torvalds * On a success the socket object pointer is returned. 4391da177e4SLinus Torvalds */ 4401da177e4SLinus Torvalds 4411da177e4SLinus Torvalds struct socket *sockfd_lookup(int fd, int *err) 4421da177e4SLinus Torvalds { 4431da177e4SLinus Torvalds struct file *file; 4441da177e4SLinus Torvalds struct socket *sock; 4451da177e4SLinus Torvalds 44689bddce5SStephen Hemminger file = fget(fd); 44789bddce5SStephen Hemminger if (!file) { 4481da177e4SLinus Torvalds *err = -EBADF; 4491da177e4SLinus Torvalds return NULL; 4501da177e4SLinus Torvalds } 45189bddce5SStephen Hemminger 4526cb153caSBenjamin LaHaise sock = sock_from_file(file, err); 4536cb153caSBenjamin LaHaise if (!sock) 4541da177e4SLinus Torvalds fput(file); 4556cb153caSBenjamin LaHaise return sock; 4561da177e4SLinus Torvalds } 4571da177e4SLinus Torvalds 4586cb153caSBenjamin LaHaise static struct socket *sockfd_lookup_light(int fd, int *err, int *fput_needed) 4596cb153caSBenjamin LaHaise { 4606cb153caSBenjamin LaHaise struct file *file; 4616cb153caSBenjamin LaHaise struct socket *sock; 4626cb153caSBenjamin LaHaise 4633672558cSHua Zhong *err = -EBADF; 4646cb153caSBenjamin LaHaise file = fget_light(fd, fput_needed); 4656cb153caSBenjamin LaHaise if (file) { 4666cb153caSBenjamin LaHaise sock = sock_from_file(file, err); 4676cb153caSBenjamin LaHaise if (sock) 4681da177e4SLinus Torvalds return sock; 4696cb153caSBenjamin LaHaise fput_light(file, *fput_needed); 4706cb153caSBenjamin LaHaise } 4716cb153caSBenjamin LaHaise return NULL; 4721da177e4SLinus Torvalds } 4731da177e4SLinus Torvalds 4741da177e4SLinus Torvalds /** 4751da177e4SLinus Torvalds * sock_alloc - allocate a socket 4761da177e4SLinus Torvalds * 4771da177e4SLinus Torvalds * Allocate a new inode and socket object. The two are bound together 4781da177e4SLinus Torvalds * and initialised. The socket is then returned. If we are out of inodes 4791da177e4SLinus Torvalds * NULL is returned. 4801da177e4SLinus Torvalds */ 4811da177e4SLinus Torvalds 4821da177e4SLinus Torvalds static struct socket *sock_alloc(void) 4831da177e4SLinus Torvalds { 4841da177e4SLinus Torvalds struct inode *inode; 4851da177e4SLinus Torvalds struct socket *sock; 4861da177e4SLinus Torvalds 4871da177e4SLinus Torvalds inode = new_inode(sock_mnt->mnt_sb); 4881da177e4SLinus Torvalds if (!inode) 4891da177e4SLinus Torvalds return NULL; 4901da177e4SLinus Torvalds 4911da177e4SLinus Torvalds sock = SOCKET_I(inode); 4921da177e4SLinus Torvalds 4931da177e4SLinus Torvalds inode->i_mode = S_IFSOCK | S_IRWXUGO; 4941da177e4SLinus Torvalds inode->i_uid = current->fsuid; 4951da177e4SLinus Torvalds inode->i_gid = current->fsgid; 4961da177e4SLinus Torvalds 4971da177e4SLinus Torvalds get_cpu_var(sockets_in_use)++; 4981da177e4SLinus Torvalds put_cpu_var(sockets_in_use); 4991da177e4SLinus Torvalds return sock; 5001da177e4SLinus Torvalds } 5011da177e4SLinus Torvalds 5021da177e4SLinus Torvalds /* 5031da177e4SLinus Torvalds * In theory you can't get an open on this inode, but /proc provides 5041da177e4SLinus Torvalds * a back door. Remember to keep it shut otherwise you'll let the 5051da177e4SLinus Torvalds * creepy crawlies in. 5061da177e4SLinus Torvalds */ 5071da177e4SLinus Torvalds 5081da177e4SLinus Torvalds static int sock_no_open(struct inode *irrelevant, struct file *dontcare) 5091da177e4SLinus Torvalds { 5101da177e4SLinus Torvalds return -ENXIO; 5111da177e4SLinus Torvalds } 5121da177e4SLinus Torvalds 5134b6f5d20SArjan van de Ven const struct file_operations bad_sock_fops = { 5141da177e4SLinus Torvalds .owner = THIS_MODULE, 5151da177e4SLinus Torvalds .open = sock_no_open, 5161da177e4SLinus Torvalds }; 5171da177e4SLinus Torvalds 5181da177e4SLinus Torvalds /** 5191da177e4SLinus Torvalds * sock_release - close a socket 5201da177e4SLinus Torvalds * @sock: socket to close 5211da177e4SLinus Torvalds * 5221da177e4SLinus Torvalds * The socket is released from the protocol stack if it has a release 5231da177e4SLinus Torvalds * callback, and the inode is then released if the socket is bound to 5241da177e4SLinus Torvalds * an inode not a file. 5251da177e4SLinus Torvalds */ 5261da177e4SLinus Torvalds 5271da177e4SLinus Torvalds void sock_release(struct socket *sock) 5281da177e4SLinus Torvalds { 5291da177e4SLinus Torvalds if (sock->ops) { 5301da177e4SLinus Torvalds struct module *owner = sock->ops->owner; 5311da177e4SLinus Torvalds 5321da177e4SLinus Torvalds sock->ops->release(sock); 5331da177e4SLinus Torvalds sock->ops = NULL; 5341da177e4SLinus Torvalds module_put(owner); 5351da177e4SLinus Torvalds } 5361da177e4SLinus Torvalds 5371da177e4SLinus Torvalds if (sock->fasync_list) 5381da177e4SLinus Torvalds printk(KERN_ERR "sock_release: fasync list not empty!\n"); 5391da177e4SLinus Torvalds 5401da177e4SLinus Torvalds get_cpu_var(sockets_in_use)--; 5411da177e4SLinus Torvalds put_cpu_var(sockets_in_use); 5421da177e4SLinus Torvalds if (!sock->file) { 5431da177e4SLinus Torvalds iput(SOCK_INODE(sock)); 5441da177e4SLinus Torvalds return; 5451da177e4SLinus Torvalds } 5461da177e4SLinus Torvalds sock->file = NULL; 5471da177e4SLinus Torvalds } 5481da177e4SLinus Torvalds 5491da177e4SLinus Torvalds static inline int __sock_sendmsg(struct kiocb *iocb, struct socket *sock, 5501da177e4SLinus Torvalds struct msghdr *msg, size_t size) 5511da177e4SLinus Torvalds { 5521da177e4SLinus Torvalds struct sock_iocb *si = kiocb_to_siocb(iocb); 5531da177e4SLinus Torvalds int err; 5541da177e4SLinus Torvalds 5551da177e4SLinus Torvalds si->sock = sock; 5561da177e4SLinus Torvalds si->scm = NULL; 5571da177e4SLinus Torvalds si->msg = msg; 5581da177e4SLinus Torvalds si->size = size; 5591da177e4SLinus Torvalds 5601da177e4SLinus Torvalds err = security_socket_sendmsg(sock, msg, size); 5611da177e4SLinus Torvalds if (err) 5621da177e4SLinus Torvalds return err; 5631da177e4SLinus Torvalds 5641da177e4SLinus Torvalds return sock->ops->sendmsg(iocb, sock, msg, size); 5651da177e4SLinus Torvalds } 5661da177e4SLinus Torvalds 5671da177e4SLinus Torvalds int sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t size) 5681da177e4SLinus Torvalds { 5691da177e4SLinus Torvalds struct kiocb iocb; 5701da177e4SLinus Torvalds struct sock_iocb siocb; 5711da177e4SLinus Torvalds int ret; 5721da177e4SLinus Torvalds 5731da177e4SLinus Torvalds init_sync_kiocb(&iocb, NULL); 5741da177e4SLinus Torvalds iocb.private = &siocb; 5751da177e4SLinus Torvalds ret = __sock_sendmsg(&iocb, sock, msg, size); 5761da177e4SLinus Torvalds if (-EIOCBQUEUED == ret) 5771da177e4SLinus Torvalds ret = wait_on_sync_kiocb(&iocb); 5781da177e4SLinus Torvalds return ret; 5791da177e4SLinus Torvalds } 5801da177e4SLinus Torvalds 5811da177e4SLinus Torvalds int kernel_sendmsg(struct socket *sock, struct msghdr *msg, 5821da177e4SLinus Torvalds struct kvec *vec, size_t num, size_t size) 5831da177e4SLinus Torvalds { 5841da177e4SLinus Torvalds mm_segment_t oldfs = get_fs(); 5851da177e4SLinus Torvalds int result; 5861da177e4SLinus Torvalds 5871da177e4SLinus Torvalds set_fs(KERNEL_DS); 5881da177e4SLinus Torvalds /* 5891da177e4SLinus Torvalds * the following is safe, since for compiler definitions of kvec and 5901da177e4SLinus Torvalds * iovec are identical, yielding the same in-core layout and alignment 5911da177e4SLinus Torvalds */ 59289bddce5SStephen Hemminger msg->msg_iov = (struct iovec *)vec; 5931da177e4SLinus Torvalds msg->msg_iovlen = num; 5941da177e4SLinus Torvalds result = sock_sendmsg(sock, msg, size); 5951da177e4SLinus Torvalds set_fs(oldfs); 5961da177e4SLinus Torvalds return result; 5971da177e4SLinus Torvalds } 5981da177e4SLinus Torvalds 59992f37fd2SEric Dumazet /* 60092f37fd2SEric Dumazet * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP) 60192f37fd2SEric Dumazet */ 60292f37fd2SEric Dumazet void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk, 60392f37fd2SEric Dumazet struct sk_buff *skb) 60492f37fd2SEric Dumazet { 60592f37fd2SEric Dumazet ktime_t kt = skb->tstamp; 60692f37fd2SEric Dumazet 60792f37fd2SEric Dumazet if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) { 60892f37fd2SEric Dumazet struct timeval tv; 60992f37fd2SEric Dumazet /* Race occurred between timestamp enabling and packet 61092f37fd2SEric Dumazet receiving. Fill in the current time for now. */ 61192f37fd2SEric Dumazet if (kt.tv64 == 0) 61292f37fd2SEric Dumazet kt = ktime_get_real(); 61392f37fd2SEric Dumazet skb->tstamp = kt; 61492f37fd2SEric Dumazet tv = ktime_to_timeval(kt); 61592f37fd2SEric Dumazet put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP, sizeof(tv), &tv); 61692f37fd2SEric Dumazet } else { 61792f37fd2SEric Dumazet struct timespec ts; 61892f37fd2SEric Dumazet /* Race occurred between timestamp enabling and packet 61992f37fd2SEric Dumazet receiving. Fill in the current time for now. */ 62092f37fd2SEric Dumazet if (kt.tv64 == 0) 62192f37fd2SEric Dumazet kt = ktime_get_real(); 62292f37fd2SEric Dumazet skb->tstamp = kt; 62392f37fd2SEric Dumazet ts = ktime_to_timespec(kt); 62492f37fd2SEric Dumazet put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS, sizeof(ts), &ts); 62592f37fd2SEric Dumazet } 62692f37fd2SEric Dumazet } 62792f37fd2SEric Dumazet 6287c81fd8bSArnaldo Carvalho de Melo EXPORT_SYMBOL_GPL(__sock_recv_timestamp); 6297c81fd8bSArnaldo Carvalho de Melo 6301da177e4SLinus Torvalds static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock, 6311da177e4SLinus Torvalds struct msghdr *msg, size_t size, int flags) 6321da177e4SLinus Torvalds { 6331da177e4SLinus Torvalds int err; 6341da177e4SLinus Torvalds struct sock_iocb *si = kiocb_to_siocb(iocb); 6351da177e4SLinus Torvalds 6361da177e4SLinus Torvalds si->sock = sock; 6371da177e4SLinus Torvalds si->scm = NULL; 6381da177e4SLinus Torvalds si->msg = msg; 6391da177e4SLinus Torvalds si->size = size; 6401da177e4SLinus Torvalds si->flags = flags; 6411da177e4SLinus Torvalds 6421da177e4SLinus Torvalds err = security_socket_recvmsg(sock, msg, size, flags); 6431da177e4SLinus Torvalds if (err) 6441da177e4SLinus Torvalds return err; 6451da177e4SLinus Torvalds 6461da177e4SLinus Torvalds return sock->ops->recvmsg(iocb, sock, msg, size, flags); 6471da177e4SLinus Torvalds } 6481da177e4SLinus Torvalds 6491da177e4SLinus Torvalds int sock_recvmsg(struct socket *sock, struct msghdr *msg, 6501da177e4SLinus Torvalds size_t size, int flags) 6511da177e4SLinus Torvalds { 6521da177e4SLinus Torvalds struct kiocb iocb; 6531da177e4SLinus Torvalds struct sock_iocb siocb; 6541da177e4SLinus Torvalds int ret; 6551da177e4SLinus Torvalds 6561da177e4SLinus Torvalds init_sync_kiocb(&iocb, NULL); 6571da177e4SLinus Torvalds iocb.private = &siocb; 6581da177e4SLinus Torvalds ret = __sock_recvmsg(&iocb, sock, msg, size, flags); 6591da177e4SLinus Torvalds if (-EIOCBQUEUED == ret) 6601da177e4SLinus Torvalds ret = wait_on_sync_kiocb(&iocb); 6611da177e4SLinus Torvalds return ret; 6621da177e4SLinus Torvalds } 6631da177e4SLinus Torvalds 6641da177e4SLinus Torvalds int kernel_recvmsg(struct socket *sock, struct msghdr *msg, 66589bddce5SStephen Hemminger struct kvec *vec, size_t num, size_t size, int flags) 6661da177e4SLinus Torvalds { 6671da177e4SLinus Torvalds mm_segment_t oldfs = get_fs(); 6681da177e4SLinus Torvalds int result; 6691da177e4SLinus Torvalds 6701da177e4SLinus Torvalds set_fs(KERNEL_DS); 6711da177e4SLinus Torvalds /* 6721da177e4SLinus Torvalds * the following is safe, since for compiler definitions of kvec and 6731da177e4SLinus Torvalds * iovec are identical, yielding the same in-core layout and alignment 6741da177e4SLinus Torvalds */ 67589bddce5SStephen Hemminger msg->msg_iov = (struct iovec *)vec, msg->msg_iovlen = num; 6761da177e4SLinus Torvalds result = sock_recvmsg(sock, msg, size, flags); 6771da177e4SLinus Torvalds set_fs(oldfs); 6781da177e4SLinus Torvalds return result; 6791da177e4SLinus Torvalds } 6801da177e4SLinus Torvalds 6811da177e4SLinus Torvalds static void sock_aio_dtor(struct kiocb *iocb) 6821da177e4SLinus Torvalds { 6831da177e4SLinus Torvalds kfree(iocb->private); 6841da177e4SLinus Torvalds } 6851da177e4SLinus Torvalds 68620380731SArnaldo Carvalho de Melo static ssize_t sock_sendpage(struct file *file, struct page *page, 6871da177e4SLinus Torvalds int offset, size_t size, loff_t *ppos, int more) 6881da177e4SLinus Torvalds { 6891da177e4SLinus Torvalds struct socket *sock; 6901da177e4SLinus Torvalds int flags; 6911da177e4SLinus Torvalds 692b69aee04SEric Dumazet sock = file->private_data; 6931da177e4SLinus Torvalds 6941da177e4SLinus Torvalds flags = !(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT; 6951da177e4SLinus Torvalds if (more) 6961da177e4SLinus Torvalds flags |= MSG_MORE; 6971da177e4SLinus Torvalds 6981da177e4SLinus Torvalds return sock->ops->sendpage(sock, page, offset, size, flags); 6991da177e4SLinus Torvalds } 7001da177e4SLinus Torvalds 7019c55e01cSJens Axboe static ssize_t sock_splice_read(struct file *file, loff_t *ppos, 7029c55e01cSJens Axboe struct pipe_inode_info *pipe, size_t len, 7039c55e01cSJens Axboe unsigned int flags) 7049c55e01cSJens Axboe { 7059c55e01cSJens Axboe struct socket *sock = file->private_data; 7069c55e01cSJens Axboe 707997b37daSRémi Denis-Courmont if (unlikely(!sock->ops->splice_read)) 708997b37daSRémi Denis-Courmont return -EINVAL; 709997b37daSRémi Denis-Courmont 7109c55e01cSJens Axboe return sock->ops->splice_read(sock, ppos, pipe, len, flags); 7119c55e01cSJens Axboe } 7129c55e01cSJens Axboe 713ce1d4d3eSChristoph Hellwig static struct sock_iocb *alloc_sock_iocb(struct kiocb *iocb, 71489bddce5SStephen Hemminger struct sock_iocb *siocb) 715ce1d4d3eSChristoph Hellwig { 716ce1d4d3eSChristoph Hellwig if (!is_sync_kiocb(iocb)) { 717ce1d4d3eSChristoph Hellwig siocb = kmalloc(sizeof(*siocb), GFP_KERNEL); 718ce1d4d3eSChristoph Hellwig if (!siocb) 719ce1d4d3eSChristoph Hellwig return NULL; 720ce1d4d3eSChristoph Hellwig iocb->ki_dtor = sock_aio_dtor; 721ce1d4d3eSChristoph Hellwig } 722ce1d4d3eSChristoph Hellwig 723ce1d4d3eSChristoph Hellwig siocb->kiocb = iocb; 724ce1d4d3eSChristoph Hellwig iocb->private = siocb; 725ce1d4d3eSChristoph Hellwig return siocb; 726ce1d4d3eSChristoph Hellwig } 727ce1d4d3eSChristoph Hellwig 728ce1d4d3eSChristoph Hellwig static ssize_t do_sock_read(struct msghdr *msg, struct kiocb *iocb, 729027445c3SBadari Pulavarty struct file *file, const struct iovec *iov, 73089bddce5SStephen Hemminger unsigned long nr_segs) 731ce1d4d3eSChristoph Hellwig { 732ce1d4d3eSChristoph Hellwig struct socket *sock = file->private_data; 733ce1d4d3eSChristoph Hellwig size_t size = 0; 734ce1d4d3eSChristoph Hellwig int i; 735ce1d4d3eSChristoph Hellwig 736ce1d4d3eSChristoph Hellwig for (i = 0; i < nr_segs; i++) 737ce1d4d3eSChristoph Hellwig size += iov[i].iov_len; 738ce1d4d3eSChristoph Hellwig 739ce1d4d3eSChristoph Hellwig msg->msg_name = NULL; 740ce1d4d3eSChristoph Hellwig msg->msg_namelen = 0; 741ce1d4d3eSChristoph Hellwig msg->msg_control = NULL; 742ce1d4d3eSChristoph Hellwig msg->msg_controllen = 0; 743ce1d4d3eSChristoph Hellwig msg->msg_iov = (struct iovec *)iov; 744ce1d4d3eSChristoph Hellwig msg->msg_iovlen = nr_segs; 745ce1d4d3eSChristoph Hellwig msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0; 746ce1d4d3eSChristoph Hellwig 747ce1d4d3eSChristoph Hellwig return __sock_recvmsg(iocb, sock, msg, size, msg->msg_flags); 748ce1d4d3eSChristoph Hellwig } 749ce1d4d3eSChristoph Hellwig 750027445c3SBadari Pulavarty static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov, 751027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos) 752ce1d4d3eSChristoph Hellwig { 753ce1d4d3eSChristoph Hellwig struct sock_iocb siocb, *x; 754ce1d4d3eSChristoph Hellwig 755ce1d4d3eSChristoph Hellwig if (pos != 0) 756ce1d4d3eSChristoph Hellwig return -ESPIPE; 757027445c3SBadari Pulavarty 758027445c3SBadari Pulavarty if (iocb->ki_left == 0) /* Match SYS5 behaviour */ 759ce1d4d3eSChristoph Hellwig return 0; 760ce1d4d3eSChristoph Hellwig 761027445c3SBadari Pulavarty 762027445c3SBadari Pulavarty x = alloc_sock_iocb(iocb, &siocb); 763ce1d4d3eSChristoph Hellwig if (!x) 764ce1d4d3eSChristoph Hellwig return -ENOMEM; 765027445c3SBadari Pulavarty return do_sock_read(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs); 766ce1d4d3eSChristoph Hellwig } 767ce1d4d3eSChristoph Hellwig 768ce1d4d3eSChristoph Hellwig static ssize_t do_sock_write(struct msghdr *msg, struct kiocb *iocb, 769027445c3SBadari Pulavarty struct file *file, const struct iovec *iov, 77089bddce5SStephen Hemminger unsigned long nr_segs) 771ce1d4d3eSChristoph Hellwig { 772ce1d4d3eSChristoph Hellwig struct socket *sock = file->private_data; 773ce1d4d3eSChristoph Hellwig size_t size = 0; 774ce1d4d3eSChristoph Hellwig int i; 775ce1d4d3eSChristoph Hellwig 776ce1d4d3eSChristoph Hellwig for (i = 0; i < nr_segs; i++) 777ce1d4d3eSChristoph Hellwig size += iov[i].iov_len; 778ce1d4d3eSChristoph Hellwig 779ce1d4d3eSChristoph Hellwig msg->msg_name = NULL; 780ce1d4d3eSChristoph Hellwig msg->msg_namelen = 0; 781ce1d4d3eSChristoph Hellwig msg->msg_control = NULL; 782ce1d4d3eSChristoph Hellwig msg->msg_controllen = 0; 783ce1d4d3eSChristoph Hellwig msg->msg_iov = (struct iovec *)iov; 784ce1d4d3eSChristoph Hellwig msg->msg_iovlen = nr_segs; 785ce1d4d3eSChristoph Hellwig msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0; 786ce1d4d3eSChristoph Hellwig if (sock->type == SOCK_SEQPACKET) 787ce1d4d3eSChristoph Hellwig msg->msg_flags |= MSG_EOR; 788ce1d4d3eSChristoph Hellwig 789ce1d4d3eSChristoph Hellwig return __sock_sendmsg(iocb, sock, msg, size); 790ce1d4d3eSChristoph Hellwig } 791ce1d4d3eSChristoph Hellwig 792027445c3SBadari Pulavarty static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov, 793027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos) 7941da177e4SLinus Torvalds { 795ce1d4d3eSChristoph Hellwig struct sock_iocb siocb, *x; 7961da177e4SLinus Torvalds 797ce1d4d3eSChristoph Hellwig if (pos != 0) 798ce1d4d3eSChristoph Hellwig return -ESPIPE; 799027445c3SBadari Pulavarty 800027445c3SBadari Pulavarty x = alloc_sock_iocb(iocb, &siocb); 801ce1d4d3eSChristoph Hellwig if (!x) 802ce1d4d3eSChristoph Hellwig return -ENOMEM; 803ce1d4d3eSChristoph Hellwig 804027445c3SBadari Pulavarty return do_sock_write(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs); 8051da177e4SLinus Torvalds } 8061da177e4SLinus Torvalds 8071da177e4SLinus Torvalds /* 8081da177e4SLinus Torvalds * Atomic setting of ioctl hooks to avoid race 8091da177e4SLinus Torvalds * with module unload. 8101da177e4SLinus Torvalds */ 8111da177e4SLinus Torvalds 8124a3e2f71SArjan van de Ven static DEFINE_MUTEX(br_ioctl_mutex); 813881d966bSEric W. Biederman static int (*br_ioctl_hook) (struct net *, unsigned int cmd, void __user *arg) = NULL; 8141da177e4SLinus Torvalds 815881d966bSEric W. Biederman void brioctl_set(int (*hook) (struct net *, unsigned int, void __user *)) 8161da177e4SLinus Torvalds { 8174a3e2f71SArjan van de Ven mutex_lock(&br_ioctl_mutex); 8181da177e4SLinus Torvalds br_ioctl_hook = hook; 8194a3e2f71SArjan van de Ven mutex_unlock(&br_ioctl_mutex); 8201da177e4SLinus Torvalds } 82189bddce5SStephen Hemminger 8221da177e4SLinus Torvalds EXPORT_SYMBOL(brioctl_set); 8231da177e4SLinus Torvalds 8244a3e2f71SArjan van de Ven static DEFINE_MUTEX(vlan_ioctl_mutex); 825881d966bSEric W. Biederman static int (*vlan_ioctl_hook) (struct net *, void __user *arg); 8261da177e4SLinus Torvalds 827881d966bSEric W. Biederman void vlan_ioctl_set(int (*hook) (struct net *, void __user *)) 8281da177e4SLinus Torvalds { 8294a3e2f71SArjan van de Ven mutex_lock(&vlan_ioctl_mutex); 8301da177e4SLinus Torvalds vlan_ioctl_hook = hook; 8314a3e2f71SArjan van de Ven mutex_unlock(&vlan_ioctl_mutex); 8321da177e4SLinus Torvalds } 83389bddce5SStephen Hemminger 8341da177e4SLinus Torvalds EXPORT_SYMBOL(vlan_ioctl_set); 8351da177e4SLinus Torvalds 8364a3e2f71SArjan van de Ven static DEFINE_MUTEX(dlci_ioctl_mutex); 8371da177e4SLinus Torvalds static int (*dlci_ioctl_hook) (unsigned int, void __user *); 8381da177e4SLinus Torvalds 8391da177e4SLinus Torvalds void dlci_ioctl_set(int (*hook) (unsigned int, void __user *)) 8401da177e4SLinus Torvalds { 8414a3e2f71SArjan van de Ven mutex_lock(&dlci_ioctl_mutex); 8421da177e4SLinus Torvalds dlci_ioctl_hook = hook; 8434a3e2f71SArjan van de Ven mutex_unlock(&dlci_ioctl_mutex); 8441da177e4SLinus Torvalds } 84589bddce5SStephen Hemminger 8461da177e4SLinus Torvalds EXPORT_SYMBOL(dlci_ioctl_set); 8471da177e4SLinus Torvalds 8481da177e4SLinus Torvalds /* 8491da177e4SLinus Torvalds * With an ioctl, arg may well be a user mode pointer, but we don't know 8501da177e4SLinus Torvalds * what to do with it - that's up to the protocol still. 8511da177e4SLinus Torvalds */ 8521da177e4SLinus Torvalds 8531da177e4SLinus Torvalds static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg) 8541da177e4SLinus Torvalds { 8551da177e4SLinus Torvalds struct socket *sock; 856881d966bSEric W. Biederman struct sock *sk; 8571da177e4SLinus Torvalds void __user *argp = (void __user *)arg; 8581da177e4SLinus Torvalds int pid, err; 859881d966bSEric W. Biederman struct net *net; 8601da177e4SLinus Torvalds 861b69aee04SEric Dumazet sock = file->private_data; 862881d966bSEric W. Biederman sk = sock->sk; 8633b1e0a65SYOSHIFUJI Hideaki net = sock_net(sk); 8641da177e4SLinus Torvalds if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) { 865881d966bSEric W. Biederman err = dev_ioctl(net, cmd, argp); 8661da177e4SLinus Torvalds } else 867d86b5e0eSAdrian Bunk #ifdef CONFIG_WIRELESS_EXT 8681da177e4SLinus Torvalds if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) { 869881d966bSEric W. Biederman err = dev_ioctl(net, cmd, argp); 8701da177e4SLinus Torvalds } else 871d86b5e0eSAdrian Bunk #endif /* CONFIG_WIRELESS_EXT */ 8721da177e4SLinus Torvalds switch (cmd) { 8731da177e4SLinus Torvalds case FIOSETOWN: 8741da177e4SLinus Torvalds case SIOCSPGRP: 8751da177e4SLinus Torvalds err = -EFAULT; 8761da177e4SLinus Torvalds if (get_user(pid, (int __user *)argp)) 8771da177e4SLinus Torvalds break; 8781da177e4SLinus Torvalds err = f_setown(sock->file, pid, 1); 8791da177e4SLinus Torvalds break; 8801da177e4SLinus Torvalds case FIOGETOWN: 8811da177e4SLinus Torvalds case SIOCGPGRP: 882609d7fa9SEric W. Biederman err = put_user(f_getown(sock->file), 88389bddce5SStephen Hemminger (int __user *)argp); 8841da177e4SLinus Torvalds break; 8851da177e4SLinus Torvalds case SIOCGIFBR: 8861da177e4SLinus Torvalds case SIOCSIFBR: 8871da177e4SLinus Torvalds case SIOCBRADDBR: 8881da177e4SLinus Torvalds case SIOCBRDELBR: 8891da177e4SLinus Torvalds err = -ENOPKG; 8901da177e4SLinus Torvalds if (!br_ioctl_hook) 8911da177e4SLinus Torvalds request_module("bridge"); 8921da177e4SLinus Torvalds 8934a3e2f71SArjan van de Ven mutex_lock(&br_ioctl_mutex); 8941da177e4SLinus Torvalds if (br_ioctl_hook) 895881d966bSEric W. Biederman err = br_ioctl_hook(net, cmd, argp); 8964a3e2f71SArjan van de Ven mutex_unlock(&br_ioctl_mutex); 8971da177e4SLinus Torvalds break; 8981da177e4SLinus Torvalds case SIOCGIFVLAN: 8991da177e4SLinus Torvalds case SIOCSIFVLAN: 9001da177e4SLinus Torvalds err = -ENOPKG; 9011da177e4SLinus Torvalds if (!vlan_ioctl_hook) 9021da177e4SLinus Torvalds request_module("8021q"); 9031da177e4SLinus Torvalds 9044a3e2f71SArjan van de Ven mutex_lock(&vlan_ioctl_mutex); 9051da177e4SLinus Torvalds if (vlan_ioctl_hook) 906881d966bSEric W. Biederman err = vlan_ioctl_hook(net, argp); 9074a3e2f71SArjan van de Ven mutex_unlock(&vlan_ioctl_mutex); 9081da177e4SLinus Torvalds break; 9091da177e4SLinus Torvalds case SIOCADDDLCI: 9101da177e4SLinus Torvalds case SIOCDELDLCI: 9111da177e4SLinus Torvalds err = -ENOPKG; 9121da177e4SLinus Torvalds if (!dlci_ioctl_hook) 9131da177e4SLinus Torvalds request_module("dlci"); 9141da177e4SLinus Torvalds 9154a3e2f71SArjan van de Ven mutex_lock(&dlci_ioctl_mutex); 9167512cbf6SPavel Emelyanov if (dlci_ioctl_hook) 9171da177e4SLinus Torvalds err = dlci_ioctl_hook(cmd, argp); 9184a3e2f71SArjan van de Ven mutex_unlock(&dlci_ioctl_mutex); 9191da177e4SLinus Torvalds break; 9201da177e4SLinus Torvalds default: 9211da177e4SLinus Torvalds err = sock->ops->ioctl(sock, cmd, arg); 922b5e5fa5eSChristoph Hellwig 923b5e5fa5eSChristoph Hellwig /* 924b5e5fa5eSChristoph Hellwig * If this ioctl is unknown try to hand it down 925b5e5fa5eSChristoph Hellwig * to the NIC driver. 926b5e5fa5eSChristoph Hellwig */ 927b5e5fa5eSChristoph Hellwig if (err == -ENOIOCTLCMD) 928881d966bSEric W. Biederman err = dev_ioctl(net, cmd, argp); 9291da177e4SLinus Torvalds break; 9301da177e4SLinus Torvalds } 9311da177e4SLinus Torvalds return err; 9321da177e4SLinus Torvalds } 9331da177e4SLinus Torvalds 9341da177e4SLinus Torvalds int sock_create_lite(int family, int type, int protocol, struct socket **res) 9351da177e4SLinus Torvalds { 9361da177e4SLinus Torvalds int err; 9371da177e4SLinus Torvalds struct socket *sock = NULL; 9381da177e4SLinus Torvalds 9391da177e4SLinus Torvalds err = security_socket_create(family, type, protocol, 1); 9401da177e4SLinus Torvalds if (err) 9411da177e4SLinus Torvalds goto out; 9421da177e4SLinus Torvalds 9431da177e4SLinus Torvalds sock = sock_alloc(); 9441da177e4SLinus Torvalds if (!sock) { 9451da177e4SLinus Torvalds err = -ENOMEM; 9461da177e4SLinus Torvalds goto out; 9471da177e4SLinus Torvalds } 9481da177e4SLinus Torvalds 9491da177e4SLinus Torvalds sock->type = type; 9507420ed23SVenkat Yekkirala err = security_socket_post_create(sock, family, type, protocol, 1); 9517420ed23SVenkat Yekkirala if (err) 9527420ed23SVenkat Yekkirala goto out_release; 9537420ed23SVenkat Yekkirala 9541da177e4SLinus Torvalds out: 9551da177e4SLinus Torvalds *res = sock; 9561da177e4SLinus Torvalds return err; 9577420ed23SVenkat Yekkirala out_release: 9587420ed23SVenkat Yekkirala sock_release(sock); 9597420ed23SVenkat Yekkirala sock = NULL; 9607420ed23SVenkat Yekkirala goto out; 9611da177e4SLinus Torvalds } 9621da177e4SLinus Torvalds 9631da177e4SLinus Torvalds /* No kernel lock held - perfect */ 9641da177e4SLinus Torvalds static unsigned int sock_poll(struct file *file, poll_table *wait) 9651da177e4SLinus Torvalds { 9661da177e4SLinus Torvalds struct socket *sock; 9671da177e4SLinus Torvalds 9681da177e4SLinus Torvalds /* 9691da177e4SLinus Torvalds * We can't return errors to poll, so it's either yes or no. 9701da177e4SLinus Torvalds */ 971b69aee04SEric Dumazet sock = file->private_data; 9721da177e4SLinus Torvalds return sock->ops->poll(file, sock, wait); 9731da177e4SLinus Torvalds } 9741da177e4SLinus Torvalds 9751da177e4SLinus Torvalds static int sock_mmap(struct file *file, struct vm_area_struct *vma) 9761da177e4SLinus Torvalds { 977b69aee04SEric Dumazet struct socket *sock = file->private_data; 9781da177e4SLinus Torvalds 9791da177e4SLinus Torvalds return sock->ops->mmap(file, sock, vma); 9801da177e4SLinus Torvalds } 9811da177e4SLinus Torvalds 98220380731SArnaldo Carvalho de Melo static int sock_close(struct inode *inode, struct file *filp) 9831da177e4SLinus Torvalds { 9841da177e4SLinus Torvalds /* 9851da177e4SLinus Torvalds * It was possible the inode is NULL we were 9861da177e4SLinus Torvalds * closing an unfinished socket. 9871da177e4SLinus Torvalds */ 9881da177e4SLinus Torvalds 98989bddce5SStephen Hemminger if (!inode) { 9901da177e4SLinus Torvalds printk(KERN_DEBUG "sock_close: NULL inode\n"); 9911da177e4SLinus Torvalds return 0; 9921da177e4SLinus Torvalds } 9931da177e4SLinus Torvalds sock_fasync(-1, filp, 0); 9941da177e4SLinus Torvalds sock_release(SOCKET_I(inode)); 9951da177e4SLinus Torvalds return 0; 9961da177e4SLinus Torvalds } 9971da177e4SLinus Torvalds 9981da177e4SLinus Torvalds /* 9991da177e4SLinus Torvalds * Update the socket async list 10001da177e4SLinus Torvalds * 10011da177e4SLinus Torvalds * Fasync_list locking strategy. 10021da177e4SLinus Torvalds * 10031da177e4SLinus Torvalds * 1. fasync_list is modified only under process context socket lock 10041da177e4SLinus Torvalds * i.e. under semaphore. 10051da177e4SLinus Torvalds * 2. fasync_list is used under read_lock(&sk->sk_callback_lock) 10061da177e4SLinus Torvalds * or under socket lock. 10071da177e4SLinus Torvalds * 3. fasync_list can be used from softirq context, so that 10081da177e4SLinus Torvalds * modification under socket lock have to be enhanced with 10091da177e4SLinus Torvalds * write_lock_bh(&sk->sk_callback_lock). 10101da177e4SLinus Torvalds * --ANK (990710) 10111da177e4SLinus Torvalds */ 10121da177e4SLinus Torvalds 10131da177e4SLinus Torvalds static int sock_fasync(int fd, struct file *filp, int on) 10141da177e4SLinus Torvalds { 10151da177e4SLinus Torvalds struct fasync_struct *fa, *fna = NULL, **prev; 10161da177e4SLinus Torvalds struct socket *sock; 10171da177e4SLinus Torvalds struct sock *sk; 10181da177e4SLinus Torvalds 101989bddce5SStephen Hemminger if (on) { 10208b3a7005SKris Katterjohn fna = kmalloc(sizeof(struct fasync_struct), GFP_KERNEL); 10211da177e4SLinus Torvalds if (fna == NULL) 10221da177e4SLinus Torvalds return -ENOMEM; 10231da177e4SLinus Torvalds } 10241da177e4SLinus Torvalds 1025b69aee04SEric Dumazet sock = filp->private_data; 10261da177e4SLinus Torvalds 102789bddce5SStephen Hemminger sk = sock->sk; 102889bddce5SStephen Hemminger if (sk == NULL) { 10291da177e4SLinus Torvalds kfree(fna); 10301da177e4SLinus Torvalds return -EINVAL; 10311da177e4SLinus Torvalds } 10321da177e4SLinus Torvalds 10331da177e4SLinus Torvalds lock_sock(sk); 10341da177e4SLinus Torvalds 10351da177e4SLinus Torvalds prev = &(sock->fasync_list); 10361da177e4SLinus Torvalds 10371da177e4SLinus Torvalds for (fa = *prev; fa != NULL; prev = &fa->fa_next, fa = *prev) 10381da177e4SLinus Torvalds if (fa->fa_file == filp) 10391da177e4SLinus Torvalds break; 10401da177e4SLinus Torvalds 104189bddce5SStephen Hemminger if (on) { 104289bddce5SStephen Hemminger if (fa != NULL) { 10431da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 10441da177e4SLinus Torvalds fa->fa_fd = fd; 10451da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 10461da177e4SLinus Torvalds 10471da177e4SLinus Torvalds kfree(fna); 10481da177e4SLinus Torvalds goto out; 10491da177e4SLinus Torvalds } 10501da177e4SLinus Torvalds fna->fa_file = filp; 10511da177e4SLinus Torvalds fna->fa_fd = fd; 10521da177e4SLinus Torvalds fna->magic = FASYNC_MAGIC; 10531da177e4SLinus Torvalds fna->fa_next = sock->fasync_list; 10541da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 10551da177e4SLinus Torvalds sock->fasync_list = fna; 10561da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 105789bddce5SStephen Hemminger } else { 105889bddce5SStephen Hemminger if (fa != NULL) { 10591da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 10601da177e4SLinus Torvalds *prev = fa->fa_next; 10611da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 10621da177e4SLinus Torvalds kfree(fa); 10631da177e4SLinus Torvalds } 10641da177e4SLinus Torvalds } 10651da177e4SLinus Torvalds 10661da177e4SLinus Torvalds out: 10671da177e4SLinus Torvalds release_sock(sock->sk); 10681da177e4SLinus Torvalds return 0; 10691da177e4SLinus Torvalds } 10701da177e4SLinus Torvalds 10711da177e4SLinus Torvalds /* This function may be called only under socket lock or callback_lock */ 10721da177e4SLinus Torvalds 10731da177e4SLinus Torvalds int sock_wake_async(struct socket *sock, int how, int band) 10741da177e4SLinus Torvalds { 10751da177e4SLinus Torvalds if (!sock || !sock->fasync_list) 10761da177e4SLinus Torvalds return -1; 107789bddce5SStephen Hemminger switch (how) { 10788d8ad9d7SPavel Emelyanov case SOCK_WAKE_WAITD: 10791da177e4SLinus Torvalds if (test_bit(SOCK_ASYNC_WAITDATA, &sock->flags)) 10801da177e4SLinus Torvalds break; 10811da177e4SLinus Torvalds goto call_kill; 10828d8ad9d7SPavel Emelyanov case SOCK_WAKE_SPACE: 10831da177e4SLinus Torvalds if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags)) 10841da177e4SLinus Torvalds break; 10851da177e4SLinus Torvalds /* fall through */ 10868d8ad9d7SPavel Emelyanov case SOCK_WAKE_IO: 10871da177e4SLinus Torvalds call_kill: 10881da177e4SLinus Torvalds __kill_fasync(sock->fasync_list, SIGIO, band); 10891da177e4SLinus Torvalds break; 10908d8ad9d7SPavel Emelyanov case SOCK_WAKE_URG: 10911da177e4SLinus Torvalds __kill_fasync(sock->fasync_list, SIGURG, band); 10921da177e4SLinus Torvalds } 10931da177e4SLinus Torvalds return 0; 10941da177e4SLinus Torvalds } 10951da177e4SLinus Torvalds 10961b8d7ae4SEric W. Biederman static int __sock_create(struct net *net, int family, int type, int protocol, 109789bddce5SStephen Hemminger struct socket **res, int kern) 10981da177e4SLinus Torvalds { 10991da177e4SLinus Torvalds int err; 11001da177e4SLinus Torvalds struct socket *sock; 110155737fdaSStephen Hemminger const struct net_proto_family *pf; 11021da177e4SLinus Torvalds 11031da177e4SLinus Torvalds /* 11041da177e4SLinus Torvalds * Check protocol is in range 11051da177e4SLinus Torvalds */ 11061da177e4SLinus Torvalds if (family < 0 || family >= NPROTO) 11071da177e4SLinus Torvalds return -EAFNOSUPPORT; 11081da177e4SLinus Torvalds if (type < 0 || type >= SOCK_MAX) 11091da177e4SLinus Torvalds return -EINVAL; 11101da177e4SLinus Torvalds 11111da177e4SLinus Torvalds /* Compatibility. 11121da177e4SLinus Torvalds 11131da177e4SLinus Torvalds This uglymoron is moved from INET layer to here to avoid 11141da177e4SLinus Torvalds deadlock in module load. 11151da177e4SLinus Torvalds */ 11161da177e4SLinus Torvalds if (family == PF_INET && type == SOCK_PACKET) { 11171da177e4SLinus Torvalds static int warned; 11181da177e4SLinus Torvalds if (!warned) { 11191da177e4SLinus Torvalds warned = 1; 112089bddce5SStephen Hemminger printk(KERN_INFO "%s uses obsolete (PF_INET,SOCK_PACKET)\n", 112189bddce5SStephen Hemminger current->comm); 11221da177e4SLinus Torvalds } 11231da177e4SLinus Torvalds family = PF_PACKET; 11241da177e4SLinus Torvalds } 11251da177e4SLinus Torvalds 11261da177e4SLinus Torvalds err = security_socket_create(family, type, protocol, kern); 11271da177e4SLinus Torvalds if (err) 11281da177e4SLinus Torvalds return err; 11291da177e4SLinus Torvalds 113055737fdaSStephen Hemminger /* 113155737fdaSStephen Hemminger * Allocate the socket and allow the family to set things up. if 113255737fdaSStephen Hemminger * the protocol is 0, the family is instructed to select an appropriate 113355737fdaSStephen Hemminger * default. 113455737fdaSStephen Hemminger */ 113555737fdaSStephen Hemminger sock = sock_alloc(); 113655737fdaSStephen Hemminger if (!sock) { 113755737fdaSStephen Hemminger if (net_ratelimit()) 113855737fdaSStephen Hemminger printk(KERN_WARNING "socket: no more sockets\n"); 113955737fdaSStephen Hemminger return -ENFILE; /* Not exactly a match, but its the 114055737fdaSStephen Hemminger closest posix thing */ 114155737fdaSStephen Hemminger } 114255737fdaSStephen Hemminger 114355737fdaSStephen Hemminger sock->type = type; 114455737fdaSStephen Hemminger 11451da177e4SLinus Torvalds #if defined(CONFIG_KMOD) 11461da177e4SLinus Torvalds /* Attempt to load a protocol module if the find failed. 11471da177e4SLinus Torvalds * 11481da177e4SLinus Torvalds * 12/09/1996 Marcin: But! this makes REALLY only sense, if the user 11491da177e4SLinus Torvalds * requested real, full-featured networking support upon configuration. 11501da177e4SLinus Torvalds * Otherwise module support will break! 11511da177e4SLinus Torvalds */ 115255737fdaSStephen Hemminger if (net_families[family] == NULL) 11531da177e4SLinus Torvalds request_module("net-pf-%d", family); 11541da177e4SLinus Torvalds #endif 11551da177e4SLinus Torvalds 115655737fdaSStephen Hemminger rcu_read_lock(); 115755737fdaSStephen Hemminger pf = rcu_dereference(net_families[family]); 11581da177e4SLinus Torvalds err = -EAFNOSUPPORT; 115955737fdaSStephen Hemminger if (!pf) 116055737fdaSStephen Hemminger goto out_release; 11611da177e4SLinus Torvalds 11621da177e4SLinus Torvalds /* 11631da177e4SLinus Torvalds * We will call the ->create function, that possibly is in a loadable 11641da177e4SLinus Torvalds * module, so we have to bump that loadable module refcnt first. 11651da177e4SLinus Torvalds */ 116655737fdaSStephen Hemminger if (!try_module_get(pf->owner)) 11671da177e4SLinus Torvalds goto out_release; 11681da177e4SLinus Torvalds 116955737fdaSStephen Hemminger /* Now protected by module ref count */ 117055737fdaSStephen Hemminger rcu_read_unlock(); 117155737fdaSStephen Hemminger 11721b8d7ae4SEric W. Biederman err = pf->create(net, sock, protocol); 117355737fdaSStephen Hemminger if (err < 0) 11741da177e4SLinus Torvalds goto out_module_put; 1175a79af59eSFrank Filz 11761da177e4SLinus Torvalds /* 11771da177e4SLinus Torvalds * Now to bump the refcnt of the [loadable] module that owns this 11781da177e4SLinus Torvalds * socket at sock_release time we decrement its refcnt. 11791da177e4SLinus Torvalds */ 118055737fdaSStephen Hemminger if (!try_module_get(sock->ops->owner)) 118155737fdaSStephen Hemminger goto out_module_busy; 118255737fdaSStephen Hemminger 11831da177e4SLinus Torvalds /* 11841da177e4SLinus Torvalds * Now that we're done with the ->create function, the [loadable] 11851da177e4SLinus Torvalds * module can have its refcnt decremented 11861da177e4SLinus Torvalds */ 118755737fdaSStephen Hemminger module_put(pf->owner); 11887420ed23SVenkat Yekkirala err = security_socket_post_create(sock, family, type, protocol, kern); 11897420ed23SVenkat Yekkirala if (err) 11903b185525SHerbert Xu goto out_sock_release; 119155737fdaSStephen Hemminger *res = sock; 11921da177e4SLinus Torvalds 119355737fdaSStephen Hemminger return 0; 119455737fdaSStephen Hemminger 119555737fdaSStephen Hemminger out_module_busy: 119655737fdaSStephen Hemminger err = -EAFNOSUPPORT; 11971da177e4SLinus Torvalds out_module_put: 119855737fdaSStephen Hemminger sock->ops = NULL; 119955737fdaSStephen Hemminger module_put(pf->owner); 120055737fdaSStephen Hemminger out_sock_release: 12011da177e4SLinus Torvalds sock_release(sock); 120255737fdaSStephen Hemminger return err; 120355737fdaSStephen Hemminger 120455737fdaSStephen Hemminger out_release: 120555737fdaSStephen Hemminger rcu_read_unlock(); 120655737fdaSStephen Hemminger goto out_sock_release; 12071da177e4SLinus Torvalds } 12081da177e4SLinus Torvalds 12091da177e4SLinus Torvalds int sock_create(int family, int type, int protocol, struct socket **res) 12101da177e4SLinus Torvalds { 12111b8d7ae4SEric W. Biederman return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0); 12121da177e4SLinus Torvalds } 12131da177e4SLinus Torvalds 12141da177e4SLinus Torvalds int sock_create_kern(int family, int type, int protocol, struct socket **res) 12151da177e4SLinus Torvalds { 12161b8d7ae4SEric W. Biederman return __sock_create(&init_net, family, type, protocol, res, 1); 12171da177e4SLinus Torvalds } 12181da177e4SLinus Torvalds 12191da177e4SLinus Torvalds asmlinkage long sys_socket(int family, int type, int protocol) 12201da177e4SLinus Torvalds { 12211da177e4SLinus Torvalds int retval; 12221da177e4SLinus Torvalds struct socket *sock; 1223a677a039SUlrich Drepper int flags; 1224a677a039SUlrich Drepper 1225e38b36f3SUlrich Drepper /* Check the SOCK_* constants for consistency. */ 1226e38b36f3SUlrich Drepper BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC); 1227e38b36f3SUlrich Drepper BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK); 1228e38b36f3SUlrich Drepper BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK); 1229e38b36f3SUlrich Drepper BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK); 1230e38b36f3SUlrich Drepper 1231a677a039SUlrich Drepper flags = type & ~SOCK_TYPE_MASK; 123277d27200SUlrich Drepper if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)) 1233a677a039SUlrich Drepper return -EINVAL; 1234a677a039SUlrich Drepper type &= SOCK_TYPE_MASK; 12351da177e4SLinus Torvalds 1236aaca0bdcSUlrich Drepper if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK)) 1237aaca0bdcSUlrich Drepper flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK; 1238aaca0bdcSUlrich Drepper 12391da177e4SLinus Torvalds retval = sock_create(family, type, protocol, &sock); 12401da177e4SLinus Torvalds if (retval < 0) 12411da177e4SLinus Torvalds goto out; 12421da177e4SLinus Torvalds 124377d27200SUlrich Drepper retval = sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK)); 12441da177e4SLinus Torvalds if (retval < 0) 12451da177e4SLinus Torvalds goto out_release; 12461da177e4SLinus Torvalds 12471da177e4SLinus Torvalds out: 12481da177e4SLinus Torvalds /* It may be already another descriptor 8) Not kernel problem. */ 12491da177e4SLinus Torvalds return retval; 12501da177e4SLinus Torvalds 12511da177e4SLinus Torvalds out_release: 12521da177e4SLinus Torvalds sock_release(sock); 12531da177e4SLinus Torvalds return retval; 12541da177e4SLinus Torvalds } 12551da177e4SLinus Torvalds 12561da177e4SLinus Torvalds /* 12571da177e4SLinus Torvalds * Create a pair of connected sockets. 12581da177e4SLinus Torvalds */ 12591da177e4SLinus Torvalds 126089bddce5SStephen Hemminger asmlinkage long sys_socketpair(int family, int type, int protocol, 126189bddce5SStephen Hemminger int __user *usockvec) 12621da177e4SLinus Torvalds { 12631da177e4SLinus Torvalds struct socket *sock1, *sock2; 12641da177e4SLinus Torvalds int fd1, fd2, err; 1265db349509SAl Viro struct file *newfile1, *newfile2; 1266a677a039SUlrich Drepper int flags; 1267a677a039SUlrich Drepper 1268a677a039SUlrich Drepper flags = type & ~SOCK_TYPE_MASK; 126977d27200SUlrich Drepper if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)) 1270a677a039SUlrich Drepper return -EINVAL; 1271a677a039SUlrich Drepper type &= SOCK_TYPE_MASK; 12721da177e4SLinus Torvalds 1273aaca0bdcSUlrich Drepper if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK)) 1274aaca0bdcSUlrich Drepper flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK; 1275aaca0bdcSUlrich Drepper 12761da177e4SLinus Torvalds /* 12771da177e4SLinus Torvalds * Obtain the first socket and check if the underlying protocol 12781da177e4SLinus Torvalds * supports the socketpair call. 12791da177e4SLinus Torvalds */ 12801da177e4SLinus Torvalds 12811da177e4SLinus Torvalds err = sock_create(family, type, protocol, &sock1); 12821da177e4SLinus Torvalds if (err < 0) 12831da177e4SLinus Torvalds goto out; 12841da177e4SLinus Torvalds 12851da177e4SLinus Torvalds err = sock_create(family, type, protocol, &sock2); 12861da177e4SLinus Torvalds if (err < 0) 12871da177e4SLinus Torvalds goto out_release_1; 12881da177e4SLinus Torvalds 12891da177e4SLinus Torvalds err = sock1->ops->socketpair(sock1, sock2); 12901da177e4SLinus Torvalds if (err < 0) 12911da177e4SLinus Torvalds goto out_release_both; 12921da177e4SLinus Torvalds 1293a677a039SUlrich Drepper fd1 = sock_alloc_fd(&newfile1, flags & O_CLOEXEC); 1294bf3c23d1SDavid S. Miller if (unlikely(fd1 < 0)) { 1295bf3c23d1SDavid S. Miller err = fd1; 12961da177e4SLinus Torvalds goto out_release_both; 1297bf3c23d1SDavid S. Miller } 12981da177e4SLinus Torvalds 1299a677a039SUlrich Drepper fd2 = sock_alloc_fd(&newfile2, flags & O_CLOEXEC); 1300db349509SAl Viro if (unlikely(fd2 < 0)) { 1301bf3c23d1SDavid S. Miller err = fd2; 1302db349509SAl Viro put_filp(newfile1); 1303db349509SAl Viro put_unused_fd(fd1); 1304db349509SAl Viro goto out_release_both; 1305db349509SAl Viro } 13061da177e4SLinus Torvalds 130777d27200SUlrich Drepper err = sock_attach_fd(sock1, newfile1, flags & O_NONBLOCK); 1308db349509SAl Viro if (unlikely(err < 0)) { 1309db349509SAl Viro goto out_fd2; 1310db349509SAl Viro } 1311db349509SAl Viro 131277d27200SUlrich Drepper err = sock_attach_fd(sock2, newfile2, flags & O_NONBLOCK); 1313db349509SAl Viro if (unlikely(err < 0)) { 1314db349509SAl Viro fput(newfile1); 1315db349509SAl Viro goto out_fd1; 1316db349509SAl Viro } 1317db349509SAl Viro 1318db349509SAl Viro err = audit_fd_pair(fd1, fd2); 1319db349509SAl Viro if (err < 0) { 1320db349509SAl Viro fput(newfile1); 1321db349509SAl Viro fput(newfile2); 1322db349509SAl Viro goto out_fd; 1323db349509SAl Viro } 1324db349509SAl Viro 1325db349509SAl Viro fd_install(fd1, newfile1); 1326db349509SAl Viro fd_install(fd2, newfile2); 13271da177e4SLinus Torvalds /* fd1 and fd2 may be already another descriptors. 13281da177e4SLinus Torvalds * Not kernel problem. 13291da177e4SLinus Torvalds */ 13301da177e4SLinus Torvalds 13311da177e4SLinus Torvalds err = put_user(fd1, &usockvec[0]); 13321da177e4SLinus Torvalds if (!err) 13331da177e4SLinus Torvalds err = put_user(fd2, &usockvec[1]); 13341da177e4SLinus Torvalds if (!err) 13351da177e4SLinus Torvalds return 0; 13361da177e4SLinus Torvalds 13371da177e4SLinus Torvalds sys_close(fd2); 13381da177e4SLinus Torvalds sys_close(fd1); 13391da177e4SLinus Torvalds return err; 13401da177e4SLinus Torvalds 13411da177e4SLinus Torvalds out_release_both: 13421da177e4SLinus Torvalds sock_release(sock2); 13431da177e4SLinus Torvalds out_release_1: 13441da177e4SLinus Torvalds sock_release(sock1); 13451da177e4SLinus Torvalds out: 13461da177e4SLinus Torvalds return err; 1347db349509SAl Viro 1348db349509SAl Viro out_fd2: 1349db349509SAl Viro put_filp(newfile1); 1350db349509SAl Viro sock_release(sock1); 1351db349509SAl Viro out_fd1: 1352db349509SAl Viro put_filp(newfile2); 1353db349509SAl Viro sock_release(sock2); 1354db349509SAl Viro out_fd: 1355db349509SAl Viro put_unused_fd(fd1); 1356db349509SAl Viro put_unused_fd(fd2); 1357db349509SAl Viro goto out; 13581da177e4SLinus Torvalds } 13591da177e4SLinus Torvalds 13601da177e4SLinus Torvalds /* 13611da177e4SLinus Torvalds * Bind a name to a socket. Nothing much to do here since it's 13621da177e4SLinus Torvalds * the protocol's responsibility to handle the local address. 13631da177e4SLinus Torvalds * 13641da177e4SLinus Torvalds * We move the socket address to kernel space before we call 13651da177e4SLinus Torvalds * the protocol layer (having also checked the address is ok). 13661da177e4SLinus Torvalds */ 13671da177e4SLinus Torvalds 13681da177e4SLinus Torvalds asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen) 13691da177e4SLinus Torvalds { 13701da177e4SLinus Torvalds struct socket *sock; 1371230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 13726cb153caSBenjamin LaHaise int err, fput_needed; 13731da177e4SLinus Torvalds 137489bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 137589bddce5SStephen Hemminger if (sock) { 1376230b1839SYOSHIFUJI Hideaki err = move_addr_to_kernel(umyaddr, addrlen, (struct sockaddr *)&address); 137789bddce5SStephen Hemminger if (err >= 0) { 137889bddce5SStephen Hemminger err = security_socket_bind(sock, 1379230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&address, 138089bddce5SStephen Hemminger addrlen); 13816cb153caSBenjamin LaHaise if (!err) 13826cb153caSBenjamin LaHaise err = sock->ops->bind(sock, 138389bddce5SStephen Hemminger (struct sockaddr *) 1384230b1839SYOSHIFUJI Hideaki &address, addrlen); 13851da177e4SLinus Torvalds } 13866cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 13871da177e4SLinus Torvalds } 13881da177e4SLinus Torvalds return err; 13891da177e4SLinus Torvalds } 13901da177e4SLinus Torvalds 13911da177e4SLinus Torvalds /* 13921da177e4SLinus Torvalds * Perform a listen. Basically, we allow the protocol to do anything 13931da177e4SLinus Torvalds * necessary for a listen, and if that works, we mark the socket as 13941da177e4SLinus Torvalds * ready for listening. 13951da177e4SLinus Torvalds */ 13961da177e4SLinus Torvalds 13971da177e4SLinus Torvalds asmlinkage long sys_listen(int fd, int backlog) 13981da177e4SLinus Torvalds { 13991da177e4SLinus Torvalds struct socket *sock; 14006cb153caSBenjamin LaHaise int err, fput_needed; 1401b8e1f9b5SPavel Emelyanov int somaxconn; 14021da177e4SLinus Torvalds 140389bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 140489bddce5SStephen Hemminger if (sock) { 14058efa6e93SPavel Emelyanov somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn; 1406b8e1f9b5SPavel Emelyanov if ((unsigned)backlog > somaxconn) 1407b8e1f9b5SPavel Emelyanov backlog = somaxconn; 14081da177e4SLinus Torvalds 14091da177e4SLinus Torvalds err = security_socket_listen(sock, backlog); 14106cb153caSBenjamin LaHaise if (!err) 14111da177e4SLinus Torvalds err = sock->ops->listen(sock, backlog); 14126cb153caSBenjamin LaHaise 14136cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 14141da177e4SLinus Torvalds } 14151da177e4SLinus Torvalds return err; 14161da177e4SLinus Torvalds } 14171da177e4SLinus Torvalds 14181da177e4SLinus Torvalds /* 14191da177e4SLinus Torvalds * For accept, we attempt to create a new socket, set up the link 14201da177e4SLinus Torvalds * with the client, wake up the client, then return the new 14211da177e4SLinus Torvalds * connected fd. We collect the address of the connector in kernel 14221da177e4SLinus Torvalds * space and move it to user at the very end. This is unclean because 14231da177e4SLinus Torvalds * we open the socket then return an error. 14241da177e4SLinus Torvalds * 14251da177e4SLinus Torvalds * 1003.1g adds the ability to recvmsg() to query connection pending 14261da177e4SLinus Torvalds * status to recvmsg. We need to add that support in a way thats 14271da177e4SLinus Torvalds * clean when we restucture accept also. 14281da177e4SLinus Torvalds */ 14291da177e4SLinus Torvalds 1430aaca0bdcSUlrich Drepper long do_accept(int fd, struct sockaddr __user *upeer_sockaddr, 1431aaca0bdcSUlrich Drepper int __user *upeer_addrlen, int flags) 14321da177e4SLinus Torvalds { 14331da177e4SLinus Torvalds struct socket *sock, *newsock; 143439d8c1b6SDavid S. Miller struct file *newfile; 14356cb153caSBenjamin LaHaise int err, len, newfd, fput_needed; 1436230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 14371da177e4SLinus Torvalds 143877d27200SUlrich Drepper if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)) 1439aaca0bdcSUlrich Drepper return -EINVAL; 1440aaca0bdcSUlrich Drepper 1441aaca0bdcSUlrich Drepper if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK)) 1442aaca0bdcSUlrich Drepper flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK; 1443aaca0bdcSUlrich Drepper 14446cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 14451da177e4SLinus Torvalds if (!sock) 14461da177e4SLinus Torvalds goto out; 14471da177e4SLinus Torvalds 14481da177e4SLinus Torvalds err = -ENFILE; 14491da177e4SLinus Torvalds if (!(newsock = sock_alloc())) 14501da177e4SLinus Torvalds goto out_put; 14511da177e4SLinus Torvalds 14521da177e4SLinus Torvalds newsock->type = sock->type; 14531da177e4SLinus Torvalds newsock->ops = sock->ops; 14541da177e4SLinus Torvalds 14551da177e4SLinus Torvalds /* 14561da177e4SLinus Torvalds * We don't need try_module_get here, as the listening socket (sock) 14571da177e4SLinus Torvalds * has the protocol module (sock->ops->owner) held. 14581da177e4SLinus Torvalds */ 14591da177e4SLinus Torvalds __module_get(newsock->ops->owner); 14601da177e4SLinus Torvalds 1461aaca0bdcSUlrich Drepper newfd = sock_alloc_fd(&newfile, flags & O_CLOEXEC); 146239d8c1b6SDavid S. Miller if (unlikely(newfd < 0)) { 146339d8c1b6SDavid S. Miller err = newfd; 14649a1875e6SDavid S. Miller sock_release(newsock); 14659a1875e6SDavid S. Miller goto out_put; 146639d8c1b6SDavid S. Miller } 146739d8c1b6SDavid S. Miller 146877d27200SUlrich Drepper err = sock_attach_fd(newsock, newfile, flags & O_NONBLOCK); 146939d8c1b6SDavid S. Miller if (err < 0) 147079f4f642SAlexey Dobriyan goto out_fd_simple; 147139d8c1b6SDavid S. Miller 1472a79af59eSFrank Filz err = security_socket_accept(sock, newsock); 1473a79af59eSFrank Filz if (err) 147439d8c1b6SDavid S. Miller goto out_fd; 1475a79af59eSFrank Filz 14761da177e4SLinus Torvalds err = sock->ops->accept(sock, newsock, sock->file->f_flags); 14771da177e4SLinus Torvalds if (err < 0) 147839d8c1b6SDavid S. Miller goto out_fd; 14791da177e4SLinus Torvalds 14801da177e4SLinus Torvalds if (upeer_sockaddr) { 1481230b1839SYOSHIFUJI Hideaki if (newsock->ops->getname(newsock, (struct sockaddr *)&address, 148289bddce5SStephen Hemminger &len, 2) < 0) { 14831da177e4SLinus Torvalds err = -ECONNABORTED; 148439d8c1b6SDavid S. Miller goto out_fd; 14851da177e4SLinus Torvalds } 1486230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&address, 1487230b1839SYOSHIFUJI Hideaki len, upeer_sockaddr, upeer_addrlen); 14881da177e4SLinus Torvalds if (err < 0) 148939d8c1b6SDavid S. Miller goto out_fd; 14901da177e4SLinus Torvalds } 14911da177e4SLinus Torvalds 14921da177e4SLinus Torvalds /* File flags are not inherited via accept() unlike another OSes. */ 14931da177e4SLinus Torvalds 149439d8c1b6SDavid S. Miller fd_install(newfd, newfile); 149539d8c1b6SDavid S. Miller err = newfd; 14961da177e4SLinus Torvalds 14971da177e4SLinus Torvalds security_socket_post_accept(sock, newsock); 14981da177e4SLinus Torvalds 14991da177e4SLinus Torvalds out_put: 15006cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 15011da177e4SLinus Torvalds out: 15021da177e4SLinus Torvalds return err; 150379f4f642SAlexey Dobriyan out_fd_simple: 150479f4f642SAlexey Dobriyan sock_release(newsock); 150579f4f642SAlexey Dobriyan put_filp(newfile); 150679f4f642SAlexey Dobriyan put_unused_fd(newfd); 150779f4f642SAlexey Dobriyan goto out_put; 150839d8c1b6SDavid S. Miller out_fd: 15099606a216SDavid S. Miller fput(newfile); 151039d8c1b6SDavid S. Miller put_unused_fd(newfd); 15111da177e4SLinus Torvalds goto out_put; 15121da177e4SLinus Torvalds } 15131da177e4SLinus Torvalds 1514c019bbc6SUlrich Drepper #ifdef HAVE_SET_RESTORE_SIGMASK 1515aaca0bdcSUlrich Drepper asmlinkage long sys_paccept(int fd, struct sockaddr __user *upeer_sockaddr, 1516aaca0bdcSUlrich Drepper int __user *upeer_addrlen, 1517aaca0bdcSUlrich Drepper const sigset_t __user *sigmask, 1518aaca0bdcSUlrich Drepper size_t sigsetsize, int flags) 1519aaca0bdcSUlrich Drepper { 1520aaca0bdcSUlrich Drepper sigset_t ksigmask, sigsaved; 1521aaca0bdcSUlrich Drepper int ret; 1522aaca0bdcSUlrich Drepper 1523aaca0bdcSUlrich Drepper if (sigmask) { 1524aaca0bdcSUlrich Drepper /* XXX: Don't preclude handling different sized sigset_t's. */ 1525aaca0bdcSUlrich Drepper if (sigsetsize != sizeof(sigset_t)) 1526aaca0bdcSUlrich Drepper return -EINVAL; 1527aaca0bdcSUlrich Drepper if (copy_from_user(&ksigmask, sigmask, sizeof(ksigmask))) 1528aaca0bdcSUlrich Drepper return -EFAULT; 1529aaca0bdcSUlrich Drepper 1530aaca0bdcSUlrich Drepper sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP)); 1531aaca0bdcSUlrich Drepper sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved); 1532aaca0bdcSUlrich Drepper } 1533aaca0bdcSUlrich Drepper 1534aaca0bdcSUlrich Drepper ret = do_accept(fd, upeer_sockaddr, upeer_addrlen, flags); 1535aaca0bdcSUlrich Drepper 1536aaca0bdcSUlrich Drepper if (ret < 0 && signal_pending(current)) { 1537aaca0bdcSUlrich Drepper /* 1538aaca0bdcSUlrich Drepper * Don't restore the signal mask yet. Let do_signal() deliver 1539aaca0bdcSUlrich Drepper * the signal on the way back to userspace, before the signal 1540aaca0bdcSUlrich Drepper * mask is restored. 1541aaca0bdcSUlrich Drepper */ 1542aaca0bdcSUlrich Drepper if (sigmask) { 1543aaca0bdcSUlrich Drepper memcpy(¤t->saved_sigmask, &sigsaved, 1544aaca0bdcSUlrich Drepper sizeof(sigsaved)); 1545aaca0bdcSUlrich Drepper set_restore_sigmask(); 1546aaca0bdcSUlrich Drepper } 1547aaca0bdcSUlrich Drepper } else if (sigmask) 1548aaca0bdcSUlrich Drepper sigprocmask(SIG_SETMASK, &sigsaved, NULL); 1549aaca0bdcSUlrich Drepper 1550aaca0bdcSUlrich Drepper return ret; 1551aaca0bdcSUlrich Drepper } 1552c019bbc6SUlrich Drepper #else 1553c019bbc6SUlrich Drepper asmlinkage long sys_paccept(int fd, struct sockaddr __user *upeer_sockaddr, 1554c019bbc6SUlrich Drepper int __user *upeer_addrlen, 1555c019bbc6SUlrich Drepper const sigset_t __user *sigmask, 1556c019bbc6SUlrich Drepper size_t sigsetsize, int flags) 1557c019bbc6SUlrich Drepper { 1558c019bbc6SUlrich Drepper /* The platform does not support restoring the signal mask in the 1559c019bbc6SUlrich Drepper * return path. So we do not allow using paccept() with a signal 1560c019bbc6SUlrich Drepper * mask. */ 1561c019bbc6SUlrich Drepper if (sigmask) 1562c019bbc6SUlrich Drepper return -EINVAL; 1563c019bbc6SUlrich Drepper 1564c019bbc6SUlrich Drepper return do_accept(fd, upeer_sockaddr, upeer_addrlen, flags); 1565c019bbc6SUlrich Drepper } 1566c019bbc6SUlrich Drepper #endif 1567aaca0bdcSUlrich Drepper 1568aaca0bdcSUlrich Drepper asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr, 1569aaca0bdcSUlrich Drepper int __user *upeer_addrlen) 1570aaca0bdcSUlrich Drepper { 1571aaca0bdcSUlrich Drepper return do_accept(fd, upeer_sockaddr, upeer_addrlen, 0); 1572aaca0bdcSUlrich Drepper } 1573aaca0bdcSUlrich Drepper 15741da177e4SLinus Torvalds /* 15751da177e4SLinus Torvalds * Attempt to connect to a socket with the server address. The address 15761da177e4SLinus Torvalds * is in user space so we verify it is OK and move it to kernel space. 15771da177e4SLinus Torvalds * 15781da177e4SLinus Torvalds * For 1003.1g we need to add clean support for a bind to AF_UNSPEC to 15791da177e4SLinus Torvalds * break bindings 15801da177e4SLinus Torvalds * 15811da177e4SLinus Torvalds * NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and 15821da177e4SLinus Torvalds * other SEQPACKET protocols that take time to connect() as it doesn't 15831da177e4SLinus Torvalds * include the -EINPROGRESS status for such sockets. 15841da177e4SLinus Torvalds */ 15851da177e4SLinus Torvalds 158689bddce5SStephen Hemminger asmlinkage long sys_connect(int fd, struct sockaddr __user *uservaddr, 158789bddce5SStephen Hemminger int addrlen) 15881da177e4SLinus Torvalds { 15891da177e4SLinus Torvalds struct socket *sock; 1590230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 15916cb153caSBenjamin LaHaise int err, fput_needed; 15921da177e4SLinus Torvalds 15936cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 15941da177e4SLinus Torvalds if (!sock) 15951da177e4SLinus Torvalds goto out; 1596230b1839SYOSHIFUJI Hideaki err = move_addr_to_kernel(uservaddr, addrlen, (struct sockaddr *)&address); 15971da177e4SLinus Torvalds if (err < 0) 15981da177e4SLinus Torvalds goto out_put; 15991da177e4SLinus Torvalds 160089bddce5SStephen Hemminger err = 1601230b1839SYOSHIFUJI Hideaki security_socket_connect(sock, (struct sockaddr *)&address, addrlen); 16021da177e4SLinus Torvalds if (err) 16031da177e4SLinus Torvalds goto out_put; 16041da177e4SLinus Torvalds 1605230b1839SYOSHIFUJI Hideaki err = sock->ops->connect(sock, (struct sockaddr *)&address, addrlen, 16061da177e4SLinus Torvalds sock->file->f_flags); 16071da177e4SLinus Torvalds out_put: 16086cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 16091da177e4SLinus Torvalds out: 16101da177e4SLinus Torvalds return err; 16111da177e4SLinus Torvalds } 16121da177e4SLinus Torvalds 16131da177e4SLinus Torvalds /* 16141da177e4SLinus Torvalds * Get the local address ('name') of a socket object. Move the obtained 16151da177e4SLinus Torvalds * name to user space. 16161da177e4SLinus Torvalds */ 16171da177e4SLinus Torvalds 161889bddce5SStephen Hemminger asmlinkage long sys_getsockname(int fd, struct sockaddr __user *usockaddr, 161989bddce5SStephen Hemminger int __user *usockaddr_len) 16201da177e4SLinus Torvalds { 16211da177e4SLinus Torvalds struct socket *sock; 1622230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 16236cb153caSBenjamin LaHaise int len, err, fput_needed; 16241da177e4SLinus Torvalds 16256cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 16261da177e4SLinus Torvalds if (!sock) 16271da177e4SLinus Torvalds goto out; 16281da177e4SLinus Torvalds 16291da177e4SLinus Torvalds err = security_socket_getsockname(sock); 16301da177e4SLinus Torvalds if (err) 16311da177e4SLinus Torvalds goto out_put; 16321da177e4SLinus Torvalds 1633230b1839SYOSHIFUJI Hideaki err = sock->ops->getname(sock, (struct sockaddr *)&address, &len, 0); 16341da177e4SLinus Torvalds if (err) 16351da177e4SLinus Torvalds goto out_put; 1636230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr, usockaddr_len); 16371da177e4SLinus Torvalds 16381da177e4SLinus Torvalds out_put: 16396cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 16401da177e4SLinus Torvalds out: 16411da177e4SLinus Torvalds return err; 16421da177e4SLinus Torvalds } 16431da177e4SLinus Torvalds 16441da177e4SLinus Torvalds /* 16451da177e4SLinus Torvalds * Get the remote address ('name') of a socket object. Move the obtained 16461da177e4SLinus Torvalds * name to user space. 16471da177e4SLinus Torvalds */ 16481da177e4SLinus Torvalds 164989bddce5SStephen Hemminger asmlinkage long sys_getpeername(int fd, struct sockaddr __user *usockaddr, 165089bddce5SStephen Hemminger int __user *usockaddr_len) 16511da177e4SLinus Torvalds { 16521da177e4SLinus Torvalds struct socket *sock; 1653230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 16546cb153caSBenjamin LaHaise int len, err, fput_needed; 16551da177e4SLinus Torvalds 165689bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 165789bddce5SStephen Hemminger if (sock != NULL) { 16581da177e4SLinus Torvalds err = security_socket_getpeername(sock); 16591da177e4SLinus Torvalds if (err) { 16606cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 16611da177e4SLinus Torvalds return err; 16621da177e4SLinus Torvalds } 16631da177e4SLinus Torvalds 166489bddce5SStephen Hemminger err = 1665230b1839SYOSHIFUJI Hideaki sock->ops->getname(sock, (struct sockaddr *)&address, &len, 166689bddce5SStephen Hemminger 1); 16671da177e4SLinus Torvalds if (!err) 1668230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr, 166989bddce5SStephen Hemminger usockaddr_len); 16706cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 16711da177e4SLinus Torvalds } 16721da177e4SLinus Torvalds return err; 16731da177e4SLinus Torvalds } 16741da177e4SLinus Torvalds 16751da177e4SLinus Torvalds /* 16761da177e4SLinus Torvalds * Send a datagram to a given address. We move the address into kernel 16771da177e4SLinus Torvalds * space and check the user space data area is readable before invoking 16781da177e4SLinus Torvalds * the protocol. 16791da177e4SLinus Torvalds */ 16801da177e4SLinus Torvalds 168189bddce5SStephen Hemminger asmlinkage long sys_sendto(int fd, void __user *buff, size_t len, 168289bddce5SStephen Hemminger unsigned flags, struct sockaddr __user *addr, 168389bddce5SStephen Hemminger int addr_len) 16841da177e4SLinus Torvalds { 16851da177e4SLinus Torvalds struct socket *sock; 1686230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 16871da177e4SLinus Torvalds int err; 16881da177e4SLinus Torvalds struct msghdr msg; 16891da177e4SLinus Torvalds struct iovec iov; 16906cb153caSBenjamin LaHaise int fput_needed; 16911da177e4SLinus Torvalds 1692de0fa95cSPavel Emelyanov sock = sockfd_lookup_light(fd, &err, &fput_needed); 1693de0fa95cSPavel Emelyanov if (!sock) 16944387ff75SDavid S. Miller goto out; 16956cb153caSBenjamin LaHaise 16961da177e4SLinus Torvalds iov.iov_base = buff; 16971da177e4SLinus Torvalds iov.iov_len = len; 16981da177e4SLinus Torvalds msg.msg_name = NULL; 16991da177e4SLinus Torvalds msg.msg_iov = &iov; 17001da177e4SLinus Torvalds msg.msg_iovlen = 1; 17011da177e4SLinus Torvalds msg.msg_control = NULL; 17021da177e4SLinus Torvalds msg.msg_controllen = 0; 17031da177e4SLinus Torvalds msg.msg_namelen = 0; 17046cb153caSBenjamin LaHaise if (addr) { 1705230b1839SYOSHIFUJI Hideaki err = move_addr_to_kernel(addr, addr_len, (struct sockaddr *)&address); 17061da177e4SLinus Torvalds if (err < 0) 17071da177e4SLinus Torvalds goto out_put; 1708230b1839SYOSHIFUJI Hideaki msg.msg_name = (struct sockaddr *)&address; 17091da177e4SLinus Torvalds msg.msg_namelen = addr_len; 17101da177e4SLinus Torvalds } 17111da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 17121da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 17131da177e4SLinus Torvalds msg.msg_flags = flags; 17141da177e4SLinus Torvalds err = sock_sendmsg(sock, &msg, len); 17151da177e4SLinus Torvalds 17161da177e4SLinus Torvalds out_put: 1717de0fa95cSPavel Emelyanov fput_light(sock->file, fput_needed); 17184387ff75SDavid S. Miller out: 17191da177e4SLinus Torvalds return err; 17201da177e4SLinus Torvalds } 17211da177e4SLinus Torvalds 17221da177e4SLinus Torvalds /* 17231da177e4SLinus Torvalds * Send a datagram down a socket. 17241da177e4SLinus Torvalds */ 17251da177e4SLinus Torvalds 17261da177e4SLinus Torvalds asmlinkage long sys_send(int fd, void __user *buff, size_t len, unsigned flags) 17271da177e4SLinus Torvalds { 17281da177e4SLinus Torvalds return sys_sendto(fd, buff, len, flags, NULL, 0); 17291da177e4SLinus Torvalds } 17301da177e4SLinus Torvalds 17311da177e4SLinus Torvalds /* 17321da177e4SLinus Torvalds * Receive a frame from the socket and optionally record the address of the 17331da177e4SLinus Torvalds * sender. We verify the buffers are writable and if needed move the 17341da177e4SLinus Torvalds * sender address from kernel to user space. 17351da177e4SLinus Torvalds */ 17361da177e4SLinus Torvalds 173789bddce5SStephen Hemminger asmlinkage long sys_recvfrom(int fd, void __user *ubuf, size_t size, 173889bddce5SStephen Hemminger unsigned flags, struct sockaddr __user *addr, 173989bddce5SStephen Hemminger int __user *addr_len) 17401da177e4SLinus Torvalds { 17411da177e4SLinus Torvalds struct socket *sock; 17421da177e4SLinus Torvalds struct iovec iov; 17431da177e4SLinus Torvalds struct msghdr msg; 1744230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 17451da177e4SLinus Torvalds int err, err2; 17466cb153caSBenjamin LaHaise int fput_needed; 17471da177e4SLinus Torvalds 1748de0fa95cSPavel Emelyanov sock = sockfd_lookup_light(fd, &err, &fput_needed); 17491da177e4SLinus Torvalds if (!sock) 1750de0fa95cSPavel Emelyanov goto out; 17511da177e4SLinus Torvalds 17521da177e4SLinus Torvalds msg.msg_control = NULL; 17531da177e4SLinus Torvalds msg.msg_controllen = 0; 17541da177e4SLinus Torvalds msg.msg_iovlen = 1; 17551da177e4SLinus Torvalds msg.msg_iov = &iov; 17561da177e4SLinus Torvalds iov.iov_len = size; 17571da177e4SLinus Torvalds iov.iov_base = ubuf; 1758230b1839SYOSHIFUJI Hideaki msg.msg_name = (struct sockaddr *)&address; 1759230b1839SYOSHIFUJI Hideaki msg.msg_namelen = sizeof(address); 17601da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 17611da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 17621da177e4SLinus Torvalds err = sock_recvmsg(sock, &msg, size, flags); 17631da177e4SLinus Torvalds 176489bddce5SStephen Hemminger if (err >= 0 && addr != NULL) { 1765230b1839SYOSHIFUJI Hideaki err2 = move_addr_to_user((struct sockaddr *)&address, 1766230b1839SYOSHIFUJI Hideaki msg.msg_namelen, addr, addr_len); 17671da177e4SLinus Torvalds if (err2 < 0) 17681da177e4SLinus Torvalds err = err2; 17691da177e4SLinus Torvalds } 1770de0fa95cSPavel Emelyanov 1771de0fa95cSPavel Emelyanov fput_light(sock->file, fput_needed); 17724387ff75SDavid S. Miller out: 17731da177e4SLinus Torvalds return err; 17741da177e4SLinus Torvalds } 17751da177e4SLinus Torvalds 17761da177e4SLinus Torvalds /* 17771da177e4SLinus Torvalds * Receive a datagram from a socket. 17781da177e4SLinus Torvalds */ 17791da177e4SLinus Torvalds 178089bddce5SStephen Hemminger asmlinkage long sys_recv(int fd, void __user *ubuf, size_t size, 178189bddce5SStephen Hemminger unsigned flags) 17821da177e4SLinus Torvalds { 17831da177e4SLinus Torvalds return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL); 17841da177e4SLinus Torvalds } 17851da177e4SLinus Torvalds 17861da177e4SLinus Torvalds /* 17871da177e4SLinus Torvalds * Set a socket option. Because we don't know the option lengths we have 17881da177e4SLinus Torvalds * to pass the user mode parameter for the protocols to sort out. 17891da177e4SLinus Torvalds */ 17901da177e4SLinus Torvalds 179189bddce5SStephen Hemminger asmlinkage long sys_setsockopt(int fd, int level, int optname, 179289bddce5SStephen Hemminger char __user *optval, int optlen) 17931da177e4SLinus Torvalds { 17946cb153caSBenjamin LaHaise int err, fput_needed; 17951da177e4SLinus Torvalds struct socket *sock; 17961da177e4SLinus Torvalds 17971da177e4SLinus Torvalds if (optlen < 0) 17981da177e4SLinus Torvalds return -EINVAL; 17991da177e4SLinus Torvalds 180089bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 180189bddce5SStephen Hemminger if (sock != NULL) { 18021da177e4SLinus Torvalds err = security_socket_setsockopt(sock, level, optname); 18036cb153caSBenjamin LaHaise if (err) 18046cb153caSBenjamin LaHaise goto out_put; 18051da177e4SLinus Torvalds 18061da177e4SLinus Torvalds if (level == SOL_SOCKET) 180789bddce5SStephen Hemminger err = 180889bddce5SStephen Hemminger sock_setsockopt(sock, level, optname, optval, 180989bddce5SStephen Hemminger optlen); 18101da177e4SLinus Torvalds else 181189bddce5SStephen Hemminger err = 181289bddce5SStephen Hemminger sock->ops->setsockopt(sock, level, optname, optval, 181389bddce5SStephen Hemminger optlen); 18146cb153caSBenjamin LaHaise out_put: 18156cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 18161da177e4SLinus Torvalds } 18171da177e4SLinus Torvalds return err; 18181da177e4SLinus Torvalds } 18191da177e4SLinus Torvalds 18201da177e4SLinus Torvalds /* 18211da177e4SLinus Torvalds * Get a socket option. Because we don't know the option lengths we have 18221da177e4SLinus Torvalds * to pass a user mode parameter for the protocols to sort out. 18231da177e4SLinus Torvalds */ 18241da177e4SLinus Torvalds 182589bddce5SStephen Hemminger asmlinkage long sys_getsockopt(int fd, int level, int optname, 182689bddce5SStephen Hemminger char __user *optval, int __user *optlen) 18271da177e4SLinus Torvalds { 18286cb153caSBenjamin LaHaise int err, fput_needed; 18291da177e4SLinus Torvalds struct socket *sock; 18301da177e4SLinus Torvalds 183189bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 183289bddce5SStephen Hemminger if (sock != NULL) { 18336cb153caSBenjamin LaHaise err = security_socket_getsockopt(sock, level, optname); 18346cb153caSBenjamin LaHaise if (err) 18356cb153caSBenjamin LaHaise goto out_put; 18361da177e4SLinus Torvalds 18371da177e4SLinus Torvalds if (level == SOL_SOCKET) 183889bddce5SStephen Hemminger err = 183989bddce5SStephen Hemminger sock_getsockopt(sock, level, optname, optval, 184089bddce5SStephen Hemminger optlen); 18411da177e4SLinus Torvalds else 184289bddce5SStephen Hemminger err = 184389bddce5SStephen Hemminger sock->ops->getsockopt(sock, level, optname, optval, 184489bddce5SStephen Hemminger optlen); 18456cb153caSBenjamin LaHaise out_put: 18466cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 18471da177e4SLinus Torvalds } 18481da177e4SLinus Torvalds return err; 18491da177e4SLinus Torvalds } 18501da177e4SLinus Torvalds 18511da177e4SLinus Torvalds /* 18521da177e4SLinus Torvalds * Shutdown a socket. 18531da177e4SLinus Torvalds */ 18541da177e4SLinus Torvalds 18551da177e4SLinus Torvalds asmlinkage long sys_shutdown(int fd, int how) 18561da177e4SLinus Torvalds { 18576cb153caSBenjamin LaHaise int err, fput_needed; 18581da177e4SLinus Torvalds struct socket *sock; 18591da177e4SLinus Torvalds 186089bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 186189bddce5SStephen Hemminger if (sock != NULL) { 18621da177e4SLinus Torvalds err = security_socket_shutdown(sock, how); 18636cb153caSBenjamin LaHaise if (!err) 18641da177e4SLinus Torvalds err = sock->ops->shutdown(sock, how); 18656cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 18661da177e4SLinus Torvalds } 18671da177e4SLinus Torvalds return err; 18681da177e4SLinus Torvalds } 18691da177e4SLinus Torvalds 18701da177e4SLinus Torvalds /* A couple of helpful macros for getting the address of the 32/64 bit 18711da177e4SLinus Torvalds * fields which are the same type (int / unsigned) on our platforms. 18721da177e4SLinus Torvalds */ 18731da177e4SLinus Torvalds #define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member) 18741da177e4SLinus Torvalds #define COMPAT_NAMELEN(msg) COMPAT_MSG(msg, msg_namelen) 18751da177e4SLinus Torvalds #define COMPAT_FLAGS(msg) COMPAT_MSG(msg, msg_flags) 18761da177e4SLinus Torvalds 18771da177e4SLinus Torvalds /* 18781da177e4SLinus Torvalds * BSD sendmsg interface 18791da177e4SLinus Torvalds */ 18801da177e4SLinus Torvalds 18811da177e4SLinus Torvalds asmlinkage long sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags) 18821da177e4SLinus Torvalds { 188389bddce5SStephen Hemminger struct compat_msghdr __user *msg_compat = 188489bddce5SStephen Hemminger (struct compat_msghdr __user *)msg; 18851da177e4SLinus Torvalds struct socket *sock; 1886230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 18871da177e4SLinus Torvalds struct iovec iovstack[UIO_FASTIOV], *iov = iovstack; 1888b9d717a7SAlex Williamson unsigned char ctl[sizeof(struct cmsghdr) + 20] 1889b9d717a7SAlex Williamson __attribute__ ((aligned(sizeof(__kernel_size_t)))); 1890b9d717a7SAlex Williamson /* 20 is size of ipv6_pktinfo */ 18911da177e4SLinus Torvalds unsigned char *ctl_buf = ctl; 18921da177e4SLinus Torvalds struct msghdr msg_sys; 18931da177e4SLinus Torvalds int err, ctl_len, iov_size, total_len; 18946cb153caSBenjamin LaHaise int fput_needed; 18951da177e4SLinus Torvalds 18961da177e4SLinus Torvalds err = -EFAULT; 18971da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 18981da177e4SLinus Torvalds if (get_compat_msghdr(&msg_sys, msg_compat)) 18991da177e4SLinus Torvalds return -EFAULT; 190089bddce5SStephen Hemminger } 190189bddce5SStephen Hemminger else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr))) 19021da177e4SLinus Torvalds return -EFAULT; 19031da177e4SLinus Torvalds 19046cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 19051da177e4SLinus Torvalds if (!sock) 19061da177e4SLinus Torvalds goto out; 19071da177e4SLinus Torvalds 19081da177e4SLinus Torvalds /* do not move before msg_sys is valid */ 19091da177e4SLinus Torvalds err = -EMSGSIZE; 19101da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_MAXIOV) 19111da177e4SLinus Torvalds goto out_put; 19121da177e4SLinus Torvalds 19131da177e4SLinus Torvalds /* Check whether to allocate the iovec area */ 19141da177e4SLinus Torvalds err = -ENOMEM; 19151da177e4SLinus Torvalds iov_size = msg_sys.msg_iovlen * sizeof(struct iovec); 19161da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_FASTIOV) { 19171da177e4SLinus Torvalds iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL); 19181da177e4SLinus Torvalds if (!iov) 19191da177e4SLinus Torvalds goto out_put; 19201da177e4SLinus Torvalds } 19211da177e4SLinus Torvalds 19221da177e4SLinus Torvalds /* This will also move the address data into kernel space */ 19231da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 1924230b1839SYOSHIFUJI Hideaki err = verify_compat_iovec(&msg_sys, iov, 1925230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&address, 1926230b1839SYOSHIFUJI Hideaki VERIFY_READ); 19271da177e4SLinus Torvalds } else 1928230b1839SYOSHIFUJI Hideaki err = verify_iovec(&msg_sys, iov, 1929230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&address, 1930230b1839SYOSHIFUJI Hideaki VERIFY_READ); 19311da177e4SLinus Torvalds if (err < 0) 19321da177e4SLinus Torvalds goto out_freeiov; 19331da177e4SLinus Torvalds total_len = err; 19341da177e4SLinus Torvalds 19351da177e4SLinus Torvalds err = -ENOBUFS; 19361da177e4SLinus Torvalds 19371da177e4SLinus Torvalds if (msg_sys.msg_controllen > INT_MAX) 19381da177e4SLinus Torvalds goto out_freeiov; 19391da177e4SLinus Torvalds ctl_len = msg_sys.msg_controllen; 19401da177e4SLinus Torvalds if ((MSG_CMSG_COMPAT & flags) && ctl_len) { 194189bddce5SStephen Hemminger err = 194289bddce5SStephen Hemminger cmsghdr_from_user_compat_to_kern(&msg_sys, sock->sk, ctl, 194389bddce5SStephen Hemminger sizeof(ctl)); 19441da177e4SLinus Torvalds if (err) 19451da177e4SLinus Torvalds goto out_freeiov; 19461da177e4SLinus Torvalds ctl_buf = msg_sys.msg_control; 19478920e8f9SAl Viro ctl_len = msg_sys.msg_controllen; 19481da177e4SLinus Torvalds } else if (ctl_len) { 194989bddce5SStephen Hemminger if (ctl_len > sizeof(ctl)) { 19501da177e4SLinus Torvalds ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL); 19511da177e4SLinus Torvalds if (ctl_buf == NULL) 19521da177e4SLinus Torvalds goto out_freeiov; 19531da177e4SLinus Torvalds } 19541da177e4SLinus Torvalds err = -EFAULT; 19551da177e4SLinus Torvalds /* 19561da177e4SLinus Torvalds * Careful! Before this, msg_sys.msg_control contains a user pointer. 19571da177e4SLinus Torvalds * Afterwards, it will be a kernel pointer. Thus the compiler-assisted 19581da177e4SLinus Torvalds * checking falls down on this. 19591da177e4SLinus Torvalds */ 196089bddce5SStephen Hemminger if (copy_from_user(ctl_buf, (void __user *)msg_sys.msg_control, 196189bddce5SStephen Hemminger ctl_len)) 19621da177e4SLinus Torvalds goto out_freectl; 19631da177e4SLinus Torvalds msg_sys.msg_control = ctl_buf; 19641da177e4SLinus Torvalds } 19651da177e4SLinus Torvalds msg_sys.msg_flags = flags; 19661da177e4SLinus Torvalds 19671da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 19681da177e4SLinus Torvalds msg_sys.msg_flags |= MSG_DONTWAIT; 19691da177e4SLinus Torvalds err = sock_sendmsg(sock, &msg_sys, total_len); 19701da177e4SLinus Torvalds 19711da177e4SLinus Torvalds out_freectl: 19721da177e4SLinus Torvalds if (ctl_buf != ctl) 19731da177e4SLinus Torvalds sock_kfree_s(sock->sk, ctl_buf, ctl_len); 19741da177e4SLinus Torvalds out_freeiov: 19751da177e4SLinus Torvalds if (iov != iovstack) 19761da177e4SLinus Torvalds sock_kfree_s(sock->sk, iov, iov_size); 19771da177e4SLinus Torvalds out_put: 19786cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 19791da177e4SLinus Torvalds out: 19801da177e4SLinus Torvalds return err; 19811da177e4SLinus Torvalds } 19821da177e4SLinus Torvalds 19831da177e4SLinus Torvalds /* 19841da177e4SLinus Torvalds * BSD recvmsg interface 19851da177e4SLinus Torvalds */ 19861da177e4SLinus Torvalds 198789bddce5SStephen Hemminger asmlinkage long sys_recvmsg(int fd, struct msghdr __user *msg, 198889bddce5SStephen Hemminger unsigned int flags) 19891da177e4SLinus Torvalds { 199089bddce5SStephen Hemminger struct compat_msghdr __user *msg_compat = 199189bddce5SStephen Hemminger (struct compat_msghdr __user *)msg; 19921da177e4SLinus Torvalds struct socket *sock; 19931da177e4SLinus Torvalds struct iovec iovstack[UIO_FASTIOV]; 19941da177e4SLinus Torvalds struct iovec *iov = iovstack; 19951da177e4SLinus Torvalds struct msghdr msg_sys; 19961da177e4SLinus Torvalds unsigned long cmsg_ptr; 19971da177e4SLinus Torvalds int err, iov_size, total_len, len; 19986cb153caSBenjamin LaHaise int fput_needed; 19991da177e4SLinus Torvalds 20001da177e4SLinus Torvalds /* kernel mode address */ 2001230b1839SYOSHIFUJI Hideaki struct sockaddr_storage addr; 20021da177e4SLinus Torvalds 20031da177e4SLinus Torvalds /* user mode address pointers */ 20041da177e4SLinus Torvalds struct sockaddr __user *uaddr; 20051da177e4SLinus Torvalds int __user *uaddr_len; 20061da177e4SLinus Torvalds 20071da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 20081da177e4SLinus Torvalds if (get_compat_msghdr(&msg_sys, msg_compat)) 20091da177e4SLinus Torvalds return -EFAULT; 201089bddce5SStephen Hemminger } 201189bddce5SStephen Hemminger else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr))) 20121da177e4SLinus Torvalds return -EFAULT; 20131da177e4SLinus Torvalds 20146cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 20151da177e4SLinus Torvalds if (!sock) 20161da177e4SLinus Torvalds goto out; 20171da177e4SLinus Torvalds 20181da177e4SLinus Torvalds err = -EMSGSIZE; 20191da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_MAXIOV) 20201da177e4SLinus Torvalds goto out_put; 20211da177e4SLinus Torvalds 20221da177e4SLinus Torvalds /* Check whether to allocate the iovec area */ 20231da177e4SLinus Torvalds err = -ENOMEM; 20241da177e4SLinus Torvalds iov_size = msg_sys.msg_iovlen * sizeof(struct iovec); 20251da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_FASTIOV) { 20261da177e4SLinus Torvalds iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL); 20271da177e4SLinus Torvalds if (!iov) 20281da177e4SLinus Torvalds goto out_put; 20291da177e4SLinus Torvalds } 20301da177e4SLinus Torvalds 20311da177e4SLinus Torvalds /* 20321da177e4SLinus Torvalds * Save the user-mode address (verify_iovec will change the 20331da177e4SLinus Torvalds * kernel msghdr to use the kernel address space) 20341da177e4SLinus Torvalds */ 20351da177e4SLinus Torvalds 2036cfcabdccSStephen Hemminger uaddr = (__force void __user *)msg_sys.msg_name; 20371da177e4SLinus Torvalds uaddr_len = COMPAT_NAMELEN(msg); 20381da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 2039230b1839SYOSHIFUJI Hideaki err = verify_compat_iovec(&msg_sys, iov, 2040230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&addr, 2041230b1839SYOSHIFUJI Hideaki VERIFY_WRITE); 20421da177e4SLinus Torvalds } else 2043230b1839SYOSHIFUJI Hideaki err = verify_iovec(&msg_sys, iov, 2044230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&addr, 2045230b1839SYOSHIFUJI Hideaki VERIFY_WRITE); 20461da177e4SLinus Torvalds if (err < 0) 20471da177e4SLinus Torvalds goto out_freeiov; 20481da177e4SLinus Torvalds total_len = err; 20491da177e4SLinus Torvalds 20501da177e4SLinus Torvalds cmsg_ptr = (unsigned long)msg_sys.msg_control; 20514a19542eSUlrich Drepper msg_sys.msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT); 20521da177e4SLinus Torvalds 20531da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 20541da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 20551da177e4SLinus Torvalds err = sock_recvmsg(sock, &msg_sys, total_len, flags); 20561da177e4SLinus Torvalds if (err < 0) 20571da177e4SLinus Torvalds goto out_freeiov; 20581da177e4SLinus Torvalds len = err; 20591da177e4SLinus Torvalds 20601da177e4SLinus Torvalds if (uaddr != NULL) { 2061230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&addr, 2062230b1839SYOSHIFUJI Hideaki msg_sys.msg_namelen, uaddr, 206389bddce5SStephen Hemminger uaddr_len); 20641da177e4SLinus Torvalds if (err < 0) 20651da177e4SLinus Torvalds goto out_freeiov; 20661da177e4SLinus Torvalds } 206737f7f421SDavid S. Miller err = __put_user((msg_sys.msg_flags & ~MSG_CMSG_COMPAT), 206837f7f421SDavid S. Miller COMPAT_FLAGS(msg)); 20691da177e4SLinus Torvalds if (err) 20701da177e4SLinus Torvalds goto out_freeiov; 20711da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) 20721da177e4SLinus Torvalds err = __put_user((unsigned long)msg_sys.msg_control - cmsg_ptr, 20731da177e4SLinus Torvalds &msg_compat->msg_controllen); 20741da177e4SLinus Torvalds else 20751da177e4SLinus Torvalds err = __put_user((unsigned long)msg_sys.msg_control - cmsg_ptr, 20761da177e4SLinus Torvalds &msg->msg_controllen); 20771da177e4SLinus Torvalds if (err) 20781da177e4SLinus Torvalds goto out_freeiov; 20791da177e4SLinus Torvalds err = len; 20801da177e4SLinus Torvalds 20811da177e4SLinus Torvalds out_freeiov: 20821da177e4SLinus Torvalds if (iov != iovstack) 20831da177e4SLinus Torvalds sock_kfree_s(sock->sk, iov, iov_size); 20841da177e4SLinus Torvalds out_put: 20856cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 20861da177e4SLinus Torvalds out: 20871da177e4SLinus Torvalds return err; 20881da177e4SLinus Torvalds } 20891da177e4SLinus Torvalds 20901da177e4SLinus Torvalds #ifdef __ARCH_WANT_SYS_SOCKETCALL 20911da177e4SLinus Torvalds 20921da177e4SLinus Torvalds /* Argument list sizes for sys_socketcall */ 20931da177e4SLinus Torvalds #define AL(x) ((x) * sizeof(unsigned long)) 2094aaca0bdcSUlrich Drepper static const unsigned char nargs[19]={ 209589bddce5SStephen Hemminger AL(0),AL(3),AL(3),AL(3),AL(2),AL(3), 20961da177e4SLinus Torvalds AL(3),AL(3),AL(4),AL(4),AL(4),AL(6), 2097aaca0bdcSUlrich Drepper AL(6),AL(2),AL(5),AL(5),AL(3),AL(3), 2098aaca0bdcSUlrich Drepper AL(6) 209989bddce5SStephen Hemminger }; 210089bddce5SStephen Hemminger 21011da177e4SLinus Torvalds #undef AL 21021da177e4SLinus Torvalds 21031da177e4SLinus Torvalds /* 21041da177e4SLinus Torvalds * System call vectors. 21051da177e4SLinus Torvalds * 21061da177e4SLinus Torvalds * Argument checking cleaned up. Saved 20% in size. 21071da177e4SLinus Torvalds * This function doesn't need to set the kernel lock because 21081da177e4SLinus Torvalds * it is set by the callees. 21091da177e4SLinus Torvalds */ 21101da177e4SLinus Torvalds 21111da177e4SLinus Torvalds asmlinkage long sys_socketcall(int call, unsigned long __user *args) 21121da177e4SLinus Torvalds { 21131da177e4SLinus Torvalds unsigned long a[6]; 21141da177e4SLinus Torvalds unsigned long a0, a1; 21151da177e4SLinus Torvalds int err; 21161da177e4SLinus Torvalds 2117aaca0bdcSUlrich Drepper if (call < 1 || call > SYS_PACCEPT) 21181da177e4SLinus Torvalds return -EINVAL; 21191da177e4SLinus Torvalds 21201da177e4SLinus Torvalds /* copy_from_user should be SMP safe. */ 21211da177e4SLinus Torvalds if (copy_from_user(a, args, nargs[call])) 21221da177e4SLinus Torvalds return -EFAULT; 21231da177e4SLinus Torvalds 21244bcff1b3SDavid Woodhouse err = audit_socketcall(nargs[call] / sizeof(unsigned long), a); 21253ec3b2fbSDavid Woodhouse if (err) 21263ec3b2fbSDavid Woodhouse return err; 21273ec3b2fbSDavid Woodhouse 21281da177e4SLinus Torvalds a0 = a[0]; 21291da177e4SLinus Torvalds a1 = a[1]; 21301da177e4SLinus Torvalds 213189bddce5SStephen Hemminger switch (call) { 21321da177e4SLinus Torvalds case SYS_SOCKET: 21331da177e4SLinus Torvalds err = sys_socket(a0, a1, a[2]); 21341da177e4SLinus Torvalds break; 21351da177e4SLinus Torvalds case SYS_BIND: 21361da177e4SLinus Torvalds err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]); 21371da177e4SLinus Torvalds break; 21381da177e4SLinus Torvalds case SYS_CONNECT: 21391da177e4SLinus Torvalds err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]); 21401da177e4SLinus Torvalds break; 21411da177e4SLinus Torvalds case SYS_LISTEN: 21421da177e4SLinus Torvalds err = sys_listen(a0, a1); 21431da177e4SLinus Torvalds break; 21441da177e4SLinus Torvalds case SYS_ACCEPT: 214589bddce5SStephen Hemminger err = 2146aaca0bdcSUlrich Drepper do_accept(a0, (struct sockaddr __user *)a1, 2147aaca0bdcSUlrich Drepper (int __user *)a[2], 0); 21481da177e4SLinus Torvalds break; 21491da177e4SLinus Torvalds case SYS_GETSOCKNAME: 215089bddce5SStephen Hemminger err = 215189bddce5SStephen Hemminger sys_getsockname(a0, (struct sockaddr __user *)a1, 215289bddce5SStephen Hemminger (int __user *)a[2]); 21531da177e4SLinus Torvalds break; 21541da177e4SLinus Torvalds case SYS_GETPEERNAME: 215589bddce5SStephen Hemminger err = 215689bddce5SStephen Hemminger sys_getpeername(a0, (struct sockaddr __user *)a1, 215789bddce5SStephen Hemminger (int __user *)a[2]); 21581da177e4SLinus Torvalds break; 21591da177e4SLinus Torvalds case SYS_SOCKETPAIR: 21601da177e4SLinus Torvalds err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]); 21611da177e4SLinus Torvalds break; 21621da177e4SLinus Torvalds case SYS_SEND: 21631da177e4SLinus Torvalds err = sys_send(a0, (void __user *)a1, a[2], a[3]); 21641da177e4SLinus Torvalds break; 21651da177e4SLinus Torvalds case SYS_SENDTO: 21661da177e4SLinus Torvalds err = sys_sendto(a0, (void __user *)a1, a[2], a[3], 21671da177e4SLinus Torvalds (struct sockaddr __user *)a[4], a[5]); 21681da177e4SLinus Torvalds break; 21691da177e4SLinus Torvalds case SYS_RECV: 21701da177e4SLinus Torvalds err = sys_recv(a0, (void __user *)a1, a[2], a[3]); 21711da177e4SLinus Torvalds break; 21721da177e4SLinus Torvalds case SYS_RECVFROM: 21731da177e4SLinus Torvalds err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3], 217489bddce5SStephen Hemminger (struct sockaddr __user *)a[4], 217589bddce5SStephen Hemminger (int __user *)a[5]); 21761da177e4SLinus Torvalds break; 21771da177e4SLinus Torvalds case SYS_SHUTDOWN: 21781da177e4SLinus Torvalds err = sys_shutdown(a0, a1); 21791da177e4SLinus Torvalds break; 21801da177e4SLinus Torvalds case SYS_SETSOCKOPT: 21811da177e4SLinus Torvalds err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]); 21821da177e4SLinus Torvalds break; 21831da177e4SLinus Torvalds case SYS_GETSOCKOPT: 218489bddce5SStephen Hemminger err = 218589bddce5SStephen Hemminger sys_getsockopt(a0, a1, a[2], (char __user *)a[3], 218689bddce5SStephen Hemminger (int __user *)a[4]); 21871da177e4SLinus Torvalds break; 21881da177e4SLinus Torvalds case SYS_SENDMSG: 21891da177e4SLinus Torvalds err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]); 21901da177e4SLinus Torvalds break; 21911da177e4SLinus Torvalds case SYS_RECVMSG: 21921da177e4SLinus Torvalds err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]); 21931da177e4SLinus Torvalds break; 2194aaca0bdcSUlrich Drepper case SYS_PACCEPT: 2195aaca0bdcSUlrich Drepper err = 2196aaca0bdcSUlrich Drepper sys_paccept(a0, (struct sockaddr __user *)a1, 2197aaca0bdcSUlrich Drepper (int __user *)a[2], 2198aaca0bdcSUlrich Drepper (const sigset_t __user *) a[3], 2199aaca0bdcSUlrich Drepper a[4], a[5]); 2200aaca0bdcSUlrich Drepper break; 22011da177e4SLinus Torvalds default: 22021da177e4SLinus Torvalds err = -EINVAL; 22031da177e4SLinus Torvalds break; 22041da177e4SLinus Torvalds } 22051da177e4SLinus Torvalds return err; 22061da177e4SLinus Torvalds } 22071da177e4SLinus Torvalds 22081da177e4SLinus Torvalds #endif /* __ARCH_WANT_SYS_SOCKETCALL */ 22091da177e4SLinus Torvalds 221055737fdaSStephen Hemminger /** 221155737fdaSStephen Hemminger * sock_register - add a socket protocol handler 221255737fdaSStephen Hemminger * @ops: description of protocol 221355737fdaSStephen Hemminger * 22141da177e4SLinus Torvalds * This function is called by a protocol handler that wants to 22151da177e4SLinus Torvalds * advertise its address family, and have it linked into the 221655737fdaSStephen Hemminger * socket interface. The value ops->family coresponds to the 221755737fdaSStephen Hemminger * socket system call protocol family. 22181da177e4SLinus Torvalds */ 2219f0fd27d4SStephen Hemminger int sock_register(const struct net_proto_family *ops) 22201da177e4SLinus Torvalds { 22211da177e4SLinus Torvalds int err; 22221da177e4SLinus Torvalds 22231da177e4SLinus Torvalds if (ops->family >= NPROTO) { 222489bddce5SStephen Hemminger printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family, 222589bddce5SStephen Hemminger NPROTO); 22261da177e4SLinus Torvalds return -ENOBUFS; 22271da177e4SLinus Torvalds } 222855737fdaSStephen Hemminger 222955737fdaSStephen Hemminger spin_lock(&net_family_lock); 223055737fdaSStephen Hemminger if (net_families[ops->family]) 22311da177e4SLinus Torvalds err = -EEXIST; 223255737fdaSStephen Hemminger else { 22331da177e4SLinus Torvalds net_families[ops->family] = ops; 22341da177e4SLinus Torvalds err = 0; 22351da177e4SLinus Torvalds } 223655737fdaSStephen Hemminger spin_unlock(&net_family_lock); 223755737fdaSStephen Hemminger 223889bddce5SStephen Hemminger printk(KERN_INFO "NET: Registered protocol family %d\n", ops->family); 22391da177e4SLinus Torvalds return err; 22401da177e4SLinus Torvalds } 22411da177e4SLinus Torvalds 224255737fdaSStephen Hemminger /** 224355737fdaSStephen Hemminger * sock_unregister - remove a protocol handler 224455737fdaSStephen Hemminger * @family: protocol family to remove 224555737fdaSStephen Hemminger * 22461da177e4SLinus Torvalds * This function is called by a protocol handler that wants to 22471da177e4SLinus Torvalds * remove its address family, and have it unlinked from the 224855737fdaSStephen Hemminger * new socket creation. 224955737fdaSStephen Hemminger * 225055737fdaSStephen Hemminger * If protocol handler is a module, then it can use module reference 225155737fdaSStephen Hemminger * counts to protect against new references. If protocol handler is not 225255737fdaSStephen Hemminger * a module then it needs to provide its own protection in 225355737fdaSStephen Hemminger * the ops->create routine. 22541da177e4SLinus Torvalds */ 2255f0fd27d4SStephen Hemminger void sock_unregister(int family) 22561da177e4SLinus Torvalds { 2257f0fd27d4SStephen Hemminger BUG_ON(family < 0 || family >= NPROTO); 22581da177e4SLinus Torvalds 225955737fdaSStephen Hemminger spin_lock(&net_family_lock); 22601da177e4SLinus Torvalds net_families[family] = NULL; 226155737fdaSStephen Hemminger spin_unlock(&net_family_lock); 226255737fdaSStephen Hemminger 226355737fdaSStephen Hemminger synchronize_rcu(); 226455737fdaSStephen Hemminger 226589bddce5SStephen Hemminger printk(KERN_INFO "NET: Unregistered protocol family %d\n", family); 22661da177e4SLinus Torvalds } 22671da177e4SLinus Torvalds 226877d76ea3SAndi Kleen static int __init sock_init(void) 22691da177e4SLinus Torvalds { 22701da177e4SLinus Torvalds /* 22711da177e4SLinus Torvalds * Initialize sock SLAB cache. 22721da177e4SLinus Torvalds */ 22731da177e4SLinus Torvalds 22741da177e4SLinus Torvalds sk_init(); 22751da177e4SLinus Torvalds 22761da177e4SLinus Torvalds /* 22771da177e4SLinus Torvalds * Initialize skbuff SLAB cache 22781da177e4SLinus Torvalds */ 22791da177e4SLinus Torvalds skb_init(); 22801da177e4SLinus Torvalds 22811da177e4SLinus Torvalds /* 22821da177e4SLinus Torvalds * Initialize the protocols module. 22831da177e4SLinus Torvalds */ 22841da177e4SLinus Torvalds 22851da177e4SLinus Torvalds init_inodecache(); 22861da177e4SLinus Torvalds register_filesystem(&sock_fs_type); 22871da177e4SLinus Torvalds sock_mnt = kern_mount(&sock_fs_type); 228877d76ea3SAndi Kleen 228977d76ea3SAndi Kleen /* The real protocol initialization is performed in later initcalls. 22901da177e4SLinus Torvalds */ 22911da177e4SLinus Torvalds 22921da177e4SLinus Torvalds #ifdef CONFIG_NETFILTER 22931da177e4SLinus Torvalds netfilter_init(); 22941da177e4SLinus Torvalds #endif 2295cbeb321aSDavid S. Miller 2296cbeb321aSDavid S. Miller return 0; 22971da177e4SLinus Torvalds } 22981da177e4SLinus Torvalds 229977d76ea3SAndi Kleen core_initcall(sock_init); /* early initcall */ 230077d76ea3SAndi Kleen 23011da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 23021da177e4SLinus Torvalds void socket_seq_show(struct seq_file *seq) 23031da177e4SLinus Torvalds { 23041da177e4SLinus Torvalds int cpu; 23051da177e4SLinus Torvalds int counter = 0; 23061da177e4SLinus Torvalds 23076f912042SKAMEZAWA Hiroyuki for_each_possible_cpu(cpu) 23081da177e4SLinus Torvalds counter += per_cpu(sockets_in_use, cpu); 23091da177e4SLinus Torvalds 23101da177e4SLinus Torvalds /* It can be negative, by the way. 8) */ 23111da177e4SLinus Torvalds if (counter < 0) 23121da177e4SLinus Torvalds counter = 0; 23131da177e4SLinus Torvalds 23141da177e4SLinus Torvalds seq_printf(seq, "sockets: used %d\n", counter); 23151da177e4SLinus Torvalds } 23161da177e4SLinus Torvalds #endif /* CONFIG_PROC_FS */ 23171da177e4SLinus Torvalds 231889bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 231989bbfc95SShaun Pereira static long compat_sock_ioctl(struct file *file, unsigned cmd, 232089bbfc95SShaun Pereira unsigned long arg) 232189bbfc95SShaun Pereira { 232289bbfc95SShaun Pereira struct socket *sock = file->private_data; 232389bbfc95SShaun Pereira int ret = -ENOIOCTLCMD; 232487de87d5SDavid S. Miller struct sock *sk; 232587de87d5SDavid S. Miller struct net *net; 232687de87d5SDavid S. Miller 232787de87d5SDavid S. Miller sk = sock->sk; 232887de87d5SDavid S. Miller net = sock_net(sk); 232989bbfc95SShaun Pereira 233089bbfc95SShaun Pereira if (sock->ops->compat_ioctl) 233189bbfc95SShaun Pereira ret = sock->ops->compat_ioctl(sock, cmd, arg); 233289bbfc95SShaun Pereira 233387de87d5SDavid S. Miller if (ret == -ENOIOCTLCMD && 233487de87d5SDavid S. Miller (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)) 233587de87d5SDavid S. Miller ret = compat_wext_handle_ioctl(net, cmd, arg); 233687de87d5SDavid S. Miller 233789bbfc95SShaun Pereira return ret; 233889bbfc95SShaun Pereira } 233989bbfc95SShaun Pereira #endif 234089bbfc95SShaun Pereira 2341ac5a488eSSridhar Samudrala int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen) 2342ac5a488eSSridhar Samudrala { 2343ac5a488eSSridhar Samudrala return sock->ops->bind(sock, addr, addrlen); 2344ac5a488eSSridhar Samudrala } 2345ac5a488eSSridhar Samudrala 2346ac5a488eSSridhar Samudrala int kernel_listen(struct socket *sock, int backlog) 2347ac5a488eSSridhar Samudrala { 2348ac5a488eSSridhar Samudrala return sock->ops->listen(sock, backlog); 2349ac5a488eSSridhar Samudrala } 2350ac5a488eSSridhar Samudrala 2351ac5a488eSSridhar Samudrala int kernel_accept(struct socket *sock, struct socket **newsock, int flags) 2352ac5a488eSSridhar Samudrala { 2353ac5a488eSSridhar Samudrala struct sock *sk = sock->sk; 2354ac5a488eSSridhar Samudrala int err; 2355ac5a488eSSridhar Samudrala 2356ac5a488eSSridhar Samudrala err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 2357ac5a488eSSridhar Samudrala newsock); 2358ac5a488eSSridhar Samudrala if (err < 0) 2359ac5a488eSSridhar Samudrala goto done; 2360ac5a488eSSridhar Samudrala 2361ac5a488eSSridhar Samudrala err = sock->ops->accept(sock, *newsock, flags); 2362ac5a488eSSridhar Samudrala if (err < 0) { 2363ac5a488eSSridhar Samudrala sock_release(*newsock); 2364fa8705b0STony Battersby *newsock = NULL; 2365ac5a488eSSridhar Samudrala goto done; 2366ac5a488eSSridhar Samudrala } 2367ac5a488eSSridhar Samudrala 2368ac5a488eSSridhar Samudrala (*newsock)->ops = sock->ops; 2369ac5a488eSSridhar Samudrala 2370ac5a488eSSridhar Samudrala done: 2371ac5a488eSSridhar Samudrala return err; 2372ac5a488eSSridhar Samudrala } 2373ac5a488eSSridhar Samudrala 2374ac5a488eSSridhar Samudrala int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen, 2375ac5a488eSSridhar Samudrala int flags) 2376ac5a488eSSridhar Samudrala { 2377ac5a488eSSridhar Samudrala return sock->ops->connect(sock, addr, addrlen, flags); 2378ac5a488eSSridhar Samudrala } 2379ac5a488eSSridhar Samudrala 2380ac5a488eSSridhar Samudrala int kernel_getsockname(struct socket *sock, struct sockaddr *addr, 2381ac5a488eSSridhar Samudrala int *addrlen) 2382ac5a488eSSridhar Samudrala { 2383ac5a488eSSridhar Samudrala return sock->ops->getname(sock, addr, addrlen, 0); 2384ac5a488eSSridhar Samudrala } 2385ac5a488eSSridhar Samudrala 2386ac5a488eSSridhar Samudrala int kernel_getpeername(struct socket *sock, struct sockaddr *addr, 2387ac5a488eSSridhar Samudrala int *addrlen) 2388ac5a488eSSridhar Samudrala { 2389ac5a488eSSridhar Samudrala return sock->ops->getname(sock, addr, addrlen, 1); 2390ac5a488eSSridhar Samudrala } 2391ac5a488eSSridhar Samudrala 2392ac5a488eSSridhar Samudrala int kernel_getsockopt(struct socket *sock, int level, int optname, 2393ac5a488eSSridhar Samudrala char *optval, int *optlen) 2394ac5a488eSSridhar Samudrala { 2395ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 2396ac5a488eSSridhar Samudrala int err; 2397ac5a488eSSridhar Samudrala 2398ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 2399ac5a488eSSridhar Samudrala if (level == SOL_SOCKET) 2400ac5a488eSSridhar Samudrala err = sock_getsockopt(sock, level, optname, optval, optlen); 2401ac5a488eSSridhar Samudrala else 2402ac5a488eSSridhar Samudrala err = sock->ops->getsockopt(sock, level, optname, optval, 2403ac5a488eSSridhar Samudrala optlen); 2404ac5a488eSSridhar Samudrala set_fs(oldfs); 2405ac5a488eSSridhar Samudrala return err; 2406ac5a488eSSridhar Samudrala } 2407ac5a488eSSridhar Samudrala 2408ac5a488eSSridhar Samudrala int kernel_setsockopt(struct socket *sock, int level, int optname, 2409ac5a488eSSridhar Samudrala char *optval, int optlen) 2410ac5a488eSSridhar Samudrala { 2411ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 2412ac5a488eSSridhar Samudrala int err; 2413ac5a488eSSridhar Samudrala 2414ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 2415ac5a488eSSridhar Samudrala if (level == SOL_SOCKET) 2416ac5a488eSSridhar Samudrala err = sock_setsockopt(sock, level, optname, optval, optlen); 2417ac5a488eSSridhar Samudrala else 2418ac5a488eSSridhar Samudrala err = sock->ops->setsockopt(sock, level, optname, optval, 2419ac5a488eSSridhar Samudrala optlen); 2420ac5a488eSSridhar Samudrala set_fs(oldfs); 2421ac5a488eSSridhar Samudrala return err; 2422ac5a488eSSridhar Samudrala } 2423ac5a488eSSridhar Samudrala 2424ac5a488eSSridhar Samudrala int kernel_sendpage(struct socket *sock, struct page *page, int offset, 2425ac5a488eSSridhar Samudrala size_t size, int flags) 2426ac5a488eSSridhar Samudrala { 2427ac5a488eSSridhar Samudrala if (sock->ops->sendpage) 2428ac5a488eSSridhar Samudrala return sock->ops->sendpage(sock, page, offset, size, flags); 2429ac5a488eSSridhar Samudrala 2430ac5a488eSSridhar Samudrala return sock_no_sendpage(sock, page, offset, size, flags); 2431ac5a488eSSridhar Samudrala } 2432ac5a488eSSridhar Samudrala 2433ac5a488eSSridhar Samudrala int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg) 2434ac5a488eSSridhar Samudrala { 2435ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 2436ac5a488eSSridhar Samudrala int err; 2437ac5a488eSSridhar Samudrala 2438ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 2439ac5a488eSSridhar Samudrala err = sock->ops->ioctl(sock, cmd, arg); 2440ac5a488eSSridhar Samudrala set_fs(oldfs); 2441ac5a488eSSridhar Samudrala 2442ac5a488eSSridhar Samudrala return err; 2443ac5a488eSSridhar Samudrala } 2444ac5a488eSSridhar Samudrala 244591cf45f0STrond Myklebust int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how) 244691cf45f0STrond Myklebust { 244791cf45f0STrond Myklebust return sock->ops->shutdown(sock, how); 244891cf45f0STrond Myklebust } 244991cf45f0STrond Myklebust 24501da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create); 24511da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create_kern); 24521da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create_lite); 24531da177e4SLinus Torvalds EXPORT_SYMBOL(sock_map_fd); 24541da177e4SLinus Torvalds EXPORT_SYMBOL(sock_recvmsg); 24551da177e4SLinus Torvalds EXPORT_SYMBOL(sock_register); 24561da177e4SLinus Torvalds EXPORT_SYMBOL(sock_release); 24571da177e4SLinus Torvalds EXPORT_SYMBOL(sock_sendmsg); 24581da177e4SLinus Torvalds EXPORT_SYMBOL(sock_unregister); 24591da177e4SLinus Torvalds EXPORT_SYMBOL(sock_wake_async); 24601da177e4SLinus Torvalds EXPORT_SYMBOL(sockfd_lookup); 24611da177e4SLinus Torvalds EXPORT_SYMBOL(kernel_sendmsg); 24621da177e4SLinus Torvalds EXPORT_SYMBOL(kernel_recvmsg); 2463ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_bind); 2464ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_listen); 2465ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_accept); 2466ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_connect); 2467ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getsockname); 2468ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getpeername); 2469ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getsockopt); 2470ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_setsockopt); 2471ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_sendpage); 2472ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_sock_ioctl); 247391cf45f0STrond Myklebust EXPORT_SYMBOL(kernel_sock_shutdown); 2474