/*
   * NET		An implementation of the SOCKET network access protocol.
   *
   * Version:	@(#)socket.c	1.1.93	18/02/95
   *
   * Authors:	Orest Zborowski, <obz@Kodak.COM>

   *		Ross Biro

   *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
   *
   * Fixes:
   *		Anonymous	:	NOTSOCK/BADF cleanup. Error fix in
   *					shutdown()
   *		Alan Cox	:	verify_area() fixes
   *		Alan Cox	:	Removed DDI
   *		Jonathan Kamens	:	SOCK_DGRAM reconnect bug
   *		Alan Cox	:	Moved a load of checks to the very
   *					top level.
   *		Alan Cox	:	Move address structures to/from user
   *					mode above the protocol layers.
   *		Rob Janssen	:	Allow 0 length sends.
   *		Alan Cox	:	Asynchronous I/O support (cribbed from the
   *					tty drivers).
   *		Niibe Yutaka	:	Asynchronous I/O for writes (4.4BSD style)
   *		Jeff Uphoff	:	Made max number of sockets command-line
   *					configurable.
   *		Matti Aarnio	:	Made the number of sockets dynamic,
   *					to be allocated when needed, and mr.
   *					Uphoff's max is used as max to be
   *					allowed to allocate.
   *		Linus		:	Argh. removed all the socket allocation
   *					altogether: it's in the inode now.
   *		Alan Cox	:	Made sock_alloc()/sock_release() public
   *					for NetROM and future kernel nfsd type
   *					stuff.
   *		Alan Cox	:	sendmsg/recvmsg basics.
   *		Tom Dyas	:	Export net symbols.
   *		Marcin Dalecki	:	Fixed problems with CONFIG_NET="n".
   *		Alan Cox	:	Added thread locking to sys_* calls
   *					for sockets. May have errors at the
   *					moment.
   *		Kevin Buhr	:	Fixed the dumb errors in the above.
   *		Andi Kleen	:	Some small cleanups, optimizations,
   *					and fixed a copy_from_user() bug.
   *		Tigran Aivazian	:	sys_send(args) calls sys_sendto(args, NULL, 0)

   *		Tigran Aivazian	:	Made listen(2) backlog sanity checks

   *					protocol-independent
   *
   *
   *		This program is free software; you can redistribute it and/or
   *		modify it under the terms of the GNU General Public License
   *		as published by the Free Software Foundation; either version
   *		2 of the License, or (at your option) any later version.
   *
   *
   *	This module is effectively the top level interface to the BSD socket

   *	paradigm.

   *
   *	Based upon Swansea University Computer Society NET3.039
   */

  #include <linux/mm.h>

  #include <linux/socket.h>
  #include <linux/file.h>
  #include <linux/net.h>
  #include <linux/interrupt.h>

  #include <linux/thread_info.h>

  #include <linux/rcupdate.h>

  #include <linux/netdevice.h>
  #include <linux/proc_fs.h>
  #include <linux/seq_file.h>

  #include <linux/mutex.h>

  #include <linux/if_bridge.h>

  #include <linux/if_frad.h>
  #include <linux/if_vlan.h>

  #include <linux/ptp_classify.h>

  #include <linux/init.h>
  #include <linux/poll.h>
  #include <linux/cache.h>
  #include <linux/module.h>
  #include <linux/highmem.h>

  #include <linux/mount.h>
  #include <linux/security.h>
  #include <linux/syscalls.h>
  #include <linux/compat.h>
  #include <linux/kmod.h>

  #include <linux/audit.h>

  #include <linux/wireless.h>

  #include <linux/nsproxy.h>

  #include <linux/magic.h>

  #include <linux/slab.h>

  #include <linux/xattr.h>

  #include <linux/uaccess.h>

  #include <asm/unistd.h>
  
  #include <net/compat.h>

  #include <net/wext.h>

  #include <net/cls_cgroup.h>

  
  #include <net/sock.h>
  #include <linux/netfilter.h>

  #include <linux/if_tun.h>
  #include <linux/ipv6_route.h>
  #include <linux/route.h>

  #include <linux/sockios.h>

  #include <net/busy_poll.h>

  #include <linux/errqueue.h>

  #ifdef CONFIG_NET_RX_BUSY_POLL

  unsigned int sysctl_net_busy_read __read_mostly;
  unsigned int sysctl_net_busy_poll __read_mostly;

  #endif

  static ssize_t sock_read_iter(struct kiocb *iocb, struct iov_iter *to);
  static ssize_t sock_write_iter(struct kiocb *iocb, struct iov_iter *from);

  static int sock_mmap(struct file *file, struct vm_area_struct *vma);

  
  static int sock_close(struct inode *inode, struct file *file);

  static struct wait_queue_head *sock_get_poll_head(struct file *file,
  		__poll_t events);
  static __poll_t sock_poll_mask(struct file *file, __poll_t);
  static __poll_t sock_poll(struct file *file, struct poll_table_struct *wait);

  static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg);

  #ifdef CONFIG_COMPAT
  static long compat_sock_ioctl(struct file *file,

  			      unsigned int cmd, unsigned long arg);

  #endif

  static int sock_fasync(int fd, struct file *filp, int on);

  static ssize_t sock_sendpage(struct file *file, struct page *page,
  			     int offset, size_t size, loff_t *ppos, int more);

  static ssize_t sock_splice_read(struct file *file, loff_t *ppos,

  				struct pipe_inode_info *pipe, size_t len,

  				unsigned int flags);

  /*
   *	Socket files have a set of 'special' operations as well as the generic file ones. These don't appear
   *	in the operation structures but are done directly via the socketcall() multiplexor.
   */

  static const struct file_operations socket_file_ops = {

  	.owner =	THIS_MODULE,
  	.llseek =	no_llseek,

  	.read_iter =	sock_read_iter,
  	.write_iter =	sock_write_iter,

  	.get_poll_head = sock_get_poll_head,
  	.poll_mask =	sock_poll_mask,

  	.poll =		sock_poll,
  	.unlocked_ioctl = sock_ioctl,

  #ifdef CONFIG_COMPAT
  	.compat_ioctl = compat_sock_ioctl,
  #endif

  	.mmap =		sock_mmap,

  	.release =	sock_close,
  	.fasync =	sock_fasync,

  	.sendpage =	sock_sendpage,
  	.splice_write = generic_splice_sendpage,

  	.splice_read =	sock_splice_read,

  };
  
  /*
   *	The protocol list. Each protocol is registered in here.
   */

  static DEFINE_SPINLOCK(net_family_lock);

  static const struct net_proto_family __rcu *net_families[NPROTO] __read_mostly;

  /*

   * Support routines.
   * Move socket addresses back and forth across the kernel/user
   * divide and look after the messy bits.

   */

  /**
   *	move_addr_to_kernel	-	copy a socket address into kernel space
   *	@uaddr: Address in user space
   *	@kaddr: Address in kernel space
   *	@ulen: Length in user space
   *
   *	The address is copied into kernel space. If the provided address is
   *	too long an error code of -EINVAL is returned. If the copy gives
   *	invalid addresses -EFAULT is returned. On a success 0 is returned.
   */

  int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr_storage *kaddr)

  {

  	if (ulen < 0 || ulen > sizeof(struct sockaddr_storage))

  		return -EINVAL;

  	if (ulen == 0)

  		return 0;

  	if (copy_from_user(kaddr, uaddr, ulen))

  		return -EFAULT;

  	return audit_sockaddr(ulen, kaddr);

  }
  
  /**
   *	move_addr_to_user	-	copy an address to user space
   *	@kaddr: kernel space address
   *	@klen: length of address in kernel
   *	@uaddr: user space address
   *	@ulen: pointer to user length field
   *
   *	The value pointed to by ulen on entry is the buffer length available.
   *	This is overwritten with the buffer space used. -EINVAL is returned
   *	if an overlong buffer is specified or a negative buffer size. -EFAULT
   *	is returned if either the buffer or the length field are not
   *	accessible.
   *	After copying the data up to the limit the user specifies, the true
   *	length of the data is written over the length limit the user
   *	specified. Zero is returned for a success.
   */

  static int move_addr_to_user(struct sockaddr_storage *kaddr, int klen,

  			     void __user *uaddr, int __user *ulen)

  {
  	int err;
  	int len;

  	BUG_ON(klen > sizeof(struct sockaddr_storage));

  	err = get_user(len, ulen);
  	if (err)

  		return err;

  	if (len > klen)
  		len = klen;

  	if (len < 0)

  		return -EINVAL;

  	if (len) {

  		if (audit_sockaddr(klen, kaddr))
  			return -ENOMEM;

  		if (copy_to_user(uaddr, kaddr, len))

  			return -EFAULT;
  	}
  	/*

  	 *      "fromlen shall refer to the value before truncation.."
  	 *                      1003.1g

  	 */
  	return __put_user(klen, ulen);
  }

  static struct kmem_cache *sock_inode_cachep __ro_after_init;

  
  static struct inode *sock_alloc_inode(struct super_block *sb)
  {
  	struct socket_alloc *ei;

  	struct socket_wq *wq;

  	ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL);

  	if (!ei)
  		return NULL;

  	wq = kmalloc(sizeof(*wq), GFP_KERNEL);
  	if (!wq) {

  		kmem_cache_free(sock_inode_cachep, ei);
  		return NULL;
  	}

  	init_waitqueue_head(&wq->wait);
  	wq->fasync_list = NULL;

  	wq->flags = 0;

  	RCU_INIT_POINTER(ei->socket.wq, wq);

  	ei->socket.state = SS_UNCONNECTED;
  	ei->socket.flags = 0;
  	ei->socket.ops = NULL;
  	ei->socket.sk = NULL;
  	ei->socket.file = NULL;

  
  	return &ei->vfs_inode;
  }
  
  static void sock_destroy_inode(struct inode *inode)
  {

  	struct socket_alloc *ei;

  	struct socket_wq *wq;

  
  	ei = container_of(inode, struct socket_alloc, vfs_inode);

  	wq = rcu_dereference_protected(ei->socket.wq, 1);

  	kfree_rcu(wq, rcu);

  	kmem_cache_free(sock_inode_cachep, ei);

  }

  static void init_once(void *foo)

  {

  	struct socket_alloc *ei = (struct socket_alloc *)foo;

  	inode_init_once(&ei->vfs_inode);

  }

  static void init_inodecache(void)

  {
  	sock_inode_cachep = kmem_cache_create("sock_inode_cache",

  					      sizeof(struct socket_alloc),
  					      0,
  					      (SLAB_HWCACHE_ALIGN |
  					       SLAB_RECLAIM_ACCOUNT |

  					       SLAB_MEM_SPREAD | SLAB_ACCOUNT),

  					      init_once);

  	BUG_ON(sock_inode_cachep == NULL);

  }

  static const struct super_operations sockfs_ops = {

  	.alloc_inode	= sock_alloc_inode,
  	.destroy_inode	= sock_destroy_inode,
  	.statfs		= simple_statfs,

  };

  /*
   * sockfs_dname() is called from d_path().
   */
  static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen)
  {
  	return dynamic_dname(dentry, buffer, buflen, "socket:[%lu]",

  				d_inode(dentry)->i_ino);

  }

  static const struct dentry_operations sockfs_dentry_operations = {

  	.d_dname  = sockfs_dname,

  };

  static int sockfs_xattr_get(const struct xattr_handler *handler,
  			    struct dentry *dentry, struct inode *inode,
  			    const char *suffix, void *value, size_t size)
  {
  	if (value) {
  		if (dentry->d_name.len + 1 > size)
  			return -ERANGE;
  		memcpy(value, dentry->d_name.name, dentry->d_name.len + 1);
  	}
  	return dentry->d_name.len + 1;
  }
  
  #define XATTR_SOCKPROTONAME_SUFFIX "sockprotoname"
  #define XATTR_NAME_SOCKPROTONAME (XATTR_SYSTEM_PREFIX XATTR_SOCKPROTONAME_SUFFIX)
  #define XATTR_NAME_SOCKPROTONAME_LEN (sizeof(XATTR_NAME_SOCKPROTONAME)-1)
  
  static const struct xattr_handler sockfs_xattr_handler = {
  	.name = XATTR_NAME_SOCKPROTONAME,
  	.get = sockfs_xattr_get,
  };

  static int sockfs_security_xattr_set(const struct xattr_handler *handler,
  				     struct dentry *dentry, struct inode *inode,
  				     const char *suffix, const void *value,
  				     size_t size, int flags)
  {
  	/* Handled by LSM. */
  	return -EAGAIN;
  }
  
  static const struct xattr_handler sockfs_security_xattr_handler = {
  	.prefix = XATTR_SECURITY_PREFIX,
  	.set = sockfs_security_xattr_set,
  };

  static const struct xattr_handler *sockfs_xattr_handlers[] = {
  	&sockfs_xattr_handler,

  	&sockfs_security_xattr_handler,

  	NULL
  };

  static struct dentry *sockfs_mount(struct file_system_type *fs_type,
  			 int flags, const char *dev_name, void *data)
  {

  	return mount_pseudo_xattr(fs_type, "socket:", &sockfs_ops,
  				  sockfs_xattr_handlers,
  				  &sockfs_dentry_operations, SOCKFS_MAGIC);

  }
  
  static struct vfsmount *sock_mnt __read_mostly;
  
  static struct file_system_type sock_fs_type = {
  	.name =		"sockfs",
  	.mount =	sockfs_mount,
  	.kill_sb =	kill_anon_super,
  };

  /*
   *	Obtains the first available file descriptor and sets it up for use.
   *

   *	These functions create file structures and maps them to fd space
   *	of the current process. On success it returns file descriptor

   *	and file struct implicitly stored in sock->file.
   *	Note that another thread may close file descriptor before we return
   *	from this function. We use the fact that now we do not refer
   *	to socket after mapping. If one day we will need it, this
   *	function will increment ref. count on file by 1.
   *
   *	In any case returned fd MAY BE not valid!
   *	This race condition is unavoidable
   *	with shared fd spaces, we cannot solve it inside kernel,
   *	but we take care of internal coherence yet.
   */

  struct file *sock_alloc_file(struct socket *sock, int flags, const char *dname)

  {

  	struct qstr name = { .name = "" };

  	struct path path;

  	struct file *file;

  	if (dname) {
  		name.name = dname;
  		name.len = strlen(name.name);
  	} else if (sock->sk) {
  		name.name = sock->sk->sk_prot_creator->name;
  		name.len = strlen(name.name);
  	}

  	path.dentry = d_alloc_pseudo(sock_mnt->mnt_sb, &name);

  	if (unlikely(!path.dentry)) {
  		sock_release(sock);

  		return ERR_PTR(-ENOMEM);

  	}

  	path.mnt = mntget(sock_mnt);

  	d_instantiate(path.dentry, SOCK_INODE(sock));

  	file = alloc_file(&path, O_RDWR | (flags & O_NONBLOCK),

  		  &socket_file_ops);

  	if (IS_ERR(file)) {

  		/* drop dentry, keep inode for a bit */

  		ihold(d_inode(path.dentry));

  		path_put(&path);

  		/* ... and now kill it properly */
  		sock_release(sock);

  		return file;

  	}
  
  	sock->file = file;

  	file->private_data = sock;

  	return file;

  }

  EXPORT_SYMBOL(sock_alloc_file);

  static int sock_map_fd(struct socket *sock, int flags)

  {
  	struct file *newfile;

  	int fd = get_unused_fd_flags(flags);

  	if (unlikely(fd < 0)) {
  		sock_release(sock);

  		return fd;

  	}

  	newfile = sock_alloc_file(sock, flags, NULL);

  	if (likely(!IS_ERR(newfile))) {

  		fd_install(fd, newfile);

  		return fd;
  	}

  	put_unused_fd(fd);
  	return PTR_ERR(newfile);

  }

  struct socket *sock_from_file(struct file *file, int *err)

  {

  	if (file->f_op == &socket_file_ops)
  		return file->private_data;	/* set in sock_map_fd */

  	*err = -ENOTSOCK;
  	return NULL;

  }

  EXPORT_SYMBOL(sock_from_file);

  /**

   *	sockfd_lookup - Go from a file number to its socket slot

   *	@fd: file handle
   *	@err: pointer to an error code return
   *
   *	The file handle passed in is locked and the socket it is bound

   *	to is returned. If an error occurs the err pointer is overwritten

   *	with a negative errno code and NULL is returned. The function checks
   *	for both invalid handles and passing a handle which is not a socket.
   *
   *	On a success the socket object pointer is returned.
   */
  
  struct socket *sockfd_lookup(int fd, int *err)
  {
  	struct file *file;

  	struct socket *sock;

  	file = fget(fd);
  	if (!file) {

  		*err = -EBADF;
  		return NULL;
  	}

  	sock = sock_from_file(file, err);
  	if (!sock)

  		fput(file);

  	return sock;
  }

  EXPORT_SYMBOL(sockfd_lookup);

  static struct socket *sockfd_lookup_light(int fd, int *err, int *fput_needed)
  {

  	struct fd f = fdget(fd);

  	struct socket *sock;

  	*err = -EBADF;

  	if (f.file) {
  		sock = sock_from_file(f.file, err);
  		if (likely(sock)) {
  			*fput_needed = f.flags;

  			return sock;

  		}
  		fdput(f);

  	}

  	return NULL;

  }

  static ssize_t sockfs_listxattr(struct dentry *dentry, char *buffer,
  				size_t size)
  {
  	ssize_t len;
  	ssize_t used = 0;

  	len = security_inode_listsecurity(d_inode(dentry), buffer, size);

  	if (len < 0)
  		return len;
  	used += len;
  	if (buffer) {
  		if (size < used)
  			return -ERANGE;
  		buffer += len;
  	}
  
  	len = (XATTR_NAME_SOCKPROTONAME_LEN + 1);
  	used += len;
  	if (buffer) {
  		if (size < used)
  			return -ERANGE;
  		memcpy(buffer, XATTR_NAME_SOCKPROTONAME, len);
  		buffer += len;
  	}
  
  	return used;
  }

  static int sockfs_setattr(struct dentry *dentry, struct iattr *iattr)

  {
  	int err = simple_setattr(dentry, iattr);

  	if (!err && (iattr->ia_valid & ATTR_UID)) {

  		struct socket *sock = SOCKET_I(d_inode(dentry));

  		if (sock->sk)
  			sock->sk->sk_uid = iattr->ia_uid;
  		else
  			err = -ENOENT;

  	}
  
  	return err;
  }

  static const struct inode_operations sockfs_inode_ops = {

  	.listxattr = sockfs_listxattr,

  	.setattr = sockfs_setattr,

  };

  /**
   *	sock_alloc	-	allocate a socket

   *

   *	Allocate a new inode and socket object. The two are bound together
   *	and initialised. The socket is then returned. If we are out of inodes
   *	NULL is returned.
   */

  struct socket *sock_alloc(void)

  {

  	struct inode *inode;
  	struct socket *sock;

  	inode = new_inode_pseudo(sock_mnt->mnt_sb);

  	if (!inode)
  		return NULL;
  
  	sock = SOCKET_I(inode);

  	inode->i_ino = get_next_ino();

  	inode->i_mode = S_IFSOCK | S_IRWXUGO;

  	inode->i_uid = current_fsuid();
  	inode->i_gid = current_fsgid();

  	inode->i_op = &sockfs_inode_ops;

  	return sock;
  }

  EXPORT_SYMBOL(sock_alloc);

  /**
   *	sock_release	-	close a socket
   *	@sock: socket to close
   *
   *	The socket is released from the protocol stack if it has a release
   *	callback, and the inode is then released if the socket is bound to

   *	an inode not a file.

   */

  static void __sock_release(struct socket *sock, struct inode *inode)

  {
  	if (sock->ops) {
  		struct module *owner = sock->ops->owner;

  		if (inode)
  			inode_lock(inode);

  		sock->ops->release(sock);

  		if (inode)
  			inode_unlock(inode);

  		sock->ops = NULL;
  		module_put(owner);
  	}

  	if (rcu_dereference_protected(sock->wq, 1)->fasync_list)

  		pr_err("%s: fasync list not empty!
  ", __func__);

  	if (!sock->file) {
  		iput(SOCK_INODE(sock));
  		return;
  	}

  	sock->file = NULL;

  }

  
  void sock_release(struct socket *sock)
  {
  	__sock_release(sock, NULL);
  }

  EXPORT_SYMBOL(sock_release);

  void __sock_tx_timestamp(__u16 tsflags, __u8 *tx_flags)

  {

  	u8 flags = *tx_flags;

  	if (tsflags & SOF_TIMESTAMPING_TX_HARDWARE)

  		flags |= SKBTX_HW_TSTAMP;

  	if (tsflags & SOF_TIMESTAMPING_TX_SOFTWARE)

  		flags |= SKBTX_SW_TSTAMP;

  	if (tsflags & SOF_TIMESTAMPING_TX_SCHED)

  		flags |= SKBTX_SCHED_TSTAMP;

  	*tx_flags = flags;

  }

  EXPORT_SYMBOL(__sock_tx_timestamp);

  static inline int sock_sendmsg_nosec(struct socket *sock, struct msghdr *msg)

  {

  	int ret = sock->ops->sendmsg(sock, msg, msg_data_left(msg));

  	BUG_ON(ret == -EIOCBQUEUED);
  	return ret;

  }

  int sock_sendmsg(struct socket *sock, struct msghdr *msg)

  {

  	int err = security_socket_sendmsg(sock, msg,

  					  msg_data_left(msg));

  	return err ?: sock_sendmsg_nosec(sock, msg);

  }

  EXPORT_SYMBOL(sock_sendmsg);

  
  int kernel_sendmsg(struct socket *sock, struct msghdr *msg,
  		   struct kvec *vec, size_t num, size_t size)
  {

  	iov_iter_kvec(&msg->msg_iter, WRITE | ITER_KVEC, vec, num, size);

  	return sock_sendmsg(sock, msg);

  }

  EXPORT_SYMBOL(kernel_sendmsg);

  int kernel_sendmsg_locked(struct sock *sk, struct msghdr *msg,
  			  struct kvec *vec, size_t num, size_t size)
  {
  	struct socket *sock = sk->sk_socket;
  
  	if (!sock->ops->sendmsg_locked)

  		return sock_no_sendmsg_locked(sk, msg, size);

  
  	iov_iter_kvec(&msg->msg_iter, WRITE | ITER_KVEC, vec, num, size);
  
  	return sock->ops->sendmsg_locked(sk, msg, msg_data_left(msg));
  }
  EXPORT_SYMBOL(kernel_sendmsg_locked);

  static bool skb_is_err_queue(const struct sk_buff *skb)
  {
  	/* pkt_type of skbs enqueued on the error queue are set to
  	 * PACKET_OUTGOING in skb_set_err_queue(). This is only safe to do
  	 * in recvmsg, since skbs received on a local socket will never
  	 * have a pkt_type of PACKET_OUTGOING.
  	 */
  	return skb->pkt_type == PACKET_OUTGOING;
  }

  /* On transmit, software and hardware timestamps are returned independently.
   * As the two skb clones share the hardware timestamp, which may be updated
   * before the software timestamp is received, a hardware TX timestamp may be
   * returned only if there is no software TX timestamp. Ignore false software
   * timestamps, which may be made in the __sock_recv_timestamp() call when the
   * option SO_TIMESTAMP(NS) is enabled on the socket, even when the skb has a
   * hardware timestamp.
   */
  static bool skb_is_swtx_tstamp(const struct sk_buff *skb, int false_tstamp)
  {
  	return skb->tstamp && !false_tstamp && skb_is_err_queue(skb);
  }

  static void put_ts_pktinfo(struct msghdr *msg, struct sk_buff *skb)
  {
  	struct scm_ts_pktinfo ts_pktinfo;
  	struct net_device *orig_dev;
  
  	if (!skb_mac_header_was_set(skb))
  		return;
  
  	memset(&ts_pktinfo, 0, sizeof(ts_pktinfo));
  
  	rcu_read_lock();
  	orig_dev = dev_get_by_napi_id(skb_napi_id(skb));
  	if (orig_dev)
  		ts_pktinfo.if_index = orig_dev->ifindex;
  	rcu_read_unlock();
  
  	ts_pktinfo.pkt_length = skb->len - skb_mac_offset(skb);
  	put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPING_PKTINFO,
  		 sizeof(ts_pktinfo), &ts_pktinfo);
  }

  /*
   * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
   */
  void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
  	struct sk_buff *skb)
  {

  	int need_software_tstamp = sock_flag(sk, SOCK_RCVTSTAMP);

  	struct scm_timestamping tss;

  	int empty = 1, false_tstamp = 0;

  	struct skb_shared_hwtstamps *shhwtstamps =
  		skb_hwtstamps(skb);
  
  	/* Race occurred between timestamp enabling and packet
  	   receiving.  Fill in the current time for now. */

  	if (need_software_tstamp && skb->tstamp == 0) {

  		__net_timestamp(skb);

  		false_tstamp = 1;
  	}

  
  	if (need_software_tstamp) {
  		if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
  			struct timeval tv;
  			skb_get_timestamp(skb, &tv);
  			put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP,
  				 sizeof(tv), &tv);
  		} else {

  			struct timespec ts;
  			skb_get_timestampns(skb, &ts);

  			put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS,

  				 sizeof(ts), &ts);

  		}
  	}

  	memset(&tss, 0, sizeof(tss));

  	if ((sk->sk_tsflags & SOF_TIMESTAMPING_SOFTWARE) &&

  	    ktime_to_timespec_cond(skb->tstamp, tss.ts + 0))

  		empty = 0;

  	if (shhwtstamps &&

  	    (sk->sk_tsflags & SOF_TIMESTAMPING_RAW_HARDWARE) &&

  	    !skb_is_swtx_tstamp(skb, false_tstamp) &&

  	    ktime_to_timespec_cond(shhwtstamps->hwtstamp, tss.ts + 2)) {

  		empty = 0;

  		if ((sk->sk_tsflags & SOF_TIMESTAMPING_OPT_PKTINFO) &&
  		    !skb_is_err_queue(skb))
  			put_ts_pktinfo(msg, skb);
  	}

  	if (!empty) {

  		put_cmsg(msg, SOL_SOCKET,

  			 SCM_TIMESTAMPING, sizeof(tss), &tss);

  		if (skb_is_err_queue(skb) && skb->len &&

  		    SKB_EXT_ERR(skb)->opt_stats)

  			put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPING_OPT_STATS,
  				 skb->len, skb->data);
  	}

  }

  EXPORT_SYMBOL_GPL(__sock_recv_timestamp);

  void __sock_recv_wifi_status(struct msghdr *msg, struct sock *sk,
  	struct sk_buff *skb)
  {
  	int ack;
  
  	if (!sock_flag(sk, SOCK_WIFI_STATUS))
  		return;
  	if (!skb->wifi_acked_valid)
  		return;
  
  	ack = skb->wifi_acked;
  
  	put_cmsg(msg, SOL_SOCKET, SCM_WIFI_STATUS, sizeof(ack), &ack);
  }
  EXPORT_SYMBOL_GPL(__sock_recv_wifi_status);

  static inline void sock_recv_drops(struct msghdr *msg, struct sock *sk,
  				   struct sk_buff *skb)

  {

  	if (sock_flag(sk, SOCK_RXQ_OVFL) && skb && SOCK_SKB_CB(skb)->dropcount)

  		put_cmsg(msg, SOL_SOCKET, SO_RXQ_OVFL,

  			sizeof(__u32), &SOCK_SKB_CB(skb)->dropcount);

  }

  void __sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,

  	struct sk_buff *skb)
  {
  	sock_recv_timestamp(msg, sk, skb);
  	sock_recv_drops(msg, sk, skb);
  }

  EXPORT_SYMBOL_GPL(__sock_recv_ts_and_drops);

  static inline int sock_recvmsg_nosec(struct socket *sock, struct msghdr *msg,

  				     int flags)

  {

  	return sock->ops->recvmsg(sock, msg, msg_data_left(msg), flags);

  }

  int sock_recvmsg(struct socket *sock, struct msghdr *msg, int flags)

  {

  	int err = security_socket_recvmsg(sock, msg, msg_data_left(msg), flags);

  	return err ?: sock_recvmsg_nosec(sock, msg, flags);

  }

  EXPORT_SYMBOL(sock_recvmsg);

  /**
   * kernel_recvmsg - Receive a message from a socket (kernel space)
   * @sock:       The socket to receive the message from
   * @msg:        Received message
   * @vec:        Input s/g array for message data
   * @num:        Size of input s/g array
   * @size:       Number of bytes to read
   * @flags:      Message flags (MSG_DONTWAIT, etc...)
   *
   * On return the msg structure contains the scatter/gather array passed in the
   * vec argument. The array is modified so that it consists of the unfilled
   * portion of the original array.
   *
   * The returned value is the total number of bytes received, or an error.
   */

  int kernel_recvmsg(struct socket *sock, struct msghdr *msg,
  		   struct kvec *vec, size_t num, size_t size, int flags)

  {
  	mm_segment_t oldfs = get_fs();
  	int result;

  	iov_iter_kvec(&msg->msg_iter, READ | ITER_KVEC, vec, num, size);

  	set_fs(KERNEL_DS);

  	result = sock_recvmsg(sock, msg, flags);

  	set_fs(oldfs);
  	return result;
  }

  EXPORT_SYMBOL(kernel_recvmsg);

  static ssize_t sock_sendpage(struct file *file, struct page *page,
  			     int offset, size_t size, loff_t *ppos, int more)

  {

  	struct socket *sock;
  	int flags;

  	sock = file->private_data;

  	flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
  	/* more is a combination of MSG_MORE and MSG_SENDPAGE_NOTLAST */
  	flags |= more;

  	return kernel_sendpage(sock, page, offset, size, flags);

  }

  static ssize_t sock_splice_read(struct file *file, loff_t *ppos,

  				struct pipe_inode_info *pipe, size_t len,

  				unsigned int flags)
  {
  	struct socket *sock = file->private_data;

  	if (unlikely(!sock->ops->splice_read))
  		return -EINVAL;

  	return sock->ops->splice_read(sock, ppos, pipe, len, flags);
  }

  static ssize_t sock_read_iter(struct kiocb *iocb, struct iov_iter *to)

  {

  	struct file *file = iocb->ki_filp;
  	struct socket *sock = file->private_data;

  	struct msghdr msg = {.msg_iter = *to,
  			     .msg_iocb = iocb};

  	ssize_t res;

  	if (file->f_flags & O_NONBLOCK)
  		msg.msg_flags = MSG_DONTWAIT;
  
  	if (iocb->ki_pos != 0)

  		return -ESPIPE;

  	if (!iov_iter_count(to))	/* Match SYS5 behaviour */

  		return 0;

  	res = sock_recvmsg(sock, &msg, msg.msg_flags);

  	*to = msg.msg_iter;
  	return res;

  }

  static ssize_t sock_write_iter(struct kiocb *iocb, struct iov_iter *from)

  {

  	struct file *file = iocb->ki_filp;
  	struct socket *sock = file->private_data;

  	struct msghdr msg = {.msg_iter = *from,
  			     .msg_iocb = iocb};

  	ssize_t res;

  	if (iocb->ki_pos != 0)

  		return -ESPIPE;

  	if (file->f_flags & O_NONBLOCK)
  		msg.msg_flags = MSG_DONTWAIT;

  	if (sock->type == SOCK_SEQPACKET)
  		msg.msg_flags |= MSG_EOR;

  	res = sock_sendmsg(sock, &msg);

  	*from = msg.msg_iter;
  	return res;

  }

  /*
   * Atomic setting of ioctl hooks to avoid race
   * with module unload.
   */

  static DEFINE_MUTEX(br_ioctl_mutex);

  static int (*br_ioctl_hook) (struct net *, unsigned int cmd, void __user *arg);

  void brioctl_set(int (*hook) (struct net *, unsigned int, void __user *))

  {

  	mutex_lock(&br_ioctl_mutex);

  	br_ioctl_hook = hook;

  	mutex_unlock(&br_ioctl_mutex);

  }
  EXPORT_SYMBOL(brioctl_set);

  static DEFINE_MUTEX(vlan_ioctl_mutex);

  static int (*vlan_ioctl_hook) (struct net *, void __user *arg);

  void vlan_ioctl_set(int (*hook) (struct net *, void __user *))

  {

  	mutex_lock(&vlan_ioctl_mutex);

  	vlan_ioctl_hook = hook;

  	mutex_unlock(&vlan_ioctl_mutex);

  }
  EXPORT_SYMBOL(vlan_ioctl_set);

  static DEFINE_MUTEX(dlci_ioctl_mutex);

  static int (*dlci_ioctl_hook) (unsigned int, void __user *);

  void dlci_ioctl_set(int (*hook) (unsigned int, void __user *))

  {

  	mutex_lock(&dlci_ioctl_mutex);

  	dlci_ioctl_hook = hook;

  	mutex_unlock(&dlci_ioctl_mutex);

  }
  EXPORT_SYMBOL(dlci_ioctl_set);

  static long sock_do_ioctl(struct net *net, struct socket *sock,
  				 unsigned int cmd, unsigned long arg)
  {
  	int err;
  	void __user *argp = (void __user *)arg;
  
  	err = sock->ops->ioctl(sock, cmd, arg);
  
  	/*
  	 * If this ioctl is unknown try to hand it down
  	 * to the NIC driver.
  	 */

  	if (err != -ENOIOCTLCMD)
  		return err;

  	if (cmd == SIOCGIFCONF) {
  		struct ifconf ifc;
  		if (copy_from_user(&ifc, argp, sizeof(struct ifconf)))
  			return -EFAULT;
  		rtnl_lock();
  		err = dev_ifconf(net, &ifc, sizeof(struct ifreq));
  		rtnl_unlock();
  		if (!err && copy_to_user(argp, &ifc, sizeof(struct ifconf)))
  			err = -EFAULT;

  	} else {
  		struct ifreq ifr;
  		bool need_copyout;
  		if (copy_from_user(&ifr, argp, sizeof(struct ifreq)))
  			return -EFAULT;
  		err = dev_ioctl(net, cmd, &ifr, &need_copyout);
  		if (!err && need_copyout)
  			if (copy_to_user(argp, &ifr, sizeof(struct ifreq)))
  				return -EFAULT;

  	}

  	return err;
  }

  /*
   *	With an ioctl, arg may well be a user mode pointer, but we don't know
   *	what to do with it - that's up to the protocol still.
   */

  struct ns_common *get_net_ns(struct ns_common *ns)

  {
  	return &get_net(container_of(ns, struct net, ns))->ns;
  }

  EXPORT_SYMBOL_GPL(get_net_ns);

  static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
  {
  	struct socket *sock;

  	struct sock *sk;

  	void __user *argp = (void __user *)arg;
  	int pid, err;

  	struct net *net;

  	sock = file->private_data;

  	sk = sock->sk;

  	net = sock_net(sk);

  	if (unlikely(cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15))) {
  		struct ifreq ifr;
  		bool need_copyout;
  		if (copy_from_user(&ifr, argp, sizeof(struct ifreq)))
  			return -EFAULT;
  		err = dev_ioctl(net, cmd, &ifr, &need_copyout);
  		if (!err && need_copyout)
  			if (copy_to_user(argp, &ifr, sizeof(struct ifreq)))
  				return -EFAULT;

  	} else

  #ifdef CONFIG_WEXT_CORE

  	if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {

  		err = wext_handle_ioctl(net, cmd, argp);

  	} else

  #endif

  		switch (cmd) {

  		case FIOSETOWN:
  		case SIOCSPGRP:
  			err = -EFAULT;
  			if (get_user(pid, (int __user *)argp))
  				break;

  			err = f_setown(sock->file, pid, 1);

  			break;
  		case FIOGETOWN:
  		case SIOCGPGRP:

  			err = put_user(f_getown(sock->file),

  				       (int __user *)argp);

  			break;
  		case SIOCGIFBR:
  		case SIOCSIFBR:
  		case SIOCBRADDBR:
  		case SIOCBRDELBR:
  			err = -ENOPKG;
  			if (!br_ioctl_hook)
  				request_module("bridge");

  			mutex_lock(&br_ioctl_mutex);

  			if (br_ioctl_hook)

  				err = br_ioctl_hook(net, cmd, argp);

  			mutex_unlock(&br_ioctl_mutex);

  			break;
  		case SIOCGIFVLAN:
  		case SIOCSIFVLAN:
  			err = -ENOPKG;
  			if (!vlan_ioctl_hook)
  				request_module("8021q");

  			mutex_lock(&vlan_ioctl_mutex);

  			if (vlan_ioctl_hook)

  				err = vlan_ioctl_hook(net, argp);

  			mutex_unlock(&vlan_ioctl_mutex);

  			break;

  		case SIOCADDDLCI:
  		case SIOCDELDLCI:
  			err = -ENOPKG;
  			if (!dlci_ioctl_hook)
  				request_module("dlci");

  			mutex_lock(&dlci_ioctl_mutex);
  			if (dlci_ioctl_hook)

  				err = dlci_ioctl_hook(cmd, argp);

  			mutex_unlock(&dlci_ioctl_mutex);

  			break;

  		case SIOCGSKNS:
  			err = -EPERM;
  			if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
  				break;
  
  			err = open_related_ns(&net->ns, get_net_ns);
  			break;

  		default:

  			err = sock_do_ioctl(net, sock, cmd, arg);

  			break;

  		}

  	return err;
  }
  
  int sock_create_lite(int family, int type, int protocol, struct socket **res)
  {
  	int err;
  	struct socket *sock = NULL;

  	err = security_socket_create(family, type, protocol, 1);
  	if (err)
  		goto out;
  
  	sock = sock_alloc();
  	if (!sock) {
  		err = -ENOMEM;
  		goto out;
  	}

  	sock->type = type;

  	err = security_socket_post_create(sock, family, type, protocol, 1);
  	if (err)
  		goto out_release;

  out:
  	*res = sock;
  	return err;

  out_release:
  	sock_release(sock);
  	sock = NULL;
  	goto out;

  }

  EXPORT_SYMBOL(sock_create_lite);

  static struct wait_queue_head *sock_get_poll_head(struct file *file,
  		__poll_t events)
  {
  	struct socket *sock = file->private_data;
  
  	if (!sock->ops->poll_mask)
  		return NULL;
  	sock_poll_busy_loop(sock, events);
  	return sk_sleep(sock->sk);
  }
  
  static __poll_t sock_poll_mask(struct file *file, __poll_t events)
  {
  	struct socket *sock = file->private_data;
  
  	/*
  	 * We need to be sure we are in sync with the socket flags modification.
  	 *
  	 * This memory barrier is paired in the wq_has_sleeper.
  	 */
  	smp_mb();
  
  	/* this socket can poll_ll so tell the system call */
  	return sock->ops->poll_mask(sock, events) |
  		(sk_can_busy_loop(sock->sk) ? POLL_BUSY_LOOP : 0);
  }

  /* No kernel lock held - perfect */

  static __poll_t sock_poll(struct file *file, poll_table *wait)

  {

  	struct socket *sock = file->private_data;

  	__poll_t events = poll_requested_events(wait), mask = 0;
  
  	if (sock->ops->poll) {
  		sock_poll_busy_loop(sock, events);
  		mask = sock->ops->poll(file, sock, wait);
  	} else if (sock->ops->poll_mask) {
  		sock_poll_wait(file, sock_get_poll_head(file, events), wait);
  		mask = sock->ops->poll_mask(sock, events);
  	}

  	return mask | sock_poll_busy_flag(sock);

  }

  static int sock_mmap(struct file *file, struct vm_area_struct *vma)

  {

  	struct socket *sock = file->private_data;

  
  	return sock->ops->mmap(file, sock, vma);
  }

  static int sock_close(struct inode *inode, struct file *filp)

  {

  	__sock_release(SOCKET_I(inode), inode);

  	return 0;
  }
  
  /*
   *	Update the socket async list
   *
   *	Fasync_list locking strategy.
   *
   *	1. fasync_list is modified only under process context socket lock
   *	   i.e. under semaphore.
   *	2. fasync_list is used under read_lock(&sk->sk_callback_lock)

   *	   or under socket lock

   */
  
  static int sock_fasync(int fd, struct file *filp, int on)
  {

  	struct socket *sock = filp->private_data;
  	struct sock *sk = sock->sk;

  	struct socket_wq *wq;

  	if (sk == NULL)

  		return -EINVAL;

  
  	lock_sock(sk);

  	wq = rcu_dereference_protected(sock->wq, lockdep_sock_is_held(sk));

  	fasync_helper(fd, filp, on, &wq->fasync_list);

  	if (!wq->fasync_list)

  		sock_reset_flag(sk, SOCK_FASYNC);
  	else

  		sock_set_flag(sk, SOCK_FASYNC);

  	release_sock(sk);

  	return 0;
  }

  /* This function may be called only under rcu_lock */

  int sock_wake_async(struct socket_wq *wq, int how, int band)

  {

  	if (!wq || !wq->fasync_list)

  		return -1;

  	switch (how) {

  	case SOCK_WAKE_WAITD:

  		if (test_bit(SOCKWQ_ASYNC_WAITDATA, &wq->flags))

  			break;
  		goto call_kill;

  	case SOCK_WAKE_SPACE:

  		if (!test_and_clear_bit(SOCKWQ_ASYNC_NOSPACE, &wq->flags))

  			break;
  		/* fall through */

  	case SOCK_WAKE_IO:

  call_kill:

  		kill_fasync(&wq->fasync_list, SIGIO, band);

  		break;

  	case SOCK_WAKE_URG:

  		kill_fasync(&wq->fasync_list, SIGURG, band);

  	}

  	return 0;
  }

  EXPORT_SYMBOL(sock_wake_async);

  int __sock_create(struct net *net, int family, int type, int protocol,

  			 struct socket **res, int kern)

  {
  	int err;
  	struct socket *sock;

  	const struct net_proto_family *pf;

  
  	/*

  	 *      Check protocol is in range

  	 */
  	if (family < 0 || family >= NPROTO)
  		return -EAFNOSUPPORT;
  	if (type < 0 || type >= SOCK_MAX)
  		return -EINVAL;
  
  	/* Compatibility.
  
  	   This uglymoron is moved from INET layer to here to avoid
  	   deadlock in module load.
  	 */
  	if (family == PF_INET && type == SOCK_PACKET) {

  		pr_info_once("%s uses obsolete (PF_INET,SOCK_PACKET)
  ",
  			     current->comm);

  		family = PF_PACKET;
  	}
  
  	err = security_socket_create(family, type, protocol, kern);
  	if (err)
  		return err;

  	/*
  	 *	Allocate the socket and allow the family to set things up. if
  	 *	the protocol is 0, the family is instructed to select an appropriate
  	 *	default.
  	 */
  	sock = sock_alloc();
  	if (!sock) {

  		net_warn_ratelimited("socket: no more sockets
  ");

  		return -ENFILE;	/* Not exactly a match, but its the
  				   closest posix thing */
  	}
  
  	sock->type = type;

  #ifdef CONFIG_MODULES

  	/* Attempt to load a protocol module if the find failed.
  	 *
  	 * 12/09/1996 Marcin: But! this makes REALLY only sense, if the user

  	 * requested real, full-featured networking support upon configuration.
  	 * Otherwise module support will break!
  	 */

  	if (rcu_access_pointer(net_families[family]) == NULL)

  		request_module("net-pf-%d", family);

  #endif

  	rcu_read_lock();
  	pf = rcu_dereference(net_families[family]);
  	err = -EAFNOSUPPORT;
  	if (!pf)
  		goto out_release;

  
  	/*
  	 * We will call the ->create function, that possibly is in a loadable
  	 * module, so we have to bump that loadable module refcnt first.
  	 */

  	if (!try_module_get(pf->owner))

  		goto out_release;

  	/* Now protected by module ref count */
  	rcu_read_unlock();

  	err = pf->create(net, sock, protocol, kern);

  	if (err < 0)

  		goto out_module_put;

  	/*
  	 * Now to bump the refcnt of the [loadable] module that owns this
  	 * socket at sock_release time we decrement its refcnt.
  	 */

  	if (!try_module_get(sock->ops->owner))
  		goto out_module_busy;

  	/*
  	 * Now that we're done with the ->create function, the [loadable]
  	 * module can have its refcnt decremented
  	 */

  	module_put(pf->owner);

  	err = security_socket_post_create(sock, family, type, protocol, kern);
  	if (err)

  		goto out_sock_release;

  	*res = sock;

  	return 0;
  
  out_module_busy:
  	err = -EAFNOSUPPORT;

  out_module_put:

  	sock->ops = NULL;
  	module_put(pf->owner);
  out_sock_release:

  	sock_release(sock);

  	return err;
  
  out_release:
  	rcu_read_unlock();
  	goto out_sock_release;

  }

  EXPORT_SYMBOL(__sock_create);

  
  int sock_create(int family, int type, int protocol, struct socket **res)
  {

  	return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);

  }

  EXPORT_SYMBOL(sock_create);

  int sock_create_kern(struct net *net, int family, int type, int protocol, struct socket **res)

  {

  	return __sock_create(net, family, type, protocol, res, 1);

  }

  EXPORT_SYMBOL(sock_create_kern);

  int __sys_socket(int family, int type, int protocol)

  {
  	int retval;
  	struct socket *sock;

  	int flags;

  	/* Check the SOCK_* constants for consistency.  */
  	BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);
  	BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK);
  	BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);
  	BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);

  	flags = type & ~SOCK_TYPE_MASK;

  	if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))

  		return -EINVAL;
  	type &= SOCK_TYPE_MASK;

  	if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
  		flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;

  	retval = sock_create(family, type, protocol, &sock);
  	if (retval < 0)

  		return retval;

  	return sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));

  }

  SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol)
  {
  	return __sys_socket(family, type, protocol);
  }

  /*
   *	Create a pair of connected sockets.
   */

  int __sys_socketpair(int family, int type, int protocol, int __user *usockvec)

  {
  	struct socket *sock1, *sock2;
  	int fd1, fd2, err;

  	struct file *newfile1, *newfile2;

  	int flags;
  
  	flags = type & ~SOCK_TYPE_MASK;

  	if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))

  		return -EINVAL;
  	type &= SOCK_TYPE_MASK;

  	if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
  		flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;

  	/*

  	 * reserve descriptors and make sure we won't fail
  	 * to return them to userland.
  	 */
  	fd1 = get_unused_fd_flags(flags);
  	if (unlikely(fd1 < 0))
  		return fd1;
  
  	fd2 = get_unused_fd_flags(flags);
  	if (unlikely(fd2 < 0)) {
  		put_unused_fd(fd1);
  		return fd2;
  	}
  
  	err = put_user(fd1, &usockvec[0]);
  	if (err)
  		goto out;
  
  	err = put_user(fd2, &usockvec[1]);
  	if (err)
  		goto out;
  
  	/*

  	 * Obtain the first socket and check if the underlying protocol
  	 * supports the socketpair call.
  	 */
  
  	err = sock_create(family, type, protocol, &sock1);

  	if (unlikely(err < 0))

  		goto out;
  
  	err = sock_create(family, type, protocol, &sock2);

  	if (unlikely(err < 0)) {
  		sock_release(sock1);
  		goto out;

  	}

  	err = security_socket_socketpair(sock1, sock2);
  	if (unlikely(err)) {
  		sock_release(sock2);
  		sock_release(sock1);
  		goto out;
  	}

  	err = sock1->ops->socketpair(sock1, sock2);
  	if (unlikely(err < 0)) {
  		sock_release(sock2);
  		sock_release(sock1);
  		goto out;

  	}

  	newfile1 = sock_alloc_file(sock1, flags, NULL);

  	if (IS_ERR(newfile1)) {