GNU Linux-libre 6.1.91-gnu
[releases.git] / net / socket.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * NET          An implementation of the SOCKET network access protocol.
4  *
5  * Version:     @(#)socket.c    1.1.93  18/02/95
6  *
7  * Authors:     Orest Zborowski, <obz@Kodak.COM>
8  *              Ross Biro
9  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
10  *
11  * Fixes:
12  *              Anonymous       :       NOTSOCK/BADF cleanup. Error fix in
13  *                                      shutdown()
14  *              Alan Cox        :       verify_area() fixes
15  *              Alan Cox        :       Removed DDI
16  *              Jonathan Kamens :       SOCK_DGRAM reconnect bug
17  *              Alan Cox        :       Moved a load of checks to the very
18  *                                      top level.
19  *              Alan Cox        :       Move address structures to/from user
20  *                                      mode above the protocol layers.
21  *              Rob Janssen     :       Allow 0 length sends.
22  *              Alan Cox        :       Asynchronous I/O support (cribbed from the
23  *                                      tty drivers).
24  *              Niibe Yutaka    :       Asynchronous I/O for writes (4.4BSD style)
25  *              Jeff Uphoff     :       Made max number of sockets command-line
26  *                                      configurable.
27  *              Matti Aarnio    :       Made the number of sockets dynamic,
28  *                                      to be allocated when needed, and mr.
29  *                                      Uphoff's max is used as max to be
30  *                                      allowed to allocate.
31  *              Linus           :       Argh. removed all the socket allocation
32  *                                      altogether: it's in the inode now.
33  *              Alan Cox        :       Made sock_alloc()/sock_release() public
34  *                                      for NetROM and future kernel nfsd type
35  *                                      stuff.
36  *              Alan Cox        :       sendmsg/recvmsg basics.
37  *              Tom Dyas        :       Export net symbols.
38  *              Marcin Dalecki  :       Fixed problems with CONFIG_NET="n".
39  *              Alan Cox        :       Added thread locking to sys_* calls
40  *                                      for sockets. May have errors at the
41  *                                      moment.
42  *              Kevin Buhr      :       Fixed the dumb errors in the above.
43  *              Andi Kleen      :       Some small cleanups, optimizations,
44  *                                      and fixed a copy_from_user() bug.
45  *              Tigran Aivazian :       sys_send(args) calls sys_sendto(args, NULL, 0)
46  *              Tigran Aivazian :       Made listen(2) backlog sanity checks
47  *                                      protocol-independent
48  *
49  *      This module is effectively the top level interface to the BSD socket
50  *      paradigm.
51  *
52  *      Based upon Swansea University Computer Society NET3.039
53  */
54
55 #include <linux/bpf-cgroup.h>
56 #include <linux/ethtool.h>
57 #include <linux/mm.h>
58 #include <linux/socket.h>
59 #include <linux/file.h>
60 #include <linux/net.h>
61 #include <linux/interrupt.h>
62 #include <linux/thread_info.h>
63 #include <linux/rcupdate.h>
64 #include <linux/netdevice.h>
65 #include <linux/proc_fs.h>
66 #include <linux/seq_file.h>
67 #include <linux/mutex.h>
68 #include <linux/if_bridge.h>
69 #include <linux/if_vlan.h>
70 #include <linux/ptp_classify.h>
71 #include <linux/init.h>
72 #include <linux/poll.h>
73 #include <linux/cache.h>
74 #include <linux/module.h>
75 #include <linux/highmem.h>
76 #include <linux/mount.h>
77 #include <linux/pseudo_fs.h>
78 #include <linux/security.h>
79 #include <linux/syscalls.h>
80 #include <linux/compat.h>
81 #include <linux/kmod.h>
82 #include <linux/audit.h>
83 #include <linux/wireless.h>
84 #include <linux/nsproxy.h>
85 #include <linux/magic.h>
86 #include <linux/slab.h>
87 #include <linux/xattr.h>
88 #include <linux/nospec.h>
89 #include <linux/indirect_call_wrapper.h>
90
91 #include <linux/uaccess.h>
92 #include <asm/unistd.h>
93
94 #include <net/compat.h>
95 #include <net/wext.h>
96 #include <net/cls_cgroup.h>
97
98 #include <net/sock.h>
99 #include <linux/netfilter.h>
100
101 #include <linux/if_tun.h>
102 #include <linux/ipv6_route.h>
103 #include <linux/route.h>
104 #include <linux/termios.h>
105 #include <linux/sockios.h>
106 #include <net/busy_poll.h>
107 #include <linux/errqueue.h>
108 #include <linux/ptp_clock_kernel.h>
109
110 #ifdef CONFIG_NET_RX_BUSY_POLL
111 unsigned int sysctl_net_busy_read __read_mostly;
112 unsigned int sysctl_net_busy_poll __read_mostly;
113 #endif
114
115 static ssize_t sock_read_iter(struct kiocb *iocb, struct iov_iter *to);
116 static ssize_t sock_write_iter(struct kiocb *iocb, struct iov_iter *from);
117 static int sock_mmap(struct file *file, struct vm_area_struct *vma);
118
119 static int sock_close(struct inode *inode, struct file *file);
120 static __poll_t sock_poll(struct file *file,
121                               struct poll_table_struct *wait);
122 static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
123 #ifdef CONFIG_COMPAT
124 static long compat_sock_ioctl(struct file *file,
125                               unsigned int cmd, unsigned long arg);
126 #endif
127 static int sock_fasync(int fd, struct file *filp, int on);
128 static ssize_t sock_sendpage(struct file *file, struct page *page,
129                              int offset, size_t size, loff_t *ppos, int more);
130 static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
131                                 struct pipe_inode_info *pipe, size_t len,
132                                 unsigned int flags);
133 static void sock_splice_eof(struct file *file);
134
135 #ifdef CONFIG_PROC_FS
136 static void sock_show_fdinfo(struct seq_file *m, struct file *f)
137 {
138         struct socket *sock = f->private_data;
139
140         if (sock->ops->show_fdinfo)
141                 sock->ops->show_fdinfo(m, sock);
142 }
143 #else
144 #define sock_show_fdinfo NULL
145 #endif
146
147 /*
148  *      Socket files have a set of 'special' operations as well as the generic file ones. These don't appear
149  *      in the operation structures but are done directly via the socketcall() multiplexor.
150  */
151
152 static const struct file_operations socket_file_ops = {
153         .owner =        THIS_MODULE,
154         .llseek =       no_llseek,
155         .read_iter =    sock_read_iter,
156         .write_iter =   sock_write_iter,
157         .poll =         sock_poll,
158         .unlocked_ioctl = sock_ioctl,
159 #ifdef CONFIG_COMPAT
160         .compat_ioctl = compat_sock_ioctl,
161 #endif
162         .mmap =         sock_mmap,
163         .release =      sock_close,
164         .fasync =       sock_fasync,
165         .sendpage =     sock_sendpage,
166         .splice_write = generic_splice_sendpage,
167         .splice_read =  sock_splice_read,
168         .splice_eof =   sock_splice_eof,
169         .show_fdinfo =  sock_show_fdinfo,
170 };
171
172 static const char * const pf_family_names[] = {
173         [PF_UNSPEC]     = "PF_UNSPEC",
174         [PF_UNIX]       = "PF_UNIX/PF_LOCAL",
175         [PF_INET]       = "PF_INET",
176         [PF_AX25]       = "PF_AX25",
177         [PF_IPX]        = "PF_IPX",
178         [PF_APPLETALK]  = "PF_APPLETALK",
179         [PF_NETROM]     = "PF_NETROM",
180         [PF_BRIDGE]     = "PF_BRIDGE",
181         [PF_ATMPVC]     = "PF_ATMPVC",
182         [PF_X25]        = "PF_X25",
183         [PF_INET6]      = "PF_INET6",
184         [PF_ROSE]       = "PF_ROSE",
185         [PF_DECnet]     = "PF_DECnet",
186         [PF_NETBEUI]    = "PF_NETBEUI",
187         [PF_SECURITY]   = "PF_SECURITY",
188         [PF_KEY]        = "PF_KEY",
189         [PF_NETLINK]    = "PF_NETLINK/PF_ROUTE",
190         [PF_PACKET]     = "PF_PACKET",
191         [PF_ASH]        = "PF_ASH",
192         [PF_ECONET]     = "PF_ECONET",
193         [PF_ATMSVC]     = "PF_ATMSVC",
194         [PF_RDS]        = "PF_RDS",
195         [PF_SNA]        = "PF_SNA",
196         [PF_IRDA]       = "PF_IRDA",
197         [PF_PPPOX]      = "PF_PPPOX",
198         [PF_WANPIPE]    = "PF_WANPIPE",
199         [PF_LLC]        = "PF_LLC",
200         [PF_IB]         = "PF_IB",
201         [PF_MPLS]       = "PF_MPLS",
202         [PF_CAN]        = "PF_CAN",
203         [PF_TIPC]       = "PF_TIPC",
204         [PF_BLUETOOTH]  = "PF_BLUETOOTH",
205         [PF_IUCV]       = "PF_IUCV",
206         [PF_RXRPC]      = "PF_RXRPC",
207         [PF_ISDN]       = "PF_ISDN",
208         [PF_PHONET]     = "PF_PHONET",
209         [PF_IEEE802154] = "PF_IEEE802154",
210         [PF_CAIF]       = "PF_CAIF",
211         [PF_ALG]        = "PF_ALG",
212         [PF_NFC]        = "PF_NFC",
213         [PF_VSOCK]      = "PF_VSOCK",
214         [PF_KCM]        = "PF_KCM",
215         [PF_QIPCRTR]    = "PF_QIPCRTR",
216         [PF_SMC]        = "PF_SMC",
217         [PF_XDP]        = "PF_XDP",
218         [PF_MCTP]       = "PF_MCTP",
219 };
220
221 /*
222  *      The protocol list. Each protocol is registered in here.
223  */
224
225 static DEFINE_SPINLOCK(net_family_lock);
226 static const struct net_proto_family __rcu *net_families[NPROTO] __read_mostly;
227
228 /*
229  * Support routines.
230  * Move socket addresses back and forth across the kernel/user
231  * divide and look after the messy bits.
232  */
233
234 /**
235  *      move_addr_to_kernel     -       copy a socket address into kernel space
236  *      @uaddr: Address in user space
237  *      @kaddr: Address in kernel space
238  *      @ulen: Length in user space
239  *
240  *      The address is copied into kernel space. If the provided address is
241  *      too long an error code of -EINVAL is returned. If the copy gives
242  *      invalid addresses -EFAULT is returned. On a success 0 is returned.
243  */
244
245 int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr_storage *kaddr)
246 {
247         if (ulen < 0 || ulen > sizeof(struct sockaddr_storage))
248                 return -EINVAL;
249         if (ulen == 0)
250                 return 0;
251         if (copy_from_user(kaddr, uaddr, ulen))
252                 return -EFAULT;
253         return audit_sockaddr(ulen, kaddr);
254 }
255
256 /**
257  *      move_addr_to_user       -       copy an address to user space
258  *      @kaddr: kernel space address
259  *      @klen: length of address in kernel
260  *      @uaddr: user space address
261  *      @ulen: pointer to user length field
262  *
263  *      The value pointed to by ulen on entry is the buffer length available.
264  *      This is overwritten with the buffer space used. -EINVAL is returned
265  *      if an overlong buffer is specified or a negative buffer size. -EFAULT
266  *      is returned if either the buffer or the length field are not
267  *      accessible.
268  *      After copying the data up to the limit the user specifies, the true
269  *      length of the data is written over the length limit the user
270  *      specified. Zero is returned for a success.
271  */
272
273 static int move_addr_to_user(struct sockaddr_storage *kaddr, int klen,
274                              void __user *uaddr, int __user *ulen)
275 {
276         int err;
277         int len;
278
279         BUG_ON(klen > sizeof(struct sockaddr_storage));
280         err = get_user(len, ulen);
281         if (err)
282                 return err;
283         if (len > klen)
284                 len = klen;
285         if (len < 0)
286                 return -EINVAL;
287         if (len) {
288                 if (audit_sockaddr(klen, kaddr))
289                         return -ENOMEM;
290                 if (copy_to_user(uaddr, kaddr, len))
291                         return -EFAULT;
292         }
293         /*
294          *      "fromlen shall refer to the value before truncation.."
295          *                      1003.1g
296          */
297         return __put_user(klen, ulen);
298 }
299
300 static struct kmem_cache *sock_inode_cachep __ro_after_init;
301
302 static struct inode *sock_alloc_inode(struct super_block *sb)
303 {
304         struct socket_alloc *ei;
305
306         ei = alloc_inode_sb(sb, sock_inode_cachep, GFP_KERNEL);
307         if (!ei)
308                 return NULL;
309         init_waitqueue_head(&ei->socket.wq.wait);
310         ei->socket.wq.fasync_list = NULL;
311         ei->socket.wq.flags = 0;
312
313         ei->socket.state = SS_UNCONNECTED;
314         ei->socket.flags = 0;
315         ei->socket.ops = NULL;
316         ei->socket.sk = NULL;
317         ei->socket.file = NULL;
318
319         return &ei->vfs_inode;
320 }
321
322 static void sock_free_inode(struct inode *inode)
323 {
324         struct socket_alloc *ei;
325
326         ei = container_of(inode, struct socket_alloc, vfs_inode);
327         kmem_cache_free(sock_inode_cachep, ei);
328 }
329
330 static void init_once(void *foo)
331 {
332         struct socket_alloc *ei = (struct socket_alloc *)foo;
333
334         inode_init_once(&ei->vfs_inode);
335 }
336
337 static void init_inodecache(void)
338 {
339         sock_inode_cachep = kmem_cache_create("sock_inode_cache",
340                                               sizeof(struct socket_alloc),
341                                               0,
342                                               (SLAB_HWCACHE_ALIGN |
343                                                SLAB_RECLAIM_ACCOUNT |
344                                                SLAB_MEM_SPREAD | SLAB_ACCOUNT),
345                                               init_once);
346         BUG_ON(sock_inode_cachep == NULL);
347 }
348
349 static const struct super_operations sockfs_ops = {
350         .alloc_inode    = sock_alloc_inode,
351         .free_inode     = sock_free_inode,
352         .statfs         = simple_statfs,
353 };
354
355 /*
356  * sockfs_dname() is called from d_path().
357  */
358 static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen)
359 {
360         return dynamic_dname(buffer, buflen, "socket:[%lu]",
361                                 d_inode(dentry)->i_ino);
362 }
363
364 static const struct dentry_operations sockfs_dentry_operations = {
365         .d_dname  = sockfs_dname,
366 };
367
368 static int sockfs_xattr_get(const struct xattr_handler *handler,
369                             struct dentry *dentry, struct inode *inode,
370                             const char *suffix, void *value, size_t size)
371 {
372         if (value) {
373                 if (dentry->d_name.len + 1 > size)
374                         return -ERANGE;
375                 memcpy(value, dentry->d_name.name, dentry->d_name.len + 1);
376         }
377         return dentry->d_name.len + 1;
378 }
379
380 #define XATTR_SOCKPROTONAME_SUFFIX "sockprotoname"
381 #define XATTR_NAME_SOCKPROTONAME (XATTR_SYSTEM_PREFIX XATTR_SOCKPROTONAME_SUFFIX)
382 #define XATTR_NAME_SOCKPROTONAME_LEN (sizeof(XATTR_NAME_SOCKPROTONAME)-1)
383
384 static const struct xattr_handler sockfs_xattr_handler = {
385         .name = XATTR_NAME_SOCKPROTONAME,
386         .get = sockfs_xattr_get,
387 };
388
389 static int sockfs_security_xattr_set(const struct xattr_handler *handler,
390                                      struct user_namespace *mnt_userns,
391                                      struct dentry *dentry, struct inode *inode,
392                                      const char *suffix, const void *value,
393                                      size_t size, int flags)
394 {
395         /* Handled by LSM. */
396         return -EAGAIN;
397 }
398
399 static const struct xattr_handler sockfs_security_xattr_handler = {
400         .prefix = XATTR_SECURITY_PREFIX,
401         .set = sockfs_security_xattr_set,
402 };
403
404 static const struct xattr_handler *sockfs_xattr_handlers[] = {
405         &sockfs_xattr_handler,
406         &sockfs_security_xattr_handler,
407         NULL
408 };
409
410 static int sockfs_init_fs_context(struct fs_context *fc)
411 {
412         struct pseudo_fs_context *ctx = init_pseudo(fc, SOCKFS_MAGIC);
413         if (!ctx)
414                 return -ENOMEM;
415         ctx->ops = &sockfs_ops;
416         ctx->dops = &sockfs_dentry_operations;
417         ctx->xattr = sockfs_xattr_handlers;
418         return 0;
419 }
420
421 static struct vfsmount *sock_mnt __read_mostly;
422
423 static struct file_system_type sock_fs_type = {
424         .name =         "sockfs",
425         .init_fs_context = sockfs_init_fs_context,
426         .kill_sb =      kill_anon_super,
427 };
428
429 /*
430  *      Obtains the first available file descriptor and sets it up for use.
431  *
432  *      These functions create file structures and maps them to fd space
433  *      of the current process. On success it returns file descriptor
434  *      and file struct implicitly stored in sock->file.
435  *      Note that another thread may close file descriptor before we return
436  *      from this function. We use the fact that now we do not refer
437  *      to socket after mapping. If one day we will need it, this
438  *      function will increment ref. count on file by 1.
439  *
440  *      In any case returned fd MAY BE not valid!
441  *      This race condition is unavoidable
442  *      with shared fd spaces, we cannot solve it inside kernel,
443  *      but we take care of internal coherence yet.
444  */
445
446 /**
447  *      sock_alloc_file - Bind a &socket to a &file
448  *      @sock: socket
449  *      @flags: file status flags
450  *      @dname: protocol name
451  *
452  *      Returns the &file bound with @sock, implicitly storing it
453  *      in sock->file. If dname is %NULL, sets to "".
454  *
455  *      On failure @sock is released, and an ERR pointer is returned.
456  *
457  *      This function uses GFP_KERNEL internally.
458  */
459
460 struct file *sock_alloc_file(struct socket *sock, int flags, const char *dname)
461 {
462         struct file *file;
463
464         if (!dname)
465                 dname = sock->sk ? sock->sk->sk_prot_creator->name : "";
466
467         file = alloc_file_pseudo(SOCK_INODE(sock), sock_mnt, dname,
468                                 O_RDWR | (flags & O_NONBLOCK),
469                                 &socket_file_ops);
470         if (IS_ERR(file)) {
471                 sock_release(sock);
472                 return file;
473         }
474
475         sock->file = file;
476         file->private_data = sock;
477         stream_open(SOCK_INODE(sock), file);
478         return file;
479 }
480 EXPORT_SYMBOL(sock_alloc_file);
481
482 static int sock_map_fd(struct socket *sock, int flags)
483 {
484         struct file *newfile;
485         int fd = get_unused_fd_flags(flags);
486         if (unlikely(fd < 0)) {
487                 sock_release(sock);
488                 return fd;
489         }
490
491         newfile = sock_alloc_file(sock, flags, NULL);
492         if (!IS_ERR(newfile)) {
493                 fd_install(fd, newfile);
494                 return fd;
495         }
496
497         put_unused_fd(fd);
498         return PTR_ERR(newfile);
499 }
500
501 /**
502  *      sock_from_file - Return the &socket bounded to @file.
503  *      @file: file
504  *
505  *      On failure returns %NULL.
506  */
507
508 struct socket *sock_from_file(struct file *file)
509 {
510         if (file->f_op == &socket_file_ops)
511                 return file->private_data;      /* set in sock_alloc_file */
512
513         return NULL;
514 }
515 EXPORT_SYMBOL(sock_from_file);
516
517 /**
518  *      sockfd_lookup - Go from a file number to its socket slot
519  *      @fd: file handle
520  *      @err: pointer to an error code return
521  *
522  *      The file handle passed in is locked and the socket it is bound
523  *      to is returned. If an error occurs the err pointer is overwritten
524  *      with a negative errno code and NULL is returned. The function checks
525  *      for both invalid handles and passing a handle which is not a socket.
526  *
527  *      On a success the socket object pointer is returned.
528  */
529
530 struct socket *sockfd_lookup(int fd, int *err)
531 {
532         struct file *file;
533         struct socket *sock;
534
535         file = fget(fd);
536         if (!file) {
537                 *err = -EBADF;
538                 return NULL;
539         }
540
541         sock = sock_from_file(file);
542         if (!sock) {
543                 *err = -ENOTSOCK;
544                 fput(file);
545         }
546         return sock;
547 }
548 EXPORT_SYMBOL(sockfd_lookup);
549
550 static struct socket *sockfd_lookup_light(int fd, int *err, int *fput_needed)
551 {
552         struct fd f = fdget(fd);
553         struct socket *sock;
554
555         *err = -EBADF;
556         if (f.file) {
557                 sock = sock_from_file(f.file);
558                 if (likely(sock)) {
559                         *fput_needed = f.flags & FDPUT_FPUT;
560                         return sock;
561                 }
562                 *err = -ENOTSOCK;
563                 fdput(f);
564         }
565         return NULL;
566 }
567
568 static ssize_t sockfs_listxattr(struct dentry *dentry, char *buffer,
569                                 size_t size)
570 {
571         ssize_t len;
572         ssize_t used = 0;
573
574         len = security_inode_listsecurity(d_inode(dentry), buffer, size);
575         if (len < 0)
576                 return len;
577         used += len;
578         if (buffer) {
579                 if (size < used)
580                         return -ERANGE;
581                 buffer += len;
582         }
583
584         len = (XATTR_NAME_SOCKPROTONAME_LEN + 1);
585         used += len;
586         if (buffer) {
587                 if (size < used)
588                         return -ERANGE;
589                 memcpy(buffer, XATTR_NAME_SOCKPROTONAME, len);
590                 buffer += len;
591         }
592
593         return used;
594 }
595
596 static int sockfs_setattr(struct user_namespace *mnt_userns,
597                           struct dentry *dentry, struct iattr *iattr)
598 {
599         int err = simple_setattr(&init_user_ns, dentry, iattr);
600
601         if (!err && (iattr->ia_valid & ATTR_UID)) {
602                 struct socket *sock = SOCKET_I(d_inode(dentry));
603
604                 if (sock->sk)
605                         sock->sk->sk_uid = iattr->ia_uid;
606                 else
607                         err = -ENOENT;
608         }
609
610         return err;
611 }
612
613 static const struct inode_operations sockfs_inode_ops = {
614         .listxattr = sockfs_listxattr,
615         .setattr = sockfs_setattr,
616 };
617
618 /**
619  *      sock_alloc - allocate a socket
620  *
621  *      Allocate a new inode and socket object. The two are bound together
622  *      and initialised. The socket is then returned. If we are out of inodes
623  *      NULL is returned. This functions uses GFP_KERNEL internally.
624  */
625
626 struct socket *sock_alloc(void)
627 {
628         struct inode *inode;
629         struct socket *sock;
630
631         inode = new_inode_pseudo(sock_mnt->mnt_sb);
632         if (!inode)
633                 return NULL;
634
635         sock = SOCKET_I(inode);
636
637         inode->i_ino = get_next_ino();
638         inode->i_mode = S_IFSOCK | S_IRWXUGO;
639         inode->i_uid = current_fsuid();
640         inode->i_gid = current_fsgid();
641         inode->i_op = &sockfs_inode_ops;
642
643         return sock;
644 }
645 EXPORT_SYMBOL(sock_alloc);
646
647 static void __sock_release(struct socket *sock, struct inode *inode)
648 {
649         if (sock->ops) {
650                 struct module *owner = sock->ops->owner;
651
652                 if (inode)
653                         inode_lock(inode);
654                 sock->ops->release(sock);
655                 sock->sk = NULL;
656                 if (inode)
657                         inode_unlock(inode);
658                 sock->ops = NULL;
659                 module_put(owner);
660         }
661
662         if (sock->wq.fasync_list)
663                 pr_err("%s: fasync list not empty!\n", __func__);
664
665         if (!sock->file) {
666                 iput(SOCK_INODE(sock));
667                 return;
668         }
669         sock->file = NULL;
670 }
671
672 /**
673  *      sock_release - close a socket
674  *      @sock: socket to close
675  *
676  *      The socket is released from the protocol stack if it has a release
677  *      callback, and the inode is then released if the socket is bound to
678  *      an inode not a file.
679  */
680 void sock_release(struct socket *sock)
681 {
682         __sock_release(sock, NULL);
683 }
684 EXPORT_SYMBOL(sock_release);
685
686 void __sock_tx_timestamp(__u16 tsflags, __u8 *tx_flags)
687 {
688         u8 flags = *tx_flags;
689
690         if (tsflags & SOF_TIMESTAMPING_TX_HARDWARE) {
691                 flags |= SKBTX_HW_TSTAMP;
692
693                 /* PTP hardware clocks can provide a free running cycle counter
694                  * as a time base for virtual clocks. Tell driver to use the
695                  * free running cycle counter for timestamp if socket is bound
696                  * to virtual clock.
697                  */
698                 if (tsflags & SOF_TIMESTAMPING_BIND_PHC)
699                         flags |= SKBTX_HW_TSTAMP_USE_CYCLES;
700         }
701
702         if (tsflags & SOF_TIMESTAMPING_TX_SOFTWARE)
703                 flags |= SKBTX_SW_TSTAMP;
704
705         if (tsflags & SOF_TIMESTAMPING_TX_SCHED)
706                 flags |= SKBTX_SCHED_TSTAMP;
707
708         *tx_flags = flags;
709 }
710 EXPORT_SYMBOL(__sock_tx_timestamp);
711
712 INDIRECT_CALLABLE_DECLARE(int inet_sendmsg(struct socket *, struct msghdr *,
713                                            size_t));
714 INDIRECT_CALLABLE_DECLARE(int inet6_sendmsg(struct socket *, struct msghdr *,
715                                             size_t));
716 static inline int sock_sendmsg_nosec(struct socket *sock, struct msghdr *msg)
717 {
718         int ret = INDIRECT_CALL_INET(sock->ops->sendmsg, inet6_sendmsg,
719                                      inet_sendmsg, sock, msg,
720                                      msg_data_left(msg));
721         BUG_ON(ret == -EIOCBQUEUED);
722         return ret;
723 }
724
725 static int __sock_sendmsg(struct socket *sock, struct msghdr *msg)
726 {
727         int err = security_socket_sendmsg(sock, msg,
728                                           msg_data_left(msg));
729
730         return err ?: sock_sendmsg_nosec(sock, msg);
731 }
732
733 /**
734  *      sock_sendmsg - send a message through @sock
735  *      @sock: socket
736  *      @msg: message to send
737  *
738  *      Sends @msg through @sock, passing through LSM.
739  *      Returns the number of bytes sent, or an error code.
740  */
741 int sock_sendmsg(struct socket *sock, struct msghdr *msg)
742 {
743         struct sockaddr_storage *save_addr = (struct sockaddr_storage *)msg->msg_name;
744         struct sockaddr_storage address;
745         int save_len = msg->msg_namelen;
746         int ret;
747
748         if (msg->msg_name) {
749                 memcpy(&address, msg->msg_name, msg->msg_namelen);
750                 msg->msg_name = &address;
751         }
752
753         ret = __sock_sendmsg(sock, msg);
754         msg->msg_name = save_addr;
755         msg->msg_namelen = save_len;
756
757         return ret;
758 }
759 EXPORT_SYMBOL(sock_sendmsg);
760
761 /**
762  *      kernel_sendmsg - send a message through @sock (kernel-space)
763  *      @sock: socket
764  *      @msg: message header
765  *      @vec: kernel vec
766  *      @num: vec array length
767  *      @size: total message data size
768  *
769  *      Builds the message data with @vec and sends it through @sock.
770  *      Returns the number of bytes sent, or an error code.
771  */
772
773 int kernel_sendmsg(struct socket *sock, struct msghdr *msg,
774                    struct kvec *vec, size_t num, size_t size)
775 {
776         iov_iter_kvec(&msg->msg_iter, ITER_SOURCE, vec, num, size);
777         return sock_sendmsg(sock, msg);
778 }
779 EXPORT_SYMBOL(kernel_sendmsg);
780
781 /**
782  *      kernel_sendmsg_locked - send a message through @sock (kernel-space)
783  *      @sk: sock
784  *      @msg: message header
785  *      @vec: output s/g array
786  *      @num: output s/g array length
787  *      @size: total message data size
788  *
789  *      Builds the message data with @vec and sends it through @sock.
790  *      Returns the number of bytes sent, or an error code.
791  *      Caller must hold @sk.
792  */
793
794 int kernel_sendmsg_locked(struct sock *sk, struct msghdr *msg,
795                           struct kvec *vec, size_t num, size_t size)
796 {
797         struct socket *sock = sk->sk_socket;
798
799         if (!sock->ops->sendmsg_locked)
800                 return sock_no_sendmsg_locked(sk, msg, size);
801
802         iov_iter_kvec(&msg->msg_iter, ITER_SOURCE, vec, num, size);
803
804         return sock->ops->sendmsg_locked(sk, msg, msg_data_left(msg));
805 }
806 EXPORT_SYMBOL(kernel_sendmsg_locked);
807
808 static bool skb_is_err_queue(const struct sk_buff *skb)
809 {
810         /* pkt_type of skbs enqueued on the error queue are set to
811          * PACKET_OUTGOING in skb_set_err_queue(). This is only safe to do
812          * in recvmsg, since skbs received on a local socket will never
813          * have a pkt_type of PACKET_OUTGOING.
814          */
815         return skb->pkt_type == PACKET_OUTGOING;
816 }
817
818 /* On transmit, software and hardware timestamps are returned independently.
819  * As the two skb clones share the hardware timestamp, which may be updated
820  * before the software timestamp is received, a hardware TX timestamp may be
821  * returned only if there is no software TX timestamp. Ignore false software
822  * timestamps, which may be made in the __sock_recv_timestamp() call when the
823  * option SO_TIMESTAMP_OLD(NS) is enabled on the socket, even when the skb has a
824  * hardware timestamp.
825  */
826 static bool skb_is_swtx_tstamp(const struct sk_buff *skb, int false_tstamp)
827 {
828         return skb->tstamp && !false_tstamp && skb_is_err_queue(skb);
829 }
830
831 static ktime_t get_timestamp(struct sock *sk, struct sk_buff *skb, int *if_index)
832 {
833         bool cycles = READ_ONCE(sk->sk_tsflags) & SOF_TIMESTAMPING_BIND_PHC;
834         struct skb_shared_hwtstamps *shhwtstamps = skb_hwtstamps(skb);
835         struct net_device *orig_dev;
836         ktime_t hwtstamp;
837
838         rcu_read_lock();
839         orig_dev = dev_get_by_napi_id(skb_napi_id(skb));
840         if (orig_dev) {
841                 *if_index = orig_dev->ifindex;
842                 hwtstamp = netdev_get_tstamp(orig_dev, shhwtstamps, cycles);
843         } else {
844                 hwtstamp = shhwtstamps->hwtstamp;
845         }
846         rcu_read_unlock();
847
848         return hwtstamp;
849 }
850
851 static void put_ts_pktinfo(struct msghdr *msg, struct sk_buff *skb,
852                            int if_index)
853 {
854         struct scm_ts_pktinfo ts_pktinfo;
855         struct net_device *orig_dev;
856
857         if (!skb_mac_header_was_set(skb))
858                 return;
859
860         memset(&ts_pktinfo, 0, sizeof(ts_pktinfo));
861
862         if (!if_index) {
863                 rcu_read_lock();
864                 orig_dev = dev_get_by_napi_id(skb_napi_id(skb));
865                 if (orig_dev)
866                         if_index = orig_dev->ifindex;
867                 rcu_read_unlock();
868         }
869         ts_pktinfo.if_index = if_index;
870
871         ts_pktinfo.pkt_length = skb->len - skb_mac_offset(skb);
872         put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPING_PKTINFO,
873                  sizeof(ts_pktinfo), &ts_pktinfo);
874 }
875
876 /*
877  * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
878  */
879 void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
880         struct sk_buff *skb)
881 {
882         int need_software_tstamp = sock_flag(sk, SOCK_RCVTSTAMP);
883         int new_tstamp = sock_flag(sk, SOCK_TSTAMP_NEW);
884         struct scm_timestamping_internal tss;
885         int empty = 1, false_tstamp = 0;
886         struct skb_shared_hwtstamps *shhwtstamps =
887                 skb_hwtstamps(skb);
888         int if_index;
889         ktime_t hwtstamp;
890         u32 tsflags;
891
892         /* Race occurred between timestamp enabling and packet
893            receiving.  Fill in the current time for now. */
894         if (need_software_tstamp && skb->tstamp == 0) {
895                 __net_timestamp(skb);
896                 false_tstamp = 1;
897         }
898
899         if (need_software_tstamp) {
900                 if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
901                         if (new_tstamp) {
902                                 struct __kernel_sock_timeval tv;
903
904                                 skb_get_new_timestamp(skb, &tv);
905                                 put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_NEW,
906                                          sizeof(tv), &tv);
907                         } else {
908                                 struct __kernel_old_timeval tv;
909
910                                 skb_get_timestamp(skb, &tv);
911                                 put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_OLD,
912                                          sizeof(tv), &tv);
913                         }
914                 } else {
915                         if (new_tstamp) {
916                                 struct __kernel_timespec ts;
917
918                                 skb_get_new_timestampns(skb, &ts);
919                                 put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_NEW,
920                                          sizeof(ts), &ts);
921                         } else {
922                                 struct __kernel_old_timespec ts;
923
924                                 skb_get_timestampns(skb, &ts);
925                                 put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_OLD,
926                                          sizeof(ts), &ts);
927                         }
928                 }
929         }
930
931         memset(&tss, 0, sizeof(tss));
932         tsflags = READ_ONCE(sk->sk_tsflags);
933         if ((tsflags & SOF_TIMESTAMPING_SOFTWARE) &&
934             ktime_to_timespec64_cond(skb->tstamp, tss.ts + 0))
935                 empty = 0;
936         if (shhwtstamps &&
937             (tsflags & SOF_TIMESTAMPING_RAW_HARDWARE) &&
938             !skb_is_swtx_tstamp(skb, false_tstamp)) {
939                 if_index = 0;
940                 if (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP_NETDEV)
941                         hwtstamp = get_timestamp(sk, skb, &if_index);
942                 else
943                         hwtstamp = shhwtstamps->hwtstamp;
944
945                 if (tsflags & SOF_TIMESTAMPING_BIND_PHC)
946                         hwtstamp = ptp_convert_timestamp(&hwtstamp,
947                                                          READ_ONCE(sk->sk_bind_phc));
948
949                 if (ktime_to_timespec64_cond(hwtstamp, tss.ts + 2)) {
950                         empty = 0;
951
952                         if ((tsflags & SOF_TIMESTAMPING_OPT_PKTINFO) &&
953                             !skb_is_err_queue(skb))
954                                 put_ts_pktinfo(msg, skb, if_index);
955                 }
956         }
957         if (!empty) {
958                 if (sock_flag(sk, SOCK_TSTAMP_NEW))
959                         put_cmsg_scm_timestamping64(msg, &tss);
960                 else
961                         put_cmsg_scm_timestamping(msg, &tss);
962
963                 if (skb_is_err_queue(skb) && skb->len &&
964                     SKB_EXT_ERR(skb)->opt_stats)
965                         put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPING_OPT_STATS,
966                                  skb->len, skb->data);
967         }
968 }
969 EXPORT_SYMBOL_GPL(__sock_recv_timestamp);
970
971 void __sock_recv_wifi_status(struct msghdr *msg, struct sock *sk,
972         struct sk_buff *skb)
973 {
974         int ack;
975
976         if (!sock_flag(sk, SOCK_WIFI_STATUS))
977                 return;
978         if (!skb->wifi_acked_valid)
979                 return;
980
981         ack = skb->wifi_acked;
982
983         put_cmsg(msg, SOL_SOCKET, SCM_WIFI_STATUS, sizeof(ack), &ack);
984 }
985 EXPORT_SYMBOL_GPL(__sock_recv_wifi_status);
986
987 static inline void sock_recv_drops(struct msghdr *msg, struct sock *sk,
988                                    struct sk_buff *skb)
989 {
990         if (sock_flag(sk, SOCK_RXQ_OVFL) && skb && SOCK_SKB_CB(skb)->dropcount)
991                 put_cmsg(msg, SOL_SOCKET, SO_RXQ_OVFL,
992                         sizeof(__u32), &SOCK_SKB_CB(skb)->dropcount);
993 }
994
995 static void sock_recv_mark(struct msghdr *msg, struct sock *sk,
996                            struct sk_buff *skb)
997 {
998         if (sock_flag(sk, SOCK_RCVMARK) && skb) {
999                 /* We must use a bounce buffer for CONFIG_HARDENED_USERCOPY=y */
1000                 __u32 mark = skb->mark;
1001
1002                 put_cmsg(msg, SOL_SOCKET, SO_MARK, sizeof(__u32), &mark);
1003         }
1004 }
1005
1006 void __sock_recv_cmsgs(struct msghdr *msg, struct sock *sk,
1007                        struct sk_buff *skb)
1008 {
1009         sock_recv_timestamp(msg, sk, skb);
1010         sock_recv_drops(msg, sk, skb);
1011         sock_recv_mark(msg, sk, skb);
1012 }
1013 EXPORT_SYMBOL_GPL(__sock_recv_cmsgs);
1014
1015 INDIRECT_CALLABLE_DECLARE(int inet_recvmsg(struct socket *, struct msghdr *,
1016                                            size_t, int));
1017 INDIRECT_CALLABLE_DECLARE(int inet6_recvmsg(struct socket *, struct msghdr *,
1018                                             size_t, int));
1019 static inline int sock_recvmsg_nosec(struct socket *sock, struct msghdr *msg,
1020                                      int flags)
1021 {
1022         return INDIRECT_CALL_INET(sock->ops->recvmsg, inet6_recvmsg,
1023                                   inet_recvmsg, sock, msg, msg_data_left(msg),
1024                                   flags);
1025 }
1026
1027 /**
1028  *      sock_recvmsg - receive a message from @sock
1029  *      @sock: socket
1030  *      @msg: message to receive
1031  *      @flags: message flags
1032  *
1033  *      Receives @msg from @sock, passing through LSM. Returns the total number
1034  *      of bytes received, or an error.
1035  */
1036 int sock_recvmsg(struct socket *sock, struct msghdr *msg, int flags)
1037 {
1038         int err = security_socket_recvmsg(sock, msg, msg_data_left(msg), flags);
1039
1040         return err ?: sock_recvmsg_nosec(sock, msg, flags);
1041 }
1042 EXPORT_SYMBOL(sock_recvmsg);
1043
1044 /**
1045  *      kernel_recvmsg - Receive a message from a socket (kernel space)
1046  *      @sock: The socket to receive the message from
1047  *      @msg: Received message
1048  *      @vec: Input s/g array for message data
1049  *      @num: Size of input s/g array
1050  *      @size: Number of bytes to read
1051  *      @flags: Message flags (MSG_DONTWAIT, etc...)
1052  *
1053  *      On return the msg structure contains the scatter/gather array passed in the
1054  *      vec argument. The array is modified so that it consists of the unfilled
1055  *      portion of the original array.
1056  *
1057  *      The returned value is the total number of bytes received, or an error.
1058  */
1059
1060 int kernel_recvmsg(struct socket *sock, struct msghdr *msg,
1061                    struct kvec *vec, size_t num, size_t size, int flags)
1062 {
1063         msg->msg_control_is_user = false;
1064         iov_iter_kvec(&msg->msg_iter, ITER_DEST, vec, num, size);
1065         return sock_recvmsg(sock, msg, flags);
1066 }
1067 EXPORT_SYMBOL(kernel_recvmsg);
1068
1069 static ssize_t sock_sendpage(struct file *file, struct page *page,
1070                              int offset, size_t size, loff_t *ppos, int more)
1071 {
1072         struct socket *sock;
1073         int flags;
1074
1075         sock = file->private_data;
1076
1077         flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
1078         /* more is a combination of MSG_MORE and MSG_SENDPAGE_NOTLAST */
1079         flags |= more;
1080
1081         return kernel_sendpage(sock, page, offset, size, flags);
1082 }
1083
1084 static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
1085                                 struct pipe_inode_info *pipe, size_t len,
1086                                 unsigned int flags)
1087 {
1088         struct socket *sock = file->private_data;
1089
1090         if (unlikely(!sock->ops->splice_read))
1091                 return generic_file_splice_read(file, ppos, pipe, len, flags);
1092
1093         return sock->ops->splice_read(sock, ppos, pipe, len, flags);
1094 }
1095
1096 static void sock_splice_eof(struct file *file)
1097 {
1098         struct socket *sock = file->private_data;
1099
1100         if (sock->ops->splice_eof)
1101                 sock->ops->splice_eof(sock);
1102 }
1103
1104 static ssize_t sock_read_iter(struct kiocb *iocb, struct iov_iter *to)
1105 {
1106         struct file *file = iocb->ki_filp;
1107         struct socket *sock = file->private_data;
1108         struct msghdr msg = {.msg_iter = *to,
1109                              .msg_iocb = iocb};
1110         ssize_t res;
1111
1112         if (file->f_flags & O_NONBLOCK || (iocb->ki_flags & IOCB_NOWAIT))
1113                 msg.msg_flags = MSG_DONTWAIT;
1114
1115         if (iocb->ki_pos != 0)
1116                 return -ESPIPE;
1117
1118         if (!iov_iter_count(to))        /* Match SYS5 behaviour */
1119                 return 0;
1120
1121         res = sock_recvmsg(sock, &msg, msg.msg_flags);
1122         *to = msg.msg_iter;
1123         return res;
1124 }
1125
1126 static ssize_t sock_write_iter(struct kiocb *iocb, struct iov_iter *from)
1127 {
1128         struct file *file = iocb->ki_filp;
1129         struct socket *sock = file->private_data;
1130         struct msghdr msg = {.msg_iter = *from,
1131                              .msg_iocb = iocb};
1132         ssize_t res;
1133
1134         if (iocb->ki_pos != 0)
1135                 return -ESPIPE;
1136
1137         if (file->f_flags & O_NONBLOCK || (iocb->ki_flags & IOCB_NOWAIT))
1138                 msg.msg_flags = MSG_DONTWAIT;
1139
1140         if (sock->type == SOCK_SEQPACKET)
1141                 msg.msg_flags |= MSG_EOR;
1142
1143         res = __sock_sendmsg(sock, &msg);
1144         *from = msg.msg_iter;
1145         return res;
1146 }
1147
1148 /*
1149  * Atomic setting of ioctl hooks to avoid race
1150  * with module unload.
1151  */
1152
1153 static DEFINE_MUTEX(br_ioctl_mutex);
1154 static int (*br_ioctl_hook)(struct net *net, struct net_bridge *br,
1155                             unsigned int cmd, struct ifreq *ifr,
1156                             void __user *uarg);
1157
1158 void brioctl_set(int (*hook)(struct net *net, struct net_bridge *br,
1159                              unsigned int cmd, struct ifreq *ifr,
1160                              void __user *uarg))
1161 {
1162         mutex_lock(&br_ioctl_mutex);
1163         br_ioctl_hook = hook;
1164         mutex_unlock(&br_ioctl_mutex);
1165 }
1166 EXPORT_SYMBOL(brioctl_set);
1167
1168 int br_ioctl_call(struct net *net, struct net_bridge *br, unsigned int cmd,
1169                   struct ifreq *ifr, void __user *uarg)
1170 {
1171         int err = -ENOPKG;
1172
1173         if (!br_ioctl_hook)
1174                 request_module("bridge");
1175
1176         mutex_lock(&br_ioctl_mutex);
1177         if (br_ioctl_hook)
1178                 err = br_ioctl_hook(net, br, cmd, ifr, uarg);
1179         mutex_unlock(&br_ioctl_mutex);
1180
1181         return err;
1182 }
1183
1184 static DEFINE_MUTEX(vlan_ioctl_mutex);
1185 static int (*vlan_ioctl_hook) (struct net *, void __user *arg);
1186
1187 void vlan_ioctl_set(int (*hook) (struct net *, void __user *))
1188 {
1189         mutex_lock(&vlan_ioctl_mutex);
1190         vlan_ioctl_hook = hook;
1191         mutex_unlock(&vlan_ioctl_mutex);
1192 }
1193 EXPORT_SYMBOL(vlan_ioctl_set);
1194
1195 static long sock_do_ioctl(struct net *net, struct socket *sock,
1196                           unsigned int cmd, unsigned long arg)
1197 {
1198         struct ifreq ifr;
1199         bool need_copyout;
1200         int err;
1201         void __user *argp = (void __user *)arg;
1202         void __user *data;
1203
1204         err = sock->ops->ioctl(sock, cmd, arg);
1205
1206         /*
1207          * If this ioctl is unknown try to hand it down
1208          * to the NIC driver.
1209          */
1210         if (err != -ENOIOCTLCMD)
1211                 return err;
1212
1213         if (!is_socket_ioctl_cmd(cmd))
1214                 return -ENOTTY;
1215
1216         if (get_user_ifreq(&ifr, &data, argp))
1217                 return -EFAULT;
1218         err = dev_ioctl(net, cmd, &ifr, data, &need_copyout);
1219         if (!err && need_copyout)
1220                 if (put_user_ifreq(&ifr, argp))
1221                         return -EFAULT;
1222
1223         return err;
1224 }
1225
1226 /*
1227  *      With an ioctl, arg may well be a user mode pointer, but we don't know
1228  *      what to do with it - that's up to the protocol still.
1229  */
1230
1231 static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
1232 {
1233         struct socket *sock;
1234         struct sock *sk;
1235         void __user *argp = (void __user *)arg;
1236         int pid, err;
1237         struct net *net;
1238
1239         sock = file->private_data;
1240         sk = sock->sk;
1241         net = sock_net(sk);
1242         if (unlikely(cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15))) {
1243                 struct ifreq ifr;
1244                 void __user *data;
1245                 bool need_copyout;
1246                 if (get_user_ifreq(&ifr, &data, argp))
1247                         return -EFAULT;
1248                 err = dev_ioctl(net, cmd, &ifr, data, &need_copyout);
1249                 if (!err && need_copyout)
1250                         if (put_user_ifreq(&ifr, argp))
1251                                 return -EFAULT;
1252         } else
1253 #ifdef CONFIG_WEXT_CORE
1254         if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {
1255                 err = wext_handle_ioctl(net, cmd, argp);
1256         } else
1257 #endif
1258                 switch (cmd) {
1259                 case FIOSETOWN:
1260                 case SIOCSPGRP:
1261                         err = -EFAULT;
1262                         if (get_user(pid, (int __user *)argp))
1263                                 break;
1264                         err = f_setown(sock->file, pid, 1);
1265                         break;
1266                 case FIOGETOWN:
1267                 case SIOCGPGRP:
1268                         err = put_user(f_getown(sock->file),
1269                                        (int __user *)argp);
1270                         break;
1271                 case SIOCGIFBR:
1272                 case SIOCSIFBR:
1273                 case SIOCBRADDBR:
1274                 case SIOCBRDELBR:
1275                         err = br_ioctl_call(net, NULL, cmd, NULL, argp);
1276                         break;
1277                 case SIOCGIFVLAN:
1278                 case SIOCSIFVLAN:
1279                         err = -ENOPKG;
1280                         if (!vlan_ioctl_hook)
1281                                 request_module("8021q");
1282
1283                         mutex_lock(&vlan_ioctl_mutex);
1284                         if (vlan_ioctl_hook)
1285                                 err = vlan_ioctl_hook(net, argp);
1286                         mutex_unlock(&vlan_ioctl_mutex);
1287                         break;
1288                 case SIOCGSKNS:
1289                         err = -EPERM;
1290                         if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1291                                 break;
1292
1293                         err = open_related_ns(&net->ns, get_net_ns);
1294                         break;
1295                 case SIOCGSTAMP_OLD:
1296                 case SIOCGSTAMPNS_OLD:
1297                         if (!sock->ops->gettstamp) {
1298                                 err = -ENOIOCTLCMD;
1299                                 break;
1300                         }
1301                         err = sock->ops->gettstamp(sock, argp,
1302                                                    cmd == SIOCGSTAMP_OLD,
1303                                                    !IS_ENABLED(CONFIG_64BIT));
1304                         break;
1305                 case SIOCGSTAMP_NEW:
1306                 case SIOCGSTAMPNS_NEW:
1307                         if (!sock->ops->gettstamp) {
1308                                 err = -ENOIOCTLCMD;
1309                                 break;
1310                         }
1311                         err = sock->ops->gettstamp(sock, argp,
1312                                                    cmd == SIOCGSTAMP_NEW,
1313                                                    false);
1314                         break;
1315
1316                 case SIOCGIFCONF:
1317                         err = dev_ifconf(net, argp);
1318                         break;
1319
1320                 default:
1321                         err = sock_do_ioctl(net, sock, cmd, arg);
1322                         break;
1323                 }
1324         return err;
1325 }
1326
1327 /**
1328  *      sock_create_lite - creates a socket
1329  *      @family: protocol family (AF_INET, ...)
1330  *      @type: communication type (SOCK_STREAM, ...)
1331  *      @protocol: protocol (0, ...)
1332  *      @res: new socket
1333  *
1334  *      Creates a new socket and assigns it to @res, passing through LSM.
1335  *      The new socket initialization is not complete, see kernel_accept().
1336  *      Returns 0 or an error. On failure @res is set to %NULL.
1337  *      This function internally uses GFP_KERNEL.
1338  */
1339
1340 int sock_create_lite(int family, int type, int protocol, struct socket **res)
1341 {
1342         int err;
1343         struct socket *sock = NULL;
1344
1345         err = security_socket_create(family, type, protocol, 1);
1346         if (err)
1347                 goto out;
1348
1349         sock = sock_alloc();
1350         if (!sock) {
1351                 err = -ENOMEM;
1352                 goto out;
1353         }
1354
1355         sock->type = type;
1356         err = security_socket_post_create(sock, family, type, protocol, 1);
1357         if (err)
1358                 goto out_release;
1359
1360 out:
1361         *res = sock;
1362         return err;
1363 out_release:
1364         sock_release(sock);
1365         sock = NULL;
1366         goto out;
1367 }
1368 EXPORT_SYMBOL(sock_create_lite);
1369
1370 /* No kernel lock held - perfect */
1371 static __poll_t sock_poll(struct file *file, poll_table *wait)
1372 {
1373         struct socket *sock = file->private_data;
1374         __poll_t events = poll_requested_events(wait), flag = 0;
1375
1376         if (!sock->ops->poll)
1377                 return 0;
1378
1379         if (sk_can_busy_loop(sock->sk)) {
1380                 /* poll once if requested by the syscall */
1381                 if (events & POLL_BUSY_LOOP)
1382                         sk_busy_loop(sock->sk, 1);
1383
1384                 /* if this socket can poll_ll, tell the system call */
1385                 flag = POLL_BUSY_LOOP;
1386         }
1387
1388         return sock->ops->poll(file, sock, wait) | flag;
1389 }
1390
1391 static int sock_mmap(struct file *file, struct vm_area_struct *vma)
1392 {
1393         struct socket *sock = file->private_data;
1394
1395         return sock->ops->mmap(file, sock, vma);
1396 }
1397
1398 static int sock_close(struct inode *inode, struct file *filp)
1399 {
1400         __sock_release(SOCKET_I(inode), inode);
1401         return 0;
1402 }
1403
1404 /*
1405  *      Update the socket async list
1406  *
1407  *      Fasync_list locking strategy.
1408  *
1409  *      1. fasync_list is modified only under process context socket lock
1410  *         i.e. under semaphore.
1411  *      2. fasync_list is used under read_lock(&sk->sk_callback_lock)
1412  *         or under socket lock
1413  */
1414
1415 static int sock_fasync(int fd, struct file *filp, int on)
1416 {
1417         struct socket *sock = filp->private_data;
1418         struct sock *sk = sock->sk;
1419         struct socket_wq *wq = &sock->wq;
1420
1421         if (sk == NULL)
1422                 return -EINVAL;
1423
1424         lock_sock(sk);
1425         fasync_helper(fd, filp, on, &wq->fasync_list);
1426
1427         if (!wq->fasync_list)
1428                 sock_reset_flag(sk, SOCK_FASYNC);
1429         else
1430                 sock_set_flag(sk, SOCK_FASYNC);
1431
1432         release_sock(sk);
1433         return 0;
1434 }
1435
1436 /* This function may be called only under rcu_lock */
1437
1438 int sock_wake_async(struct socket_wq *wq, int how, int band)
1439 {
1440         if (!wq || !wq->fasync_list)
1441                 return -1;
1442
1443         switch (how) {
1444         case SOCK_WAKE_WAITD:
1445                 if (test_bit(SOCKWQ_ASYNC_WAITDATA, &wq->flags))
1446                         break;
1447                 goto call_kill;
1448         case SOCK_WAKE_SPACE:
1449                 if (!test_and_clear_bit(SOCKWQ_ASYNC_NOSPACE, &wq->flags))
1450                         break;
1451                 fallthrough;
1452         case SOCK_WAKE_IO:
1453 call_kill:
1454                 kill_fasync(&wq->fasync_list, SIGIO, band);
1455                 break;
1456         case SOCK_WAKE_URG:
1457                 kill_fasync(&wq->fasync_list, SIGURG, band);
1458         }
1459
1460         return 0;
1461 }
1462 EXPORT_SYMBOL(sock_wake_async);
1463
1464 /**
1465  *      __sock_create - creates a socket
1466  *      @net: net namespace
1467  *      @family: protocol family (AF_INET, ...)
1468  *      @type: communication type (SOCK_STREAM, ...)
1469  *      @protocol: protocol (0, ...)
1470  *      @res: new socket
1471  *      @kern: boolean for kernel space sockets
1472  *
1473  *      Creates a new socket and assigns it to @res, passing through LSM.
1474  *      Returns 0 or an error. On failure @res is set to %NULL. @kern must
1475  *      be set to true if the socket resides in kernel space.
1476  *      This function internally uses GFP_KERNEL.
1477  */
1478
1479 int __sock_create(struct net *net, int family, int type, int protocol,
1480                          struct socket **res, int kern)
1481 {
1482         int err;
1483         struct socket *sock;
1484         const struct net_proto_family *pf;
1485
1486         /*
1487          *      Check protocol is in range
1488          */
1489         if (family < 0 || family >= NPROTO)
1490                 return -EAFNOSUPPORT;
1491         if (type < 0 || type >= SOCK_MAX)
1492                 return -EINVAL;
1493
1494         /* Compatibility.
1495
1496            This uglymoron is moved from INET layer to here to avoid
1497            deadlock in module load.
1498          */
1499         if (family == PF_INET && type == SOCK_PACKET) {
1500                 pr_info_once("%s uses obsolete (PF_INET,SOCK_PACKET)\n",
1501                              current->comm);
1502                 family = PF_PACKET;
1503         }
1504
1505         err = security_socket_create(family, type, protocol, kern);
1506         if (err)
1507                 return err;
1508
1509         /*
1510          *      Allocate the socket and allow the family to set things up. if
1511          *      the protocol is 0, the family is instructed to select an appropriate
1512          *      default.
1513          */
1514         sock = sock_alloc();
1515         if (!sock) {
1516                 net_warn_ratelimited("socket: no more sockets\n");
1517                 return -ENFILE; /* Not exactly a match, but its the
1518                                    closest posix thing */
1519         }
1520
1521         sock->type = type;
1522
1523 #ifdef CONFIG_MODULES
1524         /* Attempt to load a protocol module if the find failed.
1525          *
1526          * 12/09/1996 Marcin: But! this makes REALLY only sense, if the user
1527          * requested real, full-featured networking support upon configuration.
1528          * Otherwise module support will break!
1529          */
1530         if (rcu_access_pointer(net_families[family]) == NULL)
1531                 request_module("net-pf-%d", family);
1532 #endif
1533
1534         rcu_read_lock();
1535         pf = rcu_dereference(net_families[family]);
1536         err = -EAFNOSUPPORT;
1537         if (!pf)
1538                 goto out_release;
1539
1540         /*
1541          * We will call the ->create function, that possibly is in a loadable
1542          * module, so we have to bump that loadable module refcnt first.
1543          */
1544         if (!try_module_get(pf->owner))
1545                 goto out_release;
1546
1547         /* Now protected by module ref count */
1548         rcu_read_unlock();
1549
1550         err = pf->create(net, sock, protocol, kern);
1551         if (err < 0)
1552                 goto out_module_put;
1553
1554         /*
1555          * Now to bump the refcnt of the [loadable] module that owns this
1556          * socket at sock_release time we decrement its refcnt.
1557          */
1558         if (!try_module_get(sock->ops->owner))
1559                 goto out_module_busy;
1560
1561         /*
1562          * Now that we're done with the ->create function, the [loadable]
1563          * module can have its refcnt decremented
1564          */
1565         module_put(pf->owner);
1566         err = security_socket_post_create(sock, family, type, protocol, kern);
1567         if (err)
1568                 goto out_sock_release;
1569         *res = sock;
1570
1571         return 0;
1572
1573 out_module_busy:
1574         err = -EAFNOSUPPORT;
1575 out_module_put:
1576         sock->ops = NULL;
1577         module_put(pf->owner);
1578 out_sock_release:
1579         sock_release(sock);
1580         return err;
1581
1582 out_release:
1583         rcu_read_unlock();
1584         goto out_sock_release;
1585 }
1586 EXPORT_SYMBOL(__sock_create);
1587
1588 /**
1589  *      sock_create - creates a socket
1590  *      @family: protocol family (AF_INET, ...)
1591  *      @type: communication type (SOCK_STREAM, ...)
1592  *      @protocol: protocol (0, ...)
1593  *      @res: new socket
1594  *
1595  *      A wrapper around __sock_create().
1596  *      Returns 0 or an error. This function internally uses GFP_KERNEL.
1597  */
1598
1599 int sock_create(int family, int type, int protocol, struct socket **res)
1600 {
1601         return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);
1602 }
1603 EXPORT_SYMBOL(sock_create);
1604
1605 /**
1606  *      sock_create_kern - creates a socket (kernel space)
1607  *      @net: net namespace
1608  *      @family: protocol family (AF_INET, ...)
1609  *      @type: communication type (SOCK_STREAM, ...)
1610  *      @protocol: protocol (0, ...)
1611  *      @res: new socket
1612  *
1613  *      A wrapper around __sock_create().
1614  *      Returns 0 or an error. This function internally uses GFP_KERNEL.
1615  */
1616
1617 int sock_create_kern(struct net *net, int family, int type, int protocol, struct socket **res)
1618 {
1619         return __sock_create(net, family, type, protocol, res, 1);
1620 }
1621 EXPORT_SYMBOL(sock_create_kern);
1622
1623 static struct socket *__sys_socket_create(int family, int type, int protocol)
1624 {
1625         struct socket *sock;
1626         int retval;
1627
1628         /* Check the SOCK_* constants for consistency.  */
1629         BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);
1630         BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK);
1631         BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);
1632         BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);
1633
1634         if ((type & ~SOCK_TYPE_MASK) & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
1635                 return ERR_PTR(-EINVAL);
1636         type &= SOCK_TYPE_MASK;
1637
1638         retval = sock_create(family, type, protocol, &sock);
1639         if (retval < 0)
1640                 return ERR_PTR(retval);
1641
1642         return sock;
1643 }
1644
1645 struct file *__sys_socket_file(int family, int type, int protocol)
1646 {
1647         struct socket *sock;
1648         int flags;
1649
1650         sock = __sys_socket_create(family, type, protocol);
1651         if (IS_ERR(sock))
1652                 return ERR_CAST(sock);
1653
1654         flags = type & ~SOCK_TYPE_MASK;
1655         if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1656                 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1657
1658         return sock_alloc_file(sock, flags, NULL);
1659 }
1660
1661 int __sys_socket(int family, int type, int protocol)
1662 {
1663         struct socket *sock;
1664         int flags;
1665
1666         sock = __sys_socket_create(family, type, protocol);
1667         if (IS_ERR(sock))
1668                 return PTR_ERR(sock);
1669
1670         flags = type & ~SOCK_TYPE_MASK;
1671         if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1672                 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1673
1674         return sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));
1675 }
1676
1677 SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol)
1678 {
1679         return __sys_socket(family, type, protocol);
1680 }
1681
1682 /*
1683  *      Create a pair of connected sockets.
1684  */
1685
1686 int __sys_socketpair(int family, int type, int protocol, int __user *usockvec)
1687 {
1688         struct socket *sock1, *sock2;
1689         int fd1, fd2, err;
1690         struct file *newfile1, *newfile2;
1691         int flags;
1692
1693         flags = type & ~SOCK_TYPE_MASK;
1694         if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
1695                 return -EINVAL;
1696         type &= SOCK_TYPE_MASK;
1697
1698         if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1699                 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1700
1701         /*
1702          * reserve descriptors and make sure we won't fail
1703          * to return them to userland.
1704          */
1705         fd1 = get_unused_fd_flags(flags);
1706         if (unlikely(fd1 < 0))
1707                 return fd1;
1708
1709         fd2 = get_unused_fd_flags(flags);
1710         if (unlikely(fd2 < 0)) {
1711                 put_unused_fd(fd1);
1712                 return fd2;
1713         }
1714
1715         err = put_user(fd1, &usockvec[0]);
1716         if (err)
1717                 goto out;
1718
1719         err = put_user(fd2, &usockvec[1]);
1720         if (err)
1721                 goto out;
1722
1723         /*
1724          * Obtain the first socket and check if the underlying protocol
1725          * supports the socketpair call.
1726          */
1727
1728         err = sock_create(family, type, protocol, &sock1);
1729         if (unlikely(err < 0))
1730                 goto out;
1731
1732         err = sock_create(family, type, protocol, &sock2);
1733         if (unlikely(err < 0)) {
1734                 sock_release(sock1);
1735                 goto out;
1736         }
1737
1738         err = security_socket_socketpair(sock1, sock2);
1739         if (unlikely(err)) {
1740                 sock_release(sock2);
1741                 sock_release(sock1);
1742                 goto out;
1743         }
1744
1745         err = sock1->ops->socketpair(sock1, sock2);
1746         if (unlikely(err < 0)) {
1747                 sock_release(sock2);
1748                 sock_release(sock1);
1749                 goto out;
1750         }
1751
1752         newfile1 = sock_alloc_file(sock1, flags, NULL);
1753         if (IS_ERR(newfile1)) {
1754                 err = PTR_ERR(newfile1);
1755                 sock_release(sock2);
1756                 goto out;
1757         }
1758
1759         newfile2 = sock_alloc_file(sock2, flags, NULL);
1760         if (IS_ERR(newfile2)) {
1761                 err = PTR_ERR(newfile2);
1762                 fput(newfile1);
1763                 goto out;
1764         }
1765
1766         audit_fd_pair(fd1, fd2);
1767
1768         fd_install(fd1, newfile1);
1769         fd_install(fd2, newfile2);
1770         return 0;
1771
1772 out:
1773         put_unused_fd(fd2);
1774         put_unused_fd(fd1);
1775         return err;
1776 }
1777
1778 SYSCALL_DEFINE4(socketpair, int, family, int, type, int, protocol,
1779                 int __user *, usockvec)
1780 {
1781         return __sys_socketpair(family, type, protocol, usockvec);
1782 }
1783
1784 /*
1785  *      Bind a name to a socket. Nothing much to do here since it's
1786  *      the protocol's responsibility to handle the local address.
1787  *
1788  *      We move the socket address to kernel space before we call
1789  *      the protocol layer (having also checked the address is ok).
1790  */
1791
1792 int __sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen)
1793 {
1794         struct socket *sock;
1795         struct sockaddr_storage address;
1796         int err, fput_needed;
1797
1798         sock = sockfd_lookup_light(fd, &err, &fput_needed);
1799         if (sock) {
1800                 err = move_addr_to_kernel(umyaddr, addrlen, &address);
1801                 if (!err) {
1802                         err = security_socket_bind(sock,
1803                                                    (struct sockaddr *)&address,
1804                                                    addrlen);
1805                         if (!err)
1806                                 err = sock->ops->bind(sock,
1807                                                       (struct sockaddr *)
1808                                                       &address, addrlen);
1809                 }
1810                 fput_light(sock->file, fput_needed);
1811         }
1812         return err;
1813 }
1814
1815 SYSCALL_DEFINE3(bind, int, fd, struct sockaddr __user *, umyaddr, int, addrlen)
1816 {
1817         return __sys_bind(fd, umyaddr, addrlen);
1818 }
1819
1820 /*
1821  *      Perform a listen. Basically, we allow the protocol to do anything
1822  *      necessary for a listen, and if that works, we mark the socket as
1823  *      ready for listening.
1824  */
1825
1826 int __sys_listen(int fd, int backlog)
1827 {
1828         struct socket *sock;
1829         int err, fput_needed;
1830         int somaxconn;
1831
1832         sock = sockfd_lookup_light(fd, &err, &fput_needed);
1833         if (sock) {
1834                 somaxconn = READ_ONCE(sock_net(sock->sk)->core.sysctl_somaxconn);
1835                 if ((unsigned int)backlog > somaxconn)
1836                         backlog = somaxconn;
1837
1838                 err = security_socket_listen(sock, backlog);
1839                 if (!err)
1840                         err = sock->ops->listen(sock, backlog);
1841
1842                 fput_light(sock->file, fput_needed);
1843         }
1844         return err;
1845 }
1846
1847 SYSCALL_DEFINE2(listen, int, fd, int, backlog)
1848 {
1849         return __sys_listen(fd, backlog);
1850 }
1851
1852 struct file *do_accept(struct file *file, unsigned file_flags,
1853                        struct sockaddr __user *upeer_sockaddr,
1854                        int __user *upeer_addrlen, int flags)
1855 {
1856         struct socket *sock, *newsock;
1857         struct file *newfile;
1858         int err, len;
1859         struct sockaddr_storage address;
1860
1861         sock = sock_from_file(file);
1862         if (!sock)
1863                 return ERR_PTR(-ENOTSOCK);
1864
1865         newsock = sock_alloc();
1866         if (!newsock)
1867                 return ERR_PTR(-ENFILE);
1868
1869         newsock->type = sock->type;
1870         newsock->ops = sock->ops;
1871
1872         /*
1873          * We don't need try_module_get here, as the listening socket (sock)
1874          * has the protocol module (sock->ops->owner) held.
1875          */
1876         __module_get(newsock->ops->owner);
1877
1878         newfile = sock_alloc_file(newsock, flags, sock->sk->sk_prot_creator->name);
1879         if (IS_ERR(newfile))
1880                 return newfile;
1881
1882         err = security_socket_accept(sock, newsock);
1883         if (err)
1884                 goto out_fd;
1885
1886         err = sock->ops->accept(sock, newsock, sock->file->f_flags | file_flags,
1887                                         false);
1888         if (err < 0)
1889                 goto out_fd;
1890
1891         if (upeer_sockaddr) {
1892                 len = newsock->ops->getname(newsock,
1893                                         (struct sockaddr *)&address, 2);
1894                 if (len < 0) {
1895                         err = -ECONNABORTED;
1896                         goto out_fd;
1897                 }
1898                 err = move_addr_to_user(&address,
1899                                         len, upeer_sockaddr, upeer_addrlen);
1900                 if (err < 0)
1901                         goto out_fd;
1902         }
1903
1904         /* File flags are not inherited via accept() unlike another OSes. */
1905         return newfile;
1906 out_fd:
1907         fput(newfile);
1908         return ERR_PTR(err);
1909 }
1910
1911 static int __sys_accept4_file(struct file *file, struct sockaddr __user *upeer_sockaddr,
1912                               int __user *upeer_addrlen, int flags)
1913 {
1914         struct file *newfile;
1915         int newfd;
1916
1917         if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
1918                 return -EINVAL;
1919
1920         if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1921                 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1922
1923         newfd = get_unused_fd_flags(flags);
1924         if (unlikely(newfd < 0))
1925                 return newfd;
1926
1927         newfile = do_accept(file, 0, upeer_sockaddr, upeer_addrlen,
1928                             flags);
1929         if (IS_ERR(newfile)) {
1930                 put_unused_fd(newfd);
1931                 return PTR_ERR(newfile);
1932         }
1933         fd_install(newfd, newfile);
1934         return newfd;
1935 }
1936
1937 /*
1938  *      For accept, we attempt to create a new socket, set up the link
1939  *      with the client, wake up the client, then return the new
1940  *      connected fd. We collect the address of the connector in kernel
1941  *      space and move it to user at the very end. This is unclean because
1942  *      we open the socket then return an error.
1943  *
1944  *      1003.1g adds the ability to recvmsg() to query connection pending
1945  *      status to recvmsg. We need to add that support in a way thats
1946  *      clean when we restructure accept also.
1947  */
1948
1949 int __sys_accept4(int fd, struct sockaddr __user *upeer_sockaddr,
1950                   int __user *upeer_addrlen, int flags)
1951 {
1952         int ret = -EBADF;
1953         struct fd f;
1954
1955         f = fdget(fd);
1956         if (f.file) {
1957                 ret = __sys_accept4_file(f.file, upeer_sockaddr,
1958                                          upeer_addrlen, flags);
1959                 fdput(f);
1960         }
1961
1962         return ret;
1963 }
1964
1965 SYSCALL_DEFINE4(accept4, int, fd, struct sockaddr __user *, upeer_sockaddr,
1966                 int __user *, upeer_addrlen, int, flags)
1967 {
1968         return __sys_accept4(fd, upeer_sockaddr, upeer_addrlen, flags);
1969 }
1970
1971 SYSCALL_DEFINE3(accept, int, fd, struct sockaddr __user *, upeer_sockaddr,
1972                 int __user *, upeer_addrlen)
1973 {
1974         return __sys_accept4(fd, upeer_sockaddr, upeer_addrlen, 0);
1975 }
1976
1977 /*
1978  *      Attempt to connect to a socket with the server address.  The address
1979  *      is in user space so we verify it is OK and move it to kernel space.
1980  *
1981  *      For 1003.1g we need to add clean support for a bind to AF_UNSPEC to
1982  *      break bindings
1983  *
1984  *      NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and
1985  *      other SEQPACKET protocols that take time to connect() as it doesn't
1986  *      include the -EINPROGRESS status for such sockets.
1987  */
1988
1989 int __sys_connect_file(struct file *file, struct sockaddr_storage *address,
1990                        int addrlen, int file_flags)
1991 {
1992         struct socket *sock;
1993         int err;
1994
1995         sock = sock_from_file(file);
1996         if (!sock) {
1997                 err = -ENOTSOCK;
1998                 goto out;
1999         }
2000
2001         err =
2002             security_socket_connect(sock, (struct sockaddr *)address, addrlen);
2003         if (err)
2004                 goto out;
2005
2006         err = sock->ops->connect(sock, (struct sockaddr *)address, addrlen,
2007                                  sock->file->f_flags | file_flags);
2008 out:
2009         return err;
2010 }
2011
2012 int __sys_connect(int fd, struct sockaddr __user *uservaddr, int addrlen)
2013 {
2014         int ret = -EBADF;
2015         struct fd f;
2016
2017         f = fdget(fd);
2018         if (f.file) {
2019                 struct sockaddr_storage address;
2020
2021                 ret = move_addr_to_kernel(uservaddr, addrlen, &address);
2022                 if (!ret)
2023                         ret = __sys_connect_file(f.file, &address, addrlen, 0);
2024                 fdput(f);
2025         }
2026
2027         return ret;
2028 }
2029
2030 SYSCALL_DEFINE3(connect, int, fd, struct sockaddr __user *, uservaddr,
2031                 int, addrlen)
2032 {
2033         return __sys_connect(fd, uservaddr, addrlen);
2034 }
2035
2036 /*
2037  *      Get the local address ('name') of a socket object. Move the obtained
2038  *      name to user space.
2039  */
2040
2041 int __sys_getsockname(int fd, struct sockaddr __user *usockaddr,
2042                       int __user *usockaddr_len)
2043 {
2044         struct socket *sock;
2045         struct sockaddr_storage address;
2046         int err, fput_needed;
2047
2048         sock = sockfd_lookup_light(fd, &err, &fput_needed);
2049         if (!sock)
2050                 goto out;
2051
2052         err = security_socket_getsockname(sock);
2053         if (err)
2054                 goto out_put;
2055
2056         err = sock->ops->getname(sock, (struct sockaddr *)&address, 0);
2057         if (err < 0)
2058                 goto out_put;
2059         /* "err" is actually length in this case */
2060         err = move_addr_to_user(&address, err, usockaddr, usockaddr_len);
2061
2062 out_put:
2063         fput_light(sock->file, fput_needed);
2064 out:
2065         return err;
2066 }
2067
2068 SYSCALL_DEFINE3(getsockname, int, fd, struct sockaddr __user *, usockaddr,
2069                 int __user *, usockaddr_len)
2070 {
2071         return __sys_getsockname(fd, usockaddr, usockaddr_len);
2072 }
2073
2074 /*
2075  *      Get the remote address ('name') of a socket object. Move the obtained
2076  *      name to user space.
2077  */
2078
2079 int __sys_getpeername(int fd, struct sockaddr __user *usockaddr,
2080                       int __user *usockaddr_len)
2081 {
2082         struct socket *sock;
2083         struct sockaddr_storage address;
2084         int err, fput_needed;
2085
2086         sock = sockfd_lookup_light(fd, &err, &fput_needed);
2087         if (sock != NULL) {
2088                 err = security_socket_getpeername(sock);
2089                 if (err) {
2090                         fput_light(sock->file, fput_needed);
2091                         return err;
2092                 }
2093
2094                 err = sock->ops->getname(sock, (struct sockaddr *)&address, 1);
2095                 if (err >= 0)
2096                         /* "err" is actually length in this case */
2097                         err = move_addr_to_user(&address, err, usockaddr,
2098                                                 usockaddr_len);
2099                 fput_light(sock->file, fput_needed);
2100         }
2101         return err;
2102 }
2103
2104 SYSCALL_DEFINE3(getpeername, int, fd, struct sockaddr __user *, usockaddr,
2105                 int __user *, usockaddr_len)
2106 {
2107         return __sys_getpeername(fd, usockaddr, usockaddr_len);
2108 }
2109
2110 /*
2111  *      Send a datagram to a given address. We move the address into kernel
2112  *      space and check the user space data area is readable before invoking
2113  *      the protocol.
2114  */
2115 int __sys_sendto(int fd, void __user *buff, size_t len, unsigned int flags,
2116                  struct sockaddr __user *addr,  int addr_len)
2117 {
2118         struct socket *sock;
2119         struct sockaddr_storage address;
2120         int err;
2121         struct msghdr msg;
2122         struct iovec iov;
2123         int fput_needed;
2124
2125         err = import_single_range(ITER_SOURCE, buff, len, &iov, &msg.msg_iter);
2126         if (unlikely(err))
2127                 return err;
2128         sock = sockfd_lookup_light(fd, &err, &fput_needed);
2129         if (!sock)
2130                 goto out;
2131
2132         msg.msg_name = NULL;
2133         msg.msg_control = NULL;
2134         msg.msg_controllen = 0;
2135         msg.msg_namelen = 0;
2136         msg.msg_ubuf = NULL;
2137         if (addr) {
2138                 err = move_addr_to_kernel(addr, addr_len, &address);
2139                 if (err < 0)
2140                         goto out_put;
2141                 msg.msg_name = (struct sockaddr *)&address;
2142                 msg.msg_namelen = addr_len;
2143         }
2144         flags &= ~MSG_INTERNAL_SENDMSG_FLAGS;
2145         if (sock->file->f_flags & O_NONBLOCK)
2146                 flags |= MSG_DONTWAIT;
2147         msg.msg_flags = flags;
2148         err = __sock_sendmsg(sock, &msg);
2149
2150 out_put:
2151         fput_light(sock->file, fput_needed);
2152 out:
2153         return err;
2154 }
2155
2156 SYSCALL_DEFINE6(sendto, int, fd, void __user *, buff, size_t, len,
2157                 unsigned int, flags, struct sockaddr __user *, addr,
2158                 int, addr_len)
2159 {
2160         return __sys_sendto(fd, buff, len, flags, addr, addr_len);
2161 }
2162
2163 /*
2164  *      Send a datagram down a socket.
2165  */
2166
2167 SYSCALL_DEFINE4(send, int, fd, void __user *, buff, size_t, len,
2168                 unsigned int, flags)
2169 {
2170         return __sys_sendto(fd, buff, len, flags, NULL, 0);
2171 }
2172
2173 /*
2174  *      Receive a frame from the socket and optionally record the address of the
2175  *      sender. We verify the buffers are writable and if needed move the
2176  *      sender address from kernel to user space.
2177  */
2178 int __sys_recvfrom(int fd, void __user *ubuf, size_t size, unsigned int flags,
2179                    struct sockaddr __user *addr, int __user *addr_len)
2180 {
2181         struct sockaddr_storage address;
2182         struct msghdr msg = {
2183                 /* Save some cycles and don't copy the address if not needed */
2184                 .msg_name = addr ? (struct sockaddr *)&address : NULL,
2185         };
2186         struct socket *sock;
2187         struct iovec iov;
2188         int err, err2;
2189         int fput_needed;
2190
2191         err = import_single_range(ITER_DEST, ubuf, size, &iov, &msg.msg_iter);
2192         if (unlikely(err))
2193                 return err;
2194         sock = sockfd_lookup_light(fd, &err, &fput_needed);
2195         if (!sock)
2196                 goto out;
2197
2198         if (sock->file->f_flags & O_NONBLOCK)
2199                 flags |= MSG_DONTWAIT;
2200         err = sock_recvmsg(sock, &msg, flags);
2201
2202         if (err >= 0 && addr != NULL) {
2203                 err2 = move_addr_to_user(&address,
2204                                          msg.msg_namelen, addr, addr_len);
2205                 if (err2 < 0)
2206                         err = err2;
2207         }
2208
2209         fput_light(sock->file, fput_needed);
2210 out:
2211         return err;
2212 }
2213
2214 SYSCALL_DEFINE6(recvfrom, int, fd, void __user *, ubuf, size_t, size,
2215                 unsigned int, flags, struct sockaddr __user *, addr,
2216                 int __user *, addr_len)
2217 {
2218         return __sys_recvfrom(fd, ubuf, size, flags, addr, addr_len);
2219 }
2220
2221 /*
2222  *      Receive a datagram from a socket.
2223  */
2224
2225 SYSCALL_DEFINE4(recv, int, fd, void __user *, ubuf, size_t, size,
2226                 unsigned int, flags)
2227 {
2228         return __sys_recvfrom(fd, ubuf, size, flags, NULL, NULL);
2229 }
2230
2231 static bool sock_use_custom_sol_socket(const struct socket *sock)
2232 {
2233         const struct sock *sk = sock->sk;
2234
2235         /* Use sock->ops->setsockopt() for MPTCP */
2236         return IS_ENABLED(CONFIG_MPTCP) &&
2237                sk->sk_protocol == IPPROTO_MPTCP &&
2238                sk->sk_type == SOCK_STREAM &&
2239                (sk->sk_family == AF_INET || sk->sk_family == AF_INET6);
2240 }
2241
2242 /*
2243  *      Set a socket option. Because we don't know the option lengths we have
2244  *      to pass the user mode parameter for the protocols to sort out.
2245  */
2246 int __sys_setsockopt(int fd, int level, int optname, char __user *user_optval,
2247                 int optlen)
2248 {
2249         sockptr_t optval = USER_SOCKPTR(user_optval);
2250         char *kernel_optval = NULL;
2251         int err, fput_needed;
2252         struct socket *sock;
2253
2254         if (optlen < 0)
2255                 return -EINVAL;
2256
2257         sock = sockfd_lookup_light(fd, &err, &fput_needed);
2258         if (!sock)
2259                 return err;
2260
2261         err = security_socket_setsockopt(sock, level, optname);
2262         if (err)
2263                 goto out_put;
2264
2265         if (!in_compat_syscall())
2266                 err = BPF_CGROUP_RUN_PROG_SETSOCKOPT(sock->sk, &level, &optname,
2267                                                      user_optval, &optlen,
2268                                                      &kernel_optval);
2269         if (err < 0)
2270                 goto out_put;
2271         if (err > 0) {
2272                 err = 0;
2273                 goto out_put;
2274         }
2275
2276         if (kernel_optval)
2277                 optval = KERNEL_SOCKPTR(kernel_optval);
2278         if (level == SOL_SOCKET && !sock_use_custom_sol_socket(sock))
2279                 err = sock_setsockopt(sock, level, optname, optval, optlen);
2280         else if (unlikely(!sock->ops->setsockopt))
2281                 err = -EOPNOTSUPP;
2282         else
2283                 err = sock->ops->setsockopt(sock, level, optname, optval,
2284                                             optlen);
2285         kfree(kernel_optval);
2286 out_put:
2287         fput_light(sock->file, fput_needed);
2288         return err;
2289 }
2290
2291 SYSCALL_DEFINE5(setsockopt, int, fd, int, level, int, optname,
2292                 char __user *, optval, int, optlen)
2293 {
2294         return __sys_setsockopt(fd, level, optname, optval, optlen);
2295 }
2296
2297 INDIRECT_CALLABLE_DECLARE(bool tcp_bpf_bypass_getsockopt(int level,
2298                                                          int optname));
2299
2300 /*
2301  *      Get a socket option. Because we don't know the option lengths we have
2302  *      to pass a user mode parameter for the protocols to sort out.
2303  */
2304 int __sys_getsockopt(int fd, int level, int optname, char __user *optval,
2305                 int __user *optlen)
2306 {
2307         int err, fput_needed;
2308         struct socket *sock;
2309         int max_optlen;
2310
2311         sock = sockfd_lookup_light(fd, &err, &fput_needed);
2312         if (!sock)
2313                 return err;
2314
2315         err = security_socket_getsockopt(sock, level, optname);
2316         if (err)
2317                 goto out_put;
2318
2319         if (!in_compat_syscall())
2320                 max_optlen = BPF_CGROUP_GETSOCKOPT_MAX_OPTLEN(optlen);
2321
2322         if (level == SOL_SOCKET)
2323                 err = sock_getsockopt(sock, level, optname, optval, optlen);
2324         else if (unlikely(!sock->ops->getsockopt))
2325                 err = -EOPNOTSUPP;
2326         else
2327                 err = sock->ops->getsockopt(sock, level, optname, optval,
2328                                             optlen);
2329
2330         if (!in_compat_syscall())
2331                 err = BPF_CGROUP_RUN_PROG_GETSOCKOPT(sock->sk, level, optname,
2332                                                      optval, optlen, max_optlen,
2333                                                      err);
2334 out_put:
2335         fput_light(sock->file, fput_needed);
2336         return err;
2337 }
2338
2339 SYSCALL_DEFINE5(getsockopt, int, fd, int, level, int, optname,
2340                 char __user *, optval, int __user *, optlen)
2341 {
2342         return __sys_getsockopt(fd, level, optname, optval, optlen);
2343 }
2344
2345 /*
2346  *      Shutdown a socket.
2347  */
2348
2349 int __sys_shutdown_sock(struct socket *sock, int how)
2350 {
2351         int err;
2352
2353         err = security_socket_shutdown(sock, how);
2354         if (!err)
2355                 err = sock->ops->shutdown(sock, how);
2356
2357         return err;
2358 }
2359
2360 int __sys_shutdown(int fd, int how)
2361 {
2362         int err, fput_needed;
2363         struct socket *sock;
2364
2365         sock = sockfd_lookup_light(fd, &err, &fput_needed);
2366         if (sock != NULL) {
2367                 err = __sys_shutdown_sock(sock, how);
2368                 fput_light(sock->file, fput_needed);
2369         }
2370         return err;
2371 }
2372
2373 SYSCALL_DEFINE2(shutdown, int, fd, int, how)
2374 {
2375         return __sys_shutdown(fd, how);
2376 }
2377
2378 /* A couple of helpful macros for getting the address of the 32/64 bit
2379  * fields which are the same type (int / unsigned) on our platforms.
2380  */
2381 #define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member)
2382 #define COMPAT_NAMELEN(msg)     COMPAT_MSG(msg, msg_namelen)
2383 #define COMPAT_FLAGS(msg)       COMPAT_MSG(msg, msg_flags)
2384
2385 struct used_address {
2386         struct sockaddr_storage name;
2387         unsigned int name_len;
2388 };
2389
2390 int __copy_msghdr(struct msghdr *kmsg,
2391                   struct user_msghdr *msg,
2392                   struct sockaddr __user **save_addr)
2393 {
2394         ssize_t err;
2395
2396         kmsg->msg_control_is_user = true;
2397         kmsg->msg_get_inq = 0;
2398         kmsg->msg_control_user = msg->msg_control;
2399         kmsg->msg_controllen = msg->msg_controllen;
2400         kmsg->msg_flags = msg->msg_flags;
2401
2402         kmsg->msg_namelen = msg->msg_namelen;
2403         if (!msg->msg_name)
2404                 kmsg->msg_namelen = 0;
2405
2406         if (kmsg->msg_namelen < 0)
2407                 return -EINVAL;
2408
2409         if (kmsg->msg_namelen > sizeof(struct sockaddr_storage))
2410                 kmsg->msg_namelen = sizeof(struct sockaddr_storage);
2411
2412         if (save_addr)
2413                 *save_addr = msg->msg_name;
2414
2415         if (msg->msg_name && kmsg->msg_namelen) {
2416                 if (!save_addr) {
2417                         err = move_addr_to_kernel(msg->msg_name,
2418                                                   kmsg->msg_namelen,
2419                                                   kmsg->msg_name);
2420                         if (err < 0)
2421                                 return err;
2422                 }
2423         } else {
2424                 kmsg->msg_name = NULL;
2425                 kmsg->msg_namelen = 0;
2426         }
2427
2428         if (msg->msg_iovlen > UIO_MAXIOV)
2429                 return -EMSGSIZE;
2430
2431         kmsg->msg_iocb = NULL;
2432         kmsg->msg_ubuf = NULL;
2433         return 0;
2434 }
2435
2436 static int copy_msghdr_from_user(struct msghdr *kmsg,
2437                                  struct user_msghdr __user *umsg,
2438                                  struct sockaddr __user **save_addr,
2439                                  struct iovec **iov)
2440 {
2441         struct user_msghdr msg;
2442         ssize_t err;
2443
2444         if (copy_from_user(&msg, umsg, sizeof(*umsg)))
2445                 return -EFAULT;
2446
2447         err = __copy_msghdr(kmsg, &msg, save_addr);
2448         if (err)
2449                 return err;
2450
2451         err = import_iovec(save_addr ? ITER_DEST : ITER_SOURCE,
2452                             msg.msg_iov, msg.msg_iovlen,
2453                             UIO_FASTIOV, iov, &kmsg->msg_iter);
2454         return err < 0 ? err : 0;
2455 }
2456
2457 static int ____sys_sendmsg(struct socket *sock, struct msghdr *msg_sys,
2458                            unsigned int flags, struct used_address *used_address,
2459                            unsigned int allowed_msghdr_flags)
2460 {
2461         unsigned char ctl[sizeof(struct cmsghdr) + 20]
2462                                 __aligned(sizeof(__kernel_size_t));
2463         /* 20 is size of ipv6_pktinfo */
2464         unsigned char *ctl_buf = ctl;
2465         int ctl_len;
2466         ssize_t err;
2467
2468         err = -ENOBUFS;
2469
2470         if (msg_sys->msg_controllen > INT_MAX)
2471                 goto out;
2472         flags |= (msg_sys->msg_flags & allowed_msghdr_flags);
2473         ctl_len = msg_sys->msg_controllen;
2474         if ((MSG_CMSG_COMPAT & flags) && ctl_len) {
2475                 err =
2476                     cmsghdr_from_user_compat_to_kern(msg_sys, sock->sk, ctl,
2477                                                      sizeof(ctl));
2478                 if (err)
2479                         goto out;
2480                 ctl_buf = msg_sys->msg_control;
2481                 ctl_len = msg_sys->msg_controllen;
2482         } else if (ctl_len) {
2483                 BUILD_BUG_ON(sizeof(struct cmsghdr) !=
2484                              CMSG_ALIGN(sizeof(struct cmsghdr)));
2485                 if (ctl_len > sizeof(ctl)) {
2486                         ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL);
2487                         if (ctl_buf == NULL)
2488                                 goto out;
2489                 }
2490                 err = -EFAULT;
2491                 if (copy_from_user(ctl_buf, msg_sys->msg_control_user, ctl_len))
2492                         goto out_freectl;
2493                 msg_sys->msg_control = ctl_buf;
2494                 msg_sys->msg_control_is_user = false;
2495         }
2496         flags &= ~MSG_INTERNAL_SENDMSG_FLAGS;
2497         msg_sys->msg_flags = flags;
2498
2499         if (sock->file->f_flags & O_NONBLOCK)
2500                 msg_sys->msg_flags |= MSG_DONTWAIT;
2501         /*
2502          * If this is sendmmsg() and current destination address is same as
2503          * previously succeeded address, omit asking LSM's decision.
2504          * used_address->name_len is initialized to UINT_MAX so that the first
2505          * destination address never matches.
2506          */
2507         if (used_address && msg_sys->msg_name &&
2508             used_address->name_len == msg_sys->msg_namelen &&
2509             !memcmp(&used_address->name, msg_sys->msg_name,
2510                     used_address->name_len)) {
2511                 err = sock_sendmsg_nosec(sock, msg_sys);
2512                 goto out_freectl;
2513         }
2514         err = __sock_sendmsg(sock, msg_sys);
2515         /*
2516          * If this is sendmmsg() and sending to current destination address was
2517          * successful, remember it.
2518          */
2519         if (used_address && err >= 0) {
2520                 used_address->name_len = msg_sys->msg_namelen;
2521                 if (msg_sys->msg_name)
2522                         memcpy(&used_address->name, msg_sys->msg_name,
2523                                used_address->name_len);
2524         }
2525
2526 out_freectl:
2527         if (ctl_buf != ctl)
2528                 sock_kfree_s(sock->sk, ctl_buf, ctl_len);
2529 out:
2530         return err;
2531 }
2532
2533 int sendmsg_copy_msghdr(struct msghdr *msg,
2534                         struct user_msghdr __user *umsg, unsigned flags,
2535                         struct iovec **iov)
2536 {
2537         int err;
2538
2539         if (flags & MSG_CMSG_COMPAT) {
2540                 struct compat_msghdr __user *msg_compat;
2541
2542                 msg_compat = (struct compat_msghdr __user *) umsg;
2543                 err = get_compat_msghdr(msg, msg_compat, NULL, iov);
2544         } else {
2545                 err = copy_msghdr_from_user(msg, umsg, NULL, iov);
2546         }
2547         if (err < 0)
2548                 return err;
2549
2550         return 0;
2551 }
2552
2553 static int ___sys_sendmsg(struct socket *sock, struct user_msghdr __user *msg,
2554                          struct msghdr *msg_sys, unsigned int flags,
2555                          struct used_address *used_address,
2556                          unsigned int allowed_msghdr_flags)
2557 {
2558         struct sockaddr_storage address;
2559         struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
2560         ssize_t err;
2561
2562         msg_sys->msg_name = &address;
2563
2564         err = sendmsg_copy_msghdr(msg_sys, msg, flags, &iov);
2565         if (err < 0)
2566                 return err;
2567
2568         err = ____sys_sendmsg(sock, msg_sys, flags, used_address,
2569                                 allowed_msghdr_flags);
2570         kfree(iov);
2571         return err;
2572 }
2573
2574 /*
2575  *      BSD sendmsg interface
2576  */
2577 long __sys_sendmsg_sock(struct socket *sock, struct msghdr *msg,
2578                         unsigned int flags)
2579 {
2580         return ____sys_sendmsg(sock, msg, flags, NULL, 0);
2581 }
2582
2583 long __sys_sendmsg(int fd, struct user_msghdr __user *msg, unsigned int flags,
2584                    bool forbid_cmsg_compat)
2585 {
2586         int fput_needed, err;
2587         struct msghdr msg_sys;
2588         struct socket *sock;
2589
2590         if (forbid_cmsg_compat && (flags & MSG_CMSG_COMPAT))
2591                 return -EINVAL;
2592
2593         sock = sockfd_lookup_light(fd, &err, &fput_needed);
2594         if (!sock)
2595                 goto out;
2596
2597         err = ___sys_sendmsg(sock, msg, &msg_sys, flags, NULL, 0);
2598
2599         fput_light(sock->file, fput_needed);
2600 out:
2601         return err;
2602 }
2603
2604 SYSCALL_DEFINE3(sendmsg, int, fd, struct user_msghdr __user *, msg, unsigned int, flags)
2605 {
2606         return __sys_sendmsg(fd, msg, flags, true);
2607 }
2608
2609 /*
2610  *      Linux sendmmsg interface
2611  */
2612
2613 int __sys_sendmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
2614                    unsigned int flags, bool forbid_cmsg_compat)
2615 {
2616         int fput_needed, err, datagrams;
2617         struct socket *sock;
2618         struct mmsghdr __user *entry;
2619         struct compat_mmsghdr __user *compat_entry;
2620         struct msghdr msg_sys;
2621         struct used_address used_address;
2622         unsigned int oflags = flags;
2623
2624         if (forbid_cmsg_compat && (flags & MSG_CMSG_COMPAT))
2625                 return -EINVAL;
2626
2627         if (vlen > UIO_MAXIOV)
2628                 vlen = UIO_MAXIOV;
2629
2630         datagrams = 0;
2631
2632         sock = sockfd_lookup_light(fd, &err, &fput_needed);
2633         if (!sock)
2634                 return err;
2635
2636         used_address.name_len = UINT_MAX;
2637         entry = mmsg;
2638         compat_entry = (struct compat_mmsghdr __user *)mmsg;
2639         err = 0;
2640         flags |= MSG_BATCH;
2641
2642         while (datagrams < vlen) {
2643                 if (datagrams == vlen - 1)
2644                         flags = oflags;
2645
2646                 if (MSG_CMSG_COMPAT & flags) {
2647                         err = ___sys_sendmsg(sock, (struct user_msghdr __user *)compat_entry,
2648                                              &msg_sys, flags, &used_address, MSG_EOR);
2649                         if (err < 0)
2650                                 break;
2651                         err = __put_user(err, &compat_entry->msg_len);
2652                         ++compat_entry;
2653                 } else {
2654                         err = ___sys_sendmsg(sock,
2655                                              (struct user_msghdr __user *)entry,
2656                                              &msg_sys, flags, &used_address, MSG_EOR);
2657                         if (err < 0)
2658                                 break;
2659                         err = put_user(err, &entry->msg_len);
2660                         ++entry;
2661                 }
2662
2663                 if (err)
2664                         break;
2665                 ++datagrams;
2666                 if (msg_data_left(&msg_sys))
2667                         break;
2668                 cond_resched();
2669         }
2670
2671         fput_light(sock->file, fput_needed);
2672
2673         /* We only return an error if no datagrams were able to be sent */
2674         if (datagrams != 0)
2675                 return datagrams;
2676
2677         return err;
2678 }
2679
2680 SYSCALL_DEFINE4(sendmmsg, int, fd, struct mmsghdr __user *, mmsg,
2681                 unsigned int, vlen, unsigned int, flags)
2682 {
2683         return __sys_sendmmsg(fd, mmsg, vlen, flags, true);
2684 }
2685
2686 int recvmsg_copy_msghdr(struct msghdr *msg,
2687                         struct user_msghdr __user *umsg, unsigned flags,
2688                         struct sockaddr __user **uaddr,
2689                         struct iovec **iov)
2690 {
2691         ssize_t err;
2692
2693         if (MSG_CMSG_COMPAT & flags) {
2694                 struct compat_msghdr __user *msg_compat;
2695
2696                 msg_compat = (struct compat_msghdr __user *) umsg;
2697                 err = get_compat_msghdr(msg, msg_compat, uaddr, iov);
2698         } else {
2699                 err = copy_msghdr_from_user(msg, umsg, uaddr, iov);
2700         }
2701         if (err < 0)
2702                 return err;
2703
2704         return 0;
2705 }
2706
2707 static int ____sys_recvmsg(struct socket *sock, struct msghdr *msg_sys,
2708                            struct user_msghdr __user *msg,
2709                            struct sockaddr __user *uaddr,
2710                            unsigned int flags, int nosec)
2711 {
2712         struct compat_msghdr __user *msg_compat =
2713                                         (struct compat_msghdr __user *) msg;
2714         int __user *uaddr_len = COMPAT_NAMELEN(msg);
2715         struct sockaddr_storage addr;
2716         unsigned long cmsg_ptr;
2717         int len;
2718         ssize_t err;
2719
2720         msg_sys->msg_name = &addr;
2721         cmsg_ptr = (unsigned long)msg_sys->msg_control;
2722         msg_sys->msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT);
2723
2724         /* We assume all kernel code knows the size of sockaddr_storage */
2725         msg_sys->msg_namelen = 0;
2726
2727         if (sock->file->f_flags & O_NONBLOCK)
2728                 flags |= MSG_DONTWAIT;
2729
2730         if (unlikely(nosec))
2731                 err = sock_recvmsg_nosec(sock, msg_sys, flags);
2732         else
2733                 err = sock_recvmsg(sock, msg_sys, flags);
2734
2735         if (err < 0)
2736                 goto out;
2737         len = err;
2738
2739         if (uaddr != NULL) {
2740                 err = move_addr_to_user(&addr,
2741                                         msg_sys->msg_namelen, uaddr,
2742                                         uaddr_len);
2743                 if (err < 0)
2744                         goto out;
2745         }
2746         err = __put_user((msg_sys->msg_flags & ~MSG_CMSG_COMPAT),
2747                          COMPAT_FLAGS(msg));
2748         if (err)
2749                 goto out;
2750         if (MSG_CMSG_COMPAT & flags)
2751                 err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,
2752                                  &msg_compat->msg_controllen);
2753         else
2754                 err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,
2755                                  &msg->msg_controllen);
2756         if (err)
2757                 goto out;
2758         err = len;
2759 out:
2760         return err;
2761 }
2762
2763 static int ___sys_recvmsg(struct socket *sock, struct user_msghdr __user *msg,
2764                          struct msghdr *msg_sys, unsigned int flags, int nosec)
2765 {
2766         struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
2767         /* user mode address pointers */
2768         struct sockaddr __user *uaddr;
2769         ssize_t err;
2770
2771         err = recvmsg_copy_msghdr(msg_sys, msg, flags, &uaddr, &iov);
2772         if (err < 0)
2773                 return err;
2774
2775         err = ____sys_recvmsg(sock, msg_sys, msg, uaddr, flags, nosec);
2776         kfree(iov);
2777         return err;
2778 }
2779
2780 /*
2781  *      BSD recvmsg interface
2782  */
2783
2784 long __sys_recvmsg_sock(struct socket *sock, struct msghdr *msg,
2785                         struct user_msghdr __user *umsg,
2786                         struct sockaddr __user *uaddr, unsigned int flags)
2787 {
2788         return ____sys_recvmsg(sock, msg, umsg, uaddr, flags, 0);
2789 }
2790
2791 long __sys_recvmsg(int fd, struct user_msghdr __user *msg, unsigned int flags,
2792                    bool forbid_cmsg_compat)
2793 {
2794         int fput_needed, err;
2795         struct msghdr msg_sys;
2796         struct socket *sock;
2797
2798         if (forbid_cmsg_compat && (flags & MSG_CMSG_COMPAT))
2799                 return -EINVAL;
2800
2801         sock = sockfd_lookup_light(fd, &err, &fput_needed);
2802         if (!sock)
2803                 goto out;
2804
2805         err = ___sys_recvmsg(sock, msg, &msg_sys, flags, 0);
2806
2807         fput_light(sock->file, fput_needed);
2808 out:
2809         return err;
2810 }
2811
2812 SYSCALL_DEFINE3(recvmsg, int, fd, struct user_msghdr __user *, msg,
2813                 unsigned int, flags)
2814 {
2815         return __sys_recvmsg(fd, msg, flags, true);
2816 }
2817
2818 /*
2819  *     Linux recvmmsg interface
2820  */
2821
2822 static int do_recvmmsg(int fd, struct mmsghdr __user *mmsg,
2823                           unsigned int vlen, unsigned int flags,
2824                           struct timespec64 *timeout)
2825 {
2826         int fput_needed, err, datagrams;
2827         struct socket *sock;
2828         struct mmsghdr __user *entry;
2829         struct compat_mmsghdr __user *compat_entry;
2830         struct msghdr msg_sys;
2831         struct timespec64 end_time;
2832         struct timespec64 timeout64;
2833
2834         if (timeout &&
2835             poll_select_set_timeout(&end_time, timeout->tv_sec,
2836                                     timeout->tv_nsec))
2837                 return -EINVAL;
2838
2839         datagrams = 0;
2840
2841         sock = sockfd_lookup_light(fd, &err, &fput_needed);
2842         if (!sock)
2843                 return err;
2844
2845         if (likely(!(flags & MSG_ERRQUEUE))) {
2846                 err = sock_error(sock->sk);
2847                 if (err) {
2848                         datagrams = err;
2849                         goto out_put;
2850                 }
2851         }
2852
2853         entry = mmsg;
2854         compat_entry = (struct compat_mmsghdr __user *)mmsg;
2855
2856         while (datagrams < vlen) {
2857                 /*
2858                  * No need to ask LSM for more than the first datagram.
2859                  */
2860                 if (MSG_CMSG_COMPAT & flags) {
2861                         err = ___sys_recvmsg(sock, (struct user_msghdr __user *)compat_entry,
2862                                              &msg_sys, flags & ~MSG_WAITFORONE,
2863                                              datagrams);
2864                         if (err < 0)
2865                                 break;
2866                         err = __put_user(err, &compat_entry->msg_len);
2867                         ++compat_entry;
2868                 } else {
2869                         err = ___sys_recvmsg(sock,
2870                                              (struct user_msghdr __user *)entry,
2871                                              &msg_sys, flags & ~MSG_WAITFORONE,
2872                                              datagrams);
2873                         if (err < 0)
2874                                 break;
2875                         err = put_user(err, &entry->msg_len);
2876                         ++entry;
2877                 }
2878
2879                 if (err)
2880                         break;
2881                 ++datagrams;
2882
2883                 /* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */
2884                 if (flags & MSG_WAITFORONE)
2885                         flags |= MSG_DONTWAIT;
2886
2887                 if (timeout) {
2888                         ktime_get_ts64(&timeout64);
2889                         *timeout = timespec64_sub(end_time, timeout64);
2890                         if (timeout->tv_sec < 0) {
2891                                 timeout->tv_sec = timeout->tv_nsec = 0;
2892                                 break;
2893                         }
2894
2895                         /* Timeout, return less than vlen datagrams */
2896                         if (timeout->tv_nsec == 0 && timeout->tv_sec == 0)
2897                                 break;
2898                 }
2899
2900                 /* Out of band data, return right away */
2901                 if (msg_sys.msg_flags & MSG_OOB)
2902                         break;
2903                 cond_resched();
2904         }
2905
2906         if (err == 0)
2907                 goto out_put;
2908
2909         if (datagrams == 0) {
2910                 datagrams = err;
2911                 goto out_put;
2912         }
2913
2914         /*
2915          * We may return less entries than requested (vlen) if the
2916          * sock is non block and there aren't enough datagrams...
2917          */
2918         if (err != -EAGAIN) {
2919                 /*
2920                  * ... or  if recvmsg returns an error after we
2921                  * received some datagrams, where we record the
2922                  * error to return on the next call or if the
2923                  * app asks about it using getsockopt(SO_ERROR).
2924                  */
2925                 WRITE_ONCE(sock->sk->sk_err, -err);
2926         }
2927 out_put:
2928         fput_light(sock->file, fput_needed);
2929
2930         return datagrams;
2931 }
2932
2933 int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg,
2934                    unsigned int vlen, unsigned int flags,
2935                    struct __kernel_timespec __user *timeout,
2936                    struct old_timespec32 __user *timeout32)
2937 {
2938         int datagrams;
2939         struct timespec64 timeout_sys;
2940
2941         if (timeout && get_timespec64(&timeout_sys, timeout))
2942                 return -EFAULT;
2943
2944         if (timeout32 && get_old_timespec32(&timeout_sys, timeout32))
2945                 return -EFAULT;
2946
2947         if (!timeout && !timeout32)
2948                 return do_recvmmsg(fd, mmsg, vlen, flags, NULL);
2949
2950         datagrams = do_recvmmsg(fd, mmsg, vlen, flags, &timeout_sys);
2951
2952         if (datagrams <= 0)
2953                 return datagrams;
2954
2955         if (timeout && put_timespec64(&timeout_sys, timeout))
2956                 datagrams = -EFAULT;
2957
2958         if (timeout32 && put_old_timespec32(&timeout_sys, timeout32))
2959                 datagrams = -EFAULT;
2960
2961         return datagrams;
2962 }
2963
2964 SYSCALL_DEFINE5(recvmmsg, int, fd, struct mmsghdr __user *, mmsg,
2965                 unsigned int, vlen, unsigned int, flags,
2966                 struct __kernel_timespec __user *, timeout)
2967 {
2968         if (flags & MSG_CMSG_COMPAT)
2969                 return -EINVAL;
2970
2971         return __sys_recvmmsg(fd, mmsg, vlen, flags, timeout, NULL);
2972 }
2973
2974 #ifdef CONFIG_COMPAT_32BIT_TIME
2975 SYSCALL_DEFINE5(recvmmsg_time32, int, fd, struct mmsghdr __user *, mmsg,
2976                 unsigned int, vlen, unsigned int, flags,
2977                 struct old_timespec32 __user *, timeout)
2978 {
2979         if (flags & MSG_CMSG_COMPAT)
2980                 return -EINVAL;
2981
2982         return __sys_recvmmsg(fd, mmsg, vlen, flags, NULL, timeout);
2983 }
2984 #endif
2985
2986 #ifdef __ARCH_WANT_SYS_SOCKETCALL
2987 /* Argument list sizes for sys_socketcall */
2988 #define AL(x) ((x) * sizeof(unsigned long))
2989 static const unsigned char nargs[21] = {
2990         AL(0), AL(3), AL(3), AL(3), AL(2), AL(3),
2991         AL(3), AL(3), AL(4), AL(4), AL(4), AL(6),
2992         AL(6), AL(2), AL(5), AL(5), AL(3), AL(3),
2993         AL(4), AL(5), AL(4)
2994 };
2995
2996 #undef AL
2997
2998 /*
2999  *      System call vectors.
3000  *
3001  *      Argument checking cleaned up. Saved 20% in size.
3002  *  This function doesn't need to set the kernel lock because
3003  *  it is set by the callees.
3004  */
3005
3006 SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)
3007 {
3008         unsigned long a[AUDITSC_ARGS];
3009         unsigned long a0, a1;
3010         int err;
3011         unsigned int len;
3012
3013         if (call < 1 || call > SYS_SENDMMSG)
3014                 return -EINVAL;
3015         call = array_index_nospec(call, SYS_SENDMMSG + 1);
3016
3017         len = nargs[call];
3018         if (len > sizeof(a))
3019                 return -EINVAL;
3020
3021         /* copy_from_user should be SMP safe. */
3022         if (copy_from_user(a, args, len))
3023                 return -EFAULT;
3024
3025         err = audit_socketcall(nargs[call] / sizeof(unsigned long), a);
3026         if (err)
3027                 return err;
3028
3029         a0 = a[0];
3030         a1 = a[1];
3031
3032         switch (call) {
3033         case SYS_SOCKET:
3034                 err = __sys_socket(a0, a1, a[2]);
3035                 break;
3036         case SYS_BIND:
3037                 err = __sys_bind(a0, (struct sockaddr __user *)a1, a[2]);
3038                 break;
3039         case SYS_CONNECT:
3040                 err = __sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
3041                 break;
3042         case SYS_LISTEN:
3043                 err = __sys_listen(a0, a1);
3044                 break;
3045         case SYS_ACCEPT:
3046                 err = __sys_accept4(a0, (struct sockaddr __user *)a1,
3047                                     (int __user *)a[2], 0);
3048                 break;
3049         case SYS_GETSOCKNAME:
3050                 err =
3051                     __sys_getsockname(a0, (struct sockaddr __user *)a1,
3052                                       (int __user *)a[2]);
3053                 break;
3054         case SYS_GETPEERNAME:
3055                 err =
3056                     __sys_getpeername(a0, (struct sockaddr __user *)a1,
3057                                       (int __user *)a[2]);
3058                 break;
3059         case SYS_SOCKETPAIR:
3060                 err = __sys_socketpair(a0, a1, a[2], (int __user *)a[3]);
3061                 break;
3062         case SYS_SEND:
3063                 err = __sys_sendto(a0, (void __user *)a1, a[2], a[3],
3064                                    NULL, 0);
3065                 break;
3066         case SYS_SENDTO:
3067                 err = __sys_sendto(a0, (void __user *)a1, a[2], a[3],
3068                                    (struct sockaddr __user *)a[4], a[5]);
3069                 break;
3070         case SYS_RECV:
3071                 err = __sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
3072                                      NULL, NULL);
3073                 break;
3074         case SYS_RECVFROM:
3075                 err = __sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
3076                                      (struct sockaddr __user *)a[4],
3077                                      (int __user *)a[5]);
3078                 break;
3079         case SYS_SHUTDOWN:
3080                 err = __sys_shutdown(a0, a1);
3081                 break;
3082         case SYS_SETSOCKOPT:
3083                 err = __sys_setsockopt(a0, a1, a[2], (char __user *)a[3],
3084                                        a[4]);
3085                 break;
3086         case SYS_GETSOCKOPT:
3087                 err =
3088                     __sys_getsockopt(a0, a1, a[2], (char __user *)a[3],
3089                                      (int __user *)a[4]);
3090                 break;
3091         case SYS_SENDMSG:
3092                 err = __sys_sendmsg(a0, (struct user_msghdr __user *)a1,
3093                                     a[2], true);
3094                 break;
3095         case SYS_SENDMMSG:
3096                 err = __sys_sendmmsg(a0, (struct mmsghdr __user *)a1, a[2],
3097                                      a[3], true);
3098                 break;
3099         case SYS_RECVMSG:
3100                 err = __sys_recvmsg(a0, (struct user_msghdr __user *)a1,
3101                                     a[2], true);
3102                 break;
3103         case SYS_RECVMMSG:
3104                 if (IS_ENABLED(CONFIG_64BIT))
3105                         err = __sys_recvmmsg(a0, (struct mmsghdr __user *)a1,
3106                                              a[2], a[3],
3107                                              (struct __kernel_timespec __user *)a[4],
3108                                              NULL);
3109                 else
3110                         err = __sys_recvmmsg(a0, (struct mmsghdr __user *)a1,
3111                                              a[2], a[3], NULL,
3112                                              (struct old_timespec32 __user *)a[4]);
3113                 break;
3114         case SYS_ACCEPT4:
3115                 err = __sys_accept4(a0, (struct sockaddr __user *)a1,
3116                                     (int __user *)a[2], a[3]);
3117                 break;
3118         default:
3119                 err = -EINVAL;
3120                 break;
3121         }
3122         return err;
3123 }
3124
3125 #endif                          /* __ARCH_WANT_SYS_SOCKETCALL */
3126
3127 /**
3128  *      sock_register - add a socket protocol handler
3129  *      @ops: description of protocol
3130  *
3131  *      This function is called by a protocol handler that wants to
3132  *      advertise its address family, and have it linked into the
3133  *      socket interface. The value ops->family corresponds to the
3134  *      socket system call protocol family.
3135  */
3136 int sock_register(const struct net_proto_family *ops)
3137 {
3138         int err;
3139
3140         if (ops->family >= NPROTO) {
3141                 pr_crit("protocol %d >= NPROTO(%d)\n", ops->family, NPROTO);
3142                 return -ENOBUFS;
3143         }
3144
3145         spin_lock(&net_family_lock);
3146         if (rcu_dereference_protected(net_families[ops->family],
3147                                       lockdep_is_held(&net_family_lock)))
3148                 err = -EEXIST;
3149         else {
3150                 rcu_assign_pointer(net_families[ops->family], ops);
3151                 err = 0;
3152         }
3153         spin_unlock(&net_family_lock);
3154
3155         pr_info("NET: Registered %s protocol family\n", pf_family_names[ops->family]);
3156         return err;
3157 }
3158 EXPORT_SYMBOL(sock_register);
3159
3160 /**
3161  *      sock_unregister - remove a protocol handler
3162  *      @family: protocol family to remove
3163  *
3164  *      This function is called by a protocol handler that wants to
3165  *      remove its address family, and have it unlinked from the
3166  *      new socket creation.
3167  *
3168  *      If protocol handler is a module, then it can use module reference
3169  *      counts to protect against new references. If protocol handler is not
3170  *      a module then it needs to provide its own protection in
3171  *      the ops->create routine.
3172  */
3173 void sock_unregister(int family)
3174 {
3175         BUG_ON(family < 0 || family >= NPROTO);
3176
3177         spin_lock(&net_family_lock);
3178         RCU_INIT_POINTER(net_families[family], NULL);
3179         spin_unlock(&net_family_lock);
3180
3181         synchronize_rcu();
3182
3183         pr_info("NET: Unregistered %s protocol family\n", pf_family_names[family]);
3184 }
3185 EXPORT_SYMBOL(sock_unregister);
3186
3187 bool sock_is_registered(int family)
3188 {
3189         return family < NPROTO && rcu_access_pointer(net_families[family]);
3190 }
3191
3192 static int __init sock_init(void)
3193 {
3194         int err;
3195         /*
3196          *      Initialize the network sysctl infrastructure.
3197          */
3198         err = net_sysctl_init();
3199         if (err)
3200                 goto out;
3201
3202         /*
3203          *      Initialize skbuff SLAB cache
3204          */
3205         skb_init();
3206
3207         /*
3208          *      Initialize the protocols module.
3209          */
3210
3211         init_inodecache();
3212
3213         err = register_filesystem(&sock_fs_type);
3214         if (err)
3215                 goto out;
3216         sock_mnt = kern_mount(&sock_fs_type);
3217         if (IS_ERR(sock_mnt)) {
3218                 err = PTR_ERR(sock_mnt);
3219                 goto out_mount;
3220         }
3221
3222         /* The real protocol initialization is performed in later initcalls.
3223          */
3224
3225 #ifdef CONFIG_NETFILTER
3226         err = netfilter_init();
3227         if (err)
3228                 goto out;
3229 #endif
3230
3231         ptp_classifier_init();
3232
3233 out:
3234         return err;
3235
3236 out_mount:
3237         unregister_filesystem(&sock_fs_type);
3238         goto out;
3239 }
3240
3241 core_initcall(sock_init);       /* early initcall */
3242
3243 #ifdef CONFIG_PROC_FS
3244 void socket_seq_show(struct seq_file *seq)
3245 {
3246         seq_printf(seq, "sockets: used %d\n",
3247                    sock_inuse_get(seq->private));
3248 }
3249 #endif                          /* CONFIG_PROC_FS */
3250
3251 /* Handle the fact that while struct ifreq has the same *layout* on
3252  * 32/64 for everything but ifreq::ifru_ifmap and ifreq::ifru_data,
3253  * which are handled elsewhere, it still has different *size* due to
3254  * ifreq::ifru_ifmap (which is 16 bytes on 32 bit, 24 bytes on 64-bit,
3255  * resulting in struct ifreq being 32 and 40 bytes respectively).
3256  * As a result, if the struct happens to be at the end of a page and
3257  * the next page isn't readable/writable, we get a fault. To prevent
3258  * that, copy back and forth to the full size.
3259  */
3260 int get_user_ifreq(struct ifreq *ifr, void __user **ifrdata, void __user *arg)
3261 {
3262         if (in_compat_syscall()) {
3263                 struct compat_ifreq *ifr32 = (struct compat_ifreq *)ifr;
3264
3265                 memset(ifr, 0, sizeof(*ifr));
3266                 if (copy_from_user(ifr32, arg, sizeof(*ifr32)))
3267                         return -EFAULT;
3268
3269                 if (ifrdata)
3270                         *ifrdata = compat_ptr(ifr32->ifr_data);
3271
3272                 return 0;
3273         }
3274
3275         if (copy_from_user(ifr, arg, sizeof(*ifr)))
3276                 return -EFAULT;
3277
3278         if (ifrdata)
3279                 *ifrdata = ifr->ifr_data;
3280
3281         return 0;
3282 }
3283 EXPORT_SYMBOL(get_user_ifreq);
3284
3285 int put_user_ifreq(struct ifreq *ifr, void __user *arg)
3286 {
3287         size_t size = sizeof(*ifr);
3288
3289         if (in_compat_syscall())
3290                 size = sizeof(struct compat_ifreq);
3291
3292         if (copy_to_user(arg, ifr, size))
3293                 return -EFAULT;
3294
3295         return 0;
3296 }
3297 EXPORT_SYMBOL(put_user_ifreq);
3298
3299 #ifdef CONFIG_COMPAT
3300 static int compat_siocwandev(struct net *net, struct compat_ifreq __user *uifr32)
3301 {
3302         compat_uptr_t uptr32;
3303         struct ifreq ifr;
3304         void __user *saved;
3305         int err;
3306
3307         if (get_user_ifreq(&ifr, NULL, uifr32))
3308                 return -EFAULT;
3309
3310         if (get_user(uptr32, &uifr32->ifr_settings.ifs_ifsu))
3311                 return -EFAULT;
3312
3313         saved = ifr.ifr_settings.ifs_ifsu.raw_hdlc;
3314         ifr.ifr_settings.ifs_ifsu.raw_hdlc = compat_ptr(uptr32);
3315
3316         err = dev_ioctl(net, SIOCWANDEV, &ifr, NULL, NULL);
3317         if (!err) {
3318                 ifr.ifr_settings.ifs_ifsu.raw_hdlc = saved;
3319                 if (put_user_ifreq(&ifr, uifr32))
3320                         err = -EFAULT;
3321         }
3322         return err;
3323 }
3324
3325 /* Handle ioctls that use ifreq::ifr_data and just need struct ifreq converted */
3326 static int compat_ifr_data_ioctl(struct net *net, unsigned int cmd,
3327                                  struct compat_ifreq __user *u_ifreq32)
3328 {
3329         struct ifreq ifreq;
3330         void __user *data;
3331
3332         if (!is_socket_ioctl_cmd(cmd))
3333                 return -ENOTTY;
3334         if (get_user_ifreq(&ifreq, &data, u_ifreq32))
3335                 return -EFAULT;
3336         ifreq.ifr_data = data;
3337
3338         return dev_ioctl(net, cmd, &ifreq, data, NULL);
3339 }
3340
3341 static int compat_sock_ioctl_trans(struct file *file, struct socket *sock,
3342                          unsigned int cmd, unsigned long arg)
3343 {
3344         void __user *argp = compat_ptr(arg);
3345         struct sock *sk = sock->sk;
3346         struct net *net = sock_net(sk);
3347
3348         if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15))
3349                 return sock_ioctl(file, cmd, (unsigned long)argp);
3350
3351         switch (cmd) {
3352         case SIOCWANDEV:
3353                 return compat_siocwandev(net, argp);
3354         case SIOCGSTAMP_OLD:
3355         case SIOCGSTAMPNS_OLD:
3356                 if (!sock->ops->gettstamp)
3357                         return -ENOIOCTLCMD;
3358                 return sock->ops->gettstamp(sock, argp, cmd == SIOCGSTAMP_OLD,
3359                                             !COMPAT_USE_64BIT_TIME);
3360
3361         case SIOCETHTOOL:
3362         case SIOCBONDSLAVEINFOQUERY:
3363         case SIOCBONDINFOQUERY:
3364         case SIOCSHWTSTAMP:
3365         case SIOCGHWTSTAMP:
3366                 return compat_ifr_data_ioctl(net, cmd, argp);
3367
3368         case FIOSETOWN:
3369         case SIOCSPGRP:
3370         case FIOGETOWN:
3371         case SIOCGPGRP:
3372         case SIOCBRADDBR:
3373         case SIOCBRDELBR:
3374         case SIOCGIFVLAN:
3375         case SIOCSIFVLAN:
3376         case SIOCGSKNS:
3377         case SIOCGSTAMP_NEW:
3378         case SIOCGSTAMPNS_NEW:
3379         case SIOCGIFCONF:
3380         case SIOCSIFBR:
3381         case SIOCGIFBR:
3382                 return sock_ioctl(file, cmd, arg);
3383
3384         case SIOCGIFFLAGS:
3385         case SIOCSIFFLAGS:
3386         case SIOCGIFMAP:
3387         case SIOCSIFMAP:
3388         case SIOCGIFMETRIC:
3389         case SIOCSIFMETRIC:
3390         case SIOCGIFMTU:
3391         case SIOCSIFMTU:
3392         case SIOCGIFMEM:
3393         case SIOCSIFMEM:
3394         case SIOCGIFHWADDR:
3395         case SIOCSIFHWADDR:
3396         case SIOCADDMULTI:
3397         case SIOCDELMULTI:
3398         case SIOCGIFINDEX:
3399         case SIOCGIFADDR:
3400         case SIOCSIFADDR:
3401         case SIOCSIFHWBROADCAST:
3402         case SIOCDIFADDR:
3403         case SIOCGIFBRDADDR:
3404         case SIOCSIFBRDADDR:
3405         case SIOCGIFDSTADDR:
3406         case SIOCSIFDSTADDR:
3407         case SIOCGIFNETMASK:
3408         case SIOCSIFNETMASK:
3409         case SIOCSIFPFLAGS:
3410         case SIOCGIFPFLAGS:
3411         case SIOCGIFTXQLEN:
3412         case SIOCSIFTXQLEN:
3413         case SIOCBRADDIF:
3414         case SIOCBRDELIF:
3415         case SIOCGIFNAME:
3416         case SIOCSIFNAME:
3417         case SIOCGMIIPHY:
3418         case SIOCGMIIREG:
3419         case SIOCSMIIREG:
3420         case SIOCBONDENSLAVE:
3421         case SIOCBONDRELEASE:
3422         case SIOCBONDSETHWADDR:
3423         case SIOCBONDCHANGEACTIVE:
3424         case SIOCSARP:
3425         case SIOCGARP:
3426         case SIOCDARP:
3427         case SIOCOUTQ:
3428         case SIOCOUTQNSD:
3429         case SIOCATMARK:
3430                 return sock_do_ioctl(net, sock, cmd, arg);
3431         }
3432
3433         return -ENOIOCTLCMD;
3434 }
3435
3436 static long compat_sock_ioctl(struct file *file, unsigned int cmd,
3437                               unsigned long arg)
3438 {
3439         struct socket *sock = file->private_data;
3440         int ret = -ENOIOCTLCMD;
3441         struct sock *sk;
3442         struct net *net;
3443
3444         sk = sock->sk;
3445         net = sock_net(sk);
3446
3447         if (sock->ops->compat_ioctl)
3448                 ret = sock->ops->compat_ioctl(sock, cmd, arg);
3449
3450         if (ret == -ENOIOCTLCMD &&
3451             (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST))
3452                 ret = compat_wext_handle_ioctl(net, cmd, arg);
3453
3454         if (ret == -ENOIOCTLCMD)
3455                 ret = compat_sock_ioctl_trans(file, sock, cmd, arg);
3456
3457         return ret;
3458 }
3459 #endif
3460
3461 /**
3462  *      kernel_bind - bind an address to a socket (kernel space)
3463  *      @sock: socket
3464  *      @addr: address
3465  *      @addrlen: length of address
3466  *
3467  *      Returns 0 or an error.
3468  */
3469
3470 int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen)
3471 {
3472         struct sockaddr_storage address;
3473
3474         memcpy(&address, addr, addrlen);
3475
3476         return sock->ops->bind(sock, (struct sockaddr *)&address, addrlen);
3477 }
3478 EXPORT_SYMBOL(kernel_bind);
3479
3480 /**
3481  *      kernel_listen - move socket to listening state (kernel space)
3482  *      @sock: socket
3483  *      @backlog: pending connections queue size
3484  *
3485  *      Returns 0 or an error.
3486  */
3487
3488 int kernel_listen(struct socket *sock, int backlog)
3489 {
3490         return sock->ops->listen(sock, backlog);
3491 }
3492 EXPORT_SYMBOL(kernel_listen);
3493
3494 /**
3495  *      kernel_accept - accept a connection (kernel space)
3496  *      @sock: listening socket
3497  *      @newsock: new connected socket
3498  *      @flags: flags
3499  *
3500  *      @flags must be SOCK_CLOEXEC, SOCK_NONBLOCK or 0.
3501  *      If it fails, @newsock is guaranteed to be %NULL.
3502  *      Returns 0 or an error.
3503  */
3504
3505 int kernel_accept(struct socket *sock, struct socket **newsock, int flags)
3506 {
3507         struct sock *sk = sock->sk;
3508         int err;
3509
3510         err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol,
3511                                newsock);
3512         if (err < 0)
3513                 goto done;
3514
3515         err = sock->ops->accept(sock, *newsock, flags, true);
3516         if (err < 0) {
3517                 sock_release(*newsock);
3518                 *newsock = NULL;
3519                 goto done;
3520         }
3521
3522         (*newsock)->ops = sock->ops;
3523         __module_get((*newsock)->ops->owner);
3524
3525 done:
3526         return err;
3527 }
3528 EXPORT_SYMBOL(kernel_accept);
3529
3530 /**
3531  *      kernel_connect - connect a socket (kernel space)
3532  *      @sock: socket
3533  *      @addr: address
3534  *      @addrlen: address length
3535  *      @flags: flags (O_NONBLOCK, ...)
3536  *
3537  *      For datagram sockets, @addr is the address to which datagrams are sent
3538  *      by default, and the only address from which datagrams are received.
3539  *      For stream sockets, attempts to connect to @addr.
3540  *      Returns 0 or an error code.
3541  */
3542
3543 int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen,
3544                    int flags)
3545 {
3546         struct sockaddr_storage address;
3547
3548         memcpy(&address, addr, addrlen);
3549
3550         return sock->ops->connect(sock, (struct sockaddr *)&address, addrlen, flags);
3551 }
3552 EXPORT_SYMBOL(kernel_connect);
3553
3554 /**
3555  *      kernel_getsockname - get the address which the socket is bound (kernel space)
3556  *      @sock: socket
3557  *      @addr: address holder
3558  *
3559  *      Fills the @addr pointer with the address which the socket is bound.
3560  *      Returns the length of the address in bytes or an error code.
3561  */
3562
3563 int kernel_getsockname(struct socket *sock, struct sockaddr *addr)
3564 {
3565         return sock->ops->getname(sock, addr, 0);
3566 }
3567 EXPORT_SYMBOL(kernel_getsockname);
3568
3569 /**
3570  *      kernel_getpeername - get the address which the socket is connected (kernel space)
3571  *      @sock: socket
3572  *      @addr: address holder
3573  *
3574  *      Fills the @addr pointer with the address which the socket is connected.
3575  *      Returns the length of the address in bytes or an error code.
3576  */
3577
3578 int kernel_getpeername(struct socket *sock, struct sockaddr *addr)
3579 {
3580         return sock->ops->getname(sock, addr, 1);
3581 }
3582 EXPORT_SYMBOL(kernel_getpeername);
3583
3584 /**
3585  *      kernel_sendpage - send a &page through a socket (kernel space)
3586  *      @sock: socket
3587  *      @page: page
3588  *      @offset: page offset
3589  *      @size: total size in bytes
3590  *      @flags: flags (MSG_DONTWAIT, ...)
3591  *
3592  *      Returns the total amount sent in bytes or an error.
3593  */
3594
3595 int kernel_sendpage(struct socket *sock, struct page *page, int offset,
3596                     size_t size, int flags)
3597 {
3598         if (sock->ops->sendpage) {
3599                 /* Warn in case the improper page to zero-copy send */
3600                 WARN_ONCE(!sendpage_ok(page), "improper page for zero-copy send");
3601                 return sock->ops->sendpage(sock, page, offset, size, flags);
3602         }
3603         return sock_no_sendpage(sock, page, offset, size, flags);
3604 }
3605 EXPORT_SYMBOL(kernel_sendpage);
3606
3607 /**
3608  *      kernel_sendpage_locked - send a &page through the locked sock (kernel space)
3609  *      @sk: sock
3610  *      @page: page
3611  *      @offset: page offset
3612  *      @size: total size in bytes
3613  *      @flags: flags (MSG_DONTWAIT, ...)
3614  *
3615  *      Returns the total amount sent in bytes or an error.
3616  *      Caller must hold @sk.
3617  */
3618
3619 int kernel_sendpage_locked(struct sock *sk, struct page *page, int offset,
3620                            size_t size, int flags)
3621 {
3622         struct socket *sock = sk->sk_socket;
3623
3624         if (sock->ops->sendpage_locked)
3625                 return sock->ops->sendpage_locked(sk, page, offset, size,
3626                                                   flags);
3627
3628         return sock_no_sendpage_locked(sk, page, offset, size, flags);
3629 }
3630 EXPORT_SYMBOL(kernel_sendpage_locked);
3631
3632 /**
3633  *      kernel_sock_shutdown - shut down part of a full-duplex connection (kernel space)
3634  *      @sock: socket
3635  *      @how: connection part
3636  *
3637  *      Returns 0 or an error.
3638  */
3639
3640 int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how)
3641 {
3642         return sock->ops->shutdown(sock, how);
3643 }
3644 EXPORT_SYMBOL(kernel_sock_shutdown);
3645
3646 /**
3647  *      kernel_sock_ip_overhead - returns the IP overhead imposed by a socket
3648  *      @sk: socket
3649  *
3650  *      This routine returns the IP overhead imposed by a socket i.e.
3651  *      the length of the underlying IP header, depending on whether
3652  *      this is an IPv4 or IPv6 socket and the length from IP options turned
3653  *      on at the socket. Assumes that the caller has a lock on the socket.
3654  */
3655
3656 u32 kernel_sock_ip_overhead(struct sock *sk)
3657 {
3658         struct inet_sock *inet;
3659         struct ip_options_rcu *opt;
3660         u32 overhead = 0;
3661 #if IS_ENABLED(CONFIG_IPV6)
3662         struct ipv6_pinfo *np;
3663         struct ipv6_txoptions *optv6 = NULL;
3664 #endif /* IS_ENABLED(CONFIG_IPV6) */
3665
3666         if (!sk)
3667                 return overhead;
3668
3669         switch (sk->sk_family) {
3670         case AF_INET:
3671                 inet = inet_sk(sk);
3672                 overhead += sizeof(struct iphdr);
3673                 opt = rcu_dereference_protected(inet->inet_opt,
3674                                                 sock_owned_by_user(sk));
3675                 if (opt)
3676                         overhead += opt->opt.optlen;
3677                 return overhead;
3678 #if IS_ENABLED(CONFIG_IPV6)
3679         case AF_INET6:
3680                 np = inet6_sk(sk);
3681                 overhead += sizeof(struct ipv6hdr);
3682                 if (np)
3683                         optv6 = rcu_dereference_protected(np->opt,
3684                                                           sock_owned_by_user(sk));
3685                 if (optv6)
3686                         overhead += (optv6->opt_flen + optv6->opt_nflen);
3687                 return overhead;
3688 #endif /* IS_ENABLED(CONFIG_IPV6) */
3689         default: /* Returns 0 overhead if the socket is not ipv4 or ipv6 */
3690                 return overhead;
3691         }
3692 }
3693 EXPORT_SYMBOL(kernel_sock_ip_overhead);