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;
retval;
1224                 * module can ha2e its28cu_read_unlock();
sock_create(family, type, protocol, &sock1);
1281        if an class=">         */
1282           ="comment"e=module_put" class="sref2>modu28="sref">out_release;
err = <28name="L1238">1238        e2r28 = sock_create(owner))
family, int,t, sock2;
1281        if et/socket.1282          a href="+c2de=res" class="sref">res<2a> = 29lass="sref">out_module_busy;
1192        r2turn 0;
fd2, sock, newfile2;
SOCK_NONBLOCK))
1226         < 0)
type, , 1136         2code=out_m2dule_busy" class="sref">o2t_mod29="sref">out_releasesock_create(1226        err = -2a href="+code=ut_module_busy;
ou2_modu29="sref">out_r="L1254">1254
sock2/a>-&29name="L1238">1238        err;
sock, SOCK_NONBLOCK))
1226        2ut_so29 < 0)
type, ;
1136         3 href="+co3e=sock_release" class="sr3f">so30lass="sref">out_modulcode=sock_creatss="sref">sock_create(1226        <3turn sock1newfile2;
1226        <3net/socket3c#L1203" id="L1203" class3"line30sref">request_module(sock,, 1226        <3n3t/socket3c#L1194" id="L1194" class3lease30ass="sref">out_module_put;
1254
1246sock_create(sock, sock2;
newfile2;
SOCK_NONBLOCK))
sock3"line307/a> < 0)
type, 1136         3 8et/socke3.=module_put" class="sref3ck_cr30sref">ENFILE; ;
3="lin309u_read_unloc="L1254">1254
1171        <3"net/socke3.c#L1212" id="L1212" clas3="lin31href="+code=pf" class="sref">pf->sock, SOCK_NONBLOCK))
SOCK_NONBLOCK != type, 1136         3f="+code=s3ck_create_kern" class="sr3f">so31gs = (pf->newfile2;
1226        <3"net/socke3.c#L1215" id="L1215" clas3="lin31="sref">out_release;
__sock_cr="L1254">1254
1267        <3net/socket3c#L1218" id="L1218" class3"line31href="+code=security_socket_post_create" class="sref">security_socket_paudit.=f_ly" class="sref">faaudit.=f_ly" f="+code=type" class=fd2, err;
1226        <3"8et/socke3L_DEFINE3" class="sref">S3SCALL311136         3f9et/socke3.c#L1220" id="L1220" clas3="lin31sref">EINVAL;
pf->newfile2;
1226        <3t out_modulcode=sock_creatssref">pf->1226        <3tnet/socke3f="+code=socket" class="s3ef">s3222" class="line" namea>;
;
1254
1224        <3pan class=3comment">/* Check the SOC3_* co32cu_read_unlock();
sock1=f_ket.alaf="+code=type" class=fd2, newfile2;
1226        <3turn BU3LD_BUG_ON(sock1=f_ket.alaf="+code=type" class=frr;
1226        <3tnet/socke3e=BUILD_BUG_ON" class="sr3f">BU3LD_BUG_ON((r 8) Not kernel problem."+cocket"ne/
1257BU32ir call.
1257BU32socket.c#L1279" id="L1279" class="line" name="L1279">1279
1230        <3 href="+co3e=flags" class="sref">fla3s3= pf->usockveret.uassf="+code=type" class=fd2, 1157        <3 ( & ~((1189         3      retu3n -EINVAL;
pf->usockveret.uassf="+code=type" class=frr;
1157        <3 et/socket3e=type" class="sref">type3/a> &33 < 0)
(1189         3 an class=3c#L1235" id="L1235" class3"line33="sref">out_release1193
1246f33D_BUG_ON((sock)ys_clos=f="+code=type" class=frr;
1157        <3 href="+co3c#L1238" id="L1238" class3"line33;sock)ys_clos=f="+code=type" class=fd2, 1226        <3 href="+co3e=retval" class="sref">re3val;
1264        s3 (1230        <3      goto3:
1251        <3net/socket3c#L1242" id="L1242" class3"line34_release(sock);
1281        i3 href="+co3e=retval" class="sref">re3val = 1251        <3net/socket3+code=retval" class="sref3>retv3l < 0)
sock);
1281        i3      goto3:
1251        <3n(__sock_create(&1264        s3code=out" 3lass="sref">out:
1267        <3pan class=3comment">/* It may be alr3ady a3other /a>;
1251        <3nhref="+co3f="+code=retval" class="s3ef">r34_put(sock1newfile2;
1226        <3net/socket3c#L1250" id="L1250" class3"line34cu_read_unlock();
sock);
1281        i3code=out_r3lease" class="sref">out_r3lease3/a>:
1251        <3 href="+co3e=sock_release" class="sr3f">so3k_release(sock11226        <3turn r3tval;
sock);
1281        i3"net/socke3.c#L1254" id="L1254" clas3="lin35a>:
1251        <3      goto3c#L1255" id="L1255" class3"line35cu_read_unlock();
sock,, 1226        <3s="comment3>/*
sock,;
1157        <3s="comment3> *      Create a pair of3conne35D_BUG_ON(/socket.c#L1221+code4"net/socket.c#L     return 1254
1259S3SCALL3DEFINE4 id="L1276" class="line" name="L1276">1276__uckets.
1177
);
1257s3cket
1257f3136ne with the ->create funcnet/socWe moved="L1278" c addeasn1257fil36efcnt decremented
12571279
1267        <3 href="+co3e=flags" class="sref">fla3s36ther /a>;
socket, int, socbindt/socka href="+code=type" cdlass="sref">socfdt/sockref="+code=sock1" class="saddeL1263" class="line"adde_BUG_ode=sock1" clas class="sref">usockvec)
1189         3 ( &a="L1136">1136         3      retu3n -EINVALsock;
1222        i3 href="+co3e=type" class="sref">type3/a> &3mp;= sock);
1222        i3 net/socke3c#L1272" id="L1272" class3"line37a> & ~(socf1222        i3 uct 1213int f37 < 0)
sock;
socfdt/sock="net/socket.c#L1281"L1264" class="line" namere="net/socket.c#L1281csocf1157        <3net/socket3c#L1275" id="L1275" class3"line37cu_read_unlocsocket.c#L1189" id=sock1222" class="line" name=e="L1136">1136         3pan class=3comment">/*
pf->->1157        <3net/socket3>         * Obtain the fi3st so37="sref">out_release1136         3s="comment3>         * supports the 3ocket377"sref">out_releasepf->sock,bindlass="sref">soc"sref">sock,bindnet/socket.c#L1252" id="1222" class="line" name="L1260">1260         3s="comment3>         */
ENFILE; 1260         3s     retu3c#L1280" id="L1280" class3"line37sref">EINVAL;
1157        <3 href="+co3e=err" class="sref">err = <38lass="sref">out_modulllllllll(1189         3 (e3r3822" class="line" name                f="+code=type" >pf->owner))
socbindt/sosocket.c#L1252" id="1222" class="line" name="L1260">1260         3      goto3out;
1260         3      retval;
1157        <3 et/socket3>         * module can ha3e its38="sref">out_release1254
         */
sock;
newfile1, *socf1157        <3 et/socket3e=module_put" class="sref3>modu38="sref">out_r="L1254">1254
err = <387"sref">out_reate(&1264        s3 (e3r38 = 1254
1230        <3a href="+c3de=res" class="sref">res<3a> = 39">__uckets.
1276
127611771257o3t_mod39efcnt decremented
1279
err = -39name="L1246">1246ou3_modu39/socket.c#L1247" id=ket, int, rr;
, int, rt/sosocket.c#L1252" l clasr;
socfdt/socka href="+code=type" backloglass="sref">socbacklogname="L1189">1189         3 href="+co3e=sock" class="sref">sock3/a>-&39name=="L1136">1136         3 href="+co3e=module_put" class="sref3>modu3e_put(sock;
1222        i3net/socket3ck_release" class="sref">3ut_so39 < 0)
socf1222        i4 href="+co4e=sock_release" class="sr4f">so40;
1222        i4 1ref="+co4e#L1192" id="L1192" class4>err<40name="L1192">1192        r4net/socket4c#L1203" id="L1203" class4"line40val;
sock;
socfdt/sock="net/socket.c#L1281"L1264" class="line" namere="net/socket.c#L1281csocf1192        r4n3t/socket4c#L1194" id="L1194" class4lease40 < 0)
1136         4 href="+co4e=rcu_read_unlock" class=4sref"40="sref">out_releasesock;
newfile11222        i4 5ref="+co4e=err" class="sref">errsocbacklognamee"gt;/t/socket.c#L122somaxL1251222" class="linemaxL125name="L1189">1189         4"net/socke4.c#L1207" id="L1207" clas4="lin40="sref">out_releasesocbacklognamee=create" class="smimaxL1251222" class="linemaxL125name="L1222">1222        i4 7et/socke4.=sock" class="sref">sock4"line40name="L1238">1238        <4 8et/socke4.=module_put" class="sref4ck_cr40sref">ENFILE; pf->sock,l clasr;
sock,l clast/sosocket.c#L1252" id="1222" class="line" name=ef="+code=type" backloglass="sref">socbacklogname=="L1222">1222        i4 9et/socke4.k_release" class="sref">4="lin40sref">EINVAL;
(1189         4turn out_modulllllllllf="+code=type" >pf->owner))
socbacklogname=="L1222">1222        i4"net/socke4.c#L1212" id="L1212" clas4="lin41name="L1192">1192        r4net/socket4c#L1213" id="L1213" class4"line41out;
sock;
newfile1, *socf1157        <4f="+code=s4ck_create_kern" class="sr4f">so41gs = (1254
out_reate(&1264        s4turn _="L1254">1254
1267        <4net/socket4c#L1218" id="L1218" class4"line41ir call.
1276S4SCALL41socket.c#L1279" id="L1279" cnet/socF"L1accept,8" i#ttempt /spcet.c#L12new1278" c, set up77"e link" name="L1276">12761276__uckets.
1276s42 nameckets.
)i#t" id=very end.cThin1276
12571257/* Check the SOC4_* co42efcnt decremented
1276BU42socket.c#L1186" id="L1186" cnet/sochtatus1177BU42ed sockets.
1257BU42ir call.
1279
BU42name="L1259">1259(socketpair, int, socfdt/sockref="+code=sock1" class="saddeL1263" class="line"adde_BUG_ode=sock1" clas class="sref">usockvec)
1260         4 href="+co4e=flags" class="sref">fla4s43">__user *, usockvec)
SOCK_NONB="L1189">1189         4 (1262        s4      retu4n -EINVALsock;
1264        s4 et/socket4e=type" class="sref">type4/a> &43 < 0)
"+code=newfile1" class="sref">newfile1, *1264        s4 net/socke4c#L1235" id="L1235" class4"line43="sref">out_rsoce2" dnameref="+code=type" csocf1222        i4 (EINVALsock);
1222        i4      f43name="L1267">1267        <4 href="+co4c#L1238" id="L1238" class4"line437/a> < 0)
SOCK_CLOEXEC | SOCK_NONBLOCK))
1269         4 href="+co4e=retval" class="sref">re4valENFILE; 1270        <4 (1230        <4      goto4 < 0)
O_NONBLOCK && (flags & SOCK_NONBLOCK))
1273         4net/socket4c#L1242" id="L1242" class4"line4422" class="line" name href="+code=sos="sref">flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1274
re4val1213int sock;
socfdt/sock="net/socket.c#L1281"L1264" class="line" namere="net/socket.c#L1281csocf1213int (1213int out:
1267        <4pan class=4comment">/* It may be alr4ady a44href="+code=security_socket_post_create" class="sref">seet/socket.c#L1270NFILE"L1270" class="lNFILEreturn r44sock;
1273         4n(EINVAL;
;
pf->out_r4lease45name="L1171">1171        <4 href="+co4e=sock_release" class="sr4f">so4k_release(SOCK_TYP=create" class="smily1222" class="line" name+code=owner" class="_MASK" class="sref">SOCK_TYrn r4tval;
owner))
owner))
1224        <4      goto4c#L1255" id="L1255" class4"line45cu_read_unlockl.
12761276 *      Create a pair of4conne45et and check if the underlying protocohas77"e );
< module (278"+code1257
1279
(usockvecowner))
owner))
1213int S4SCALL45name="L1230">1230        <4      int 4a href="+code=__user" cla4s="sr46 soce2" dname;
sock, SOCK_NONBLOCK))
1226        <4"net/socke4.c#L1262" id="L1262" clas4="lin46lt; 0)
type, soce2" dname;" name=me="L1136">1136         4ruct s46sref">EINVAL;
pf->soce2" dname="L1226">1226        <4"et/socket4+code=fd1" class="sref">f4146gs = (sock);
1226        <4"     goto4f="+code=file" class="sre4">fil46="sref">out_release;
pf->__sock_cr="L1254">1254
1267        <4 href="+co4e=flags" class="sref">fla4s46href="+code=security_socket_post_create" class="sref">security_socket_p sock, SOCK_NONBLOCK))
EINVAL;
;
type4/a> &47name="L1171">1171        <4 net/socke4c#L1272" id="L1272" class4"line47href="+code=pf" class="sref">pf->sock,acceptsref">sock, sref">sock,acceptint,t, 1226        <4 uct 1189         4      f47gs = (, /*
security_socket_p owner))
sock,acceptint,t, newfile1, *S_SOCK_NONB=rn          * Obtain the fi4st so47="sref">out_rsocket.c#L1189" id="L1189" class="line" namee" name=n out_release;
         */
1259 < 0)
1136         4 href="+co4e=err" class="sref">err = <48lass="sref">out_modulowner))
ef">owner))
getf">eint,t, 1260         4 (e4r4822" class="line" name                          ="net/socket.c#L1281leily" class="srefleit/sock2)e" name=e="L1136">1136         4      goto4out;
seet/socket.c#L1270CONNABORTED"L1270" class="lCONNABORTEDreturn retval;
;
         * module can ha4e its48="sref">out_release1254
         */
pf->usockvemove_adde_to_lassint,t(ref="+code=sock1" class="saddeL1263" class="line"adde_BUG_*)="net/socket.c#L1281addeasnly" class="srefaddeasnname="L1260">1260         4 et/socket4e=module_put" class="sref4>modu48="sref">out_releaseerr = <487"sref">out_releasee4r48sref">ENFILE; ;
1254
res<4a> = 49name="L1171">1171        <4net/socket4c#L1192" id="L1192" class4"line49href="+code=pfr 8) Not kernel problem.F, * SOCK_ are no 1inhef">ed via1accept() unlikef="net/soOSes..ce" name="L1279">1279
1213int  < 0)
sock1=f_ket.alaf="+code=type" classe2" dlass="sref">soce2" dnameref="+code=type" e2" cla1222" class="liL12>, *o4t_mod49cu_read_unlock();
pf->soce2" dname="L1226">1226        <4nan class=4e=err" class="sref">err = -49name="L1246">1246ou4_modu49D_BUG_ON((sock,pos>,acceptsref">sock, sref">sock,pos>,acceptint,t, 1226        <4 href="+co4e=sock" class="sref">sock4/a>-&49name="L1238">1238        <4 href="+co4e=module_put" class="sref4>modu4e_putpf->1251        <4net/socket4ck_release" class="sref">4ut_so49cu_read_unlock();
sock;
newfile1, *socf1157        <5 href="+co5e=sock_release" class="sr5f">so50a>:
pf->1251        <5 1ref="+co5e#L1192" id="L1192" class5>err<50href="+code=peate(&1264        s5net/socket5c#L1203" id="L1203" class5"line50 = 1251        <5 3t/socket5c#L1194" id="L1194" class5lease50 < 0)
sock);
1226        <5 href="+co5e=rcu_read_unlock" class=5sref"50cu_read_unlock();
sock1errsock,soce2" dname=rn ou5="lin50D_BUG_ON(/socket.c#L1221+code4"n.sref">pf->sock5"line50ther /a>;
1251        <5 8et/socke5.=module_put" class="sref5ck_cr50_put(pf->5="lin50cu_read_unlock();
sock,soce2" dname=rn o/socket.c#L1221+code4"n.sref">pf->1254
1213int so51a>:
socket, int, sock,acceptint,cka href="+code=type" cdlass="sref">socfdt/sockref="+code=sock1" class="saddeL1263" class="line"adde_BUG_ode=sock1" clas class="sref">usockvec)
1260         5"net/socke5.c#L1215" id="L1215" clas5="lin51="sref">out_releaseusockvec)
_="L1136">1136         5"net/socke5.c#L1217" id="L1217" clas5="lin51D_BUG_ON(eate(&))
socf, *SOCK_NONBLOCK) | 5276
52765276__uckA79" cnet/solity
s42 nameck /spn"net/sets.

52761257
1257/* Check the SOC4_* co42efcnt dbreakht.c#ingcnlockl.
BU42snlockl.
1177BU42ed sockNOTE:1ecrementdraft 6.3e /sbrokan>
d="L="ney
BU42id sockf">ed SEQPACKEThe underlss
5279
S4SCALL41socket.includ>cr-EINPROGRESS.c#L1186>
52595260         4 href="+5o4e=f53s" class="sref">res<4a> = 49na5B="L1189">5189         4 (so51a>:
socketolitysock,acceptint,cka href="+code=type" cdlass="sref">socfdt/sockref="+code=sock1" class="saddeL1263" class="line"adde_BUG_ode=sock1" clas class="sref">usockvecsocfsoc1263" class="lLpeer_s="saddename="L1262">5262        s4      re5u4n -53ef="+code=out" class4L1263" class="lLmyaddet/socka href="+code=type" addeleily" class="srefaddeleina5e="L1264">5264        s4 et/sock5t4e=t5pe" cl_sock_create" c5ass="5ref">h="L1264">5264        s4 net/soc5e4c#L5235" id="L1235s="sref3>modu3e_put(sock;
5222        i4 (EINVALsock);
5222        i4      3ut_so39 < 0)
socf5267        <4 href="+5o4c#L53k" class="sref">sock4/a>-&49na5e="L1269">5269         4 href="+5o4e=r53ule_put" class="sref5ck_cr50 href="net/socket.c#L1222" =sock1222" class="line" namee=create" class="smilyfd_lookup_lighf">sock;
socfdt/sock="net/socket.c#L1281"L1264" class="line" namere="net/socket.c#L1281csocf5270        <4 ((5230        <4      go5o4err5273         4net/sock5t4c#L5472" id="L1272" class4"line47href="+code=pf" class="sref">pf->->socfsoc1263"3" class="lLmyaddet/socka href="+code=type" addeleily" class="srefaddeleiname, (ref="+code=sock1" class="saddeL1263" class="line"adde_BUG_*)="net/socket.c#L1281addeasnly" class="srefaddeasnnam5e="L1274">5274
5213int f47gs = (o/socket.c#L1221+code4"n.sref">pf->5213int 5213int /*
5="+code=retval" 4code=out5 4las54ule_put" class="sref">ou4_modu49D_BUG_ON((sock,pos>,acceptint,t, pf->5267        <4pan clas5=4com5438" id="L1238" class4"line437/a>K_NONBLOCK != e4ef">f47gs = (o/socket.c#L1221+code4"n.sref">pf->5273         4n(S4SCALL45na5urn security_socket_p owner))olitysock,pos>,acceptint,t, 5171        <4 href="+5o4e=s55=err" class="sref">e4r4822" class=sock;
newfile1, *S_SOCK_NON5Yrn pf->();
sock;
newfile1, *socf5224        <4      go5o4c#L5255" i44 href="+code=ut_modul/socket.c#L1221+cref">pf->5276/*" class5>err<50href="+code=peate(&5276 *5     Clin51D_BUG_ON(eate(e="L1257">5257sock4/a>-&49na5e="L1279">5279
S4SCALL4_unlockl.
5213int 
5230        <4      in5 4a h56=retval" class="sref4>retv42">__uck    ef="net/s"L127278"+code5226        <4"net/soc5e4.c#56ode=socket" class="s4ef">s42 ept() unlikef="net/soOSes..ce" na5e="L1136">5136         4ruct 5226        <4"et/sock5t4+co56eate_kern" class="sr5f">so51a>:
socketgets5"l href="net/socket.c#L1s5"l hreyacceptsref">sock,acceptint,cka href="+code=type" cdlass="sref">socfdt/sockref="+code=sock1" class="saddeL1263" class="line"adde_BUG_ode=sock1" clas class="sref">usockvecsocf5226        <4"     go5o4f="5code=file" class="sre4="lin51="sref">out_releaseusockvec
r="L1254">5254
sock;
5267        <4 href="+5o4e=f5ags" class="srK" clas4="sre435ref">EINVALsock);
out_code=ut_modulde=type" class=leily" class=" < 0)
socfS4SCALL45na5urn sock;
socfdt/sock="net/socket.c#L1281"L1264" class="line" namere="net/socket.c#L1281cS4SCALL45na5u="L1226">5171        <4 net/soc5e4c#L57262" id="L1262" ceas4" cla44cu_read_unlocsock(5226        <4 uct 5189         4      o4t_mod49cu_read_unlock();
pf->((sock;
S4SCALL45na5urn /*" class4"line437/a>K_NONBLOCK !=   57ule_put" class="sref4ef">f47gs = (o/socket.c#L1221+code4"n.sref">pf->sock4/a>-&49na5urn   57ule_put" class="sref5ck_cr50 href="+code=ecurity_socket_post_create" class="sref">security_socket_p owner))
ef">owner))>,acceptint,t, SOCK_NONBLOCK) | 5259K_NONBLOCK != 5136         4 href="+5o4e=e5r" class="sref">errf47gs = (o/socket.c#L1221+code4"n.sref">pf->5260         4 (pf->usockvemove_adde_to_lassint,t(ref="+code=sock1" class="saddeL1263" class="line"adde_BUG_*)="net/socket.c#L1281addeasasesocfusockvec
pf->5136         4      go5o4re58eate_kern" class="sr5"lidu4e_putpf->  58busy" class="sref">o4t_mod49();
sock;
newfile1, *socf5254
  5      44 href="+code=ut_modul/socket.c#L1221+cref">pf->5260         4 et/sock5t4e=m58217" id="L1217" clas5="lin51D_BUG_Ocode=peate(&(eate(e=n 
5254
__uckGref="n remoteL1257" cl(id="Lcodeid="L)lafdhref="ne objy
5171        <4net/sock5t4c#L59ode=socket" class="s4ef">s42 nameck    ef="net/s"L127278"+code5279
5213int so51a>:
socketgetf=3n href="net/socket.c#L1f=3n hreyacceptsref">sock,acceptint,cka href="+code=type" cdlass="sref">socfdt/sockref="+code=sock1" class="saddeL1263" class="line"adde_BUG_ode=sock1" clas class="sref">usockvecsocf5226        <4nan clas5=4e=e59     */
out_releaseusockvec
5246e="L1226">5226        <4 href="+5o4e=s59gs" class="srK" clas4="sre435ref">EINVA href="+code=sock" class="sref">sock;
5238        <4 href="+5o4e=m598s" class="srK" clas4="sre435ref">EINVALsock);
5251        <4net/sock5t4ck_5elease" class=="lin51="sref">out_code=ut_modulde=type" class=leily" class=" < 0)
socf6157        <5 href="+6o5e=s60s" class="sref">res<4a> = 49na6u="L1251">6251        <5 1ref="+6o5e#L6072" id="L1272" class4"line47 href="net/socket.c#L1222" =sock1222" class="line" namee=create" class="smilyfd_lookup_lighf">sock;
socfdt/sock="net/socket.c#L1281"L1264" class="line" namere="net/socket.c#L1281cres<4a> = 49na6u2"L1251">6279
O_NONBNULhref="net/socketNULhedlasass="srefleit/sock2)e" name6u="L1251">6251        <5 3t/sock6t5c#L60code=flags" class="s4sref">o4t_mod49cu_read_unlock();
pf->((sock;
S4SCALL45na6e="L1226">6226        <5 href="+6o5e=r60ode=file" class="sre4= class4"line47K_NONBLOCK != 6226        <4nan clas6o5e=e60     */
o4t_mod49();
sock;
newfile1, *socferr(eate6u="L1251">6251        <5 8et/soc6e5.=m60     */
o4t_mod49cu_read_unlock();

errowner))
ef">owner))>,acceptint,t, 
6="+code=retval" 5"net/soc6e5.c#61=err" class="sref">e4r4822" class="line"1ss="sref">socf6254
 != 6213int pf->usockvemove_adde_to_lassint,t(ref="+code=sock1" class="saddeL1263" class="line"adde_BUG_*)="net/socket.c#L1281addeasasesocf6260         5"net/soc6e5.c#61215" id="L1215" clas555555555555555555555555555555555"sref">usockvec
pf->sock;
newfile1, *socf6136         5"net/soc6e5.c#61217" id="L121lin51D_BUG_ON(eate6ref=     56net/socke5.c#L1217" id="L6217" 61" class="sref7" clas5="lin51D_BUG_Ocode=peate(&6276(eate6rrn S4SCALL45na6e="L1276">6276s42 nameckSend a datagram


6276
62576257/* Check the SOC4_* co42eept() unlikef="net/soOSes..ce" na6e=n err = -49na6e="L1136">6177so51a>:
(&am5f">so51a>:
sock;
sock,acceptint,cka href="+code=typvoidin51="sref">out_releaseusockvecbuffenewfile1size_" class="smilyfd_ize_"ddeasaseerr = -49na6eef=     56257err, *socfdt/sockref="+code=sock1" class="saddeL1263" class="line"adde_BUG_ode=sock1" clas class="sref">usockvecckref="+code=sock1"ddeL1263""+"L1189" class="line" na6e="L1276">6279
e4L1263" class="lLmyaddet/o="+cod79
62596260         4 href="+6o4e=f63" class="srefK" clas4="sre435ref">EINVA href="+code=sock" class="sref">sock;
6189         4 (EINVALsock);
6262        s4      re6u4n -63ef="+code=out sref">3ut_so39 < 0)
6264        s4 et/sock6t4e=t633 class="srefK" clas4="sre435ref">Emsghref="+code=sock1"msghreef">sock);
6264        s4 net/soc6e4c#L6235" id="L1235s="sref3>modu3e_putsock);
3ut_so39"line" nameref="+code=type" csocf6222        i4      6267        <4 href="+6o4c#L63gs" class="sref">fla4s46 href="net/socket.c#L1222" =sock1222" class="line" namee=create" class="smilyfd_lookup_lighf">sock;
socfdt/sock="net/socket.c#L1281"L1264" class="line" namere="net/socket.c#L1281c6269         4 href="+6o4e=r63=flags" class="sreas4" cla44cu_read_unlocsock(6270        <4 (EINVAL name+code=ownere4"n.sref">pf->6230        <4      go6o4res<4a> = 49na6e="L1273">6273         4net/sock6t4c#L6472" id="L1272" class4"line47i
<;
pf->6274
pf->6213int pf->6213int o4t_mod49msgf="+code=sock1"msg#L12." class4"line47msg_i
<;
6213int /*
6="+code=retval" 4code=out6 4las64put" class="sref">ou4_modu49msgf="+code=sock1"msg#L12." class4"line47msg_contro" class="smove_adsg_contro"22" =sock1222" class="NULhref="net/socketNULhedlaref">pf->6267        <4pan clas6=4com64gs" class="sref">fla4s46msgf="+code=sock1"msg#L12." class4"line47msg_contro"code=ut_modulde=tymsg_contro"cod22" =so0ref">pf->6="+code=retval" 4chref="+6o4f="64ule_put" class="sref5ck_cr50msgf="+code=sock1"msg#L12." class4"line47msg_ hrecode=ut_modulde=tymsg_ hrecod22" =so0ref">pf->6273         4n(ckref="+code=sock1"ddeL1263=ass="srefleit/sock2)e" name6urn errpf->->
6171        <4 href="+6o4e=s65=err" class="sref">e4K" clas4="sre47>SOCK_NONBLOCK != oef">f47gs = (o/socket.c#L1221+code4"n.sref">pf->o4t_mod49msgf="+code=sock1"msg#L12." class4"line47msg_ href="net/socket.cmsg_ hre22" =soly" class="srefaddeleiname, (ref="+code=sock1" class="saddeL1263" class="line"adde_BUG_*)="net/socket.c#L1281addearef">pf->6224        <4      go6o4c#L65215" id="L1215" clas5s="sref5ck_cr50msgf="+code=sock1"msg#L12." class4"line47msg_ hrecode=ut_modulde=tymsg_ hrecod22" =so" class="lLmyaddet/o="+cod79
pf->6276/*lin51D_BUG_ON(eate6e="L1276">6276 *65     * Obtain the fi4st so47="sret.lighft/sosocket.c#L1252" id="1222" class="line" name="net/socket.c#L118"="sref">newfile1, *6257err, *pf->6279
, *,22" =so" class="lLmyadL12>, *pf->6213int 5="lin50 href="+code=ecurity_socket_post_create" class=_D_ndmsgf="+code=sock1"ass=_D_ndmsgghf">sock;
6230        <4      in6 4a h66s" class="sref">res<4a> = 49na6e="L1226">6226        <4"net/soc6e4.c#66=flagkern" class="sr5"lidu4e_putpf->6136         4ruct ();
sock;
newfile1, *socf6226        <4"et/sock6t4+co66eate_kern" class="srut_modul/socket.c#L1221+cref">pf->6226        <4"     go6o4f="6code=file" cla7" clas5="lin51D_BUG_Ocode=peate(&6254
6267        <4 href="+6o4e=f66LD_BUG_ON" class="sr4f">BU4_unlockl.
S4SCALL41socket.Send a datagram
downdhref="ne278"+coderes<4a> = 49na6u="L1226">6171        <4 net/soc6e4c#L67=flagkern" class="sr5f">so51a>:
(&so51a>:
sock;
sock,acceptint,cka href="+code=typvoidin51="sref">out_releaseusockvecbuffenewfile1size_" class="smilyfd_ize_"ddeasaseerr = -49na6e="L1226">6226        <4 uct 6189         4      ;
usockvecbuffenewfile1code=ut_modulde=type" class=leily" class="L12>, *SOCK_NONBLOCK) |   6767" id="L1267" class4"line4 na6e=n BU4_unlockl.
  67INE3" class="sref">S4SCALL41socket.Receivedhrfr   efromL1276v="nen/spanoptionallya7"cord tocL1257" c=of tocnlockl.
6136         4 href="+6o4e=e68=retval" class="sref4>retv42">__uckeenderL1257" c=fromL moved=f="net/s"L127278"+code6260         4 (s42 ept() unlikef="net/soOSes..ce" na6e="L1226">6136         4      go6o4re68eate_kern" class="sr5f">so51a>:
(&am5f">so51a>:
sock;
(&am7"cvfrompe" cltsref">sock,acceptint,cka href="+code=typvoidin51="sref">out_releaseusockvecubufenewfile1size_" class="smilyfd_ize_"ddeasaseerr = -49na6urn   68215" id="L1215" clas5unsignedla1222" class="liL12>, *socfdt/sockref="+code=sock1" class="saddeL1263" class="line"adde_BUG_ode=sock1" clas class="sref">usockvecckref="+code=sock1"ddeL1263""+"L1189" class="line" na6/="L1254">6254
  68     */
out_releaseusockvecdet/o="+cod79
6260         4 et/sock6t4e=m68put" _sock_create" c5ass="5ref"6=rn EINVA href="+code=sock" class="sref">sock;
Ei
sock);
Emsghref="+code=sock1"msghreef">sock);
6254
EINVALsock);
6171        <4net/sock6t4c#L69262" id="L1262sref">3ut_so39 < 0)
6279
3ut_so39"line" nameref="+code=type" csocf6213int o4t_mod49 href="net/socket.c#L1222" =sock1222" class="line" namee=create" class="smilyfd_lookup_lighf">sock;
socfdt/sock="net/socket.c#L1281"L1264" class="line" namere="net/socket.c#L1281c6226        <4nan clas6=4e=e69     */(6246f47gs = (sock4/a>-&49na6e="L1238">6238        <4 href="+6o4e=m69ule_put" class="sref5ck_cr50msgf="+code=sock1"msg#L12." class4"line47msg_contro" class="smove_adsg_contro"22" =sock1222" class="NULhref="net/socketNULhedlaref">pf->6251        <4net/sock6t4ck_69lease" class="sref">5="lin50msgf="+code=sock1"msg#L12." class4"line47msg_contro"code=ut_modulde=tymsg_contro"cod22" =so0ref">pf->7157        <5 href="+7o5e=s70f="+code=__user" cla4s="sr46msgf="+code=sock1"msg#L12." class4"line47msg_i
7251        <5 1ref="+7o5e#L7072" id="L1272" class4"line47msgf="+code=sock1"msg#L12." class4"line47msg_i
<;
7279
7213int 72"+code=retval" 4code=out7o5e=r70busy" class="sref">o4t_mod49msgf="+code=sock1"msg#L12." class4"line47msg_ href="net/socket.cmsg_ hre22" =soly" class="srefaddeleiname, (ref="+code=sock1" class="saddeL1263" class="line"adde_BUG_*)="net/socket.c#L1281addearef">pf->7226        <4nan clas7o5e=e70nt">/*
newfile1, *err, *pf->7251        <5 8et/soc7e5.=m70ule_put" class="sref5ck_cr50 href="+code=ecurity_socket_post_create" class=_7"cvmsgf="+code=sock1"ass=_7"cvmsgghf">sock;
pf->7251        <4net/sock7e5.k_70INE4" class="sref">S4SCALL45na7=rn O_NONBNULhref="net/socketNULhedlasass="srefleit/sock2)e" name7=="L1251">7="+code=retval" 5"net/soc7e5.c#71=err" class="sref">e4""L1264" class=t.c2t; 0)
pf->usockvemove_adde_to_lassint,t(ref="+code=sock1" class="saddeL1263" class="line"adde_BUG_*)="net/socket.c#L1281addeass="srefleit/sock2)e" name7=2"L1251">7254
usockvecckref="+code=sock1"ddeL1263"="sref">usockvecdet/o="+cod79
pf->7213int 7260         5"net/soc7e5.c#71215" id="L1215" clas555555555s="sref5ck_cr50 href="+code=ecurity_socket_post_create" clt.c2t; 0)
/*lin51D_BUG_ON(eate7_="L1136">7136         5"net/soc7e5.c#7167" id="L1267" class4"line4 na7ref=     57net/socke5.c#L1217" id="L7217" 71gs" class="sref">fla4s46();
sock;
newfile1, *socf7276 = (pf->7276(eate7ern 7276
72577257/* Check the SOC4_* co42eept() unlikef="net/soOSes..ce" na7e=n err = -49na7e="L1136">7177 sref">3ut_so39"tint,cka href="+code=typvoidin51="sref">out_releasenewfile1size_" class="smilyfd_ize_"ddeaaseerr = -49na7eef=     57257err, *7279
7259(&amc=)y7"cvfrom;
newfile1size class="smilyfd_ize clasa1222" class="liL12>, *O_NONBNULhref="net/socketNULhedlasef="L1264" class="line" na7e="L1260">7260         4 href="+7o4e=f73=retvlin51D_BUG_ON(eate7B="L1189">7189         4 ((eate7e="L1262">7262        s4      re7u4n -73=flags" class="sref"4flags4_unlockl.
7264        s4 et/sock7t4e=t7324" id="L1224" class4"line42nnameckSen/sref="ne option. Becakve we donid="Lt know ="n option ="+gths we havcnlockl.
7264        s4 net/soc7e4c#L73nt">/* Check the SOC4_* co42enameckto pthe tocLnet/smNON ptr   tt/sforkf the underlskto sore oue278"+code        i4 (7222        i4      7267        <4 href="+7o4c#L73gs" cs="sref">O_NONB5f">so51a>:
so51a>:
sock;
sock,acceptint,cka href="+code=typtsref">sock,acceleve" class="smove_aleve"de=typtsref">sock,acceopt href="net/socket.copt hre classs="sref">err = -49na7e="L1276">7269         4 href="+7o4e=r73=err" class="sref">e4charin51="sref">out_releaseusockvecoptva" class="smove_aoptva"de=typtsref">sock,acceopt="+cod79
7270        <4 (7230        <4      go7o43ut_so39 < 0)
socf7273         4net/sock7t4c#L741 class="srefK" clas4="sre435ref">EINVA href="+code=sock" class="sref">sock;
7274
7213int 
7213int int err = -49na7e="L1222">7="+code=retval" 4code=out7 4las74put" class="sref">ou4_modu49 href="net/socket.c#L1222" =sock1222" class="line" namee=create" class="smilyfd_lookup_lighf">sock;
socfdt/sock="net/socket.c#L1281"L1264" class="line" namere="net/socket.c#L1281cerr = -49na7e="L1267">7267        <4pan clas7=4com74gs" class="srK" clas4="sre47>SOC href="net/socket.c#L1222" =lass="sref">O_NONBNULhref="net/socketNULhedlasass="srefleit/sock2)e" name7e="L1276">7="+code=retval" 4chref="+7o4f="74=err" class="sref">e4s="sref5ck_cr50 href="+code=ecurity_socket_post_create" cla_BUG_ON((sock;
sock,acceleve" class="smove_aleve"de=typ">sock,acceopt href="net/socket.copt hre class="sreref">err = -49na7e="L1270">7273         4n(K_NONBLOCK != errf47gs = (o/socket.c#L1221+code4"n.sref">pf->7171        <4 href="+7o4e=s75ode=sin51D_BUG_ON(eate7Yrn leve" class="smove_aleve"de=t =t_post_create" clSOL_SOCKET *7="+code=retval" 4cet/sock7t4.c#75code=flags" class="s4sref">e4s="sref5ck_cr50 href="+code=ecurity_socket"+"L1189" class="line" na7u="L1260">7224        <4      go7o4c#L75215" id="L1215" clas5="s4sref">e4s="sref5ck_cr50ass=_eets5"lopt class="smilyfd_ss=_eets5"loptghf">sock;
sock,acceleve" class="smove_aleve"de=typ">sock,acceopt href="net/socket.copt hre clas="sref">usockvecoptva" class="smove_aoptva"de=ty"+"L1189" class="line" na7u=n e4s="sref5ck_cr50opt="+cod79
pf->7276 *75ule_put" class="sref4elseef">pf->7257erre4s="sref5ck_cr50 href="+code=ecurity_socket"+"L1189" class="line" na7u="L1276">7279
e4="s4sref">e4s="sref5ck_cr50ass=ighft/sosocket.c#L1252" id="1222" class="line" name+code=owner" class="sref">owner))eets5"lopt class="smilyfd_ets5"loptedla>sock;
sock,acceleve" class="smove_aleve"de=typ">sock,acceopt href="net/socket.copt hre clas="sref">usockvecoptva" class="smove_aoptva"de=ty"+"L1189" class="line" na7u="L1270">7213int e4s="sref5ck_cr50opt="+cod79
pf->7230        <4      in7 4a h76s" cl47gs = (o/socket.c#L1221+code4"n.sref">pf->7226        <4"net/soc7e4.c#76=err" class="sref">e4""L1264" class=();
sock;
newfile1, *socf7136         4ruct 7226        <4"et/sock7t4+co76code=flags" c7" clas5="lin51D_BUG_Ocode=peate(&7226        <4"     go7o4f="7code=flin51D_BUG_ON(eate7e=n err = -49na7r="L1254">7254

7267        <4 href="+7o4e=f76LD_BUG_ON" class="sr4f">BU42">__uckGrefsref="ne option. Becakve we donid="Lt know ="n option ="+gths we havcnlockl.
S4SCALL41socket.to pthe aLnet/smNON ptr   tt/sforkf the underlskto sore oue278"+coderes<4a> = 49na7u="L1226">7171        <4 net/soc7e4c#L77=flagkern" class="sr5f">so51a>:
so51a>:
sock;
sock,acceptint,cka href="+code=typtsref">sock,acceleve" class="smove_aleve"de=typtsref">sock,acceopt href="net/socket.copt hre classs="sref">err = -49na7e="L1226">7226        <4 uct out_releaseusockvecoptva" class="smove_aoptva"de=typtsrin51="sref">out_releaseusockvecopt="+cod79
7189         4      3ut_so39 < 0)
socfEINVA href="+code=sock" class="sref">sock;
  7767" id="L1267" class4"line4 na7e=n fla4s46 href="net/socket.c#L1222" =sock1222" class="line" namee=create" class="smilyfd_lookup_lighf">sock;
socfdt/sock="net/socket.c#L1281"L1264" class="line" namere="net/sockete=type" csocf  77=flags" class="srlas4="sre47>SOC href="net/socket.c#L1222" =lass="sref">O_NONBNULhref="net/socketNULhedlasass="srefleit/sock2)e" name7u=n o4t_mod49cu_read_unlock();
((sock;
sock,acceleve" class="smove_aleve"de=typ">sock,acceopt href="net/socket.copt hre class="sref">socf7136         4 href="+7o4e=e78" class="sref">errK_NONBLOCK != 7260         4 (e4r482ef">f47gs = (o/socket.c#L1221+code4"n.sref">pf->7136         4      go7o4re78al;
  78215" id="L1215" clas5EINVAL"4sref">o4t_mod49cu_read_unlock();

  78     */
o4t_mod49_ss=_gets5"lopt class="smilyfdass=_gets5"loptedla>sock;
sock,acceleve" class="smove_aleve"de=typ">sock,acceopt href="net/socket.copt hre clas="sref">usockvecoptva" class="smove_aoptva"de=ty"+"L1189" class="line" na7e="L1260">7260         4 et/sock7t4e=m78ule_put" class="sref4>modu48=>
o4t_mod49opt="+cod79
pf->errpf->e4="s4srefsref">o4t_mod49cu_read_unlock();
owner))gets5"lopt class="smilyfdgets5"loptedla>sock;
sock,acceleve" class="smove_aleve"de=typ">sock,acceopt href="net/socket.copt hre clas="sref">usockvecoptva" class="smove_aoptva"de=ty"+"L1189" class="line" na7c="L1254">7254
err
o4t_mod49opt="+cod79
pf->7171        <4net/sock7t4c#L79=flagkern" class="sr5"lidu4e_putpf->7279
();
sock;
newfile1, *socf7213int ;
(eate7=rn 7226        <4nan clas7=4e=e79ode=_lin51D_BUG_ON(eate7e="L1246">7246        <4 href="+7o4e=s79LD_BUG_ON" class="sr4f">BU4_unlockl.
7238        <4 href="+7o4e=m79INE3" class="sref">S4SCALL41socket.Shutdowndhref="ne278"+code7251        <4net/sock7t4ck_79220" id="L1220" clas4="lin41Eept() unlikef="net/soOSes..ce" na8=="L1157">8157        <5 href="+8o5e=s80s" class="sref">res<4a> = 49na8u="L1251">8251        <5 1ref="+8o5e#L80=flagkern" class="sr5f">so51a>:
so51a>:
sock;
sock,acceptint,cka href="+code=typtsref">sock,accehowint,cka href="+howhref="+"L1189" class="line" na8u2"L1251">8279
8213int 3ut_so39 < 0)
socf82"+code=retval" 4code=out8o5e=r80busy" class="K" clas4="sre435ref">EINVA href="+code=sock" class="sref">sock;
8226        <4nan clas8o5e=e80" class="sref">err = -49na8=rn ou4_modu49 href="net/socket.c#L1222" =sock1222" class="line" namee=create" class="smilyfd_lookup_lighf">sock;
socfdt/sock="net/socket.c#L1281"L1264" class="line" namere="net/sockete=type" csocfO_NONBNULhref="net/socketNULhedlasass="srefleit/sock2)e" name8u="L1251">8251        <5 8et/soc8e5.=m80=err" class="sref">e4s="sref5ck_cr50 href="+code=ecurity_socket_post_create" cla_BUG_ON((((sock;
sock,accehowint,cka href="+howhref=s="sref">socf8251        <4net/sock8e5.k_80 href="+code=EINVAL"4" cleas4" cla44cu_reK_NONBLOCK != errowner))ehutdownighft/sosocket.chutdownedla>sock;
sock,accehowint,cka href="+howhref=s="sref">socf8="+code=retval" 5"net/soc8e5.c#81=err" class="sref">e4""L1264" class=();
sock;
newfile1, *socf8254
(eate8e="L1213">8213int 8260         5"net/soc8e5.c#81ode=flin51D_BUG_ON(eate8o=n err = -49na8_="L1136">8136         5"net/soc8e5.c#8167" is" class="sref"4flags4_u A couple=of helpful macrossforkgetting tocL1257" c=of toc 32/64 bitpt() unlikef="net/soOSes..ce" na8ref=     58net/socke5.c#L1217" id="L8217" 81LD_BUG_ON" class="sr4f">BU42">fields whichot k 1276v" i type > sre/4unsigned) on our platforms278"+code8276S4SCALL41sept() unlikef="net/soOSes..ce" na8rrn sock;
S4pat id="1222" class="limembate" class="smove_embatedla :81"L1264" class="linemsgf="+code=sock1"msg#L12 id="1222" class="limembate" class="smove_embatedla="+"L1189" class="line" na8e="L1276">8276sock;
e4""L1264" class=COMPAT_MSGe=peate(&amCOMPAT_MSGghf">sock;
8276(&amCOMPAT_FLAGSghf">sock;
e4e4""L1264" class=COMPAT_MSGe=peate(&amCOMPAT_MSGghf">sock;
, *,22" ="+"L1189" class="line" na8e2"L1251">82768257
8257/* Check the SOC4_* co42e">e4e4BSD D_ndmsg4Ksrerfaccnlockl.
8177O_NONB5f">so51a>:
so51a>:
sock;
sock,acceptint,cka href="+code=typK" clas4="sre435ref">Emsghref="+code=sock1"msghreef">sock);
usockvecmsgf="+code=sock1"msg#L12saunsignedla1222" class="liL12>, *8279
8259E>S4pat_msghref="+code=sock1">S4pat_msghreef">sock);
S4pat *S4pat
8260         4 href="+8o4e=f83" class="sref">ersockvemove_adde_to_lass>S4pat_msghref="+code=sock1">S4pat_msghreef">sock);
usockvecmsgf="+code=sock1"msg#L12ef="L1264" class="line" na8B="L1189">8189         4 (EINVA href="+code=sock" class="sref">sock;
8262        s4      re8u4n -832 class="srefK" clas4="sre435ref">EINVALsock);
8264        s4 et/sock8t4e=t833 class="srefK" clas4="sre435ref">Ei
sock);
[ock);
],ref">sock;
snly" class="srefaddeasnna8e="L1260">8264        s4 net/soc8e4c#L83busy" class="unsignedacharin51="sref">out_ct" class="smove_act"ef">[_izeofaockvemove_adde_to_lass>msghref="+code=sock1">msghreef">) + 20]nly" class="srefaddeasnna8e=n         i4 (
);
8260        eve"3n */
sock7260         4 (7260         4 (72Rv6_pktinfoclas4="sre435ref">Emsghref="+code=so"sref">err8/4> = -49na7e="L1276">7268 837"larin5iaock         4 ( hre8=4+co83     */7260         4 (hr4id="L121ck,acceptint,ne" na8e="30        <4      go784
3ut__sydmsg4Ksrerfaccnlocklsyd 4 (hr4id="L121ck,acceptint,ve_adde_to5ref">EINVA href="+code=s8ck" c83>S4pat_msghre6        <4nan clas8o5e=e80" class="sref">err = -49na   _err = -49na)="n_ON(eate7e=)="n_ONerr = -49natota _7274
ou4_msre47>SOCo8t="+cod79
e4""L;
8276uFAUL"8o5eul80put" class="sref">ou4_ms="srefaddelass="sref">err = -498a7e="81222">7="+code=retval" 4code=out7s="line" na8e="L1276">8276ersockvemck1222" cl8ss="line" namee=create" c8ass="8milyfd_lookup_lighf">s=retval" 4code=out7get_22" class="line" na8e="L1262get_22" class="liine4 a>(&amCOMPAT_MSGghf">so_sydmsg4Ksrerfaccnlocklsyd 4 (SOC4_* co42e">e4e4BSD         4 (         4 et/sock7t4e=ock;
8276uFAUL"8o5eul80put" class="sref">ou4_mscka href=">err = -49na7e="L12678>72678/a>        <4pBUG_ON" class="sr4f">BU42">lopt class8"smilyfd_eBUG_ON((sock(&amCOMPAT_MSGghf">so_sydmsg4Ksrerfaccnlocklsyd 4 (SOC4_* co42e">e4e4BSleaseerr = -49n87e="L8270">7273         ock;
8276uFAUL"8o5eul80put" class="sref">ou4_msve_adde_tode=sin51D_BUG_ON(eate8/a>7Y84s="sref">e4""L1264" class=t.c28="smove_al8ve"de=t =t_post_create" c8SOL_S85et/i
<#L12snly" class="srefags" class="srK" clas4="sre47>SOC href="net/socket.c#L1222" =lass="sref">O_NONBNULhref="net/socketNULhedlasass="srefleit/sock2)e" name8u="L1251">8251        <5 8et/soc8e5.=m80=err" class="sref">e4s="sref5ck_cr50 href="+code=ecurity_socket_post_create" cla4""L1264" class=t.c28=re47>SOCo8="s4sref">e4s="sref5ck_cr80 hre85122">7="+code=retm69ule_put" class="sref5ck_cr50msgf="+code=sock1"msg#L12." class4"lin8class="lin8" na7u="L1260">7224  8     84      go7o4c#L75215" ref="net/socketNULhedlaref">pf->6251   82"28">sock8/a>,acceleve" class="smov8_alev85net/socket.c#L1281c7260        do not      before ocklsyd (Emsghref="+code=sor84s="sref5ck_cr50 href="+c8de=ec8rity_socket"+"ss="ubufee4""L;
8276u clSIZEet.srere6u="L1251">6251   82cka href="hft/sosocket.c#L1252" id=81222"85="liL12>, *so_sydmsg4Ksrerfaccnlocklsyd 4 (a>
) + 20]nly" clMAXghrode=sock1"msg#L12." class4"lin8copt class8t class="smilyfd_ets5"lop8edla>8ock;
  78215" 8>,acceopt 8ref="net/socket.copt hre 8las="8ref">ul" 4 et/sock7t4>  78215" 8>ve_adde_toe4.c#76=err" class="sref"8e4""L8264" class=7260        Check whetherf">sallocat+code=out_cf="+aclas4="sre435ref">Emsghref="+code=soket.c#L1188="sref">newfile1, *e4""L;
8276uNOMEMretval" 4 et/sock7t4>  78215" 8ruct (eate7e=)="n_ON
out_ct" cte" cla4""L1264" class=t.c28omme7t4+co86" class="sref">err =8-49na8r="L1254">7254 hre"+code=SOCK_NON>so_sydmsg4Ksrerfaccnlocklsyd 4 (a>
msghreef">) + 20]nly" class="srefadpef83" class="sref">ersockvemL7667" is"8class="sref"4flags4_unloc8l.  78     nna8e=n         i4 (8279(&(eate7e=)="n_ONerr = -49naGFP_KERNEwhref=s="sref">sGFP_KERNEwt" cte" cla4""L1264" class=t.c28ode=ty"+"L8ckGrefsref="ne option. Be8akve 86ilyfd_lookup_lighf">s=retm69ule_put" clas222        i4 (
         4 et/sock7t4e=ref="+"L1189" class="line" na7urn   78215" 8 hre7=4+co86INE3" class="sref">S4SCA8L41so86a>        <4pBUG_ON" class="sr4f">BU42">278"+code<8 +coderes<4a> = 49na7u="L1826">78684" class=7260        Th(Emsghref="+code=sokve_adde_tofdgets5"loptedla28tsref">8ock7254 hre"+code=SOCK_NONs="line" na8e="L1276">8276ersockvemsmove_alev8"de=typtsref">sock,ac8eopt 87nam8=="L1251">8="+cody" class="srefac#81=err" class="sref">e4""Ly" class="srefaverify_22" clanedacharin51="sref">verify_22" clanedacine4 a>(&amCOMPAT_MSGghf">so_sydmsg4Ksrerfaccnlocklsyd 4 (SOC4_* co42e">e4e222        i4 (7279
err8/4> = -49na7e="L1226">7228 87KET *usockvecckref="+code=sock1"ddeL1263"="sref">usockvecdet/o="+cod79
pf->78      EINVA href="+code=s8ck" c87rn ownersy" class="srefac#81=err" class="sref">e4""Ly" class="srefaverify_nedacharin51="sref">verify_nedacine4 a>(&amCOMPAT_MSGghf">so_sydmsg4Ksrerfaccnlocklsyd 4 (SOC4_* co42e">e4e222        i4 (7279
         4 et/sock7t4e=m78uhhhhhhhd22" s="sref">usockvecckref="+code=sock1"ddeL1263"="sref">usockvecdet/o="+cod79
pf->78 hre7=4+co81281"L1264" class="line" 8amere87>();
usockvemov49 href="net/socket.c#L1222" =s8lopt class8"smilyfda_BUG_ON((7273         ref="+"L1189" class="linfree222        i4 "linfree222retval" 4 et/sock7t4>  78215" 8pt hre cla8s="sref">socf7136 err = -49natota _so_lass="sref">usockvemal" 4 et/sock7t4>  78215" 8go7o48279
e4""L;
  78215" 8g     o4t_mod89cu_r8ad_unlock();

<8 href88222">7="+code=retval" 4code=out7>so_sydmsg4Ksrerfaccnlocklsyd 4 (a>
sock8/a>,acceleve" class="smov8_alev8"de=typ">sock,acceref="+"L1189" class="linfree222        i4 "linfree222retval" 4 et/sock7t4>  78215" 8"de=ty"+"L8189" class="line" na7e="L8260">88ity_socket"+"ss="ubufe
  78215" 8"hre7=4+co8fsref">o4t_mod49cu_read_u8lock<88="liL12>, *8276ersockvem_cr50ass=i8hft/sosocket.c#L1252" id=81222"8class="line" name+codeass="_ize classc#81=err" class="sref">e4""83" class="sref">ersockvem_opt class8t class="smilyfdgets5"lop8edla>8ock;
(&amCOMPAT_MSGghf">so_sydmsg4Ksrerfaccnlocklsyd 4 (SOC4_* co42e">e4eaode=peate(&78>,acceopt 8ref="net/socket.copt hre 8las="8ref">usockvecoptva" class="smove_aaaaaaaaaaaaaaaaaaaaaaaaaana8eefe" name7e="L1276"L12>7260         4 (a hr4id="L121ck,acceptint=4n     go8o4hre79ef="+code=out" cla8s4""L8264" class=re78al;
newfile1, *  78215" 8net/sock7t8c#L79al;
(eate7=rn   78215" 8nlass="lin8967" id="L1267" class4"li8e4 na89 an clas7=4>  78     nna8e=n 
  78215" 8s79LD_BUG_8N" class="sr4f">BU4_unloc8l.
ersockvemCALL41sock8t.Shutdowndhref="ne278"+c8de         4 et/s=retval" 4code=out7c  _7260         4 (a ef83" class="sref">ersockvemChre7=4+co8   <4net/sock7t4ck_79220"8id="L89>();
         4 ( hre8=4+co83     */8279(&err = -49naGFP_KERNEwhref=s="sref">sGFP_KERNEwt" cte" cla4""L1264" class=t.c28"net/soOSe8..ce" na8=="L1157">8157    89ck;
         4 ( hre8=howint,cka href="+howhref=s="sref">socfusockvecoptva" class="smove_aKEThref="+"L1189" class="linfree222        i4 "linfree222retval" 4 et/sock7t4>  78215" 8n,acceopt 8chutdownedla28tsref">sock8/a>,a89ef">usockvecoptva" clBUG_ON" class="sr4f">BU42"9+howhref="9"L1189" class="line" na8u9"L12590nam8=="L1251">8="+cody" class="srefac#81=err" class="sref">e4""L;
8276uFAUL"8o5eul80put" class="sref">ou4_9#L80=SOCKs9="srefleit/sock2)e" name893"L1290a>(eate8e="L1213">4tnet/soc8e4e=B8267" id="L1267" class4"line4 na8eef=   9las4="sre495ref">EINVA href="+code=s9ck" c90eckto pthe tocLnet/smNON ptlass="smove_aKETh* Cass4ul! Before this, ocklsyd." clcontrol contain class="spoo51a>s="smove_embatedlasa(>sock;
<9/socket.c#91222" id="L1222" class="l9ne" n90re7222        i4 (s Thusref">22" iler-   istt_crsmove_embatedlasa(>sock;
<9/4ocket.c#91" class="sr4f">BU4_unloc91222"90sref">O_NONB5f">so51a>:
son thiss="smove_embatedlasa(>sock;
<9/5ocket.c#91.Shutdowndhref="ne278"+c9amere90tint,cka href="+code=typK" cass="smove_aKETh*as4="sre435ref">Emsghref="+code=s9ss="sref">9ocf         4 ( hre, (void s4      re8u4n -832 class="srefK" clas4="sre435ref">EINVAL
79wnighft/so9ocket.c_BUG_ON((;
8="+cody" class="srefac  _7260     "linfree"L18o5eul80put" class="sref">ou4_9#9    <4ne9/hutdownedla28tsref">sock9ehutd9wnighft/sosocket.chutdf">EINVAL
         4 ( hreul80put" class="sref">ou4_9t,cka href9"+howhref=s="sref">socfBU42"9net/sock8t9c#L81=SOCK_NONBLOClin51D_9UG_ON91=sock1222" class="_ize class+co_sydmsg4Ksrerfaccnlocklsyd 4 (a>

8=4+co83     */ou4_9tas4="sre491" class="sref">err =9-49na91d_unlock();
7="+code=retval" 4code=out7aode=peate(&8260    ="L1264" class="line"o D_ndmsg4Ksrerfaccnlfl.
8ssint,t(ref="+code=soO_NONBLOCKmsg4KsrerfaccnlO_NONBLOCKet.ne" cla4""L1264" class=t.c29a8ref=    958net/socke5.c#L1217" id=9L821791ilyfd_lookup_lighf">sy" class="srefa+co_sydmsg4Ksrerfaccnlocklsyd 4 (a>

8|=4+co83     */8276ou4_9t5ocket.c#9hot k 1276v" i type > sre94unsi91ity_socket"+"ss="ubufee4""L+co83     */

8279(&e4s="sref5ck_>so_sydmsg4Ksrerfaccnlocklsyd 4 (SOC4_* co42e">e4etota _8279<91code=usockvec" class="sref">us9lease#def 9ls5="lin51D_BUG_OCOMPAT_M9Ge=pe9122" class="liL12>, *"linfree"L12>7260     "linfree"L18o5e="L1213">7213int 7260         4 (a"L1213">7213int EINVAL8279(&         4 ( hre, y" class="srefac  _8279<92code=type" c        i4 "linfree222retv="L1213">7213int 8276<9pan c92122">7="+code=rettype" c        i4 (7213int <9pan cla4turn (eate7=rn 8279(&        i4 ((eate7e=)="n_ON8179<9pan claype" csocf7213int 9span cla4net/sock8t4e=B829s" cs924ty_socket"+"ss="ubufe8260         5"net/soc8e5.c#81ode=flin51D_BUG_ON(eate8o=n sock,acc9ptint,cype" csocf7213int sock);
();
BU42"9ine" na8e=9L1260">8260         49href=92ef">ul" 4 et/sock7t4>  78215" 9ove_adde_t9_lass>S4pat_msghref="+cod9=sock92eptint,cka href="+code=typtid="L1267" class4"line4 na8eef=   9>EINVA hre9="+code=sock" class="sref9>sock9/a>;
<>O_NONB5f">so51a>:
so51a>:
sock;
Emsghref="+code=s9;
93d_unlock();
8264 9     93an claype" c8279CK_NONBcsock122recvf">      ="srefleit/sock2)e" name8e="L1259">8259E>S4pat_msghref="+code=sock1">S4pat_msghreef">sock);
9k;
sS4pat *S4pat
ersockve9,cka href=9+code=typtsref">sock         4 (ef">sock);
usockvecmsgf="+code=sock1"msg#L12ef="L1264" class="line" na8B="L1189">8189         4 (err9/4> = -49na7e="L1276">7269 93ck;
8262        s4      re8u4n -832 class="srefK" clas4="sre435ref">EINVALsock);
9,ne" na8e=930        <4      go794
(&Ei
sock9,ve_adde_t95ref">EINVA href="+code=s9ck" c93>S4pat_msghreef">sock);
out_ct" class="smove_act"ef">[_izeofaockvemove_adde_to_lass>msghref="+code=sock1">msghreef">) + 20]nly" class="srefaddref="net/i
sock9/socket.c#91222" id="L1222" class="l9ne" n97e="L1262">727ef">sock);
out_ct" clsnna8e=n         i4 (
);

8264<        <4net/sock6t4c#L69262" id="L1262sref">3ut__sydmsg4Ksrerfaccnlocklsyd 4 (hr4id="L121ck,acceptin9etEINVAh229 id="L1222" class="line" 9a7e=n94sock1222" claerr = -499a7e="91222">7="+code=        <4nan clas8o5e=e80" class="sref">err = -49na)="n_ON(eate7e=)="n_ONerr = -49natota _->  78215" 9ck1222" cl9ss="line" namee=create" c9ass="9milyfd_lookup_4
ou4_9/socket.c#91281"L1264" class="line" 9amere94ed) on our platforms278"+code<9scka href=9>err = -49na7e="L12679>72679/a>        <4p7260         eve"3 m hroOSes..celas4="sre435ref">Emsghref="+code=s9lopt class9"smilyfd_eBUG_ON((sock],ref">sock;
],ref">sock="sref">ul80put" class="sref">ou4_9/ne" na8e=9s="sreref">err = -49n97e="L94ef">ul" 4 et/sock7t4>  78215" 9sve_adde_t9de=sin51D_BUG_ON(eate9/a>7Y9464" class=7260        ss="sm hroOSes..cepoo51a>celas4="sre435ref">Emsghref="+code=s9="smove_al9ve"de=t =t_post_create" c9SOL_S95e="L1262">727ef">sock);
ucmsgf="+code=sock1"msg#L12ef="L1264" class="line" na8B="L1189">u="+code=sock1"ddeL1u="sref">ul80put" class="sref">ou4_9=re47>SOCo9="s4sref">e4s="sref5ck_cr90 hre95122">7="+code=
u="+c_ul80put" class="sref">ou4_9=tEINVAh229" na7u="L1260">7224  9     95d_unlock();
sock9/a>,acceleve" class="smov9_alev95222">7="+code=retval" 4code=out7s="line" na8e="L1276">8276ersockve9"de=ty"+"L9189" class="line" na7u=n 9a hre95ilyfd_lookup_lighf">s=ret=retv#def cls5=get_22" class="line" na8e="L1262get_22" class="liine4 a>(&amCOMPAT_MSGghf">so_sydmsg4Ksrerfaccnlocklsyd 4 (SOC4_* co42e">e4e4BSD         4 (94s="sref5ck_cr50 href="+c9de=ec9560         4 et/sock7t4e=ock;
8276uFAUL"8o5eul80put" class="sref">ou4_92cka href=9hft/sosocket.c#L1252" id=91222"95a>        <4pBUG_ON" class="sr4f">BU42"9copt class9t class="smilyfd_ets5"lop9edla>95tghf">sock(&amCOMPAT_MSGghf">so_sydmsg4Ksrerfaccnlocklsyd 4 (SOC4_* co42e">e4e4BSleaseBU42"9cne" na8e=9ref="net/socket.copt hre 9las="9570">7273         ock;
8276uFAUL"8o5eul80put" class="sref">ou4_9>ve_adde_t9e4.c#76=err" class="sref"9e4""L95s="sref">e4""L1264" class=t.c29ket.c#L1189="sref">newfile1, *Ei
SOC href="net/socket.c#L1222" =lass="sref">O_NONBNULhref="net/socketNULhedlasass="srefleit/sock2)e" name8u="L1251">8251        <5 8et/soc8e5.=m80=err" class="sref">e4s="sref5ck_cr50 href="+code=ecurity_socket_post_create" cla4""L1264" class=t.c29ruct 7="+code=retm69ule_put" class="sref5ck_cr50msgf="+code=sock1"msg#L12." class4"lin9omme7t4+co96" class="sref">err =9-49na96a>(eate7=rn pf->6251   9L7667" is"9class="sref"4flags4_unloc9l.e4""L;
8276u clSIZEet.srere6u="L1251">6251   9hs we havc9lockl.
        hre"+code=SOCK_NON>so_sydmsg4Ksrerfaccnlocklsyd 4 (a>
) + 20]nly" clMAXghrode=sock1"msg#L12." class4"lin9 hre7=4+co96INE3" class="sref">S4SCA9L41so96>();
  78215" 9278"+code<9 +coderes<4a> = 49na7u="L1926">79684" class=7260        Check whetherf">sallocat+code=out_cf="+aclas4="sre435ref">Emsghref="+code=s9kve_adde_t9fdgets5"loptedla28tsref">9ock7136 err = -49nac#81=err" class="sref">e4""L;
8276uNOMEMretval" 4 et/sock7t4>  78215" 9smove_alev9"de=typtsref">sock,ac9eopt 97et/i
<#L12snly" class="srefa)="n_ON(eate7e=)="n_ON
out_ct" cte" cla4""L1264" class=t.c29"sref">err9/4> = -49na7e="L1226">7229 97122">7="+code=rettype" cso_sydmsg4Ksrerfaccnlocklsyd 4 (a>
msghreef">) + 20]nly" class="srefadpef83" class="sref">ersockve9              i4 (8279(&(eate7e=)="n_ONerr = -49naGFP_KERNEwhref=s="sref">sGFP_KERNEwt" cte" cla4""L1264" class=t.c29las4="sre495ref">EINVA href="+code=s9ck" c97rn         i4 (sL1189" cref="+"L1189" class="line" na7urn   78215" 9"s we havc9"net/socket.c#L1222" =soc91222"9760       BUG_ON" class="sr4f">BU42"9 hre7=4+co91281"L1264" class="line" 9amere97code=usockvec" class="sref">us9l78"+code<9ocf((socfs32  t/so eve"3 OSes..cea];
<>O_NONB5f">so51a>:
Emsghref="+code=s9="smove_al9ve"de=t =t_post_create" c9SOL_S98"+code=ecurity_socket"+"L1189"9g     o4t_mod99cu_r98sock1222" class="ubufe8=4e" name7e="L1276"=forc(eate7e="=forc8void s4      re8u4n -832 class="srefK" clas4="sre435ref">EINVAL
o4tmsg4Ksrerfaccnlockl>o4tretval" 4 et/sock7t4>  78215" 9class="lin9" na7urn 
<9 href98222">7="+code" na8B="L1189">u="+c_8=4+co83     */sock;
  78215" 9csocket.c#9/a>,acceleve" class="smov9_alev9"de=typ">sock<=retval" 4code=out7s="line" na8e="L1276">8276ersockve9"de=ty"+"L9189" class="line" na7e="L9260">9860         4 et/serr = -49nac#81=err" class="sref">e4""Lerr = -49naverify_22" clanedacharin51="sref">verify_22" clanedacine4 a>(&amCOMPAT_MSGghf">so_sydmsg4Ksrerfaccnlocklsyd 4 (SOC4_* co42e">e4e222        i4 (7279
o4t_mod49cu_read_u9lock<98>();
usockvecckref="+code=sock1"ddeL1263"="sref">usockvecdet/o="+cod79
],ref">sock="sref">7e="L1226">7279
8276VERIFY_WRITEgf="+al" 4 et/sock7t4>  78215" 9copt class9t class="smilyfdgets5"lop9edla>9ock;
owner,acceopt 9ref="net/socket.copt hre 9las="9ref">usockvecoptva" clerr = -49nac#81=err" class="sref">e4""Lerr = -49naverify_nedacharin51="sref">verify_nedacine4 a>(&amCOMPAT_MSGghf">so_sydmsg4Ksrerfaccnlocklsyd 4 (SOC4_* co42e">e4e222        i4 (7279
usockvecckref="+code=sock1"ddeL1263"="sref">usockvecdet/o="+cod79
],ref">sock="sref">7e="L1226">7279
newfile1, *8276VERIFY_WRITEgf="+al" 4 et/sock7t4>  78215" 9net/sock7t9c#L79al;
(eate7=a fusockvemov49 href="net/socket.c#L1222" =s9nlass="lin9967" id="L1267" class4"li9e4 na99 an clas7=4>  78     ref="+"L1189" class="linfree222        i4 "linfree222retval" 4 et/sock7t4>  78215" 9s79LD_BUG_9N" class="sr4f">BU4_unloc9l.so_lass="sref">usockvemal" 4 et/sock7t4>  78215" 9CALL41sock9t.Shutdowndhref="ne278"+c9deEINVAL
  78215" 9C78"+code<9..ce" na8=="L1157">8157    99ck;
EINVAL

8=4+co83     */82768276  78215" 9nopt class9    <5 1ref="+8o5e#L80=fl9gkern99ef">ul" 4 et/sock7t4>  78215" 9n,acceopt 9chutdownedla28tsref">sock9/a>,a999"L1254">7254 hre"+code=SOCK_NONaode=peate(&8260    ="L1264" class="line"o D_ndmsg4Ksrerfaccnlfl.
8ssint,t(ref="+code=soO_NONBLOCKmsg4KsrerfaccnlO_NONBLOCKet.ne" cla4""L1264" class=t.c20+howhref=20+howdownedla28tsref">soc20+ho>20+hf">usockvecoptva" clerr = -49na"lin51D_BUG_OCOMPAT_NAMELENe==|=4+co83     */827682do8tsrhrefc3/4f/08b3c7ee107c6a1666369aaeaa645bd64855_3/20+ho> cla4""L1264" class=t.c20+1owhref=20+"sref">newfile1, *<20+"s>20+=sock1222" class="_ize classc#81=err" class="sref">e4""L+co83     */CK_NONBcsock122L"4srrecvf"> na8e="L1276">8279(&e4s="sref5ck_>so_sydmsg4Ksrerfaccnlocklsyd 4 (SOC4_* co42e">e4etota _S4pat *S4pal" 4 et/sock7t4>  78215"20+2owhref=20+#L79al;
20+a>(eate7=a fusockvemov49 href="net/socket.c#L1222" =20+3owhref=20+67" id="L1267" class4"l20+67>20+ an clas7=4>  78     ref="+"L1189" class="linfree222        i4 "linfree222retval" 4 et/sock7t4>  78215"20+4owhref=20+" class="sr4f">BU4_unlo20+" >20+4ty_socket"+"ss="ubufeso_lass="sref">usockvemal" 4 et/sock7t4>  78215"20+5owhref=20+.Shutdowndhref="ne278"+20+.S>20+ed) on our platforms278"+code20+6owhref=20+  <4net/sock7t4ck_7922020+  >20+="liL12>, *8ehowint,cka href="+howhref=s="sref">socfersockv20+7owhref=20+.ce" na8=="L1157">8157<20+.c>20+lass="line" name+codeass="_ize classc#81=err" class="sref">e4""EINVALusockvecckref="+code=sock1"ddeL1263"="sref">usockvecdet/o="+cod79
],ref">sock="sref">7e="L1226">7279
usockvecoptva" class="smove_aKETh>;
EINVAL
7e="L1226">7279
soc20+hu>20+ef">usockvecoptva" class="smove_aaaaaaaaaaaaa" na8B="L1189">u="+c_pal" 4 et/sock7t4>  78215"201howhref=20"+howhref=s="sref">socf<20"+h>20"+n usockvemov49 href="net/socket.c#L1222" =2011owhref=20c#L81=SOCK_NONBLOClin51D20c#L>20"KET *  78215"20"2owhref=201" class="sref">err 201" >20"a>(eate7=BUG_ON" class="sr4f">BU4220"3owhref=20class="sref"4flags4_u A 20cla>20"222">7="+code" na8B="L1189">c#81=err" class="sref">e4""EINVALEINVAL

8ssint,~val" 4code=out7s="line" na8e="L1276">82767279
20"ilyfd_lookup_lighf">sL1189" c4+co83     */sock;
  78215"2015owhref=20hot k 1276v" i type > sr20hot>20"60        hre"+code=SOCK_NON8al;
8220) h>20">();
  78215"20"7owhref=20ls5="lin51D_BUG_OCOMPAT_20ls5>20"a>sock;
8276  78215"20"8owhref=20_COMPATe" class="smoveMS20_CO>20"ef">usockvecoptva" cl" na8B="L1189">c#81=err" class="sref">e4""EINVALEINVAL
7279
20"ef">usockvecoptva" class="smove_aaaaaa"sref">e4s="sref5ck_>so_         4 (  78215"202howhref=20s="line" na8e="L1251">8220s=">20s=f">usockveco=owner" class="sref">owner827620e" >20sa>(eate8e="L1213"> na8B="L1189">c#81=err" class="sref">e4""EINVALEINVAL
7279
20sef"7CK" class=7="+codddddddddddddddddd"sref">e4s="sref5ck_>so>sock;
  78215"2023owhref=20Ses..ce" na8e="L1136">8120Ses>20s222">7="+code=retval" 4code=out78al;
20sde=typ">sock,acceref="+"L1189" class="linfree222        i4 "linfree222retval" 4 et/sock7t4>  78215"20s5owhref=20_ndmsgghf"28tsref">sock<20_nd>20sity_socket"+"ss="ubufee4""L+co83     */  78215"20s6owhref=20f">sock);
>20scode=usockvec" class="sref">u20s7owhref=20+code=sock1"msg#L12sauns20+co>20s22" class="liL12>, *"linfree222        i4 "linfree222retv="L1213">7213int 8260         20L12>20stedla>sock;
        i4 (7213int S4pat_msghref="+co20_la>20snighft/sosocket.chutdf">EINVAL8279(&        i4 ((eate7e=)="n_ON20="2" class="liL12>, *"linss="sref">socf7213int 20==sock1222" class="_ize class hr5f="+code8s5ck_81code=flags" c7" clas5="lin51D_BUG_Ocode=peate(&8260         5"net/soc8e5.c#81ode=flin51D_BUG_ON(eate8o=n 20=22" class="liL12>, *"li"sref">socf7213int 826420asn>20=222">7="+codeossforkgetting tocL1257" c=of toc 32/64 bitpt() unlikef="net/soOSes..ce"20=4owhref=20k;
20=de=tyBUG_ON" class="sr4f">BU422035owhref=20   4 (20=ed) on our platforms278"+code2036owhref=20+code=typtsref">sock20=code=#ifdefEINVAL = -49na7e="L1276">7220/4>>20="lin50msgf="+code=sock1"msg#L20=8owhref=2030        <4      go2030<>20=MPATode=f1"L12o" class="lLm/* Argus="l listea hrs for syd_ock1"mcally*as4="sre435ref">Emsghref="+code=20=9owhref=205ref">EINVA href="+code=205re>20=nighf#defhreEINVALEINVAL7213int EINVALersockv2041owhref=20t="+cod79
201=sock1222" class="_ize classAslass="srefK" clAL clas0),ass="_ize classAslass="srefK" clAL clas3),ass="_ize classAslass="srefK" clAL clas3),ass="_ize classAslass="srefK" clAL clas3),ass="_ize classAslass="srefK" clAL clas2),ass="_ize classAslass="srefK" clAL clas3),83" class="sref">ersockv2042owhref=20 id="L1222" class="line"20 id>201sock1222" class="ubufeersockv2043owhref=20lass="sref">err = -420las>201222">7="+code" na8B="L1189">Aslass="srefK" clAL clas6),ass="_ize classAslass="srefK" clAL clas2),ass="_ize classAslass="srefK" clAL clas5),ass="_ize classAslass="srefK" clAL clas5),ass="_ize classAslass="srefK" clAL clas3),ass="_ize classAslass="srefK" clAL clas3),83" class="sref">ersockv2044owhref=20ss="line" namee=create" 20ss=>2014ty_socket"+"ss="ubufeersockv2045owhref=201281"L1264" class="line"20128>201ed) o} unlikef="net/soOSes..ce"2046owhref=20>err = -49na7e="L12620>er>201code=usockvec" class="sref">u2047owhref=20"smilyfd_eBUG_ON((201"lin5#undefEINVALu2048owhref=20s="sreref">err = -4920s=">201ef">ul" 4 et/sock7t4>  78215"2019owhref=20de=sin51D_BUG_ON(eat20de=>201eptint,cka href="+code=typtid="L1267" class4"line4 na8eef=  205howhref=20ve"de=t =t_post_create" 20ve">20veptint,cka href="+code=typty*e4s="sref5ck_c20="s>20vlass=cka href="+code=typK" cl="smove_embatedlasa(>sock;
20v2owhref=20" na7u="L1260">7224 20" n>20veckto pthe tocLnet/smNON ptl*sset t/so eve"3 lock becauss="L1267" class4"line4 na8eef=  20v4owhref=20189" class="line" na7u=n20189>20vsref">O_NONB5f">so51a>:
2alleess="smove_embatedlasa(>sock;
20v5owhref=204s="sref5ck_cr50 href="+204s=>20vtint,cka href="+code=typK" c*as4="sre435ref">Emsghref="+code=2056owhref=20hft/sosocket.c#L1252" id20hft>20vcode=usockvec" class="sref">u2057owhref=20t class="smilyfd_ets5"lo20t c>20v22" class="liL12>, *2" class="line2lass="srefK" cl2" class="line2 clas5="lin51D_BUG_Ocode"mcall=peate(&(&call      S4pat_msghreef">sock);
ersockv2058owhref=20ref="net/socket.copt hre20ref>20vef">uf83" class="sref">ersockv2059owhref=20e4.c#76=err" class="sref20e4.>20vnighft/sosocksocknewfile1, *<20="s>20="ighft/sosock20=122">7="+code=
err 206" >20=d_unlock();
20=222">7="+code=retval" 4code=out7call=peate(&call    ov49 h1 ||efleit/sock2)e" call=peate(&call    7e=so"ss="ubufeersockv2064owhref=20ckGrefsref="ne option. B20ckG>20=de=typ">sock,acceock;

S4SC206IN>20=a>        <4p7260        copy_ 4 h832 c shouldsbecSMP safe.c*as4="sre435ref">Emsghref="+code=2067owhref=20 +code20=a>sock;
sock);
sock);
(&call    ]ea"L1213">7213int res<4a> = 49na7u="L20ref>20=70">7273         ock;
8276uFAUL"8o5eul80put" class="sref">ou420=9owhref=20fdgets5"loptedla28tsref"20fdg>20=s="sref">e4""L1264" class=t.c207howhref=20"de=typtsref">sock,a20"de>20"dty_socket"+"ss="ubufee4""L+co83     */(&audit_code"mcalline4 val" 4code=out7narn51D_BUG_OCOMPAT_narn5et.n[fleit/sock2)e" call=peate(&call    ] /ea hr918sock);
 = -49na7e="L1226">7220/4>>20"122">7="+code=rettype" c;
20"ef"7CK" class=7="+codossforkgetting tocL1257" c=of toc 32/64 bitpt() unlikef="net/soOSes..ce"2073owhref=205ref">EINVA href="+code=205re>20"net/socket.c#L1281csock20"ity_socket"+"ss="ubufesock20"code=usockvec" class="sref">u2077owhref=20ocf20"tghf">sock(&call    eef83" class="sref">ersockv2078owhref=20"smilyfda_BUG_ON((20"70">7273 caseEINVAL7213int socf20"ef">usockvecoptva" clerr = -49nac#81=err" class="sref">e4""Lerr = -49nasyd_ock1"m=peate(&yd_ock1"mine4 val" 4code=out7a01D_BUG_OCOMPAT_a0         5"net/soc8e5a11D_BUG_OCOMPAT_a1pt()">sock);
203"f">usockvecoptva" clbreaka hre8="+code=retval" 5tu2081owhref=20ve"de=t =t_post_create" 20ve">20310">7273 caseEINVAL7213int o4t_mo20las>203ef"7CK" class=7="+codnna8e=n e4""Lerr = -49nasyd_binlin51D_BUG_ONusockvecckref="+code=sock1"ddeL1263"="sref">ut(ref="+code=sohref="+code=sock1">S4pat_msghreefef">EINVALsock);

20" n>203 an clas7=4>  78     breaka hre8="+code=retval" 5tu2084owhref=20/a>,acceleve" class="smo20/a>>20340">7273 caseEINVAL7213int e4""Lerr = -49nasyd_connecm=peate(&yd_connecmine4 val" 4code=out7a01D_BUG_OCOMPAT_a0      d22" s="sref">usockvecckref="+code=sock1"ddeL1263"="sref">ut(ref="+code=sohref="+code=sock1">S4pat_msghreefef">EINVALsock);
o4t_mod49cu_read_20fsr>203>();
20370">7273 caseEINVAL7213int 203ef">usockvecoptva" cl" na8B="L1189">c#81=err" class="sref">e4""EINVAL203ef">usockvecoptva" clbreaka hre8="+code=retval" 5tu209howhref=20o4hre79ef="+code=out" cl20o4h>20o40">7273 caseEINVAL7213int newfile1, *<20="s>20oa>(eate8e="L1213"> na8B="L1189">c#81=err" class="sref">e4""EINVALusockvecckref="+code=sock1"ddeL1263"="sref">ut(ref="+code=sohref="+code=sock1">S4pat_msghreefef">EINVAL7213int ;
20oef"7CK" class=7="+codddddddddddddddddd (=
EINVAL20o an clas7=4>  78     breaka hre8="+code=retval" 5tu2094owhref=20N" class="sr4f">BU4_unlo20N" >20o40">7273 caseEINVAL7213int 20o60         4 et/serr = -49nac#81=err" class="sref">e4"""L1213">7213int 20o>();
EINVALin>o4tmsg4Ksrerfaccnl;yd_geta>in>o4tine4 val" 4code=out7a01D_BUG_OCOMPAT_a0      d22" s="sref">usockvecckref="+code=sock1"ddeL1263"="sref">ut(ref="+code=sohref="+code=sock1">S4pat_msghreefef">EINVAL7213int 8157<20..c>20olass="line" name+codeeeeeeeeeeeeeeeeeeeee(=
EINVALusockvecoptva" clbreaka hre8="+code=retval" 5tu2099owhref=20chutdownedla28tsref">soc20chu>20o90">7273 caseEINVAL7213int soc21+ho>21+hf">usockvecoptva" clerr = -49nac#81=err" class="sref">e4"""L1213">7213int newfile1, *<21+"s>210KET *EINVALo4tmsg4Ksrerfaccnl;yd_getpeer>o4tine4 val" 4code=out7a01D_BUG_OCOMPAT_a0      d22" s="sref">usockvecckref="+code=sock1"ddeL1263"="sref">ut(ref="+code=sohref="+code=sock1">S4pat_msghreefef">EINVAL7213int ;
210ef"7CK" class=7="+codddddddddddddddddd ee(=
EINVAL21+ an clas7=4>  78     breaka hre8="+code=retval" 5tu21+4owhref=21+" class="sr4f">BU4_unlo21+" >21040">7273 caseEINVAL7213int 21060         4 et/serr = -49nac#81=err" class="sref">e4""Lerr = -49nasyd_a>int paicode=sock1"ddeL12yd_a>int paicine4 val" 4code=out7a01D_BUG_OCOMPAT_a0         5"net/soc8e5a11D_BUG_OCOMPAT_a1pt()">sock);

EINVAL210>();
8157<21+.c>21070">7273 caseEINVAL7213int usockvecoptva" clerr = -49nac#81=err" class="sref">e4""Lerr = -49nasyd_aenlin51D_BUG_ONEINVALsock);
EINVALsoc21+hu>21+ef">usockvecoptva" clbreaka hre8="+code=retval" 5tu211howhref=21"+howhref=s="sref">socf<21"+h>21140">7273 caseEINVAL7213int 21"KET * = -49nac#81=err" class="sref">e4""Lerr = -49nasyd_aenltoin51D_BUG_ONEINVALsock);
EINVAL7213int err 211" >211ef"7CK" class=7="+coddddddddddddddddddd22" s="sref">usockvecckref="+code=sock1"ddeL1263"="sref">ut(ref="+code=sohref="+code=sock1">S4pat_msghreefef">EINVALEINVAL211 an clas7=4>  78     breaka hre8="+code=retval" 5tu2114owhref=2158net/socke5.c#L1217" id2158n>21140">7273 caseEINVAL) + 20]nlySYS_RECram7e="L1213">7213int  sr21hot>21160         4 et/serr = -49nac#81=err" class="sref">e4""Lerr = -49nasyd_recvin51D_BUG_ONEINVALsock);
EINVAL8221) h>21">();
21170">7273 caseEINVAL8276SYS_RECrFROMam7e="L1213">7213int usockvecoptva" cl" na8B="L1189">c#81=err" class="sref">e4""EINVALEINVALsock);
EINVAL7213int 21"ef">usockvecoptva" class="smove_aaaaaaddd22" s="sref">usockvecckref="+code=sock1"ddeL1263"="sref">ut(ref="+code=sohref="+code=sock1">S4pat_msghreefef">EINVAL7213int 8221s=">21264" class=
EINVAL827621e" >21sa>(eate8e="L1213"breaka hre8="+code=retval" 5tu2122owhref=21pan cla4turn 21sef"7CK" classcaseEINVAL7213int 8121Ses>212 an clas7=4>  78     err = -49nac#81=err" class="sref">e4""Lerr = -49nasyd_ahutdowelease21sde=typ">sock,accebreaka hre8="+code=retval" 5tu2125owhref=21_ndmsgghf"28tsref">sock<21_nd>21sity_socket"+"caseEINVAL7213int sock);
>212>();
 = -49nac#81=err" class="sref">e4""Lerr = -49nasyd_aeta>inopm=peate(&yd_oeta>inopmine4 val" 4code=out7a01D_BUG_OCOMPAT_a0         5"net/soc8e5a11D_BUG_OCOMPAT_a1pt()">sock);
EINVALEINVALsock);
212lass="line" name+codebreaka hre8="+code=retval" 5tu2128owhref=21L1260">8260         21L12>21270">7273 caseEINVAL7213int S4pat_msghref="+co21_la>21snighft/sosocket.chutdf">EINVALe4"""L1213">7213int 21364" class=EINVALinopm=peate(&yd_geta>inopmine4 val" 4code=out7a01D_BUG_OCOMPAT_a0         5"net/soc8e5a11D_BUG_OCOMPAT_a1pt()">sock);
EINVALEINVAL7213int 213KET *
EINVAL213ef"7CK" class=7="+codbreaka hre8="+code=retval" 5tu21=3owhref=21asnna8e="L1260">826421asn>21=222">7="+codecaseEINVAL7213int ;
213de=typ">sock,acceerr = -49nac#81=err" class="sref">e4""Lerr = -49nasyd_aenlf">CK_NONBcsock122Lyd_aenlf">ine4 val" 4code=out7a01D_BUG_OCOMPAT_a0      d22" s="sref">usockveccm#L6921D_BUG_OCOMPAT_m#L692ef">ut(ref="+code=sohref="+code=sock1">S4pat_msghreefef">EINVALsock);
21360         4 et/sbreaka hre8="+code=retval" 5tu21=6owhref=21+code=typtsref">sock213622">7="+codecaseEINVAL7213int  = -49na7e="L1276">7221/4>>213lass="line" name+codeass="_ize classc#81=err" class="sref">e4""EINVALCK_NONBcsock122Lyd_recvf"> na8e="L1276">8279usockveccm#L6921D_BUG_OCOMPAT_m#L692ef">ut(ref="+code=sohref="+code=sock1">S4pat_msghreefef">EINVALsock);
        <4      go2130<>213ef">usockvecoptva" clbreaka hre8="+code=retval" 5tu21=9owhref=215ref">EINVA href="+code=215re>21390">7273 caseEINVAL7213int usockvecoptva" clerr = -49nac#81=err" class="sref">e4""EINVALusockvecckref="+code=sock1"ddeL1263"="sref">ut(ref="+code=sohref="+code=sock1">S4pat_msghreefef">EINVAL7213int 
214KET *
EINVALEINVAL214ef"7CK" class=7="+codbreaka hre8="+code=retval" 5tu2143owhref=21lass="sref">err = -421las>211222">7="+codedefault="L1213">7213int 214de=typ">sock,acceerr = -49nac#81=err" class="sref">e4""L;
21460         4 et/sbreaka hre8="+code=retval" 5tu2146owhref=21>err = -49na7e="L12621>er>214622">7="+codeBUG_ON" class="sr4f">BU422147owhref=21"smilyfd_eBUG_ON((214lass="line" nossforkgetting tocL1257" c=of toc 32/64 bitpt() unlikef="net/soOSes..ce"2148owhref=21s="sreref">err = -4921s=">211ef">uBUG_ON" class="sr4f">BU422149owhref=21de=sin51D_BUG_ON(eat21de=>214s="sref">e4""L1264" class=t.c215howhref=21ve"de=t =t_post_create" 21ve">21veptin#enlifcode=SOL_SOCCCCCCCCCCCCCCC7260        asARCH_WANT_SYS_SOCKETclasc*as4="sre435ref">Emsghref="+code=21v1owhref=21="s4sref">e4s="sref5ck_c21="s>215"+code=ecurity_socket"+"L11892152owhref=21" na7u="L1260">7224 21" n>21veckto pthe tocLnet/smNON pt/*l="smove_embatedlasa(>sock;
21v3owhref=21/a>,acceleve" class="smo21/a>>21vre7222        i4 (21vsref">O_NONB5f">so51a>:
21vcode=>O_NONB5f">so51a>:
sock;
21v7owhref=21t class="smilyfd_ets5"lo21t c>21v22" clO_NONB5f">so51a>:
sock;
21v8owhref=21ref="net/socket.copt hre21ref>215MPATode=f1"L12o" class="lLme*sock;
21v9owhref=21e4.c#76=err" class="sref21e4.>215eptint,cka href="+code=typte*newfile1, *<21="s>216eptint,cka href="+code=typty*as4="sre435ref">Emsghref="+code=2161owhref=21f="76=SOCK_NONBLOClin51D21f=">21=122">=
usockveccsgh_proto_familyode=sock1"ddeL1sgh_proto_family="linesref">usockveccopsode=sock1"ddeL1opspt()<435ref">Emsghref="+code=2162owhref=216" class="sref">err 216" >21=d_unlf83" class="sref">ersockv21=3owhref=21class="sref"4flags4_unlo21cla>21=222">7="+code=
21=de=tyunlikef="net/soOSes..ce"2165owhref=21lockl.
ersockv2166owhref=216INE3" class="sref">S4SC216IN>216>();
 = -49napr=(&pr=8276KERN_CRI"ef">ut,cka href="+22"ing">"protocol %dn"L12ho+PROTO(%d)\n"s4="sre, f">EINVAL7213int 216lass="line" name+codeeeeeeeewint,cka href="+PROTOlass="srefK" cl+PROTOpt()< unlikef="net/soOSes..ce"2168owhref=21ref">res<4a> = 49na7u="L21ref>21=70">7273         ock;
21690">7273 BUG_ON" class="sr4f">BU42217howhref=21"de=typtsref">sock,a21"de>21"dty_sUG_ON" class="sr4f">BU422171owhref=21/4> = -49na7e="L1226">7221/4>>21"122">7="+code>
e4s="sref5ck_sgh_family_lockode=sock1"ddeL1sgh_family_lockpt()< unlikef="net/soOSes..ce"2172owhref=2112277e" cl_sock_create" 21122>21"ef"7CK" class hre"+code=SOCK_NONsgh_familie51D_BUG_OCOMPAT_ngh_familie5et.n[f">EINVALEmsghref="+code=2173owhref=215ref">EINVA href="+code=215re>217 an clas7=4>  78     err = -49nac#81=err" class="sref">e4""L;
8276uEXIS"pt() unlikef="net/soOSes..ce"21"4owhref=211222" id="L1222" class="21122>21"4ty_socket"+"=ownef83" class="sref">ersockv2175owhref=21"net/socket.c#L1222" =so21"ne>21760         4 et/serr = -49nasgh_familie51D_BUG_OCOMPAT_ngh_familie5et.n[f">EINVALEINVAL217>();
 = -49nac#81=err" class="sref">e4""L0 unlikef="net/soOSes..ce"21"7owhref=21ocf21"tghf">sockBU422178owhref=21"smilyfda_BUG_ON((21"70">7273 >
e4s="sref5ck_sgh_family_lockode=sock1"ddeL1sgh_family_lockpt()< unlikef="net/soOSes..ce"2179owhref=21s="sref">socf217s="sref">e4""L1264" class=t.c218howhref=213" id="L1213" class5"lin213" >218dty_socket"+"ss="ubufe(&pr=ut,cka href="+22"ing">"NET: Registrred protocol family %d\n"s4="sre, f">EINVAL21310">7273 ossforkgetting tocL1257" c=of toc 32/64 bitpt() unlikef="net/soOSes..ce"2182owhref=21las5EINVAL"4sref">o4t_mo21las>213ef"7CBUG_ON" class="sr4f">BU422183owhref=21" na7urn 
21" n>218net/socket.c#L1281c,acceleve" class="smo21/a>>218sref">O_NONB5f">so51a>:
 263"_unregistrr - re+edara protocol handlss="smove_embatedlasa(>sock;
2186owhref=21fsref">o4t_mod49cu_read_21fsr>218code=>O_NONB5f">so51a>:
21822" clO_NONB5f">so51a>:
218MPATode=f1"L12o" class="lLme*sock;
2139owhref=21ref="net/socket.copt hre21ref>218eptint,cka href="+code=typte*sock;
219howhref=21o4hre79ef="+code=out" cl21o4h>219eptint,cka href="+code=typty*newfile1, *<21="s>219lass=cka href="+code=typK" cl="smove_embatedlasa(>sock;
2192owhref=21c#L79al;
219eckto pthe tocLnet/smNON ptl*sock;
2193owhref=21967" id="L1267" class4"l21967>219re7222        i4 (sock;
2194owhref=21N" class="sr4f">BU4_unlo21N" >219sref">O_NONB5f">so51a>:
sock;
2195owhref=21t.Shutdowndhref="ne278"+21t.S>219tint,cka href="+code=typK" c*3 ef">ops="L12createaroutrefs="smove_embatedlasa(>sock;
2196owhref=21   <4net/sock7t4ck_7922021   >219code=>O_NONB5f">so51a>:
Emsghref="+code=2197owhref=21..ce" na8=="L1157">8157<21..c>21olass=void s4      re8u4n 263"_unregistrrode=sock1"ddeL1263"_unregistrrine4 =
Emsghref="+code=2198owhref=21    <5 1ref="+8o5e#L80=f21   >219ef">uf83" class="sref">ersockv2199owhref=21chutdownedla28tsref">soc21chu>21o90">7273 >
soc22+ho>220dty_sUG_ON" class="sr4f">BU4222+1owhref=22+"sref">newfile1, *<22+"s>220122">7="+code>
e4s="sref5ck_sgh_family_lockode=sock1"ddeL1sgh_family_lockpt()< unlikef="net/soOSes..ce"22+2owhref=22+#L79al;
220ef"7CK" classerr = -49nasgh_familie51D_BUG_OCOMPAT_ngh_familie5et.n[f">EINVALEINVAL220222">7="+code" na8B="L1189">spin_unlockode=sock1"ddeL12pin_unlockine4 "sref">e4s="sref5ck_sgh_family_lockode=sock1"ddeL1sgh_family_lockpt()< unlikef="net/soOSes..ce"22+4owhref=22+" class="sr4f">BU4_unlo22+" >220de=tyunlikef="net/soOSes..ce"22+5owhref=22+.Shutdowndhref="ne278"+22+.S>220ity_socket"+"ss="ubufe220code=usockvec" class="sref">u22+7owhref=22+.ce" na8=="L1157">8157<22+.c>22070">7273 ss="ubufe(&pr=ut,cka href="+22"ing">"NET: Unregistrred protocol family %d\n"s4="sre, f">EINVALuBUG_ON" class="sr4f">BU4222+9owhref=22+hutdownedla28tsref">soc22+hu>220s="sref">e4""L1264" class=t.c221howhref=22"+howhref=s="sref">socf<22"+h>2212et.ntritic =
(&ckinimef">ut(ref="+code=so263"_inim=peate(&263"_inimine4 void<435ref">Emsghref="+code=2211owhref=22c#L81=SOCK_NONBLOClin51D22c#L>22"KET *f83" class="sref">ersockv22"2owhref=221" class="sref">err 221" >221ef"7CK" classt,cka href="+code=typtid="L1267" class4"line4 na8eef=  22"3owhref=22class="sref"4flags4_u A 22cla>221re7222        i4 (221sref">O_NONB5f">so51a>:
Emsghref="+code=2215owhref=22hot k 1276v" i type > sr22hot>221ed) on our platforms278"+code22"6owhref=22) helde" na8e="L1276">8222) h>22">();
(&2"_inimine4 < unlikef="net/soOSes..ce"2217owhref=22ls5="lin51D_BUG_OCOMPAT_22ls5>221"lin50msgf="+code=sock1"msg#L2218owhref=22_COMPATe" class="smoveMS22_CO>22"ef">usockvecot,cka href="+code=typtid="L1267" class4"line4 na8eef=  22"9owhref=22ass="linemsgf="+code=soc22ass>221eptint,cka href="+code=typteeeeeeeee*8222s=">222eptint,cka href="+code=typtyeeeeeeee*as4="sre435ref">Emsghref="+code=22s1owhref=22e" na8e2"L1251">827622e" >222122">7="+code>
(&2"b_inimine4 < unlikef="net/soOSes..ce"2222owhref=22pan cla4turn 222d_unlock();
8122Ses>222 an clas7=4> t,cka href="+code=typtid="L1267" class4"line4 na8eef=  2224owhref=22span cla4net/sock8t4e=B822spa>222sref">O_NONB5f">so51a>:
protocols modules="smove_embatedlasa(>sock;
2225owhref=22_ndmsgghf"28tsref">sock<22_nd>222tint,cka href="+code=typK" ceeeeeeee*as4="sre435ref">Emsghref="+code=22s6owhref=22f">sock);
>222code=usockvec" class="sref">u22s7owhref=22+code=sock1"msg#L12sauns22+co>22270">7273 ss="ubufe(&inim_inef=chchfine4 < unlikef="net/soOSes..ce"2228owhref=22L1260">8260         22L12>22270">7273 >
(&registrr_filesystemine4 "sref">e4s="sref5ck_263"_fs_typf=peate(&263"_fs_typf="li< unlikef="net/soOSes..ce"2229owhref=22_lass>S4pat_msghref="+co22_la>22290">7273 >
(&263"_mnm">e4""L>
(& eve_mountine4 "sref">e4s="sref5ck_263"_fs_typf=peate(&263"_fs_typf="li< unlikef="net/soOSes..ce"223howhref=22="+code=sock" class="sre22="+>223dty_sUG_ON" class="sr4f">BU422231owhref=22=_BUG_ode=sock1" clasadd22=_B>223KET *7260        The realyprotocol inimialization is performed =< latrr inim2allss="smove_embatedlasa(>sock;
22=2owhref=22taref="net/socket.ci
223eckto pthe tocLnet/smNON ptleeeeeeee*as4="sre435ref">Emsghref="+code=22=3owhref=22asnna8e="L1260">826422asn>223net/socket.c#L1281c;
223de=ty#ifdefEINVAL223ity_socket"+"ss="ubufe(&281filtrr_inimine4 < unlikef="net/soOSes..ce"22=6owhref=22+code=typtsref">sock223622">#enlifunlikef="net/soOSes..ce"22=7owhref=22/4> = -49na7e="L1276">7222/4>>223"lin50msgf="+code=sock1"msg#L2238owhref=2230        <4      go2230<>223ef">usockvecoossfork0 unlikef="net/soOSes..ce"22=9owhref=225ref">EINVA href="+code=225re>22390">7BUG_ON" class="sr4f">BU42224howhref=221222" id="L1222" class="22122>224dty_sUG_ON" class="sr4f">BU422241owhref=22t="+cod79
224KET *ss="ubufe(&core_inim2alline4 val" 4code=out7263"_inim=peate(&263"_inimine4);a hre"+7260        early inim2alle*as4="sre435ref">Emsghref="+code=2242owhref=22 id="L1222" class="line"22 id>224d_unlock();
err = -422las>221222">#ifdefEINVAL();
224de=tyvoid s4      re8u4n 263"et_seq_show=peate(&263"et_seq_showine4 22" s="sref">usockvecckeq_file=peate(&2eq_filef">usesref">usockvecc2eq=peate(&2eq="li<435ref">Emsghref="+code=2245owhref=221281"L1264" class="line"22128>22460ersockv2246owhref=22>err = -49na7e="L12622>er>224622">7="+code=
((224lass="line" n=
e4""L0 unlikef="net/soOSes..ce"2248owhref=22s="sreref">err = -4922s=">221ef">uunlikef="net/soOSes..ce"2249owhref=22de=sin51D_BUG_ON(eat22de=>22490">7273 >
Emsghref="+code=225howhref=22ve"de=t =t_post_create" 22ve">225hf">usockvecoptva>
e4"+"L>
(&263"ets_in_usfine4refleit/sock2)e" cpulass="srefK" clcpupt()< unlikef="net/soOSes..ce"22v1owhref=22="s4sref">e4s="sref5ck_c22="s>225"+code=ecurity_socket"+"L11892252owhref=22" na7u="L1260">7224 22" n>225ef"7CK" classt,cka href="+code=typtid It che be negative, byref">way. 8)e*as4="sre435ref">Emsghref="+code=22v3owhref=22/a>,acceleve" class="smo22/a>>225222">7="+code=retval" 4code=out7count class="srefK" clcount c">e4""49 h0<435ref">Emsghref="+code=2254owhref=22189" class="line" na7u=n22189>225de=typ">sock,acceerr = -49nacount class="srefK" clcount c">e4""L0 unlikef="net/soOSes..ce"22v5owhref=224s="sref5ck_cr50 href="+224s=>225ed) on our platforms278"+code22v6owhref=22hft/sosocket.c#L1252" id22hft>225>();
(&2eq="li,ut,cka href="+22"ing">"263"ets: uwnd %d\n"s4="sre, f">EINVALe4< unlikef="net/soOSes..ce"22v7owhref=22t class="smilyfd_ets5"lo22t c>22v22" cBUG_ON" class="sr4f">BU4222v8owhref=22ref="net/socket.copt hre22ref>225MPATo#enlifcode=SOL_SOCCCCCCCCCCCCCCC7260        CONFIG_PROC_Fle*as4="sre435ref">Emsghref="+code=22v9owhref=22e4.c#76=err" class="sref22e4.>225s="sref">e4""L1264" class=t.c226howhref=22="sref">newfile1, *<22="s>226eptin#ifdefEINVAL8276CONFIG_COMPA"="sref">e4""L1264" class=t.c2261owhref=22f="76=SOCK_NONBLOClin51D22f=">22=122">tritic long f">EINVAL(&compat_code_ioctline4 22" s="sref">usockveccfile=peate(&filef">usesref">usockveccfile=peate(&filef">u, EINVALu,ef">e4""L1264" class=t.c2262owhref=226" class="sref">err 226" >226ef"7CK" class=7="+codddddddddddddddEINVALCK_NONBcsock122ar>pt()<435ref">Emsghref="+code=22=3owhref=22class="sref"4flags4_unlo22cla>22=222">f83" class="sref">ersockv2264owhref=22ckGrefsref="ne option. B22ckG>226de=typ">sock<22" s="sref">usockvecckref"m=peate(&ref"mf">usesref">usockvecc2ockode=sock1"ddeL12ockpt()""L>
(&filef">u="L1264" class="linepr=vate_data1D_BUG_OCOMPAT_pr=vate_datapt() unlikef="net/soOSes..ce"2265owhref=22lockl.
(&rem">e4""L;
S4SC226IN>226>();
usockvecckrefode=sock1"ddeL12ockpt()"esref">usockvecc2fode=sock1"ddeL12kpt() unlikef="net/soOSes..ce"2267owhref=22 +code226lass="line" n22" s="sref">usockveccsgh=peate(&281pt()"esref">usockveccsgh=peate(&281pt() unlikef="net/soOSes..ce"2268owhref=22ref">res<4a> = 49na7u="L22ref>226ef">uunlikef="net/soOSes..ce"2269owhref=22fdgets5"loptedla28tsref"22fdg>22690">7273 >
EINVALsock,a22"de>227dty_socket"+"ss="ubufe(&281pt()""EINVAL(&ref_sghine4 val" 4code=out72fode=sock1"ddeL12kpt()< unlikef="net/soOSes..ce"2271owhref=22/4> = -49na7e="L1226">7222/4>>227"+code=ecurity_socket"+"L11892272owhref=2212277e" cl_sock_create" 22122>22"ef"7CK" class hre"+code=SOCK_NON;refode=sock1"ddeL12ockpt()="L1264" class="lineopsode=sock1"ddeL1opspt()="L1264" class="linecompat_ioctl=peate(&compat_ioctline4<435ref">Emsghref="+code=2273owhref=225ref">EINVA href="+code=225re>227 an clas7=4>  78     err = -49nar"m=peate(&rem">e4""L"+code=SOCK_NON;refode=sock1"ddeL12ockpt()="L1264" class="lineopsode=sock1"ddeL1opspt()="L1264" class="linecompat_ioctl=peate(&compat_ioctline4e"+code=SOCK_NON;refode=sock1"ddeL12ockpt(), f">EINVALu, f">EINVALCK_NONBcsock122ar>pt()< unlikef="net/soOSes..ce"2274owhref=221222" id="L1222" class="22122>227de=tyunlikef="net/soOSes..ce"2275owhref=22"net/socket.c#L1222" =so22"ne>22760        hre"+code=SOCK_NONr"m=peate(&rem">e4"""L;
227>();
un"L12howint,cka href="SIOCIWFIRS"L1276">8276SIOCIWFIRS"pt() "sref"sref f">EINVALu""49 howint,cka href="SIOCIWLAS"L1276">8276SIOCIWLAS"pt()<<435ref">Emsghref="+code=2277owhref=22ocf227lass="line" name+codeass="_ize classr"m=peate(&rem">e4""L"+code=SOCK_NONcompat_wext_handls_ioctl=peate(&compat_wext_handls_ioctline4e"+code=SOCK_NONsgh=peate(&281pt(), f">EINVALu, f">EINVALCK_NONBcsock122ar>pt()< unlikef="net/soOSes..ce"2278owhref=22"smilyfda_BUG_ON((227ef">uunlikef="net/soOSes..ce"2279owhref=22s="sref">socf22790">7273 ossforkgetting tocL125r"m=peate(&rem">e4 unlikef="net/soOSes..ce"228howhref=223" id="L1213" class5"lin223" >228dty_sBUG_ON" class="sr4f">BU422281owhref=22ve"de=t =t_post_create" 22ve">22310">7#enlifunlikef="net/soOSes..ce"2282owhref=22las5EINVAL"4sref">o4t_mo22las>228d_unlock();

22" n>228net/s 
usockvecckref"m=peate(&ref"mf">usesref">usockvecc2ockode=sock1"ddeL12ockpt(),"22" s="sref">usockvecckref="+code=sock1"ddeL1263"="sref">uesref">usockvecc="+code=sock1"ddeL1="sref">,  
Emsghref="+code=2284owhref=22/a>,acceleve" class="smo22/a>>228sref"f83" class="sref">ersockv2285owhref=22189" class="line" na7e="22189>22850">7273 ossforkgetting tocL125;refode=sock1"ddeL12ockpt()="L1264" class="lineopsode=sock1"ddeL1opspt()="L1264" class="linebinlin51D_BUG_ONEINVAL, >
o4t_mod49cu_read_22fsr>228code=BUG_ON" class="sr4f">BU422287owhref=22hft/sosocket.c#L1252" id22hft>228"lin50msgf="+code=sock1"msg#L2288owhref=22t class="smilyfdgets5"lo22t c>228MPATo 
usockvecckref"m=peate(&ref"mf">usesref">usockvecc2ockode=sock1"ddeL12ockpt()," 
CK_NONBcsock122backlo>ine4<435ref">Emsghref="+code=2289owhref=22ref="net/socket.copt hre22ref>228eptinf83" class="sref">ersockv229howhref=22o4hre79ef="+code=out" cl22o4h>22900">7273 ossforkgetting tocL125;refode=sock1"ddeL12ockpt()="L1264" class="lineopsode=sock1"ddeL1opspt()="L1264" class="linelistreleaseEINVALCK_NONBcsock122backlo>ine4< unlikef="net/soOSes..ce"2291owhref=22="sref">newfile1, *<22="s>229lass=BUG_ON" class="sr4f">BU422292owhref=22c#L79al;
229d_unlock();
229net/s 
usockvecckref"m=peate(&ref"mf">usesref">usockvecc2ockode=sock1"ddeL12ockpt(),"22" s="sref">usockvecckref"m=peate(&ref"mf">useesref">usockveccsgw2ockode=sock1"ddeL1sgw2ockpt()," 
Emsghref="+code=2294owhref=22N" class="sr4f">BU4_unlo22N" >229sref"f83" class="sref">ersockv2295owhref=22t.Shutdowndhref="ne278"+22t.S>22950">7273 22" s="sref">usockvecckrefode=sock1"ddeL12ockpt()"esref">usockvecc2fode=sock1"ddeL12kpt()""EINVAL229622">7="+code=
8157<22..c>229"lin50msgf="+code=sock1"msg#L2298owhref=22    <5 1ref="+8o5e#L80=f22   >22970">7273 >
e4""EINVAL(&263"_create_litfine4 val" 4code=out72fode=sock1"ddeL12kpt()="L1264" class="line2f_familyode=sock1"ddeL12f_familypt(), f">EINVALEINVALu,ef">e4""L1264" class=t.c2299owhref=22chutdownedla28tsref">soc22chu>229ef">usockvecoptva" class="smove_aaaasref">usockveccsgw2ockode=sock1"ddeL1sgw2ockpt()< unlikef="net/soOSes..ce"23+howhref=23+howdownedla28tsref">soc23+ho>23000">7273  hre"+code=SOCK_NONc#81=err" class="sref">e4""49 h0<435ref">Emsghref="+code=23+1owhref=23+"sref">newfile1, *<23+"s>230KET *usockveccdonf=peate(&donfpt() unlikef="net/soOSes..ce"23+2owhref=23+#L79al;
230d_unlock();
230222">7="+code" na8B="L1189">c#81=err" class="sref">e4""EINVALusockvecc2ockode=sock1"ddeL12ockpt(),"esref">usockveccsgw2ockode=sock1"ddeL1sgw2ockpt(),">
BU4_unlo23+" >23040">7273  hre"+code=SOCK_NONc#81=err" class="sref">e4""49 h0ersockv23+5owhref=23+.Shutdowndhref="ne278"+23+.S>230ity_socket"+"7="+code" na8B="L1189">263"_releasf=peate(&263"_releasfine4 esref">usockveccsgw2ockode=sock1"ddeL1sgw2ockpt()< unlikef="net/soOSes..ce"23+6owhref=23+  <4net/sock7t4ck_7922023+  >230>();
usockveccsgw2ockode=sock1"ddeL1sgw2ockpt()""EINVAL8157<23+.c>230lass="line" name+codegotoasref">usockveccdonf=peate(&donfpt() unlikef="net/soOSes..ce"23+8owhref=23+   <5 1ref="+8o5e#L80=f23+  >23070">7273 BUG_ON" class="sr4f">BU4223+9owhref=23+hutdownedla28tsref">soc23+hu>230s="sref">e4""L1264" class=t.c231howhref=23"+howhref=s="sref">socf<23"+h>23100">7273  esref">usockveccsgw2ockode=sock1"ddeL1sgw2ockpt()<="L1264" class="lineopsode=sock1"ddeL1opspt()""EINVAL231122">7="+code>
usockveccsgw2ockode=sock1"ddeL1sgw2ockpt()<="L1264" class="lineopsode=sock1"ddeL1opspt()="L1264" class="lineown class="srefK" clown cpt()< unlikef="net/soOSes..ce"23"2owhref=231" class="sref">err 231" >231d_unlock();
231re7222ref">usockveccdonf=peate(&donfpt()="L1213">7213int 23140">7273 ossforkgetting tocL1257" c=of toc 32/64 bitpt() unlikef="net/soOSes..ce"2315owhref=23hot k 1276v" i type > sr23hot>231ed) oBUG_ON" class="sr4f">BU4223"6owhref=23) helde" na8e="L1276">8223) h>231code=usockvec" class="sref">u2317owhref=23ls5="lin51D_BUG_OCOMPAT_23ls5>231"lin5 
usockvecckref"m=peate(&ref"mf">usesref">usockvecc2ockode=sock1"ddeL12ockpt(),"22" s="sref">usockvecckref="+code=sock1"ddeL1263"="sref">uesref">usockvecc="+code=sock1"ddeL1="sref">,  
e4""L1264" class=t.c2318owhref=23_COMPATe" class="smoveMS23_CO>23"ef">usockvecoptva" cl de=
Emsghref="+code=23"9owhref=23ass="linemsgf="+code=soc23ass>231eptinf83" class="sref">ersockv232howhref=23s="line" na8e="L1251">8223s=">23200">7273 ossforkgetting tocL125;refode=sock1"ddeL12ockpt()="L1264" class="lineopsode=sock1"ddeL1opspt()="L1264" class="lineconnectleaseEINVAL, >

827623e" >232lass=BUG_ON" class="sr4f">BU422322owhref=23pan cla4turn 232d_unlock();
8123Ses>232net/s 
in136"leasein136"ine4 22" s="sref">usockvecckref"m=peate(&ref"mf">usesref">usockvecc2ockode=sock1"ddeL12ockpt(),"22" s="sref">usockvecckref="+code=sock1"ddeL1263"="sref">uesref">usockvecc="+code=sock1"ddeL1="sref">,ock();
23sde=typ">sock,acceva" cl de=usockvecc="+clreleaseEmsghref="+code=2325owhref=23_ndmsgghf"28tsref">sock<23_nd>23260ersockv23s6owhref=23f">sock);
>232>();
EINVAL, >
23222" cBUG_ON" class="sr4f">BU422328owhref=23L1260">8260         23L12>232ef">uunlikef="net/soOSes..ce"2329owhref=23_lass>S4pat_msghref="+co23_la>23290">7 
usockvecckref"m=peate(&ref"mf">usesref">usockvecc2ockode=sock1"ddeL12ockpt(),"22" s="sref">usockvecckref="+code=sock1"ddeL1263"="sref">uesref">usockvecc="+code=sock1"ddeL1="sref">,ock();
23364" class=usockvecc="+clreleaseEmsghref="+code=2331owhref=23=_BUG_ode=sock1" clasadd23=_B>233KET *f83" class="sref">ersockv23=2owhref=23taref="net/socket.ci
233ef"7CK" classossforkgetting tocL125;refode=sock1"ddeL12ockpt()="L1264" class="lineopsode=sock1"ddeL1opspt()="L1264" class="lineget136"leaseEINVAL, >
826423asn>233net/sBUG_ON" class="sr4f">BU4223=4owhref=23k;
233de=tyunlikef="net/soOSes..ce"23=5owhref=23   4 (233ity_s 
inoptleaseinoptine4 22" s="sref">usockvecckref"m=peate(&ref"mf">usesref">usockvecc2ockode=sock1"ddeL12ockpt()," 
(&levelpt()," 
,ock();
sock233>();
usockveccoptval=peate(&optvalpt()," usockveccoptlreleaseEmsghref="+code=2337owhref=23/4> = -49na7e="L1276">7223/4>>233"lin5f83" class="sref">ersockv23=8owhref=2330        <4      go2330<>23370">7273 >
   _m=peate(&mm_seg>   _m0">72sref">usockveccoldfsode=sock1"ddeL1oldfspt()""EINVALEINVA href="+code=235re>23390">7273 =
BU422341owhref=23t="+cod79
234122">7="+code>

234ef"7CK" class hre"+code=SOCK_NONlevel=peate(&levelpt()"""L"+code=SOCK_NONSOL_SOCKET=peate(&SOL_SOCKETine4<435ref">Emsghref="+code=2343owhref=23lass="sref">err = -423las>234 an clas7=4>  78     err = -49nac#81=err" class="sref">e4""EINVALinoptleaseinoptine4 "+code=SOCK_NON;refode=sock1"ddeL12ockpt(), f">EINVAL(&levelpt(),">
,">
(&optvalpt(),"sref">usockveccoptlrelease234de=typ">sock<=ownunlikef="net/soOSes..ce"2345owhref=231281"L1264" class="line"23128>23460         4 et/s" na8B="L1189">c#81=err" class="sref">e4""EINVALinoptine4 "+code=SOCK_NON;refode=sock1"ddeL12ockpt(), f">EINVAL(&levelpt(),">
,">
(&optvalpt(),unlikef="net/soOSes..ce"2346owhref=23>err = -49na7e="L12623>er>234>();
usockveccoptlrelease((23470">7273 ss="ubufe
err = -4923s=">234ef">usockvecoossfork>
(eat23de=>23490">7BUG_ON" class="sr4f">BU42235howhref=23ve"de=t =t_post_create" 23ve">235dty_sUG_ON" class="sr4f">BU4223v1owhref=23="s4sref">e4s="sref5ck_c23="s>235122">=
inoptleaseinoptine4 22" s="sref">usockvecckref"m=peate(&ref"mf">usesref">usockvecc2ockode=sock1"ddeL12ockpt()," 
(&levelpt()," 
,ock();
7224 23" n>235ef"7CK" class=7="+codddddddddcharnesref">usockveccoptval=peate(&optvalpt()," usockveccoptlreleaseEmsghref="+code=23v3owhref=23/a>,acceleve" class="smo23/a>>235222">f83" class="sref">ersockv2354owhref=23189" class="line" na7u=n23189>235de=typ">sock<>
   _m=peate(&mm_seg>   _m0">72sref">usockveccoldfsode=sock1"ddeL1oldfspt()""EINVAL235code=usockvec" class="sref">u23v7owhref=23t class="smilyfd_ets5"lo23t c>23570">7273 ss="ubufe
235ef">usockveco hre"+code=SOCK_NONlevel=peate(&levelpt()"""L"+code=SOCK_NONSOL_SOCKET=peate(&SOL_SOCKETine4<435ref">Emsghref="+code=23v9owhref=23e4.c#76=err" class="sref23e4.>235ef">usockvecoptva" clerr = -49nac#81=err" class="sref">e4""EINVALinoptleaseinoptine4 "+code=SOCK_NON;refode=sock1"ddeL12ockpt(), f">EINVAL(&levelpt(),">
,">
(&optvalpt(),csref">usockveccoptlreleasenewfile1, *<23="s>23664" class=236KET *c#81=err" class="sref">e4""EINVALinoptine4 "+code=SOCK_NON;refode=sock1"ddeL12ockpt(), f">EINVAL(&levelpt(),">
,">
(&optvalpt(),unlikef="net/soOSes..ce"2362owhref=236" class="sref">err 236" >236ef"7CK" class=7="+coddddddddddddddd hre"+code=SOL" na8B="L1189">optlrelease236222">7="+code" na8B="L1189">sgh_fsode=sock1"ddeL1sgh_fsine4 >
23640">7273 ossforkgetting tocL1257" c=of toc 32/64 bitpt() unlikef="net/soOSes..ce"2365owhref=23lockl.
BU422366owhref=236INE3" class="sref">S4SC236IN>236code=usockvec" class="sref">u2367owhref=23 +code236"lin5 
usockvecckref"m=peate(&ref"mf">usesref">usockvecc2ockode=sock1"ddeL12ockpt(),"22" s="sref">usockveccpag"leaseusockveccpag"leaseusockveccoffs"m=peate(&offs"mpt(),unlikef="net/soOSes..ce"2368owhref=23ref">res<4a> = 49na7u="L23ref>236ef">usockvecoptva" cl de"sref">usockvecckize_m=peate(&ize_m0">72sref">usockvecc;ize=peate(&izeine4," usockveccflagsode=sock1"ddeL1flagsine4<435ref">Emsghref="+code=2369owhref=23fdgets5"loptedla28tsref"23fdg>236eptinf83" class="sref">ersockv237howhref=23"de=typtsref">sock,a23"de>23700">7273  hre"+code=SOCK_NON;refode=sock1"ddeL12ockpt()="L1264" class="lineopsode=sock1"ddeL1opspt()="L1264" class="linesendpag"leaseEmsghref="+code=2371owhref=23/4> = -49na7e="L1226">7223/4>>237KET *EINVALusockveccoffs"m=peate(&offs"mpt(),2sref">usockvecc;ize=peate(&izeine4,"sref">usockveccflagsode=sock1"ddeL1flagsine4< unlikef="net/soOSes..ce"2372owhref=2312277e" cl_sock_create" 23122>237d_unlock();
EINVA href="+code=235re>237 an clas7=4> ossforkgetting tocL125;ref_no_sendpag"leaseEINVALusockveccoffs"m=peate(&offs"mpt(),2sref">usockvecc;ize=peate(&izeine4,"sref">usockveccflagsode=sock1"ddeL1flagsine4< unlikef="net/soOSes..ce"2374owhref=231222" id="L1222" class="23122>237de=tyBUG_ON" class="sr4f">BU422375owhref=23"net/socket.c#L1222" =so23"ne>237ed) on our platforms278"+code2376owhref=231281"L1264" class="line"23128>237>();
 
(& eveel_sode_ioctline4 22" s="sref">usockvecckref"m=peate(&ref"mf">usesref">usockvecc2ockode=sock1"ddeL12ockpt()," 
u, EINVALCK_NONBcsock122ar>pt()<435ref">Emsghref="+code=2377owhref=23ocf237"lin5f83" class="sref">ersockv2378owhref=23"smilyfda_BUG_ON((23770">7273 >
   _m=peate(&mm_seg>   _m0">72sref">usockveccoldfsode=sock1"ddeL1oldfspt()""EINVALsocf23790">7273 =
238dty_sUG_ON" class="sr4f">BU422381owhref=23ve"de=t =t_post_create" 23ve">238122">7="+code>

o4t_mo23las>238ef"7CK" classerr = -49nac#81=err" class="sref">e4""EINVALEINVALu, f">EINVALCK_NONBcsock122ar>pt()< unlikef="net/soOSes..ce"2383owhref=23" na7urn 
23" n>238222">7="+code" na8B="L1189">sgh_fsode=sock1"ddeL1sgh_fsine4 >
,acceleve" class="smo23/a>>238de=tyunlikef="net/soOSes..ce"2385owhref=23189" class="line" na7e="23189>23850">7273 ossforkgetting tocL1257" c=of toc 32/64 bitpt() unlikef="net/soOSes..ce"2386owhref=23fsref">o4t_mod49cu_read_23fsr>238code=BUG_ON" class="sr4f">BU422387owhref=23hft/sosocket.c#L1252" id23hft>238"lin50msgf="+code=sock1"msg#L2388owhref=23t class="smilyfdgets5"lo23t c>238MPATo 
usockvecckref"m=peate(&ref"mf">usesref">usockvecc2ockode=sock1"ddeL12ockpt(),"enumEINVAL72sref">usockvecchow=peate(&howine4<435ref">Emsghref="+code=2389owhref=23ref="net/socket.copt hre23ref>238eptinf83" class="sref">ersockv239howhref=23o4hre79ef="+code=out" cl23o4h>23900">7273 ossforkgetting tocL125;refode=sock1"ddeL12ockpt()="L1264" class="lineopsode=sock1"ddeL1opspt()="L1264" class="lineshutdoweleaseEINVAL(&howine4< unlikef="net/soOSes..ce"2391owhref=23="sref">newfile1, *<23="s>239lass=BUG_ON" class="sr4f">BU422392owhref=23c#L79al;
239d_unlock();
239re7222ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON;ref_createin51D_BUG_ONBU4_unlo23N" >239sref"2ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON;ref_create_ evein51D_BUG_ON23950">72ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON;ref_create_litf=peate(&263"_create_litfine4< unlikef="net/soOSes..ce"2396owhref=23   <4net/sock7t4ck_7922023   >239622">2ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON;ref_map_flin51D_BUG_ON8157<23..c>239"lin52ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON;ref_recvms>CK_NONBcsock122;ref_recvms>ine4< unlikef="net/soOSes..ce"2398owhref=23    <5 1ref="+8o5e#L80=f23   >23970">72ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON;ref_registrrCK_NONBcsock122;ref_registrrine4< unlikef="net/soOSes..ce"2399owhref=23chutdownedla28tsref">soc23chu>239ef">u2ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON;ref_releasf=peate(&263"_releasfine4< unlikef="net/soOSes..ce"24+howhref=24+howdownedla28tsref">soc24+ho>24000">72ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON;ref_sendms>CK_NONBcsock122;ref_sendms>ine4< unlikef="net/soOSes..ce"24+1owhref=24+"sref">newfile1, *<24+"s>240KET *ss="ubufe;
240d_unlss="ubufe240re7222ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON;reffd_lookupCK_NONBcsock122;reffd_lookupine4< unlikef="net/soOSes..ce"24+4owhref=24+" class="sr4f">BU4_unlo24+" >240sref"2ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON eveel_sendms>CK_NONBcsock122 eveel_sendms>ine4< unlikef="net/soOSes..ce"24+5owhref=24+.Shutdowndhref="ne278"+24+.S>24050">72ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON eveel_recvms>CK_NONBcsock122 eveel_recvms>ine4< unlikef="net/soOSes..ce"24+6owhref=24+  <4net/sock7t4ck_7922024+  >240622">2ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON eveel_binlin51D_BUG_ON8157<24+.c>240"lin52ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON eveel_listrelease24070">72ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON eveel_acceptleasesoc24+hu>240ef">u2ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON eveel_connectleasesocf<24"+h>24100">72ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON eveel_geta>in136"leasein136"ine4< unlikef="net/soOSes..ce"2411owhref=24c#L81=SOCK_NONBLOClin51D24c#L>241KET *ss="ubufeerr 241" >241d_unlss="ubufeinoptleaseinoptine4< unlikef="net/soOSes..ce"2413owhref=24class="sref"4flags4_u A 24cla>241re7222ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON eveel_seta>inoptleaseinoptine4< unlikef="net/soOSes..ce"2414owhref=2458net/socke5.c#L1217" id2458n>241sref"2ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON eveel_sendpag"lease sr24hot>24150">72ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON eveel_sode_ioctl=peate(& eveel_sode_ioctline4< unlikef="net/soOSes..ce"2416owhref=24) helde" na8e="L1276">8224) h>241622">2ref">usockveccEXPORT_SYMBOslass="srefK" clEXPORT_SYMBOsine4 "+code=SOCK_NON eveel_;ref_shutdowelease241"lin5


The original LXR software byref">nlikef="nhttp:/soOurceforge.et/sprojects/lxrC>LXR unitypt(), this experi> al version byrnlikef="nmailto:lxr@_BUux.no">lxr@_BUux.nopt().
lxr._BUux.no kinlly hostrd byrnlikef="nhttp:/swww.redpill-_BUpro.no">Redpill LBUpro ASpt(), provider of LBUux