GV

GeezerVison

The World Wide Web, restored to 800 pixels of glory.

Home|About|Gaming cabinet|Archives|How it works|Starter sites

On this site

No menu could be recovered. Follow the blue links in the page.

This view

  • Original page
  • New address

GeezerVison is showing codebrowser.dev (truncated) — socket.c source code [linux/net/socket.c] - Codebrowser

Codebrowser logo
About
Contact
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, <[email protected]>
8 * Ross Biro
9 * Fred N. van Kempen, <[email protected]>
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/splice.h>
61#include <linux/net.h>
62#include <linux/interrupt.h>
63#include <linux/thread_info.h>
64#include <linux/rcupdate.h>
65#include <linux/netdevice.h>
66#include <linux/proc_fs.h>
67#include <linux/seq_file.h>
68#include <linux/mutex.h>
69#include <linux/if_bridge.h>
70#include <linux/if_vlan.h>
71#include <linux/ptp_classify.h>
72#include <linux/init.h>
73#include <linux/poll.h>
74#include <linux/cache.h>
75#include <linux/module.h>
76#include <linux/highmem.h>
77#include <linux/mount.h>
78#include <linux/pseudo_fs.h>
79#include <linux/security.h>
80#include <linux/syscalls.h>
81#include <linux/compat.h>
82#include <linux/kmod.h>
83#include <linux/audit.h>
84#include <linux/wireless.h>
85#include <linux/nsproxy.h>
86#include <linux/magic.h>
87#include <linux/slab.h>
88#include <linux/xattr.h>
89#include <linux/nospec.h>
90#include <linux/indirect_call_wrapper.h>
91#include <linux/io_uring/net.h>
92
93#include <linux/uaccess.h>
94#include <asm/unistd.h>
95
96#include <net/compat.h>
97#include <net/wext.h>
98#include <net/cls_cgroup.h>
99
100#include <net/sock.h>
101#include <linux/netfilter.h>
102
103#include <linux/if_tun.h>
104#include <linux/ipv6_route.h>
105#include <linux/route.h>
106#include <linux/termios.h>
107#include <linux/sockios.h>
108#include <net/busy_poll.h>
109#include <linux/errqueue.h>
110#include <linux/ptp_clock_kernel.h>
111#include <trace/events/sock.h>
112
113#include "core/dev.h"
114
115#ifdef CONFIG_NET_RX_BUSY_POLL
116unsigned int sysctl_net_busy_read __read_mostly;
117unsigned int sysctl_net_busy_poll __read_mostly;
118#endif
119
120static ssize_t sock_read_iter(struct kiocb *iocb, struct iov_iter *to);
121static ssize_t sock_write_iter(struct kiocb *iocb, struct iov_iter *from);
122static int sock_mmap(struct file *file, struct vm_area_struct *vma);
123
124static int sock_close(struct inode *inode, struct file *file);
125static __poll_t sock_poll(struct file *file,
126 struct poll_table_struct *wait);
127static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
128#ifdef CONFIG_COMPAT
129static long compat_sock_ioctl(struct file *file,
130 unsigned int cmd, unsigned long arg);
131#endif
132static int sock_fasync(int fd, struct file *filp, int on);
133static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
134 struct pipe_inode_info *pipe, size_t len,
135 unsigned int flags);
136static void sock_splice_eof(struct file *file);
137
138#ifdef CONFIG_PROC_FS
139static void sock_show_fdinfo(struct seq_file *m, struct file *f)
140{
141 struct socket *sock = f->private_data;
142 const struct proto_ops *ops = READ_ONCE(sock->ops);
143
144 if (ops->show_fdinfo)
145 ops->show_fdinfo(m, sock);
146}
147#else
148#define sock_show_fdinfo NULL
149#endif
150
151/*
152 * Socket files have a set of 'special' operations as well as the generic file ones. These don't appear
153 * in the operation structures but are done directly via the socketcall() multiplexor.
154 */
155
156static const struct file_operations socket_file_ops = {
157 .owner = THIS_MODULE,
158 .read_iter = sock_read_iter,
159 .write_iter = sock_write_iter,
160 .poll = sock_poll,
161 .unlocked_ioctl = sock_ioctl,
162#ifdef CONFIG_COMPAT
163 .compat_ioctl = compat_sock_ioctl,
164#endif
165 .uring_cmd = io_uring_cmd_sock,
166 .mmap = sock_mmap,
167 .release = sock_close,
168 .fasync = sock_fasync,
169 .splice_write = splice_to_socket,
170 .splice_read = sock_splice_read,
171 .splice_eof = sock_splice_eof,
172 .show_fdinfo = sock_show_fdinfo,
173};
174
175static const char * const pf_family_names[] = {
176 [PF_UNSPEC] = "PF_UNSPEC",
177 [PF_UNIX] = "PF_UNIX/PF_LOCAL",
178 [PF_INET] = "PF_INET",
179 [PF_AX25] = "PF_AX25",
180 [PF_IPX] = "PF_IPX",
181 [PF_APPLETALK] = "PF_APPLETALK",
182 [PF_NETROM] = "PF_NETROM",
183 [PF_BRIDGE] = "PF_BRIDGE",
184 [PF_ATMPVC] = "PF_ATMPVC",
185 [PF_X25] = "PF_X25",
186 [PF_INET6] = "PF_INET6",
187 [PF_ROSE] = "PF_ROSE",
188 [PF_DECnet] = "PF_DECnet",
189 [PF_NETBEUI] = "PF_NETBEUI",
190 [PF_SECURITY] = "PF_SECURITY",
191 [PF_KEY] = "PF_KEY",
192 [PF_NETLINK] = "PF_NETLINK/PF_ROUTE",
193 [PF_PACKET] = "PF_PACKET",
194 [PF_ASH] = "PF_ASH",
195 [PF_ECONET] = "PF_ECONET",
196 [PF_ATMSVC] = "PF_ATMSVC",
197 [PF_RDS] = "PF_RDS",
198 [PF_SNA] = "PF_SNA",
199 [PF_IRDA] = "PF_IRDA",
200 [PF_PPPOX] = "PF_PPPOX",
201 [PF_WANPIPE] = "PF_WANPIPE",
202 [PF_LLC] = "PF_LLC",
203 [PF_IB] = "PF_IB",
204 [PF_MPLS] = "PF_MPLS",
205 [PF_CAN] = "PF_CAN",
206 [PF_TIPC] = "PF_TIPC",
207 [PF_BLUETOOTH] = "PF_BLUETOOTH",
208 [PF_IUCV] = "PF_IUCV",
209 [PF_RXRPC] = "PF_RXRPC",
210 [PF_ISDN] = "PF_ISDN",
211 [PF_PHONET] = "PF_PHONET",
212 [PF_IEEE802154] = "PF_IEEE802154",
213 [PF_CAIF] = "PF_CAIF",
214 [PF_ALG] = "PF_ALG",
215 [PF_NFC] = "PF_NFC",
216 [PF_VSOCK] = "PF_VSOCK",
217 [PF_KCM] = "PF_KCM",
218 [PF_QIPCRTR] = "PF_QIPCRTR",
219 [PF_SMC] = "PF_SMC",
220 [PF_XDP] = "PF_XDP",
221 [PF_MCTP] = "PF_MCTP",
222};
223
224/*
225 * The protocol list. Each protocol is registered in here.
226 */
227
228static DEFINE_SPINLOCK(net_family_lock);
229static const struct net_proto_family __rcu *net_families[NPROTO] __read_mostly;
230
231/*
232 * Support routines.
233 * Move socket addresses back and forth across the kernel/user
234 * divide and look after the messy bits.
235 */
236
237/**
238 * move_addr_to_kernel - copy a socket address into kernel space
239 * @uaddr: Address in user space
240 * @kaddr: Address in kernel space
241 * @ulen: Length in user space
242 *
243 * The address is copied into kernel space. If the provided address is
244 * too long an error code of -EINVAL is returned. If the copy gives
245 * invalid addresses -EFAULT is returned. On a success 0 is returned.
246 */
247
248int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr_storage *kaddr)
249{
250 if (ulen < 0 || ulen > sizeof(struct sockaddr_storage))
251 return -EINVAL;
252 if (ulen == 0)
253 return 0;
254 if (copy_from_user(to: kaddr, from: uaddr, n: ulen))
255 return -EFAULT;
256 return audit_sockaddr(len: ulen, addr: kaddr);
257}
258
259/**
260 * move_addr_to_user - copy an address to user space
261 * @kaddr: kernel space address
262 * @klen: length of address in kernel
263 * @uaddr: user space address
264 * @ulen: pointer to user length field
265 *
266 * The value pointed to by ulen on entry is the buffer length available.
267 * This is overwritten with the buffer space used. -EINVAL is returned
268 * if an overlong buffer is specified or a negative buffer size. -EFAULT
269 * is returned if either the buffer or the length field are not
270 * accessible.
271 * After copying the data up to the limit the user specifies, the true
272 * length of the data is written over the length limit the user
273 * specified. Zero is returned for a success.
274 */
275
276static int move_addr_to_user(struct sockaddr_storage *kaddr, int klen,
277 void __user *uaddr, int __user *ulen)
278{
279 int len;
280
281 BUG_ON(klen > sizeof(struct sockaddr_storage));
282
283 if (can_do_masked_user_access())
284 ulen = masked_user_access_begin(ulen);
285 else if (!user_access_begin(ulen, 4))
286 return -EFAULT;
287
288 unsafe_get_user(len, ulen, efault_end);
289
290 if (len > klen)
291 len = klen;
292 /*
293 * "fromlen shall refer to the value before truncation.."
294 * 1003.1g
295 */
296 if (len >= 0)
297 unsafe_put_user(klen, ulen, efault_end);
298
299 user_access_end();
300
301 if (len) {
302 if (len < 0)
303 return -EINVAL;
304 if (audit_sockaddr(len: klen, addr: kaddr))
305 return -ENOMEM;
306 if (copy_to_user(to: uaddr, from: kaddr, n: len))
307 return -EFAULT;
308 }
309 return 0;
310
311efault_end:
312 user_access_end();
313 return -EFAULT;
314}
315
316static struct kmem_cache *sock_inode_cachep __ro_after_init;
317
318static struct inode *sock_alloc_inode(struct super_block *sb)
319{
320 struct socket_alloc *ei;
321
322 ei = alloc_inode_sb(sb, sock_inode_cachep, GFP_KERNEL);
323 if (!ei)
324 return NULL;
325 init_waitqueue_head(&ei->socket.wq.wait);
326 ei->socket.wq.fasync_list = NULL;
327 ei->socket.wq.flags = 0;
328
329 ei->socket.state = SS_UNCONNECTED;
330 ei->socket.flags = 0;
331 ei->socket.ops = NULL;
332 ei->socket.sk = NULL;
333 ei->socket.file = NULL;
334
335 return &ei->vfs_inode;
336}
337
338static void sock_free_inode(struct inode *inode)
339{
340 struct socket_alloc *ei;
341
342 ei = container_of(inode, struct socket_alloc, vfs_inode);
343 kmem_cache_free(s: sock_inode_cachep, objp: ei);
344}
345
346static void init_once(void *foo)
347{
348 struct socket_alloc *ei = (struct socket_alloc *)foo;
349
350 inode_init_once(&ei->vfs_inode);
351}
352
353static void init_inodecache(void)
354{
355 sock_inode_cachep = kmem_cache_create("sock_inode_cache",
356 sizeof(struct socket_alloc),
357 0,
358 (SLAB_HWCACHE_ALIGN |
359 SLAB_RECLAIM_ACCOUNT |
360 SLAB_ACCOUNT),
361 init_once);
362 BUG_ON(sock_inode_cachep == NULL);
363}
364
365static const struct super_operations sockfs_ops = {
366 .alloc_inode = sock_alloc_inode,
367 .free_inode = sock_free_inode,
368 .statfs = simple_statfs,
369};
370
371/*
372 * sockfs_dname() is called from d_path().
373 */
374static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen)
375{
376 return dynamic_dname(buffer, buflen, "socket:[%lu]",
377 d_inode(dentry)->i_ino);
378}
379
380static const struct dentry_operations sockfs_dentry_operations = {
381 .d_dname = sockfs_dname,
382};
383
384static int sockfs_xattr_get(const struct xattr_handler *handler,
385 struct dentry *dentry, struct inode *inode,
386 const char *suffix, void *value, size_t size)
387{
388 if (value) {
389 if (dentry->d_name.len + 1 > size)
390 return -ERANGE;
391 memcpy(value, dentry->d_name.name, dentry->d_name.len + 1);
392 }
393 return dentry->d_name.len + 1;
394}
395
396#define XATTR_SOCKPROTONAME_SUFFIX "sockprotoname"
397#define XATTR_NAME_SOCKPROTONAME (XATTR_SYSTEM_PREFIX XATTR_SOCKPROTONAME_SUFFIX)
398#define XATTR_NAME_SOCKPROTONAME_LEN (sizeof(XATTR_NAME_SOCKPROTONAME)-1)
399
400static const struct xattr_handler sockfs_xattr_handler = {
401 .name = XATTR_NAME_SOCKPROTONAME,
402 .get = sockfs_xattr_get,
403};
404
405static int sockfs_security_xattr_set(const struct xattr_handler *handler,
406 struct mnt_idmap *idmap,
407 struct dentry *dentry, struct inode *inode,
408 const char *suffix, const void *value,
409 size_t size, int flags)
410{
411 /* Handled by LSM. */
412 return -EAGAIN;
413}
414
415static const struct xattr_handler sockfs_security_xattr_handler = {
416 .prefix = XATTR_SECURITY_PREFIX,
417 .set = sockfs_security_xattr_set,
418};
419
420static const struct xattr_handler * const sockfs_xattr_handlers[] = {
421 &sockfs_xattr_handler,
422 &sockfs_security_xattr_handler,
423 NULL
424};
425
426static int sockfs_init_fs_context(struct fs_context *fc)
427{
428 struct pseudo_fs_context *ctx = init_pseudo(fc, SOCKFS_MAGIC);
429 if (!ctx)
430 return -ENOMEM;
431 ctx->ops = &sockfs_ops;
432 ctx->dops = &sockfs_dentry_operations;
433 ctx->xattr = sockfs_xattr_handlers;
434 return 0;
435}
436
437static struct vfsmount *sock_mnt __read_mostly;
438
439static struct file_system_type sock_fs_type = {
440 .name = "sockfs",
441 .init_fs_context = sockfs_init_fs_context,
442 .kill_sb = kill_anon_super,
443};
444
445/*
446 * Obtains the first available file descriptor and sets it up for use.
447 *
448 * These functions create file structures and maps them to fd space
449 * of the current process. On success it returns file descriptor
450 * and file struct implicitly stored in sock->file.
451 * Note that another thread may close file descriptor before we return
452 * from this function. We use the fact that now we do not refer
453 * to socket after mapping. If one day we will need it, this
454 * function will increment ref. count on file by 1.
455 *
456 * In any case returned fd MAY BE not valid!
457 * This race condition is unavoidable
458 * with shared fd spaces, we cannot solve it inside kernel,
459 * but we take care of internal coherence yet.
460 */
461
462/**
463 * sock_alloc_file - Bind a &socket to a &file
464 * @sock: socket
465 * @flags: file status flags
466 * @dname: protocol name
467 *
468 * Returns the &file bound with @sock, implicitly storing it
469 * in sock->file. If dname is %NULL, sets to "".
470 *
471 * On failure @sock is released, and an ERR pointer is returned.
472 *
473 * This function uses GFP_KERNEL internally.
474 */
475
476struct file *sock_alloc_file(struct socket *sock, int flags, const char *dname)
477{
478 struct file *file;
479
480 if (!dname)
481 dname = sock->sk ? sock->sk->sk_prot_creator->name : "";
482
483 file = alloc_file_pseudo(SOCK_INODE(socket: sock), sock_mnt, dname,
484 O_RDWR | (flags & O_NONBLOCK),
485 &socket_file_ops);
486 if (IS_ERR(ptr: file)) {
487 sock_release(sock);
488 return file;
489 }
490
491 file->f_mode |= FMODE_NOWAIT;
492 sock->file = file;
493 file->private_data = sock;
494 stream_open(inode: SOCK_INODE(socket: sock), filp: file);
495 /*
496 * Disable permission and pre-content events, but enable legacy
497 * inotify events for legacy users.
498 */
499 file_set_fsnotify_mode(file, FMODE_NONOTIFY_PERM);
500 return file;
501}
502EXPORT_SYMBOL(sock_alloc_file);
503
504static int sock_map_fd(struct socket *sock, int flags)
505{
506 struct file *newfile;
507 int fd = get_unused_fd_flags(flags);
508 if (unlikely(fd < 0)) {
509 sock_release(sock);
510 return fd;
511 }
512
513 newfile = sock_alloc_file(sock, flags, NULL);
514 if (!IS_ERR(ptr: newfile)) {
515 fd_install(fd, file: newfile);
516 return fd;
517 }
518
519 put_unused_fd(fd);
520 return PTR_ERR(ptr: newfile);
521}
522
523/**
524 * sock_from_file - Return the &socket bounded to @file.
525 * @file: file
526 *
527 * On failure returns %NULL.
528 */
529
530struct socket *sock_from_file(struct file *file)
531{
532 if (likely(file->f_op == &socket_file_ops))
533 return file->private_data; /* set in sock_alloc_file */
534
535 return NULL;
536}
537EXPORT_SYMBOL(sock_from_file);
538
539/**
540 * sockfd_lookup - Go from a file number to its socket slot
541 * @fd: file handle
542 * @err: pointer to an error code return
543 *
544 * The file handle passed in is locked and the socket it is bound
545 * to is returned. If an error occurs the err pointer is overwritten
546 * with a negative errno code and NULL is returned. The function checks
547 * for both invalid handles and passing a handle which is not a socket.
548 *
549 * On a success the socket object pointer is returned.
550 */
551
552struct socket *sockfd_lookup(int fd, int *err)
553{
554 struct file *file;
555 struct socket *sock;
556
557 file = fget(fd);
558 if (!file) {
559 *err = -EBADF;
560 return NULL;
561 }
562
563 sock = sock_from_file(file);
564 if (!sock) {
565 *err = -ENOTSOCK;
566 fput(file);
567 }
568 return sock;
569}
570EXPORT_SYMBOL(sockfd_lookup);
571
572static ssize_t sockfs_listxattr(struct dentry *dentry, char *buffer,
573 size_t size)
574{
575 ssize_t len;
576 ssize_t used = 0;
577
578 len = security_inode_listsecurity(inode: d_inode(dentry), buffer, buffer_size: size);
579 if (len < 0)
580 return len;
581 used += len;
582 if (buffer) {
583 if (size < used)
584 return -ERANGE;
585 buffer += len;
586 }
587
588 len = (XATTR_NAME_SOCKPROTONAME_LEN + 1);
589 used += len;
590 if (buffer) {
591 if (size < used)
592 return -ERANGE;
593 memcpy(buffer, XATTR_NAME_SOCKPROTONAME, len);
594 buffer += len;
595 }
596
597 return used;
598}
599
600static int sockfs_setattr(struct mnt_idmap *idmap,
601 struct dentry *dentry, struct iattr *iattr)
602{
603 int err = simple_setattr(&nop_mnt_idmap, dentry, iattr);
604
605 if (!err && (iattr->ia_valid & ATTR_UID)) {
606 struct socket *sock = SOCKET_I(inode: d_inode(dentry));
607
608 if (sock->sk) {
609 /* Paired with READ_ONCE() in sk_uid() */
610 WRITE_ONCE(sock->sk->sk_uid, iattr->ia_uid);
611 } else {
612 err = -ENOENT;
613 }
614 }
615
616 return err;
617}
618
619static const struct inode_operations sockfs_inode_ops = {
620 .listxattr = sockfs_listxattr,
621 .setattr = sockfs_setattr,
622};
623
624/**
625 * sock_alloc - allocate a socket
626 *
627 * Allocate a new inode and socket object. The two are bound together
628 * and initialised. The socket is then returned. If we are out of inodes
629 * NULL is returned. This functions uses GFP_KERNEL internally.
630 */
631
632struct socket *sock_alloc(void)
633{
634 struct inode *inode;
635 struct socket *sock;
636
637 inode = new_inode_pseudo(sb: sock_mnt->mnt_sb);
638 if (!inode)
639 return NULL;
640
641 sock = SOCKET_I(inode);
642
643 inode->i_ino = get_next_ino();
644 inode->i_mode = S_IFSOCK | S_IRWXUGO;
645 inode->i_uid = current_fsuid();
646 inode->i_gid = current_fsgid();
647 inode->i_op = &sockfs_inode_ops;
648
649 return sock;
650}
651EXPORT_SYMBOL(sock_alloc);
652
653static void __sock_release(struct socket *sock, struct inode *inode)
654{
655 const struct proto_ops *ops = READ_ONCE(sock->ops);
656
657 if (ops) {
658 struct module *owner = ops->owner;
659
660 if (inode)
661 inode_lock(inode);
662 ops->release(sock);
663 sock->sk = NULL;
664 if (inode)
665 inode_unlock(inode);
666 sock->ops = NULL;
667 module_put(module: owner);
668 }
669
670 if (sock->wq.fasync_list)
671 pr_err("%s: fasync list not empty!\n", __func__);
672
673 if (!sock->file) {
674 iput(SOCK_INODE(socket: sock));
675 return;
676 }
677 sock->file = NULL;
678}
679
680/**
681 * sock_release - close a socket
682 * @sock: socket to close
683 *
684 * The socket is released from the protocol stack if it has a release
685 * callback, and the inode is then released if the socket is bound to
686 * an inode not a file.
687 */
688void sock_release(struct socket *sock)
689{
690 __sock_release(sock, NULL);
691}
692EXPORT_SYMBOL(sock_release);
693
694void __sock_tx_timestamp(__u32 tsflags, __u8 *tx_flags)
695{
696 u8 flags = *tx_flags;
697
698 if (tsflags & SOF_TIMESTAMPING_TX_HARDWARE)
699 flags |= SKBTX_HW_TSTAMP_NOBPF;
700
701 if (tsflags & SOF_TIMESTAMPING_TX_SOFTWARE)
702 flags |= SKBTX_SW_TSTAMP;
703
704 if (tsflags & SOF_TIMESTAMPING_TX_SCHED)
705 flags |= SKBTX_SCHED_TSTAMP;
706
707 if (tsflags & SOF_TIMESTAMPING_TX_COMPLETION)
708 flags |= SKBTX_COMPLETION_TSTAMP;
709
710 *tx_flags = flags;
711}
712EXPORT_SYMBOL(__sock_tx_timestamp);
713
714INDIRECT_CALLABLE_DECLARE(int inet_sendmsg(struct socket *, struct msghdr *,
715 size_t));
716INDIRECT_CALLABLE_DECLARE(int inet6_sendmsg(struct socket *, struct msghdr *,
717 size_t));
718
719static noinline void call_trace_sock_send_length(struct sock *sk, int ret,
720 int flags)
721{
722 trace_sock_send_length(sk, ret, flags: 0);
723}
724
725static inline int sock_sendmsg_nosec(struct socket *sock, struct msghdr *msg)
726{
727 int ret = INDIRECT_CALL_INET(READ_ONCE(sock->ops)->sendmsg, inet6_sendmsg,
728 inet_sendmsg, sock, msg,
729 msg_data_left(msg));
730 BUG_ON(ret == -EIOCBQUEUED);
731
732 if (trace_sock_send_length_enabled())
733 call_trace_sock_send_length(sk: sock->sk, ret, flags: 0);
734 return ret;
735}
736
737static int __sock_sendmsg(struct socket *sock, struct msghdr *msg)
738{
739 int err = security_socket_sendmsg(sock, msg,
740 size: msg_data_left(msg));
741
742 return err ?: sock_sendmsg_nosec(sock, msg);
743}
744
745/**
746 * sock_sendmsg - send a message through @sock
747 * @sock: socket
748 * @msg: message to send
749 *
750 * Sends @msg through @sock, passing through LSM.
751 * Returns the number of bytes sent, or an error code.
752 */
753int sock_sendmsg(struct socket *sock, struct msghdr *msg)
754{
755 struct sockaddr_storage *save_addr = (struct sockaddr_storage *)msg->msg_name;
756 struct sockaddr_storage address;
757 int save_len = msg->msg_namelen;
758 int ret;
759
760 if (msg->msg_name) {
761 memcpy(&address, msg->msg_name, msg->msg_namelen);
762 msg->msg_name = &address;
763 }
764
765 ret = __sock_sendmsg(sock, msg);
766 msg->msg_name = save_addr;
767 msg->msg_namelen = save_len;
768
769 return ret;
770}
771EXPORT_SYMBOL(sock_sendmsg);
772
773/**
774 * kernel_sendmsg - send a message through @sock (kernel-space)
775 * @sock: socket
776 * @msg: message header
777 * @vec: kernel vec
778 * @num: vec array length
779 * @size: total message data size
780 *
781 * Builds the message data with @vec and sends it through @sock.
782 * Returns the number of bytes sent, or an error code.
783 */
784
785int kernel_sendmsg(struct socket *sock, struct msghdr *msg,
786 struct kvec *vec, size_t num, size_t size)
787{
788 iov_iter_kvec(i: &msg->msg_iter, ITER_SOURCE, kvec: vec, nr_segs: num, count: size);
789 return sock_sendmsg(sock, msg);
790}
791EXPORT_SYMBOL(kernel_sendmsg);
792
793static bool skb_is_err_queue(const struct sk_buff *skb)
794{
795 /* pkt_type of skbs enqueued on the error queue are set to
796 * PACKET_OUTGOING in skb_set_err_queue(). This is only safe to do
797 * in recvmsg, since skbs received on a local socket will never
798 * have a pkt_type of PACKET_OUTGOING.
799 */
800 return skb->pkt_type == PACKET_OUTGOING;
801}
802
803/* On transmit, software and hardware timestamps are returned independently.
804 * As the two skb clones share the hardware timestamp, which may be updated
805 * before the software timestamp is received, a hardware TX timestamp may be
806 * returned only if there is no software TX timestamp. Ignore false software
807 * timestamps, which may be made in the __sock_recv_timestamp() call when the
808 * option SO_TIMESTAMP_OLD(NS) is enabled on the socket, even when the skb has a
809 * hardware timestamp.
810 */
811static bool skb_is_swtx_tstamp(const struct sk_buff *skb, int false_tstamp)
812{
813 return skb->tstamp && !false_tstamp && skb_is_err_queue(skb);
814}
815
816static ktime_t get_timestamp(struct sock *sk, struct sk_buff *skb, int *if_index)
817{
818 bool cycles = READ_ONCE(sk->sk_tsflags) & SOF_TIMESTAMPING_BIND_PHC;
819 struct skb_shared_hwtstamps *shhwtstamps = skb_hwtstamps(skb);
820 struct net_device *orig_dev;
821 ktime_t hwtstamp;
822
823 rcu_read_lock();
824 orig_dev = dev_get_by_napi_id(napi_id: skb_napi_id(skb));
825 if (orig_dev) {
826 *if_index = orig_dev->ifindex;
827 hwtstamp = netdev_get_tstamp(dev: orig_dev, hwtstamps: shhwtstamps, cycles);
828 } else {
829 hwtstamp = shhwtstamps->hwtstamp;
830 }
831 rcu_read_unlock();
832
833 return hwtstamp;
834}
835
836static void put_ts_pktinfo(struct msghdr *msg, struct sk_buff *skb,
837 int if_index)
838{
839 struct scm_ts_pktinfo ts_pktinfo;
840 struct net_device *orig_dev;
841
842 if (!skb_mac_header_was_set(skb))
843 return;
844
845 memset(&ts_pktinfo, 0, sizeof(ts_pktinfo));
846
847 if (!if_index) {
848 rcu_read_lock();
849 orig_dev = dev_get_by_napi_id(napi_id: skb_napi_id(skb));
850 if (orig_dev)
851 if_index = orig_dev->ifindex;
852 rcu_read_unlock();
853 }
854 ts_pktinfo.if_index = if_index;
855
856 ts_pktinfo.pkt_length = skb->len - skb_mac_offset(skb);
857 put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPING_PKTINFO,
858 len: sizeof(ts_pktinfo), data: &ts_pktinfo);
859}
860
861bool skb_has_tx_timestamp(struct sk_buff *skb, const struct sock *sk)
862{
863 const struct sock_exterr_skb *serr = SKB_EXT_ERR(skb);
864 u32 tsflags = READ_ONCE(sk->sk_tsflags);
865
866 if (serr->ee.ee_errno != ENOMSG ||
867 serr->ee.ee_origin != SO_EE_ORIGIN_TIMESTAMPING)
868 return false;
869
870 /* software time stamp available and wanted */
871 if ((tsflags & SOF_TIMESTAMPING_SOFTWARE) && skb->tstamp)
872 return true;
873 /* hardware time stamps available and wanted */
874 return (tsflags & SOF_TIMESTAMPING_RAW_HARDWARE) &&
875 skb_hwtstamps(skb)->hwtstamp;
876}
877
878int skb_get_tx_timestamp(struct sk_buff *skb, struct sock *sk,
879 struct timespec64 *ts)
880{
881 u32 tsflags = READ_ONCE(sk->sk_tsflags);
882 ktime_t hwtstamp;
883 int if_index = 0;
884
885 if ((tsflags & SOF_TIMESTAMPING_SOFTWARE) &&
886 ktime_to_timespec64_cond(kt: skb->tstamp, ts))
887 return SOF_TIMESTAMPING_TX_SOFTWARE;
888
889 if (!(tsflags & SOF_TIMESTAMPING_RAW_HARDWARE) ||
890 skb_is_swtx_tstamp(skb, false_tstamp: false))
891 return -ENOENT;
892
893 if (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP_NETDEV)
894 hwtstamp = get_timestamp(sk, skb, if_index: &if_index);
895 else
896 hwtstamp = skb_hwtstamps(skb)->hwtstamp;
897
898 if (tsflags & SOF_TIMESTAMPING_BIND_PHC)
899 hwtstamp = ptp_convert_timestamp(hwtstamp: &hwtstamp,
900 READ_ONCE(sk->sk_bind_phc));
901 if (!ktime_to_timespec64_cond(kt: hwtstamp, ts))
902 return -ENOENT;
903
904 return SOF_TIMESTAMPING_TX_HARDWARE;
905}
906
907/*
908 * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
909 */
910void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
911 struct sk_buff *skb)
912{
913 int need_software_tstamp = sock_flag(sk, flag: SOCK_RCVTSTAMP);
914 int new_tstamp = sock_flag(sk, flag: SOCK_TSTAMP_NEW);
915 struct scm_timestamping_internal tss;
916 int empty = 1, false_tstamp = 0;
917 struct skb_shared_hwtstamps *shhwtstamps =
918 skb_hwtstamps(skb);
919 int if_index;
920 ktime_t hwtstamp;
921 u32 tsflags;
922
923 /* Race occurred between timestamp enabling and packet
924 receiving. Fill in the current time for now. */
925 if (need_software_tstamp && skb->tstamp == 0) {
926 __net_timestamp(skb);
927 false_tstamp = 1;
928 }
929
930 if (need_software_tstamp) {
931 if (!sock_flag(sk, flag: SOCK_RCVTSTAMPNS)) {
932 if (new_tstamp) {
933 struct __kernel_sock_timeval tv;
934
935 skb_get_new_timestamp(skb, stamp: &tv);
936 put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_NEW,
937 len: sizeof(tv), data: &tv);
938 } else {
939 struct __kernel_old_timeval tv;
940
941 skb_get_timestamp(skb, stamp: &tv);
942 put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_OLD,
943 len: sizeof(tv), data: &tv);
944 }
945 } else {
946 if (new_tstamp) {
947 struct __kernel_timespec ts;
948
949 skb_get_new_timestampns(skb, stamp: &ts);
950 put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_NEW,
951 len: sizeof(ts), data: &ts);
952 } else {
953 struct __kernel_old_timespec ts;
954
955 skb_get_timestampns(skb, stamp: &ts);
956 put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_OLD,
957 len: sizeof(ts), data: &ts);
958 }
959 }
960 }
961
962 memset(&tss, 0, sizeof(tss));
963 tsflags = READ_ONCE(sk->sk_tsflags);
964 if ((tsflags & SOF_TIMESTAMPING_SOFTWARE &&
965 (tsflags & SOF_TIMESTAMPING_RX_SOFTWARE ||
966 skb_is_err_queue(skb) ||
967 !(tsflags & SOF_TIMESTAMPING_OPT_RX_FILTER))) &&
968 ktime_to_timespec64_cond(kt: skb->tstamp, ts: tss.ts + 0))
969 empty = 0;
970 if (shhwtstamps &&
971 (tsflags & SOF_TIMESTAMPING_RAW_HARDWARE &&
972 (tsflags & SOF_TIMESTAMPING_RX_HARDWARE ||
973 skb_is_err_queue(skb) ||
974 !(tsflags & SOF_TIMESTAMPING_OPT_RX_FILTER))) &&
975 !skb_is_swtx_tstamp(skb, false_tstamp)) {
976 if_index = 0;
977 if (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP_NETDEV)
978 hwtstamp = get_timestamp(sk, skb, if_index: &if_index);
979 else
980 hwtstamp = shhwtstamps->hwtstamp;
981
982 if (tsflags & SOF_TIMESTAMPING_BIND_PHC)
983 hwtstamp = ptp_convert_timestamp(hwtstamp: &hwtstamp,
984 READ_ONCE(sk->sk_bind_phc));
985
986 if (ktime_to_timespec64_cond(kt: hwtstamp, ts: tss.ts + 2)) {
987 empty = 0;
988
989 if ((tsflags & SOF_TIMESTAMPING_OPT_PKTINFO) &&
990 !skb_is_err_queue(skb))
991 put_ts_pktinfo(msg, skb, if_index);
992 }
993 }
994 if (!empty) {
995 if (sock_flag(sk, flag: SOCK_TSTAMP_NEW))
996 put_cmsg_scm_timestamping64(msg, tss: &tss);
997 else
998 put_cmsg_scm_timestamping(msg, tss: &tss);
999
1000 if (skb_is_err_queue(skb) && skb->len &&
1001 SKB_EXT_ERR(skb)->opt_stats)
1002 put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPING_OPT_STATS,
1003 len: skb->len, data: skb->data);
1004 }
1005}
1006EXPORT_SYMBOL_GPL(__sock_recv_timestamp);
1007
1008#ifdef CONFIG_WIRELESS
1009void __sock_recv_wifi_status(struct msghdr *msg, struct sock *sk,
1010 struct sk_buff *skb)
1011{
1012 int ack;
1013
1014 if (!sock_flag(sk, flag: SOCK_WIFI_STATUS))
1015 return;
1016 if (!skb->wifi_acked_valid)
1017 return;
1018
1019 ack = skb->wifi_acked;
1020
1021 put_cmsg(msg, SOL_SOCKET, SCM_WIFI_STATUS, len: sizeof(ack), data: &ack);
1022}
1023EXPORT_SYMBOL_GPL(__sock_recv_wifi_status);
1024#endif
1025
1026static inline void sock_recv_drops(struct msghdr *msg, struct sock *sk,
1027 struct sk_buff *skb)
1028{
1029 if (sock_flag(sk, flag: SOCK_RXQ_OVFL) && skb && SOCK_SKB_CB(skb)->dropcount)
1030 put_cmsg(msg, SOL_SOCKET, SO_RXQ_OVFL,
1031 len: sizeof(__u32), data: &SOCK_SKB_CB(skb)->dropcount);
1032}
1033
1034static void sock_recv_mark(struct msghdr *msg, struct sock *sk,
1035 struct sk_buff *skb)
1036{
1037 if (sock_flag(sk, flag: SOCK_RCVMARK) && skb) {
1038 /* We must use a bounce buffer for CONFIG_HARDENED_USERCOPY=y */
1039 __u32 mark = skb->mark;
1040
1041 put_cmsg(msg, SOL_SOCKET, SO_MARK, len: sizeof(__u32), data: &mark);
1042 }
1043}
1044
1045static void sock_recv_priority(struct msghdr *msg, struct sock *sk,
1046 struct sk_buff *skb)
1047{
1048 if (sock_flag(sk, flag: SOCK_RCVPRIORITY) && skb) {
1049 __u32 priority = skb->priority;
1050
1051 put_cmsg(msg, SOL_SOCKET, SO_PRIORITY, len: sizeof(__u32), data: &priority);
1052 }
1053}
1054
1055void __sock_recv_cmsgs(struct msghdr *msg, struct sock *sk,
1056 struct sk_buff *skb)
1057{
1058 sock_recv_timestamp(msg, sk, skb);
1059 sock_recv_drops(msg, sk, skb);
1060 sock_recv_mark(msg, sk, skb);
1061 sock_recv_priority(msg, sk, skb);
1062}
1063EXPORT_SYMBOL_GPL(__sock_recv_cmsgs);
1064
1065INDIRECT_CALLABLE_DECLARE(int inet_recvmsg(struct socket *, struct msghdr *,
1066 size_t, int));
1067INDIRECT_CALLABLE_DECLARE(int inet6_recvmsg(struct socket *, struct msghdr *,
1068 size_t, int));
1069
1070static noinline void call_trace_sock_recv_length(struct sock *sk, int ret, int flags)
1071{
1072 trace_sock_recv_length(sk, ret, flags);
1073}
1074
1075static inline int sock_recvmsg_nosec(struct socket *sock, struct msghdr *msg,
1076 int flags)
1077{
1078 int ret = INDIRECT_CALL_INET(READ_ONCE(sock->ops)->recvmsg,
1079 inet6_recvmsg,
1080 inet_recvmsg, sock, msg,
1081 msg_data_left(msg), flags);
1082 if (trace_sock_recv_length_enabled())
1083 call_trace_sock_recv_length(sk: sock->sk, ret, flags);
1084 return ret;
1085}
1086
1087/**
1088 * sock_recvmsg - receive a message from @sock
1089 * @sock: socket
1090 * @msg: message to receive
1091 * @flags: message flags
1092 *
1093 * Receives @msg from @sock, passing through LSM. Returns the total number
1094 * of bytes received, or an error.
1095 */
1096int sock_recvmsg(struct socket *sock, struct msghdr *msg, int flags)
1097{
1098 int err = security_socket_recvmsg(sock, msg, size: msg_data_left(msg), flags);
1099
1100 return err ?: sock_recvmsg_nosec(sock, msg, flags);
1101}
1102EXPORT_SYMBOL(sock_recvmsg);
1103
1104/**
1105 * kernel_recvmsg - Receive a message from a socket (kernel space)
1106 * @sock: The socket to receive the message from
1107 * @msg: Received message
1108 * @vec: Input s/g array for message data
1109 * @num: Size of input s/g array
1110 * @size: Number of bytes to read
1111 * @flags: Message flags (MSG_DONTWAIT, etc...)
1112 *
1113 * On return the msg structure contains the scatter/gather array passed in the
1114 * vec argument. The array is modified so that it consists of the unfilled
1115 * portion of the original array.
1116 *
1117 * The returned value is the total number of bytes received, or an error.
1118 */
1119
1120int kernel_recvmsg(struct socket *sock, struct msghdr *msg,
1121 struct kvec *vec, size_t num, size_t size, int flags)
1122{
1123 msg->msg_control_is_user = false;
1124 iov_iter_kvec(i: &msg->msg_iter, ITER_DEST, kvec: vec, nr_segs: num, count: size);
1125 return sock_recvmsg(sock, msg, flags);
1126}
1127EXPORT_SYMBOL(kernel_recvmsg);
1128
1129static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
1130 struct pipe_inode_info *pipe, size_t len,
1131 unsigned int flags)
1132{
1133 struct socket *sock = file->private_data;
1134 const struct proto_ops *ops;
1135
1136 ops = READ_ONCE(sock->ops);
1137 if (unlikely(!ops->splice_read))
1138 return copy_splice_read(in: file, ppos, pipe, len, flags);
1139
1140 return ops->splice_read(sock, ppos, pipe, len, flags);
1141}
1142
1143static void sock_splice_eof(struct file *file)
1144{
1145 struct socket *sock = file->private_data;
1146 const struct proto_ops *ops;
1147
1148 ops = READ_ONCE(sock->ops);
1149 if (ops->splice_eof)
1150 ops->splice_eof(sock);
1151}
1152
1153static ssize_t sock_read_iter(struct kiocb *iocb, struct iov_iter *to)
1154{
1155 struct file *file = iocb->ki_filp;
1156 struct socket *sock = file->private_data;
1157 struct msghdr msg = {.msg_iter = *to,
1158 .msg_iocb = iocb};
1159 ssize_t res;
1160
1161 if (file->f_flags & O_NONBLOCK || (iocb->ki_flags & IOCB_NOWAIT))
1162 msg.msg_flags = MSG_DONTWAIT;
1163
1164 if (iocb->ki_pos != 0)
1165 return -ESPIPE;
1166
1167 if (!iov_iter_count(i: to)) /* Match SYS5 behaviour */
1168 return 0;
1169
1170 res = sock_recvmsg(sock, &msg, msg.msg_flags);
1171 *to = msg.msg_iter;
1172 return res;
1173}
1174
1175static ssize_t sock_write_iter(struct kiocb *iocb, struct iov_iter *from)
1176{
1177 struct file *file = iocb->ki_filp;
1178 struct socket *sock = file->private_data;
1179 struct msghdr msg = {.msg_iter = *from,
1180 .msg_iocb = iocb};
1181 ssize_t res;
1182
1183 if (iocb->ki_pos != 0)
1184 return -ESPIPE;
1185
1186 if (file->f_flags & O_NONBLOCK || (iocb->ki_flags & IOCB_NOWAIT))
1187 msg.msg_flags = MSG_DONTWAIT;
1188
1189 if (sock->type == SOCK_SEQPACKET)
1190 msg.msg_flags |= MSG_EOR;
1191
1192 if (iocb->ki_flags & IOCB_NOSIGNAL)
1193 msg.msg_flags |= MSG_NOSIGNAL;
1194
1195 res = __sock_sendmsg(sock, msg: &msg);
1196 *from = msg.msg_iter;
1197 return res;
1198}
1199
1200/*
1201 * Atomic setting of ioctl hooks to avoid race
1202 * with module unload.
1203 */
1204
1205static DEFINE_MUTEX(br_ioctl_mutex);
1206static int (*br_ioctl_hook)(struct net *net, unsigned int cmd,
1207 void __user *uarg);
1208
1209void brioctl_set(int (*hook)(struct net *net, unsigned int cmd,
1210 void __user *uarg))
1211{
1212 mutex_lock(&br_ioctl_mutex);
1213 br_ioctl_hook = hook;
1214 mutex_unlock(lock: &br_ioctl_mutex);
1215}
1216EXPORT_SYMBOL(brioctl_set);
1217
1218int br_ioctl_call(struct net *net, unsigned int cmd, void __user *uarg)
1219{
1220 int err = -ENOPKG;
1221
1222 if (!br_ioctl_hook)
1223 request_module("bridge");
1224
1225 mutex_lock(&br_ioctl_mutex);
1226 if (br_ioctl_hook)
1227 err = br_ioctl_hook(net, cmd, uarg);
1228 mutex_unlock(lock: &br_ioctl_mutex);
1229
1230 return err;
1231}
1232
1233static DEFINE_MUTEX(vlan_ioctl_mutex);
1234static int (*vlan_ioctl_hook) (struct net *, void __user *arg);
1235
1236void vlan_ioctl_set(int (*hook) (struct net *, void __user *))
1237{
1238 mutex_lock(&vlan_ioctl_mutex);
1239 vlan_ioctl_hook = hook;
1240 mutex_unlock(lock: &vlan_ioctl_mutex);
1241}
1242EXPORT_SYMBOL(vlan_ioctl_set);
1243
1244static long sock_do_ioctl(struct net *net, struct socket *sock,
1245 unsigned int cmd, unsigned long arg)
1246{
1247 const struct proto_ops *ops = READ_ONCE(sock->ops);
1248 struct ifreq ifr;
1249 bool need_copyout;
1250 int err;
1251 void __user *argp = (void __user *)arg;
1252 void __user *data;
1253
1254 err = ops->ioctl(sock, cmd, arg);
1255
1256 /*
1257 * If this ioctl is unknown try to hand it down
1258 * to the NIC driver.
1259 */
1260 if (err != -ENOIOCTLCMD)
1261 return err;
1262
1263 if (!is_socket_ioctl_cmd(cmd))
1264 return -ENOTTY;
1265
1266 if (get_user_ifreq(ifr: &ifr, ifrdata: &data, arg: argp))
1267 return -EFAULT;
1268 err = dev_ioctl(net, cmd, ifr: &ifr, data, need_copyout: &need_copyout);
1269 if (!err && need_copyout)
1270 if (put_user_ifreq(ifr: &ifr, arg: argp))
1271 return -EFAULT;
1272
1273 return err;
1274}
1275
1276/*
1277 * With an ioctl, arg may well be a user mode pointer, but we don't know
1278 * what to do with it - that's up to the protocol still.
1279 */
1280
1281static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
1282{
1283 const struct proto_ops *ops;
1284 struct socket *sock;
1285 struct sock *sk;
1286 void __user *argp = (void __user *)arg;
1287 int pid, err;
1288 struct net *net;
1289
1290 sock = file->private_data;
1291 ops = READ_ONCE(sock->ops);
1292 sk = sock->sk;
1293 net = sock_net(sk);
1294 if (unlikely(cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15))) {
1295 struct ifreq ifr;
1296 void __user *data;
1297 bool need_copyout;
1298 if (get_user_ifreq(ifr: &ifr, ifrdata: &data, arg: argp))
1299 return -EFAULT;
1300 err = dev_ioctl(net, cmd, ifr: &ifr, data, need_copyout: &need_copyout);
1301 if (!err && need_copyout)
1302 if (put_user_ifreq(ifr: &ifr, arg: argp))
1303 return -EFAULT;
1304 } else
1305#ifdef CONFIG_WEXT_CORE
1306 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {
1307 err = wext_handle_ioctl(net, cmd, arg: argp);
1308 } else
1309#endif
1310 switch (cmd) {
1311 case FIOSETOWN:
1312 case SIOCSPGRP:
1313 err = -EFAULT;
1314 if (get_user(pid, (int __user *)argp))
1315 break;
1316 err = f_setown(filp: sock->file, who: pid, force: 1);
1317 break;
1318 case FIOGETOWN:
1319 case SIOCGPGRP:
1320 err = put_user(f_getown(sock->file),
1321 (int __user *)argp);
1322 break;
1323 case SIOCGIFBR:
1324 case SIOCSIFBR:
1325 case SIOCBRADDBR:
1326 case SIOCBRDELBR:
1327 case SIOCBRADDIF:
1328 case SIOCBRDELIF:
1329 err = br_ioctl_call(net, cmd, uarg: argp);
1330 break;
1331 case SIOCGIFVLAN:
1332 case SIOCSIFVLAN:
1333 err = -ENOPKG;
1334 if (!vlan_ioctl_hook)
1335 request_module("8021q");
1336
1337 mutex_lock(&vlan_ioctl_mutex);
1338 if (vlan_ioctl_hook)
1339 err = vlan_ioctl_hook(net, argp);
1340 mutex_unlock(lock: &vlan_ioctl_mutex);
1341 break;
1342 case SIOCGSKNS:
1343 err = -EPERM;
1344 if (!ns_capable(ns: net->user_ns, CAP_NET_ADMIN))
1345 break;
1346
1347 err = open_related_ns(ns: &net->ns, get_ns: get_net_ns);
1348 break;
1349 case SIOCGSTAMP_OLD:
1350 case SIOCGSTAMPNS_OLD:
1351 if (!ops->gettstamp) {
1352 err = -ENOIOCTLCMD;
1353 break;
1354 }
1355 err = ops->gettstamp(sock, argp,
1356 cmd == SIOCGSTAMP_OLD,
1357 !IS_ENABLED(CONFIG_64BIT));
1358 break;
1359 case SIOCGSTAMP_NEW:
1360 case SIOCGSTAMPNS_NEW:
1361 if (!ops->gettstamp) {
1362 err = -ENOIOCTLCMD;
1363 break;
1364 }
1365 err = ops->gettstamp(sock, argp,
1366 cmd == SIOCGSTAMP_NEW,
1367 false);
1368 break;
1369
1370 case SIOCGIFCONF:
1371 err = dev_ifconf(net, ifc: argp);
1372 break;
1373
1374 default:
1375 err = sock_do_ioctl(net, sock, cmd, arg);
1376 break;
1377 }
1378 return err;
1379}
1380
1381/**
1382 * sock_create_lite - creates a socket
1383 * @family: protocol family (AF_INET, ...)
1384 * @type: communication type (SOCK_STREAM, ...)
1385 * @protocol: protocol (0, ...)
1386 * @res: new socket
1387 *
1388 * Creates a new socket and assigns it to @res, passing through LSM.
1389 * The new socket initialization is not complete, see kernel_accept().
1390 * Returns 0 or an error. On failure @res is set to %NULL.
1391 * This function internally uses GFP_KERNEL.
1392 */
1393
1394int sock_create_lite(int family, int type, int protocol, struct socket **res)
1395{
1396 int err;
1397 struct socket *sock = NULL;
1398
1399 err = security_socket_create(family, type, protocol, kern: 1);
1400 if (err)
1401 goto out;
1402
1403 sock = sock_alloc();
1404 if (!sock) {
1405 err = -ENOMEM;
1406 goto out;
1407 }
1408
1409 sock->type = type;
1410 err = security_socket_post_create(sock, family, type, protocol, kern: 1);
1411 if (err)
1412 goto out_release;
1413
1414out:
1415 *res = sock;
1416 return err;
1417out_release:
1418 sock_release(sock);
1419 sock = NULL;
1420 goto out;
1421}
1422EXPORT_SYMBOL(sock_create_lite);
1423
1424/* No kernel lock held - perfect */
1425static __poll_t sock_poll(struct file *file, poll_table *wait)
1426{
1427 struct socket *sock = file->private_data;
1428 const struct proto_ops *ops = READ_ONCE(sock->ops);
1429 __poll_t events = poll_requested_events(p: wait), flag = 0;
1430
1431 if (!ops->poll)
1432 return 0;
1433
1434 if (sk_can_busy_loop(sk: sock->sk)) {
1435 /* poll once if requested by the syscall */
1436 if (events & POLL_BUSY_LOOP)
1437 sk_busy_loop(sk: sock->sk, nonblock: 1);
1438
1439 /* if this socket can poll_ll, tell the system call */
1440 flag = POLL_BUSY_LOOP;
1441 }
1442
1443 return ops->poll(file, sock, wait) | flag;
1444}
1445
1446static int sock_mmap(struct file *file, struct vm_area_struct *vma)
1447{
1448 struct socket *sock = file->private_data;
1449
1450 return READ_ONCE(sock->ops)->mmap(file, sock, vma);
1451}
1452
1453static int sock_close(struct inode *inode, struct file *filp)
1454{
1455 __sock_release(sock: SOCKET_I(inode), inode);
1456 return 0;
1457}
1458
1459/*
1460 * Update the socket async list
1461 *
1462 * Fasync_list locking strategy.
1463 *
1464 * 1. fasync_list is modified only under process context socket lock
1465 * i.e. under semaphore.
1466 * 2. fasync_list is used under read_lock(&sk->sk_callback_lock)
1467 * or under socket lock
1468 */
1469
1470static int sock_fasync(int fd, struct file *filp, int on)
1471{
1472 struct socket *sock = filp->private_data;
1473 struct sock *sk = sock->sk;
1474 struct socket_wq *wq = &sock->wq;
1475
1476 if (sk == NULL)
1477 return -EINVAL;
1478
1479 lock_sock(sk);
1480 fasync_helper(fd, filp, on, &wq->fasync_list);
1481
1482 if (!wq->fasync_list)
1483 sock_reset_flag(sk, flag: SOCK_FASYNC);
1484 else
1485 sock_set_flag(sk, flag: SOCK_FASYNC);
1486
1487 release_sock(sk);
1488 return 0;
1489}
1490
1491/* This function may be called only under rcu_lock */
1492
1493int sock_wake_async(struct socket_wq *wq, int how, int band)
1494{
1495 if (!wq || !wq->fasync_list)
1496 return -1;
1497
1498 switch (how) {
1499 case SOCK_WAKE_WAITD:
1500 if (test_bit(SOCKWQ_ASYNC_WAITDATA, &wq->flags))
1501 break;
1502 goto call_kill;
1503 case SOCK_WAKE_SPACE:
1504 if (!test_and_clear_bit(nr: SOCKWQ_ASYNC_NOSPACE, addr: &wq->flags))
1505 break;
1506 fallthrough;
1507 case SOCK_WAKE_IO:
1508call_kill:
1509 kill_fasync(&wq->fasync_list, SIGIO, band);
1510 break;
1511 case SOCK_WAKE_URG:
1512 kill_fasync(&wq->fasync_list, SIGURG, band);
1513 }
1514
1515 return 0;
1516}
1517EXPORT_SYMBOL(sock_wake_async);
1518
1519/**
1520 * __sock_create - creates a socket
1521 * @net: net namespace
1522 * @family: protocol family (AF_INET, ...)
1523 * @type: communication type (SOCK_STREAM, ...)
1524 * @protocol: protocol (0, ...)
1525 * @res: new socket
1526 * @kern: boolean for kernel space sockets
1527 *
1528 * Creates a new socket and assigns it to @res, passing through LSM.
1529 * Returns 0 or an error. On failure @res is set to %NULL. @kern must
1530 * be set to true if the socket resides in kernel space.
1531 * This function internally uses GFP_KERNEL.
1532 */
1533
1534int __sock_create(struct net *net, int family, int type, int protocol,
1535 struct socket **res, int kern)
1536{
1537 int err;
1538 struct socket *sock;
1539 const struct net_proto_family *pf;
1540
1541 /*
1542 * Check protocol is in range
1543 */
1544 if (family < 0 || family >= NPROTO)
1545 return -EAFNOSUPPORT;
1546 if (type < 0 || type >= SOCK_MAX)
1547 return -EINVAL;
1548
1549 /* Compatibility.
1550
1551 This uglymoron is moved from INET layer to here to avoid
1552 deadlock in module load.
1553 */
1554 if (family == PF_INET && type == SOCK_PACKET) {
1555 pr_info_once("%s uses obsolete (PF_INET,SOCK_PACKET)\n",
1556 current->comm);
1557 family = PF_PACKET;
1558 }
1559
1560 err = security_socket_create(family, type, protocol, kern);
1561 if (err)
1562 return err;
1563
1564 /*
1565 * Allocate the socket and allow the family to set things up. if
1566 * the protocol is 0, the family is instructed to select an appropriate
1567 * default.
1568 */
1569 sock = sock_alloc();
1570 if (!sock) {
1571 net_warn_ratelimited("socket: no more sockets\n");
1572 return -ENFILE; /* Not exactly a match, but its the
1573 closest posix thing */
1574 }
1575
1576 sock->type = type;
1577
1578#ifdef CONFIG_MODULES
1579 /* Attempt to load a protocol module if the find failed.
1580 *
1581 * 12/09/1996 Marcin: But! this makes REALLY only sense, if the user
1582 * requested real, full-featured networking support upon configuration.
1583 * Otherwise module support will break!
1584 */
1585 if (rcu_access_pointer(net_families[family]) == NULL)
1586 request_module("net-pf-%d", family);
1587#endif
1588
1589 rcu_read_lock();
1590 pf = rcu_dereference(net_families[family]);
1591 err = -EAFNOSUPPORT;
1592 if (!pf)
1593 goto out_release;
1594
1595 /*
1596 * We will call the ->create function, that possibly is in a loadable
1597 * module, so we have to bump that loadable module refcnt first.
1598 */
1599 if (!try_module_get(module: pf->owner))
1600 goto out_release;
1601
1602 /* Now protected by module ref count */
1603 rcu_read_unlock();
1604
1605 err = pf->create(net, sock, protocol, kern);
1606 if (err < 0) {
1607 /* ->create should release the allocated sock->sk object on error
1608 * and make sure sock->sk is set to NULL to avoid use-after-free
1609 */
1610 DEBUG_NET_WARN_ONCE(sock->sk,
1611 "%ps must clear sock->sk on failure, family: %d, type: %d, protocol: %d\n",
1612 pf->create, family, type, protocol);
1613 goto out_module_put;
1614 }
1615
1616 /*
1617 * Now to bump the refcnt of the [loadable] module that owns this
1618 * socket at sock_release time we decrement its refcnt.
1619 */
1620 if (!try_module_get(module: sock->ops->owner))
1621 goto out_module_busy;
1622
1623 /*
1624 * Now that we're done with the ->create function, the [loadable]
1625 * module can have its refcnt decremented
1626 */
1627 module_put(module: pf->owner);
1628 err = security_socket_post_create(sock, family, type, protocol, kern);
1629 if (err)
1630 goto out_sock_release;
1631 *res = sock;
1632
1633 return 0;
1634
1635out_module_busy:
1636 err = -EAFNOSUPPORT;
1637out_module_put:
1638 sock->ops = NULL;
1639 module_put(module: pf->owner);
1640out_sock_release:
1641 sock_release(sock);
1642 return err;
1643
1644out_release:
1645 rcu_read_unlock();
1646 goto out_sock_release;
1647}
1648EXPORT_SYMBOL(__sock_create);
1649
1650/**
1651 * sock_create - creates a socket
1652 * @family: protocol family (AF_INET, ...)
1653 * @type: communication type (SOCK_STREAM, ...)
1654 * @protocol: protocol (0, ...)
1655 * @res: new socket
1656 *
1657 * A wrapper around __sock_create().
1658 * Returns 0 or an error. This function internally uses GFP_KERNEL.
1659 */
1660
1661int sock_create(int family, int type, int protocol, struct socket **res)
1662{
1663 return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);
1664}
1665EXPORT_SYMBOL(sock_create);
1666
1667/**
1668 * sock_create_kern - creates a socket (kernel space)
1669 * @net: net namespace
1670 * @family: protocol family (AF_INET, ...)
1671 * @type: communication type (SOCK_STREAM, ...)
1672 * @protocol: protocol (0, ...)
1673 * @res: new socket
1674 *
1675 * A wrapper around __sock_create().
1676 * Returns 0 or an error. This function internally uses GFP_KERNEL.
1677 */
1678
1679int sock_create_kern(struct net *net, int family, int type, int protocol, struct socket **res)
1680{
1681 return __sock_create(net, family, type, protocol, res, 1);
1682}
1683EXPORT_SYMBOL(sock_create_kern);
1684
1685static struct socket *__sys_socket_create(int family, int type, int protocol)
1686{
1687 struct socket *sock;
1688 int retval;
1689
1690 /* Check the SOCK_* constants for consistency. */
1691 BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);
1692 BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK);
1693 BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);
1694 BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);
1695
1696 if ((type & ~SOCK_TYPE_MASK) & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
1697 return ERR_PTR(error: -EINVAL);
1698 type &= SOCK_TYPE_MASK;
1699
1700 retval = sock_create(family, type, protocol, &sock);
1701 if (retval < 0)
1702 return ERR_PTR(error: retval);
1703
1704 return sock;
1705}
1706
1707struct file *__sys_socket_file(int family, int type, int protocol)
1708{
1709 struct socket *sock;
1710 int flags;
1711
1712 sock = __sys_socket_create(family, type, protocol);
1713 if (IS_ERR(ptr: sock))
1714 return ERR_CAST(ptr: sock);
1715
1716 flags = type & ~SOCK_TYPE_MASK;
1717 if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1718 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1719
1720 return sock_alloc_file(sock, flags, NULL);
1721}
1722
1723/* A hook for bpf progs to attach to and update socket protocol.
1724 *
1725 * A static noinline declaration here could cause the compiler to
1726 * optimize away the function. A global noinline declaration will
1727 * keep the definition, but may optimize away the callsite.
1728 * Therefore, __weak is needed to ensure that the call is still
1729 * emitted, by telling the compiler that we don't know what the
1730 * function might eventually be.
1731 */
1732
1733__bpf_hook_start();
1734
1735__weak noinline int update_socket_protocol(int family, int type, int protocol)
1736{
1737 return protocol;
1738}
1739
1740__bpf_hook_end();
1741
1742int __sys_socket(int family, int type, int protocol)
1743{
1744 struct socket *sock;
1745 int flags;
1746
1747 sock = __sys_socket_create(family, type,
1748 protocol: update_socket_protocol(family, type, protocol));
1749 if (IS_ERR(ptr: sock))
1750 return PTR_ERR(ptr: sock);
1751
1752 flags = type & ~SOCK_TYPE_MASK;
1753 if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1754 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1755
1756 return sock_map_fd(sock, flags: flags & (O_CLOEXEC | O_NONBLOCK));
1757}
1758
1759SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol)
1760{
1761 return __sys_socket(family, type, protocol);
1762}
1763
1764/*
1765 * Create a pair of connected sockets.
1766 */
1767
1768int __sys_socketpair(int family, int type, int protocol, int __user *usockvec)
1769{
1770 struct socket *sock1, *sock2;
1771 int fd1, fd2, err;
1772 struct file *newfile1, *newfile2;
1773 int flags;
1774
1775 flags = type & ~SOCK_TYPE_MASK;
1776 if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
1777 return -EINVAL;
1778 type &= SOCK_TYPE_MASK;
1779
1780 if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1781 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1782
1783 /*
1784 * reserve descriptors and make sure we won't fail
1785 * to return them to userland.
1786 */
1787 fd1 = get_unused_fd_flags(flags);
1788 if (unlikely(fd1 < 0))
1789 return fd1;
1790
1791 fd2 = get_unused_fd_flags(flags);
1792 if (unlikely(fd2 < 0)) {
1793 put_unused_fd(fd: fd1);
1794 return fd2;
1795 }
1796
1797 err = put_user(fd1, &usockvec[0]);
1798 if (err)
1799 goto out;
1800
1801 err = put_user(fd2, &usockvec[1]);
1802 if (err)
1803 goto out;
1804
1805 /*
1806 * Obtain the first socket and check if the underlying protocol
1807 * supports the socketpair call.
1808 */
1809
1810 err = sock_create(family, type, protocol, &sock1);
1811 if (unlikely(err < 0))
1812 goto out;
1813
1814 err = sock_create(family, type, protocol, &sock2);
1815 if (unlikely(err < 0)) {
1816 sock_release(sock1);
1817 goto out;
1818 }
1819
1820 err = security_socket_socketpair(socka: sock1, sockb: sock2);
1821 if (unlikely(err)) {
1822 sock_release(sock2);
1823 sock_release(sock1);
1824 goto out;
1825 }
1826
1827 err = READ_ONCE(sock1->ops)->socketpair(sock1, sock2);
1828 if (unlikely(err < 0)) {
1829 sock_release(sock2);
1830 sock_release(sock1);
1831 goto out;
1832 }
1833
1834 newfile1 = sock_alloc_file(sock1, flags, NULL);
1835 if (IS_ERR(ptr: newfile1)) {
1836 err = PTR_ERR(ptr: newfile1);
1837 sock_release(sock2);
1838 goto out;
1839 }
1840
1841 newfile2 = sock_alloc_file(sock2, flags, NULL);
1842 if (IS_ERR(ptr: newfile2)) {
1843 err = PTR_ERR(ptr: newfile2);
1844 fput(newfile1);
1845 goto out;
1846 }
1847
1848 audit_fd_pair(fd1, fd2);
1849
1850 fd_install(fd: fd1, file: newfile1);
1851 fd_install(fd: fd2, file: newfile2);
1852 return 0;
1853
1854out:
1855 put_unused_fd(fd: fd2);
1856 put_unused_fd(fd: fd1);
1857 return err;
1858}
1859
1860SYSCALL_DEFINE4(socketpair, int, family, int, type, int, protocol,
1861 int __user *, usockvec)
1862{
1863 return __sys_socketpair(family, type, protocol, usockvec);
1864}
1865
1866int __sys_bind_socket(struct socket *sock, struct sockaddr_storage *address,
1867 int addrlen)
1868{
1869 int err;
1870
1871 err = security_socket_bind(sock, address: (struct sockaddr *)address,
1872 addrlen);
1873 if (!err)
1874 err = READ_ONCE(sock->ops)->bind(sock,
1875 (struct sockaddr_unsized *)address,
1876 addrlen);
1877 return err;
1878}
1879
1880/*
1881 * Bind a name to a socket. Nothing much to do here since it's
1882 * the protocol's responsibility to handle the local address.
1883 *
1884 * We move the socket address to kernel space before we call
1885 * the protocol layer (having also checked the address is ok).
1886 */
1887
1888int __sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen)
1889{
1890 struct socket *sock;
1891 struct sockaddr_storage address;
1892 CLASS(fd, f)(fd);
1893 int err;
1894
1895 if (fd_empty(f))
1896 return -EBADF;
1897 sock = sock_from_file(fd_file(f));
1898 if (unlikely(!sock))
1899 return -ENOTSOCK;
1900
1901 err = move_addr_to_kernel(uaddr: umyaddr, ulen: addrlen, kaddr: &address);
1902 if (unlikely(err))
1903 return err;
1904
1905 return __sys_bind_socket(sock, address: &address, addrlen);
1906}
1907
1908SYSCALL_DEFINE3(bind, int, fd, struct sockaddr __user *, umyaddr, int, addrlen)
1909{
1910 return __sys_bind(fd, umyaddr, addrlen);
1911}
1912
1913/*
1914 * Perform a listen. Basically, we allow the protocol to do anything
1915 * necessary for a listen, and if that works, we mark the socket as
1916 * ready for listening.
1917 */
1918int __sys_listen_socket(struct socket *sock, int backlog)
1919{
1920 int somaxconn, err;
1921
1922 somaxconn = READ_ONCE(sock_net(sock->sk)->core.sysctl_somaxconn);
1923 if ((unsigned int)backlog > somaxconn)
1924 backlog = somaxconn;
1925
1926 err = security_socket_listen(sock, backlog);
1927 if (!err)
1928 err = READ_ONCE(sock->ops)->listen(sock, backlog);
1929 return err;
1930}
1931
1932int __sys_listen(int fd, int backlog)
1933{
1934 CLASS(fd, f)(fd);
1935 struct socket *sock;
1936
1937 if (fd_empty(f))
1938 return -EBADF;
1939 sock = sock_from_file(fd_file(f));
1940 if (unlikely(!sock))
1941 return -ENOTSOCK;
1942
1943 return __sys_listen_socket(sock, backlog);
1944}
1945
1946SYSCALL_DEFINE2(listen, int, fd, int, backlog)
1947{
1948 return __sys_listen(fd, backlog);
1949}
1950
1951struct file *do_accept(struct file *file, struct proto_accept_arg *arg,
1952 struct sockaddr __user *upeer_sockaddr,
1953 int __user *upeer_addrlen, int flags)
1954{
1955 struct socket *sock, *newsock;
1956 struct file *newfile;
1957 int err, len;
1958 struct sockaddr_storage address;
1959 const struct proto_ops *ops;
1960
1961 sock = sock_from_file(file);
1962 if (!sock)
1963 return ERR_PTR(error: -ENOTSOCK);
1964
1965 newsock = sock_alloc();
1966 if (!newsock)
1967 return ERR_PTR(error: -ENFILE);
1968 ops = READ_ONCE(sock->ops);
1969
1970 newsock->type = sock->type;
1971 newsock->ops = ops;
1972
1973 /*
1974 * We don't need try_module_get here, as the listening socket (sock)
1975 * has the protocol module (sock->ops->owner) held.
1976 */
1977 __module_get(module: ops->owner);
1978
1979 newfile = sock_alloc_file(newsock, flags, sock->sk->sk_prot_creator->name);
1980 if (IS_ERR(ptr: newfile))
1981 return newfile;
1982
1983 err = security_socket_accept(sock, newsock);
1984 if (err)
1985 goto out_fd;
1986
1987 arg->flags |= sock->file->f_flags;
1988 err = ops->accept(sock, newsock, arg);
1989 if (err < 0)
1990 goto out_fd;
1991
1992 if (upeer_sockaddr) {
1993 len = ops->getname(newsock, (struct sockaddr *)&address, 2);
1994 if (len < 0) {
1995 err = -ECONNABORTED;
1996 goto out_fd;
1997 }
1998 err = move_addr_to_user(kaddr: &address,
1999 klen: len, uaddr: upeer_sockaddr, ulen: upeer_addrlen);
2000 if (err < 0)
2001 goto out_fd;
2002 }
2003
2004 /* File flags are not inherited via accept() unlike another OSes. */
2005 return newfile;
2006out_fd:
2007 fput(newfile);
2008 return ERR_PTR(error: err);
2009}
2010
2011static int __sys_accept4_file(struct file *file, struct sockaddr __user *upeer_sockaddr,
2012 int __user *upeer_addrlen, int flags)
2013{
2014 struct proto_accept_arg arg = { };
2015
2016 if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
2017 return -EINVAL;
2018
2019 if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
2020 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
2021
2022 return FD_ADD(flags, do_accept(file, &arg, upeer_sockaddr, upeer_addrlen, flags));
2023}
2024
2025/*
2026 * For accept, we attempt to create a new socket, set up the link
2027 * with the client, wake up the client, then return the new
2028 * connected fd. We collect the address of the connector in kernel
2029 * space and move it to user at the very end. This is unclean because
2030 * we open the socket then return an error.
2031 *
2032 * 1003.1g adds the ability to recvmsg() to query connection pending
2033 * status to recvmsg. We need to add that support in a way thats
2034 * clean when we restructure accept also.
2035 */
2036
2037int __sys_accept4(int fd, struct sockaddr __user *upeer_sockaddr,
2038 int __user *upeer_addrlen, int flags)
2039{
2040 CLASS(fd, f)(fd);
2041
2042 if (fd_empty(f))
2043 return -EBADF;
2044 return __sys_accept4_file(fd_file(f), upeer_sockaddr,
2045 upeer_addrlen, flags);
2046}
2047
2048SYSCALL_DEFINE4(accept4, int, fd, struct sockaddr __user *, upeer_sockaddr,
2049 int __user *, upeer_addrlen, int, flags)
2050{
2051 return __sys_accept4(fd, upeer_sockaddr, upeer_addrlen, flags);
2052}
2053
2054You are visitor 01402503 — GeezerVison does not store the pages you look up.
Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required.