11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * NET An implementation of the SOCKET network access protocol. 31da177e4SLinus Torvalds * 41da177e4SLinus Torvalds * Version: @(#)socket.c 1.1.93 18/02/95 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * Authors: Orest Zborowski, <obz@Kodak.COM> 702c30a84SJesper Juhl * Ross Biro 81da177e4SLinus Torvalds * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 91da177e4SLinus Torvalds * 101da177e4SLinus Torvalds * Fixes: 111da177e4SLinus Torvalds * Anonymous : NOTSOCK/BADF cleanup. Error fix in 121da177e4SLinus Torvalds * shutdown() 131da177e4SLinus Torvalds * Alan Cox : verify_area() fixes 141da177e4SLinus Torvalds * Alan Cox : Removed DDI 151da177e4SLinus Torvalds * Jonathan Kamens : SOCK_DGRAM reconnect bug 161da177e4SLinus Torvalds * Alan Cox : Moved a load of checks to the very 171da177e4SLinus Torvalds * top level. 181da177e4SLinus Torvalds * Alan Cox : Move address structures to/from user 191da177e4SLinus Torvalds * mode above the protocol layers. 201da177e4SLinus Torvalds * Rob Janssen : Allow 0 length sends. 211da177e4SLinus Torvalds * Alan Cox : Asynchronous I/O support (cribbed from the 221da177e4SLinus Torvalds * tty drivers). 231da177e4SLinus Torvalds * Niibe Yutaka : Asynchronous I/O for writes (4.4BSD style) 241da177e4SLinus Torvalds * Jeff Uphoff : Made max number of sockets command-line 251da177e4SLinus Torvalds * configurable. 261da177e4SLinus Torvalds * Matti Aarnio : Made the number of sockets dynamic, 271da177e4SLinus Torvalds * to be allocated when needed, and mr. 281da177e4SLinus Torvalds * Uphoff's max is used as max to be 291da177e4SLinus Torvalds * allowed to allocate. 301da177e4SLinus Torvalds * Linus : Argh. removed all the socket allocation 311da177e4SLinus Torvalds * altogether: it's in the inode now. 321da177e4SLinus Torvalds * Alan Cox : Made sock_alloc()/sock_release() public 331da177e4SLinus Torvalds * for NetROM and future kernel nfsd type 341da177e4SLinus Torvalds * stuff. 351da177e4SLinus Torvalds * Alan Cox : sendmsg/recvmsg basics. 361da177e4SLinus Torvalds * Tom Dyas : Export net symbols. 371da177e4SLinus Torvalds * Marcin Dalecki : Fixed problems with CONFIG_NET="n". 381da177e4SLinus Torvalds * Alan Cox : Added thread locking to sys_* calls 391da177e4SLinus Torvalds * for sockets. May have errors at the 401da177e4SLinus Torvalds * moment. 411da177e4SLinus Torvalds * Kevin Buhr : Fixed the dumb errors in the above. 421da177e4SLinus Torvalds * Andi Kleen : Some small cleanups, optimizations, 431da177e4SLinus Torvalds * and fixed a copy_from_user() bug. 441da177e4SLinus Torvalds * Tigran Aivazian : sys_send(args) calls sys_sendto(args, NULL, 0) 451da177e4SLinus Torvalds * Tigran Aivazian : Made listen(2) backlog sanity checks 461da177e4SLinus Torvalds * protocol-independent 471da177e4SLinus Torvalds * 481da177e4SLinus Torvalds * 491da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or 501da177e4SLinus Torvalds * modify it under the terms of the GNU General Public License 511da177e4SLinus Torvalds * as published by the Free Software Foundation; either version 521da177e4SLinus Torvalds * 2 of the License, or (at your option) any later version. 531da177e4SLinus Torvalds * 541da177e4SLinus Torvalds * 551da177e4SLinus Torvalds * This module is effectively the top level interface to the BSD socket 561da177e4SLinus Torvalds * paradigm. 571da177e4SLinus Torvalds * 581da177e4SLinus Torvalds * Based upon Swansea University Computer Society NET3.039 591da177e4SLinus Torvalds */ 601da177e4SLinus Torvalds 611da177e4SLinus Torvalds #include <linux/mm.h> 621da177e4SLinus Torvalds #include <linux/socket.h> 631da177e4SLinus Torvalds #include <linux/file.h> 641da177e4SLinus Torvalds #include <linux/net.h> 651da177e4SLinus Torvalds #include <linux/interrupt.h> 66aaca0bdcSUlrich Drepper #include <linux/thread_info.h> 6755737fdaSStephen Hemminger #include <linux/rcupdate.h> 681da177e4SLinus Torvalds #include <linux/netdevice.h> 691da177e4SLinus Torvalds #include <linux/proc_fs.h> 701da177e4SLinus Torvalds #include <linux/seq_file.h> 714a3e2f71SArjan van de Ven #include <linux/mutex.h> 721da177e4SLinus Torvalds #include <linux/wanrouter.h> 731da177e4SLinus Torvalds #include <linux/if_bridge.h> 7420380731SArnaldo Carvalho de Melo #include <linux/if_frad.h> 7520380731SArnaldo Carvalho de Melo #include <linux/if_vlan.h> 761da177e4SLinus Torvalds #include <linux/init.h> 771da177e4SLinus Torvalds #include <linux/poll.h> 781da177e4SLinus Torvalds #include <linux/cache.h> 791da177e4SLinus Torvalds #include <linux/module.h> 801da177e4SLinus Torvalds #include <linux/highmem.h> 811da177e4SLinus Torvalds #include <linux/mount.h> 821da177e4SLinus Torvalds #include <linux/security.h> 831da177e4SLinus Torvalds #include <linux/syscalls.h> 841da177e4SLinus Torvalds #include <linux/compat.h> 851da177e4SLinus Torvalds #include <linux/kmod.h> 863ec3b2fbSDavid Woodhouse #include <linux/audit.h> 87d86b5e0eSAdrian Bunk #include <linux/wireless.h> 881b8d7ae4SEric W. Biederman #include <linux/nsproxy.h> 891fd7317dSNick Black #include <linux/magic.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 1006b96018bSArnd Bergmann #include <linux/if_tun.h> 1016b96018bSArnd Bergmann #include <linux/ipv6_route.h> 1026b96018bSArnd Bergmann #include <linux/route.h> 1036b96018bSArnd Bergmann #include <linux/atmdev.h> 1046b96018bSArnd Bergmann #include <linux/atmarp.h> 1056b96018bSArnd Bergmann #include <linux/atmsvc.h> 1066b96018bSArnd Bergmann #include <linux/atmlec.h> 1076b96018bSArnd Bergmann #include <linux/atmclip.h> 1086b96018bSArnd Bergmann #include <linux/atmmpc.h> 1096b96018bSArnd Bergmann #include <linux/atm_tcp.h> 1106b96018bSArnd Bergmann #include <linux/sonet.h> 1116b96018bSArnd Bergmann #include <linux/sockios.h> 1126b96018bSArnd Bergmann #include <linux/atalk.h> 1136b96018bSArnd Bergmann 1141da177e4SLinus Torvalds static int sock_no_open(struct inode *irrelevant, struct file *dontcare); 115027445c3SBadari Pulavarty static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov, 116027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos); 117027445c3SBadari Pulavarty static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov, 118027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos); 1191da177e4SLinus Torvalds static int sock_mmap(struct file *file, struct vm_area_struct *vma); 1201da177e4SLinus Torvalds 1211da177e4SLinus Torvalds static int sock_close(struct inode *inode, struct file *file); 1221da177e4SLinus Torvalds static unsigned int sock_poll(struct file *file, 1231da177e4SLinus Torvalds struct poll_table_struct *wait); 12489bddce5SStephen Hemminger static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg); 12589bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 12689bbfc95SShaun Pereira static long compat_sock_ioctl(struct file *file, 12789bbfc95SShaun Pereira unsigned int cmd, unsigned long arg); 12889bbfc95SShaun Pereira #endif 1291da177e4SLinus Torvalds static int sock_fasync(int fd, struct file *filp, int on); 1301da177e4SLinus Torvalds static ssize_t sock_sendpage(struct file *file, struct page *page, 1311da177e4SLinus Torvalds int offset, size_t size, loff_t *ppos, int more); 1329c55e01cSJens Axboe static ssize_t sock_splice_read(struct file *file, loff_t *ppos, 1339c55e01cSJens Axboe struct pipe_inode_info *pipe, size_t len, 1349c55e01cSJens Axboe unsigned int flags); 1351da177e4SLinus Torvalds 1361da177e4SLinus Torvalds /* 1371da177e4SLinus Torvalds * Socket files have a set of 'special' operations as well as the generic file ones. These don't appear 1381da177e4SLinus Torvalds * in the operation structures but are done directly via the socketcall() multiplexor. 1391da177e4SLinus Torvalds */ 1401da177e4SLinus Torvalds 141da7071d7SArjan van de Ven static const struct file_operations socket_file_ops = { 1421da177e4SLinus Torvalds .owner = THIS_MODULE, 1431da177e4SLinus Torvalds .llseek = no_llseek, 1441da177e4SLinus Torvalds .aio_read = sock_aio_read, 1451da177e4SLinus Torvalds .aio_write = sock_aio_write, 1461da177e4SLinus Torvalds .poll = sock_poll, 1471da177e4SLinus Torvalds .unlocked_ioctl = sock_ioctl, 14889bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 14989bbfc95SShaun Pereira .compat_ioctl = compat_sock_ioctl, 15089bbfc95SShaun Pereira #endif 1511da177e4SLinus Torvalds .mmap = sock_mmap, 1521da177e4SLinus Torvalds .open = sock_no_open, /* special open code to disallow open via /proc */ 1531da177e4SLinus Torvalds .release = sock_close, 1541da177e4SLinus Torvalds .fasync = sock_fasync, 1555274f052SJens Axboe .sendpage = sock_sendpage, 1565274f052SJens Axboe .splice_write = generic_splice_sendpage, 1579c55e01cSJens Axboe .splice_read = sock_splice_read, 1581da177e4SLinus Torvalds }; 1591da177e4SLinus Torvalds 1601da177e4SLinus Torvalds /* 1611da177e4SLinus Torvalds * The protocol list. Each protocol is registered in here. 1621da177e4SLinus Torvalds */ 1631da177e4SLinus Torvalds 1641da177e4SLinus Torvalds static DEFINE_SPINLOCK(net_family_lock); 165f0fd27d4SStephen Hemminger static const struct net_proto_family *net_families[NPROTO] __read_mostly; 1661da177e4SLinus Torvalds 1671da177e4SLinus Torvalds /* 1681da177e4SLinus Torvalds * Statistics counters of the socket lists 1691da177e4SLinus Torvalds */ 1701da177e4SLinus Torvalds 1711da177e4SLinus Torvalds static DEFINE_PER_CPU(int, sockets_in_use) = 0; 1721da177e4SLinus Torvalds 1731da177e4SLinus Torvalds /* 17489bddce5SStephen Hemminger * Support routines. 17589bddce5SStephen Hemminger * Move socket addresses back and forth across the kernel/user 1761da177e4SLinus Torvalds * divide and look after the messy bits. 1771da177e4SLinus Torvalds */ 1781da177e4SLinus Torvalds 1791da177e4SLinus Torvalds #define MAX_SOCK_ADDR 128 /* 108 for Unix domain - 1801da177e4SLinus Torvalds 16 for IP, 16 for IPX, 1811da177e4SLinus Torvalds 24 for IPv6, 1821da177e4SLinus Torvalds about 80 for AX.25 1831da177e4SLinus Torvalds must be at least one bigger than 1841da177e4SLinus Torvalds the AF_UNIX size (see net/unix/af_unix.c 1851da177e4SLinus Torvalds :unix_mkname()). 1861da177e4SLinus Torvalds */ 1871da177e4SLinus Torvalds 1881da177e4SLinus Torvalds /** 1891da177e4SLinus Torvalds * move_addr_to_kernel - copy a socket address into kernel space 1901da177e4SLinus Torvalds * @uaddr: Address in user space 1911da177e4SLinus Torvalds * @kaddr: Address in kernel space 1921da177e4SLinus Torvalds * @ulen: Length in user space 1931da177e4SLinus Torvalds * 1941da177e4SLinus Torvalds * The address is copied into kernel space. If the provided address is 1951da177e4SLinus Torvalds * too long an error code of -EINVAL is returned. If the copy gives 1961da177e4SLinus Torvalds * invalid addresses -EFAULT is returned. On a success 0 is returned. 1971da177e4SLinus Torvalds */ 1981da177e4SLinus Torvalds 199230b1839SYOSHIFUJI Hideaki int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr *kaddr) 2001da177e4SLinus Torvalds { 201230b1839SYOSHIFUJI Hideaki if (ulen < 0 || ulen > sizeof(struct sockaddr_storage)) 2021da177e4SLinus Torvalds return -EINVAL; 2031da177e4SLinus Torvalds if (ulen == 0) 2041da177e4SLinus Torvalds return 0; 2051da177e4SLinus Torvalds if (copy_from_user(kaddr, uaddr, ulen)) 2061da177e4SLinus Torvalds return -EFAULT; 2073ec3b2fbSDavid Woodhouse return audit_sockaddr(ulen, kaddr); 2081da177e4SLinus Torvalds } 2091da177e4SLinus Torvalds 2101da177e4SLinus Torvalds /** 2111da177e4SLinus Torvalds * move_addr_to_user - copy an address to user space 2121da177e4SLinus Torvalds * @kaddr: kernel space address 2131da177e4SLinus Torvalds * @klen: length of address in kernel 2141da177e4SLinus Torvalds * @uaddr: user space address 2151da177e4SLinus Torvalds * @ulen: pointer to user length field 2161da177e4SLinus Torvalds * 2171da177e4SLinus Torvalds * The value pointed to by ulen on entry is the buffer length available. 2181da177e4SLinus Torvalds * This is overwritten with the buffer space used. -EINVAL is returned 2191da177e4SLinus Torvalds * if an overlong buffer is specified or a negative buffer size. -EFAULT 2201da177e4SLinus Torvalds * is returned if either the buffer or the length field are not 2211da177e4SLinus Torvalds * accessible. 2221da177e4SLinus Torvalds * After copying the data up to the limit the user specifies, the true 2231da177e4SLinus Torvalds * length of the data is written over the length limit the user 2241da177e4SLinus Torvalds * specified. Zero is returned for a success. 2251da177e4SLinus Torvalds */ 2261da177e4SLinus Torvalds 227230b1839SYOSHIFUJI Hideaki int move_addr_to_user(struct sockaddr *kaddr, int klen, void __user *uaddr, 22889bddce5SStephen Hemminger int __user *ulen) 2291da177e4SLinus Torvalds { 2301da177e4SLinus Torvalds int err; 2311da177e4SLinus Torvalds int len; 2321da177e4SLinus Torvalds 23389bddce5SStephen Hemminger err = get_user(len, ulen); 23489bddce5SStephen Hemminger if (err) 2351da177e4SLinus Torvalds return err; 2361da177e4SLinus Torvalds if (len > klen) 2371da177e4SLinus Torvalds len = klen; 238230b1839SYOSHIFUJI Hideaki if (len < 0 || len > sizeof(struct sockaddr_storage)) 2391da177e4SLinus Torvalds return -EINVAL; 24089bddce5SStephen Hemminger if (len) { 241d6fe3945SSteve Grubb if (audit_sockaddr(klen, kaddr)) 242d6fe3945SSteve Grubb return -ENOMEM; 2431da177e4SLinus Torvalds if (copy_to_user(uaddr, kaddr, len)) 2441da177e4SLinus Torvalds return -EFAULT; 2451da177e4SLinus Torvalds } 2461da177e4SLinus Torvalds /* 2471da177e4SLinus Torvalds * "fromlen shall refer to the value before truncation.." 2481da177e4SLinus Torvalds * 1003.1g 2491da177e4SLinus Torvalds */ 2501da177e4SLinus Torvalds return __put_user(klen, ulen); 2511da177e4SLinus Torvalds } 2521da177e4SLinus Torvalds 253e18b890bSChristoph Lameter static struct kmem_cache *sock_inode_cachep __read_mostly; 2541da177e4SLinus Torvalds 2551da177e4SLinus Torvalds static struct inode *sock_alloc_inode(struct super_block *sb) 2561da177e4SLinus Torvalds { 2571da177e4SLinus Torvalds struct socket_alloc *ei; 25889bddce5SStephen Hemminger 259e94b1766SChristoph Lameter ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL); 2601da177e4SLinus Torvalds if (!ei) 2611da177e4SLinus Torvalds return NULL; 2621da177e4SLinus Torvalds init_waitqueue_head(&ei->socket.wait); 2631da177e4SLinus Torvalds 2641da177e4SLinus Torvalds ei->socket.fasync_list = NULL; 2651da177e4SLinus Torvalds ei->socket.state = SS_UNCONNECTED; 2661da177e4SLinus Torvalds ei->socket.flags = 0; 2671da177e4SLinus Torvalds ei->socket.ops = NULL; 2681da177e4SLinus Torvalds ei->socket.sk = NULL; 2691da177e4SLinus Torvalds ei->socket.file = NULL; 2701da177e4SLinus Torvalds 2711da177e4SLinus Torvalds return &ei->vfs_inode; 2721da177e4SLinus Torvalds } 2731da177e4SLinus Torvalds 2741da177e4SLinus Torvalds static void sock_destroy_inode(struct inode *inode) 2751da177e4SLinus Torvalds { 2761da177e4SLinus Torvalds kmem_cache_free(sock_inode_cachep, 2771da177e4SLinus Torvalds container_of(inode, struct socket_alloc, vfs_inode)); 2781da177e4SLinus Torvalds } 2791da177e4SLinus Torvalds 28051cc5068SAlexey Dobriyan static void init_once(void *foo) 2811da177e4SLinus Torvalds { 2821da177e4SLinus Torvalds struct socket_alloc *ei = (struct socket_alloc *)foo; 2831da177e4SLinus Torvalds 2841da177e4SLinus Torvalds inode_init_once(&ei->vfs_inode); 2851da177e4SLinus Torvalds } 2861da177e4SLinus Torvalds 2871da177e4SLinus Torvalds static int init_inodecache(void) 2881da177e4SLinus Torvalds { 2891da177e4SLinus Torvalds sock_inode_cachep = kmem_cache_create("sock_inode_cache", 2901da177e4SLinus Torvalds sizeof(struct socket_alloc), 29189bddce5SStephen Hemminger 0, 29289bddce5SStephen Hemminger (SLAB_HWCACHE_ALIGN | 29389bddce5SStephen Hemminger SLAB_RECLAIM_ACCOUNT | 294fffb60f9SPaul Jackson SLAB_MEM_SPREAD), 29520c2df83SPaul Mundt init_once); 2961da177e4SLinus Torvalds if (sock_inode_cachep == NULL) 2971da177e4SLinus Torvalds return -ENOMEM; 2981da177e4SLinus Torvalds return 0; 2991da177e4SLinus Torvalds } 3001da177e4SLinus Torvalds 301b87221deSAlexey Dobriyan static const struct super_operations sockfs_ops = { 3021da177e4SLinus Torvalds .alloc_inode = sock_alloc_inode, 3031da177e4SLinus Torvalds .destroy_inode =sock_destroy_inode, 3041da177e4SLinus Torvalds .statfs = simple_statfs, 3051da177e4SLinus Torvalds }; 3061da177e4SLinus Torvalds 307454e2398SDavid Howells static int sockfs_get_sb(struct file_system_type *fs_type, 30889bddce5SStephen Hemminger int flags, const char *dev_name, void *data, 30989bddce5SStephen Hemminger struct vfsmount *mnt) 3101da177e4SLinus Torvalds { 311454e2398SDavid Howells return get_sb_pseudo(fs_type, "socket:", &sockfs_ops, SOCKFS_MAGIC, 312454e2398SDavid Howells mnt); 3131da177e4SLinus Torvalds } 3141da177e4SLinus Torvalds 315ba89966cSEric Dumazet static struct vfsmount *sock_mnt __read_mostly; 3161da177e4SLinus Torvalds 3171da177e4SLinus Torvalds static struct file_system_type sock_fs_type = { 3181da177e4SLinus Torvalds .name = "sockfs", 3191da177e4SLinus Torvalds .get_sb = sockfs_get_sb, 3201da177e4SLinus Torvalds .kill_sb = kill_anon_super, 3211da177e4SLinus Torvalds }; 32289bddce5SStephen Hemminger 3231da177e4SLinus Torvalds static int sockfs_delete_dentry(struct dentry *dentry) 3241da177e4SLinus Torvalds { 325304e61e6SEric Dumazet /* 326304e61e6SEric Dumazet * At creation time, we pretended this dentry was hashed 327304e61e6SEric Dumazet * (by clearing DCACHE_UNHASHED bit in d_flags) 328304e61e6SEric Dumazet * At delete time, we restore the truth : not hashed. 329304e61e6SEric Dumazet * (so that dput() can proceed correctly) 330304e61e6SEric Dumazet */ 331304e61e6SEric Dumazet dentry->d_flags |= DCACHE_UNHASHED; 332304e61e6SEric Dumazet return 0; 3331da177e4SLinus Torvalds } 334c23fbb6bSEric Dumazet 335c23fbb6bSEric Dumazet /* 336c23fbb6bSEric Dumazet * sockfs_dname() is called from d_path(). 337c23fbb6bSEric Dumazet */ 338c23fbb6bSEric Dumazet static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen) 339c23fbb6bSEric Dumazet { 340c23fbb6bSEric Dumazet return dynamic_dname(dentry, buffer, buflen, "socket:[%lu]", 341c23fbb6bSEric Dumazet dentry->d_inode->i_ino); 342c23fbb6bSEric Dumazet } 343c23fbb6bSEric Dumazet 3443ba13d17SAl Viro static const struct dentry_operations sockfs_dentry_operations = { 3451da177e4SLinus Torvalds .d_delete = sockfs_delete_dentry, 346c23fbb6bSEric Dumazet .d_dname = sockfs_dname, 3471da177e4SLinus Torvalds }; 3481da177e4SLinus Torvalds 3491da177e4SLinus Torvalds /* 3501da177e4SLinus Torvalds * Obtains the first available file descriptor and sets it up for use. 3511da177e4SLinus Torvalds * 35239d8c1b6SDavid S. Miller * These functions create file structures and maps them to fd space 35339d8c1b6SDavid S. Miller * of the current process. On success it returns file descriptor 3541da177e4SLinus Torvalds * and file struct implicitly stored in sock->file. 3551da177e4SLinus Torvalds * Note that another thread may close file descriptor before we return 3561da177e4SLinus Torvalds * from this function. We use the fact that now we do not refer 3571da177e4SLinus Torvalds * to socket after mapping. If one day we will need it, this 3581da177e4SLinus Torvalds * function will increment ref. count on file by 1. 3591da177e4SLinus Torvalds * 3601da177e4SLinus Torvalds * In any case returned fd MAY BE not valid! 3611da177e4SLinus Torvalds * This race condition is unavoidable 3621da177e4SLinus Torvalds * with shared fd spaces, we cannot solve it inside kernel, 3631da177e4SLinus Torvalds * but we take care of internal coherence yet. 3641da177e4SLinus Torvalds */ 3651da177e4SLinus Torvalds 366a677a039SUlrich Drepper static int sock_alloc_fd(struct file **filep, int flags) 3671da177e4SLinus Torvalds { 3681da177e4SLinus Torvalds int fd; 3691da177e4SLinus Torvalds 370a677a039SUlrich Drepper fd = get_unused_fd_flags(flags); 37139d8c1b6SDavid S. Miller if (likely(fd >= 0)) { 3721da177e4SLinus Torvalds struct file *file = get_empty_filp(); 3731da177e4SLinus Torvalds 37439d8c1b6SDavid S. Miller *filep = file; 37539d8c1b6SDavid S. Miller if (unlikely(!file)) { 3761da177e4SLinus Torvalds put_unused_fd(fd); 37739d8c1b6SDavid S. Miller return -ENFILE; 3781da177e4SLinus Torvalds } 37939d8c1b6SDavid S. Miller } else 38039d8c1b6SDavid S. Miller *filep = NULL; 38139d8c1b6SDavid S. Miller return fd; 38239d8c1b6SDavid S. Miller } 38339d8c1b6SDavid S. Miller 38477d27200SUlrich Drepper static int sock_attach_fd(struct socket *sock, struct file *file, int flags) 38539d8c1b6SDavid S. Miller { 386ce8d2cdfSDave Hansen struct dentry *dentry; 387c23fbb6bSEric Dumazet struct qstr name = { .name = "" }; 3881da177e4SLinus Torvalds 389ce8d2cdfSDave Hansen dentry = d_alloc(sock_mnt->mnt_sb->s_root, &name); 390ce8d2cdfSDave Hansen if (unlikely(!dentry)) 39139d8c1b6SDavid S. Miller return -ENOMEM; 39239d8c1b6SDavid S. Miller 393ce8d2cdfSDave Hansen dentry->d_op = &sockfs_dentry_operations; 394304e61e6SEric Dumazet /* 395304e61e6SEric Dumazet * We dont want to push this dentry into global dentry hash table. 396304e61e6SEric Dumazet * We pretend dentry is already hashed, by unsetting DCACHE_UNHASHED 397304e61e6SEric Dumazet * This permits a working /proc/$pid/fd/XXX on sockets 398304e61e6SEric Dumazet */ 399ce8d2cdfSDave Hansen dentry->d_flags &= ~DCACHE_UNHASHED; 400ce8d2cdfSDave Hansen d_instantiate(dentry, SOCK_INODE(sock)); 4011da177e4SLinus Torvalds 4021da177e4SLinus Torvalds sock->file = file; 403ce8d2cdfSDave Hansen init_file(file, sock_mnt, dentry, FMODE_READ | FMODE_WRITE, 404ce8d2cdfSDave Hansen &socket_file_ops); 405ce8d2cdfSDave Hansen SOCK_INODE(sock)->i_fop = &socket_file_ops; 40677d27200SUlrich Drepper file->f_flags = O_RDWR | (flags & O_NONBLOCK); 4071da177e4SLinus Torvalds file->f_pos = 0; 40807dc3f07SBenjamin LaHaise file->private_data = sock; 40939d8c1b6SDavid S. Miller 41039d8c1b6SDavid S. Miller return 0; 4111da177e4SLinus Torvalds } 4121da177e4SLinus Torvalds 413a677a039SUlrich Drepper int sock_map_fd(struct socket *sock, int flags) 41439d8c1b6SDavid S. Miller { 41539d8c1b6SDavid S. Miller struct file *newfile; 416a677a039SUlrich Drepper int fd = sock_alloc_fd(&newfile, flags); 41739d8c1b6SDavid S. Miller 41839d8c1b6SDavid S. Miller if (likely(fd >= 0)) { 41977d27200SUlrich Drepper int err = sock_attach_fd(sock, newfile, flags); 42039d8c1b6SDavid S. Miller 42139d8c1b6SDavid S. Miller if (unlikely(err < 0)) { 42239d8c1b6SDavid S. Miller put_filp(newfile); 42339d8c1b6SDavid S. Miller put_unused_fd(fd); 42439d8c1b6SDavid S. Miller return err; 42539d8c1b6SDavid S. Miller } 42639d8c1b6SDavid S. Miller fd_install(fd, newfile); 42739d8c1b6SDavid S. Miller } 4281da177e4SLinus Torvalds return fd; 4291da177e4SLinus Torvalds } 4301da177e4SLinus Torvalds 4316cb153caSBenjamin LaHaise static struct socket *sock_from_file(struct file *file, int *err) 4326cb153caSBenjamin LaHaise { 4336cb153caSBenjamin LaHaise if (file->f_op == &socket_file_ops) 4346cb153caSBenjamin LaHaise return file->private_data; /* set in sock_map_fd */ 4356cb153caSBenjamin LaHaise 4366cb153caSBenjamin LaHaise *err = -ENOTSOCK; 4376cb153caSBenjamin LaHaise return NULL; 4386cb153caSBenjamin LaHaise } 4396cb153caSBenjamin LaHaise 4401da177e4SLinus Torvalds /** 4411da177e4SLinus Torvalds * sockfd_lookup - Go from a file number to its socket slot 4421da177e4SLinus Torvalds * @fd: file handle 4431da177e4SLinus Torvalds * @err: pointer to an error code return 4441da177e4SLinus Torvalds * 4451da177e4SLinus Torvalds * The file handle passed in is locked and the socket it is bound 4461da177e4SLinus Torvalds * too is returned. If an error occurs the err pointer is overwritten 4471da177e4SLinus Torvalds * with a negative errno code and NULL is returned. The function checks 4481da177e4SLinus Torvalds * for both invalid handles and passing a handle which is not a socket. 4491da177e4SLinus Torvalds * 4501da177e4SLinus Torvalds * On a success the socket object pointer is returned. 4511da177e4SLinus Torvalds */ 4521da177e4SLinus Torvalds 4531da177e4SLinus Torvalds struct socket *sockfd_lookup(int fd, int *err) 4541da177e4SLinus Torvalds { 4551da177e4SLinus Torvalds struct file *file; 4561da177e4SLinus Torvalds struct socket *sock; 4571da177e4SLinus Torvalds 45889bddce5SStephen Hemminger file = fget(fd); 45989bddce5SStephen Hemminger if (!file) { 4601da177e4SLinus Torvalds *err = -EBADF; 4611da177e4SLinus Torvalds return NULL; 4621da177e4SLinus Torvalds } 46389bddce5SStephen Hemminger 4646cb153caSBenjamin LaHaise sock = sock_from_file(file, err); 4656cb153caSBenjamin LaHaise if (!sock) 4661da177e4SLinus Torvalds fput(file); 4676cb153caSBenjamin LaHaise return sock; 4681da177e4SLinus Torvalds } 4691da177e4SLinus Torvalds 4706cb153caSBenjamin LaHaise static struct socket *sockfd_lookup_light(int fd, int *err, int *fput_needed) 4716cb153caSBenjamin LaHaise { 4726cb153caSBenjamin LaHaise struct file *file; 4736cb153caSBenjamin LaHaise struct socket *sock; 4746cb153caSBenjamin LaHaise 4753672558cSHua Zhong *err = -EBADF; 4766cb153caSBenjamin LaHaise file = fget_light(fd, fput_needed); 4776cb153caSBenjamin LaHaise if (file) { 4786cb153caSBenjamin LaHaise sock = sock_from_file(file, err); 4796cb153caSBenjamin LaHaise if (sock) 4801da177e4SLinus Torvalds return sock; 4816cb153caSBenjamin LaHaise fput_light(file, *fput_needed); 4826cb153caSBenjamin LaHaise } 4836cb153caSBenjamin LaHaise return NULL; 4841da177e4SLinus Torvalds } 4851da177e4SLinus Torvalds 4861da177e4SLinus Torvalds /** 4871da177e4SLinus Torvalds * sock_alloc - allocate a socket 4881da177e4SLinus Torvalds * 4891da177e4SLinus Torvalds * Allocate a new inode and socket object. The two are bound together 4901da177e4SLinus Torvalds * and initialised. The socket is then returned. If we are out of inodes 4911da177e4SLinus Torvalds * NULL is returned. 4921da177e4SLinus Torvalds */ 4931da177e4SLinus Torvalds 4941da177e4SLinus Torvalds static struct socket *sock_alloc(void) 4951da177e4SLinus Torvalds { 4961da177e4SLinus Torvalds struct inode *inode; 4971da177e4SLinus Torvalds struct socket *sock; 4981da177e4SLinus Torvalds 4991da177e4SLinus Torvalds inode = new_inode(sock_mnt->mnt_sb); 5001da177e4SLinus Torvalds if (!inode) 5011da177e4SLinus Torvalds return NULL; 5021da177e4SLinus Torvalds 5031da177e4SLinus Torvalds sock = SOCKET_I(inode); 5041da177e4SLinus Torvalds 50529a020d3SEric Dumazet kmemcheck_annotate_bitfield(sock, type); 5061da177e4SLinus Torvalds inode->i_mode = S_IFSOCK | S_IRWXUGO; 5078192b0c4SDavid Howells inode->i_uid = current_fsuid(); 5088192b0c4SDavid Howells inode->i_gid = current_fsgid(); 5091da177e4SLinus Torvalds 5104e69489aSEric Dumazet percpu_add(sockets_in_use, 1); 5111da177e4SLinus Torvalds return sock; 5121da177e4SLinus Torvalds } 5131da177e4SLinus Torvalds 5141da177e4SLinus Torvalds /* 5151da177e4SLinus Torvalds * In theory you can't get an open on this inode, but /proc provides 5161da177e4SLinus Torvalds * a back door. Remember to keep it shut otherwise you'll let the 5171da177e4SLinus Torvalds * creepy crawlies in. 5181da177e4SLinus Torvalds */ 5191da177e4SLinus Torvalds 5201da177e4SLinus Torvalds static int sock_no_open(struct inode *irrelevant, struct file *dontcare) 5211da177e4SLinus Torvalds { 5221da177e4SLinus Torvalds return -ENXIO; 5231da177e4SLinus Torvalds } 5241da177e4SLinus Torvalds 5254b6f5d20SArjan van de Ven const struct file_operations bad_sock_fops = { 5261da177e4SLinus Torvalds .owner = THIS_MODULE, 5271da177e4SLinus Torvalds .open = sock_no_open, 5281da177e4SLinus Torvalds }; 5291da177e4SLinus Torvalds 5301da177e4SLinus Torvalds /** 5311da177e4SLinus Torvalds * sock_release - close a socket 5321da177e4SLinus Torvalds * @sock: socket to close 5331da177e4SLinus Torvalds * 5341da177e4SLinus Torvalds * The socket is released from the protocol stack if it has a release 5351da177e4SLinus Torvalds * callback, and the inode is then released if the socket is bound to 5361da177e4SLinus Torvalds * an inode not a file. 5371da177e4SLinus Torvalds */ 5381da177e4SLinus Torvalds 5391da177e4SLinus Torvalds void sock_release(struct socket *sock) 5401da177e4SLinus Torvalds { 5411da177e4SLinus Torvalds if (sock->ops) { 5421da177e4SLinus Torvalds struct module *owner = sock->ops->owner; 5431da177e4SLinus Torvalds 5441da177e4SLinus Torvalds sock->ops->release(sock); 5451da177e4SLinus Torvalds sock->ops = NULL; 5461da177e4SLinus Torvalds module_put(owner); 5471da177e4SLinus Torvalds } 5481da177e4SLinus Torvalds 5491da177e4SLinus Torvalds if (sock->fasync_list) 5501da177e4SLinus Torvalds printk(KERN_ERR "sock_release: fasync list not empty!\n"); 5511da177e4SLinus Torvalds 5524e69489aSEric Dumazet percpu_sub(sockets_in_use, 1); 5531da177e4SLinus Torvalds if (!sock->file) { 5541da177e4SLinus Torvalds iput(SOCK_INODE(sock)); 5551da177e4SLinus Torvalds return; 5561da177e4SLinus Torvalds } 5571da177e4SLinus Torvalds sock->file = NULL; 5581da177e4SLinus Torvalds } 5591da177e4SLinus Torvalds 56020d49473SPatrick Ohly int sock_tx_timestamp(struct msghdr *msg, struct sock *sk, 56120d49473SPatrick Ohly union skb_shared_tx *shtx) 56220d49473SPatrick Ohly { 56320d49473SPatrick Ohly shtx->flags = 0; 56420d49473SPatrick Ohly if (sock_flag(sk, SOCK_TIMESTAMPING_TX_HARDWARE)) 56520d49473SPatrick Ohly shtx->hardware = 1; 56620d49473SPatrick Ohly if (sock_flag(sk, SOCK_TIMESTAMPING_TX_SOFTWARE)) 56720d49473SPatrick Ohly shtx->software = 1; 56820d49473SPatrick Ohly return 0; 56920d49473SPatrick Ohly } 57020d49473SPatrick Ohly EXPORT_SYMBOL(sock_tx_timestamp); 57120d49473SPatrick Ohly 5721da177e4SLinus Torvalds static inline int __sock_sendmsg(struct kiocb *iocb, struct socket *sock, 5731da177e4SLinus Torvalds struct msghdr *msg, size_t size) 5741da177e4SLinus Torvalds { 5751da177e4SLinus Torvalds struct sock_iocb *si = kiocb_to_siocb(iocb); 5761da177e4SLinus Torvalds int err; 5771da177e4SLinus Torvalds 5781da177e4SLinus Torvalds si->sock = sock; 5791da177e4SLinus Torvalds si->scm = NULL; 5801da177e4SLinus Torvalds si->msg = msg; 5811da177e4SLinus Torvalds si->size = size; 5821da177e4SLinus Torvalds 5831da177e4SLinus Torvalds err = security_socket_sendmsg(sock, msg, size); 5841da177e4SLinus Torvalds if (err) 5851da177e4SLinus Torvalds return err; 5861da177e4SLinus Torvalds 5871da177e4SLinus Torvalds return sock->ops->sendmsg(iocb, sock, msg, size); 5881da177e4SLinus Torvalds } 5891da177e4SLinus Torvalds 5901da177e4SLinus Torvalds int sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t size) 5911da177e4SLinus Torvalds { 5921da177e4SLinus Torvalds struct kiocb iocb; 5931da177e4SLinus Torvalds struct sock_iocb siocb; 5941da177e4SLinus Torvalds int ret; 5951da177e4SLinus Torvalds 5961da177e4SLinus Torvalds init_sync_kiocb(&iocb, NULL); 5971da177e4SLinus Torvalds iocb.private = &siocb; 5981da177e4SLinus Torvalds ret = __sock_sendmsg(&iocb, sock, msg, size); 5991da177e4SLinus Torvalds if (-EIOCBQUEUED == ret) 6001da177e4SLinus Torvalds ret = wait_on_sync_kiocb(&iocb); 6011da177e4SLinus Torvalds return ret; 6021da177e4SLinus Torvalds } 6031da177e4SLinus Torvalds 6041da177e4SLinus Torvalds int kernel_sendmsg(struct socket *sock, struct msghdr *msg, 6051da177e4SLinus Torvalds struct kvec *vec, size_t num, size_t size) 6061da177e4SLinus Torvalds { 6071da177e4SLinus Torvalds mm_segment_t oldfs = get_fs(); 6081da177e4SLinus Torvalds int result; 6091da177e4SLinus Torvalds 6101da177e4SLinus Torvalds set_fs(KERNEL_DS); 6111da177e4SLinus Torvalds /* 6121da177e4SLinus Torvalds * the following is safe, since for compiler definitions of kvec and 6131da177e4SLinus Torvalds * iovec are identical, yielding the same in-core layout and alignment 6141da177e4SLinus Torvalds */ 61589bddce5SStephen Hemminger msg->msg_iov = (struct iovec *)vec; 6161da177e4SLinus Torvalds msg->msg_iovlen = num; 6171da177e4SLinus Torvalds result = sock_sendmsg(sock, msg, size); 6181da177e4SLinus Torvalds set_fs(oldfs); 6191da177e4SLinus Torvalds return result; 6201da177e4SLinus Torvalds } 6211da177e4SLinus Torvalds 62220d49473SPatrick Ohly static int ktime2ts(ktime_t kt, struct timespec *ts) 62320d49473SPatrick Ohly { 62420d49473SPatrick Ohly if (kt.tv64) { 62520d49473SPatrick Ohly *ts = ktime_to_timespec(kt); 62620d49473SPatrick Ohly return 1; 62720d49473SPatrick Ohly } else { 62820d49473SPatrick Ohly return 0; 62920d49473SPatrick Ohly } 63020d49473SPatrick Ohly } 63120d49473SPatrick Ohly 63292f37fd2SEric Dumazet /* 63392f37fd2SEric Dumazet * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP) 63492f37fd2SEric Dumazet */ 63592f37fd2SEric Dumazet void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk, 63692f37fd2SEric Dumazet struct sk_buff *skb) 63792f37fd2SEric Dumazet { 63820d49473SPatrick Ohly int need_software_tstamp = sock_flag(sk, SOCK_RCVTSTAMP); 63920d49473SPatrick Ohly struct timespec ts[3]; 64020d49473SPatrick Ohly int empty = 1; 64120d49473SPatrick Ohly struct skb_shared_hwtstamps *shhwtstamps = 64220d49473SPatrick Ohly skb_hwtstamps(skb); 64392f37fd2SEric Dumazet 64420d49473SPatrick Ohly /* Race occurred between timestamp enabling and packet 64520d49473SPatrick Ohly receiving. Fill in the current time for now. */ 64620d49473SPatrick Ohly if (need_software_tstamp && skb->tstamp.tv64 == 0) 64720d49473SPatrick Ohly __net_timestamp(skb); 64820d49473SPatrick Ohly 64920d49473SPatrick Ohly if (need_software_tstamp) { 65092f37fd2SEric Dumazet if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) { 65192f37fd2SEric Dumazet struct timeval tv; 65220d49473SPatrick Ohly skb_get_timestamp(skb, &tv); 65320d49473SPatrick Ohly put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP, 65420d49473SPatrick Ohly sizeof(tv), &tv); 65592f37fd2SEric Dumazet } else { 65692f37fd2SEric Dumazet struct timespec ts; 65720d49473SPatrick Ohly skb_get_timestampns(skb, &ts); 65820d49473SPatrick Ohly put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS, 65920d49473SPatrick Ohly sizeof(ts), &ts); 66092f37fd2SEric Dumazet } 66192f37fd2SEric Dumazet } 66292f37fd2SEric Dumazet 66320d49473SPatrick Ohly 66420d49473SPatrick Ohly memset(ts, 0, sizeof(ts)); 66520d49473SPatrick Ohly if (skb->tstamp.tv64 && 66620d49473SPatrick Ohly sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE)) { 66720d49473SPatrick Ohly skb_get_timestampns(skb, ts + 0); 66820d49473SPatrick Ohly empty = 0; 66920d49473SPatrick Ohly } 67020d49473SPatrick Ohly if (shhwtstamps) { 67120d49473SPatrick Ohly if (sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE) && 67220d49473SPatrick Ohly ktime2ts(shhwtstamps->syststamp, ts + 1)) 67320d49473SPatrick Ohly empty = 0; 67420d49473SPatrick Ohly if (sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE) && 67520d49473SPatrick Ohly ktime2ts(shhwtstamps->hwtstamp, ts + 2)) 67620d49473SPatrick Ohly empty = 0; 67720d49473SPatrick Ohly } 67820d49473SPatrick Ohly if (!empty) 67920d49473SPatrick Ohly put_cmsg(msg, SOL_SOCKET, 68020d49473SPatrick Ohly SCM_TIMESTAMPING, sizeof(ts), &ts); 68120d49473SPatrick Ohly } 68220d49473SPatrick Ohly 6837c81fd8bSArnaldo Carvalho de Melo EXPORT_SYMBOL_GPL(__sock_recv_timestamp); 6847c81fd8bSArnaldo Carvalho de Melo 6853b885787SNeil Horman inline void sock_recv_drops(struct msghdr *msg, struct sock *sk, struct sk_buff *skb) 6863b885787SNeil Horman { 6873b885787SNeil Horman if (sock_flag(sk, SOCK_RXQ_OVFL) && skb && skb->dropcount) 6883b885787SNeil Horman put_cmsg(msg, SOL_SOCKET, SO_RXQ_OVFL, 6893b885787SNeil Horman sizeof(__u32), &skb->dropcount); 6903b885787SNeil Horman } 6913b885787SNeil Horman 6923b885787SNeil Horman void sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk, 6933b885787SNeil Horman struct sk_buff *skb) 6943b885787SNeil Horman { 6953b885787SNeil Horman sock_recv_timestamp(msg, sk, skb); 6963b885787SNeil Horman sock_recv_drops(msg, sk, skb); 6973b885787SNeil Horman } 6983b885787SNeil Horman EXPORT_SYMBOL_GPL(sock_recv_ts_and_drops); 6993b885787SNeil Horman 700a2e27255SArnaldo Carvalho de Melo static inline int __sock_recvmsg_nosec(struct kiocb *iocb, struct socket *sock, 7011da177e4SLinus Torvalds struct msghdr *msg, size_t size, int flags) 7021da177e4SLinus Torvalds { 7031da177e4SLinus Torvalds struct sock_iocb *si = kiocb_to_siocb(iocb); 7041da177e4SLinus Torvalds 7051da177e4SLinus Torvalds si->sock = sock; 7061da177e4SLinus Torvalds si->scm = NULL; 7071da177e4SLinus Torvalds si->msg = msg; 7081da177e4SLinus Torvalds si->size = size; 7091da177e4SLinus Torvalds si->flags = flags; 7101da177e4SLinus Torvalds 7111da177e4SLinus Torvalds return sock->ops->recvmsg(iocb, sock, msg, size, flags); 7121da177e4SLinus Torvalds } 7131da177e4SLinus Torvalds 714a2e27255SArnaldo Carvalho de Melo static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock, 715a2e27255SArnaldo Carvalho de Melo struct msghdr *msg, size_t size, int flags) 716a2e27255SArnaldo Carvalho de Melo { 717a2e27255SArnaldo Carvalho de Melo int err = security_socket_recvmsg(sock, msg, size, flags); 718a2e27255SArnaldo Carvalho de Melo 719a2e27255SArnaldo Carvalho de Melo return err ?: __sock_recvmsg_nosec(iocb, sock, msg, size, flags); 720a2e27255SArnaldo Carvalho de Melo } 721a2e27255SArnaldo Carvalho de Melo 7221da177e4SLinus Torvalds int sock_recvmsg(struct socket *sock, struct msghdr *msg, 7231da177e4SLinus Torvalds size_t size, int flags) 7241da177e4SLinus Torvalds { 7251da177e4SLinus Torvalds struct kiocb iocb; 7261da177e4SLinus Torvalds struct sock_iocb siocb; 7271da177e4SLinus Torvalds int ret; 7281da177e4SLinus Torvalds 7291da177e4SLinus Torvalds init_sync_kiocb(&iocb, NULL); 7301da177e4SLinus Torvalds iocb.private = &siocb; 7311da177e4SLinus Torvalds ret = __sock_recvmsg(&iocb, sock, msg, size, flags); 7321da177e4SLinus Torvalds if (-EIOCBQUEUED == ret) 7331da177e4SLinus Torvalds ret = wait_on_sync_kiocb(&iocb); 7341da177e4SLinus Torvalds return ret; 7351da177e4SLinus Torvalds } 7361da177e4SLinus Torvalds 737a2e27255SArnaldo Carvalho de Melo static int sock_recvmsg_nosec(struct socket *sock, struct msghdr *msg, 738a2e27255SArnaldo Carvalho de Melo size_t size, int flags) 739a2e27255SArnaldo Carvalho de Melo { 740a2e27255SArnaldo Carvalho de Melo struct kiocb iocb; 741a2e27255SArnaldo Carvalho de Melo struct sock_iocb siocb; 742a2e27255SArnaldo Carvalho de Melo int ret; 743a2e27255SArnaldo Carvalho de Melo 744a2e27255SArnaldo Carvalho de Melo init_sync_kiocb(&iocb, NULL); 745a2e27255SArnaldo Carvalho de Melo iocb.private = &siocb; 746a2e27255SArnaldo Carvalho de Melo ret = __sock_recvmsg_nosec(&iocb, sock, msg, size, flags); 747a2e27255SArnaldo Carvalho de Melo if (-EIOCBQUEUED == ret) 748a2e27255SArnaldo Carvalho de Melo ret = wait_on_sync_kiocb(&iocb); 749a2e27255SArnaldo Carvalho de Melo return ret; 750a2e27255SArnaldo Carvalho de Melo } 751a2e27255SArnaldo Carvalho de Melo 7521da177e4SLinus Torvalds int kernel_recvmsg(struct socket *sock, struct msghdr *msg, 75389bddce5SStephen Hemminger struct kvec *vec, size_t num, size_t size, int flags) 7541da177e4SLinus Torvalds { 7551da177e4SLinus Torvalds mm_segment_t oldfs = get_fs(); 7561da177e4SLinus Torvalds int result; 7571da177e4SLinus Torvalds 7581da177e4SLinus Torvalds set_fs(KERNEL_DS); 7591da177e4SLinus Torvalds /* 7601da177e4SLinus Torvalds * the following is safe, since for compiler definitions of kvec and 7611da177e4SLinus Torvalds * iovec are identical, yielding the same in-core layout and alignment 7621da177e4SLinus Torvalds */ 76389bddce5SStephen Hemminger msg->msg_iov = (struct iovec *)vec, msg->msg_iovlen = num; 7641da177e4SLinus Torvalds result = sock_recvmsg(sock, msg, size, flags); 7651da177e4SLinus Torvalds set_fs(oldfs); 7661da177e4SLinus Torvalds return result; 7671da177e4SLinus Torvalds } 7681da177e4SLinus Torvalds 7691da177e4SLinus Torvalds static void sock_aio_dtor(struct kiocb *iocb) 7701da177e4SLinus Torvalds { 7711da177e4SLinus Torvalds kfree(iocb->private); 7721da177e4SLinus Torvalds } 7731da177e4SLinus Torvalds 77420380731SArnaldo Carvalho de Melo static ssize_t sock_sendpage(struct file *file, struct page *page, 7751da177e4SLinus Torvalds int offset, size_t size, loff_t *ppos, int more) 7761da177e4SLinus Torvalds { 7771da177e4SLinus Torvalds struct socket *sock; 7781da177e4SLinus Torvalds int flags; 7791da177e4SLinus Torvalds 780b69aee04SEric Dumazet sock = file->private_data; 7811da177e4SLinus Torvalds 7821da177e4SLinus Torvalds flags = !(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT; 7831da177e4SLinus Torvalds if (more) 7841da177e4SLinus Torvalds flags |= MSG_MORE; 7851da177e4SLinus Torvalds 786e6949583SLinus Torvalds return kernel_sendpage(sock, page, offset, size, flags); 7871da177e4SLinus Torvalds } 7881da177e4SLinus Torvalds 7899c55e01cSJens Axboe static ssize_t sock_splice_read(struct file *file, loff_t *ppos, 7909c55e01cSJens Axboe struct pipe_inode_info *pipe, size_t len, 7919c55e01cSJens Axboe unsigned int flags) 7929c55e01cSJens Axboe { 7939c55e01cSJens Axboe struct socket *sock = file->private_data; 7949c55e01cSJens Axboe 795997b37daSRémi Denis-Courmont if (unlikely(!sock->ops->splice_read)) 796997b37daSRémi Denis-Courmont return -EINVAL; 797997b37daSRémi Denis-Courmont 7989c55e01cSJens Axboe return sock->ops->splice_read(sock, ppos, pipe, len, flags); 7999c55e01cSJens Axboe } 8009c55e01cSJens Axboe 801ce1d4d3eSChristoph Hellwig static struct sock_iocb *alloc_sock_iocb(struct kiocb *iocb, 80289bddce5SStephen Hemminger struct sock_iocb *siocb) 803ce1d4d3eSChristoph Hellwig { 804ce1d4d3eSChristoph Hellwig if (!is_sync_kiocb(iocb)) { 805ce1d4d3eSChristoph Hellwig siocb = kmalloc(sizeof(*siocb), GFP_KERNEL); 806ce1d4d3eSChristoph Hellwig if (!siocb) 807ce1d4d3eSChristoph Hellwig return NULL; 808ce1d4d3eSChristoph Hellwig iocb->ki_dtor = sock_aio_dtor; 809ce1d4d3eSChristoph Hellwig } 810ce1d4d3eSChristoph Hellwig 811ce1d4d3eSChristoph Hellwig siocb->kiocb = iocb; 812ce1d4d3eSChristoph Hellwig iocb->private = siocb; 813ce1d4d3eSChristoph Hellwig return siocb; 814ce1d4d3eSChristoph Hellwig } 815ce1d4d3eSChristoph Hellwig 816ce1d4d3eSChristoph Hellwig static ssize_t do_sock_read(struct msghdr *msg, struct kiocb *iocb, 817027445c3SBadari Pulavarty struct file *file, const struct iovec *iov, 81889bddce5SStephen Hemminger unsigned long nr_segs) 819ce1d4d3eSChristoph Hellwig { 820ce1d4d3eSChristoph Hellwig struct socket *sock = file->private_data; 821ce1d4d3eSChristoph Hellwig size_t size = 0; 822ce1d4d3eSChristoph Hellwig int i; 823ce1d4d3eSChristoph Hellwig 824ce1d4d3eSChristoph Hellwig for (i = 0; i < nr_segs; i++) 825ce1d4d3eSChristoph Hellwig size += iov[i].iov_len; 826ce1d4d3eSChristoph Hellwig 827ce1d4d3eSChristoph Hellwig msg->msg_name = NULL; 828ce1d4d3eSChristoph Hellwig msg->msg_namelen = 0; 829ce1d4d3eSChristoph Hellwig msg->msg_control = NULL; 830ce1d4d3eSChristoph Hellwig msg->msg_controllen = 0; 831ce1d4d3eSChristoph Hellwig msg->msg_iov = (struct iovec *)iov; 832ce1d4d3eSChristoph Hellwig msg->msg_iovlen = nr_segs; 833ce1d4d3eSChristoph Hellwig msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0; 834ce1d4d3eSChristoph Hellwig 835ce1d4d3eSChristoph Hellwig return __sock_recvmsg(iocb, sock, msg, size, msg->msg_flags); 836ce1d4d3eSChristoph Hellwig } 837ce1d4d3eSChristoph Hellwig 838027445c3SBadari Pulavarty static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov, 839027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos) 840ce1d4d3eSChristoph Hellwig { 841ce1d4d3eSChristoph Hellwig struct sock_iocb siocb, *x; 842ce1d4d3eSChristoph Hellwig 843ce1d4d3eSChristoph Hellwig if (pos != 0) 844ce1d4d3eSChristoph Hellwig return -ESPIPE; 845027445c3SBadari Pulavarty 846027445c3SBadari Pulavarty if (iocb->ki_left == 0) /* Match SYS5 behaviour */ 847ce1d4d3eSChristoph Hellwig return 0; 848ce1d4d3eSChristoph Hellwig 849027445c3SBadari Pulavarty 850027445c3SBadari Pulavarty x = alloc_sock_iocb(iocb, &siocb); 851ce1d4d3eSChristoph Hellwig if (!x) 852ce1d4d3eSChristoph Hellwig return -ENOMEM; 853027445c3SBadari Pulavarty return do_sock_read(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs); 854ce1d4d3eSChristoph Hellwig } 855ce1d4d3eSChristoph Hellwig 856ce1d4d3eSChristoph Hellwig static ssize_t do_sock_write(struct msghdr *msg, struct kiocb *iocb, 857027445c3SBadari Pulavarty struct file *file, const struct iovec *iov, 85889bddce5SStephen Hemminger unsigned long nr_segs) 859ce1d4d3eSChristoph Hellwig { 860ce1d4d3eSChristoph Hellwig struct socket *sock = file->private_data; 861ce1d4d3eSChristoph Hellwig size_t size = 0; 862ce1d4d3eSChristoph Hellwig int i; 863ce1d4d3eSChristoph Hellwig 864ce1d4d3eSChristoph Hellwig for (i = 0; i < nr_segs; i++) 865ce1d4d3eSChristoph Hellwig size += iov[i].iov_len; 866ce1d4d3eSChristoph Hellwig 867ce1d4d3eSChristoph Hellwig msg->msg_name = NULL; 868ce1d4d3eSChristoph Hellwig msg->msg_namelen = 0; 869ce1d4d3eSChristoph Hellwig msg->msg_control = NULL; 870ce1d4d3eSChristoph Hellwig msg->msg_controllen = 0; 871ce1d4d3eSChristoph Hellwig msg->msg_iov = (struct iovec *)iov; 872ce1d4d3eSChristoph Hellwig msg->msg_iovlen = nr_segs; 873ce1d4d3eSChristoph Hellwig msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0; 874ce1d4d3eSChristoph Hellwig if (sock->type == SOCK_SEQPACKET) 875ce1d4d3eSChristoph Hellwig msg->msg_flags |= MSG_EOR; 876ce1d4d3eSChristoph Hellwig 877ce1d4d3eSChristoph Hellwig return __sock_sendmsg(iocb, sock, msg, size); 878ce1d4d3eSChristoph Hellwig } 879ce1d4d3eSChristoph Hellwig 880027445c3SBadari Pulavarty static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov, 881027445c3SBadari Pulavarty unsigned long nr_segs, loff_t pos) 8821da177e4SLinus Torvalds { 883ce1d4d3eSChristoph Hellwig struct sock_iocb siocb, *x; 8841da177e4SLinus Torvalds 885ce1d4d3eSChristoph Hellwig if (pos != 0) 886ce1d4d3eSChristoph Hellwig return -ESPIPE; 887027445c3SBadari Pulavarty 888027445c3SBadari Pulavarty x = alloc_sock_iocb(iocb, &siocb); 889ce1d4d3eSChristoph Hellwig if (!x) 890ce1d4d3eSChristoph Hellwig return -ENOMEM; 891ce1d4d3eSChristoph Hellwig 892027445c3SBadari Pulavarty return do_sock_write(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs); 8931da177e4SLinus Torvalds } 8941da177e4SLinus Torvalds 8951da177e4SLinus Torvalds /* 8961da177e4SLinus Torvalds * Atomic setting of ioctl hooks to avoid race 8971da177e4SLinus Torvalds * with module unload. 8981da177e4SLinus Torvalds */ 8991da177e4SLinus Torvalds 9004a3e2f71SArjan van de Ven static DEFINE_MUTEX(br_ioctl_mutex); 901881d966bSEric W. Biederman static int (*br_ioctl_hook) (struct net *, unsigned int cmd, void __user *arg) = NULL; 9021da177e4SLinus Torvalds 903881d966bSEric W. Biederman void brioctl_set(int (*hook) (struct net *, unsigned int, void __user *)) 9041da177e4SLinus Torvalds { 9054a3e2f71SArjan van de Ven mutex_lock(&br_ioctl_mutex); 9061da177e4SLinus Torvalds br_ioctl_hook = hook; 9074a3e2f71SArjan van de Ven mutex_unlock(&br_ioctl_mutex); 9081da177e4SLinus Torvalds } 90989bddce5SStephen Hemminger 9101da177e4SLinus Torvalds EXPORT_SYMBOL(brioctl_set); 9111da177e4SLinus Torvalds 9124a3e2f71SArjan van de Ven static DEFINE_MUTEX(vlan_ioctl_mutex); 913881d966bSEric W. Biederman static int (*vlan_ioctl_hook) (struct net *, void __user *arg); 9141da177e4SLinus Torvalds 915881d966bSEric W. Biederman void vlan_ioctl_set(int (*hook) (struct net *, void __user *)) 9161da177e4SLinus Torvalds { 9174a3e2f71SArjan van de Ven mutex_lock(&vlan_ioctl_mutex); 9181da177e4SLinus Torvalds vlan_ioctl_hook = hook; 9194a3e2f71SArjan van de Ven mutex_unlock(&vlan_ioctl_mutex); 9201da177e4SLinus Torvalds } 92189bddce5SStephen Hemminger 9221da177e4SLinus Torvalds EXPORT_SYMBOL(vlan_ioctl_set); 9231da177e4SLinus Torvalds 9244a3e2f71SArjan van de Ven static DEFINE_MUTEX(dlci_ioctl_mutex); 9251da177e4SLinus Torvalds static int (*dlci_ioctl_hook) (unsigned int, void __user *); 9261da177e4SLinus Torvalds 9271da177e4SLinus Torvalds void dlci_ioctl_set(int (*hook) (unsigned int, void __user *)) 9281da177e4SLinus Torvalds { 9294a3e2f71SArjan van de Ven mutex_lock(&dlci_ioctl_mutex); 9301da177e4SLinus Torvalds dlci_ioctl_hook = hook; 9314a3e2f71SArjan van de Ven mutex_unlock(&dlci_ioctl_mutex); 9321da177e4SLinus Torvalds } 93389bddce5SStephen Hemminger 9341da177e4SLinus Torvalds EXPORT_SYMBOL(dlci_ioctl_set); 9351da177e4SLinus Torvalds 9366b96018bSArnd Bergmann static long sock_do_ioctl(struct net *net, struct socket *sock, 9376b96018bSArnd Bergmann unsigned int cmd, unsigned long arg) 9386b96018bSArnd Bergmann { 9396b96018bSArnd Bergmann int err; 9406b96018bSArnd Bergmann void __user *argp = (void __user *)arg; 9416b96018bSArnd Bergmann 9426b96018bSArnd Bergmann err = sock->ops->ioctl(sock, cmd, arg); 9436b96018bSArnd Bergmann 9446b96018bSArnd Bergmann /* 9456b96018bSArnd Bergmann * If this ioctl is unknown try to hand it down 9466b96018bSArnd Bergmann * to the NIC driver. 9476b96018bSArnd Bergmann */ 9486b96018bSArnd Bergmann if (err == -ENOIOCTLCMD) 9496b96018bSArnd Bergmann err = dev_ioctl(net, cmd, argp); 9506b96018bSArnd Bergmann 9516b96018bSArnd Bergmann return err; 9526b96018bSArnd Bergmann } 9536b96018bSArnd Bergmann 9541da177e4SLinus Torvalds /* 9551da177e4SLinus Torvalds * With an ioctl, arg may well be a user mode pointer, but we don't know 9561da177e4SLinus Torvalds * what to do with it - that's up to the protocol still. 9571da177e4SLinus Torvalds */ 9581da177e4SLinus Torvalds 9591da177e4SLinus Torvalds static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg) 9601da177e4SLinus Torvalds { 9611da177e4SLinus Torvalds struct socket *sock; 962881d966bSEric W. Biederman struct sock *sk; 9631da177e4SLinus Torvalds void __user *argp = (void __user *)arg; 9641da177e4SLinus Torvalds int pid, err; 965881d966bSEric W. Biederman struct net *net; 9661da177e4SLinus Torvalds 967b69aee04SEric Dumazet sock = file->private_data; 968881d966bSEric W. Biederman sk = sock->sk; 9693b1e0a65SYOSHIFUJI Hideaki net = sock_net(sk); 9701da177e4SLinus Torvalds if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) { 971881d966bSEric W. Biederman err = dev_ioctl(net, cmd, argp); 9721da177e4SLinus Torvalds } else 9733d23e349SJohannes Berg #ifdef CONFIG_WEXT_CORE 9741da177e4SLinus Torvalds if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) { 975881d966bSEric W. Biederman err = dev_ioctl(net, cmd, argp); 9761da177e4SLinus Torvalds } else 9773d23e349SJohannes Berg #endif 9781da177e4SLinus Torvalds switch (cmd) { 9791da177e4SLinus Torvalds case FIOSETOWN: 9801da177e4SLinus Torvalds case SIOCSPGRP: 9811da177e4SLinus Torvalds err = -EFAULT; 9821da177e4SLinus Torvalds if (get_user(pid, (int __user *)argp)) 9831da177e4SLinus Torvalds break; 9841da177e4SLinus Torvalds err = f_setown(sock->file, pid, 1); 9851da177e4SLinus Torvalds break; 9861da177e4SLinus Torvalds case FIOGETOWN: 9871da177e4SLinus Torvalds case SIOCGPGRP: 988609d7fa9SEric W. Biederman err = put_user(f_getown(sock->file), 98989bddce5SStephen Hemminger (int __user *)argp); 9901da177e4SLinus Torvalds break; 9911da177e4SLinus Torvalds case SIOCGIFBR: 9921da177e4SLinus Torvalds case SIOCSIFBR: 9931da177e4SLinus Torvalds case SIOCBRADDBR: 9941da177e4SLinus Torvalds case SIOCBRDELBR: 9951da177e4SLinus Torvalds err = -ENOPKG; 9961da177e4SLinus Torvalds if (!br_ioctl_hook) 9971da177e4SLinus Torvalds request_module("bridge"); 9981da177e4SLinus Torvalds 9994a3e2f71SArjan van de Ven mutex_lock(&br_ioctl_mutex); 10001da177e4SLinus Torvalds if (br_ioctl_hook) 1001881d966bSEric W. Biederman err = br_ioctl_hook(net, cmd, argp); 10024a3e2f71SArjan van de Ven mutex_unlock(&br_ioctl_mutex); 10031da177e4SLinus Torvalds break; 10041da177e4SLinus Torvalds case SIOCGIFVLAN: 10051da177e4SLinus Torvalds case SIOCSIFVLAN: 10061da177e4SLinus Torvalds err = -ENOPKG; 10071da177e4SLinus Torvalds if (!vlan_ioctl_hook) 10081da177e4SLinus Torvalds request_module("8021q"); 10091da177e4SLinus Torvalds 10104a3e2f71SArjan van de Ven mutex_lock(&vlan_ioctl_mutex); 10111da177e4SLinus Torvalds if (vlan_ioctl_hook) 1012881d966bSEric W. Biederman err = vlan_ioctl_hook(net, argp); 10134a3e2f71SArjan van de Ven mutex_unlock(&vlan_ioctl_mutex); 10141da177e4SLinus Torvalds break; 10151da177e4SLinus Torvalds case SIOCADDDLCI: 10161da177e4SLinus Torvalds case SIOCDELDLCI: 10171da177e4SLinus Torvalds err = -ENOPKG; 10181da177e4SLinus Torvalds if (!dlci_ioctl_hook) 10191da177e4SLinus Torvalds request_module("dlci"); 10201da177e4SLinus Torvalds 10214a3e2f71SArjan van de Ven mutex_lock(&dlci_ioctl_mutex); 10227512cbf6SPavel Emelyanov if (dlci_ioctl_hook) 10231da177e4SLinus Torvalds err = dlci_ioctl_hook(cmd, argp); 10244a3e2f71SArjan van de Ven mutex_unlock(&dlci_ioctl_mutex); 10251da177e4SLinus Torvalds break; 10261da177e4SLinus Torvalds default: 10276b96018bSArnd Bergmann err = sock_do_ioctl(net, sock, cmd, arg); 10281da177e4SLinus Torvalds break; 10291da177e4SLinus Torvalds } 10301da177e4SLinus Torvalds return err; 10311da177e4SLinus Torvalds } 10321da177e4SLinus Torvalds 10331da177e4SLinus Torvalds int sock_create_lite(int family, int type, int protocol, struct socket **res) 10341da177e4SLinus Torvalds { 10351da177e4SLinus Torvalds int err; 10361da177e4SLinus Torvalds struct socket *sock = NULL; 10371da177e4SLinus Torvalds 10381da177e4SLinus Torvalds err = security_socket_create(family, type, protocol, 1); 10391da177e4SLinus Torvalds if (err) 10401da177e4SLinus Torvalds goto out; 10411da177e4SLinus Torvalds 10421da177e4SLinus Torvalds sock = sock_alloc(); 10431da177e4SLinus Torvalds if (!sock) { 10441da177e4SLinus Torvalds err = -ENOMEM; 10451da177e4SLinus Torvalds goto out; 10461da177e4SLinus Torvalds } 10471da177e4SLinus Torvalds 10481da177e4SLinus Torvalds sock->type = type; 10497420ed23SVenkat Yekkirala err = security_socket_post_create(sock, family, type, protocol, 1); 10507420ed23SVenkat Yekkirala if (err) 10517420ed23SVenkat Yekkirala goto out_release; 10527420ed23SVenkat Yekkirala 10531da177e4SLinus Torvalds out: 10541da177e4SLinus Torvalds *res = sock; 10551da177e4SLinus Torvalds return err; 10567420ed23SVenkat Yekkirala out_release: 10577420ed23SVenkat Yekkirala sock_release(sock); 10587420ed23SVenkat Yekkirala sock = NULL; 10597420ed23SVenkat Yekkirala goto out; 10601da177e4SLinus Torvalds } 10611da177e4SLinus Torvalds 10621da177e4SLinus Torvalds /* No kernel lock held - perfect */ 10631da177e4SLinus Torvalds static unsigned int sock_poll(struct file *file, poll_table *wait) 10641da177e4SLinus Torvalds { 10651da177e4SLinus Torvalds struct socket *sock; 10661da177e4SLinus Torvalds 10671da177e4SLinus Torvalds /* 10681da177e4SLinus Torvalds * We can't return errors to poll, so it's either yes or no. 10691da177e4SLinus Torvalds */ 1070b69aee04SEric Dumazet sock = file->private_data; 10711da177e4SLinus Torvalds return sock->ops->poll(file, sock, wait); 10721da177e4SLinus Torvalds } 10731da177e4SLinus Torvalds 10741da177e4SLinus Torvalds static int sock_mmap(struct file *file, struct vm_area_struct *vma) 10751da177e4SLinus Torvalds { 1076b69aee04SEric Dumazet struct socket *sock = file->private_data; 10771da177e4SLinus Torvalds 10781da177e4SLinus Torvalds return sock->ops->mmap(file, sock, vma); 10791da177e4SLinus Torvalds } 10801da177e4SLinus Torvalds 108120380731SArnaldo Carvalho de Melo static int sock_close(struct inode *inode, struct file *filp) 10821da177e4SLinus Torvalds { 10831da177e4SLinus Torvalds /* 10841da177e4SLinus Torvalds * It was possible the inode is NULL we were 10851da177e4SLinus Torvalds * closing an unfinished socket. 10861da177e4SLinus Torvalds */ 10871da177e4SLinus Torvalds 108889bddce5SStephen Hemminger if (!inode) { 10891da177e4SLinus Torvalds printk(KERN_DEBUG "sock_close: NULL inode\n"); 10901da177e4SLinus Torvalds return 0; 10911da177e4SLinus Torvalds } 10921da177e4SLinus Torvalds sock_release(SOCKET_I(inode)); 10931da177e4SLinus Torvalds return 0; 10941da177e4SLinus Torvalds } 10951da177e4SLinus Torvalds 10961da177e4SLinus Torvalds /* 10971da177e4SLinus Torvalds * Update the socket async list 10981da177e4SLinus Torvalds * 10991da177e4SLinus Torvalds * Fasync_list locking strategy. 11001da177e4SLinus Torvalds * 11011da177e4SLinus Torvalds * 1. fasync_list is modified only under process context socket lock 11021da177e4SLinus Torvalds * i.e. under semaphore. 11031da177e4SLinus Torvalds * 2. fasync_list is used under read_lock(&sk->sk_callback_lock) 11041da177e4SLinus Torvalds * or under socket lock. 11051da177e4SLinus Torvalds * 3. fasync_list can be used from softirq context, so that 11061da177e4SLinus Torvalds * modification under socket lock have to be enhanced with 11071da177e4SLinus Torvalds * write_lock_bh(&sk->sk_callback_lock). 11081da177e4SLinus Torvalds * --ANK (990710) 11091da177e4SLinus Torvalds */ 11101da177e4SLinus Torvalds 11111da177e4SLinus Torvalds static int sock_fasync(int fd, struct file *filp, int on) 11121da177e4SLinus Torvalds { 11131da177e4SLinus Torvalds struct fasync_struct *fa, *fna = NULL, **prev; 11141da177e4SLinus Torvalds struct socket *sock; 11151da177e4SLinus Torvalds struct sock *sk; 11161da177e4SLinus Torvalds 111789bddce5SStephen Hemminger if (on) { 11188b3a7005SKris Katterjohn fna = kmalloc(sizeof(struct fasync_struct), GFP_KERNEL); 11191da177e4SLinus Torvalds if (fna == NULL) 11201da177e4SLinus Torvalds return -ENOMEM; 11211da177e4SLinus Torvalds } 11221da177e4SLinus Torvalds 1123b69aee04SEric Dumazet sock = filp->private_data; 11241da177e4SLinus Torvalds 112589bddce5SStephen Hemminger sk = sock->sk; 112689bddce5SStephen Hemminger if (sk == NULL) { 11271da177e4SLinus Torvalds kfree(fna); 11281da177e4SLinus Torvalds return -EINVAL; 11291da177e4SLinus Torvalds } 11301da177e4SLinus Torvalds 11311da177e4SLinus Torvalds lock_sock(sk); 11321da177e4SLinus Torvalds 113376398425SJonathan Corbet spin_lock(&filp->f_lock); 113476398425SJonathan Corbet if (on) 113576398425SJonathan Corbet filp->f_flags |= FASYNC; 113676398425SJonathan Corbet else 113776398425SJonathan Corbet filp->f_flags &= ~FASYNC; 113876398425SJonathan Corbet spin_unlock(&filp->f_lock); 113976398425SJonathan Corbet 11401da177e4SLinus Torvalds prev = &(sock->fasync_list); 11411da177e4SLinus Torvalds 11421da177e4SLinus Torvalds for (fa = *prev; fa != NULL; prev = &fa->fa_next, fa = *prev) 11431da177e4SLinus Torvalds if (fa->fa_file == filp) 11441da177e4SLinus Torvalds break; 11451da177e4SLinus Torvalds 114689bddce5SStephen Hemminger if (on) { 114789bddce5SStephen Hemminger if (fa != NULL) { 11481da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 11491da177e4SLinus Torvalds fa->fa_fd = fd; 11501da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 11511da177e4SLinus Torvalds 11521da177e4SLinus Torvalds kfree(fna); 11531da177e4SLinus Torvalds goto out; 11541da177e4SLinus Torvalds } 11551da177e4SLinus Torvalds fna->fa_file = filp; 11561da177e4SLinus Torvalds fna->fa_fd = fd; 11571da177e4SLinus Torvalds fna->magic = FASYNC_MAGIC; 11581da177e4SLinus Torvalds fna->fa_next = sock->fasync_list; 11591da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 11601da177e4SLinus Torvalds sock->fasync_list = fna; 1161bcdce719SEric Dumazet sock_set_flag(sk, SOCK_FASYNC); 11621da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 116389bddce5SStephen Hemminger } else { 116489bddce5SStephen Hemminger if (fa != NULL) { 11651da177e4SLinus Torvalds write_lock_bh(&sk->sk_callback_lock); 11661da177e4SLinus Torvalds *prev = fa->fa_next; 1167bcdce719SEric Dumazet if (!sock->fasync_list) 1168bcdce719SEric Dumazet sock_reset_flag(sk, SOCK_FASYNC); 11691da177e4SLinus Torvalds write_unlock_bh(&sk->sk_callback_lock); 11701da177e4SLinus Torvalds kfree(fa); 11711da177e4SLinus Torvalds } 11721da177e4SLinus Torvalds } 11731da177e4SLinus Torvalds 11741da177e4SLinus Torvalds out: 11751da177e4SLinus Torvalds release_sock(sock->sk); 11761da177e4SLinus Torvalds return 0; 11771da177e4SLinus Torvalds } 11781da177e4SLinus Torvalds 11791da177e4SLinus Torvalds /* This function may be called only under socket lock or callback_lock */ 11801da177e4SLinus Torvalds 11811da177e4SLinus Torvalds int sock_wake_async(struct socket *sock, int how, int band) 11821da177e4SLinus Torvalds { 11831da177e4SLinus Torvalds if (!sock || !sock->fasync_list) 11841da177e4SLinus Torvalds return -1; 118589bddce5SStephen Hemminger switch (how) { 11868d8ad9d7SPavel Emelyanov case SOCK_WAKE_WAITD: 11871da177e4SLinus Torvalds if (test_bit(SOCK_ASYNC_WAITDATA, &sock->flags)) 11881da177e4SLinus Torvalds break; 11891da177e4SLinus Torvalds goto call_kill; 11908d8ad9d7SPavel Emelyanov case SOCK_WAKE_SPACE: 11911da177e4SLinus Torvalds if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags)) 11921da177e4SLinus Torvalds break; 11931da177e4SLinus Torvalds /* fall through */ 11948d8ad9d7SPavel Emelyanov case SOCK_WAKE_IO: 11951da177e4SLinus Torvalds call_kill: 11961da177e4SLinus Torvalds __kill_fasync(sock->fasync_list, SIGIO, band); 11971da177e4SLinus Torvalds break; 11988d8ad9d7SPavel Emelyanov case SOCK_WAKE_URG: 11991da177e4SLinus Torvalds __kill_fasync(sock->fasync_list, SIGURG, band); 12001da177e4SLinus Torvalds } 12011da177e4SLinus Torvalds return 0; 12021da177e4SLinus Torvalds } 12031da177e4SLinus Torvalds 12041b8d7ae4SEric W. Biederman static int __sock_create(struct net *net, int family, int type, int protocol, 120589bddce5SStephen Hemminger struct socket **res, int kern) 12061da177e4SLinus Torvalds { 12071da177e4SLinus Torvalds int err; 12081da177e4SLinus Torvalds struct socket *sock; 120955737fdaSStephen Hemminger const struct net_proto_family *pf; 12101da177e4SLinus Torvalds 12111da177e4SLinus Torvalds /* 12121da177e4SLinus Torvalds * Check protocol is in range 12131da177e4SLinus Torvalds */ 12141da177e4SLinus Torvalds if (family < 0 || family >= NPROTO) 12151da177e4SLinus Torvalds return -EAFNOSUPPORT; 12161da177e4SLinus Torvalds if (type < 0 || type >= SOCK_MAX) 12171da177e4SLinus Torvalds return -EINVAL; 12181da177e4SLinus Torvalds 12191da177e4SLinus Torvalds /* Compatibility. 12201da177e4SLinus Torvalds 12211da177e4SLinus Torvalds This uglymoron is moved from INET layer to here to avoid 12221da177e4SLinus Torvalds deadlock in module load. 12231da177e4SLinus Torvalds */ 12241da177e4SLinus Torvalds if (family == PF_INET && type == SOCK_PACKET) { 12251da177e4SLinus Torvalds static int warned; 12261da177e4SLinus Torvalds if (!warned) { 12271da177e4SLinus Torvalds warned = 1; 122889bddce5SStephen Hemminger printk(KERN_INFO "%s uses obsolete (PF_INET,SOCK_PACKET)\n", 122989bddce5SStephen Hemminger current->comm); 12301da177e4SLinus Torvalds } 12311da177e4SLinus Torvalds family = PF_PACKET; 12321da177e4SLinus Torvalds } 12331da177e4SLinus Torvalds 12341da177e4SLinus Torvalds err = security_socket_create(family, type, protocol, kern); 12351da177e4SLinus Torvalds if (err) 12361da177e4SLinus Torvalds return err; 12371da177e4SLinus Torvalds 123855737fdaSStephen Hemminger /* 123955737fdaSStephen Hemminger * Allocate the socket and allow the family to set things up. if 124055737fdaSStephen Hemminger * the protocol is 0, the family is instructed to select an appropriate 124155737fdaSStephen Hemminger * default. 124255737fdaSStephen Hemminger */ 124355737fdaSStephen Hemminger sock = sock_alloc(); 124455737fdaSStephen Hemminger if (!sock) { 124555737fdaSStephen Hemminger if (net_ratelimit()) 124655737fdaSStephen Hemminger printk(KERN_WARNING "socket: no more sockets\n"); 124755737fdaSStephen Hemminger return -ENFILE; /* Not exactly a match, but its the 124855737fdaSStephen Hemminger closest posix thing */ 124955737fdaSStephen Hemminger } 125055737fdaSStephen Hemminger 125155737fdaSStephen Hemminger sock->type = type; 125255737fdaSStephen Hemminger 125395a5afcaSJohannes Berg #ifdef CONFIG_MODULES 12541da177e4SLinus Torvalds /* Attempt to load a protocol module if the find failed. 12551da177e4SLinus Torvalds * 12561da177e4SLinus Torvalds * 12/09/1996 Marcin: But! this makes REALLY only sense, if the user 12571da177e4SLinus Torvalds * requested real, full-featured networking support upon configuration. 12581da177e4SLinus Torvalds * Otherwise module support will break! 12591da177e4SLinus Torvalds */ 126055737fdaSStephen Hemminger if (net_families[family] == NULL) 12611da177e4SLinus Torvalds request_module("net-pf-%d", family); 12621da177e4SLinus Torvalds #endif 12631da177e4SLinus Torvalds 126455737fdaSStephen Hemminger rcu_read_lock(); 126555737fdaSStephen Hemminger pf = rcu_dereference(net_families[family]); 12661da177e4SLinus Torvalds err = -EAFNOSUPPORT; 126755737fdaSStephen Hemminger if (!pf) 126855737fdaSStephen Hemminger goto out_release; 12691da177e4SLinus Torvalds 12701da177e4SLinus Torvalds /* 12711da177e4SLinus Torvalds * We will call the ->create function, that possibly is in a loadable 12721da177e4SLinus Torvalds * module, so we have to bump that loadable module refcnt first. 12731da177e4SLinus Torvalds */ 127455737fdaSStephen Hemminger if (!try_module_get(pf->owner)) 12751da177e4SLinus Torvalds goto out_release; 12761da177e4SLinus Torvalds 127755737fdaSStephen Hemminger /* Now protected by module ref count */ 127855737fdaSStephen Hemminger rcu_read_unlock(); 127955737fdaSStephen Hemminger 12803f378b68SEric Paris err = pf->create(net, sock, protocol, kern); 128155737fdaSStephen Hemminger if (err < 0) 12821da177e4SLinus Torvalds goto out_module_put; 1283a79af59eSFrank Filz 12841da177e4SLinus Torvalds /* 12851da177e4SLinus Torvalds * Now to bump the refcnt of the [loadable] module that owns this 12861da177e4SLinus Torvalds * socket at sock_release time we decrement its refcnt. 12871da177e4SLinus Torvalds */ 128855737fdaSStephen Hemminger if (!try_module_get(sock->ops->owner)) 128955737fdaSStephen Hemminger goto out_module_busy; 129055737fdaSStephen Hemminger 12911da177e4SLinus Torvalds /* 12921da177e4SLinus Torvalds * Now that we're done with the ->create function, the [loadable] 12931da177e4SLinus Torvalds * module can have its refcnt decremented 12941da177e4SLinus Torvalds */ 129555737fdaSStephen Hemminger module_put(pf->owner); 12967420ed23SVenkat Yekkirala err = security_socket_post_create(sock, family, type, protocol, kern); 12977420ed23SVenkat Yekkirala if (err) 12983b185525SHerbert Xu goto out_sock_release; 129955737fdaSStephen Hemminger *res = sock; 13001da177e4SLinus Torvalds 130155737fdaSStephen Hemminger return 0; 130255737fdaSStephen Hemminger 130355737fdaSStephen Hemminger out_module_busy: 130455737fdaSStephen Hemminger err = -EAFNOSUPPORT; 13051da177e4SLinus Torvalds out_module_put: 130655737fdaSStephen Hemminger sock->ops = NULL; 130755737fdaSStephen Hemminger module_put(pf->owner); 130855737fdaSStephen Hemminger out_sock_release: 13091da177e4SLinus Torvalds sock_release(sock); 131055737fdaSStephen Hemminger return err; 131155737fdaSStephen Hemminger 131255737fdaSStephen Hemminger out_release: 131355737fdaSStephen Hemminger rcu_read_unlock(); 131455737fdaSStephen Hemminger goto out_sock_release; 13151da177e4SLinus Torvalds } 13161da177e4SLinus Torvalds 13171da177e4SLinus Torvalds int sock_create(int family, int type, int protocol, struct socket **res) 13181da177e4SLinus Torvalds { 13191b8d7ae4SEric W. Biederman return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0); 13201da177e4SLinus Torvalds } 13211da177e4SLinus Torvalds 13221da177e4SLinus Torvalds int sock_create_kern(int family, int type, int protocol, struct socket **res) 13231da177e4SLinus Torvalds { 13241b8d7ae4SEric W. Biederman return __sock_create(&init_net, family, type, protocol, res, 1); 13251da177e4SLinus Torvalds } 13261da177e4SLinus Torvalds 13273e0fa65fSHeiko Carstens SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol) 13281da177e4SLinus Torvalds { 13291da177e4SLinus Torvalds int retval; 13301da177e4SLinus Torvalds struct socket *sock; 1331a677a039SUlrich Drepper int flags; 1332a677a039SUlrich Drepper 1333e38b36f3SUlrich Drepper /* Check the SOCK_* constants for consistency. */ 1334e38b36f3SUlrich Drepper BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC); 1335e38b36f3SUlrich Drepper BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK); 1336e38b36f3SUlrich Drepper BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK); 1337e38b36f3SUlrich Drepper BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK); 1338e38b36f3SUlrich Drepper 1339a677a039SUlrich Drepper flags = type & ~SOCK_TYPE_MASK; 134077d27200SUlrich Drepper if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)) 1341a677a039SUlrich Drepper return -EINVAL; 1342a677a039SUlrich Drepper type &= SOCK_TYPE_MASK; 13431da177e4SLinus Torvalds 1344aaca0bdcSUlrich Drepper if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK)) 1345aaca0bdcSUlrich Drepper flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK; 1346aaca0bdcSUlrich Drepper 13471da177e4SLinus Torvalds retval = sock_create(family, type, protocol, &sock); 13481da177e4SLinus Torvalds if (retval < 0) 13491da177e4SLinus Torvalds goto out; 13501da177e4SLinus Torvalds 135177d27200SUlrich Drepper retval = sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK)); 13521da177e4SLinus Torvalds if (retval < 0) 13531da177e4SLinus Torvalds goto out_release; 13541da177e4SLinus Torvalds 13551da177e4SLinus Torvalds out: 13561da177e4SLinus Torvalds /* It may be already another descriptor 8) Not kernel problem. */ 13571da177e4SLinus Torvalds return retval; 13581da177e4SLinus Torvalds 13591da177e4SLinus Torvalds out_release: 13601da177e4SLinus Torvalds sock_release(sock); 13611da177e4SLinus Torvalds return retval; 13621da177e4SLinus Torvalds } 13631da177e4SLinus Torvalds 13641da177e4SLinus Torvalds /* 13651da177e4SLinus Torvalds * Create a pair of connected sockets. 13661da177e4SLinus Torvalds */ 13671da177e4SLinus Torvalds 13683e0fa65fSHeiko Carstens SYSCALL_DEFINE4(socketpair, int, family, int, type, int, protocol, 13693e0fa65fSHeiko Carstens int __user *, usockvec) 13701da177e4SLinus Torvalds { 13711da177e4SLinus Torvalds struct socket *sock1, *sock2; 13721da177e4SLinus Torvalds int fd1, fd2, err; 1373db349509SAl Viro struct file *newfile1, *newfile2; 1374a677a039SUlrich Drepper int flags; 1375a677a039SUlrich Drepper 1376a677a039SUlrich Drepper flags = type & ~SOCK_TYPE_MASK; 137777d27200SUlrich Drepper if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)) 1378a677a039SUlrich Drepper return -EINVAL; 1379a677a039SUlrich Drepper type &= SOCK_TYPE_MASK; 13801da177e4SLinus Torvalds 1381aaca0bdcSUlrich Drepper if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK)) 1382aaca0bdcSUlrich Drepper flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK; 1383aaca0bdcSUlrich Drepper 13841da177e4SLinus Torvalds /* 13851da177e4SLinus Torvalds * Obtain the first socket and check if the underlying protocol 13861da177e4SLinus Torvalds * supports the socketpair call. 13871da177e4SLinus Torvalds */ 13881da177e4SLinus Torvalds 13891da177e4SLinus Torvalds err = sock_create(family, type, protocol, &sock1); 13901da177e4SLinus Torvalds if (err < 0) 13911da177e4SLinus Torvalds goto out; 13921da177e4SLinus Torvalds 13931da177e4SLinus Torvalds err = sock_create(family, type, protocol, &sock2); 13941da177e4SLinus Torvalds if (err < 0) 13951da177e4SLinus Torvalds goto out_release_1; 13961da177e4SLinus Torvalds 13971da177e4SLinus Torvalds err = sock1->ops->socketpair(sock1, sock2); 13981da177e4SLinus Torvalds if (err < 0) 13991da177e4SLinus Torvalds goto out_release_both; 14001da177e4SLinus Torvalds 1401a677a039SUlrich Drepper fd1 = sock_alloc_fd(&newfile1, flags & O_CLOEXEC); 1402bf3c23d1SDavid S. Miller if (unlikely(fd1 < 0)) { 1403bf3c23d1SDavid S. Miller err = fd1; 14041da177e4SLinus Torvalds goto out_release_both; 1405bf3c23d1SDavid S. Miller } 14061da177e4SLinus Torvalds 1407a677a039SUlrich Drepper fd2 = sock_alloc_fd(&newfile2, flags & O_CLOEXEC); 1408db349509SAl Viro if (unlikely(fd2 < 0)) { 1409bf3c23d1SDavid S. Miller err = fd2; 1410db349509SAl Viro put_filp(newfile1); 1411db349509SAl Viro put_unused_fd(fd1); 1412db349509SAl Viro goto out_release_both; 1413db349509SAl Viro } 14141da177e4SLinus Torvalds 141577d27200SUlrich Drepper err = sock_attach_fd(sock1, newfile1, flags & O_NONBLOCK); 1416db349509SAl Viro if (unlikely(err < 0)) { 1417db349509SAl Viro goto out_fd2; 1418db349509SAl Viro } 1419db349509SAl Viro 142077d27200SUlrich Drepper err = sock_attach_fd(sock2, newfile2, flags & O_NONBLOCK); 1421db349509SAl Viro if (unlikely(err < 0)) { 1422db349509SAl Viro fput(newfile1); 1423db349509SAl Viro goto out_fd1; 1424db349509SAl Viro } 1425db349509SAl Viro 1426157cf649SAl Viro audit_fd_pair(fd1, fd2); 1427db349509SAl Viro fd_install(fd1, newfile1); 1428db349509SAl Viro fd_install(fd2, newfile2); 14291da177e4SLinus Torvalds /* fd1 and fd2 may be already another descriptors. 14301da177e4SLinus Torvalds * Not kernel problem. 14311da177e4SLinus Torvalds */ 14321da177e4SLinus Torvalds 14331da177e4SLinus Torvalds err = put_user(fd1, &usockvec[0]); 14341da177e4SLinus Torvalds if (!err) 14351da177e4SLinus Torvalds err = put_user(fd2, &usockvec[1]); 14361da177e4SLinus Torvalds if (!err) 14371da177e4SLinus Torvalds return 0; 14381da177e4SLinus Torvalds 14391da177e4SLinus Torvalds sys_close(fd2); 14401da177e4SLinus Torvalds sys_close(fd1); 14411da177e4SLinus Torvalds return err; 14421da177e4SLinus Torvalds 14431da177e4SLinus Torvalds out_release_both: 14441da177e4SLinus Torvalds sock_release(sock2); 14451da177e4SLinus Torvalds out_release_1: 14461da177e4SLinus Torvalds sock_release(sock1); 14471da177e4SLinus Torvalds out: 14481da177e4SLinus Torvalds return err; 1449db349509SAl Viro 1450db349509SAl Viro out_fd2: 1451db349509SAl Viro put_filp(newfile1); 1452db349509SAl Viro sock_release(sock1); 1453db349509SAl Viro out_fd1: 1454db349509SAl Viro put_filp(newfile2); 1455db349509SAl Viro sock_release(sock2); 1456db349509SAl Viro put_unused_fd(fd1); 1457db349509SAl Viro put_unused_fd(fd2); 1458db349509SAl Viro goto out; 14591da177e4SLinus Torvalds } 14601da177e4SLinus Torvalds 14611da177e4SLinus Torvalds /* 14621da177e4SLinus Torvalds * Bind a name to a socket. Nothing much to do here since it's 14631da177e4SLinus Torvalds * the protocol's responsibility to handle the local address. 14641da177e4SLinus Torvalds * 14651da177e4SLinus Torvalds * We move the socket address to kernel space before we call 14661da177e4SLinus Torvalds * the protocol layer (having also checked the address is ok). 14671da177e4SLinus Torvalds */ 14681da177e4SLinus Torvalds 146920f37034SHeiko Carstens SYSCALL_DEFINE3(bind, int, fd, struct sockaddr __user *, umyaddr, int, addrlen) 14701da177e4SLinus Torvalds { 14711da177e4SLinus Torvalds struct socket *sock; 1472230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 14736cb153caSBenjamin LaHaise int err, fput_needed; 14741da177e4SLinus Torvalds 147589bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 147689bddce5SStephen Hemminger if (sock) { 1477230b1839SYOSHIFUJI Hideaki err = move_addr_to_kernel(umyaddr, addrlen, (struct sockaddr *)&address); 147889bddce5SStephen Hemminger if (err >= 0) { 147989bddce5SStephen Hemminger err = security_socket_bind(sock, 1480230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&address, 148189bddce5SStephen Hemminger addrlen); 14826cb153caSBenjamin LaHaise if (!err) 14836cb153caSBenjamin LaHaise err = sock->ops->bind(sock, 148489bddce5SStephen Hemminger (struct sockaddr *) 1485230b1839SYOSHIFUJI Hideaki &address, addrlen); 14861da177e4SLinus Torvalds } 14876cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 14881da177e4SLinus Torvalds } 14891da177e4SLinus Torvalds return err; 14901da177e4SLinus Torvalds } 14911da177e4SLinus Torvalds 14921da177e4SLinus Torvalds /* 14931da177e4SLinus Torvalds * Perform a listen. Basically, we allow the protocol to do anything 14941da177e4SLinus Torvalds * necessary for a listen, and if that works, we mark the socket as 14951da177e4SLinus Torvalds * ready for listening. 14961da177e4SLinus Torvalds */ 14971da177e4SLinus Torvalds 14983e0fa65fSHeiko Carstens SYSCALL_DEFINE2(listen, int, fd, int, backlog) 14991da177e4SLinus Torvalds { 15001da177e4SLinus Torvalds struct socket *sock; 15016cb153caSBenjamin LaHaise int err, fput_needed; 1502b8e1f9b5SPavel Emelyanov int somaxconn; 15031da177e4SLinus Torvalds 150489bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 150589bddce5SStephen Hemminger if (sock) { 15068efa6e93SPavel Emelyanov somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn; 1507b8e1f9b5SPavel Emelyanov if ((unsigned)backlog > somaxconn) 1508b8e1f9b5SPavel Emelyanov backlog = somaxconn; 15091da177e4SLinus Torvalds 15101da177e4SLinus Torvalds err = security_socket_listen(sock, backlog); 15116cb153caSBenjamin LaHaise if (!err) 15121da177e4SLinus Torvalds err = sock->ops->listen(sock, backlog); 15136cb153caSBenjamin LaHaise 15146cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 15151da177e4SLinus Torvalds } 15161da177e4SLinus Torvalds return err; 15171da177e4SLinus Torvalds } 15181da177e4SLinus Torvalds 15191da177e4SLinus Torvalds /* 15201da177e4SLinus Torvalds * For accept, we attempt to create a new socket, set up the link 15211da177e4SLinus Torvalds * with the client, wake up the client, then return the new 15221da177e4SLinus Torvalds * connected fd. We collect the address of the connector in kernel 15231da177e4SLinus Torvalds * space and move it to user at the very end. This is unclean because 15241da177e4SLinus Torvalds * we open the socket then return an error. 15251da177e4SLinus Torvalds * 15261da177e4SLinus Torvalds * 1003.1g adds the ability to recvmsg() to query connection pending 15271da177e4SLinus Torvalds * status to recvmsg. We need to add that support in a way thats 15281da177e4SLinus Torvalds * clean when we restucture accept also. 15291da177e4SLinus Torvalds */ 15301da177e4SLinus Torvalds 153120f37034SHeiko Carstens SYSCALL_DEFINE4(accept4, int, fd, struct sockaddr __user *, upeer_sockaddr, 153220f37034SHeiko Carstens int __user *, upeer_addrlen, int, flags) 15331da177e4SLinus Torvalds { 15341da177e4SLinus Torvalds struct socket *sock, *newsock; 153539d8c1b6SDavid S. Miller struct file *newfile; 15366cb153caSBenjamin LaHaise int err, len, newfd, fput_needed; 1537230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 15381da177e4SLinus Torvalds 153977d27200SUlrich Drepper if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK)) 1540aaca0bdcSUlrich Drepper return -EINVAL; 1541aaca0bdcSUlrich Drepper 1542aaca0bdcSUlrich Drepper if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK)) 1543aaca0bdcSUlrich Drepper flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK; 1544aaca0bdcSUlrich Drepper 15456cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 15461da177e4SLinus Torvalds if (!sock) 15471da177e4SLinus Torvalds goto out; 15481da177e4SLinus Torvalds 15491da177e4SLinus Torvalds err = -ENFILE; 15501da177e4SLinus Torvalds if (!(newsock = sock_alloc())) 15511da177e4SLinus Torvalds goto out_put; 15521da177e4SLinus Torvalds 15531da177e4SLinus Torvalds newsock->type = sock->type; 15541da177e4SLinus Torvalds newsock->ops = sock->ops; 15551da177e4SLinus Torvalds 15561da177e4SLinus Torvalds /* 15571da177e4SLinus Torvalds * We don't need try_module_get here, as the listening socket (sock) 15581da177e4SLinus Torvalds * has the protocol module (sock->ops->owner) held. 15591da177e4SLinus Torvalds */ 15601da177e4SLinus Torvalds __module_get(newsock->ops->owner); 15611da177e4SLinus Torvalds 1562aaca0bdcSUlrich Drepper newfd = sock_alloc_fd(&newfile, flags & O_CLOEXEC); 156339d8c1b6SDavid S. Miller if (unlikely(newfd < 0)) { 156439d8c1b6SDavid S. Miller err = newfd; 15659a1875e6SDavid S. Miller sock_release(newsock); 15669a1875e6SDavid S. Miller goto out_put; 156739d8c1b6SDavid S. Miller } 156839d8c1b6SDavid S. Miller 156977d27200SUlrich Drepper err = sock_attach_fd(newsock, newfile, flags & O_NONBLOCK); 157039d8c1b6SDavid S. Miller if (err < 0) 157179f4f642SAlexey Dobriyan goto out_fd_simple; 157239d8c1b6SDavid S. Miller 1573a79af59eSFrank Filz err = security_socket_accept(sock, newsock); 1574a79af59eSFrank Filz if (err) 157539d8c1b6SDavid S. Miller goto out_fd; 1576a79af59eSFrank Filz 15771da177e4SLinus Torvalds err = sock->ops->accept(sock, newsock, sock->file->f_flags); 15781da177e4SLinus Torvalds if (err < 0) 157939d8c1b6SDavid S. Miller goto out_fd; 15801da177e4SLinus Torvalds 15811da177e4SLinus Torvalds if (upeer_sockaddr) { 1582230b1839SYOSHIFUJI Hideaki if (newsock->ops->getname(newsock, (struct sockaddr *)&address, 158389bddce5SStephen Hemminger &len, 2) < 0) { 15841da177e4SLinus Torvalds err = -ECONNABORTED; 158539d8c1b6SDavid S. Miller goto out_fd; 15861da177e4SLinus Torvalds } 1587230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&address, 1588230b1839SYOSHIFUJI Hideaki len, upeer_sockaddr, upeer_addrlen); 15891da177e4SLinus Torvalds if (err < 0) 159039d8c1b6SDavid S. Miller goto out_fd; 15911da177e4SLinus Torvalds } 15921da177e4SLinus Torvalds 15931da177e4SLinus Torvalds /* File flags are not inherited via accept() unlike another OSes. */ 15941da177e4SLinus Torvalds 159539d8c1b6SDavid S. Miller fd_install(newfd, newfile); 159639d8c1b6SDavid S. Miller err = newfd; 15971da177e4SLinus Torvalds 15981da177e4SLinus Torvalds out_put: 15996cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 16001da177e4SLinus Torvalds out: 16011da177e4SLinus Torvalds return err; 160279f4f642SAlexey Dobriyan out_fd_simple: 160379f4f642SAlexey Dobriyan sock_release(newsock); 160479f4f642SAlexey Dobriyan put_filp(newfile); 160579f4f642SAlexey Dobriyan put_unused_fd(newfd); 160679f4f642SAlexey Dobriyan goto out_put; 160739d8c1b6SDavid S. Miller out_fd: 16089606a216SDavid S. Miller fput(newfile); 160939d8c1b6SDavid S. Miller put_unused_fd(newfd); 16101da177e4SLinus Torvalds goto out_put; 16111da177e4SLinus Torvalds } 16121da177e4SLinus Torvalds 161320f37034SHeiko Carstens SYSCALL_DEFINE3(accept, int, fd, struct sockaddr __user *, upeer_sockaddr, 161420f37034SHeiko Carstens int __user *, upeer_addrlen) 1615aaca0bdcSUlrich Drepper { 1616de11defeSUlrich Drepper return sys_accept4(fd, upeer_sockaddr, upeer_addrlen, 0); 1617aaca0bdcSUlrich Drepper } 1618aaca0bdcSUlrich Drepper 16191da177e4SLinus Torvalds /* 16201da177e4SLinus Torvalds * Attempt to connect to a socket with the server address. The address 16211da177e4SLinus Torvalds * is in user space so we verify it is OK and move it to kernel space. 16221da177e4SLinus Torvalds * 16231da177e4SLinus Torvalds * For 1003.1g we need to add clean support for a bind to AF_UNSPEC to 16241da177e4SLinus Torvalds * break bindings 16251da177e4SLinus Torvalds * 16261da177e4SLinus Torvalds * NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and 16271da177e4SLinus Torvalds * other SEQPACKET protocols that take time to connect() as it doesn't 16281da177e4SLinus Torvalds * include the -EINPROGRESS status for such sockets. 16291da177e4SLinus Torvalds */ 16301da177e4SLinus Torvalds 163120f37034SHeiko Carstens SYSCALL_DEFINE3(connect, int, fd, struct sockaddr __user *, uservaddr, 163220f37034SHeiko Carstens int, addrlen) 16331da177e4SLinus Torvalds { 16341da177e4SLinus Torvalds struct socket *sock; 1635230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 16366cb153caSBenjamin LaHaise int err, fput_needed; 16371da177e4SLinus Torvalds 16386cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 16391da177e4SLinus Torvalds if (!sock) 16401da177e4SLinus Torvalds goto out; 1641230b1839SYOSHIFUJI Hideaki err = move_addr_to_kernel(uservaddr, addrlen, (struct sockaddr *)&address); 16421da177e4SLinus Torvalds if (err < 0) 16431da177e4SLinus Torvalds goto out_put; 16441da177e4SLinus Torvalds 164589bddce5SStephen Hemminger err = 1646230b1839SYOSHIFUJI Hideaki security_socket_connect(sock, (struct sockaddr *)&address, addrlen); 16471da177e4SLinus Torvalds if (err) 16481da177e4SLinus Torvalds goto out_put; 16491da177e4SLinus Torvalds 1650230b1839SYOSHIFUJI Hideaki err = sock->ops->connect(sock, (struct sockaddr *)&address, addrlen, 16511da177e4SLinus Torvalds sock->file->f_flags); 16521da177e4SLinus Torvalds out_put: 16536cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 16541da177e4SLinus Torvalds out: 16551da177e4SLinus Torvalds return err; 16561da177e4SLinus Torvalds } 16571da177e4SLinus Torvalds 16581da177e4SLinus Torvalds /* 16591da177e4SLinus Torvalds * Get the local address ('name') of a socket object. Move the obtained 16601da177e4SLinus Torvalds * name to user space. 16611da177e4SLinus Torvalds */ 16621da177e4SLinus Torvalds 166320f37034SHeiko Carstens SYSCALL_DEFINE3(getsockname, int, fd, struct sockaddr __user *, usockaddr, 166420f37034SHeiko Carstens int __user *, usockaddr_len) 16651da177e4SLinus Torvalds { 16661da177e4SLinus Torvalds struct socket *sock; 1667230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 16686cb153caSBenjamin LaHaise int len, err, fput_needed; 16691da177e4SLinus Torvalds 16706cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 16711da177e4SLinus Torvalds if (!sock) 16721da177e4SLinus Torvalds goto out; 16731da177e4SLinus Torvalds 16741da177e4SLinus Torvalds err = security_socket_getsockname(sock); 16751da177e4SLinus Torvalds if (err) 16761da177e4SLinus Torvalds goto out_put; 16771da177e4SLinus Torvalds 1678230b1839SYOSHIFUJI Hideaki err = sock->ops->getname(sock, (struct sockaddr *)&address, &len, 0); 16791da177e4SLinus Torvalds if (err) 16801da177e4SLinus Torvalds goto out_put; 1681230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr, usockaddr_len); 16821da177e4SLinus Torvalds 16831da177e4SLinus Torvalds out_put: 16846cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 16851da177e4SLinus Torvalds out: 16861da177e4SLinus Torvalds return err; 16871da177e4SLinus Torvalds } 16881da177e4SLinus Torvalds 16891da177e4SLinus Torvalds /* 16901da177e4SLinus Torvalds * Get the remote address ('name') of a socket object. Move the obtained 16911da177e4SLinus Torvalds * name to user space. 16921da177e4SLinus Torvalds */ 16931da177e4SLinus Torvalds 169420f37034SHeiko Carstens SYSCALL_DEFINE3(getpeername, int, fd, struct sockaddr __user *, usockaddr, 169520f37034SHeiko Carstens int __user *, usockaddr_len) 16961da177e4SLinus Torvalds { 16971da177e4SLinus Torvalds struct socket *sock; 1698230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 16996cb153caSBenjamin LaHaise int len, err, fput_needed; 17001da177e4SLinus Torvalds 170189bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 170289bddce5SStephen Hemminger if (sock != NULL) { 17031da177e4SLinus Torvalds err = security_socket_getpeername(sock); 17041da177e4SLinus Torvalds if (err) { 17056cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 17061da177e4SLinus Torvalds return err; 17071da177e4SLinus Torvalds } 17081da177e4SLinus Torvalds 170989bddce5SStephen Hemminger err = 1710230b1839SYOSHIFUJI Hideaki sock->ops->getname(sock, (struct sockaddr *)&address, &len, 171189bddce5SStephen Hemminger 1); 17121da177e4SLinus Torvalds if (!err) 1713230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr, 171489bddce5SStephen Hemminger usockaddr_len); 17156cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 17161da177e4SLinus Torvalds } 17171da177e4SLinus Torvalds return err; 17181da177e4SLinus Torvalds } 17191da177e4SLinus Torvalds 17201da177e4SLinus Torvalds /* 17211da177e4SLinus Torvalds * Send a datagram to a given address. We move the address into kernel 17221da177e4SLinus Torvalds * space and check the user space data area is readable before invoking 17231da177e4SLinus Torvalds * the protocol. 17241da177e4SLinus Torvalds */ 17251da177e4SLinus Torvalds 17263e0fa65fSHeiko Carstens SYSCALL_DEFINE6(sendto, int, fd, void __user *, buff, size_t, len, 17273e0fa65fSHeiko Carstens unsigned, flags, struct sockaddr __user *, addr, 17283e0fa65fSHeiko Carstens int, addr_len) 17291da177e4SLinus Torvalds { 17301da177e4SLinus Torvalds struct socket *sock; 1731230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 17321da177e4SLinus Torvalds int err; 17331da177e4SLinus Torvalds struct msghdr msg; 17341da177e4SLinus Torvalds struct iovec iov; 17356cb153caSBenjamin LaHaise int fput_needed; 17361da177e4SLinus Torvalds 1737de0fa95cSPavel Emelyanov sock = sockfd_lookup_light(fd, &err, &fput_needed); 1738de0fa95cSPavel Emelyanov if (!sock) 17394387ff75SDavid S. Miller goto out; 17406cb153caSBenjamin LaHaise 17411da177e4SLinus Torvalds iov.iov_base = buff; 17421da177e4SLinus Torvalds iov.iov_len = len; 17431da177e4SLinus Torvalds msg.msg_name = NULL; 17441da177e4SLinus Torvalds msg.msg_iov = &iov; 17451da177e4SLinus Torvalds msg.msg_iovlen = 1; 17461da177e4SLinus Torvalds msg.msg_control = NULL; 17471da177e4SLinus Torvalds msg.msg_controllen = 0; 17481da177e4SLinus Torvalds msg.msg_namelen = 0; 17496cb153caSBenjamin LaHaise if (addr) { 1750230b1839SYOSHIFUJI Hideaki err = move_addr_to_kernel(addr, addr_len, (struct sockaddr *)&address); 17511da177e4SLinus Torvalds if (err < 0) 17521da177e4SLinus Torvalds goto out_put; 1753230b1839SYOSHIFUJI Hideaki msg.msg_name = (struct sockaddr *)&address; 17541da177e4SLinus Torvalds msg.msg_namelen = addr_len; 17551da177e4SLinus Torvalds } 17561da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 17571da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 17581da177e4SLinus Torvalds msg.msg_flags = flags; 17591da177e4SLinus Torvalds err = sock_sendmsg(sock, &msg, len); 17601da177e4SLinus Torvalds 17611da177e4SLinus Torvalds out_put: 1762de0fa95cSPavel Emelyanov fput_light(sock->file, fput_needed); 17634387ff75SDavid S. Miller out: 17641da177e4SLinus Torvalds return err; 17651da177e4SLinus Torvalds } 17661da177e4SLinus Torvalds 17671da177e4SLinus Torvalds /* 17681da177e4SLinus Torvalds * Send a datagram down a socket. 17691da177e4SLinus Torvalds */ 17701da177e4SLinus Torvalds 17713e0fa65fSHeiko Carstens SYSCALL_DEFINE4(send, int, fd, void __user *, buff, size_t, len, 17723e0fa65fSHeiko Carstens unsigned, flags) 17731da177e4SLinus Torvalds { 17741da177e4SLinus Torvalds return sys_sendto(fd, buff, len, flags, NULL, 0); 17751da177e4SLinus Torvalds } 17761da177e4SLinus Torvalds 17771da177e4SLinus Torvalds /* 17781da177e4SLinus Torvalds * Receive a frame from the socket and optionally record the address of the 17791da177e4SLinus Torvalds * sender. We verify the buffers are writable and if needed move the 17801da177e4SLinus Torvalds * sender address from kernel to user space. 17811da177e4SLinus Torvalds */ 17821da177e4SLinus Torvalds 17833e0fa65fSHeiko Carstens SYSCALL_DEFINE6(recvfrom, int, fd, void __user *, ubuf, size_t, size, 17843e0fa65fSHeiko Carstens unsigned, flags, struct sockaddr __user *, addr, 17853e0fa65fSHeiko Carstens int __user *, addr_len) 17861da177e4SLinus Torvalds { 17871da177e4SLinus Torvalds struct socket *sock; 17881da177e4SLinus Torvalds struct iovec iov; 17891da177e4SLinus Torvalds struct msghdr msg; 1790230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 17911da177e4SLinus Torvalds int err, err2; 17926cb153caSBenjamin LaHaise int fput_needed; 17931da177e4SLinus Torvalds 1794de0fa95cSPavel Emelyanov sock = sockfd_lookup_light(fd, &err, &fput_needed); 17951da177e4SLinus Torvalds if (!sock) 1796de0fa95cSPavel Emelyanov goto out; 17971da177e4SLinus Torvalds 17981da177e4SLinus Torvalds msg.msg_control = NULL; 17991da177e4SLinus Torvalds msg.msg_controllen = 0; 18001da177e4SLinus Torvalds msg.msg_iovlen = 1; 18011da177e4SLinus Torvalds msg.msg_iov = &iov; 18021da177e4SLinus Torvalds iov.iov_len = size; 18031da177e4SLinus Torvalds iov.iov_base = ubuf; 1804230b1839SYOSHIFUJI Hideaki msg.msg_name = (struct sockaddr *)&address; 1805230b1839SYOSHIFUJI Hideaki msg.msg_namelen = sizeof(address); 18061da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 18071da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 18081da177e4SLinus Torvalds err = sock_recvmsg(sock, &msg, size, flags); 18091da177e4SLinus Torvalds 181089bddce5SStephen Hemminger if (err >= 0 && addr != NULL) { 1811230b1839SYOSHIFUJI Hideaki err2 = move_addr_to_user((struct sockaddr *)&address, 1812230b1839SYOSHIFUJI Hideaki msg.msg_namelen, addr, addr_len); 18131da177e4SLinus Torvalds if (err2 < 0) 18141da177e4SLinus Torvalds err = err2; 18151da177e4SLinus Torvalds } 1816de0fa95cSPavel Emelyanov 1817de0fa95cSPavel Emelyanov fput_light(sock->file, fput_needed); 18184387ff75SDavid S. Miller out: 18191da177e4SLinus Torvalds return err; 18201da177e4SLinus Torvalds } 18211da177e4SLinus Torvalds 18221da177e4SLinus Torvalds /* 18231da177e4SLinus Torvalds * Receive a datagram from a socket. 18241da177e4SLinus Torvalds */ 18251da177e4SLinus Torvalds 182689bddce5SStephen Hemminger asmlinkage long sys_recv(int fd, void __user *ubuf, size_t size, 182789bddce5SStephen Hemminger unsigned flags) 18281da177e4SLinus Torvalds { 18291da177e4SLinus Torvalds return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL); 18301da177e4SLinus Torvalds } 18311da177e4SLinus Torvalds 18321da177e4SLinus Torvalds /* 18331da177e4SLinus Torvalds * Set a socket option. Because we don't know the option lengths we have 18341da177e4SLinus Torvalds * to pass the user mode parameter for the protocols to sort out. 18351da177e4SLinus Torvalds */ 18361da177e4SLinus Torvalds 183720f37034SHeiko Carstens SYSCALL_DEFINE5(setsockopt, int, fd, int, level, int, optname, 183820f37034SHeiko Carstens char __user *, optval, int, optlen) 18391da177e4SLinus Torvalds { 18406cb153caSBenjamin LaHaise int err, fput_needed; 18411da177e4SLinus Torvalds struct socket *sock; 18421da177e4SLinus Torvalds 18431da177e4SLinus Torvalds if (optlen < 0) 18441da177e4SLinus Torvalds return -EINVAL; 18451da177e4SLinus Torvalds 184689bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 184789bddce5SStephen Hemminger if (sock != NULL) { 18481da177e4SLinus Torvalds err = security_socket_setsockopt(sock, level, optname); 18496cb153caSBenjamin LaHaise if (err) 18506cb153caSBenjamin LaHaise goto out_put; 18511da177e4SLinus Torvalds 18521da177e4SLinus Torvalds if (level == SOL_SOCKET) 185389bddce5SStephen Hemminger err = 185489bddce5SStephen Hemminger sock_setsockopt(sock, level, optname, optval, 185589bddce5SStephen Hemminger optlen); 18561da177e4SLinus Torvalds else 185789bddce5SStephen Hemminger err = 185889bddce5SStephen Hemminger sock->ops->setsockopt(sock, level, optname, optval, 185989bddce5SStephen Hemminger optlen); 18606cb153caSBenjamin LaHaise out_put: 18616cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 18621da177e4SLinus Torvalds } 18631da177e4SLinus Torvalds return err; 18641da177e4SLinus Torvalds } 18651da177e4SLinus Torvalds 18661da177e4SLinus Torvalds /* 18671da177e4SLinus Torvalds * Get a socket option. Because we don't know the option lengths we have 18681da177e4SLinus Torvalds * to pass a user mode parameter for the protocols to sort out. 18691da177e4SLinus Torvalds */ 18701da177e4SLinus Torvalds 187120f37034SHeiko Carstens SYSCALL_DEFINE5(getsockopt, int, fd, int, level, int, optname, 187220f37034SHeiko Carstens char __user *, optval, int __user *, optlen) 18731da177e4SLinus Torvalds { 18746cb153caSBenjamin LaHaise int err, fput_needed; 18751da177e4SLinus Torvalds struct socket *sock; 18761da177e4SLinus Torvalds 187789bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 187889bddce5SStephen Hemminger if (sock != NULL) { 18796cb153caSBenjamin LaHaise err = security_socket_getsockopt(sock, level, optname); 18806cb153caSBenjamin LaHaise if (err) 18816cb153caSBenjamin LaHaise goto out_put; 18821da177e4SLinus Torvalds 18831da177e4SLinus Torvalds if (level == SOL_SOCKET) 188489bddce5SStephen Hemminger err = 188589bddce5SStephen Hemminger sock_getsockopt(sock, level, optname, optval, 188689bddce5SStephen Hemminger optlen); 18871da177e4SLinus Torvalds else 188889bddce5SStephen Hemminger err = 188989bddce5SStephen Hemminger sock->ops->getsockopt(sock, level, optname, optval, 189089bddce5SStephen Hemminger optlen); 18916cb153caSBenjamin LaHaise out_put: 18926cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 18931da177e4SLinus Torvalds } 18941da177e4SLinus Torvalds return err; 18951da177e4SLinus Torvalds } 18961da177e4SLinus Torvalds 18971da177e4SLinus Torvalds /* 18981da177e4SLinus Torvalds * Shutdown a socket. 18991da177e4SLinus Torvalds */ 19001da177e4SLinus Torvalds 1901754fe8d2SHeiko Carstens SYSCALL_DEFINE2(shutdown, int, fd, int, how) 19021da177e4SLinus Torvalds { 19036cb153caSBenjamin LaHaise int err, fput_needed; 19041da177e4SLinus Torvalds struct socket *sock; 19051da177e4SLinus Torvalds 190689bddce5SStephen Hemminger sock = sockfd_lookup_light(fd, &err, &fput_needed); 190789bddce5SStephen Hemminger if (sock != NULL) { 19081da177e4SLinus Torvalds err = security_socket_shutdown(sock, how); 19096cb153caSBenjamin LaHaise if (!err) 19101da177e4SLinus Torvalds err = sock->ops->shutdown(sock, how); 19116cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 19121da177e4SLinus Torvalds } 19131da177e4SLinus Torvalds return err; 19141da177e4SLinus Torvalds } 19151da177e4SLinus Torvalds 19161da177e4SLinus Torvalds /* A couple of helpful macros for getting the address of the 32/64 bit 19171da177e4SLinus Torvalds * fields which are the same type (int / unsigned) on our platforms. 19181da177e4SLinus Torvalds */ 19191da177e4SLinus Torvalds #define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member) 19201da177e4SLinus Torvalds #define COMPAT_NAMELEN(msg) COMPAT_MSG(msg, msg_namelen) 19211da177e4SLinus Torvalds #define COMPAT_FLAGS(msg) COMPAT_MSG(msg, msg_flags) 19221da177e4SLinus Torvalds 19231da177e4SLinus Torvalds /* 19241da177e4SLinus Torvalds * BSD sendmsg interface 19251da177e4SLinus Torvalds */ 19261da177e4SLinus Torvalds 19273e0fa65fSHeiko Carstens SYSCALL_DEFINE3(sendmsg, int, fd, struct msghdr __user *, msg, unsigned, flags) 19281da177e4SLinus Torvalds { 192989bddce5SStephen Hemminger struct compat_msghdr __user *msg_compat = 193089bddce5SStephen Hemminger (struct compat_msghdr __user *)msg; 19311da177e4SLinus Torvalds struct socket *sock; 1932230b1839SYOSHIFUJI Hideaki struct sockaddr_storage address; 19331da177e4SLinus Torvalds struct iovec iovstack[UIO_FASTIOV], *iov = iovstack; 1934b9d717a7SAlex Williamson unsigned char ctl[sizeof(struct cmsghdr) + 20] 1935b9d717a7SAlex Williamson __attribute__ ((aligned(sizeof(__kernel_size_t)))); 1936b9d717a7SAlex Williamson /* 20 is size of ipv6_pktinfo */ 19371da177e4SLinus Torvalds unsigned char *ctl_buf = ctl; 19381da177e4SLinus Torvalds struct msghdr msg_sys; 19391da177e4SLinus Torvalds int err, ctl_len, iov_size, total_len; 19406cb153caSBenjamin LaHaise int fput_needed; 19411da177e4SLinus Torvalds 19421da177e4SLinus Torvalds err = -EFAULT; 19431da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 19441da177e4SLinus Torvalds if (get_compat_msghdr(&msg_sys, msg_compat)) 19451da177e4SLinus Torvalds return -EFAULT; 194689bddce5SStephen Hemminger } 194789bddce5SStephen Hemminger else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr))) 19481da177e4SLinus Torvalds return -EFAULT; 19491da177e4SLinus Torvalds 19506cb153caSBenjamin LaHaise sock = sockfd_lookup_light(fd, &err, &fput_needed); 19511da177e4SLinus Torvalds if (!sock) 19521da177e4SLinus Torvalds goto out; 19531da177e4SLinus Torvalds 19541da177e4SLinus Torvalds /* do not move before msg_sys is valid */ 19551da177e4SLinus Torvalds err = -EMSGSIZE; 19561da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_MAXIOV) 19571da177e4SLinus Torvalds goto out_put; 19581da177e4SLinus Torvalds 19591da177e4SLinus Torvalds /* Check whether to allocate the iovec area */ 19601da177e4SLinus Torvalds err = -ENOMEM; 19611da177e4SLinus Torvalds iov_size = msg_sys.msg_iovlen * sizeof(struct iovec); 19621da177e4SLinus Torvalds if (msg_sys.msg_iovlen > UIO_FASTIOV) { 19631da177e4SLinus Torvalds iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL); 19641da177e4SLinus Torvalds if (!iov) 19651da177e4SLinus Torvalds goto out_put; 19661da177e4SLinus Torvalds } 19671da177e4SLinus Torvalds 19681da177e4SLinus Torvalds /* This will also move the address data into kernel space */ 19691da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 1970230b1839SYOSHIFUJI Hideaki err = verify_compat_iovec(&msg_sys, iov, 1971230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&address, 1972230b1839SYOSHIFUJI Hideaki VERIFY_READ); 19731da177e4SLinus Torvalds } else 1974230b1839SYOSHIFUJI Hideaki err = verify_iovec(&msg_sys, iov, 1975230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&address, 1976230b1839SYOSHIFUJI Hideaki VERIFY_READ); 19771da177e4SLinus Torvalds if (err < 0) 19781da177e4SLinus Torvalds goto out_freeiov; 19791da177e4SLinus Torvalds total_len = err; 19801da177e4SLinus Torvalds 19811da177e4SLinus Torvalds err = -ENOBUFS; 19821da177e4SLinus Torvalds 19831da177e4SLinus Torvalds if (msg_sys.msg_controllen > INT_MAX) 19841da177e4SLinus Torvalds goto out_freeiov; 19851da177e4SLinus Torvalds ctl_len = msg_sys.msg_controllen; 19861da177e4SLinus Torvalds if ((MSG_CMSG_COMPAT & flags) && ctl_len) { 198789bddce5SStephen Hemminger err = 198889bddce5SStephen Hemminger cmsghdr_from_user_compat_to_kern(&msg_sys, sock->sk, ctl, 198989bddce5SStephen Hemminger sizeof(ctl)); 19901da177e4SLinus Torvalds if (err) 19911da177e4SLinus Torvalds goto out_freeiov; 19921da177e4SLinus Torvalds ctl_buf = msg_sys.msg_control; 19938920e8f9SAl Viro ctl_len = msg_sys.msg_controllen; 19941da177e4SLinus Torvalds } else if (ctl_len) { 199589bddce5SStephen Hemminger if (ctl_len > sizeof(ctl)) { 19961da177e4SLinus Torvalds ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL); 19971da177e4SLinus Torvalds if (ctl_buf == NULL) 19981da177e4SLinus Torvalds goto out_freeiov; 19991da177e4SLinus Torvalds } 20001da177e4SLinus Torvalds err = -EFAULT; 20011da177e4SLinus Torvalds /* 20021da177e4SLinus Torvalds * Careful! Before this, msg_sys.msg_control contains a user pointer. 20031da177e4SLinus Torvalds * Afterwards, it will be a kernel pointer. Thus the compiler-assisted 20041da177e4SLinus Torvalds * checking falls down on this. 20051da177e4SLinus Torvalds */ 200689bddce5SStephen Hemminger if (copy_from_user(ctl_buf, (void __user *)msg_sys.msg_control, 200789bddce5SStephen Hemminger ctl_len)) 20081da177e4SLinus Torvalds goto out_freectl; 20091da177e4SLinus Torvalds msg_sys.msg_control = ctl_buf; 20101da177e4SLinus Torvalds } 20111da177e4SLinus Torvalds msg_sys.msg_flags = flags; 20121da177e4SLinus Torvalds 20131da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 20141da177e4SLinus Torvalds msg_sys.msg_flags |= MSG_DONTWAIT; 20151da177e4SLinus Torvalds err = sock_sendmsg(sock, &msg_sys, total_len); 20161da177e4SLinus Torvalds 20171da177e4SLinus Torvalds out_freectl: 20181da177e4SLinus Torvalds if (ctl_buf != ctl) 20191da177e4SLinus Torvalds sock_kfree_s(sock->sk, ctl_buf, ctl_len); 20201da177e4SLinus Torvalds out_freeiov: 20211da177e4SLinus Torvalds if (iov != iovstack) 20221da177e4SLinus Torvalds sock_kfree_s(sock->sk, iov, iov_size); 20231da177e4SLinus Torvalds out_put: 20246cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 20251da177e4SLinus Torvalds out: 20261da177e4SLinus Torvalds return err; 20271da177e4SLinus Torvalds } 20281da177e4SLinus Torvalds 2029a2e27255SArnaldo Carvalho de Melo static int __sys_recvmsg(struct socket *sock, struct msghdr __user *msg, 2030a2e27255SArnaldo Carvalho de Melo struct msghdr *msg_sys, unsigned flags, int nosec) 20311da177e4SLinus Torvalds { 203289bddce5SStephen Hemminger struct compat_msghdr __user *msg_compat = 203389bddce5SStephen Hemminger (struct compat_msghdr __user *)msg; 20341da177e4SLinus Torvalds struct iovec iovstack[UIO_FASTIOV]; 20351da177e4SLinus Torvalds struct iovec *iov = iovstack; 20361da177e4SLinus Torvalds unsigned long cmsg_ptr; 20371da177e4SLinus Torvalds int err, iov_size, total_len, len; 20381da177e4SLinus Torvalds 20391da177e4SLinus Torvalds /* kernel mode address */ 2040230b1839SYOSHIFUJI Hideaki struct sockaddr_storage addr; 20411da177e4SLinus Torvalds 20421da177e4SLinus Torvalds /* user mode address pointers */ 20431da177e4SLinus Torvalds struct sockaddr __user *uaddr; 20441da177e4SLinus Torvalds int __user *uaddr_len; 20451da177e4SLinus Torvalds 20461da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 2047a2e27255SArnaldo Carvalho de Melo if (get_compat_msghdr(msg_sys, msg_compat)) 20481da177e4SLinus Torvalds return -EFAULT; 204989bddce5SStephen Hemminger } 2050a2e27255SArnaldo Carvalho de Melo else if (copy_from_user(msg_sys, msg, sizeof(struct msghdr))) 20511da177e4SLinus Torvalds return -EFAULT; 20521da177e4SLinus Torvalds 20531da177e4SLinus Torvalds err = -EMSGSIZE; 2054a2e27255SArnaldo Carvalho de Melo if (msg_sys->msg_iovlen > UIO_MAXIOV) 2055a2e27255SArnaldo Carvalho de Melo goto out; 20561da177e4SLinus Torvalds 20571da177e4SLinus Torvalds /* Check whether to allocate the iovec area */ 20581da177e4SLinus Torvalds err = -ENOMEM; 2059a2e27255SArnaldo Carvalho de Melo iov_size = msg_sys->msg_iovlen * sizeof(struct iovec); 2060a2e27255SArnaldo Carvalho de Melo if (msg_sys->msg_iovlen > UIO_FASTIOV) { 20611da177e4SLinus Torvalds iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL); 20621da177e4SLinus Torvalds if (!iov) 2063a2e27255SArnaldo Carvalho de Melo goto out; 20641da177e4SLinus Torvalds } 20651da177e4SLinus Torvalds 20661da177e4SLinus Torvalds /* 20671da177e4SLinus Torvalds * Save the user-mode address (verify_iovec will change the 20681da177e4SLinus Torvalds * kernel msghdr to use the kernel address space) 20691da177e4SLinus Torvalds */ 20701da177e4SLinus Torvalds 2071a2e27255SArnaldo Carvalho de Melo uaddr = (__force void __user *)msg_sys->msg_name; 20721da177e4SLinus Torvalds uaddr_len = COMPAT_NAMELEN(msg); 20731da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) { 2074a2e27255SArnaldo Carvalho de Melo err = verify_compat_iovec(msg_sys, iov, 2075230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&addr, 2076230b1839SYOSHIFUJI Hideaki VERIFY_WRITE); 20771da177e4SLinus Torvalds } else 2078a2e27255SArnaldo Carvalho de Melo err = verify_iovec(msg_sys, iov, 2079230b1839SYOSHIFUJI Hideaki (struct sockaddr *)&addr, 2080230b1839SYOSHIFUJI Hideaki VERIFY_WRITE); 20811da177e4SLinus Torvalds if (err < 0) 20821da177e4SLinus Torvalds goto out_freeiov; 20831da177e4SLinus Torvalds total_len = err; 20841da177e4SLinus Torvalds 2085a2e27255SArnaldo Carvalho de Melo cmsg_ptr = (unsigned long)msg_sys->msg_control; 2086a2e27255SArnaldo Carvalho de Melo msg_sys->msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT); 20871da177e4SLinus Torvalds 20881da177e4SLinus Torvalds if (sock->file->f_flags & O_NONBLOCK) 20891da177e4SLinus Torvalds flags |= MSG_DONTWAIT; 2090a2e27255SArnaldo Carvalho de Melo err = (nosec ? sock_recvmsg_nosec : sock_recvmsg)(sock, msg_sys, 2091a2e27255SArnaldo Carvalho de Melo total_len, flags); 20921da177e4SLinus Torvalds if (err < 0) 20931da177e4SLinus Torvalds goto out_freeiov; 20941da177e4SLinus Torvalds len = err; 20951da177e4SLinus Torvalds 20961da177e4SLinus Torvalds if (uaddr != NULL) { 2097230b1839SYOSHIFUJI Hideaki err = move_addr_to_user((struct sockaddr *)&addr, 2098a2e27255SArnaldo Carvalho de Melo msg_sys->msg_namelen, uaddr, 209989bddce5SStephen Hemminger uaddr_len); 21001da177e4SLinus Torvalds if (err < 0) 21011da177e4SLinus Torvalds goto out_freeiov; 21021da177e4SLinus Torvalds } 2103a2e27255SArnaldo Carvalho de Melo err = __put_user((msg_sys->msg_flags & ~MSG_CMSG_COMPAT), 210437f7f421SDavid S. Miller COMPAT_FLAGS(msg)); 21051da177e4SLinus Torvalds if (err) 21061da177e4SLinus Torvalds goto out_freeiov; 21071da177e4SLinus Torvalds if (MSG_CMSG_COMPAT & flags) 2108a2e27255SArnaldo Carvalho de Melo err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr, 21091da177e4SLinus Torvalds &msg_compat->msg_controllen); 21101da177e4SLinus Torvalds else 2111a2e27255SArnaldo Carvalho de Melo err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr, 21121da177e4SLinus Torvalds &msg->msg_controllen); 21131da177e4SLinus Torvalds if (err) 21141da177e4SLinus Torvalds goto out_freeiov; 21151da177e4SLinus Torvalds err = len; 21161da177e4SLinus Torvalds 21171da177e4SLinus Torvalds out_freeiov: 21181da177e4SLinus Torvalds if (iov != iovstack) 21191da177e4SLinus Torvalds sock_kfree_s(sock->sk, iov, iov_size); 2120a2e27255SArnaldo Carvalho de Melo out: 2121a2e27255SArnaldo Carvalho de Melo return err; 2122a2e27255SArnaldo Carvalho de Melo } 2123a2e27255SArnaldo Carvalho de Melo 2124a2e27255SArnaldo Carvalho de Melo /* 2125a2e27255SArnaldo Carvalho de Melo * BSD recvmsg interface 2126a2e27255SArnaldo Carvalho de Melo */ 2127a2e27255SArnaldo Carvalho de Melo 2128a2e27255SArnaldo Carvalho de Melo SYSCALL_DEFINE3(recvmsg, int, fd, struct msghdr __user *, msg, 2129a2e27255SArnaldo Carvalho de Melo unsigned int, flags) 2130a2e27255SArnaldo Carvalho de Melo { 2131a2e27255SArnaldo Carvalho de Melo int fput_needed, err; 2132a2e27255SArnaldo Carvalho de Melo struct msghdr msg_sys; 2133a2e27255SArnaldo Carvalho de Melo struct socket *sock = sockfd_lookup_light(fd, &err, &fput_needed); 2134a2e27255SArnaldo Carvalho de Melo 2135a2e27255SArnaldo Carvalho de Melo if (!sock) 2136a2e27255SArnaldo Carvalho de Melo goto out; 2137a2e27255SArnaldo Carvalho de Melo 2138a2e27255SArnaldo Carvalho de Melo err = __sys_recvmsg(sock, msg, &msg_sys, flags, 0); 2139a2e27255SArnaldo Carvalho de Melo 21406cb153caSBenjamin LaHaise fput_light(sock->file, fput_needed); 21411da177e4SLinus Torvalds out: 21421da177e4SLinus Torvalds return err; 21431da177e4SLinus Torvalds } 21441da177e4SLinus Torvalds 2145a2e27255SArnaldo Carvalho de Melo /* 2146a2e27255SArnaldo Carvalho de Melo * Linux recvmmsg interface 2147a2e27255SArnaldo Carvalho de Melo */ 21481da177e4SLinus Torvalds 2149a2e27255SArnaldo Carvalho de Melo int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen, 2150a2e27255SArnaldo Carvalho de Melo unsigned int flags, struct timespec *timeout) 2151a2e27255SArnaldo Carvalho de Melo { 2152a2e27255SArnaldo Carvalho de Melo int fput_needed, err, datagrams; 2153a2e27255SArnaldo Carvalho de Melo struct socket *sock; 2154a2e27255SArnaldo Carvalho de Melo struct mmsghdr __user *entry; 2155a2e27255SArnaldo Carvalho de Melo struct msghdr msg_sys; 2156a2e27255SArnaldo Carvalho de Melo struct timespec end_time; 2157a2e27255SArnaldo Carvalho de Melo 2158a2e27255SArnaldo Carvalho de Melo if (timeout && 2159a2e27255SArnaldo Carvalho de Melo poll_select_set_timeout(&end_time, timeout->tv_sec, 2160a2e27255SArnaldo Carvalho de Melo timeout->tv_nsec)) 2161a2e27255SArnaldo Carvalho de Melo return -EINVAL; 2162a2e27255SArnaldo Carvalho de Melo 2163a2e27255SArnaldo Carvalho de Melo datagrams = 0; 2164a2e27255SArnaldo Carvalho de Melo 2165a2e27255SArnaldo Carvalho de Melo sock = sockfd_lookup_light(fd, &err, &fput_needed); 2166a2e27255SArnaldo Carvalho de Melo if (!sock) 2167a2e27255SArnaldo Carvalho de Melo return err; 2168a2e27255SArnaldo Carvalho de Melo 2169a2e27255SArnaldo Carvalho de Melo err = sock_error(sock->sk); 2170a2e27255SArnaldo Carvalho de Melo if (err) 2171a2e27255SArnaldo Carvalho de Melo goto out_put; 2172a2e27255SArnaldo Carvalho de Melo 2173a2e27255SArnaldo Carvalho de Melo entry = mmsg; 2174a2e27255SArnaldo Carvalho de Melo 2175a2e27255SArnaldo Carvalho de Melo while (datagrams < vlen) { 2176a2e27255SArnaldo Carvalho de Melo /* 2177a2e27255SArnaldo Carvalho de Melo * No need to ask LSM for more than the first datagram. 2178a2e27255SArnaldo Carvalho de Melo */ 2179a2e27255SArnaldo Carvalho de Melo err = __sys_recvmsg(sock, (struct msghdr __user *)entry, 2180a2e27255SArnaldo Carvalho de Melo &msg_sys, flags, datagrams); 2181a2e27255SArnaldo Carvalho de Melo if (err < 0) 2182a2e27255SArnaldo Carvalho de Melo break; 2183a2e27255SArnaldo Carvalho de Melo err = put_user(err, &entry->msg_len); 2184a2e27255SArnaldo Carvalho de Melo if (err) 2185a2e27255SArnaldo Carvalho de Melo break; 2186a2e27255SArnaldo Carvalho de Melo ++entry; 2187a2e27255SArnaldo Carvalho de Melo ++datagrams; 2188a2e27255SArnaldo Carvalho de Melo 2189a2e27255SArnaldo Carvalho de Melo if (timeout) { 2190a2e27255SArnaldo Carvalho de Melo ktime_get_ts(timeout); 2191a2e27255SArnaldo Carvalho de Melo *timeout = timespec_sub(end_time, *timeout); 2192a2e27255SArnaldo Carvalho de Melo if (timeout->tv_sec < 0) { 2193a2e27255SArnaldo Carvalho de Melo timeout->tv_sec = timeout->tv_nsec = 0; 2194a2e27255SArnaldo Carvalho de Melo break; 2195a2e27255SArnaldo Carvalho de Melo } 2196a2e27255SArnaldo Carvalho de Melo 2197a2e27255SArnaldo Carvalho de Melo /* Timeout, return less than vlen datagrams */ 2198a2e27255SArnaldo Carvalho de Melo if (timeout->tv_nsec == 0 && timeout->tv_sec == 0) 2199a2e27255SArnaldo Carvalho de Melo break; 2200a2e27255SArnaldo Carvalho de Melo } 2201a2e27255SArnaldo Carvalho de Melo 2202a2e27255SArnaldo Carvalho de Melo /* Out of band data, return right away */ 2203a2e27255SArnaldo Carvalho de Melo if (msg_sys.msg_flags & MSG_OOB) 2204a2e27255SArnaldo Carvalho de Melo break; 2205a2e27255SArnaldo Carvalho de Melo } 2206a2e27255SArnaldo Carvalho de Melo 2207a2e27255SArnaldo Carvalho de Melo out_put: 2208a2e27255SArnaldo Carvalho de Melo fput_light(sock->file, fput_needed); 2209a2e27255SArnaldo Carvalho de Melo 2210a2e27255SArnaldo Carvalho de Melo if (err == 0) 2211a2e27255SArnaldo Carvalho de Melo return datagrams; 2212a2e27255SArnaldo Carvalho de Melo 2213a2e27255SArnaldo Carvalho de Melo if (datagrams != 0) { 2214a2e27255SArnaldo Carvalho de Melo /* 2215a2e27255SArnaldo Carvalho de Melo * We may return less entries than requested (vlen) if the 2216a2e27255SArnaldo Carvalho de Melo * sock is non block and there aren't enough datagrams... 2217a2e27255SArnaldo Carvalho de Melo */ 2218a2e27255SArnaldo Carvalho de Melo if (err != -EAGAIN) { 2219a2e27255SArnaldo Carvalho de Melo /* 2220a2e27255SArnaldo Carvalho de Melo * ... or if recvmsg returns an error after we 2221a2e27255SArnaldo Carvalho de Melo * received some datagrams, where we record the 2222a2e27255SArnaldo Carvalho de Melo * error to return on the next call or if the 2223a2e27255SArnaldo Carvalho de Melo * app asks about it using getsockopt(SO_ERROR). 2224a2e27255SArnaldo Carvalho de Melo */ 2225a2e27255SArnaldo Carvalho de Melo sock->sk->sk_err = -err; 2226a2e27255SArnaldo Carvalho de Melo } 2227a2e27255SArnaldo Carvalho de Melo 2228a2e27255SArnaldo Carvalho de Melo return datagrams; 2229a2e27255SArnaldo Carvalho de Melo } 2230a2e27255SArnaldo Carvalho de Melo 2231a2e27255SArnaldo Carvalho de Melo return err; 2232a2e27255SArnaldo Carvalho de Melo } 2233a2e27255SArnaldo Carvalho de Melo 2234a2e27255SArnaldo Carvalho de Melo SYSCALL_DEFINE5(recvmmsg, int, fd, struct mmsghdr __user *, mmsg, 2235a2e27255SArnaldo Carvalho de Melo unsigned int, vlen, unsigned int, flags, 2236a2e27255SArnaldo Carvalho de Melo struct timespec __user *, timeout) 2237a2e27255SArnaldo Carvalho de Melo { 2238a2e27255SArnaldo Carvalho de Melo int datagrams; 2239a2e27255SArnaldo Carvalho de Melo struct timespec timeout_sys; 2240a2e27255SArnaldo Carvalho de Melo 2241a2e27255SArnaldo Carvalho de Melo if (!timeout) 2242a2e27255SArnaldo Carvalho de Melo return __sys_recvmmsg(fd, mmsg, vlen, flags, NULL); 2243a2e27255SArnaldo Carvalho de Melo 2244a2e27255SArnaldo Carvalho de Melo if (copy_from_user(&timeout_sys, timeout, sizeof(timeout_sys))) 2245a2e27255SArnaldo Carvalho de Melo return -EFAULT; 2246a2e27255SArnaldo Carvalho de Melo 2247a2e27255SArnaldo Carvalho de Melo datagrams = __sys_recvmmsg(fd, mmsg, vlen, flags, &timeout_sys); 2248a2e27255SArnaldo Carvalho de Melo 2249a2e27255SArnaldo Carvalho de Melo if (datagrams > 0 && 2250a2e27255SArnaldo Carvalho de Melo copy_to_user(timeout, &timeout_sys, sizeof(timeout_sys))) 2251a2e27255SArnaldo Carvalho de Melo datagrams = -EFAULT; 2252a2e27255SArnaldo Carvalho de Melo 2253a2e27255SArnaldo Carvalho de Melo return datagrams; 2254a2e27255SArnaldo Carvalho de Melo } 2255a2e27255SArnaldo Carvalho de Melo 2256a2e27255SArnaldo Carvalho de Melo #ifdef __ARCH_WANT_SYS_SOCKETCALL 22571da177e4SLinus Torvalds /* Argument list sizes for sys_socketcall */ 22581da177e4SLinus Torvalds #define AL(x) ((x) * sizeof(unsigned long)) 2259a2e27255SArnaldo Carvalho de Melo static const unsigned char nargs[20] = { 226089bddce5SStephen Hemminger AL(0),AL(3),AL(3),AL(3),AL(2),AL(3), 22611da177e4SLinus Torvalds AL(3),AL(3),AL(4),AL(4),AL(4),AL(6), 2262aaca0bdcSUlrich Drepper AL(6),AL(2),AL(5),AL(5),AL(3),AL(3), 2263a2e27255SArnaldo Carvalho de Melo AL(4),AL(5) 226489bddce5SStephen Hemminger }; 226589bddce5SStephen Hemminger 22661da177e4SLinus Torvalds #undef AL 22671da177e4SLinus Torvalds 22681da177e4SLinus Torvalds /* 22691da177e4SLinus Torvalds * System call vectors. 22701da177e4SLinus Torvalds * 22711da177e4SLinus Torvalds * Argument checking cleaned up. Saved 20% in size. 22721da177e4SLinus Torvalds * This function doesn't need to set the kernel lock because 22731da177e4SLinus Torvalds * it is set by the callees. 22741da177e4SLinus Torvalds */ 22751da177e4SLinus Torvalds 22763e0fa65fSHeiko Carstens SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args) 22771da177e4SLinus Torvalds { 22781da177e4SLinus Torvalds unsigned long a[6]; 22791da177e4SLinus Torvalds unsigned long a0, a1; 22801da177e4SLinus Torvalds int err; 228147379052SArjan van de Ven unsigned int len; 22821da177e4SLinus Torvalds 2283a2e27255SArnaldo Carvalho de Melo if (call < 1 || call > SYS_RECVMMSG) 22841da177e4SLinus Torvalds return -EINVAL; 22851da177e4SLinus Torvalds 228647379052SArjan van de Ven len = nargs[call]; 228747379052SArjan van de Ven if (len > sizeof(a)) 228847379052SArjan van de Ven return -EINVAL; 228947379052SArjan van de Ven 22901da177e4SLinus Torvalds /* copy_from_user should be SMP safe. */ 229147379052SArjan van de Ven if (copy_from_user(a, args, len)) 22921da177e4SLinus Torvalds return -EFAULT; 22931da177e4SLinus Torvalds 2294f3298dc4SAl Viro audit_socketcall(nargs[call] / sizeof(unsigned long), a); 22953ec3b2fbSDavid Woodhouse 22961da177e4SLinus Torvalds a0 = a[0]; 22971da177e4SLinus Torvalds a1 = a[1]; 22981da177e4SLinus Torvalds 229989bddce5SStephen Hemminger switch (call) { 23001da177e4SLinus Torvalds case SYS_SOCKET: 23011da177e4SLinus Torvalds err = sys_socket(a0, a1, a[2]); 23021da177e4SLinus Torvalds break; 23031da177e4SLinus Torvalds case SYS_BIND: 23041da177e4SLinus Torvalds err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]); 23051da177e4SLinus Torvalds break; 23061da177e4SLinus Torvalds case SYS_CONNECT: 23071da177e4SLinus Torvalds err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]); 23081da177e4SLinus Torvalds break; 23091da177e4SLinus Torvalds case SYS_LISTEN: 23101da177e4SLinus Torvalds err = sys_listen(a0, a1); 23111da177e4SLinus Torvalds break; 23121da177e4SLinus Torvalds case SYS_ACCEPT: 2313de11defeSUlrich Drepper err = sys_accept4(a0, (struct sockaddr __user *)a1, 2314aaca0bdcSUlrich Drepper (int __user *)a[2], 0); 23151da177e4SLinus Torvalds break; 23161da177e4SLinus Torvalds case SYS_GETSOCKNAME: 231789bddce5SStephen Hemminger err = 231889bddce5SStephen Hemminger sys_getsockname(a0, (struct sockaddr __user *)a1, 231989bddce5SStephen Hemminger (int __user *)a[2]); 23201da177e4SLinus Torvalds break; 23211da177e4SLinus Torvalds case SYS_GETPEERNAME: 232289bddce5SStephen Hemminger err = 232389bddce5SStephen Hemminger sys_getpeername(a0, (struct sockaddr __user *)a1, 232489bddce5SStephen Hemminger (int __user *)a[2]); 23251da177e4SLinus Torvalds break; 23261da177e4SLinus Torvalds case SYS_SOCKETPAIR: 23271da177e4SLinus Torvalds err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]); 23281da177e4SLinus Torvalds break; 23291da177e4SLinus Torvalds case SYS_SEND: 23301da177e4SLinus Torvalds err = sys_send(a0, (void __user *)a1, a[2], a[3]); 23311da177e4SLinus Torvalds break; 23321da177e4SLinus Torvalds case SYS_SENDTO: 23331da177e4SLinus Torvalds err = sys_sendto(a0, (void __user *)a1, a[2], a[3], 23341da177e4SLinus Torvalds (struct sockaddr __user *)a[4], a[5]); 23351da177e4SLinus Torvalds break; 23361da177e4SLinus Torvalds case SYS_RECV: 23371da177e4SLinus Torvalds err = sys_recv(a0, (void __user *)a1, a[2], a[3]); 23381da177e4SLinus Torvalds break; 23391da177e4SLinus Torvalds case SYS_RECVFROM: 23401da177e4SLinus Torvalds err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3], 234189bddce5SStephen Hemminger (struct sockaddr __user *)a[4], 234289bddce5SStephen Hemminger (int __user *)a[5]); 23431da177e4SLinus Torvalds break; 23441da177e4SLinus Torvalds case SYS_SHUTDOWN: 23451da177e4SLinus Torvalds err = sys_shutdown(a0, a1); 23461da177e4SLinus Torvalds break; 23471da177e4SLinus Torvalds case SYS_SETSOCKOPT: 23481da177e4SLinus Torvalds err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]); 23491da177e4SLinus Torvalds break; 23501da177e4SLinus Torvalds case SYS_GETSOCKOPT: 235189bddce5SStephen Hemminger err = 235289bddce5SStephen Hemminger sys_getsockopt(a0, a1, a[2], (char __user *)a[3], 235389bddce5SStephen Hemminger (int __user *)a[4]); 23541da177e4SLinus Torvalds break; 23551da177e4SLinus Torvalds case SYS_SENDMSG: 23561da177e4SLinus Torvalds err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]); 23571da177e4SLinus Torvalds break; 23581da177e4SLinus Torvalds case SYS_RECVMSG: 23591da177e4SLinus Torvalds err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]); 23601da177e4SLinus Torvalds break; 2361a2e27255SArnaldo Carvalho de Melo case SYS_RECVMMSG: 2362a2e27255SArnaldo Carvalho de Melo err = sys_recvmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3], 2363a2e27255SArnaldo Carvalho de Melo (struct timespec __user *)a[4]); 2364a2e27255SArnaldo Carvalho de Melo break; 2365de11defeSUlrich Drepper case SYS_ACCEPT4: 2366de11defeSUlrich Drepper err = sys_accept4(a0, (struct sockaddr __user *)a1, 2367de11defeSUlrich Drepper (int __user *)a[2], a[3]); 2368aaca0bdcSUlrich Drepper break; 23691da177e4SLinus Torvalds default: 23701da177e4SLinus Torvalds err = -EINVAL; 23711da177e4SLinus Torvalds break; 23721da177e4SLinus Torvalds } 23731da177e4SLinus Torvalds return err; 23741da177e4SLinus Torvalds } 23751da177e4SLinus Torvalds 23761da177e4SLinus Torvalds #endif /* __ARCH_WANT_SYS_SOCKETCALL */ 23771da177e4SLinus Torvalds 237855737fdaSStephen Hemminger /** 237955737fdaSStephen Hemminger * sock_register - add a socket protocol handler 238055737fdaSStephen Hemminger * @ops: description of protocol 238155737fdaSStephen Hemminger * 23821da177e4SLinus Torvalds * This function is called by a protocol handler that wants to 23831da177e4SLinus Torvalds * advertise its address family, and have it linked into the 238455737fdaSStephen Hemminger * socket interface. The value ops->family coresponds to the 238555737fdaSStephen Hemminger * socket system call protocol family. 23861da177e4SLinus Torvalds */ 2387f0fd27d4SStephen Hemminger int sock_register(const struct net_proto_family *ops) 23881da177e4SLinus Torvalds { 23891da177e4SLinus Torvalds int err; 23901da177e4SLinus Torvalds 23911da177e4SLinus Torvalds if (ops->family >= NPROTO) { 239289bddce5SStephen Hemminger printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family, 239389bddce5SStephen Hemminger NPROTO); 23941da177e4SLinus Torvalds return -ENOBUFS; 23951da177e4SLinus Torvalds } 239655737fdaSStephen Hemminger 239755737fdaSStephen Hemminger spin_lock(&net_family_lock); 239855737fdaSStephen Hemminger if (net_families[ops->family]) 23991da177e4SLinus Torvalds err = -EEXIST; 240055737fdaSStephen Hemminger else { 24011da177e4SLinus Torvalds net_families[ops->family] = ops; 24021da177e4SLinus Torvalds err = 0; 24031da177e4SLinus Torvalds } 240455737fdaSStephen Hemminger spin_unlock(&net_family_lock); 240555737fdaSStephen Hemminger 240689bddce5SStephen Hemminger printk(KERN_INFO "NET: Registered protocol family %d\n", ops->family); 24071da177e4SLinus Torvalds return err; 24081da177e4SLinus Torvalds } 24091da177e4SLinus Torvalds 241055737fdaSStephen Hemminger /** 241155737fdaSStephen Hemminger * sock_unregister - remove a protocol handler 241255737fdaSStephen Hemminger * @family: protocol family to remove 241355737fdaSStephen Hemminger * 24141da177e4SLinus Torvalds * This function is called by a protocol handler that wants to 24151da177e4SLinus Torvalds * remove its address family, and have it unlinked from the 241655737fdaSStephen Hemminger * new socket creation. 241755737fdaSStephen Hemminger * 241855737fdaSStephen Hemminger * If protocol handler is a module, then it can use module reference 241955737fdaSStephen Hemminger * counts to protect against new references. If protocol handler is not 242055737fdaSStephen Hemminger * a module then it needs to provide its own protection in 242155737fdaSStephen Hemminger * the ops->create routine. 24221da177e4SLinus Torvalds */ 2423f0fd27d4SStephen Hemminger void sock_unregister(int family) 24241da177e4SLinus Torvalds { 2425f0fd27d4SStephen Hemminger BUG_ON(family < 0 || family >= NPROTO); 24261da177e4SLinus Torvalds 242755737fdaSStephen Hemminger spin_lock(&net_family_lock); 24281da177e4SLinus Torvalds net_families[family] = NULL; 242955737fdaSStephen Hemminger spin_unlock(&net_family_lock); 243055737fdaSStephen Hemminger 243155737fdaSStephen Hemminger synchronize_rcu(); 243255737fdaSStephen Hemminger 243389bddce5SStephen Hemminger printk(KERN_INFO "NET: Unregistered protocol family %d\n", family); 24341da177e4SLinus Torvalds } 24351da177e4SLinus Torvalds 243677d76ea3SAndi Kleen static int __init sock_init(void) 24371da177e4SLinus Torvalds { 24381da177e4SLinus Torvalds /* 24391da177e4SLinus Torvalds * Initialize sock SLAB cache. 24401da177e4SLinus Torvalds */ 24411da177e4SLinus Torvalds 24421da177e4SLinus Torvalds sk_init(); 24431da177e4SLinus Torvalds 24441da177e4SLinus Torvalds /* 24451da177e4SLinus Torvalds * Initialize skbuff SLAB cache 24461da177e4SLinus Torvalds */ 24471da177e4SLinus Torvalds skb_init(); 24481da177e4SLinus Torvalds 24491da177e4SLinus Torvalds /* 24501da177e4SLinus Torvalds * Initialize the protocols module. 24511da177e4SLinus Torvalds */ 24521da177e4SLinus Torvalds 24531da177e4SLinus Torvalds init_inodecache(); 24541da177e4SLinus Torvalds register_filesystem(&sock_fs_type); 24551da177e4SLinus Torvalds sock_mnt = kern_mount(&sock_fs_type); 245677d76ea3SAndi Kleen 245777d76ea3SAndi Kleen /* The real protocol initialization is performed in later initcalls. 24581da177e4SLinus Torvalds */ 24591da177e4SLinus Torvalds 24601da177e4SLinus Torvalds #ifdef CONFIG_NETFILTER 24611da177e4SLinus Torvalds netfilter_init(); 24621da177e4SLinus Torvalds #endif 2463cbeb321aSDavid S. Miller 2464cbeb321aSDavid S. Miller return 0; 24651da177e4SLinus Torvalds } 24661da177e4SLinus Torvalds 246777d76ea3SAndi Kleen core_initcall(sock_init); /* early initcall */ 246877d76ea3SAndi Kleen 24691da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 24701da177e4SLinus Torvalds void socket_seq_show(struct seq_file *seq) 24711da177e4SLinus Torvalds { 24721da177e4SLinus Torvalds int cpu; 24731da177e4SLinus Torvalds int counter = 0; 24741da177e4SLinus Torvalds 24756f912042SKAMEZAWA Hiroyuki for_each_possible_cpu(cpu) 24761da177e4SLinus Torvalds counter += per_cpu(sockets_in_use, cpu); 24771da177e4SLinus Torvalds 24781da177e4SLinus Torvalds /* It can be negative, by the way. 8) */ 24791da177e4SLinus Torvalds if (counter < 0) 24801da177e4SLinus Torvalds counter = 0; 24811da177e4SLinus Torvalds 24821da177e4SLinus Torvalds seq_printf(seq, "sockets: used %d\n", counter); 24831da177e4SLinus Torvalds } 24841da177e4SLinus Torvalds #endif /* CONFIG_PROC_FS */ 24851da177e4SLinus Torvalds 248689bbfc95SShaun Pereira #ifdef CONFIG_COMPAT 24876b96018bSArnd Bergmann static int do_siocgstamp(struct net *net, struct socket *sock, 24886b96018bSArnd Bergmann unsigned int cmd, struct compat_timeval __user *up) 24897a229387SArnd Bergmann { 24907a229387SArnd Bergmann mm_segment_t old_fs = get_fs(); 24917a229387SArnd Bergmann struct timeval ktv; 24927a229387SArnd Bergmann int err; 24937a229387SArnd Bergmann 24947a229387SArnd Bergmann set_fs(KERNEL_DS); 24956b96018bSArnd Bergmann err = sock_do_ioctl(net, sock, cmd, (unsigned long)&ktv); 24967a229387SArnd Bergmann set_fs(old_fs); 24977a229387SArnd Bergmann if (!err) { 24987a229387SArnd Bergmann err = put_user(ktv.tv_sec, &up->tv_sec); 24997a229387SArnd Bergmann err |= __put_user(ktv.tv_usec, &up->tv_usec); 25007a229387SArnd Bergmann } 25017a229387SArnd Bergmann return err; 25027a229387SArnd Bergmann } 25037a229387SArnd Bergmann 25046b96018bSArnd Bergmann static int do_siocgstampns(struct net *net, struct socket *sock, 25056b96018bSArnd Bergmann unsigned int cmd, struct compat_timespec __user *up) 25067a229387SArnd Bergmann { 25077a229387SArnd Bergmann mm_segment_t old_fs = get_fs(); 25087a229387SArnd Bergmann struct timespec kts; 25097a229387SArnd Bergmann int err; 25107a229387SArnd Bergmann 25117a229387SArnd Bergmann set_fs(KERNEL_DS); 25126b96018bSArnd Bergmann err = sock_do_ioctl(net, sock, cmd, (unsigned long)&kts); 25137a229387SArnd Bergmann set_fs(old_fs); 25147a229387SArnd Bergmann if (!err) { 25157a229387SArnd Bergmann err = put_user(kts.tv_sec, &up->tv_sec); 25167a229387SArnd Bergmann err |= __put_user(kts.tv_nsec, &up->tv_nsec); 25177a229387SArnd Bergmann } 25187a229387SArnd Bergmann return err; 25197a229387SArnd Bergmann } 25207a229387SArnd Bergmann 25216b96018bSArnd Bergmann static int dev_ifname32(struct net *net, struct compat_ifreq __user *uifr32) 25227a229387SArnd Bergmann { 25237a229387SArnd Bergmann struct ifreq __user *uifr; 25247a229387SArnd Bergmann int err; 25257a229387SArnd Bergmann 25267a229387SArnd Bergmann uifr = compat_alloc_user_space(sizeof(struct ifreq)); 25276b96018bSArnd Bergmann if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq))) 25287a229387SArnd Bergmann return -EFAULT; 25297a229387SArnd Bergmann 25306b96018bSArnd Bergmann err = dev_ioctl(net, SIOCGIFNAME, uifr); 25317a229387SArnd Bergmann if (err) 25327a229387SArnd Bergmann return err; 25337a229387SArnd Bergmann 25346b96018bSArnd Bergmann if (copy_in_user(uifr32, uifr, sizeof(struct compat_ifreq))) 25357a229387SArnd Bergmann return -EFAULT; 25367a229387SArnd Bergmann 25377a229387SArnd Bergmann return 0; 25387a229387SArnd Bergmann } 25397a229387SArnd Bergmann 25406b96018bSArnd Bergmann static int dev_ifconf(struct net *net, struct compat_ifconf __user *uifc32) 25417a229387SArnd Bergmann { 25426b96018bSArnd Bergmann struct compat_ifconf ifc32; 25437a229387SArnd Bergmann struct ifconf ifc; 25447a229387SArnd Bergmann struct ifconf __user *uifc; 25456b96018bSArnd Bergmann struct compat_ifreq __user *ifr32; 25467a229387SArnd Bergmann struct ifreq __user *ifr; 25477a229387SArnd Bergmann unsigned int i, j; 25487a229387SArnd Bergmann int err; 25497a229387SArnd Bergmann 25506b96018bSArnd Bergmann if (copy_from_user(&ifc32, uifc32, sizeof(struct compat_ifconf))) 25517a229387SArnd Bergmann return -EFAULT; 25527a229387SArnd Bergmann 25537a229387SArnd Bergmann if (ifc32.ifcbuf == 0) { 25547a229387SArnd Bergmann ifc32.ifc_len = 0; 25557a229387SArnd Bergmann ifc.ifc_len = 0; 25567a229387SArnd Bergmann ifc.ifc_req = NULL; 25577a229387SArnd Bergmann uifc = compat_alloc_user_space(sizeof(struct ifconf)); 25587a229387SArnd Bergmann } else { 25596b96018bSArnd Bergmann size_t len =((ifc32.ifc_len / sizeof (struct compat_ifreq)) + 1) * 25607a229387SArnd Bergmann sizeof (struct ifreq); 25617a229387SArnd Bergmann uifc = compat_alloc_user_space(sizeof(struct ifconf) + len); 25627a229387SArnd Bergmann ifc.ifc_len = len; 25637a229387SArnd Bergmann ifr = ifc.ifc_req = (void __user *)(uifc + 1); 25647a229387SArnd Bergmann ifr32 = compat_ptr(ifc32.ifcbuf); 25656b96018bSArnd Bergmann for (i = 0; i < ifc32.ifc_len; i += sizeof (struct compat_ifreq)) { 25666b96018bSArnd Bergmann if (copy_in_user(ifr, ifr32, sizeof(struct compat_ifreq))) 25677a229387SArnd Bergmann return -EFAULT; 25687a229387SArnd Bergmann ifr++; 25697a229387SArnd Bergmann ifr32++; 25707a229387SArnd Bergmann } 25717a229387SArnd Bergmann } 25727a229387SArnd Bergmann if (copy_to_user(uifc, &ifc, sizeof(struct ifconf))) 25737a229387SArnd Bergmann return -EFAULT; 25747a229387SArnd Bergmann 25756b96018bSArnd Bergmann err = dev_ioctl(net, SIOCGIFCONF, uifc); 25767a229387SArnd Bergmann if (err) 25777a229387SArnd Bergmann return err; 25787a229387SArnd Bergmann 25797a229387SArnd Bergmann if (copy_from_user(&ifc, uifc, sizeof(struct ifconf))) 25807a229387SArnd Bergmann return -EFAULT; 25817a229387SArnd Bergmann 25827a229387SArnd Bergmann ifr = ifc.ifc_req; 25837a229387SArnd Bergmann ifr32 = compat_ptr(ifc32.ifcbuf); 25847a229387SArnd Bergmann for (i = 0, j = 0; 25856b96018bSArnd Bergmann i + sizeof (struct compat_ifreq) <= ifc32.ifc_len && j < ifc.ifc_len; 25866b96018bSArnd Bergmann i += sizeof (struct compat_ifreq), j += sizeof (struct ifreq)) { 25876b96018bSArnd Bergmann if (copy_in_user(ifr32, ifr, sizeof (struct compat_ifreq))) 25887a229387SArnd Bergmann return -EFAULT; 25897a229387SArnd Bergmann ifr32++; 25907a229387SArnd Bergmann ifr++; 25917a229387SArnd Bergmann } 25927a229387SArnd Bergmann 25937a229387SArnd Bergmann if (ifc32.ifcbuf == 0) { 25947a229387SArnd Bergmann /* Translate from 64-bit structure multiple to 25957a229387SArnd Bergmann * a 32-bit one. 25967a229387SArnd Bergmann */ 25977a229387SArnd Bergmann i = ifc.ifc_len; 25986b96018bSArnd Bergmann i = ((i / sizeof(struct ifreq)) * sizeof(struct compat_ifreq)); 25997a229387SArnd Bergmann ifc32.ifc_len = i; 26007a229387SArnd Bergmann } else { 26017a229387SArnd Bergmann ifc32.ifc_len = i; 26027a229387SArnd Bergmann } 26036b96018bSArnd Bergmann if (copy_to_user(uifc32, &ifc32, sizeof(struct compat_ifconf))) 26047a229387SArnd Bergmann return -EFAULT; 26057a229387SArnd Bergmann 26067a229387SArnd Bergmann return 0; 26077a229387SArnd Bergmann } 26087a229387SArnd Bergmann 26096b96018bSArnd Bergmann static int ethtool_ioctl(struct net *net, struct compat_ifreq __user *ifr32) 26107a229387SArnd Bergmann { 26117a229387SArnd Bergmann struct ifreq __user *ifr; 26127a229387SArnd Bergmann u32 data; 26137a229387SArnd Bergmann void __user *datap; 26147a229387SArnd Bergmann 26157a229387SArnd Bergmann ifr = compat_alloc_user_space(sizeof(*ifr)); 26167a229387SArnd Bergmann 26177a229387SArnd Bergmann if (copy_in_user(&ifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ)) 26187a229387SArnd Bergmann return -EFAULT; 26197a229387SArnd Bergmann 26207a229387SArnd Bergmann if (get_user(data, &ifr32->ifr_ifru.ifru_data)) 26217a229387SArnd Bergmann return -EFAULT; 26227a229387SArnd Bergmann 26237a229387SArnd Bergmann datap = compat_ptr(data); 26247a229387SArnd Bergmann if (put_user(datap, &ifr->ifr_ifru.ifru_data)) 26257a229387SArnd Bergmann return -EFAULT; 26267a229387SArnd Bergmann 26276b96018bSArnd Bergmann return dev_ioctl(net, SIOCETHTOOL, ifr); 26287a229387SArnd Bergmann } 26297a229387SArnd Bergmann 2630*7a50a240SArnd Bergmann static int compat_siocwandev(struct net *net, struct compat_ifreq __user *uifr32) 2631*7a50a240SArnd Bergmann { 2632*7a50a240SArnd Bergmann void __user *uptr; 2633*7a50a240SArnd Bergmann compat_uptr_t uptr32; 2634*7a50a240SArnd Bergmann struct ifreq __user *uifr; 2635*7a50a240SArnd Bergmann 2636*7a50a240SArnd Bergmann uifr = compat_alloc_user_space(sizeof (*uifr)); 2637*7a50a240SArnd Bergmann if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq))) 2638*7a50a240SArnd Bergmann return -EFAULT; 2639*7a50a240SArnd Bergmann 2640*7a50a240SArnd Bergmann if (get_user(uptr32, &uifr32->ifr_settings.ifs_ifsu)) 2641*7a50a240SArnd Bergmann return -EFAULT; 2642*7a50a240SArnd Bergmann 2643*7a50a240SArnd Bergmann uptr = compat_ptr(uptr32); 2644*7a50a240SArnd Bergmann 2645*7a50a240SArnd Bergmann if (put_user(uptr, &uifr->ifr_settings.ifs_ifsu.raw_hdlc)) 2646*7a50a240SArnd Bergmann return -EFAULT; 2647*7a50a240SArnd Bergmann 2648*7a50a240SArnd Bergmann return dev_ioctl(net, SIOCWANDEV, uifr); 2649*7a50a240SArnd Bergmann } 2650*7a50a240SArnd Bergmann 26516b96018bSArnd Bergmann static int bond_ioctl(struct net *net, unsigned int cmd, 26526b96018bSArnd Bergmann struct compat_ifreq __user *ifr32) 26537a229387SArnd Bergmann { 26547a229387SArnd Bergmann struct ifreq kifr; 26557a229387SArnd Bergmann struct ifreq __user *uifr; 26567a229387SArnd Bergmann mm_segment_t old_fs; 26577a229387SArnd Bergmann int err; 26587a229387SArnd Bergmann u32 data; 26597a229387SArnd Bergmann void __user *datap; 26607a229387SArnd Bergmann 26617a229387SArnd Bergmann switch (cmd) { 26627a229387SArnd Bergmann case SIOCBONDENSLAVE: 26637a229387SArnd Bergmann case SIOCBONDRELEASE: 26647a229387SArnd Bergmann case SIOCBONDSETHWADDR: 26657a229387SArnd Bergmann case SIOCBONDCHANGEACTIVE: 26666b96018bSArnd Bergmann if (copy_from_user(&kifr, ifr32, sizeof(struct compat_ifreq))) 26677a229387SArnd Bergmann return -EFAULT; 26687a229387SArnd Bergmann 26697a229387SArnd Bergmann old_fs = get_fs(); 26707a229387SArnd Bergmann set_fs (KERNEL_DS); 26716b96018bSArnd Bergmann err = dev_ioctl(net, cmd, &kifr); 26727a229387SArnd Bergmann set_fs (old_fs); 26737a229387SArnd Bergmann 26747a229387SArnd Bergmann return err; 26757a229387SArnd Bergmann case SIOCBONDSLAVEINFOQUERY: 26767a229387SArnd Bergmann case SIOCBONDINFOQUERY: 26777a229387SArnd Bergmann uifr = compat_alloc_user_space(sizeof(*uifr)); 26787a229387SArnd Bergmann if (copy_in_user(&uifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ)) 26797a229387SArnd Bergmann return -EFAULT; 26807a229387SArnd Bergmann 26817a229387SArnd Bergmann if (get_user(data, &ifr32->ifr_ifru.ifru_data)) 26827a229387SArnd Bergmann return -EFAULT; 26837a229387SArnd Bergmann 26847a229387SArnd Bergmann datap = compat_ptr(data); 26857a229387SArnd Bergmann if (put_user(datap, &uifr->ifr_ifru.ifru_data)) 26867a229387SArnd Bergmann return -EFAULT; 26877a229387SArnd Bergmann 26886b96018bSArnd Bergmann return dev_ioctl(net, cmd, uifr); 26897a229387SArnd Bergmann default: 26907a229387SArnd Bergmann return -EINVAL; 26917a229387SArnd Bergmann }; 26927a229387SArnd Bergmann } 26937a229387SArnd Bergmann 26946b96018bSArnd Bergmann static int siocdevprivate_ioctl(struct net *net, unsigned int cmd, 26956b96018bSArnd Bergmann struct compat_ifreq __user *u_ifreq32) 26967a229387SArnd Bergmann { 26977a229387SArnd Bergmann struct ifreq __user *u_ifreq64; 26987a229387SArnd Bergmann char tmp_buf[IFNAMSIZ]; 26997a229387SArnd Bergmann void __user *data64; 27007a229387SArnd Bergmann u32 data32; 27017a229387SArnd Bergmann 27027a229387SArnd Bergmann if (copy_from_user(&tmp_buf[0], &(u_ifreq32->ifr_ifrn.ifrn_name[0]), 27037a229387SArnd Bergmann IFNAMSIZ)) 27047a229387SArnd Bergmann return -EFAULT; 27057a229387SArnd Bergmann if (__get_user(data32, &u_ifreq32->ifr_ifru.ifru_data)) 27067a229387SArnd Bergmann return -EFAULT; 27077a229387SArnd Bergmann data64 = compat_ptr(data32); 27087a229387SArnd Bergmann 27097a229387SArnd Bergmann u_ifreq64 = compat_alloc_user_space(sizeof(*u_ifreq64)); 27107a229387SArnd Bergmann 27117a229387SArnd Bergmann /* Don't check these user accesses, just let that get trapped 27127a229387SArnd Bergmann * in the ioctl handler instead. 27137a229387SArnd Bergmann */ 27147a229387SArnd Bergmann if (copy_to_user(&u_ifreq64->ifr_ifrn.ifrn_name[0], &tmp_buf[0], 27157a229387SArnd Bergmann IFNAMSIZ)) 27167a229387SArnd Bergmann return -EFAULT; 27177a229387SArnd Bergmann if (__put_user(data64, &u_ifreq64->ifr_ifru.ifru_data)) 27187a229387SArnd Bergmann return -EFAULT; 27197a229387SArnd Bergmann 27206b96018bSArnd Bergmann return dev_ioctl(net, cmd, u_ifreq64); 27217a229387SArnd Bergmann } 27227a229387SArnd Bergmann 27236b96018bSArnd Bergmann static int dev_ifsioc(struct net *net, struct socket *sock, 27246b96018bSArnd Bergmann unsigned int cmd, struct compat_ifreq __user *uifr32) 27257a229387SArnd Bergmann { 27267a229387SArnd Bergmann struct ifreq ifr; 27276b96018bSArnd Bergmann struct compat_ifmap __user *uifmap32; 27287a229387SArnd Bergmann mm_segment_t old_fs; 27297a229387SArnd Bergmann int err; 27307a229387SArnd Bergmann 27317a229387SArnd Bergmann uifmap32 = &uifr32->ifr_ifru.ifru_map; 27327a229387SArnd Bergmann switch (cmd) { 27337a229387SArnd Bergmann case SIOCSIFMAP: 27347a229387SArnd Bergmann err = copy_from_user(&ifr, uifr32, sizeof(ifr.ifr_name)); 27357a229387SArnd Bergmann err |= __get_user(ifr.ifr_map.mem_start, &uifmap32->mem_start); 27367a229387SArnd Bergmann err |= __get_user(ifr.ifr_map.mem_end, &uifmap32->mem_end); 27377a229387SArnd Bergmann err |= __get_user(ifr.ifr_map.base_addr, &uifmap32->base_addr); 27387a229387SArnd Bergmann err |= __get_user(ifr.ifr_map.irq, &uifmap32->irq); 27397a229387SArnd Bergmann err |= __get_user(ifr.ifr_map.dma, &uifmap32->dma); 27407a229387SArnd Bergmann err |= __get_user(ifr.ifr_map.port, &uifmap32->port); 27417a229387SArnd Bergmann if (err) 27427a229387SArnd Bergmann return -EFAULT; 27437a229387SArnd Bergmann break; 27447a229387SArnd Bergmann case SIOCSHWTSTAMP: 27457a229387SArnd Bergmann if (copy_from_user(&ifr, uifr32, sizeof(*uifr32))) 27467a229387SArnd Bergmann return -EFAULT; 27477a229387SArnd Bergmann ifr.ifr_data = compat_ptr(uifr32->ifr_ifru.ifru_data); 27487a229387SArnd Bergmann break; 27497a229387SArnd Bergmann default: 27507a229387SArnd Bergmann if (copy_from_user(&ifr, uifr32, sizeof(*uifr32))) 27517a229387SArnd Bergmann return -EFAULT; 27527a229387SArnd Bergmann break; 27537a229387SArnd Bergmann } 27547a229387SArnd Bergmann old_fs = get_fs(); 27557a229387SArnd Bergmann set_fs (KERNEL_DS); 27566b96018bSArnd Bergmann err = sock_do_ioctl(net, sock, cmd, (unsigned long)&ifr); 27577a229387SArnd Bergmann set_fs (old_fs); 27587a229387SArnd Bergmann if (!err) { 27597a229387SArnd Bergmann switch (cmd) { 27607a229387SArnd Bergmann case SIOCGIFFLAGS: 27617a229387SArnd Bergmann case SIOCGIFMETRIC: 27627a229387SArnd Bergmann case SIOCGIFMTU: 27637a229387SArnd Bergmann case SIOCGIFMEM: 27647a229387SArnd Bergmann case SIOCGIFHWADDR: 27657a229387SArnd Bergmann case SIOCGIFINDEX: 27667a229387SArnd Bergmann case SIOCGIFADDR: 27677a229387SArnd Bergmann case SIOCGIFBRDADDR: 27687a229387SArnd Bergmann case SIOCGIFDSTADDR: 27697a229387SArnd Bergmann case SIOCGIFNETMASK: 2770fab2532bSArnd Bergmann case SIOCGIFPFLAGS: 27717a229387SArnd Bergmann case SIOCGIFTXQLEN: 2772fab2532bSArnd Bergmann case SIOCGMIIPHY: 2773fab2532bSArnd Bergmann case SIOCGMIIREG: 27747a229387SArnd Bergmann if (copy_to_user(uifr32, &ifr, sizeof(*uifr32))) 27757a229387SArnd Bergmann return -EFAULT; 27767a229387SArnd Bergmann break; 27777a229387SArnd Bergmann case SIOCGIFMAP: 27787a229387SArnd Bergmann err = copy_to_user(uifr32, &ifr, sizeof(ifr.ifr_name)); 27797a229387SArnd Bergmann err |= __put_user(ifr.ifr_map.mem_start, &uifmap32->mem_start); 27807a229387SArnd Bergmann err |= __put_user(ifr.ifr_map.mem_end, &uifmap32->mem_end); 27817a229387SArnd Bergmann err |= __put_user(ifr.ifr_map.base_addr, &uifmap32->base_addr); 27827a229387SArnd Bergmann err |= __put_user(ifr.ifr_map.irq, &uifmap32->irq); 27837a229387SArnd Bergmann err |= __put_user(ifr.ifr_map.dma, &uifmap32->dma); 27847a229387SArnd Bergmann err |= __put_user(ifr.ifr_map.port, &uifmap32->port); 27857a229387SArnd Bergmann if (err) 27867a229387SArnd Bergmann err = -EFAULT; 27877a229387SArnd Bergmann break; 27887a229387SArnd Bergmann } 27897a229387SArnd Bergmann } 27907a229387SArnd Bergmann return err; 27917a229387SArnd Bergmann } 27927a229387SArnd Bergmann 27937a229387SArnd Bergmann struct rtentry32 { 27947a229387SArnd Bergmann u32 rt_pad1; 27957a229387SArnd Bergmann struct sockaddr rt_dst; /* target address */ 27967a229387SArnd Bergmann struct sockaddr rt_gateway; /* gateway addr (RTF_GATEWAY) */ 27977a229387SArnd Bergmann struct sockaddr rt_genmask; /* target network mask (IP) */ 27987a229387SArnd Bergmann unsigned short rt_flags; 27997a229387SArnd Bergmann short rt_pad2; 28007a229387SArnd Bergmann u32 rt_pad3; 28017a229387SArnd Bergmann unsigned char rt_tos; 28027a229387SArnd Bergmann unsigned char rt_class; 28037a229387SArnd Bergmann short rt_pad4; 28047a229387SArnd Bergmann short rt_metric; /* +1 for binary compatibility! */ 28057a229387SArnd Bergmann /* char * */ u32 rt_dev; /* forcing the device at add */ 28067a229387SArnd Bergmann u32 rt_mtu; /* per route MTU/Window */ 28077a229387SArnd Bergmann u32 rt_window; /* Window clamping */ 28087a229387SArnd Bergmann unsigned short rt_irtt; /* Initial RTT */ 28097a229387SArnd Bergmann }; 28107a229387SArnd Bergmann 28117a229387SArnd Bergmann struct in6_rtmsg32 { 28127a229387SArnd Bergmann struct in6_addr rtmsg_dst; 28137a229387SArnd Bergmann struct in6_addr rtmsg_src; 28147a229387SArnd Bergmann struct in6_addr rtmsg_gateway; 28157a229387SArnd Bergmann u32 rtmsg_type; 28167a229387SArnd Bergmann u16 rtmsg_dst_len; 28177a229387SArnd Bergmann u16 rtmsg_src_len; 28187a229387SArnd Bergmann u32 rtmsg_metric; 28197a229387SArnd Bergmann u32 rtmsg_info; 28207a229387SArnd Bergmann u32 rtmsg_flags; 28217a229387SArnd Bergmann s32 rtmsg_ifindex; 28227a229387SArnd Bergmann }; 28237a229387SArnd Bergmann 28246b96018bSArnd Bergmann static int routing_ioctl(struct net *net, struct socket *sock, 28256b96018bSArnd Bergmann unsigned int cmd, void __user *argp) 28267a229387SArnd Bergmann { 28277a229387SArnd Bergmann int ret; 28287a229387SArnd Bergmann void *r = NULL; 28297a229387SArnd Bergmann struct in6_rtmsg r6; 28307a229387SArnd Bergmann struct rtentry r4; 28317a229387SArnd Bergmann char devname[16]; 28327a229387SArnd Bergmann u32 rtdev; 28337a229387SArnd Bergmann mm_segment_t old_fs = get_fs(); 28347a229387SArnd Bergmann 28356b96018bSArnd Bergmann if (sock && sock->sk && sock->sk->sk_family == AF_INET6) { /* ipv6 */ 28366b96018bSArnd Bergmann struct in6_rtmsg32 __user *ur6 = argp; 28377a229387SArnd Bergmann ret = copy_from_user (&r6.rtmsg_dst, &(ur6->rtmsg_dst), 28387a229387SArnd Bergmann 3 * sizeof(struct in6_addr)); 28397a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_type, &(ur6->rtmsg_type)); 28407a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_dst_len, &(ur6->rtmsg_dst_len)); 28417a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_src_len, &(ur6->rtmsg_src_len)); 28427a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_metric, &(ur6->rtmsg_metric)); 28437a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_info, &(ur6->rtmsg_info)); 28447a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_flags, &(ur6->rtmsg_flags)); 28457a229387SArnd Bergmann ret |= __get_user (r6.rtmsg_ifindex, &(ur6->rtmsg_ifindex)); 28467a229387SArnd Bergmann 28477a229387SArnd Bergmann r = (void *) &r6; 28487a229387SArnd Bergmann } else { /* ipv4 */ 28496b96018bSArnd Bergmann struct rtentry32 __user *ur4 = argp; 28507a229387SArnd Bergmann ret = copy_from_user (&r4.rt_dst, &(ur4->rt_dst), 28517a229387SArnd Bergmann 3 * sizeof(struct sockaddr)); 28527a229387SArnd Bergmann ret |= __get_user (r4.rt_flags, &(ur4->rt_flags)); 28537a229387SArnd Bergmann ret |= __get_user (r4.rt_metric, &(ur4->rt_metric)); 28547a229387SArnd Bergmann ret |= __get_user (r4.rt_mtu, &(ur4->rt_mtu)); 28557a229387SArnd Bergmann ret |= __get_user (r4.rt_window, &(ur4->rt_window)); 28567a229387SArnd Bergmann ret |= __get_user (r4.rt_irtt, &(ur4->rt_irtt)); 28577a229387SArnd Bergmann ret |= __get_user (rtdev, &(ur4->rt_dev)); 28587a229387SArnd Bergmann if (rtdev) { 28597a229387SArnd Bergmann ret |= copy_from_user (devname, compat_ptr(rtdev), 15); 28607a229387SArnd Bergmann r4.rt_dev = devname; devname[15] = 0; 28617a229387SArnd Bergmann } else 28627a229387SArnd Bergmann r4.rt_dev = NULL; 28637a229387SArnd Bergmann 28647a229387SArnd Bergmann r = (void *) &r4; 28657a229387SArnd Bergmann } 28667a229387SArnd Bergmann 28677a229387SArnd Bergmann if (ret) { 28687a229387SArnd Bergmann ret = -EFAULT; 28697a229387SArnd Bergmann goto out; 28707a229387SArnd Bergmann } 28717a229387SArnd Bergmann 28727a229387SArnd Bergmann set_fs (KERNEL_DS); 28736b96018bSArnd Bergmann ret = sock_do_ioctl(net, sock, cmd, (unsigned long) r); 28747a229387SArnd Bergmann set_fs (old_fs); 28757a229387SArnd Bergmann 28767a229387SArnd Bergmann out: 28777a229387SArnd Bergmann return ret; 28787a229387SArnd Bergmann } 28797a229387SArnd Bergmann 28807a229387SArnd Bergmann /* Since old style bridge ioctl's endup using SIOCDEVPRIVATE 28817a229387SArnd Bergmann * for some operations; this forces use of the newer bridge-utils that 28827a229387SArnd Bergmann * use compatiable ioctls 28837a229387SArnd Bergmann */ 28846b96018bSArnd Bergmann static int old_bridge_ioctl(compat_ulong_t __user *argp) 28857a229387SArnd Bergmann { 28866b96018bSArnd Bergmann compat_ulong_t tmp; 28877a229387SArnd Bergmann 28886b96018bSArnd Bergmann if (get_user(tmp, argp)) 28897a229387SArnd Bergmann return -EFAULT; 28907a229387SArnd Bergmann if (tmp == BRCTL_GET_VERSION) 28917a229387SArnd Bergmann return BRCTL_VERSION + 1; 28927a229387SArnd Bergmann return -EINVAL; 28937a229387SArnd Bergmann } 28947a229387SArnd Bergmann 28957a229387SArnd Bergmann struct atmif_sioc32 { 28967a229387SArnd Bergmann compat_int_t number; 28977a229387SArnd Bergmann compat_int_t length; 28987a229387SArnd Bergmann compat_caddr_t arg; 28997a229387SArnd Bergmann }; 29007a229387SArnd Bergmann 29017a229387SArnd Bergmann struct atm_iobuf32 { 29027a229387SArnd Bergmann compat_int_t length; 29037a229387SArnd Bergmann compat_caddr_t buffer; 29047a229387SArnd Bergmann }; 29057a229387SArnd Bergmann 29067a229387SArnd Bergmann #define ATM_GETLINKRATE32 _IOW('a', ATMIOC_ITF+1, struct atmif_sioc32) 29077a229387SArnd Bergmann #define ATM_GETNAMES32 _IOW('a', ATMIOC_ITF+3, struct atm_iobuf32) 29087a229387SArnd Bergmann #define ATM_GETTYPE32 _IOW('a', ATMIOC_ITF+4, struct atmif_sioc32) 29097a229387SArnd Bergmann #define ATM_GETESI32 _IOW('a', ATMIOC_ITF+5, struct atmif_sioc32) 29107a229387SArnd Bergmann #define ATM_GETADDR32 _IOW('a', ATMIOC_ITF+6, struct atmif_sioc32) 29117a229387SArnd Bergmann #define ATM_RSTADDR32 _IOW('a', ATMIOC_ITF+7, struct atmif_sioc32) 29127a229387SArnd Bergmann #define ATM_ADDADDR32 _IOW('a', ATMIOC_ITF+8, struct atmif_sioc32) 29137a229387SArnd Bergmann #define ATM_DELADDR32 _IOW('a', ATMIOC_ITF+9, struct atmif_sioc32) 29147a229387SArnd Bergmann #define ATM_GETCIRANGE32 _IOW('a', ATMIOC_ITF+10, struct atmif_sioc32) 29157a229387SArnd Bergmann #define ATM_SETCIRANGE32 _IOW('a', ATMIOC_ITF+11, struct atmif_sioc32) 29167a229387SArnd Bergmann #define ATM_SETESI32 _IOW('a', ATMIOC_ITF+12, struct atmif_sioc32) 29177a229387SArnd Bergmann #define ATM_SETESIF32 _IOW('a', ATMIOC_ITF+13, struct atmif_sioc32) 29187a229387SArnd Bergmann #define ATM_GETSTAT32 _IOW('a', ATMIOC_SARCOM+0, struct atmif_sioc32) 29197a229387SArnd Bergmann #define ATM_GETSTATZ32 _IOW('a', ATMIOC_SARCOM+1, struct atmif_sioc32) 29207a229387SArnd Bergmann #define ATM_GETLOOP32 _IOW('a', ATMIOC_SARCOM+2, struct atmif_sioc32) 29217a229387SArnd Bergmann #define ATM_SETLOOP32 _IOW('a', ATMIOC_SARCOM+3, struct atmif_sioc32) 29227a229387SArnd Bergmann #define ATM_QUERYLOOP32 _IOW('a', ATMIOC_SARCOM+4, struct atmif_sioc32) 29237a229387SArnd Bergmann 29247a229387SArnd Bergmann static struct { 29257a229387SArnd Bergmann unsigned int cmd32; 29267a229387SArnd Bergmann unsigned int cmd; 29277a229387SArnd Bergmann } atm_ioctl_map[] = { 29287a229387SArnd Bergmann { ATM_GETLINKRATE32, ATM_GETLINKRATE }, 29297a229387SArnd Bergmann { ATM_GETNAMES32, ATM_GETNAMES }, 29307a229387SArnd Bergmann { ATM_GETTYPE32, ATM_GETTYPE }, 29317a229387SArnd Bergmann { ATM_GETESI32, ATM_GETESI }, 29327a229387SArnd Bergmann { ATM_GETADDR32, ATM_GETADDR }, 29337a229387SArnd Bergmann { ATM_RSTADDR32, ATM_RSTADDR }, 29347a229387SArnd Bergmann { ATM_ADDADDR32, ATM_ADDADDR }, 29357a229387SArnd Bergmann { ATM_DELADDR32, ATM_DELADDR }, 29367a229387SArnd Bergmann { ATM_GETCIRANGE32, ATM_GETCIRANGE }, 29377a229387SArnd Bergmann { ATM_SETCIRANGE32, ATM_SETCIRANGE }, 29387a229387SArnd Bergmann { ATM_SETESI32, ATM_SETESI }, 29397a229387SArnd Bergmann { ATM_SETESIF32, ATM_SETESIF }, 29407a229387SArnd Bergmann { ATM_GETSTAT32, ATM_GETSTAT }, 29417a229387SArnd Bergmann { ATM_GETSTATZ32, ATM_GETSTATZ }, 29427a229387SArnd Bergmann { ATM_GETLOOP32, ATM_GETLOOP }, 29437a229387SArnd Bergmann { ATM_SETLOOP32, ATM_SETLOOP }, 29447a229387SArnd Bergmann { ATM_QUERYLOOP32, ATM_QUERYLOOP } 29457a229387SArnd Bergmann }; 29467a229387SArnd Bergmann 29477a229387SArnd Bergmann #define NR_ATM_IOCTL ARRAY_SIZE(atm_ioctl_map) 29487a229387SArnd Bergmann 29496b96018bSArnd Bergmann static int do_atm_iobuf(struct net *net, struct socket *sock, 29506b96018bSArnd Bergmann unsigned int cmd, unsigned long arg) 29517a229387SArnd Bergmann { 29527a229387SArnd Bergmann struct atm_iobuf __user *iobuf; 29537a229387SArnd Bergmann struct atm_iobuf32 __user *iobuf32; 29547a229387SArnd Bergmann u32 data; 29557a229387SArnd Bergmann void __user *datap; 29567a229387SArnd Bergmann int len, err; 29577a229387SArnd Bergmann 29587a229387SArnd Bergmann iobuf = compat_alloc_user_space(sizeof(*iobuf)); 29597a229387SArnd Bergmann iobuf32 = compat_ptr(arg); 29607a229387SArnd Bergmann 29617a229387SArnd Bergmann if (get_user(len, &iobuf32->length) || 29627a229387SArnd Bergmann get_user(data, &iobuf32->buffer)) 29637a229387SArnd Bergmann return -EFAULT; 29647a229387SArnd Bergmann datap = compat_ptr(data); 29657a229387SArnd Bergmann if (put_user(len, &iobuf->length) || 29667a229387SArnd Bergmann put_user(datap, &iobuf->buffer)) 29677a229387SArnd Bergmann return -EFAULT; 29687a229387SArnd Bergmann 29696b96018bSArnd Bergmann err = sock_do_ioctl(net, sock, cmd, (unsigned long)iobuf); 29707a229387SArnd Bergmann 29717a229387SArnd Bergmann if (!err) { 29727a229387SArnd Bergmann if (copy_in_user(&iobuf32->length, &iobuf->length, 29737a229387SArnd Bergmann sizeof(int))) 29747a229387SArnd Bergmann err = -EFAULT; 29757a229387SArnd Bergmann } 29767a229387SArnd Bergmann 29777a229387SArnd Bergmann return err; 29787a229387SArnd Bergmann } 29797a229387SArnd Bergmann 29806b96018bSArnd Bergmann static int do_atmif_sioc(struct net *net, struct socket *sock, 29816b96018bSArnd Bergmann unsigned int cmd, unsigned long arg) 29827a229387SArnd Bergmann { 29837a229387SArnd Bergmann struct atmif_sioc __user *sioc; 29847a229387SArnd Bergmann struct atmif_sioc32 __user *sioc32; 29857a229387SArnd Bergmann u32 data; 29867a229387SArnd Bergmann void __user *datap; 29877a229387SArnd Bergmann int err; 29887a229387SArnd Bergmann 29897a229387SArnd Bergmann sioc = compat_alloc_user_space(sizeof(*sioc)); 29907a229387SArnd Bergmann sioc32 = compat_ptr(arg); 29917a229387SArnd Bergmann 29927a229387SArnd Bergmann if (copy_in_user(&sioc->number, &sioc32->number, 2 * sizeof(int)) || 29937a229387SArnd Bergmann get_user(data, &sioc32->arg)) 29947a229387SArnd Bergmann return -EFAULT; 29957a229387SArnd Bergmann datap = compat_ptr(data); 29967a229387SArnd Bergmann if (put_user(datap, &sioc->arg)) 29977a229387SArnd Bergmann return -EFAULT; 29987a229387SArnd Bergmann 29996b96018bSArnd Bergmann err = sock_do_ioctl(net, sock, cmd, (unsigned long) sioc); 30007a229387SArnd Bergmann 30017a229387SArnd Bergmann if (!err) { 30027a229387SArnd Bergmann if (copy_in_user(&sioc32->length, &sioc->length, 30037a229387SArnd Bergmann sizeof(int))) 30047a229387SArnd Bergmann err = -EFAULT; 30057a229387SArnd Bergmann } 30067a229387SArnd Bergmann return err; 30077a229387SArnd Bergmann } 30087a229387SArnd Bergmann 30096b96018bSArnd Bergmann static int do_atm_ioctl(struct net *net, struct socket *sock, 30106b96018bSArnd Bergmann unsigned int cmd32, unsigned long arg) 30117a229387SArnd Bergmann { 30127a229387SArnd Bergmann int i; 30137a229387SArnd Bergmann unsigned int cmd = 0; 30147a229387SArnd Bergmann 30157a229387SArnd Bergmann switch (cmd32) { 30167a229387SArnd Bergmann case SONET_GETSTAT: 30177a229387SArnd Bergmann case SONET_GETSTATZ: 30187a229387SArnd Bergmann case SONET_GETDIAG: 30197a229387SArnd Bergmann case SONET_SETDIAG: 30207a229387SArnd Bergmann case SONET_CLRDIAG: 30217a229387SArnd Bergmann case SONET_SETFRAMING: 30227a229387SArnd Bergmann case SONET_GETFRAMING: 30237a229387SArnd Bergmann case SONET_GETFRSENSE: 30246b96018bSArnd Bergmann return do_atmif_sioc(net, sock, cmd32, arg); 30257a229387SArnd Bergmann } 30267a229387SArnd Bergmann 30277a229387SArnd Bergmann for (i = 0; i < NR_ATM_IOCTL; i++) { 30287a229387SArnd Bergmann if (cmd32 == atm_ioctl_map[i].cmd32) { 30297a229387SArnd Bergmann cmd = atm_ioctl_map[i].cmd; 30307a229387SArnd Bergmann break; 30317a229387SArnd Bergmann } 30327a229387SArnd Bergmann } 30337a229387SArnd Bergmann if (i == NR_ATM_IOCTL) 30347a229387SArnd Bergmann return -EINVAL; 30357a229387SArnd Bergmann 30367a229387SArnd Bergmann switch (cmd) { 30377a229387SArnd Bergmann case ATM_GETNAMES: 30386b96018bSArnd Bergmann return do_atm_iobuf(net, sock, cmd, arg); 30397a229387SArnd Bergmann 30407a229387SArnd Bergmann case ATM_GETLINKRATE: 30417a229387SArnd Bergmann case ATM_GETTYPE: 30427a229387SArnd Bergmann case ATM_GETESI: 30437a229387SArnd Bergmann case ATM_GETADDR: 30447a229387SArnd Bergmann case ATM_RSTADDR: 30457a229387SArnd Bergmann case ATM_ADDADDR: 30467a229387SArnd Bergmann case ATM_DELADDR: 30477a229387SArnd Bergmann case ATM_GETCIRANGE: 30487a229387SArnd Bergmann case ATM_SETCIRANGE: 30497a229387SArnd Bergmann case ATM_SETESI: 30507a229387SArnd Bergmann case ATM_SETESIF: 30517a229387SArnd Bergmann case ATM_GETSTAT: 30527a229387SArnd Bergmann case ATM_GETSTATZ: 30537a229387SArnd Bergmann case ATM_GETLOOP: 30547a229387SArnd Bergmann case ATM_SETLOOP: 30557a229387SArnd Bergmann case ATM_QUERYLOOP: 30566b96018bSArnd Bergmann return do_atmif_sioc(net, sock, cmd, arg); 30577a229387SArnd Bergmann } 30587a229387SArnd Bergmann 30597a229387SArnd Bergmann return -EINVAL; 30607a229387SArnd Bergmann } 30617a229387SArnd Bergmann 30626b96018bSArnd Bergmann static int compat_sock_ioctl_trans(struct file *file, struct socket *sock, 30636b96018bSArnd Bergmann unsigned int cmd, unsigned long arg) 30646b96018bSArnd Bergmann { 30656b96018bSArnd Bergmann void __user *argp = compat_ptr(arg); 30666b96018bSArnd Bergmann struct sock *sk = sock->sk; 30676b96018bSArnd Bergmann struct net *net = sock_net(sk); 30687a229387SArnd Bergmann 30696b96018bSArnd Bergmann if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) 30706b96018bSArnd Bergmann return siocdevprivate_ioctl(net, cmd, argp); 30717a229387SArnd Bergmann 30726b96018bSArnd Bergmann switch (cmd) { 30736b96018bSArnd Bergmann case SIOCSIFBR: 30746b96018bSArnd Bergmann case SIOCGIFBR: 30756b96018bSArnd Bergmann return old_bridge_ioctl(argp); 30766b96018bSArnd Bergmann case SIOCGIFNAME: 30776b96018bSArnd Bergmann return dev_ifname32(net, argp); 30786b96018bSArnd Bergmann case SIOCGIFCONF: 30796b96018bSArnd Bergmann return dev_ifconf(net, argp); 30806b96018bSArnd Bergmann case SIOCETHTOOL: 30816b96018bSArnd Bergmann return ethtool_ioctl(net, argp); 3082*7a50a240SArnd Bergmann case SIOCWANDEV: 3083*7a50a240SArnd Bergmann return compat_siocwandev(net, argp); 30846b96018bSArnd Bergmann case SIOCBONDENSLAVE: 30856b96018bSArnd Bergmann case SIOCBONDRELEASE: 30866b96018bSArnd Bergmann case SIOCBONDSETHWADDR: 30876b96018bSArnd Bergmann case SIOCBONDSLAVEINFOQUERY: 30886b96018bSArnd Bergmann case SIOCBONDINFOQUERY: 30896b96018bSArnd Bergmann case SIOCBONDCHANGEACTIVE: 30906b96018bSArnd Bergmann return bond_ioctl(net, cmd, argp); 30916b96018bSArnd Bergmann case SIOCADDRT: 30926b96018bSArnd Bergmann case SIOCDELRT: 30936b96018bSArnd Bergmann return routing_ioctl(net, sock, cmd, argp); 30946b96018bSArnd Bergmann case SIOCGSTAMP: 30956b96018bSArnd Bergmann return do_siocgstamp(net, sock, cmd, argp); 30966b96018bSArnd Bergmann case SIOCGSTAMPNS: 30976b96018bSArnd Bergmann return do_siocgstampns(net, sock, cmd, argp); 30987a229387SArnd Bergmann 30996b96018bSArnd Bergmann case FIOSETOWN: 31006b96018bSArnd Bergmann case SIOCSPGRP: 31016b96018bSArnd Bergmann case FIOGETOWN: 31026b96018bSArnd Bergmann case SIOCGPGRP: 31036b96018bSArnd Bergmann case SIOCBRADDBR: 31046b96018bSArnd Bergmann case SIOCBRDELBR: 31056b96018bSArnd Bergmann case SIOCGIFVLAN: 31066b96018bSArnd Bergmann case SIOCSIFVLAN: 31076b96018bSArnd Bergmann case SIOCADDDLCI: 31086b96018bSArnd Bergmann case SIOCDELDLCI: 31096b96018bSArnd Bergmann return sock_ioctl(file, cmd, arg); 31106b96018bSArnd Bergmann 31116b96018bSArnd Bergmann case SIOCGIFFLAGS: 31126b96018bSArnd Bergmann case SIOCSIFFLAGS: 31136b96018bSArnd Bergmann case SIOCGIFMETRIC: 31146b96018bSArnd Bergmann case SIOCSIFMETRIC: 31156b96018bSArnd Bergmann case SIOCGIFMTU: 31166b96018bSArnd Bergmann case SIOCSIFMTU: 31176b96018bSArnd Bergmann case SIOCGIFMEM: 31186b96018bSArnd Bergmann case SIOCSIFMEM: 31196b96018bSArnd Bergmann case SIOCGIFHWADDR: 31206b96018bSArnd Bergmann case SIOCSIFHWADDR: 31216b96018bSArnd Bergmann case SIOCADDMULTI: 31226b96018bSArnd Bergmann case SIOCDELMULTI: 31236b96018bSArnd Bergmann case SIOCGIFINDEX: 31246b96018bSArnd Bergmann case SIOCGIFMAP: 31256b96018bSArnd Bergmann case SIOCSIFMAP: 31266b96018bSArnd Bergmann case SIOCGIFADDR: 31276b96018bSArnd Bergmann case SIOCSIFADDR: 31286b96018bSArnd Bergmann case SIOCSIFHWBROADCAST: 31296b96018bSArnd Bergmann case SIOCSHWTSTAMP: 31306b96018bSArnd Bergmann case SIOCDIFADDR: 31316b96018bSArnd Bergmann case SIOCGIFBRDADDR: 31326b96018bSArnd Bergmann case SIOCSIFBRDADDR: 31336b96018bSArnd Bergmann case SIOCGIFDSTADDR: 31346b96018bSArnd Bergmann case SIOCSIFDSTADDR: 31356b96018bSArnd Bergmann case SIOCGIFNETMASK: 31366b96018bSArnd Bergmann case SIOCSIFNETMASK: 31376b96018bSArnd Bergmann case SIOCSIFPFLAGS: 31386b96018bSArnd Bergmann case SIOCGIFPFLAGS: 31396b96018bSArnd Bergmann case SIOCGIFTXQLEN: 31406b96018bSArnd Bergmann case SIOCSIFTXQLEN: 31416b96018bSArnd Bergmann case SIOCBRADDIF: 31426b96018bSArnd Bergmann case SIOCBRDELIF: 31439177efd3SArnd Bergmann case SIOCSIFNAME: 31449177efd3SArnd Bergmann case SIOCGMIIPHY: 31459177efd3SArnd Bergmann case SIOCGMIIREG: 31469177efd3SArnd Bergmann case SIOCSMIIREG: 31476b96018bSArnd Bergmann return dev_ifsioc(net, sock, cmd, argp); 31489177efd3SArnd Bergmann 31496b96018bSArnd Bergmann case ATM_GETLINKRATE32: 31506b96018bSArnd Bergmann case ATM_GETNAMES32: 31516b96018bSArnd Bergmann case ATM_GETTYPE32: 31526b96018bSArnd Bergmann case ATM_GETESI32: 31536b96018bSArnd Bergmann case ATM_GETADDR32: 31546b96018bSArnd Bergmann case ATM_RSTADDR32: 31556b96018bSArnd Bergmann case ATM_ADDADDR32: 31566b96018bSArnd Bergmann case ATM_DELADDR32: 31576b96018bSArnd Bergmann case ATM_GETCIRANGE32: 31586b96018bSArnd Bergmann case ATM_SETCIRANGE32: 31596b96018bSArnd Bergmann case ATM_SETESI32: 31606b96018bSArnd Bergmann case ATM_SETESIF32: 31616b96018bSArnd Bergmann case ATM_GETSTAT32: 31626b96018bSArnd Bergmann case ATM_GETSTATZ32: 31636b96018bSArnd Bergmann case ATM_GETLOOP32: 31646b96018bSArnd Bergmann case ATM_SETLOOP32: 31656b96018bSArnd Bergmann case ATM_QUERYLOOP32: 31666b96018bSArnd Bergmann case SONET_GETSTAT: 31676b96018bSArnd Bergmann case SONET_GETSTATZ: 31686b96018bSArnd Bergmann case SONET_GETDIAG: 31696b96018bSArnd Bergmann case SONET_SETDIAG: 31706b96018bSArnd Bergmann case SONET_CLRDIAG: 31716b96018bSArnd Bergmann case SONET_SETFRAMING: 31726b96018bSArnd Bergmann case SONET_GETFRAMING: 31736b96018bSArnd Bergmann case SONET_GETFRSENSE: 31746b96018bSArnd Bergmann return do_atm_ioctl(net, sock, cmd, arg); 31756b96018bSArnd Bergmann 31766b96018bSArnd Bergmann case ATMSIGD_CTRL: 31776b96018bSArnd Bergmann case ATMARPD_CTRL: 31786b96018bSArnd Bergmann case ATMLEC_CTRL: 31796b96018bSArnd Bergmann case ATMLEC_MCAST: 31806b96018bSArnd Bergmann case ATMLEC_DATA: 31816b96018bSArnd Bergmann case ATM_SETSC: 31826b96018bSArnd Bergmann case SIOCSIFATMTCP: 31836b96018bSArnd Bergmann case SIOCMKCLIP: 31846b96018bSArnd Bergmann case ATMARP_MKIP: 31856b96018bSArnd Bergmann case ATMARP_SETENTRY: 31866b96018bSArnd Bergmann case ATMARP_ENCAP: 31876b96018bSArnd Bergmann case ATMTCP_CREATE: 31886b96018bSArnd Bergmann case ATMTCP_REMOVE: 31896b96018bSArnd Bergmann case ATMMPC_CTRL: 31906b96018bSArnd Bergmann case ATMMPC_DATA: 31916b96018bSArnd Bergmann 31926b96018bSArnd Bergmann case SIOCSARP: 31936b96018bSArnd Bergmann case SIOCGARP: 31946b96018bSArnd Bergmann case SIOCDARP: 31956b96018bSArnd Bergmann case SIOCATMARK: 31969177efd3SArnd Bergmann return sock_do_ioctl(net, sock, cmd, arg); 31979177efd3SArnd Bergmann } 31989177efd3SArnd Bergmann 31999177efd3SArnd Bergmann /* Prevent warning from compat_sys_ioctl, these always 32009177efd3SArnd Bergmann * result in -EINVAL in the native case anyway. */ 32019177efd3SArnd Bergmann switch (cmd) { 32029177efd3SArnd Bergmann case SIOCRTMSG: 32039177efd3SArnd Bergmann case SIOCGIFCOUNT: 32046b96018bSArnd Bergmann case SIOCSRARP: 32056b96018bSArnd Bergmann case SIOCGRARP: 32066b96018bSArnd Bergmann case SIOCDRARP: 32079177efd3SArnd Bergmann case SIOCSIFLINK: 32089177efd3SArnd Bergmann case SIOCGIFSLAVE: 32099177efd3SArnd Bergmann case SIOCSIFSLAVE: 32109177efd3SArnd Bergmann return -EINVAL; 32116b96018bSArnd Bergmann } 32126b96018bSArnd Bergmann 32136b96018bSArnd Bergmann return -ENOIOCTLCMD; 32146b96018bSArnd Bergmann } 32157a229387SArnd Bergmann 321689bbfc95SShaun Pereira static long compat_sock_ioctl(struct file *file, unsigned cmd, 321789bbfc95SShaun Pereira unsigned long arg) 321889bbfc95SShaun Pereira { 321989bbfc95SShaun Pereira struct socket *sock = file->private_data; 322089bbfc95SShaun Pereira int ret = -ENOIOCTLCMD; 322187de87d5SDavid S. Miller struct sock *sk; 322287de87d5SDavid S. Miller struct net *net; 322387de87d5SDavid S. Miller 322487de87d5SDavid S. Miller sk = sock->sk; 322587de87d5SDavid S. Miller net = sock_net(sk); 322689bbfc95SShaun Pereira 322789bbfc95SShaun Pereira if (sock->ops->compat_ioctl) 322889bbfc95SShaun Pereira ret = sock->ops->compat_ioctl(sock, cmd, arg); 322989bbfc95SShaun Pereira 323087de87d5SDavid S. Miller if (ret == -ENOIOCTLCMD && 323187de87d5SDavid S. Miller (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST)) 323287de87d5SDavid S. Miller ret = compat_wext_handle_ioctl(net, cmd, arg); 323387de87d5SDavid S. Miller 32346b96018bSArnd Bergmann if (ret == -ENOIOCTLCMD) 32356b96018bSArnd Bergmann ret = compat_sock_ioctl_trans(file, sock, cmd, arg); 32366b96018bSArnd Bergmann 323789bbfc95SShaun Pereira return ret; 323889bbfc95SShaun Pereira } 323989bbfc95SShaun Pereira #endif 324089bbfc95SShaun Pereira 3241ac5a488eSSridhar Samudrala int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen) 3242ac5a488eSSridhar Samudrala { 3243ac5a488eSSridhar Samudrala return sock->ops->bind(sock, addr, addrlen); 3244ac5a488eSSridhar Samudrala } 3245ac5a488eSSridhar Samudrala 3246ac5a488eSSridhar Samudrala int kernel_listen(struct socket *sock, int backlog) 3247ac5a488eSSridhar Samudrala { 3248ac5a488eSSridhar Samudrala return sock->ops->listen(sock, backlog); 3249ac5a488eSSridhar Samudrala } 3250ac5a488eSSridhar Samudrala 3251ac5a488eSSridhar Samudrala int kernel_accept(struct socket *sock, struct socket **newsock, int flags) 3252ac5a488eSSridhar Samudrala { 3253ac5a488eSSridhar Samudrala struct sock *sk = sock->sk; 3254ac5a488eSSridhar Samudrala int err; 3255ac5a488eSSridhar Samudrala 3256ac5a488eSSridhar Samudrala err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol, 3257ac5a488eSSridhar Samudrala newsock); 3258ac5a488eSSridhar Samudrala if (err < 0) 3259ac5a488eSSridhar Samudrala goto done; 3260ac5a488eSSridhar Samudrala 3261ac5a488eSSridhar Samudrala err = sock->ops->accept(sock, *newsock, flags); 3262ac5a488eSSridhar Samudrala if (err < 0) { 3263ac5a488eSSridhar Samudrala sock_release(*newsock); 3264fa8705b0STony Battersby *newsock = NULL; 3265ac5a488eSSridhar Samudrala goto done; 3266ac5a488eSSridhar Samudrala } 3267ac5a488eSSridhar Samudrala 3268ac5a488eSSridhar Samudrala (*newsock)->ops = sock->ops; 32691b08534eSWei Yongjun __module_get((*newsock)->ops->owner); 3270ac5a488eSSridhar Samudrala 3271ac5a488eSSridhar Samudrala done: 3272ac5a488eSSridhar Samudrala return err; 3273ac5a488eSSridhar Samudrala } 3274ac5a488eSSridhar Samudrala 3275ac5a488eSSridhar Samudrala int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen, 3276ac5a488eSSridhar Samudrala int flags) 3277ac5a488eSSridhar Samudrala { 3278ac5a488eSSridhar Samudrala return sock->ops->connect(sock, addr, addrlen, flags); 3279ac5a488eSSridhar Samudrala } 3280ac5a488eSSridhar Samudrala 3281ac5a488eSSridhar Samudrala int kernel_getsockname(struct socket *sock, struct sockaddr *addr, 3282ac5a488eSSridhar Samudrala int *addrlen) 3283ac5a488eSSridhar Samudrala { 3284ac5a488eSSridhar Samudrala return sock->ops->getname(sock, addr, addrlen, 0); 3285ac5a488eSSridhar Samudrala } 3286ac5a488eSSridhar Samudrala 3287ac5a488eSSridhar Samudrala int kernel_getpeername(struct socket *sock, struct sockaddr *addr, 3288ac5a488eSSridhar Samudrala int *addrlen) 3289ac5a488eSSridhar Samudrala { 3290ac5a488eSSridhar Samudrala return sock->ops->getname(sock, addr, addrlen, 1); 3291ac5a488eSSridhar Samudrala } 3292ac5a488eSSridhar Samudrala 3293ac5a488eSSridhar Samudrala int kernel_getsockopt(struct socket *sock, int level, int optname, 3294ac5a488eSSridhar Samudrala char *optval, int *optlen) 3295ac5a488eSSridhar Samudrala { 3296ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 3297ac5a488eSSridhar Samudrala int err; 3298ac5a488eSSridhar Samudrala 3299ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 3300ac5a488eSSridhar Samudrala if (level == SOL_SOCKET) 3301ac5a488eSSridhar Samudrala err = sock_getsockopt(sock, level, optname, optval, optlen); 3302ac5a488eSSridhar Samudrala else 3303ac5a488eSSridhar Samudrala err = sock->ops->getsockopt(sock, level, optname, optval, 3304ac5a488eSSridhar Samudrala optlen); 3305ac5a488eSSridhar Samudrala set_fs(oldfs); 3306ac5a488eSSridhar Samudrala return err; 3307ac5a488eSSridhar Samudrala } 3308ac5a488eSSridhar Samudrala 3309ac5a488eSSridhar Samudrala int kernel_setsockopt(struct socket *sock, int level, int optname, 3310b7058842SDavid S. Miller char *optval, unsigned int optlen) 3311ac5a488eSSridhar Samudrala { 3312ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 3313ac5a488eSSridhar Samudrala int err; 3314ac5a488eSSridhar Samudrala 3315ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 3316ac5a488eSSridhar Samudrala if (level == SOL_SOCKET) 3317ac5a488eSSridhar Samudrala err = sock_setsockopt(sock, level, optname, optval, optlen); 3318ac5a488eSSridhar Samudrala else 3319ac5a488eSSridhar Samudrala err = sock->ops->setsockopt(sock, level, optname, optval, 3320ac5a488eSSridhar Samudrala optlen); 3321ac5a488eSSridhar Samudrala set_fs(oldfs); 3322ac5a488eSSridhar Samudrala return err; 3323ac5a488eSSridhar Samudrala } 3324ac5a488eSSridhar Samudrala 3325ac5a488eSSridhar Samudrala int kernel_sendpage(struct socket *sock, struct page *page, int offset, 3326ac5a488eSSridhar Samudrala size_t size, int flags) 3327ac5a488eSSridhar Samudrala { 3328ac5a488eSSridhar Samudrala if (sock->ops->sendpage) 3329ac5a488eSSridhar Samudrala return sock->ops->sendpage(sock, page, offset, size, flags); 3330ac5a488eSSridhar Samudrala 3331ac5a488eSSridhar Samudrala return sock_no_sendpage(sock, page, offset, size, flags); 3332ac5a488eSSridhar Samudrala } 3333ac5a488eSSridhar Samudrala 3334ac5a488eSSridhar Samudrala int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg) 3335ac5a488eSSridhar Samudrala { 3336ac5a488eSSridhar Samudrala mm_segment_t oldfs = get_fs(); 3337ac5a488eSSridhar Samudrala int err; 3338ac5a488eSSridhar Samudrala 3339ac5a488eSSridhar Samudrala set_fs(KERNEL_DS); 3340ac5a488eSSridhar Samudrala err = sock->ops->ioctl(sock, cmd, arg); 3341ac5a488eSSridhar Samudrala set_fs(oldfs); 3342ac5a488eSSridhar Samudrala 3343ac5a488eSSridhar Samudrala return err; 3344ac5a488eSSridhar Samudrala } 3345ac5a488eSSridhar Samudrala 334691cf45f0STrond Myklebust int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how) 334791cf45f0STrond Myklebust { 334891cf45f0STrond Myklebust return sock->ops->shutdown(sock, how); 334991cf45f0STrond Myklebust } 335091cf45f0STrond Myklebust 33511da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create); 33521da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create_kern); 33531da177e4SLinus Torvalds EXPORT_SYMBOL(sock_create_lite); 33541da177e4SLinus Torvalds EXPORT_SYMBOL(sock_map_fd); 33551da177e4SLinus Torvalds EXPORT_SYMBOL(sock_recvmsg); 33561da177e4SLinus Torvalds EXPORT_SYMBOL(sock_register); 33571da177e4SLinus Torvalds EXPORT_SYMBOL(sock_release); 33581da177e4SLinus Torvalds EXPORT_SYMBOL(sock_sendmsg); 33591da177e4SLinus Torvalds EXPORT_SYMBOL(sock_unregister); 33601da177e4SLinus Torvalds EXPORT_SYMBOL(sock_wake_async); 33611da177e4SLinus Torvalds EXPORT_SYMBOL(sockfd_lookup); 33621da177e4SLinus Torvalds EXPORT_SYMBOL(kernel_sendmsg); 33631da177e4SLinus Torvalds EXPORT_SYMBOL(kernel_recvmsg); 3364ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_bind); 3365ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_listen); 3366ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_accept); 3367ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_connect); 3368ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getsockname); 3369ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getpeername); 3370ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_getsockopt); 3371ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_setsockopt); 3372ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_sendpage); 3373ac5a488eSSridhar Samudrala EXPORT_SYMBOL(kernel_sock_ioctl); 337491cf45f0STrond Myklebust EXPORT_SYMBOL(kernel_sock_shutdown); 3375