linux/net/socket.c
<<
>>
Prefs
   1/*
   2 * NET          An implementation of the SOCKET network access protocol.
   3 *
   4 * Version:     @(#)socket.c    1.1.93  18/02/95
   5 *
   6 * Authors:     Orest Zborowski, <obz@Kodak.COM>
   7 *              Ross Biro
   8 *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
   9 *
  10 * Fixes:
  11 *              Anonymous       :       NOTSOCK/BADF cleanup. Error fix in
  12 *                                      shutdown()
  13 *              Alan Cox        :       verify_area() fixes
  14 *              Alan Cox        :       Removed DDI
  15 *              Jonathan Kamens :       SOCK_DGRAM reconnect bug
  16 *              Alan Cox        :       Moved a load of checks to the very
  17 *                                      top level.
  18 *              Alan Cox        :       Move address structures to/from user
  19 *                                      mode above the protocol layers.
  20 *              Rob Janssen     :       Allow 0 length sends.
  21 *              Alan Cox        :       Asynchronous I/O support (cribbed from the
  22 *                                      tty drivers).
  23 *              Niibe Yutaka    :       Asynchronous I/O for writes (4.4BSD style)
  24 *              Jeff Uphoff     :       Made max number of sockets command-line
  25 *                                      configurable.
  26 *              Matti Aarnio    :       Made the number of sockets dynamic,
  27 *                                      to be allocated when needed, and mr.
  28 *                                      Uphoff's max is used as max to be
  29 *                                      allowed to allocate.
  30 *              Linus           :       Argh. removed all the socket allocation
  31 *                                      altogether: it's in the inode now.
  32 *              Alan Cox        :       Made sock_alloc()/sock_release() public
  33 *                                      for NetROM and future kernel nfsd type
  34 *                                      stuff.
  35 *              Alan Cox        :       sendmsg/recvmsg basics.
  36 *              Tom Dyas        :       Export net symbols.
  37 *              Marcin Dalecki  :       Fixed problems with CONFIG_NET="n".
  38 *              Alan Cox        :       Added thread locking to sys_* calls
  39 *                                      for sockets. May have errors at the
  40 *                                      moment.
  41 *              Kevin Buhr      :       Fixed the dumb errors in the above.
  42 *              Andi Kleen      :       Some small cleanups, optimizations,
  43 *                                      and fixed a copy_from_user() bug.
  44 *              Tigran Aivazian :       sys_send(args) calls sys_sendto(args, NULL, 0)
  45 *              Tigran Aivazian :       Made listen(2) backlog sanity checks
  46 *                                      protocol-independent
  47 *
  48 *
  49 *              This program is free software; you can redistribute it and/or
  50 *              modify it under the terms of the GNU General Public License
  51 *              as published by the Free Software Foundation; either version
  52 *              2 of the License, or (at your option) any later version.
  53 *
  54 *
  55 *      This module is effectively the top level interface to the BSD socket
  56 *      paradigm.
  57 *
  58 *      Based upon Swansea University Computer Society NET3.039
  59 */
  60
  61#include <linux/mm.h>
  62#include <linux/socket.h>
  63#include <linux/file.h>
  64#include <linux/net.h>
  65#include <linux/interrupt.h>
  66#include <linux/thread_info.h>
  67#include <linux/rcupdate.h>
  68#include <linux/netdevice.h>
  69#include <linux/proc_fs.h>
  70#include <linux/seq_file.h>
  71#include <linux/mutex.h>
  72#include <linux/thread_info.h>
  73#include <linux/wanrouter.h>
  74#include <linux/if_bridge.h>
  75#include <linux/if_frad.h>
  76#include <linux/if_vlan.h>
  77#include <linux/init.h>
  78#include <linux/poll.h>
  79#include <linux/cache.h>
  80#include <linux/module.h>
  81#include <linux/highmem.h>
  82#include <linux/mount.h>
  83#include <linux/security.h>
  84#include <linux/syscalls.h>
  85#include <linux/compat.h>
  86#include <linux/kmod.h>
  87#include <linux/audit.h>
  88#include <linux/wireless.h>
  89#include <linux/nsproxy.h>
  90
  91#include <asm/uaccess.h>
  92#include <asm/unistd.h>
  93
  94#include <net/compat.h>
  95#include <net/wext.h>
  96
  97#include <net/sock.h>
  98#include <linux/netfilter.h>
  99
 100static int sock_no_open(struct inode *irrelevant, struct file *dontcare);
 101static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov,
 102                         unsigned long nr_segs, loff_t pos);
 103static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov,
 104                          unsigned long nr_segs, loff_t pos);
 105static int sock_mmap(struct file *file, struct vm_area_struct *vma);
 106
 107static int sock_close(struct inode *inode, struct file *file);
 108static unsigned int sock_poll(struct file *file,
 109                              struct poll_table_struct *wait);
 110static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
 111#ifdef CONFIG_COMPAT
 112static long compat_sock_ioctl(struct file *file,
 113                              unsigned int cmd, unsigned long arg);
 114#endif
 115static int sock_fasync(int fd, struct file *filp, int on);
 116static ssize_t sock_sendpage(struct file *file, struct page *page,
 117                             int offset, size_t size, loff_t *ppos, int more);
 118static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
 119                                struct pipe_inode_info *pipe, size_t len,
 120                                unsigned int flags);
 121
 122/*
 123 *      Socket files have a set of 'special' operations as well as the generic file ones. These don't appear
 124 *      in the operation structures but are done directly via the socketcall() multiplexor.
 125 */
 126
 127static const struct file_operations socket_file_ops = {
 128        .owner =        THIS_MODULE,
 129        .llseek =       no_llseek,
 130        .aio_read =     sock_aio_read,
 131        .aio_write =    sock_aio_write,
 132        .poll =         sock_poll,
 133        .unlocked_ioctl = sock_ioctl,
 134#ifdef CONFIG_COMPAT
 135        .compat_ioctl = compat_sock_ioctl,
 136#endif
 137        .mmap =         sock_mmap,
 138        .open =         sock_no_open,   /* special open code to disallow open via /proc */
 139        .release =      sock_close,
 140        .fasync =       sock_fasync,
 141        .sendpage =     sock_sendpage,
 142        .splice_write = generic_splice_sendpage,
 143        .splice_read =  sock_splice_read,
 144};
 145
 146/*
 147 *      The protocol list. Each protocol is registered in here.
 148 */
 149
 150static DEFINE_SPINLOCK(net_family_lock);
 151static const struct net_proto_family *net_families[NPROTO] __read_mostly;
 152
 153/*
 154 *      Statistics counters of the socket lists
 155 */
 156
 157static DEFINE_PER_CPU(int, sockets_in_use) = 0;
 158
 159/*
 160 * Support routines.
 161 * Move socket addresses back and forth across the kernel/user
 162 * divide and look after the messy bits.
 163 */
 164
 165#define MAX_SOCK_ADDR   128             /* 108 for Unix domain -
 166                                           16 for IP, 16 for IPX,
 167                                           24 for IPv6,
 168                                           about 80 for AX.25
 169                                           must be at least one bigger than
 170                                           the AF_UNIX size (see net/unix/af_unix.c
 171                                           :unix_mkname()).
 172                                         */
 173
 174/**
 175 *      move_addr_to_kernel     -       copy a socket address into kernel space
 176 *      @uaddr: Address in user space
 177 *      @kaddr: Address in kernel space
 178 *      @ulen: Length in user space
 179 *
 180 *      The address is copied into kernel space. If the provided address is
 181 *      too long an error code of -EINVAL is returned. If the copy gives
 182 *      invalid addresses -EFAULT is returned. On a success 0 is returned.
 183 */
 184
 185int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr *kaddr)
 186{
 187        if (ulen < 0 || ulen > sizeof(struct sockaddr_storage))
 188                return -EINVAL;
 189        if (ulen == 0)
 190                return 0;
 191        if (copy_from_user(kaddr, uaddr, ulen))
 192                return -EFAULT;
 193        return audit_sockaddr(ulen, kaddr);
 194}
 195
 196/**
 197 *      move_addr_to_user       -       copy an address to user space
 198 *      @kaddr: kernel space address
 199 *      @klen: length of address in kernel
 200 *      @uaddr: user space address
 201 *      @ulen: pointer to user length field
 202 *
 203 *      The value pointed to by ulen on entry is the buffer length available.
 204 *      This is overwritten with the buffer space used. -EINVAL is returned
 205 *      if an overlong buffer is specified or a negative buffer size. -EFAULT
 206 *      is returned if either the buffer or the length field are not
 207 *      accessible.
 208 *      After copying the data up to the limit the user specifies, the true
 209 *      length of the data is written over the length limit the user
 210 *      specified. Zero is returned for a success.
 211 */
 212
 213int move_addr_to_user(struct sockaddr *kaddr, int klen, void __user *uaddr,
 214                      int __user *ulen)
 215{
 216        int err;
 217        int len;
 218
 219        err = get_user(len, ulen);
 220        if (err)
 221                return err;
 222        if (len > klen)
 223                len = klen;
 224        if (len < 0 || len > sizeof(struct sockaddr_storage))
 225                return -EINVAL;
 226        if (len) {
 227                if (audit_sockaddr(klen, kaddr))
 228                        return -ENOMEM;
 229                if (copy_to_user(uaddr, kaddr, len))
 230                        return -EFAULT;
 231        }
 232        /*
 233         *      "fromlen shall refer to the value before truncation.."
 234         *                      1003.1g
 235         */
 236        return __put_user(klen, ulen);
 237}
 238
 239#define SOCKFS_MAGIC 0x534F434B
 240
 241static struct kmem_cache *sock_inode_cachep __read_mostly;
 242
 243static struct inode *sock_alloc_inode(struct super_block *sb)
 244{
 245        struct socket_alloc *ei;
 246
 247        ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL);
 248        if (!ei)
 249                return NULL;
 250        init_waitqueue_head(&ei->socket.wait);
 251
 252        ei->socket.fasync_list = NULL;
 253        ei->socket.state = SS_UNCONNECTED;
 254        ei->socket.flags = 0;
 255        ei->socket.ops = NULL;
 256        ei->socket.sk = NULL;
 257        ei->socket.file = NULL;
 258
 259        return &ei->vfs_inode;
 260}
 261
 262static void sock_destroy_inode(struct inode *inode)
 263{
 264        kmem_cache_free(sock_inode_cachep,
 265                        container_of(inode, struct socket_alloc, vfs_inode));
 266}
 267
 268static void init_once(void *foo)
 269{
 270        struct socket_alloc *ei = (struct socket_alloc *)foo;
 271
 272        inode_init_once(&ei->vfs_inode);
 273}
 274
 275static int init_inodecache(void)
 276{
 277        sock_inode_cachep = kmem_cache_create("sock_inode_cache",
 278                                              sizeof(struct socket_alloc),
 279                                              0,
 280                                              (SLAB_HWCACHE_ALIGN |
 281                                               SLAB_RECLAIM_ACCOUNT |
 282                                               SLAB_MEM_SPREAD),
 283                                              init_once);
 284        if (sock_inode_cachep == NULL)
 285                return -ENOMEM;
 286        return 0;
 287}
 288
 289static struct super_operations sockfs_ops = {
 290        .alloc_inode =  sock_alloc_inode,
 291        .destroy_inode =sock_destroy_inode,
 292        .statfs =       simple_statfs,
 293};
 294
 295static int sockfs_get_sb(struct file_system_type *fs_type,
 296                         int flags, const char *dev_name, void *data,
 297                         struct vfsmount *mnt)
 298{
 299        return get_sb_pseudo(fs_type, "socket:", &sockfs_ops, SOCKFS_MAGIC,
 300                             mnt);
 301}
 302
 303static struct vfsmount *sock_mnt __read_mostly;
 304
 305static struct file_system_type sock_fs_type = {
 306        .name =         "sockfs",
 307        .get_sb =       sockfs_get_sb,
 308        .kill_sb =      kill_anon_super,
 309};
 310
 311static int sockfs_delete_dentry(struct dentry *dentry)
 312{
 313        /*
 314         * At creation time, we pretended this dentry was hashed
 315         * (by clearing DCACHE_UNHASHED bit in d_flags)
 316         * At delete time, we restore the truth : not hashed.
 317         * (so that dput() can proceed correctly)
 318         */
 319        dentry->d_flags |= DCACHE_UNHASHED;
 320        return 0;
 321}
 322
 323/*
 324 * sockfs_dname() is called from d_path().
 325 */
 326static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen)
 327{
 328        return dynamic_dname(dentry, buffer, buflen, "socket:[%lu]",
 329                                dentry->d_inode->i_ino);
 330}
 331
 332static struct dentry_operations sockfs_dentry_operations = {
 333        .d_delete = sockfs_delete_dentry,
 334        .d_dname  = sockfs_dname,
 335};
 336
 337/*
 338 *      Obtains the first available file descriptor and sets it up for use.
 339 *
 340 *      These functions create file structures and maps them to fd space
 341 *      of the current process. On success it returns file descriptor
 342 *      and file struct implicitly stored in sock->file.
 343 *      Note that another thread may close file descriptor before we return
 344 *      from this function. We use the fact that now we do not refer
 345 *      to socket after mapping. If one day we will need it, this
 346 *      function will increment ref. count on file by 1.
 347 *
 348 *      In any case returned fd MAY BE not valid!
 349 *      This race condition is unavoidable
 350 *      with shared fd spaces, we cannot solve it inside kernel,
 351 *      but we take care of internal coherence yet.
 352 */
 353
 354static int sock_alloc_fd(struct file **filep, int flags)
 355{
 356        int fd;
 357
 358        fd = get_unused_fd_flags(flags);
 359        if (likely(fd >= 0)) {
 360                struct file *file = get_empty_filp();
 361
 362                *filep = file;
 363                if (unlikely(!file)) {
 364                        put_unused_fd(fd);
 365                        return -ENFILE;
 366                }
 367        } else
 368                *filep = NULL;
 369        return fd;
 370}
 371
 372static int sock_attach_fd(struct socket *sock, struct file *file, int flags)
 373{
 374        struct dentry *dentry;
 375        struct qstr name = { .name = "" };
 376
 377        dentry = d_alloc(sock_mnt->mnt_sb->s_root, &name);
 378        if (unlikely(!dentry))
 379                return -ENOMEM;
 380
 381        dentry->d_op = &sockfs_dentry_operations;
 382        /*
 383         * We dont want to push this dentry into global dentry hash table.
 384         * We pretend dentry is already hashed, by unsetting DCACHE_UNHASHED
 385         * This permits a working /proc/$pid/fd/XXX on sockets
 386         */
 387        dentry->d_flags &= ~DCACHE_UNHASHED;
 388        d_instantiate(dentry, SOCK_INODE(sock));
 389
 390        sock->file = file;
 391        init_file(file, sock_mnt, dentry, FMODE_READ | FMODE_WRITE,
 392                  &socket_file_ops);
 393        SOCK_INODE(sock)->i_fop = &socket_file_ops;
 394        file->f_flags = O_RDWR | (flags & O_NONBLOCK);
 395        file->f_pos = 0;
 396        file->private_data = sock;
 397
 398        return 0;
 399}
 400
 401int sock_map_fd(struct socket *sock, int flags)
 402{
 403        struct file *newfile;
 404        int fd = sock_alloc_fd(&newfile, flags);
 405
 406        if (likely(fd >= 0)) {
 407                int err = sock_attach_fd(sock, newfile, flags);
 408
 409                if (unlikely(err < 0)) {
 410                        put_filp(newfile);
 411                        put_unused_fd(fd);
 412                        return err;
 413                }
 414                fd_install(fd, newfile);
 415        }
 416        return fd;
 417}
 418
 419static struct socket *sock_from_file(struct file *file, int *err)
 420{
 421        if (file->f_op == &socket_file_ops)
 422                return file->private_data;      /* set in sock_map_fd */
 423
 424        *err = -ENOTSOCK;
 425        return NULL;
 426}
 427
 428/**
 429 *      sockfd_lookup   -       Go from a file number to its socket slot
 430 *      @fd: file handle
 431 *      @err: pointer to an error code return
 432 *
 433 *      The file handle passed in is locked and the socket it is bound
 434 *      too is returned. If an error occurs the err pointer is overwritten
 435 *      with a negative errno code and NULL is returned. The function checks
 436 *      for both invalid handles and passing a handle which is not a socket.
 437 *
 438 *      On a success the socket object pointer is returned.
 439 */
 440
 441struct socket *sockfd_lookup(int fd, int *err)
 442{
 443        struct file *file;
 444        struct socket *sock;
 445
 446        file = fget(fd);
 447        if (!file) {
 448                *err = -EBADF;
 449                return NULL;
 450        }
 451
 452        sock = sock_from_file(file, err);
 453        if (!sock)
 454                fput(file);
 455        return sock;
 456}
 457
 458static struct socket *sockfd_lookup_light(int fd, int *err, int *fput_needed)
 459{
 460        struct file *file;
 461        struct socket *sock;
 462
 463        *err = -EBADF;
 464        file = fget_light(fd, fput_needed);
 465        if (file) {
 466                sock = sock_from_file(file, err);
 467                if (sock)
 468                        return sock;
 469                fput_light(file, *fput_needed);
 470        }
 471        return NULL;
 472}
 473
 474/**
 475 *      sock_alloc      -       allocate a socket
 476 *
 477 *      Allocate a new inode and socket object. The two are bound together
 478 *      and initialised. The socket is then returned. If we are out of inodes
 479 *      NULL is returned.
 480 */
 481
 482static struct socket *sock_alloc(void)
 483{
 484        struct inode *inode;
 485        struct socket *sock;
 486
 487        inode = new_inode(sock_mnt->mnt_sb);
 488        if (!inode)
 489                return NULL;
 490
 491        sock = SOCKET_I(inode);
 492
 493        inode->i_mode = S_IFSOCK | S_IRWXUGO;
 494        inode->i_uid = current->fsuid;
 495        inode->i_gid = current->fsgid;
 496
 497        get_cpu_var(sockets_in_use)++;
 498        put_cpu_var(sockets_in_use);
 499        return sock;
 500}
 501
 502/*
 503 *      In theory you can't get an open on this inode, but /proc provides
 504 *      a back door. Remember to keep it shut otherwise you'll let the
 505 *      creepy crawlies in.
 506 */
 507
 508static int sock_no_open(struct inode *irrelevant, struct file *dontcare)
 509{
 510        return -ENXIO;
 511}
 512
 513const struct file_operations bad_sock_fops = {
 514        .owner = THIS_MODULE,
 515        .open = sock_no_open,
 516};
 517
 518/**
 519 *      sock_release    -       close a socket
 520 *      @sock: socket to close
 521 *
 522 *      The socket is released from the protocol stack if it has a release
 523 *      callback, and the inode is then released if the socket is bound to
 524 *      an inode not a file.
 525 */
 526
 527void sock_release(struct socket *sock)
 528{
 529        if (sock->ops) {
 530                struct module *owner = sock->ops->owner;
 531
 532                sock->ops->release(sock);
 533                sock->ops = NULL;
 534                module_put(owner);
 535        }
 536
 537        if (sock->fasync_list)
 538                printk(KERN_ERR "sock_release: fasync list not empty!\n");
 539
 540        get_cpu_var(sockets_in_use)--;
 541        put_cpu_var(sockets_in_use);
 542        if (!sock->file) {
 543                iput(SOCK_INODE(sock));
 544                return;
 545        }
 546        sock->file = NULL;
 547}
 548
 549static inline int __sock_sendmsg(struct kiocb *iocb, struct socket *sock,
 550                                 struct msghdr *msg, size_t size)
 551{
 552        struct sock_iocb *si = kiocb_to_siocb(iocb);
 553        int err;
 554
 555        si->sock = sock;
 556        si->scm = NULL;
 557        si->msg = msg;
 558        si->size = size;
 559
 560        err = security_socket_sendmsg(sock, msg, size);
 561        if (err)
 562                return err;
 563
 564        return sock->ops->sendmsg(iocb, sock, msg, size);
 565}
 566
 567int sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
 568{
 569        struct kiocb iocb;
 570        struct sock_iocb siocb;
 571        int ret;
 572
 573        init_sync_kiocb(&iocb, NULL);
 574        iocb.private = &siocb;
 575        ret = __sock_sendmsg(&iocb, sock, msg, size);
 576        if (-EIOCBQUEUED == ret)
 577                ret = wait_on_sync_kiocb(&iocb);
 578        return ret;
 579}
 580
 581int kernel_sendmsg(struct socket *sock, struct msghdr *msg,
 582                   struct kvec *vec, size_t num, size_t size)
 583{
 584        mm_segment_t oldfs = get_fs();
 585        int result;
 586
 587        set_fs(KERNEL_DS);
 588        /*
 589         * the following is safe, since for compiler definitions of kvec and
 590         * iovec are identical, yielding the same in-core layout and alignment
 591         */
 592        msg->msg_iov = (struct iovec *)vec;
 593        msg->msg_iovlen = num;
 594        result = sock_sendmsg(sock, msg, size);
 595        set_fs(oldfs);
 596        return result;
 597}
 598
 599/*
 600 * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
 601 */
 602void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
 603        struct sk_buff *skb)
 604{
 605        ktime_t kt = skb->tstamp;
 606
 607        if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
 608                struct timeval tv;
 609                /* Race occurred between timestamp enabling and packet
 610                   receiving.  Fill in the current time for now. */
 611                if (kt.tv64 == 0)
 612                        kt = ktime_get_real();
 613                skb->tstamp = kt;
 614                tv = ktime_to_timeval(kt);
 615                put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP, sizeof(tv), &tv);
 616        } else {
 617                struct timespec ts;
 618                /* Race occurred between timestamp enabling and packet
 619                   receiving.  Fill in the current time for now. */
 620                if (kt.tv64 == 0)
 621                        kt = ktime_get_real();
 622                skb->tstamp = kt;
 623                ts = ktime_to_timespec(kt);
 624                put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS, sizeof(ts), &ts);
 625        }
 626}
 627
 628EXPORT_SYMBOL_GPL(__sock_recv_timestamp);
 629
 630static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock,
 631                                 struct msghdr *msg, size_t size, int flags)
 632{
 633        int err;
 634        struct sock_iocb *si = kiocb_to_siocb(iocb);
 635
 636        si->sock = sock;
 637        si->scm = NULL;
 638        si->msg = msg;
 639        si->size = size;
 640        si->flags = flags;
 641
 642        err = security_socket_recvmsg(sock, msg, size, flags);
 643        if (err)
 644                return err;
 645
 646        return sock->ops->recvmsg(iocb, sock, msg, size, flags);
 647}
 648
 649int sock_recvmsg(struct socket *sock, struct msghdr *msg,
 650                 size_t size, int flags)
 651{
 652        struct kiocb iocb;
 653        struct sock_iocb siocb;
 654        int ret;
 655
 656        init_sync_kiocb(&iocb, NULL);
 657        iocb.private = &siocb;
 658        ret = __sock_recvmsg(&iocb, sock, msg, size, flags);
 659        if (-EIOCBQUEUED == ret)
 660                ret = wait_on_sync_kiocb(&iocb);
 661        return ret;
 662}
 663
 664int kernel_recvmsg(struct socket *sock, struct msghdr *msg,
 665                   struct kvec *vec, size_t num, size_t size, int flags)
 666{
 667        mm_segment_t oldfs = get_fs();
 668        int result;
 669
 670        set_fs(KERNEL_DS);
 671        /*
 672         * the following is safe, since for compiler definitions of kvec and
 673         * iovec are identical, yielding the same in-core layout and alignment
 674         */
 675        msg->msg_iov = (struct iovec *)vec, msg->msg_iovlen = num;
 676        result = sock_recvmsg(sock, msg, size, flags);
 677        set_fs(oldfs);
 678        return result;
 679}
 680
 681static void sock_aio_dtor(struct kiocb *iocb)
 682{
 683        kfree(iocb->private);
 684}
 685
 686static ssize_t sock_sendpage(struct file *file, struct page *page,
 687                             int offset, size_t size, loff_t *ppos, int more)
 688{
 689        struct socket *sock;
 690        int flags;
 691
 692        sock = file->private_data;
 693
 694        flags = !(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT;
 695        if (more)
 696                flags |= MSG_MORE;
 697
 698        return sock->ops->sendpage(sock, page, offset, size, flags);
 699}
 700
 701static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
 702                                struct pipe_inode_info *pipe, size_t len,
 703                                unsigned int flags)
 704{
 705        struct socket *sock = file->private_data;
 706
 707        if (unlikely(!sock->ops->splice_read))
 708                return -EINVAL;
 709
 710        return sock->ops->splice_read(sock, ppos, pipe, len, flags);
 711}
 712
 713static struct sock_iocb *alloc_sock_iocb(struct kiocb *iocb,
 714                                         struct sock_iocb *siocb)
 715{
 716        if (!is_sync_kiocb(iocb)) {
 717                siocb = kmalloc(sizeof(*siocb), GFP_KERNEL);
 718                if (!siocb)
 719                        return NULL;
 720                iocb->ki_dtor = sock_aio_dtor;
 721        }
 722
 723        siocb->kiocb = iocb;
 724        iocb->private = siocb;
 725        return siocb;
 726}
 727
 728static ssize_t do_sock_read(struct msghdr *msg, struct kiocb *iocb,
 729                struct file *file, const struct iovec *iov,
 730                unsigned long nr_segs)
 731{
 732        struct socket *sock = file->private_data;
 733        size_t size = 0;
 734        int i;
 735
 736        for (i = 0; i < nr_segs; i++)
 737                size += iov[i].iov_len;
 738
 739        msg->msg_name = NULL;
 740        msg->msg_namelen = 0;
 741        msg->msg_control = NULL;
 742        msg->msg_controllen = 0;
 743        msg->msg_iov = (struct iovec *)iov;
 744        msg->msg_iovlen = nr_segs;
 745        msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
 746
 747        return __sock_recvmsg(iocb, sock, msg, size, msg->msg_flags);
 748}
 749
 750static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov,
 751                                unsigned long nr_segs, loff_t pos)
 752{
 753        struct sock_iocb siocb, *x;
 754
 755        if (pos != 0)
 756                return -ESPIPE;
 757
 758        if (iocb->ki_left == 0) /* Match SYS5 behaviour */
 759                return 0;
 760
 761
 762        x = alloc_sock_iocb(iocb, &siocb);
 763        if (!x)
 764                return -ENOMEM;
 765        return do_sock_read(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs);
 766}
 767
 768static ssize_t do_sock_write(struct msghdr *msg, struct kiocb *iocb,
 769                        struct file *file, const struct iovec *iov,
 770                        unsigned long nr_segs)
 771{
 772        struct socket *sock = file->private_data;
 773        size_t size = 0;
 774        int i;
 775
 776        for (i = 0; i < nr_segs; i++)
 777                size += iov[i].iov_len;
 778
 779        msg->msg_name = NULL;
 780        msg->msg_namelen = 0;
 781        msg->msg_control = NULL;
 782        msg->msg_controllen = 0;
 783        msg->msg_iov = (struct iovec *)iov;
 784        msg->msg_iovlen = nr_segs;
 785        msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
 786        if (sock->type == SOCK_SEQPACKET)
 787                msg->msg_flags |= MSG_EOR;
 788
 789        return __sock_sendmsg(iocb, sock, msg, size);
 790}
 791
 792static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov,
 793                          unsigned long nr_segs, loff_t pos)
 794{
 795        struct sock_iocb siocb, *x;
 796
 797        if (pos != 0)
 798                return -ESPIPE;
 799
 800        x = alloc_sock_iocb(iocb, &siocb);
 801        if (!x)
 802                return -ENOMEM;
 803
 804        return do_sock_write(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs);
 805}
 806
 807/*
 808 * Atomic setting of ioctl hooks to avoid race
 809 * with module unload.
 810 */
 811
 812static DEFINE_MUTEX(br_ioctl_mutex);
 813static int (*br_ioctl_hook) (struct net *, unsigned int cmd, void __user *arg) = NULL;
 814
 815void brioctl_set(int (*hook) (struct net *, unsigned int, void __user *))
 816{
 817        mutex_lock(&br_ioctl_mutex);
 818        br_ioctl_hook = hook;
 819        mutex_unlock(&br_ioctl_mutex);
 820}
 821
 822EXPORT_SYMBOL(brioctl_set);
 823
 824static DEFINE_MUTEX(vlan_ioctl_mutex);
 825static int (*vlan_ioctl_hook) (struct net *, void __user *arg);
 826
 827void vlan_ioctl_set(int (*hook) (struct net *, void __user *))
 828{
 829        mutex_lock(&vlan_ioctl_mutex);
 830        vlan_ioctl_hook = hook;
 831        mutex_unlock(&vlan_ioctl_mutex);
 832}
 833
 834EXPORT_SYMBOL(vlan_ioctl_set);
 835
 836static DEFINE_MUTEX(dlci_ioctl_mutex);
 837static int (*dlci_ioctl_hook) (unsigned int, void __user *);
 838
 839void dlci_ioctl_set(int (*hook) (unsigned int, void __user *))
 840{
 841        mutex_lock(&dlci_ioctl_mutex);
 842        dlci_ioctl_hook = hook;
 843        mutex_unlock(&dlci_ioctl_mutex);
 844}
 845
 846EXPORT_SYMBOL(dlci_ioctl_set);
 847
 848/*
 849 *      With an ioctl, arg may well be a user mode pointer, but we don't know
 850 *      what to do with it - that's up to the protocol still.
 851 */
 852
 853static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
 854{
 855        struct socket *sock;
 856        struct sock *sk;
 857        void __user *argp = (void __user *)arg;
 858        int pid, err;
 859        struct net *net;
 860
 861        sock = file->private_data;
 862        sk = sock->sk;
 863        net = sock_net(sk);
 864        if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) {
 865                err = dev_ioctl(net, cmd, argp);
 866        } else
 867#ifdef CONFIG_WIRELESS_EXT
 868        if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {
 869                err = dev_ioctl(net, cmd, argp);
 870        } else
 871#endif                          /* CONFIG_WIRELESS_EXT */
 872                switch (cmd) {
 873                case FIOSETOWN:
 874                case SIOCSPGRP:
 875                        err = -EFAULT;
 876                        if (get_user(pid, (int __user *)argp))
 877                                break;
 878                        err = f_setown(sock->file, pid, 1);
 879                        break;
 880                case FIOGETOWN:
 881                case SIOCGPGRP:
 882                        err = put_user(f_getown(sock->file),
 883                                       (int __user *)argp);
 884                        break;
 885                case SIOCGIFBR:
 886                case SIOCSIFBR:
 887                case SIOCBRADDBR:
 888                case SIOCBRDELBR:
 889                        err = -ENOPKG;
 890                        if (!br_ioctl_hook)
 891                                request_module("bridge");
 892
 893                        mutex_lock(&br_ioctl_mutex);
 894                        if (br_ioctl_hook)
 895                                err = br_ioctl_hook(net, cmd, argp);
 896                        mutex_unlock(&br_ioctl_mutex);
 897                        break;
 898                case SIOCGIFVLAN:
 899                case SIOCSIFVLAN:
 900                        err = -ENOPKG;
 901                        if (!vlan_ioctl_hook)
 902                                request_module("8021q");
 903
 904                        mutex_lock(&vlan_ioctl_mutex);
 905                        if (vlan_ioctl_hook)
 906                                err = vlan_ioctl_hook(net, argp);
 907                        mutex_unlock(&vlan_ioctl_mutex);
 908                        break;
 909                case SIOCADDDLCI:
 910                case SIOCDELDLCI:
 911                        err = -ENOPKG;
 912                        if (!dlci_ioctl_hook)
 913                                request_module("dlci");
 914
 915                        mutex_lock(&dlci_ioctl_mutex);
 916                        if (dlci_ioctl_hook)
 917                                err = dlci_ioctl_hook(cmd, argp);
 918                        mutex_unlock(&dlci_ioctl_mutex);
 919                        break;
 920                default:
 921                        err = sock->ops->ioctl(sock, cmd, arg);
 922
 923                        /*
 924                         * If this ioctl is unknown try to hand it down
 925                         * to the NIC driver.
 926                         */
 927                        if (err == -ENOIOCTLCMD)
 928                                err = dev_ioctl(net, cmd, argp);
 929                        break;
 930                }
 931        return err;
 932}
 933
 934int sock_create_lite(int family, int type, int protocol, struct socket **res)
 935{
 936        int err;
 937        struct socket *sock = NULL;
 938
 939        err = security_socket_create(family, type, protocol, 1);
 940        if (err)
 941                goto out;
 942
 943        sock = sock_alloc();
 944        if (!sock) {
 945                err = -ENOMEM;
 946                goto out;
 947        }
 948
 949        sock->type = type;
 950        err = security_socket_post_create(sock, family, type, protocol, 1);
 951        if (err)
 952                goto out_release;
 953
 954out:
 955        *res = sock;
 956        return err;
 957out_release:
 958        sock_release(sock);
 959        sock = NULL;
 960        goto out;
 961}
 962
 963/* No kernel lock held - perfect */
 964static unsigned int sock_poll(struct file *file, poll_table *wait)
 965{
 966        struct socket *sock;
 967
 968        /*
 969         *      We can't return errors to poll, so it's either yes or no.
 970         */
 971        sock = file->private_data;
 972        return sock->ops->poll(file, sock, wait);
 973}
 974
 975static int sock_mmap(struct file *file, struct vm_area_struct *vma)
 976{
 977        struct socket *sock = file->private_data;
 978
 979        return sock->ops->mmap(file, sock, vma);
 980}
 981
 982static int sock_close(struct inode *inode, struct file *filp)
 983{
 984        /*
 985         *      It was possible the inode is NULL we were
 986         *      closing an unfinished socket.
 987         */
 988
 989        if (!inode) {
 990                printk(KERN_DEBUG "sock_close: NULL inode\n");
 991                return 0;
 992        }
 993        sock_release(SOCKET_I(inode));
 994        return 0;
 995}
 996
 997/*
 998 *      Update the socket async list
 999 *
1000 *      Fasync_list locking strategy.
1001 *
1002 *      1. fasync_list is modified only under process context socket lock
1003 *         i.e. under semaphore.
1004 *      2. fasync_list is used under read_lock(&sk->sk_callback_lock)
1005 *         or under socket lock.
1006 *      3. fasync_list can be used from softirq context, so that
1007 *         modification under socket lock have to be enhanced with
1008 *         write_lock_bh(&sk->sk_callback_lock).
1009 *                                                      --ANK (990710)
1010 */
1011
1012static int sock_fasync(int fd, struct file *filp, int on)
1013{
1014        struct fasync_struct *fa, *fna = NULL, **prev;
1015        struct socket *sock;
1016        struct sock *sk;
1017
1018        if (on) {
1019                fna = kmalloc(sizeof(struct fasync_struct), GFP_KERNEL);
1020                if (fna == NULL)
1021                        return -ENOMEM;
1022        }
1023
1024        sock = filp->private_data;
1025
1026        sk = sock->sk;
1027        if (sk == NULL) {
1028                kfree(fna);
1029                return -EINVAL;
1030        }
1031
1032        lock_sock(sk);
1033
1034        prev = &(sock->fasync_list);
1035
1036        for (fa = *prev; fa != NULL; prev = &fa->fa_next, fa = *prev)
1037                if (fa->fa_file == filp)
1038                        break;
1039
1040        if (on) {
1041                if (fa != NULL) {
1042                        write_lock_bh(&sk->sk_callback_lock);
1043                        fa->fa_fd = fd;
1044                        write_unlock_bh(&sk->sk_callback_lock);
1045
1046                        kfree(fna);
1047                        goto out;
1048                }
1049                fna->fa_file = filp;
1050                fna->fa_fd = fd;
1051                fna->magic = FASYNC_MAGIC;
1052                fna->fa_next = sock->fasync_list;
1053                write_lock_bh(&sk->sk_callback_lock);
1054                sock->fasync_list = fna;
1055                write_unlock_bh(&sk->sk_callback_lock);
1056        } else {
1057                if (fa != NULL) {
1058                        write_lock_bh(&sk->sk_callback_lock);
1059                        *prev = fa->fa_next;
1060                        write_unlock_bh(&sk->sk_callback_lock);
1061                        kfree(fa);
1062                }
1063        }
1064
1065out:
1066        release_sock(sock->sk);
1067        return 0;
1068}
1069
1070/* This function may be called only under socket lock or callback_lock */
1071
1072int sock_wake_async(struct socket *sock, int how, int band)
1073{
1074        if (!sock || !sock->fasync_list)
1075                return -1;
1076        switch (how) {
1077        case SOCK_WAKE_WAITD:
1078                if (test_bit(SOCK_ASYNC_WAITDATA, &sock->flags))
1079                        break;
1080                goto call_kill;
1081        case SOCK_WAKE_SPACE:
1082                if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags))
1083                        break;
1084                /* fall through */
1085        case SOCK_WAKE_IO:
1086call_kill:
1087                __kill_fasync(sock->fasync_list, SIGIO, band);
1088                break;
1089        case SOCK_WAKE_URG:
1090                __kill_fasync(sock->fasync_list, SIGURG, band);
1091        }
1092        return 0;
1093}
1094
1095static int __sock_create(struct net *net, int family, int type, int protocol,
1096                         struct socket **res, int kern)
1097{
1098        int err;
1099        struct socket *sock;
1100        const struct net_proto_family *pf;
1101
1102        /*
1103         *      Check protocol is in range
1104         */
1105        if (family < 0 || family >= NPROTO)
1106                return -EAFNOSUPPORT;
1107        if (type < 0 || type >= SOCK_MAX)
1108                return -EINVAL;
1109
1110        /* Compatibility.
1111
1112           This uglymoron is moved from INET layer to here to avoid
1113           deadlock in module load.
1114         */
1115        if (family == PF_INET && type == SOCK_PACKET) {
1116                static int warned;
1117                if (!warned) {
1118                        warned = 1;
1119                        printk(KERN_INFO "%s uses obsolete (PF_INET,SOCK_PACKET)\n",
1120                               current->comm);
1121                }
1122                family = PF_PACKET;
1123        }
1124
1125        err = security_socket_create(family, type, protocol, kern);
1126        if (err)
1127                return err;
1128
1129        /*
1130         *      Allocate the socket and allow the family to set things up. if
1131         *      the protocol is 0, the family is instructed to select an appropriate
1132         *      default.
1133         */
1134        sock = sock_alloc();
1135        if (!sock) {
1136                if (net_ratelimit())
1137                        printk(KERN_WARNING "socket: no more sockets\n");
1138                return -ENFILE; /* Not exactly a match, but its the
1139                                   closest posix thing */
1140        }
1141
1142        sock->type = type;
1143
1144#ifdef CONFIG_MODULES
1145        /* Attempt to load a protocol module if the find failed.
1146         *
1147         * 12/09/1996 Marcin: But! this makes REALLY only sense, if the user
1148         * requested real, full-featured networking support upon configuration.
1149         * Otherwise module support will break!
1150         */
1151        if (net_families[family] == NULL)
1152                request_module("net-pf-%d", family);
1153#endif
1154
1155        rcu_read_lock();
1156        pf = rcu_dereference(net_families[family]);
1157        err = -EAFNOSUPPORT;
1158        if (!pf)
1159                goto out_release;
1160
1161        /*
1162         * We will call the ->create function, that possibly is in a loadable
1163         * module, so we have to bump that loadable module refcnt first.
1164         */
1165        if (!try_module_get(pf->owner))
1166                goto out_release;
1167
1168        /* Now protected by module ref count */
1169        rcu_read_unlock();
1170
1171        err = pf->create(net, sock, protocol);
1172        if (err < 0)
1173                goto out_module_put;
1174
1175        /*
1176         * Now to bump the refcnt of the [loadable] module that owns this
1177         * socket at sock_release time we decrement its refcnt.
1178         */
1179        if (!try_module_get(sock->ops->owner))
1180                goto out_module_busy;
1181
1182        /*
1183         * Now that we're done with the ->create function, the [loadable]
1184         * module can have its refcnt decremented
1185         */
1186        module_put(pf->owner);
1187        err = security_socket_post_create(sock, family, type, protocol, kern);
1188        if (err)
1189                goto out_sock_release;
1190        *res = sock;
1191
1192        return 0;
1193
1194out_module_busy:
1195        err = -EAFNOSUPPORT;
1196out_module_put:
1197        sock->ops = NULL;
1198        module_put(pf->owner);
1199out_sock_release:
1200        sock_release(sock);
1201        return err;
1202
1203out_release:
1204        rcu_read_unlock();
1205        goto out_sock_release;
1206}
1207
1208int sock_create(int family, int type, int protocol, struct socket **res)
1209{
1210        return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);
1211}
1212
1213int sock_create_kern(int family, int type, int protocol, struct socket **res)
1214{
1215        return __sock_create(&init_net, family, type, protocol, res, 1);
1216}
1217
1218SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol)
1219{
1220        int retval;
1221        struct socket *sock;
1222        int flags;
1223
1224        /* Check the SOCK_* constants for consistency.  */
1225        BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);
1226        BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK);
1227        BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);
1228        BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);
1229
1230        flags = type & ~SOCK_TYPE_MASK;
1231        if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
1232                return -EINVAL;
1233        type &= SOCK_TYPE_MASK;
1234
1235        if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1236                flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1237
1238        retval = sock_create(family, type, protocol, &sock);
1239        if (retval < 0)
1240                goto out;
1241
1242        retval = sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));
1243        if (retval < 0)
1244                goto out_release;
1245
1246out:
1247        /* It may be already another descriptor 8) Not kernel problem. */
1248        return retval;
1249
1250out_release:
1251        sock_release(sock);
1252        return retval;
1253}
1254
1255/*
1256 *      Create a pair of connected sockets.
1257 */
1258
1259SYSCALL_DEFINE4(socketpair, int, family, int, type, int, protocol,
1260                int __user *, usockvec)
1261{
1262        struct socket *sock1, *sock2;
1263        int fd1, fd2, err;
1264        struct file *newfile1, *newfile2;
1265        int flags;
1266
1267        flags = type & ~SOCK_TYPE_MASK;
1268        if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
1269                return -EINVAL;
1270        type &= SOCK_TYPE_MASK;
1271
1272        if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1273                flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1274
1275        /*
1276         * Obtain the first socket and check if the underlying protocol
1277         * supports the socketpair call.
1278         */
1279
1280        err = sock_create(family, type, protocol, &sock1);
1281        if (err < 0)
1282                goto out;
1283
1284        err = sock_create(family, type, protocol, &sock2);
1285        if (err < 0)
1286                goto out_release_1;
1287
1288        err = sock1->ops->socketpair(sock1, sock2);
1289        if (err < 0)
1290                goto out_release_both;
1291
1292        fd1 = sock_alloc_fd(&newfile1, flags & O_CLOEXEC);
1293        if (unlikely(fd1 < 0)) {
1294                err = fd1;
1295                goto out_release_both;
1296        }
1297
1298        fd2 = sock_alloc_fd(&newfile2, flags & O_CLOEXEC);
1299        if (unlikely(fd2 < 0)) {
1300                err = fd2;
1301                put_filp(newfile1);
1302                put_unused_fd(fd1);
1303                goto out_release_both;
1304        }
1305
1306        err = sock_attach_fd(sock1, newfile1, flags & O_NONBLOCK);
1307        if (unlikely(err < 0)) {
1308                goto out_fd2;
1309        }
1310
1311        err = sock_attach_fd(sock2, newfile2, flags & O_NONBLOCK);
1312        if (unlikely(err < 0)) {
1313                fput(newfile1);
1314                goto out_fd1;
1315        }
1316
1317        err = audit_fd_pair(fd1, fd2);
1318        if (err < 0) {
1319                fput(newfile1);
1320                fput(newfile2);
1321                goto out_fd;
1322        }
1323
1324        fd_install(fd1, newfile1);
1325        fd_install(fd2, newfile2);
1326        /* fd1 and fd2 may be already another descriptors.
1327         * Not kernel problem.
1328         */
1329
1330        err = put_user(fd1, &usockvec[0]);
1331        if (!err)
1332                err = put_user(fd2, &usockvec[1]);
1333        if (!err)
1334                return 0;
1335
1336        sys_close(fd2);
1337        sys_close(fd1);
1338        return err;
1339
1340out_release_both:
1341        sock_release(sock2);
1342out_release_1:
1343        sock_release(sock1);
1344out:
1345        return err;
1346
1347out_fd2:
1348        put_filp(newfile1);
1349        sock_release(sock1);
1350out_fd1:
1351        put_filp(newfile2);
1352        sock_release(sock2);
1353out_fd:
1354        put_unused_fd(fd1);
1355        put_unused_fd(fd2);
1356        goto out;
1357}
1358
1359/*
1360 *      Bind a name to a socket. Nothing much to do here since it's
1361 *      the protocol's responsibility to handle the local address.
1362 *
1363 *      We move the socket address to kernel space before we call
1364 *      the protocol layer (having also checked the address is ok).
1365 */
1366
1367SYSCALL_DEFINE3(bind, int, fd, struct sockaddr __user *, umyaddr, int, addrlen)
1368{
1369        struct socket *sock;
1370        struct sockaddr_storage address;
1371        int err, fput_needed;
1372
1373        sock = sockfd_lookup_light(fd, &err, &fput_needed);
1374        if (sock) {
1375                err = move_addr_to_kernel(umyaddr, addrlen, (struct sockaddr *)&address);
1376                if (err >= 0) {
1377                        err = security_socket_bind(sock,
1378                                                   (struct sockaddr *)&address,
1379                                                   addrlen);
1380                        if (!err)
1381                                err = sock->ops->bind(sock,
1382                                                      (struct sockaddr *)
1383                                                      &address, addrlen);
1384                }
1385                fput_light(sock->file, fput_needed);
1386        }
1387        return err;
1388}
1389
1390/*
1391 *      Perform a listen. Basically, we allow the protocol to do anything
1392 *      necessary for a listen, and if that works, we mark the socket as
1393 *      ready for listening.
1394 */
1395
1396SYSCALL_DEFINE2(listen, int, fd, int, backlog)
1397{
1398        struct socket *sock;
1399        int err, fput_needed;
1400        int somaxconn;
1401
1402        sock = sockfd_lookup_light(fd, &err, &fput_needed);
1403        if (sock) {
1404                somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn;
1405                if ((unsigned)backlog > somaxconn)
1406                        backlog = somaxconn;
1407
1408                err = security_socket_listen(sock, backlog);
1409                if (!err)
1410                        err = sock->ops->listen(sock, backlog);
1411
1412                fput_light(sock->file, fput_needed);
1413        }
1414        return err;
1415}
1416
1417/*
1418 *      For accept, we attempt to create a new socket, set up the link
1419 *      with the client, wake up the client, then return the new
1420 *      connected fd. We collect the address of the connector in kernel
1421 *      space and move it to user at the very end. This is unclean because
1422 *      we open the socket then return an error.
1423 *
1424 *      1003.1g adds the ability to recvmsg() to query connection pending
1425 *      status to recvmsg. We need to add that support in a way thats
1426 *      clean when we restucture accept also.
1427 */
1428
1429SYSCALL_DEFINE4(accept4, int, fd, struct sockaddr __user *, upeer_sockaddr,
1430                int __user *, upeer_addrlen, int, flags)
1431{
1432        struct socket *sock, *newsock;
1433        struct file *newfile;
1434        int err, len, newfd, fput_needed;
1435        struct sockaddr_storage address;
1436
1437        if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
1438                return -EINVAL;
1439
1440        if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1441                flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1442
1443        sock = sockfd_lookup_light(fd, &err, &fput_needed);
1444        if (!sock)
1445                goto out;
1446
1447        err = -ENFILE;
1448        if (!(newsock = sock_alloc()))
1449                goto out_put;
1450
1451        newsock->type = sock->type;
1452        newsock->ops = sock->ops;
1453
1454        /*
1455         * We don't need try_module_get here, as the listening socket (sock)
1456         * has the protocol module (sock->ops->owner) held.
1457         */
1458        __module_get(newsock->ops->owner);
1459
1460        newfd = sock_alloc_fd(&newfile, flags & O_CLOEXEC);
1461        if (unlikely(newfd < 0)) {
1462                err = newfd;
1463                sock_release(newsock);
1464                goto out_put;
1465        }
1466
1467        err = sock_attach_fd(newsock, newfile, flags & O_NONBLOCK);
1468        if (err < 0)
1469                goto out_fd_simple;
1470
1471        err = security_socket_accept(sock, newsock);
1472        if (err)
1473                goto out_fd;
1474
1475        err = sock->ops->accept(sock, newsock, sock->file->f_flags);
1476        if (err < 0)
1477                goto out_fd;
1478
1479        if (upeer_sockaddr) {
1480                if (newsock->ops->getname(newsock, (struct sockaddr *)&address,
1481                                          &len, 2) < 0) {
1482                        err = -ECONNABORTED;
1483                        goto out_fd;
1484                }
1485                err = move_addr_to_user((struct sockaddr *)&address,
1486                                        len, upeer_sockaddr, upeer_addrlen);
1487                if (err < 0)
1488                        goto out_fd;
1489        }
1490
1491        /* File flags are not inherited via accept() unlike another OSes. */
1492
1493        fd_install(newfd, newfile);
1494        err = newfd;
1495
1496        security_socket_post_accept(sock, newsock);
1497
1498out_put:
1499        fput_light(sock->file, fput_needed);
1500out:
1501        return err;
1502out_fd_simple:
1503        sock_release(newsock);
1504        put_filp(newfile);
1505        put_unused_fd(newfd);
1506        goto out_put;
1507out_fd:
1508        fput(newfile);
1509        put_unused_fd(newfd);
1510        goto out_put;
1511}
1512
1513SYSCALL_DEFINE3(accept, int, fd, struct sockaddr __user *, upeer_sockaddr,
1514                int __user *, upeer_addrlen)
1515{
1516        return sys_accept4(fd, upeer_sockaddr, upeer_addrlen, 0);
1517}
1518
1519/*
1520 *      Attempt to connect to a socket with the server address.  The address
1521 *      is in user space so we verify it is OK and move it to kernel space.
1522 *
1523 *      For 1003.1g we need to add clean support for a bind to AF_UNSPEC to
1524 *      break bindings
1525 *
1526 *      NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and
1527 *      other SEQPACKET protocols that take time to connect() as it doesn't
1528 *      include the -EINPROGRESS status for such sockets.
1529 */
1530
1531SYSCALL_DEFINE3(connect, int, fd, struct sockaddr __user *, uservaddr,
1532                int, addrlen)
1533{
1534        struct socket *sock;
1535        struct sockaddr_storage address;
1536        int err, fput_needed;
1537
1538        sock = sockfd_lookup_light(fd, &err, &fput_needed);
1539        if (!sock)
1540                goto out;
1541        err = move_addr_to_kernel(uservaddr, addrlen, (struct sockaddr *)&address);
1542        if (err < 0)
1543                goto out_put;
1544
1545        err =
1546            security_socket_connect(sock, (struct sockaddr *)&address, addrlen);
1547        if (err)
1548                goto out_put;
1549
1550        err = sock->ops->connect(sock, (struct sockaddr *)&address, addrlen,
1551                                 sock->file->f_flags);
1552out_put:
1553        fput_light(sock->file, fput_needed);
1554out:
1555        return err;
1556}
1557
1558/*
1559 *      Get the local address ('name') of a socket object. Move the obtained
1560 *      name to user space.
1561 */
1562
1563SYSCALL_DEFINE3(getsockname, int, fd, struct sockaddr __user *, usockaddr,
1564                int __user *, usockaddr_len)
1565{
1566        struct socket *sock;
1567        struct sockaddr_storage address;
1568        int len, err, fput_needed;
1569
1570        sock = sockfd_lookup_light(fd, &err, &fput_needed);
1571        if (!sock)
1572                goto out;
1573
1574        err = security_socket_getsockname(sock);
1575        if (err)
1576                goto out_put;
1577
1578        err = sock->ops->getname(sock, (struct sockaddr *)&address, &len, 0);
1579        if (err)
1580                goto out_put;
1581        err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr, usockaddr_len);
1582
1583out_put:
1584        fput_light(sock->file, fput_needed);
1585out:
1586        return err;
1587}
1588
1589/*
1590 *      Get the remote address ('name') of a socket object. Move the obtained
1591 *      name to user space.
1592 */
1593
1594SYSCALL_DEFINE3(getpeername, int, fd, struct sockaddr __user *, usockaddr,
1595                int __user *, usockaddr_len)
1596{
1597        struct socket *sock;
1598        struct sockaddr_storage address;
1599        int len, err, fput_needed;
1600
1601        sock = sockfd_lookup_light(fd, &err, &fput_needed);
1602        if (sock != NULL) {
1603                err = security_socket_getpeername(sock);
1604                if (err) {
1605                        fput_light(sock->file, fput_needed);
1606                        return err;
1607                }
1608
1609                err =
1610                    sock->ops->getname(sock, (struct sockaddr *)&address, &len,
1611                                       1);
1612                if (!err)
1613                        err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr,
1614                                                usockaddr_len);
1615                fput_light(sock->file, fput_needed);
1616        }
1617        return err;
1618}
1619
1620/*
1621 *      Send a datagram to a given address. We move the address into kernel
1622 *      space and check the user space data area is readable before invoking
1623 *      the protocol.
1624 */
1625
1626SYSCALL_DEFINE6(sendto, int, fd, void __user *, buff, size_t, len,
1627                unsigned, flags, struct sockaddr __user *, addr,
1628                int, addr_len)
1629{
1630        struct socket *sock;
1631        struct sockaddr_storage address;
1632        int err;
1633        struct msghdr msg;
1634        struct iovec iov;
1635        int fput_needed;
1636
1637        sock = sockfd_lookup_light(fd, &err, &fput_needed);
1638        if (!sock)
1639                goto out;
1640
1641        iov.iov_base = buff;
1642        iov.iov_len = len;
1643        msg.msg_name = NULL;
1644        msg.msg_iov = &iov;
1645        msg.msg_iovlen = 1;
1646        msg.msg_control = NULL;
1647        msg.msg_controllen = 0;
1648        msg.msg_namelen = 0;
1649        if (addr) {
1650                err = move_addr_to_kernel(addr, addr_len, (struct sockaddr *)&address);
1651                if (err < 0)
1652                        goto out_put;
1653                msg.msg_name = (struct sockaddr *)&address;
1654                msg.msg_namelen = addr_len;
1655        }
1656        if (sock->file->f_flags & O_NONBLOCK)
1657                flags |= MSG_DONTWAIT;
1658        msg.msg_flags = flags;
1659        err = sock_sendmsg(sock, &msg, len);
1660
1661out_put:
1662        fput_light(sock->file, fput_needed);
1663out:
1664        return err;
1665}
1666
1667/*
1668 *      Send a datagram down a socket.
1669 */
1670
1671SYSCALL_DEFINE4(send, int, fd, void __user *, buff, size_t, len,
1672                unsigned, flags)
1673{
1674        return sys_sendto(fd, buff, len, flags, NULL, 0);
1675}
1676
1677/*
1678 *      Receive a frame from the socket and optionally record the address of the
1679 *      sender. We verify the buffers are writable and if needed move the
1680 *      sender address from kernel to user space.
1681 */
1682
1683SYSCALL_DEFINE6(recvfrom, int, fd, void __user *, ubuf, size_t, size,
1684                unsigned, flags, struct sockaddr __user *, addr,
1685                int __user *, addr_len)
1686{
1687        struct socket *sock;
1688        struct iovec iov;
1689        struct msghdr msg;
1690        struct sockaddr_storage address;
1691        int err, err2;
1692        int fput_needed;
1693
1694        sock = sockfd_lookup_light(fd, &err, &fput_needed);
1695        if (!sock)
1696                goto out;
1697
1698        msg.msg_control = NULL;
1699        msg.msg_controllen = 0;
1700        msg.msg_iovlen = 1;
1701        msg.msg_iov = &iov;
1702        iov.iov_len = size;
1703        iov.iov_base = ubuf;
1704        msg.msg_name = (struct sockaddr *)&address;
1705        msg.msg_namelen = sizeof(address);
1706        if (sock->file->f_flags & O_NONBLOCK)
1707                flags |= MSG_DONTWAIT;
1708        err = sock_recvmsg(sock, &msg, size, flags);
1709
1710        if (err >= 0 && addr != NULL) {
1711                err2 = move_addr_to_user((struct sockaddr *)&address,
1712                                         msg.msg_namelen, addr, addr_len);
1713                if (err2 < 0)
1714                        err = err2;
1715        }
1716
1717        fput_light(sock->file, fput_needed);
1718out:
1719        return err;
1720}
1721
1722/*
1723 *      Receive a datagram from a socket.
1724 */
1725
1726asmlinkage long sys_recv(int fd, void __user *ubuf, size_t size,
1727                         unsigned flags)
1728{
1729        return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL);
1730}
1731
1732/*
1733 *      Set a socket option. Because we don't know the option lengths we have
1734 *      to pass the user mode parameter for the protocols to sort out.
1735 */
1736
1737SYSCALL_DEFINE5(setsockopt, int, fd, int, level, int, optname,
1738                char __user *, optval, int, optlen)
1739{
1740        int err, fput_needed;
1741        struct socket *sock;
1742
1743        if (optlen < 0)
1744                return -EINVAL;
1745
1746        sock = sockfd_lookup_light(fd, &err, &fput_needed);
1747        if (sock != NULL) {
1748                err = security_socket_setsockopt(sock, level, optname);
1749                if (err)
1750                        goto out_put;
1751
1752                if (level == SOL_SOCKET)
1753                        err =
1754                            sock_setsockopt(sock, level, optname, optval,
1755                                            optlen);
1756                else
1757                        err =
1758                            sock->ops->setsockopt(sock, level, optname, optval,
1759                                                  optlen);
1760out_put:
1761                fput_light(sock->file, fput_needed);
1762        }
1763        return err;
1764}
1765
1766/*
1767 *      Get a socket option. Because we don't know the option lengths we have
1768 *      to pass a user mode parameter for the protocols to sort out.
1769 */
1770
1771SYSCALL_DEFINE5(getsockopt, int, fd, int, level, int, optname,
1772                char __user *, optval, int __user *, optlen)
1773{
1774        int err, fput_needed;
1775        struct socket *sock;
1776
1777        sock = sockfd_lookup_light(fd, &err, &fput_needed);
1778        if (sock != NULL) {
1779                err = security_socket_getsockopt(sock, level, optname);
1780                if (err)
1781                        goto out_put;
1782
1783                if (level == SOL_SOCKET)
1784                        err =
1785                            sock_getsockopt(sock, level, optname, optval,
1786                                            optlen);
1787                else
1788                        err =
1789                            sock->ops->getsockopt(sock, level, optname, optval,
1790                                                  optlen);
1791out_put:
1792                fput_light(sock->file, fput_needed);
1793        }
1794        return err;
1795}
1796
1797/*
1798 *      Shutdown a socket.
1799 */
1800
1801SYSCALL_DEFINE2(shutdown, int, fd, int, how)
1802{
1803        int err, fput_needed;
1804        struct socket *sock;
1805
1806        sock = sockfd_lookup_light(fd, &err, &fput_needed);
1807        if (sock != NULL) {
1808                err = security_socket_shutdown(sock, how);
1809                if (!err)
1810                        err = sock->ops->shutdown(sock, how);
1811                fput_light(sock->file, fput_needed);
1812        }
1813        return err;
1814}
1815
1816/* A couple of helpful macros for getting the address of the 32/64 bit
1817 * fields which are the same type (int / unsigned) on our platforms.
1818 */
1819#define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member)
1820#define COMPAT_NAMELEN(msg)     COMPAT_MSG(msg, msg_namelen)
1821#define COMPAT_FLAGS(msg)       COMPAT_MSG(msg, msg_flags)
1822
1823/*
1824 *      BSD sendmsg interface
1825 */
1826
1827SYSCALL_DEFINE3(sendmsg, int, fd, struct msghdr __user *, msg, unsigned, flags)
1828{
1829        struct compat_msghdr __user *msg_compat =
1830            (struct compat_msghdr __user *)msg;
1831        struct socket *sock;
1832        struct sockaddr_storage address;
1833        struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
1834        unsigned char ctl[sizeof(struct cmsghdr) + 20]
1835            __attribute__ ((aligned(sizeof(__kernel_size_t))));
1836        /* 20 is size of ipv6_pktinfo */
1837        unsigned char *ctl_buf = ctl;
1838        struct msghdr msg_sys;
1839        int err, ctl_len, iov_size, total_len;
1840        int fput_needed;
1841
1842        err = -EFAULT;
1843        if (MSG_CMSG_COMPAT & flags) {
1844                if (get_compat_msghdr(&msg_sys, msg_compat))
1845                        return -EFAULT;
1846        }
1847        else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr)))
1848                return -EFAULT;
1849
1850        sock = sockfd_lookup_light(fd, &err, &fput_needed);
1851        if (!sock)
1852                goto out;
1853
1854        /* do not move before msg_sys is valid */
1855        err = -EMSGSIZE;
1856        if (msg_sys.msg_iovlen > UIO_MAXIOV)
1857                goto out_put;
1858
1859        /* Check whether to allocate the iovec area */
1860        err = -ENOMEM;
1861        iov_size = msg_sys.msg_iovlen * sizeof(struct iovec);
1862        if (msg_sys.msg_iovlen > UIO_FASTIOV) {
1863                iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
1864                if (!iov)
1865                        goto out_put;
1866        }
1867
1868        /* This will also move the address data into kernel space */
1869        if (MSG_CMSG_COMPAT & flags) {
1870                err = verify_compat_iovec(&msg_sys, iov,
1871                                          (struct sockaddr *)&address,
1872                                          VERIFY_READ);
1873        } else
1874                err = verify_iovec(&msg_sys, iov,
1875                                   (struct sockaddr *)&address,
1876                                   VERIFY_READ);
1877        if (err < 0)
1878                goto out_freeiov;
1879        total_len = err;
1880
1881        err = -ENOBUFS;
1882
1883        if (msg_sys.msg_controllen > INT_MAX)
1884                goto out_freeiov;
1885        ctl_len = msg_sys.msg_controllen;
1886        if ((MSG_CMSG_COMPAT & flags) && ctl_len) {
1887                err =
1888                    cmsghdr_from_user_compat_to_kern(&msg_sys, sock->sk, ctl,
1889                                                     sizeof(ctl));
1890                if (err)
1891                        goto out_freeiov;
1892                ctl_buf = msg_sys.msg_control;
1893                ctl_len = msg_sys.msg_controllen;
1894        } else if (ctl_len) {
1895                if (ctl_len > sizeof(ctl)) {
1896                        ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL);
1897                        if (ctl_buf == NULL)
1898                                goto out_freeiov;
1899                }
1900                err = -EFAULT;
1901                /*
1902                 * Careful! Before this, msg_sys.msg_control contains a user pointer.
1903                 * Afterwards, it will be a kernel pointer. Thus the compiler-assisted
1904                 * checking falls down on this.
1905                 */
1906                if (copy_from_user(ctl_buf, (void __user *)msg_sys.msg_control,
1907                                   ctl_len))
1908                        goto out_freectl;
1909                msg_sys.msg_control = ctl_buf;
1910        }
1911        msg_sys.msg_flags = flags;
1912
1913        if (sock->file->f_flags & O_NONBLOCK)
1914                msg_sys.msg_flags |= MSG_DONTWAIT;
1915        err = sock_sendmsg(sock, &msg_sys, total_len);
1916
1917out_freectl:
1918        if (ctl_buf != ctl)
1919                sock_kfree_s(sock->sk, ctl_buf, ctl_len);
1920out_freeiov:
1921        if (iov != iovstack)
1922                sock_kfree_s(sock->sk, iov, iov_size);
1923out_put:
1924        fput_light(sock->file, fput_needed);
1925out:
1926        return err;
1927}
1928
1929/*
1930 *      BSD recvmsg interface
1931 */
1932
1933SYSCALL_DEFINE3(recvmsg, int, fd, struct msghdr __user *, msg,
1934                unsigned int, flags)
1935{
1936        struct compat_msghdr __user *msg_compat =
1937            (struct compat_msghdr __user *)msg;
1938        struct socket *sock;
1939        struct iovec iovstack[UIO_FASTIOV];
1940        struct iovec *iov = iovstack;
1941        struct msghdr msg_sys;
1942        unsigned long cmsg_ptr;
1943        int err, iov_size, total_len, len;
1944        int fput_needed;
1945
1946        /* kernel mode address */
1947        struct sockaddr_storage addr;
1948
1949        /* user mode address pointers */
1950        struct sockaddr __user *uaddr;
1951        int __user *uaddr_len;
1952
1953        if (MSG_CMSG_COMPAT & flags) {
1954                if (get_compat_msghdr(&msg_sys, msg_compat))
1955                        return -EFAULT;
1956        }
1957        else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr)))
1958                return -EFAULT;
1959
1960        sock = sockfd_lookup_light(fd, &err, &fput_needed);
1961        if (!sock)
1962                goto out;
1963
1964        err = -EMSGSIZE;
1965        if (msg_sys.msg_iovlen > UIO_MAXIOV)
1966                goto out_put;
1967
1968        /* Check whether to allocate the iovec area */
1969        err = -ENOMEM;
1970        iov_size = msg_sys.msg_iovlen * sizeof(struct iovec);
1971        if (msg_sys.msg_iovlen > UIO_FASTIOV) {
1972                iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
1973                if (!iov)
1974                        goto out_put;
1975        }
1976
1977        /*
1978         *      Save the user-mode address (verify_iovec will change the
1979         *      kernel msghdr to use the kernel address space)
1980         */
1981
1982        uaddr = (__force void __user *)msg_sys.msg_name;
1983        uaddr_len = COMPAT_NAMELEN(msg);
1984        if (MSG_CMSG_COMPAT & flags) {
1985                err = verify_compat_iovec(&msg_sys, iov,
1986                                          (struct sockaddr *)&addr,
1987                                          VERIFY_WRITE);
1988        } else
1989                err = verify_iovec(&msg_sys, iov,
1990                                   (struct sockaddr *)&addr,
1991                                   VERIFY_WRITE);
1992        if (err < 0)
1993                goto out_freeiov;
1994        total_len = err;
1995
1996        cmsg_ptr = (unsigned long)msg_sys.msg_control;
1997        msg_sys.msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT);
1998
1999        if (sock->file->f_flags & O_NONBLOCK)
2000                flags |= MSG_DONTWAIT;
2001        err = sock_recvmsg(sock, &msg_sys, total_len, flags);
2002        if (err < 0)
2003                goto out_freeiov;
2004        len = err;
2005
2006        if (uaddr != NULL) {
2007                err = move_addr_to_user((struct sockaddr *)&addr,
2008                                        msg_sys.msg_namelen, uaddr,
2009                                        uaddr_len);
2010                if (err < 0)
2011                        goto out_freeiov;
2012        }
2013        err = __put_user((msg_sys.msg_flags & ~MSG_CMSG_COMPAT),
2014                         COMPAT_FLAGS(msg));
2015        if (err)
2016                goto out_freeiov;
2017        if (MSG_CMSG_COMPAT & flags)
2018                err = __put_user((unsigned long)msg_sys.msg_control - cmsg_ptr,
2019                                 &msg_compat->msg_controllen);
2020        else
2021                err = __put_user((unsigned long)msg_sys.msg_control - cmsg_ptr,
2022                                 &msg->msg_controllen);
2023        if (err)
2024                goto out_freeiov;
2025        err = len;
2026
2027out_freeiov:
2028        if (iov != iovstack)
2029                sock_kfree_s(sock->sk, iov, iov_size);
2030out_put:
2031        fput_light(sock->file, fput_needed);
2032out:
2033        return err;
2034}
2035
2036#ifdef __ARCH_WANT_SYS_SOCKETCALL
2037
2038/* Argument list sizes for sys_socketcall */
2039#define AL(x) ((x) * sizeof(unsigned long))
2040static const unsigned char nargs[19]={
2041        AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
2042        AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
2043        AL(6),AL(2),AL(5),AL(5),AL(3),AL(3),
2044        AL(4)
2045};
2046
2047#undef AL
2048
2049/*
2050 *      System call vectors.
2051 *
2052 *      Argument checking cleaned up. Saved 20% in size.
2053 *  This function doesn't need to set the kernel lock because
2054 *  it is set by the callees.
2055 */
2056
2057SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)
2058{
2059        unsigned long a[6];
2060        unsigned long a0, a1;
2061        int err;
2062
2063        if (call < 1 || call > SYS_ACCEPT4)
2064                return -EINVAL;
2065
2066        /* copy_from_user should be SMP safe. */
2067        if (copy_from_user(a, args, nargs[call]))
2068                return -EFAULT;
2069
2070        err = audit_socketcall(nargs[call] / sizeof(unsigned long), a);
2071        if (err)
2072                return err;
2073
2074        a0 = a[0];
2075        a1 = a[1];
2076
2077        switch (call) {
2078        case SYS_SOCKET:
2079                err = sys_socket(a0, a1, a[2]);
2080                break;
2081        case SYS_BIND:
2082                err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]);
2083                break;
2084        case SYS_CONNECT:
2085                err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
2086                break;
2087        case SYS_LISTEN:
2088                err = sys_listen(a0, a1);
2089                break;
2090        case SYS_ACCEPT:
2091                err = sys_accept4(a0, (struct sockaddr __user *)a1,
2092                                  (int __user *)a[2], 0);
2093                break;
2094        case SYS_GETSOCKNAME:
2095                err =
2096                    sys_getsockname(a0, (struct sockaddr __user *)a1,
2097                                    (int __user *)a[2]);
2098                break;
2099        case SYS_GETPEERNAME:
2100                err =
2101                    sys_getpeername(a0, (struct sockaddr __user *)a1,
2102                                    (int __user *)a[2]);
2103                break;
2104        case SYS_SOCKETPAIR:
2105                err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]);
2106                break;
2107        case SYS_SEND:
2108                err = sys_send(a0, (void __user *)a1, a[2], a[3]);
2109                break;
2110        case SYS_SENDTO:
2111                err = sys_sendto(a0, (void __user *)a1, a[2], a[3],
2112                                 (struct sockaddr __user *)a[4], a[5]);
2113                break;
2114        case SYS_RECV:
2115                err = sys_recv(a0, (void __user *)a1, a[2], a[3]);
2116                break;
2117        case SYS_RECVFROM:
2118                err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
2119                                   (struct sockaddr __user *)a[4],
2120                                   (int __user *)a[5]);
2121                break;
2122        case SYS_SHUTDOWN:
2123                err = sys_shutdown(a0, a1);
2124                break;
2125        case SYS_SETSOCKOPT:
2126                err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]);
2127                break;
2128        case SYS_GETSOCKOPT:
2129                err =
2130                    sys_getsockopt(a0, a1, a[2], (char __user *)a[3],
2131                                   (int __user *)a[4]);
2132                break;
2133        case SYS_SENDMSG:
2134                err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]);
2135                break;
2136        case SYS_RECVMSG:
2137                err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]);
2138                break;
2139        case SYS_ACCEPT4:
2140                err = sys_accept4(a0, (struct sockaddr __user *)a1,
2141                                  (int __user *)a[2], a[3]);
2142                break;
2143        default:
2144                err = -EINVAL;
2145                break;
2146        }
2147        return err;
2148}
2149
2150#endif                          /* __ARCH_WANT_SYS_SOCKETCALL */
2151
2152/**
2153 *      sock_register - add a socket protocol handler
2154 *      @ops: description of protocol
2155 *
2156 *      This function is called by a protocol handler that wants to
2157 *      advertise its address family, and have it linked into the
2158 *      socket interface. The value ops->family coresponds to the
2159 *      socket system call protocol family.
2160 */
2161int sock_register(const struct net_proto_family *ops)
2162{
2163        int err;
2164
2165        if (ops->family >= NPROTO) {
2166                printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family,
2167                       NPROTO);
2168                return -ENOBUFS;
2169        }
2170
2171        spin_lock(&net_family_lock);
2172        if (net_families[ops->family])
2173                err = -EEXIST;
2174        else {
2175                net_families[ops->family] = ops;
2176                err = 0;
2177        }
2178        spin_unlock(&net_family_lock);
2179
2180        printk(KERN_INFO "NET: Registered protocol family %d\n", ops->family);
2181        return err;
2182}
2183
2184/**
2185 *      sock_unregister - remove a protocol handler
2186 *      @family: protocol family to remove
2187 *
2188 *      This function is called by a protocol handler that wants to
2189 *      remove its address family, and have it unlinked from the
2190 *      new socket creation.
2191 *
2192 *      If protocol handler is a module, then it can use module reference
2193 *      counts to protect against new references. If protocol handler is not
2194 *      a module then it needs to provide its own protection in
2195 *      the ops->create routine.
2196 */
2197void sock_unregister(int family)
2198{
2199        BUG_ON(family < 0 || family >= NPROTO);
2200
2201        spin_lock(&net_family_lock);
2202        net_families[family] = NULL;
2203        spin_unlock(&net_family_lock);
2204
2205        synchronize_rcu();
2206
2207        printk(KERN_INFO "NET: Unregistered protocol family %d\n", family);
2208}
2209
2210static int __init sock_init(void)
2211{
2212        /*
2213         *      Initialize sock SLAB cache.
2214         */
2215
2216        sk_init();
2217
2218        /*
2219         *      Initialize skbuff SLAB cache
2220         */
2221        skb_init();
2222
2223        /*
2224         *      Initialize the protocols module.
2225         */
2226
2227        init_inodecache();
2228        register_filesystem(&sock_fs_type);
2229        sock_mnt = kern_mount(&sock_fs_type);
2230
2231        /* The real protocol initialization is performed in later initcalls.
2232         */
2233
2234#ifdef CONFIG_NETFILTER
2235        netfilter_init();
2236#endif
2237
2238        return 0;
2239}
2240
2241core_initcall(sock_init);       /* early initcall */
2242
2243#ifdef CONFIG_PROC_FS
2244void socket_seq_show(struct seq_file *seq)
2245{
2246        int cpu;
2247        int counter = 0;
2248
2249        for_each_possible_cpu(cpu)
2250            counter += per_cpu(sockets_in_use, cpu);
2251
2252        /* It can be negative, by the way. 8) */
2253        if (counter < 0)
2254                counter = 0;
2255
2256        seq_printf(seq, "sockets: used %d\n", counter);
2257}
2258#endif                          /* CONFIG_PROC_FS */
2259
2260#ifdef CONFIG_COMPAT
2261static long compat_sock_ioctl(struct file *file, unsigned cmd,
2262                              unsigned long arg)
2263{
2264        struct socket *sock = file->private_data;
2265        int ret = -ENOIOCTLCMD;
2266        struct sock *sk;
2267        struct net *net;
2268
2269        sk = sock->sk;
2270        net = sock_net(sk);
2271
2272        if (sock->ops->compat_ioctl)
2273                ret = sock->ops->compat_ioctl(sock, cmd, arg);
2274
2275        if (ret == -ENOIOCTLCMD &&
2276            (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST))
2277                ret = compat_wext_handle_ioctl(net, cmd, arg);
2278
2279        return ret;
2280}
2281#endif
2282
2283int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen)
2284{
2285        return sock->ops->bind(sock, addr, addrlen);
2286}
2287
2288int kernel_listen(struct socket *sock, int backlog)
2289{
2290        return sock->ops->listen(sock, backlog);
2291}
2292
2293int kernel_accept(struct socket *sock, struct socket **newsock, int flags)
2294{
2295        struct sock *sk = sock->sk;
2296        int err;
2297
2298        err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol,
2299                               newsock);
2300        if (err < 0)
2301                goto done;
2302
2303        err = sock->ops->accept(sock, *newsock, flags);
2304        if (err < 0) {
2305                sock_release(*newsock);
2306                *newsock = NULL;
2307                goto done;
2308        }
2309
2310        (*newsock)->ops = sock->ops;
2311        __module_get((*newsock)->ops->owner);
2312
2313done:
2314        return err;
2315}
2316
2317int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen,
2318                   int flags)
2319{
2320        return sock->ops->connect(sock, addr, addrlen, flags);
2321}
2322
2323int kernel_getsockname(struct socket *sock, struct sockaddr *addr,
2324                         int *addrlen)
2325{
2326        return sock->ops->getname(sock, addr, addrlen, 0);
2327}
2328
2329int kernel_getpeername(struct socket *sock, struct sockaddr *addr,
2330                         int *addrlen)
2331{
2332        return sock->ops->getname(sock, addr, addrlen, 1);
2333}
2334
2335int kernel_getsockopt(struct socket *sock, int level, int optname,
2336                        char *optval, int *optlen)
2337{
2338        mm_segment_t oldfs = get_fs();
2339        int err;
2340
2341        set_fs(KERNEL_DS);
2342        if (level == SOL_SOCKET)
2343                err = sock_getsockopt(sock, level, optname, optval, optlen);
2344        else
2345                err = sock->ops->getsockopt(sock, level, optname, optval,
2346                                            optlen);
2347        set_fs(oldfs);
2348        return err;
2349}
2350
2351int kernel_setsockopt(struct socket *sock, int level, int optname,
2352                        char *optval, int optlen)
2353{
2354        mm_segment_t oldfs = get_fs();
2355        int err;
2356
2357        set_fs(KERNEL_DS);
2358        if (level == SOL_SOCKET)
2359                err = sock_setsockopt(sock, level, optname, optval, optlen);
2360        else
2361                err = sock->ops->setsockopt(sock, level, optname, optval,
2362                                            optlen);
2363        set_fs(oldfs);
2364        return err;
2365}
2366
2367int kernel_sendpage(struct socket *sock, struct page *page, int offset,
2368                    size_t size, int flags)
2369{
2370        if (sock->ops->sendpage)
2371                return sock->ops->sendpage(sock, page, offset, size, flags);
2372
2373        return sock_no_sendpage(sock, page, offset, size, flags);
2374}
2375
2376int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg)
2377{
2378        mm_segment_t oldfs = get_fs();
2379        int err;
2380
2381        set_fs(KERNEL_DS);
2382        err = sock->ops->ioctl(sock, cmd, arg);
2383        set_fs(oldfs);
2384
2385        return err;
2386}
2387
2388int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how)
2389{
2390        return sock->ops->shutdown(sock, how);
2391}
2392
2393EXPORT_SYMBOL(sock_create);
2394EXPORT_SYMBOL(sock_create_kern);
2395EXPORT_SYMBOL(sock_create_lite);
2396EXPORT_SYMBOL(sock_map_fd);
2397EXPORT_SYMBOL(sock_recvmsg);
2398EXPORT_SYMBOL(sock_register);
2399EXPORT_SYMBOL(sock_release);
2400EXPORT_SYMBOL(sock_sendmsg);
2401EXPORT_SYMBOL(sock_unregister);
2402EXPORT_SYMBOL(sock_wake_async);
2403EXPORT_SYMBOL(sockfd_lookup);
2404EXPORT_SYMBOL(kernel_sendmsg);
2405EXPORT_SYMBOL(kernel_recvmsg);
2406EXPORT_SYMBOL(kernel_bind);
2407EXPORT_SYMBOL(kernel_listen);
2408EXPORT_SYMBOL(kernel_accept);
2409EXPORT_SYMBOL(kernel_connect);
2410EXPORT_SYMBOL(kernel_getsockname);
2411EXPORT_SYMBOL(kernel_getpeername);
2412EXPORT_SYMBOL(kernel_getsockopt);
2413EXPORT_SYMBOL(kernel_setsockopt);
2414EXPORT_SYMBOL(kernel_sendpage);
2415EXPORT_SYMBOL(kernel_sock_ioctl);
2416EXPORT_SYMBOL(kernel_sock_shutdown);
2417
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.