vmci: propagate msghdr all way down to __qp_memcpy_from_queue()
[linux-2.6-block.git] / net / socket.c
CommitLineData
1da177e4
LT
1/*
2 * NET An implementation of the SOCKET network access protocol.
3 *
4 * Version: @(#)socket.c 1.1.93 18/02/95
5 *
6 * Authors: Orest Zborowski, <obz@Kodak.COM>
02c30a84 7 * Ross Biro
1da177e4
LT
8 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
9 *
10 * Fixes:
11 * Anonymous : NOTSOCK/BADF cleanup. Error fix in
12 * shutdown()
13 * Alan Cox : verify_area() fixes
14 * Alan Cox : Removed DDI
15 * Jonathan Kamens : SOCK_DGRAM reconnect bug
16 * Alan Cox : Moved a load of checks to the very
17 * top level.
18 * Alan Cox : Move address structures to/from user
19 * mode above the protocol layers.
20 * Rob Janssen : Allow 0 length sends.
21 * Alan Cox : Asynchronous I/O support (cribbed from the
22 * tty drivers).
23 * Niibe Yutaka : Asynchronous I/O for writes (4.4BSD style)
24 * Jeff Uphoff : Made max number of sockets command-line
25 * configurable.
26 * Matti Aarnio : Made the number of sockets dynamic,
27 * to be allocated when needed, and mr.
28 * Uphoff's max is used as max to be
29 * allowed to allocate.
30 * Linus : Argh. removed all the socket allocation
31 * altogether: it's in the inode now.
32 * Alan Cox : Made sock_alloc()/sock_release() public
33 * for NetROM and future kernel nfsd type
34 * stuff.
35 * Alan Cox : sendmsg/recvmsg basics.
36 * Tom Dyas : Export net symbols.
37 * Marcin Dalecki : Fixed problems with CONFIG_NET="n".
38 * Alan Cox : Added thread locking to sys_* calls
39 * for sockets. May have errors at the
40 * moment.
41 * Kevin Buhr : Fixed the dumb errors in the above.
42 * Andi Kleen : Some small cleanups, optimizations,
43 * and fixed a copy_from_user() bug.
44 * Tigran Aivazian : sys_send(args) calls sys_sendto(args, NULL, 0)
89bddce5 45 * Tigran Aivazian : Made listen(2) backlog sanity checks
1da177e4
LT
46 * protocol-independent
47 *
48 *
49 * This program is free software; you can redistribute it and/or
50 * modify it under the terms of the GNU General Public License
51 * as published by the Free Software Foundation; either version
52 * 2 of the License, or (at your option) any later version.
53 *
54 *
55 * This module is effectively the top level interface to the BSD socket
89bddce5 56 * paradigm.
1da177e4
LT
57 *
58 * Based upon Swansea University Computer Society NET3.039
59 */
60
1da177e4 61#include <linux/mm.h>
1da177e4
LT
62#include <linux/socket.h>
63#include <linux/file.h>
64#include <linux/net.h>
65#include <linux/interrupt.h>
aaca0bdc 66#include <linux/thread_info.h>
55737fda 67#include <linux/rcupdate.h>
1da177e4
LT
68#include <linux/netdevice.h>
69#include <linux/proc_fs.h>
70#include <linux/seq_file.h>
4a3e2f71 71#include <linux/mutex.h>
1da177e4 72#include <linux/if_bridge.h>
20380731
ACM
73#include <linux/if_frad.h>
74#include <linux/if_vlan.h>
408eccce 75#include <linux/ptp_classify.h>
1da177e4
LT
76#include <linux/init.h>
77#include <linux/poll.h>
78#include <linux/cache.h>
79#include <linux/module.h>
80#include <linux/highmem.h>
1da177e4
LT
81#include <linux/mount.h>
82#include <linux/security.h>
83#include <linux/syscalls.h>
84#include <linux/compat.h>
85#include <linux/kmod.h>
3ec3b2fb 86#include <linux/audit.h>
d86b5e0e 87#include <linux/wireless.h>
1b8d7ae4 88#include <linux/nsproxy.h>
1fd7317d 89#include <linux/magic.h>
5a0e3ad6 90#include <linux/slab.h>
600e1779 91#include <linux/xattr.h>
1da177e4
LT
92
93#include <asm/uaccess.h>
94#include <asm/unistd.h>
95
96#include <net/compat.h>
87de87d5 97#include <net/wext.h>
f8451725 98#include <net/cls_cgroup.h>
1da177e4
LT
99
100#include <net/sock.h>
101#include <linux/netfilter.h>
102
6b96018b
AB
103#include <linux/if_tun.h>
104#include <linux/ipv6_route.h>
105#include <linux/route.h>
6b96018b
AB
106#include <linux/sockios.h>
107#include <linux/atalk.h>
076bb0c8 108#include <net/busy_poll.h>
f24b9be5 109#include <linux/errqueue.h>
06021292 110
e0d1095a 111#ifdef CONFIG_NET_RX_BUSY_POLL
64b0dc51
ET
112unsigned int sysctl_net_busy_read __read_mostly;
113unsigned int sysctl_net_busy_poll __read_mostly;
06021292 114#endif
6b96018b 115
1da177e4 116static int sock_no_open(struct inode *irrelevant, struct file *dontcare);
027445c3
BP
117static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov,
118 unsigned long nr_segs, loff_t pos);
119static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov,
120 unsigned long nr_segs, loff_t pos);
89bddce5 121static int sock_mmap(struct file *file, struct vm_area_struct *vma);
1da177e4
LT
122
123static int sock_close(struct inode *inode, struct file *file);
124static unsigned int sock_poll(struct file *file,
125 struct poll_table_struct *wait);
89bddce5 126static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
89bbfc95
SP
127#ifdef CONFIG_COMPAT
128static long compat_sock_ioctl(struct file *file,
89bddce5 129 unsigned int cmd, unsigned long arg);
89bbfc95 130#endif
1da177e4 131static int sock_fasync(int fd, struct file *filp, int on);
1da177e4
LT
132static ssize_t sock_sendpage(struct file *file, struct page *page,
133 int offset, size_t size, loff_t *ppos, int more);
9c55e01c 134static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
c6d409cf 135 struct pipe_inode_info *pipe, size_t len,
9c55e01c 136 unsigned int flags);
1da177e4 137
1da177e4
LT
138/*
139 * Socket files have a set of 'special' operations as well as the generic file ones. These don't appear
140 * in the operation structures but are done directly via the socketcall() multiplexor.
141 */
142
da7071d7 143static const struct file_operations socket_file_ops = {
1da177e4
LT
144 .owner = THIS_MODULE,
145 .llseek = no_llseek,
146 .aio_read = sock_aio_read,
147 .aio_write = sock_aio_write,
148 .poll = sock_poll,
149 .unlocked_ioctl = sock_ioctl,
89bbfc95
SP
150#ifdef CONFIG_COMPAT
151 .compat_ioctl = compat_sock_ioctl,
152#endif
1da177e4
LT
153 .mmap = sock_mmap,
154 .open = sock_no_open, /* special open code to disallow open via /proc */
155 .release = sock_close,
156 .fasync = sock_fasync,
5274f052
JA
157 .sendpage = sock_sendpage,
158 .splice_write = generic_splice_sendpage,
9c55e01c 159 .splice_read = sock_splice_read,
1da177e4
LT
160};
161
162/*
163 * The protocol list. Each protocol is registered in here.
164 */
165
1da177e4 166static DEFINE_SPINLOCK(net_family_lock);
190683a9 167static const struct net_proto_family __rcu *net_families[NPROTO] __read_mostly;
1da177e4 168
1da177e4
LT
169/*
170 * Statistics counters of the socket lists
171 */
172
c6d409cf 173static DEFINE_PER_CPU(int, sockets_in_use);
1da177e4
LT
174
175/*
89bddce5
SH
176 * Support routines.
177 * Move socket addresses back and forth across the kernel/user
178 * divide and look after the messy bits.
1da177e4
LT
179 */
180
1da177e4
LT
181/**
182 * move_addr_to_kernel - copy a socket address into kernel space
183 * @uaddr: Address in user space
184 * @kaddr: Address in kernel space
185 * @ulen: Length in user space
186 *
187 * The address is copied into kernel space. If the provided address is
188 * too long an error code of -EINVAL is returned. If the copy gives
189 * invalid addresses -EFAULT is returned. On a success 0 is returned.
190 */
191
43db362d 192int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr_storage *kaddr)
1da177e4 193{
230b1839 194 if (ulen < 0 || ulen > sizeof(struct sockaddr_storage))
1da177e4 195 return -EINVAL;
89bddce5 196 if (ulen == 0)
1da177e4 197 return 0;
89bddce5 198 if (copy_from_user(kaddr, uaddr, ulen))
1da177e4 199 return -EFAULT;
3ec3b2fb 200 return audit_sockaddr(ulen, kaddr);
1da177e4
LT
201}
202
203/**
204 * move_addr_to_user - copy an address to user space
205 * @kaddr: kernel space address
206 * @klen: length of address in kernel
207 * @uaddr: user space address
208 * @ulen: pointer to user length field
209 *
210 * The value pointed to by ulen on entry is the buffer length available.
211 * This is overwritten with the buffer space used. -EINVAL is returned
212 * if an overlong buffer is specified or a negative buffer size. -EFAULT
213 * is returned if either the buffer or the length field are not
214 * accessible.
215 * After copying the data up to the limit the user specifies, the true
216 * length of the data is written over the length limit the user
217 * specified. Zero is returned for a success.
218 */
89bddce5 219
43db362d 220static int move_addr_to_user(struct sockaddr_storage *kaddr, int klen,
11165f14 221 void __user *uaddr, int __user *ulen)
1da177e4
LT
222{
223 int err;
224 int len;
225
68c6beb3 226 BUG_ON(klen > sizeof(struct sockaddr_storage));
89bddce5
SH
227 err = get_user(len, ulen);
228 if (err)
1da177e4 229 return err;
89bddce5
SH
230 if (len > klen)
231 len = klen;
68c6beb3 232 if (len < 0)
1da177e4 233 return -EINVAL;
89bddce5 234 if (len) {
d6fe3945
SG
235 if (audit_sockaddr(klen, kaddr))
236 return -ENOMEM;
89bddce5 237 if (copy_to_user(uaddr, kaddr, len))
1da177e4
LT
238 return -EFAULT;
239 }
240 /*
89bddce5
SH
241 * "fromlen shall refer to the value before truncation.."
242 * 1003.1g
1da177e4
LT
243 */
244 return __put_user(klen, ulen);
245}
246
e18b890b 247static struct kmem_cache *sock_inode_cachep __read_mostly;
1da177e4
LT
248
249static struct inode *sock_alloc_inode(struct super_block *sb)
250{
251 struct socket_alloc *ei;
eaefd110 252 struct socket_wq *wq;
89bddce5 253
e94b1766 254 ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL);
1da177e4
LT
255 if (!ei)
256 return NULL;
eaefd110
ED
257 wq = kmalloc(sizeof(*wq), GFP_KERNEL);
258 if (!wq) {
43815482
ED
259 kmem_cache_free(sock_inode_cachep, ei);
260 return NULL;
261 }
eaefd110
ED
262 init_waitqueue_head(&wq->wait);
263 wq->fasync_list = NULL;
264 RCU_INIT_POINTER(ei->socket.wq, wq);
89bddce5 265
1da177e4
LT
266 ei->socket.state = SS_UNCONNECTED;
267 ei->socket.flags = 0;
268 ei->socket.ops = NULL;
269 ei->socket.sk = NULL;
270 ei->socket.file = NULL;
1da177e4
LT
271
272 return &ei->vfs_inode;
273}
274
275static void sock_destroy_inode(struct inode *inode)
276{
43815482 277 struct socket_alloc *ei;
eaefd110 278 struct socket_wq *wq;
43815482
ED
279
280 ei = container_of(inode, struct socket_alloc, vfs_inode);
eaefd110 281 wq = rcu_dereference_protected(ei->socket.wq, 1);
61845220 282 kfree_rcu(wq, rcu);
43815482 283 kmem_cache_free(sock_inode_cachep, ei);
1da177e4
LT
284}
285
51cc5068 286static void init_once(void *foo)
1da177e4 287{
89bddce5 288 struct socket_alloc *ei = (struct socket_alloc *)foo;
1da177e4 289
a35afb83 290 inode_init_once(&ei->vfs_inode);
1da177e4 291}
89bddce5 292
1da177e4
LT
293static int init_inodecache(void)
294{
295 sock_inode_cachep = kmem_cache_create("sock_inode_cache",
89bddce5
SH
296 sizeof(struct socket_alloc),
297 0,
298 (SLAB_HWCACHE_ALIGN |
299 SLAB_RECLAIM_ACCOUNT |
300 SLAB_MEM_SPREAD),
20c2df83 301 init_once);
1da177e4
LT
302 if (sock_inode_cachep == NULL)
303 return -ENOMEM;
304 return 0;
305}
306
b87221de 307static const struct super_operations sockfs_ops = {
c6d409cf
ED
308 .alloc_inode = sock_alloc_inode,
309 .destroy_inode = sock_destroy_inode,
310 .statfs = simple_statfs,
1da177e4
LT
311};
312
c23fbb6b
ED
313/*
314 * sockfs_dname() is called from d_path().
315 */
316static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen)
317{
318 return dynamic_dname(dentry, buffer, buflen, "socket:[%lu]",
319 dentry->d_inode->i_ino);
320}
321
3ba13d17 322static const struct dentry_operations sockfs_dentry_operations = {
c23fbb6b 323 .d_dname = sockfs_dname,
1da177e4
LT
324};
325
c74a1cbb
AV
326static struct dentry *sockfs_mount(struct file_system_type *fs_type,
327 int flags, const char *dev_name, void *data)
328{
329 return mount_pseudo(fs_type, "socket:", &sockfs_ops,
330 &sockfs_dentry_operations, SOCKFS_MAGIC);
331}
332
333static struct vfsmount *sock_mnt __read_mostly;
334
335static struct file_system_type sock_fs_type = {
336 .name = "sockfs",
337 .mount = sockfs_mount,
338 .kill_sb = kill_anon_super,
339};
340
1da177e4
LT
341/*
342 * Obtains the first available file descriptor and sets it up for use.
343 *
39d8c1b6
DM
344 * These functions create file structures and maps them to fd space
345 * of the current process. On success it returns file descriptor
1da177e4
LT
346 * and file struct implicitly stored in sock->file.
347 * Note that another thread may close file descriptor before we return
348 * from this function. We use the fact that now we do not refer
349 * to socket after mapping. If one day we will need it, this
350 * function will increment ref. count on file by 1.
351 *
352 * In any case returned fd MAY BE not valid!
353 * This race condition is unavoidable
354 * with shared fd spaces, we cannot solve it inside kernel,
355 * but we take care of internal coherence yet.
356 */
357
aab174f0 358struct file *sock_alloc_file(struct socket *sock, int flags, const char *dname)
1da177e4 359{
7cbe66b6 360 struct qstr name = { .name = "" };
2c48b9c4 361 struct path path;
7cbe66b6 362 struct file *file;
1da177e4 363
600e1779
MY
364 if (dname) {
365 name.name = dname;
366 name.len = strlen(name.name);
367 } else if (sock->sk) {
368 name.name = sock->sk->sk_prot_creator->name;
369 name.len = strlen(name.name);
370 }
4b936885 371 path.dentry = d_alloc_pseudo(sock_mnt->mnt_sb, &name);
28407630
AV
372 if (unlikely(!path.dentry))
373 return ERR_PTR(-ENOMEM);
2c48b9c4 374 path.mnt = mntget(sock_mnt);
39d8c1b6 375
2c48b9c4 376 d_instantiate(path.dentry, SOCK_INODE(sock));
cc3808f8 377 SOCK_INODE(sock)->i_fop = &socket_file_ops;
39d8c1b6 378
2c48b9c4 379 file = alloc_file(&path, FMODE_READ | FMODE_WRITE,
ce8d2cdf 380 &socket_file_ops);
39b65252 381 if (unlikely(IS_ERR(file))) {
cc3808f8 382 /* drop dentry, keep inode */
7de9c6ee 383 ihold(path.dentry->d_inode);
2c48b9c4 384 path_put(&path);
39b65252 385 return file;
cc3808f8
AV
386 }
387
388 sock->file = file;
77d27200 389 file->f_flags = O_RDWR | (flags & O_NONBLOCK);
39d8c1b6 390 file->private_data = sock;
28407630 391 return file;
39d8c1b6 392}
56b31d1c 393EXPORT_SYMBOL(sock_alloc_file);
39d8c1b6 394
56b31d1c 395static int sock_map_fd(struct socket *sock, int flags)
39d8c1b6
DM
396{
397 struct file *newfile;
28407630
AV
398 int fd = get_unused_fd_flags(flags);
399 if (unlikely(fd < 0))
400 return fd;
39d8c1b6 401
aab174f0 402 newfile = sock_alloc_file(sock, flags, NULL);
28407630 403 if (likely(!IS_ERR(newfile))) {
39d8c1b6 404 fd_install(fd, newfile);
28407630
AV
405 return fd;
406 }
7cbe66b6 407
28407630
AV
408 put_unused_fd(fd);
409 return PTR_ERR(newfile);
1da177e4
LT
410}
411
406a3c63 412struct socket *sock_from_file(struct file *file, int *err)
6cb153ca 413{
6cb153ca
BL
414 if (file->f_op == &socket_file_ops)
415 return file->private_data; /* set in sock_map_fd */
416
23bb80d2
ED
417 *err = -ENOTSOCK;
418 return NULL;
6cb153ca 419}
406a3c63 420EXPORT_SYMBOL(sock_from_file);
6cb153ca 421
1da177e4 422/**
c6d409cf 423 * sockfd_lookup - Go from a file number to its socket slot
1da177e4
LT
424 * @fd: file handle
425 * @err: pointer to an error code return
426 *
427 * The file handle passed in is locked and the socket it is bound
428 * too is returned. If an error occurs the err pointer is overwritten
429 * with a negative errno code and NULL is returned. The function checks
430 * for both invalid handles and passing a handle which is not a socket.
431 *
432 * On a success the socket object pointer is returned.
433 */
434
435struct socket *sockfd_lookup(int fd, int *err)
436{
437 struct file *file;
1da177e4
LT
438 struct socket *sock;
439
89bddce5
SH
440 file = fget(fd);
441 if (!file) {
1da177e4
LT
442 *err = -EBADF;
443 return NULL;
444 }
89bddce5 445
6cb153ca
BL
446 sock = sock_from_file(file, err);
447 if (!sock)
1da177e4 448 fput(file);
6cb153ca
BL
449 return sock;
450}
c6d409cf 451EXPORT_SYMBOL(sockfd_lookup);
1da177e4 452
6cb153ca
BL
453static struct socket *sockfd_lookup_light(int fd, int *err, int *fput_needed)
454{
00e188ef 455 struct fd f = fdget(fd);
6cb153ca
BL
456 struct socket *sock;
457
3672558c 458 *err = -EBADF;
00e188ef
AV
459 if (f.file) {
460 sock = sock_from_file(f.file, err);
461 if (likely(sock)) {
462 *fput_needed = f.flags;
6cb153ca 463 return sock;
00e188ef
AV
464 }
465 fdput(f);
1da177e4 466 }
6cb153ca 467 return NULL;
1da177e4
LT
468}
469
600e1779
MY
470#define XATTR_SOCKPROTONAME_SUFFIX "sockprotoname"
471#define XATTR_NAME_SOCKPROTONAME (XATTR_SYSTEM_PREFIX XATTR_SOCKPROTONAME_SUFFIX)
472#define XATTR_NAME_SOCKPROTONAME_LEN (sizeof(XATTR_NAME_SOCKPROTONAME)-1)
473static ssize_t sockfs_getxattr(struct dentry *dentry,
474 const char *name, void *value, size_t size)
475{
476 const char *proto_name;
477 size_t proto_size;
478 int error;
479
480 error = -ENODATA;
481 if (!strncmp(name, XATTR_NAME_SOCKPROTONAME, XATTR_NAME_SOCKPROTONAME_LEN)) {
482 proto_name = dentry->d_name.name;
483 proto_size = strlen(proto_name);
484
485 if (value) {
486 error = -ERANGE;
487 if (proto_size + 1 > size)
488 goto out;
489
490 strncpy(value, proto_name, proto_size + 1);
491 }
492 error = proto_size + 1;
493 }
494
495out:
496 return error;
497}
498
499static ssize_t sockfs_listxattr(struct dentry *dentry, char *buffer,
500 size_t size)
501{
502 ssize_t len;
503 ssize_t used = 0;
504
505 len = security_inode_listsecurity(dentry->d_inode, buffer, size);
506 if (len < 0)
507 return len;
508 used += len;
509 if (buffer) {
510 if (size < used)
511 return -ERANGE;
512 buffer += len;
513 }
514
515 len = (XATTR_NAME_SOCKPROTONAME_LEN + 1);
516 used += len;
517 if (buffer) {
518 if (size < used)
519 return -ERANGE;
520 memcpy(buffer, XATTR_NAME_SOCKPROTONAME, len);
521 buffer += len;
522 }
523
524 return used;
525}
526
527static const struct inode_operations sockfs_inode_ops = {
528 .getxattr = sockfs_getxattr,
529 .listxattr = sockfs_listxattr,
530};
531
1da177e4
LT
532/**
533 * sock_alloc - allocate a socket
89bddce5 534 *
1da177e4
LT
535 * Allocate a new inode and socket object. The two are bound together
536 * and initialised. The socket is then returned. If we are out of inodes
537 * NULL is returned.
538 */
539
540static struct socket *sock_alloc(void)
541{
89bddce5
SH
542 struct inode *inode;
543 struct socket *sock;
1da177e4 544
a209dfc7 545 inode = new_inode_pseudo(sock_mnt->mnt_sb);
1da177e4
LT
546 if (!inode)
547 return NULL;
548
549 sock = SOCKET_I(inode);
550
29a020d3 551 kmemcheck_annotate_bitfield(sock, type);
85fe4025 552 inode->i_ino = get_next_ino();
89bddce5 553 inode->i_mode = S_IFSOCK | S_IRWXUGO;
8192b0c4
DH
554 inode->i_uid = current_fsuid();
555 inode->i_gid = current_fsgid();
600e1779 556 inode->i_op = &sockfs_inode_ops;
1da177e4 557
19e8d69c 558 this_cpu_add(sockets_in_use, 1);
1da177e4
LT
559 return sock;
560}
561
562/*
563 * In theory you can't get an open on this inode, but /proc provides
564 * a back door. Remember to keep it shut otherwise you'll let the
565 * creepy crawlies in.
566 */
89bddce5 567
1da177e4
LT
568static int sock_no_open(struct inode *irrelevant, struct file *dontcare)
569{
570 return -ENXIO;
571}
572
4b6f5d20 573const struct file_operations bad_sock_fops = {
1da177e4
LT
574 .owner = THIS_MODULE,
575 .open = sock_no_open,
6038f373 576 .llseek = noop_llseek,
1da177e4
LT
577};
578
579/**
580 * sock_release - close a socket
581 * @sock: socket to close
582 *
583 * The socket is released from the protocol stack if it has a release
584 * callback, and the inode is then released if the socket is bound to
89bddce5 585 * an inode not a file.
1da177e4 586 */
89bddce5 587
1da177e4
LT
588void sock_release(struct socket *sock)
589{
590 if (sock->ops) {
591 struct module *owner = sock->ops->owner;
592
593 sock->ops->release(sock);
594 sock->ops = NULL;
595 module_put(owner);
596 }
597
eaefd110 598 if (rcu_dereference_protected(sock->wq, 1)->fasync_list)
3410f22e 599 pr_err("%s: fasync list not empty!\n", __func__);
1da177e4 600
b09e786b
MP
601 if (test_bit(SOCK_EXTERNALLY_ALLOCATED, &sock->flags))
602 return;
603
19e8d69c 604 this_cpu_sub(sockets_in_use, 1);
1da177e4
LT
605 if (!sock->file) {
606 iput(SOCK_INODE(sock));
607 return;
608 }
89bddce5 609 sock->file = NULL;
1da177e4 610}
c6d409cf 611EXPORT_SYMBOL(sock_release);
1da177e4 612
67cc0d40 613void __sock_tx_timestamp(const struct sock *sk, __u8 *tx_flags)
20d49473 614{
140c55d4
ED
615 u8 flags = *tx_flags;
616
b9f40e21 617 if (sk->sk_tsflags & SOF_TIMESTAMPING_TX_HARDWARE)
140c55d4
ED
618 flags |= SKBTX_HW_TSTAMP;
619
b9f40e21 620 if (sk->sk_tsflags & SOF_TIMESTAMPING_TX_SOFTWARE)
140c55d4
ED
621 flags |= SKBTX_SW_TSTAMP;
622
e7fd2885 623 if (sk->sk_tsflags & SOF_TIMESTAMPING_TX_SCHED)
140c55d4
ED
624 flags |= SKBTX_SCHED_TSTAMP;
625
e1c8a607 626 if (sk->sk_tsflags & SOF_TIMESTAMPING_TX_ACK)
140c55d4 627 flags |= SKBTX_ACK_TSTAMP;
e7fd2885 628
140c55d4 629 *tx_flags = flags;
20d49473 630}
67cc0d40 631EXPORT_SYMBOL(__sock_tx_timestamp);
20d49473 632
228e548e
AB
633static inline int __sock_sendmsg_nosec(struct kiocb *iocb, struct socket *sock,
634 struct msghdr *msg, size_t size)
1da177e4
LT
635{
636 struct sock_iocb *si = kiocb_to_siocb(iocb);
1da177e4
LT
637
638 si->sock = sock;
639 si->scm = NULL;
640 si->msg = msg;
641 si->size = size;
642
1da177e4
LT
643 return sock->ops->sendmsg(iocb, sock, msg, size);
644}
645
228e548e
AB
646static inline int __sock_sendmsg(struct kiocb *iocb, struct socket *sock,
647 struct msghdr *msg, size_t size)
648{
649 int err = security_socket_sendmsg(sock, msg, size);
650
651 return err ?: __sock_sendmsg_nosec(iocb, sock, msg, size);
652}
653
0cf00c6f
GZ
654static int do_sock_sendmsg(struct socket *sock, struct msghdr *msg,
655 size_t size, bool nosec)
1da177e4
LT
656{
657 struct kiocb iocb;
658 struct sock_iocb siocb;
659 int ret;
660
661 init_sync_kiocb(&iocb, NULL);
662 iocb.private = &siocb;
0cf00c6f
GZ
663 ret = nosec ? __sock_sendmsg_nosec(&iocb, sock, msg, size) :
664 __sock_sendmsg(&iocb, sock, msg, size);
1da177e4
LT
665 if (-EIOCBQUEUED == ret)
666 ret = wait_on_sync_kiocb(&iocb);
667 return ret;
668}
0cf00c6f
GZ
669
670int sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
671{
672 return do_sock_sendmsg(sock, msg, size, false);
673}
c6d409cf 674EXPORT_SYMBOL(sock_sendmsg);
1da177e4 675
894dc24c 676static int sock_sendmsg_nosec(struct socket *sock, struct msghdr *msg, size_t size)
228e548e 677{
0cf00c6f 678 return do_sock_sendmsg(sock, msg, size, true);
228e548e
AB
679}
680
1da177e4
LT
681int kernel_sendmsg(struct socket *sock, struct msghdr *msg,
682 struct kvec *vec, size_t num, size_t size)
683{
684 mm_segment_t oldfs = get_fs();
685 int result;
686
687 set_fs(KERNEL_DS);
688 /*
689 * the following is safe, since for compiler definitions of kvec and
690 * iovec are identical, yielding the same in-core layout and alignment
691 */
89bddce5 692 msg->msg_iov = (struct iovec *)vec;
1da177e4
LT
693 msg->msg_iovlen = num;
694 result = sock_sendmsg(sock, msg, size);
695 set_fs(oldfs);
696 return result;
697}
c6d409cf 698EXPORT_SYMBOL(kernel_sendmsg);
1da177e4 699
92f37fd2
ED
700/*
701 * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
702 */
703void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
704 struct sk_buff *skb)
705{
20d49473 706 int need_software_tstamp = sock_flag(sk, SOCK_RCVTSTAMP);
f24b9be5 707 struct scm_timestamping tss;
20d49473
PO
708 int empty = 1;
709 struct skb_shared_hwtstamps *shhwtstamps =
710 skb_hwtstamps(skb);
711
712 /* Race occurred between timestamp enabling and packet
713 receiving. Fill in the current time for now. */
714 if (need_software_tstamp && skb->tstamp.tv64 == 0)
715 __net_timestamp(skb);
716
717 if (need_software_tstamp) {
718 if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
719 struct timeval tv;
720 skb_get_timestamp(skb, &tv);
721 put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP,
722 sizeof(tv), &tv);
723 } else {
f24b9be5
WB
724 struct timespec ts;
725 skb_get_timestampns(skb, &ts);
20d49473 726 put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS,
f24b9be5 727 sizeof(ts), &ts);
20d49473
PO
728 }
729 }
730
f24b9be5 731 memset(&tss, 0, sizeof(tss));
c199105d 732 if ((sk->sk_tsflags & SOF_TIMESTAMPING_SOFTWARE) &&
f24b9be5 733 ktime_to_timespec_cond(skb->tstamp, tss.ts + 0))
20d49473 734 empty = 0;
4d276eb6 735 if (shhwtstamps &&
b9f40e21 736 (sk->sk_tsflags & SOF_TIMESTAMPING_RAW_HARDWARE) &&
f24b9be5 737 ktime_to_timespec_cond(shhwtstamps->hwtstamp, tss.ts + 2))
4d276eb6 738 empty = 0;
20d49473
PO
739 if (!empty)
740 put_cmsg(msg, SOL_SOCKET,
f24b9be5 741 SCM_TIMESTAMPING, sizeof(tss), &tss);
92f37fd2 742}
7c81fd8b
ACM
743EXPORT_SYMBOL_GPL(__sock_recv_timestamp);
744
6e3e939f
JB
745void __sock_recv_wifi_status(struct msghdr *msg, struct sock *sk,
746 struct sk_buff *skb)
747{
748 int ack;
749
750 if (!sock_flag(sk, SOCK_WIFI_STATUS))
751 return;
752 if (!skb->wifi_acked_valid)
753 return;
754
755 ack = skb->wifi_acked;
756
757 put_cmsg(msg, SOL_SOCKET, SCM_WIFI_STATUS, sizeof(ack), &ack);
758}
759EXPORT_SYMBOL_GPL(__sock_recv_wifi_status);
760
11165f14 761static inline void sock_recv_drops(struct msghdr *msg, struct sock *sk,
762 struct sk_buff *skb)
3b885787
NH
763{
764 if (sock_flag(sk, SOCK_RXQ_OVFL) && skb && skb->dropcount)
765 put_cmsg(msg, SOL_SOCKET, SO_RXQ_OVFL,
766 sizeof(__u32), &skb->dropcount);
767}
768
767dd033 769void __sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
3b885787
NH
770 struct sk_buff *skb)
771{
772 sock_recv_timestamp(msg, sk, skb);
773 sock_recv_drops(msg, sk, skb);
774}
767dd033 775EXPORT_SYMBOL_GPL(__sock_recv_ts_and_drops);
3b885787 776
a2e27255
ACM
777static inline int __sock_recvmsg_nosec(struct kiocb *iocb, struct socket *sock,
778 struct msghdr *msg, size_t size, int flags)
1da177e4 779{
1da177e4
LT
780 struct sock_iocb *si = kiocb_to_siocb(iocb);
781
782 si->sock = sock;
783 si->scm = NULL;
784 si->msg = msg;
785 si->size = size;
786 si->flags = flags;
787
1da177e4
LT
788 return sock->ops->recvmsg(iocb, sock, msg, size, flags);
789}
790
a2e27255
ACM
791static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock,
792 struct msghdr *msg, size_t size, int flags)
793{
794 int err = security_socket_recvmsg(sock, msg, size, flags);
795
796 return err ?: __sock_recvmsg_nosec(iocb, sock, msg, size, flags);
797}
798
89bddce5 799int sock_recvmsg(struct socket *sock, struct msghdr *msg,
1da177e4
LT
800 size_t size, int flags)
801{
802 struct kiocb iocb;
803 struct sock_iocb siocb;
804 int ret;
805
89bddce5 806 init_sync_kiocb(&iocb, NULL);
1da177e4
LT
807 iocb.private = &siocb;
808 ret = __sock_recvmsg(&iocb, sock, msg, size, flags);
809 if (-EIOCBQUEUED == ret)
810 ret = wait_on_sync_kiocb(&iocb);
811 return ret;
812}
c6d409cf 813EXPORT_SYMBOL(sock_recvmsg);
1da177e4 814
a2e27255
ACM
815static int sock_recvmsg_nosec(struct socket *sock, struct msghdr *msg,
816 size_t size, int flags)
817{
818 struct kiocb iocb;
819 struct sock_iocb siocb;
820 int ret;
821
822 init_sync_kiocb(&iocb, NULL);
823 iocb.private = &siocb;
824 ret = __sock_recvmsg_nosec(&iocb, sock, msg, size, flags);
825 if (-EIOCBQUEUED == ret)
826 ret = wait_on_sync_kiocb(&iocb);
827 return ret;
828}
829
c1249c0a
ML
830/**
831 * kernel_recvmsg - Receive a message from a socket (kernel space)
832 * @sock: The socket to receive the message from
833 * @msg: Received message
834 * @vec: Input s/g array for message data
835 * @num: Size of input s/g array
836 * @size: Number of bytes to read
837 * @flags: Message flags (MSG_DONTWAIT, etc...)
838 *
839 * On return the msg structure contains the scatter/gather array passed in the
840 * vec argument. The array is modified so that it consists of the unfilled
841 * portion of the original array.
842 *
843 * The returned value is the total number of bytes received, or an error.
844 */
89bddce5
SH
845int kernel_recvmsg(struct socket *sock, struct msghdr *msg,
846 struct kvec *vec, size_t num, size_t size, int flags)
1da177e4
LT
847{
848 mm_segment_t oldfs = get_fs();
849 int result;
850
851 set_fs(KERNEL_DS);
852 /*
853 * the following is safe, since for compiler definitions of kvec and
854 * iovec are identical, yielding the same in-core layout and alignment
855 */
89bddce5 856 msg->msg_iov = (struct iovec *)vec, msg->msg_iovlen = num;
1da177e4
LT
857 result = sock_recvmsg(sock, msg, size, flags);
858 set_fs(oldfs);
859 return result;
860}
c6d409cf 861EXPORT_SYMBOL(kernel_recvmsg);
1da177e4 862
ce1d4d3e
CH
863static ssize_t sock_sendpage(struct file *file, struct page *page,
864 int offset, size_t size, loff_t *ppos, int more)
1da177e4 865{
1da177e4
LT
866 struct socket *sock;
867 int flags;
868
ce1d4d3e
CH
869 sock = file->private_data;
870
35f9c09f
ED
871 flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
872 /* more is a combination of MSG_MORE and MSG_SENDPAGE_NOTLAST */
873 flags |= more;
ce1d4d3e 874
e6949583 875 return kernel_sendpage(sock, page, offset, size, flags);
ce1d4d3e 876}
1da177e4 877
9c55e01c 878static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
c6d409cf 879 struct pipe_inode_info *pipe, size_t len,
9c55e01c
JA
880 unsigned int flags)
881{
882 struct socket *sock = file->private_data;
883
997b37da
RDC
884 if (unlikely(!sock->ops->splice_read))
885 return -EINVAL;
886
9c55e01c
JA
887 return sock->ops->splice_read(sock, ppos, pipe, len, flags);
888}
889
ce1d4d3e 890static struct sock_iocb *alloc_sock_iocb(struct kiocb *iocb,
89bddce5 891 struct sock_iocb *siocb)
ce1d4d3e 892{
d29c445b
KO
893 if (!is_sync_kiocb(iocb))
894 BUG();
1da177e4 895
ce1d4d3e 896 siocb->kiocb = iocb;
ce1d4d3e
CH
897 iocb->private = siocb;
898 return siocb;
1da177e4
LT
899}
900
ce1d4d3e 901static ssize_t do_sock_read(struct msghdr *msg, struct kiocb *iocb,
027445c3
BP
902 struct file *file, const struct iovec *iov,
903 unsigned long nr_segs)
ce1d4d3e
CH
904{
905 struct socket *sock = file->private_data;
906 size_t size = 0;
907 int i;
1da177e4 908
89bddce5
SH
909 for (i = 0; i < nr_segs; i++)
910 size += iov[i].iov_len;
1da177e4 911
ce1d4d3e
CH
912 msg->msg_name = NULL;
913 msg->msg_namelen = 0;
914 msg->msg_control = NULL;
915 msg->msg_controllen = 0;
89bddce5 916 msg->msg_iov = (struct iovec *)iov;
ce1d4d3e
CH
917 msg->msg_iovlen = nr_segs;
918 msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
919
920 return __sock_recvmsg(iocb, sock, msg, size, msg->msg_flags);
921}
922
027445c3
BP
923static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov,
924 unsigned long nr_segs, loff_t pos)
ce1d4d3e
CH
925{
926 struct sock_iocb siocb, *x;
927
1da177e4
LT
928 if (pos != 0)
929 return -ESPIPE;
027445c3 930
73a7075e 931 if (iocb->ki_nbytes == 0) /* Match SYS5 behaviour */
1da177e4
LT
932 return 0;
933
027445c3
BP
934
935 x = alloc_sock_iocb(iocb, &siocb);
ce1d4d3e
CH
936 if (!x)
937 return -ENOMEM;
027445c3 938 return do_sock_read(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs);
1da177e4
LT
939}
940
ce1d4d3e 941static ssize_t do_sock_write(struct msghdr *msg, struct kiocb *iocb,
027445c3
BP
942 struct file *file, const struct iovec *iov,
943 unsigned long nr_segs)
1da177e4 944{
ce1d4d3e
CH
945 struct socket *sock = file->private_data;
946 size_t size = 0;
947 int i;
1da177e4 948
89bddce5
SH
949 for (i = 0; i < nr_segs; i++)
950 size += iov[i].iov_len;
1da177e4 951
ce1d4d3e
CH
952 msg->msg_name = NULL;
953 msg->msg_namelen = 0;
954 msg->msg_control = NULL;
955 msg->msg_controllen = 0;
89bddce5 956 msg->msg_iov = (struct iovec *)iov;
ce1d4d3e
CH
957 msg->msg_iovlen = nr_segs;
958 msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
959 if (sock->type == SOCK_SEQPACKET)
960 msg->msg_flags |= MSG_EOR;
1da177e4 961
ce1d4d3e 962 return __sock_sendmsg(iocb, sock, msg, size);
1da177e4
LT
963}
964
027445c3
BP
965static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov,
966 unsigned long nr_segs, loff_t pos)
ce1d4d3e
CH
967{
968 struct sock_iocb siocb, *x;
1da177e4 969
ce1d4d3e
CH
970 if (pos != 0)
971 return -ESPIPE;
027445c3 972
027445c3 973 x = alloc_sock_iocb(iocb, &siocb);
ce1d4d3e
CH
974 if (!x)
975 return -ENOMEM;
1da177e4 976
027445c3 977 return do_sock_write(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs);
1da177e4
LT
978}
979
1da177e4
LT
980/*
981 * Atomic setting of ioctl hooks to avoid race
982 * with module unload.
983 */
984
4a3e2f71 985static DEFINE_MUTEX(br_ioctl_mutex);
c6d409cf 986static int (*br_ioctl_hook) (struct net *, unsigned int cmd, void __user *arg);
1da177e4 987
881d966b 988void brioctl_set(int (*hook) (struct net *, unsigned int, void __user *))
1da177e4 989{
4a3e2f71 990 mutex_lock(&br_ioctl_mutex);
1da177e4 991 br_ioctl_hook = hook;
4a3e2f71 992 mutex_unlock(&br_ioctl_mutex);
1da177e4
LT
993}
994EXPORT_SYMBOL(brioctl_set);
995
4a3e2f71 996static DEFINE_MUTEX(vlan_ioctl_mutex);
881d966b 997static int (*vlan_ioctl_hook) (struct net *, void __user *arg);
1da177e4 998
881d966b 999void vlan_ioctl_set(int (*hook) (struct net *, void __user *))
1da177e4 1000{
4a3e2f71 1001 mutex_lock(&vlan_ioctl_mutex);
1da177e4 1002 vlan_ioctl_hook = hook;
4a3e2f71 1003 mutex_unlock(&vlan_ioctl_mutex);
1da177e4
LT
1004}
1005EXPORT_SYMBOL(vlan_ioctl_set);
1006
4a3e2f71 1007static DEFINE_MUTEX(dlci_ioctl_mutex);
89bddce5 1008static int (*dlci_ioctl_hook) (unsigned int, void __user *);
1da177e4 1009
89bddce5 1010void dlci_ioctl_set(int (*hook) (unsigned int, void __user *))
1da177e4 1011{
4a3e2f71 1012 mutex_lock(&dlci_ioctl_mutex);
1da177e4 1013 dlci_ioctl_hook = hook;
4a3e2f71 1014 mutex_unlock(&dlci_ioctl_mutex);
1da177e4
LT
1015}
1016EXPORT_SYMBOL(dlci_ioctl_set);
1017
6b96018b
AB
1018static long sock_do_ioctl(struct net *net, struct socket *sock,
1019 unsigned int cmd, unsigned long arg)
1020{
1021 int err;
1022 void __user *argp = (void __user *)arg;
1023
1024 err = sock->ops->ioctl(sock, cmd, arg);
1025
1026 /*
1027 * If this ioctl is unknown try to hand it down
1028 * to the NIC driver.
1029 */
1030 if (err == -ENOIOCTLCMD)
1031 err = dev_ioctl(net, cmd, argp);
1032
1033 return err;
1034}
1035
1da177e4
LT
1036/*
1037 * With an ioctl, arg may well be a user mode pointer, but we don't know
1038 * what to do with it - that's up to the protocol still.
1039 */
1040
1041static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
1042{
1043 struct socket *sock;
881d966b 1044 struct sock *sk;
1da177e4
LT
1045 void __user *argp = (void __user *)arg;
1046 int pid, err;
881d966b 1047 struct net *net;
1da177e4 1048
b69aee04 1049 sock = file->private_data;
881d966b 1050 sk = sock->sk;
3b1e0a65 1051 net = sock_net(sk);
1da177e4 1052 if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) {
881d966b 1053 err = dev_ioctl(net, cmd, argp);
1da177e4 1054 } else
3d23e349 1055#ifdef CONFIG_WEXT_CORE
1da177e4 1056 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {
881d966b 1057 err = dev_ioctl(net, cmd, argp);
1da177e4 1058 } else
3d23e349 1059#endif
89bddce5 1060 switch (cmd) {
1da177e4
LT
1061 case FIOSETOWN:
1062 case SIOCSPGRP:
1063 err = -EFAULT;
1064 if (get_user(pid, (int __user *)argp))
1065 break;
e0b93edd
JL
1066 f_setown(sock->file, pid, 1);
1067 err = 0;
1da177e4
LT
1068 break;
1069 case FIOGETOWN:
1070 case SIOCGPGRP:
609d7fa9 1071 err = put_user(f_getown(sock->file),
89bddce5 1072 (int __user *)argp);
1da177e4
LT
1073 break;
1074 case SIOCGIFBR:
1075 case SIOCSIFBR:
1076 case SIOCBRADDBR:
1077 case SIOCBRDELBR:
1078 err = -ENOPKG;
1079 if (!br_ioctl_hook)
1080 request_module("bridge");
1081
4a3e2f71 1082 mutex_lock(&br_ioctl_mutex);
89bddce5 1083 if (br_ioctl_hook)
881d966b 1084 err = br_ioctl_hook(net, cmd, argp);
4a3e2f71 1085 mutex_unlock(&br_ioctl_mutex);
1da177e4
LT
1086 break;
1087 case SIOCGIFVLAN:
1088 case SIOCSIFVLAN:
1089 err = -ENOPKG;
1090 if (!vlan_ioctl_hook)
1091 request_module("8021q");
1092
4a3e2f71 1093 mutex_lock(&vlan_ioctl_mutex);
1da177e4 1094 if (vlan_ioctl_hook)
881d966b 1095 err = vlan_ioctl_hook(net, argp);
4a3e2f71 1096 mutex_unlock(&vlan_ioctl_mutex);
1da177e4 1097 break;
1da177e4
LT
1098 case SIOCADDDLCI:
1099 case SIOCDELDLCI:
1100 err = -ENOPKG;
1101 if (!dlci_ioctl_hook)
1102 request_module("dlci");
1103
7512cbf6
PE
1104 mutex_lock(&dlci_ioctl_mutex);
1105 if (dlci_ioctl_hook)
1da177e4 1106 err = dlci_ioctl_hook(cmd, argp);
7512cbf6 1107 mutex_unlock(&dlci_ioctl_mutex);
1da177e4
LT
1108 break;
1109 default:
6b96018b 1110 err = sock_do_ioctl(net, sock, cmd, arg);
1da177e4 1111 break;
89bddce5 1112 }
1da177e4
LT
1113 return err;
1114}
1115
1116int sock_create_lite(int family, int type, int protocol, struct socket **res)
1117{
1118 int err;
1119 struct socket *sock = NULL;
89bddce5 1120
1da177e4
LT
1121 err = security_socket_create(family, type, protocol, 1);
1122 if (err)
1123 goto out;
1124
1125 sock = sock_alloc();
1126 if (!sock) {
1127 err = -ENOMEM;
1128 goto out;
1129 }
1130
1da177e4 1131 sock->type = type;
7420ed23
VY
1132 err = security_socket_post_create(sock, family, type, protocol, 1);
1133 if (err)
1134 goto out_release;
1135
1da177e4
LT
1136out:
1137 *res = sock;
1138 return err;
7420ed23
VY
1139out_release:
1140 sock_release(sock);
1141 sock = NULL;
1142 goto out;
1da177e4 1143}
c6d409cf 1144EXPORT_SYMBOL(sock_create_lite);
1da177e4
LT
1145
1146/* No kernel lock held - perfect */
89bddce5 1147static unsigned int sock_poll(struct file *file, poll_table *wait)
1da177e4 1148{
cbf55001 1149 unsigned int busy_flag = 0;
1da177e4
LT
1150 struct socket *sock;
1151
1152 /*
89bddce5 1153 * We can't return errors to poll, so it's either yes or no.
1da177e4 1154 */
b69aee04 1155 sock = file->private_data;
2d48d67f 1156
cbf55001 1157 if (sk_can_busy_loop(sock->sk)) {
2d48d67f 1158 /* this socket can poll_ll so tell the system call */
cbf55001 1159 busy_flag = POLL_BUSY_LOOP;
2d48d67f
ET
1160
1161 /* once, only if requested by syscall */
cbf55001
ET
1162 if (wait && (wait->_key & POLL_BUSY_LOOP))
1163 sk_busy_loop(sock->sk, 1);
2d48d67f
ET
1164 }
1165
cbf55001 1166 return busy_flag | sock->ops->poll(file, sock, wait);
1da177e4
LT
1167}
1168
89bddce5 1169static int sock_mmap(struct file *file, struct vm_area_struct *vma)
1da177e4 1170{
b69aee04 1171 struct socket *sock = file->private_data;
1da177e4
LT
1172
1173 return sock->ops->mmap(file, sock, vma);
1174}
1175
20380731 1176static int sock_close(struct inode *inode, struct file *filp)
1da177e4 1177{
1da177e4
LT
1178 sock_release(SOCKET_I(inode));
1179 return 0;
1180}
1181
1182/*
1183 * Update the socket async list
1184 *
1185 * Fasync_list locking strategy.
1186 *
1187 * 1. fasync_list is modified only under process context socket lock
1188 * i.e. under semaphore.
1189 * 2. fasync_list is used under read_lock(&sk->sk_callback_lock)
989a2979 1190 * or under socket lock
1da177e4
LT
1191 */
1192
1193static int sock_fasync(int fd, struct file *filp, int on)
1194{
989a2979
ED
1195 struct socket *sock = filp->private_data;
1196 struct sock *sk = sock->sk;
eaefd110 1197 struct socket_wq *wq;
1da177e4 1198
989a2979 1199 if (sk == NULL)
1da177e4 1200 return -EINVAL;
1da177e4
LT
1201
1202 lock_sock(sk);
eaefd110
ED
1203 wq = rcu_dereference_protected(sock->wq, sock_owned_by_user(sk));
1204 fasync_helper(fd, filp, on, &wq->fasync_list);
1da177e4 1205
eaefd110 1206 if (!wq->fasync_list)
989a2979
ED
1207 sock_reset_flag(sk, SOCK_FASYNC);
1208 else
bcdce719 1209 sock_set_flag(sk, SOCK_FASYNC);
1da177e4 1210
989a2979 1211 release_sock(sk);
1da177e4
LT
1212 return 0;
1213}
1214
43815482 1215/* This function may be called only under socket lock or callback_lock or rcu_lock */
1da177e4
LT
1216
1217int sock_wake_async(struct socket *sock, int how, int band)
1218{
43815482
ED
1219 struct socket_wq *wq;
1220
1221 if (!sock)
1222 return -1;
1223 rcu_read_lock();
1224 wq = rcu_dereference(sock->wq);
1225 if (!wq || !wq->fasync_list) {
1226 rcu_read_unlock();
1da177e4 1227 return -1;
43815482 1228 }
89bddce5 1229 switch (how) {
8d8ad9d7 1230 case SOCK_WAKE_WAITD:
1da177e4
LT
1231 if (test_bit(SOCK_ASYNC_WAITDATA, &sock->flags))
1232 break;
1233 goto call_kill;
8d8ad9d7 1234 case SOCK_WAKE_SPACE:
1da177e4
LT
1235 if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags))
1236 break;
1237 /* fall through */
8d8ad9d7 1238 case SOCK_WAKE_IO:
89bddce5 1239call_kill:
43815482 1240 kill_fasync(&wq->fasync_list, SIGIO, band);
1da177e4 1241 break;
8d8ad9d7 1242 case SOCK_WAKE_URG:
43815482 1243 kill_fasync(&wq->fasync_list, SIGURG, band);
1da177e4 1244 }
43815482 1245 rcu_read_unlock();
1da177e4
LT
1246 return 0;
1247}
c6d409cf 1248EXPORT_SYMBOL(sock_wake_async);
1da177e4 1249
721db93a 1250int __sock_create(struct net *net, int family, int type, int protocol,
89bddce5 1251 struct socket **res, int kern)
1da177e4
LT
1252{
1253 int err;
1254 struct socket *sock;
55737fda 1255 const struct net_proto_family *pf;
1da177e4
LT
1256
1257 /*
89bddce5 1258 * Check protocol is in range
1da177e4
LT
1259 */
1260 if (family < 0 || family >= NPROTO)
1261 return -EAFNOSUPPORT;
1262 if (type < 0 || type >= SOCK_MAX)
1263 return -EINVAL;
1264
1265 /* Compatibility.
1266
1267 This uglymoron is moved from INET layer to here to avoid
1268 deadlock in module load.
1269 */
1270 if (family == PF_INET && type == SOCK_PACKET) {
89bddce5 1271 static int warned;
1da177e4
LT
1272 if (!warned) {
1273 warned = 1;
3410f22e
YY
1274 pr_info("%s uses obsolete (PF_INET,SOCK_PACKET)\n",
1275 current->comm);
1da177e4
LT
1276 }
1277 family = PF_PACKET;
1278 }
1279
1280 err = security_socket_create(family, type, protocol, kern);
1281 if (err)
1282 return err;
89bddce5 1283
55737fda
SH
1284 /*
1285 * Allocate the socket and allow the family to set things up. if
1286 * the protocol is 0, the family is instructed to select an appropriate
1287 * default.
1288 */
1289 sock = sock_alloc();
1290 if (!sock) {
e87cc472 1291 net_warn_ratelimited("socket: no more sockets\n");
55737fda
SH
1292 return -ENFILE; /* Not exactly a match, but its the
1293 closest posix thing */
1294 }
1295
1296 sock->type = type;
1297
95a5afca 1298#ifdef CONFIG_MODULES
89bddce5
SH
1299 /* Attempt to load a protocol module if the find failed.
1300 *
1301 * 12/09/1996 Marcin: But! this makes REALLY only sense, if the user
1da177e4
LT
1302 * requested real, full-featured networking support upon configuration.
1303 * Otherwise module support will break!
1304 */
190683a9 1305 if (rcu_access_pointer(net_families[family]) == NULL)
89bddce5 1306 request_module("net-pf-%d", family);
1da177e4
LT
1307#endif
1308
55737fda
SH
1309 rcu_read_lock();
1310 pf = rcu_dereference(net_families[family]);
1311 err = -EAFNOSUPPORT;
1312 if (!pf)
1313 goto out_release;
1da177e4
LT
1314
1315 /*
1316 * We will call the ->create function, that possibly is in a loadable
1317 * module, so we have to bump that loadable module refcnt first.
1318 */
55737fda 1319 if (!try_module_get(pf->owner))
1da177e4
LT
1320 goto out_release;
1321
55737fda
SH
1322 /* Now protected by module ref count */
1323 rcu_read_unlock();
1324
3f378b68 1325 err = pf->create(net, sock, protocol, kern);
55737fda 1326 if (err < 0)
1da177e4 1327 goto out_module_put;
a79af59e 1328
1da177e4
LT
1329 /*
1330 * Now to bump the refcnt of the [loadable] module that owns this
1331 * socket at sock_release time we decrement its refcnt.
1332 */
55737fda
SH
1333 if (!try_module_get(sock->ops->owner))
1334 goto out_module_busy;
1335
1da177e4
LT
1336 /*
1337 * Now that we're done with the ->create function, the [loadable]
1338 * module can have its refcnt decremented
1339 */
55737fda 1340 module_put(pf->owner);
7420ed23
VY
1341 err = security_socket_post_create(sock, family, type, protocol, kern);
1342 if (err)
3b185525 1343 goto out_sock_release;
55737fda 1344 *res = sock;
1da177e4 1345
55737fda
SH
1346 return 0;
1347
1348out_module_busy:
1349 err = -EAFNOSUPPORT;
1da177e4 1350out_module_put:
55737fda
SH
1351 sock->ops = NULL;
1352 module_put(pf->owner);
1353out_sock_release:
1da177e4 1354 sock_release(sock);
55737fda
SH
1355 return err;
1356
1357out_release:
1358 rcu_read_unlock();
1359 goto out_sock_release;
1da177e4 1360}
721db93a 1361EXPORT_SYMBOL(__sock_create);
1da177e4
LT
1362
1363int sock_create(int family, int type, int protocol, struct socket **res)
1364{
1b8d7ae4 1365 return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);
1da177e4 1366}
c6d409cf 1367EXPORT_SYMBOL(sock_create);
1da177e4
LT
1368
1369int sock_create_kern(int family, int type, int protocol, struct socket **res)
1370{
1b8d7ae4 1371 return __sock_create(&init_net, family, type, protocol, res, 1);
1da177e4 1372}
c6d409cf 1373EXPORT_SYMBOL(sock_create_kern);
1da177e4 1374
3e0fa65f 1375SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol)
1da177e4
LT
1376{
1377 int retval;
1378 struct socket *sock;
a677a039
UD
1379 int flags;
1380
e38b36f3
UD
1381 /* Check the SOCK_* constants for consistency. */
1382 BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);
1383 BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK);
1384 BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);
1385 BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);
1386
a677a039 1387 flags = type & ~SOCK_TYPE_MASK;
77d27200 1388 if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
a677a039
UD
1389 return -EINVAL;
1390 type &= SOCK_TYPE_MASK;
1da177e4 1391
aaca0bdc
UD
1392 if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1393 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1394
1da177e4
LT
1395 retval = sock_create(family, type, protocol, &sock);
1396 if (retval < 0)
1397 goto out;
1398
77d27200 1399 retval = sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));
1da177e4
LT
1400 if (retval < 0)
1401 goto out_release;
1402
1403out:
1404 /* It may be already another descriptor 8) Not kernel problem. */
1405 return retval;
1406
1407out_release:
1408 sock_release(sock);
1409 return retval;
1410}
1411
1412/*
1413 * Create a pair of connected sockets.
1414 */
1415
3e0fa65f
HC
1416SYSCALL_DEFINE4(socketpair, int, family, int, type, int, protocol,
1417 int __user *, usockvec)
1da177e4
LT
1418{
1419 struct socket *sock1, *sock2;
1420 int fd1, fd2, err;
db349509 1421 struct file *newfile1, *newfile2;
a677a039
UD
1422 int flags;
1423
1424 flags = type & ~SOCK_TYPE_MASK;
77d27200 1425 if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
a677a039
UD
1426 return -EINVAL;
1427 type &= SOCK_TYPE_MASK;
1da177e4 1428
aaca0bdc
UD
1429 if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1430 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1431
1da177e4
LT
1432 /*
1433 * Obtain the first socket and check if the underlying protocol
1434 * supports the socketpair call.
1435 */
1436
1437 err = sock_create(family, type, protocol, &sock1);
1438 if (err < 0)
1439 goto out;
1440
1441 err = sock_create(family, type, protocol, &sock2);
1442 if (err < 0)
1443 goto out_release_1;
1444
1445 err = sock1->ops->socketpair(sock1, sock2);
89bddce5 1446 if (err < 0)
1da177e4
LT
1447 goto out_release_both;
1448
28407630 1449 fd1 = get_unused_fd_flags(flags);
bf3c23d1
DM
1450 if (unlikely(fd1 < 0)) {
1451 err = fd1;
db349509 1452 goto out_release_both;
bf3c23d1 1453 }
d73aa286 1454
28407630 1455 fd2 = get_unused_fd_flags(flags);
198de4d7
AV
1456 if (unlikely(fd2 < 0)) {
1457 err = fd2;
d73aa286 1458 goto out_put_unused_1;
28407630
AV
1459 }
1460
aab174f0 1461 newfile1 = sock_alloc_file(sock1, flags, NULL);
28407630
AV
1462 if (unlikely(IS_ERR(newfile1))) {
1463 err = PTR_ERR(newfile1);
d73aa286 1464 goto out_put_unused_both;
28407630
AV
1465 }
1466
aab174f0 1467 newfile2 = sock_alloc_file(sock2, flags, NULL);
28407630
AV
1468 if (IS_ERR(newfile2)) {
1469 err = PTR_ERR(newfile2);
d73aa286 1470 goto out_fput_1;
db349509
AV
1471 }
1472
d73aa286
YD
1473 err = put_user(fd1, &usockvec[0]);
1474 if (err)
1475 goto out_fput_both;
1476
1477 err = put_user(fd2, &usockvec[1]);
1478 if (err)
1479 goto out_fput_both;
1480
157cf649 1481 audit_fd_pair(fd1, fd2);
d73aa286 1482
db349509
AV
1483 fd_install(fd1, newfile1);
1484 fd_install(fd2, newfile2);
1da177e4
LT
1485 /* fd1 and fd2 may be already another descriptors.
1486 * Not kernel problem.
1487 */
1488
d73aa286 1489 return 0;
1da177e4 1490
d73aa286
YD
1491out_fput_both:
1492 fput(newfile2);
1493 fput(newfile1);
1494 put_unused_fd(fd2);
1495 put_unused_fd(fd1);
1496 goto out;
1497
1498out_fput_1:
1499 fput(newfile1);
1500 put_unused_fd(fd2);
1501 put_unused_fd(fd1);
1502 sock_release(sock2);
1503 goto out;
1da177e4 1504
d73aa286
YD
1505out_put_unused_both:
1506 put_unused_fd(fd2);
1507out_put_unused_1:
1508 put_unused_fd(fd1);
1da177e4 1509out_release_both:
89bddce5 1510 sock_release(sock2);
1da177e4 1511out_release_1:
89bddce5 1512 sock_release(sock1);
1da177e4
LT
1513out:
1514 return err;
1515}
1516
1da177e4
LT
1517/*
1518 * Bind a name to a socket. Nothing much to do here since it's
1519 * the protocol's responsibility to handle the local address.
1520 *
1521 * We move the socket address to kernel space before we call
1522 * the protocol layer (having also checked the address is ok).
1523 */
1524
20f37034 1525SYSCALL_DEFINE3(bind, int, fd, struct sockaddr __user *, umyaddr, int, addrlen)
1da177e4
LT
1526{
1527 struct socket *sock;
230b1839 1528 struct sockaddr_storage address;
6cb153ca 1529 int err, fput_needed;
1da177e4 1530
89bddce5 1531 sock = sockfd_lookup_light(fd, &err, &fput_needed);
e71a4783 1532 if (sock) {
43db362d 1533 err = move_addr_to_kernel(umyaddr, addrlen, &address);
89bddce5
SH
1534 if (err >= 0) {
1535 err = security_socket_bind(sock,
230b1839 1536 (struct sockaddr *)&address,
89bddce5 1537 addrlen);
6cb153ca
BL
1538 if (!err)
1539 err = sock->ops->bind(sock,
89bddce5 1540 (struct sockaddr *)
230b1839 1541 &address, addrlen);
1da177e4 1542 }
6cb153ca 1543 fput_light(sock->file, fput_needed);
89bddce5 1544 }
1da177e4
LT
1545 return err;
1546}
1547
1da177e4
LT
1548/*
1549 * Perform a listen. Basically, we allow the protocol to do anything
1550 * necessary for a listen, and if that works, we mark the socket as
1551 * ready for listening.
1552 */
1553
3e0fa65f 1554SYSCALL_DEFINE2(listen, int, fd, int, backlog)
1da177e4
LT
1555{
1556 struct socket *sock;
6cb153ca 1557 int err, fput_needed;
b8e1f9b5 1558 int somaxconn;
89bddce5
SH
1559
1560 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1561 if (sock) {
8efa6e93 1562 somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn;
95c96174 1563 if ((unsigned int)backlog > somaxconn)
b8e1f9b5 1564 backlog = somaxconn;
1da177e4
LT
1565
1566 err = security_socket_listen(sock, backlog);
6cb153ca
BL
1567 if (!err)
1568 err = sock->ops->listen(sock, backlog);
1da177e4 1569
6cb153ca 1570 fput_light(sock->file, fput_needed);
1da177e4
LT
1571 }
1572 return err;
1573}
1574
1da177e4
LT
1575/*
1576 * For accept, we attempt to create a new socket, set up the link
1577 * with the client, wake up the client, then return the new
1578 * connected fd. We collect the address of the connector in kernel
1579 * space and move it to user at the very end. This is unclean because
1580 * we open the socket then return an error.
1581 *
1582 * 1003.1g adds the ability to recvmsg() to query connection pending
1583 * status to recvmsg. We need to add that support in a way thats
1584 * clean when we restucture accept also.
1585 */
1586
20f37034
HC
1587SYSCALL_DEFINE4(accept4, int, fd, struct sockaddr __user *, upeer_sockaddr,
1588 int __user *, upeer_addrlen, int, flags)
1da177e4
LT
1589{
1590 struct socket *sock, *newsock;
39d8c1b6 1591 struct file *newfile;
6cb153ca 1592 int err, len, newfd, fput_needed;
230b1839 1593 struct sockaddr_storage address;
1da177e4 1594
77d27200 1595 if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
aaca0bdc
UD
1596 return -EINVAL;
1597
1598 if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1599 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1600
6cb153ca 1601 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4
LT
1602 if (!sock)
1603 goto out;
1604
1605 err = -ENFILE;
c6d409cf
ED
1606 newsock = sock_alloc();
1607 if (!newsock)
1da177e4
LT
1608 goto out_put;
1609
1610 newsock->type = sock->type;
1611 newsock->ops = sock->ops;
1612
1da177e4
LT
1613 /*
1614 * We don't need try_module_get here, as the listening socket (sock)
1615 * has the protocol module (sock->ops->owner) held.
1616 */
1617 __module_get(newsock->ops->owner);
1618
28407630 1619 newfd = get_unused_fd_flags(flags);
39d8c1b6
DM
1620 if (unlikely(newfd < 0)) {
1621 err = newfd;
9a1875e6
DM
1622 sock_release(newsock);
1623 goto out_put;
39d8c1b6 1624 }
aab174f0 1625 newfile = sock_alloc_file(newsock, flags, sock->sk->sk_prot_creator->name);
28407630
AV
1626 if (unlikely(IS_ERR(newfile))) {
1627 err = PTR_ERR(newfile);
1628 put_unused_fd(newfd);
1629 sock_release(newsock);
1630 goto out_put;
1631 }
39d8c1b6 1632
a79af59e
FF
1633 err = security_socket_accept(sock, newsock);
1634 if (err)
39d8c1b6 1635 goto out_fd;
a79af59e 1636
1da177e4
LT
1637 err = sock->ops->accept(sock, newsock, sock->file->f_flags);
1638 if (err < 0)
39d8c1b6 1639 goto out_fd;
1da177e4
LT
1640
1641 if (upeer_sockaddr) {
230b1839 1642 if (newsock->ops->getname(newsock, (struct sockaddr *)&address,
89bddce5 1643 &len, 2) < 0) {
1da177e4 1644 err = -ECONNABORTED;
39d8c1b6 1645 goto out_fd;
1da177e4 1646 }
43db362d 1647 err = move_addr_to_user(&address,
230b1839 1648 len, upeer_sockaddr, upeer_addrlen);
1da177e4 1649 if (err < 0)
39d8c1b6 1650 goto out_fd;
1da177e4
LT
1651 }
1652
1653 /* File flags are not inherited via accept() unlike another OSes. */
1654
39d8c1b6
DM
1655 fd_install(newfd, newfile);
1656 err = newfd;
1da177e4 1657
1da177e4 1658out_put:
6cb153ca 1659 fput_light(sock->file, fput_needed);
1da177e4
LT
1660out:
1661 return err;
39d8c1b6 1662out_fd:
9606a216 1663 fput(newfile);
39d8c1b6 1664 put_unused_fd(newfd);
1da177e4
LT
1665 goto out_put;
1666}
1667
20f37034
HC
1668SYSCALL_DEFINE3(accept, int, fd, struct sockaddr __user *, upeer_sockaddr,
1669 int __user *, upeer_addrlen)
aaca0bdc 1670{
de11defe 1671 return sys_accept4(fd, upeer_sockaddr, upeer_addrlen, 0);
aaca0bdc
UD
1672}
1673
1da177e4
LT
1674/*
1675 * Attempt to connect to a socket with the server address. The address
1676 * is in user space so we verify it is OK and move it to kernel space.
1677 *
1678 * For 1003.1g we need to add clean support for a bind to AF_UNSPEC to
1679 * break bindings
1680 *
1681 * NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and
1682 * other SEQPACKET protocols that take time to connect() as it doesn't
1683 * include the -EINPROGRESS status for such sockets.
1684 */
1685
20f37034
HC
1686SYSCALL_DEFINE3(connect, int, fd, struct sockaddr __user *, uservaddr,
1687 int, addrlen)
1da177e4
LT
1688{
1689 struct socket *sock;
230b1839 1690 struct sockaddr_storage address;
6cb153ca 1691 int err, fput_needed;
1da177e4 1692
6cb153ca 1693 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4
LT
1694 if (!sock)
1695 goto out;
43db362d 1696 err = move_addr_to_kernel(uservaddr, addrlen, &address);
1da177e4
LT
1697 if (err < 0)
1698 goto out_put;
1699
89bddce5 1700 err =
230b1839 1701 security_socket_connect(sock, (struct sockaddr *)&address, addrlen);
1da177e4
LT
1702 if (err)
1703 goto out_put;
1704
230b1839 1705 err = sock->ops->connect(sock, (struct sockaddr *)&address, addrlen,
1da177e4
LT
1706 sock->file->f_flags);
1707out_put:
6cb153ca 1708 fput_light(sock->file, fput_needed);
1da177e4
LT
1709out:
1710 return err;
1711}
1712
1713/*
1714 * Get the local address ('name') of a socket object. Move the obtained
1715 * name to user space.
1716 */
1717
20f37034
HC
1718SYSCALL_DEFINE3(getsockname, int, fd, struct sockaddr __user *, usockaddr,
1719 int __user *, usockaddr_len)
1da177e4
LT
1720{
1721 struct socket *sock;
230b1839 1722 struct sockaddr_storage address;
6cb153ca 1723 int len, err, fput_needed;
89bddce5 1724
6cb153ca 1725 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4
LT
1726 if (!sock)
1727 goto out;
1728
1729 err = security_socket_getsockname(sock);
1730 if (err)
1731 goto out_put;
1732
230b1839 1733 err = sock->ops->getname(sock, (struct sockaddr *)&address, &len, 0);
1da177e4
LT
1734 if (err)
1735 goto out_put;
43db362d 1736 err = move_addr_to_user(&address, len, usockaddr, usockaddr_len);
1da177e4
LT
1737
1738out_put:
6cb153ca 1739 fput_light(sock->file, fput_needed);
1da177e4
LT
1740out:
1741 return err;
1742}
1743
1744/*
1745 * Get the remote address ('name') of a socket object. Move the obtained
1746 * name to user space.
1747 */
1748
20f37034
HC
1749SYSCALL_DEFINE3(getpeername, int, fd, struct sockaddr __user *, usockaddr,
1750 int __user *, usockaddr_len)
1da177e4
LT
1751{
1752 struct socket *sock;
230b1839 1753 struct sockaddr_storage address;
6cb153ca 1754 int len, err, fput_needed;
1da177e4 1755
89bddce5
SH
1756 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1757 if (sock != NULL) {
1da177e4
LT
1758 err = security_socket_getpeername(sock);
1759 if (err) {
6cb153ca 1760 fput_light(sock->file, fput_needed);
1da177e4
LT
1761 return err;
1762 }
1763
89bddce5 1764 err =
230b1839 1765 sock->ops->getname(sock, (struct sockaddr *)&address, &len,
89bddce5 1766 1);
1da177e4 1767 if (!err)
43db362d 1768 err = move_addr_to_user(&address, len, usockaddr,
89bddce5 1769 usockaddr_len);
6cb153ca 1770 fput_light(sock->file, fput_needed);
1da177e4
LT
1771 }
1772 return err;
1773}
1774
1775/*
1776 * Send a datagram to a given address. We move the address into kernel
1777 * space and check the user space data area is readable before invoking
1778 * the protocol.
1779 */
1780
3e0fa65f 1781SYSCALL_DEFINE6(sendto, int, fd, void __user *, buff, size_t, len,
95c96174 1782 unsigned int, flags, struct sockaddr __user *, addr,
3e0fa65f 1783 int, addr_len)
1da177e4
LT
1784{
1785 struct socket *sock;
230b1839 1786 struct sockaddr_storage address;
1da177e4
LT
1787 int err;
1788 struct msghdr msg;
1789 struct iovec iov;
6cb153ca 1790 int fput_needed;
6cb153ca 1791
253eacc0
LT
1792 if (len > INT_MAX)
1793 len = INT_MAX;
de0fa95c
PE
1794 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1795 if (!sock)
4387ff75 1796 goto out;
6cb153ca 1797
89bddce5
SH
1798 iov.iov_base = buff;
1799 iov.iov_len = len;
1800 msg.msg_name = NULL;
1801 msg.msg_iov = &iov;
1802 msg.msg_iovlen = 1;
1803 msg.msg_control = NULL;
1804 msg.msg_controllen = 0;
1805 msg.msg_namelen = 0;
6cb153ca 1806 if (addr) {
43db362d 1807 err = move_addr_to_kernel(addr, addr_len, &address);
1da177e4
LT
1808 if (err < 0)
1809 goto out_put;
230b1839 1810 msg.msg_name = (struct sockaddr *)&address;
89bddce5 1811 msg.msg_namelen = addr_len;
1da177e4
LT
1812 }
1813 if (sock->file->f_flags & O_NONBLOCK)
1814 flags |= MSG_DONTWAIT;
1815 msg.msg_flags = flags;
1816 err = sock_sendmsg(sock, &msg, len);
1817
89bddce5 1818out_put:
de0fa95c 1819 fput_light(sock->file, fput_needed);
4387ff75 1820out:
1da177e4
LT
1821 return err;
1822}
1823
1824/*
89bddce5 1825 * Send a datagram down a socket.
1da177e4
LT
1826 */
1827
3e0fa65f 1828SYSCALL_DEFINE4(send, int, fd, void __user *, buff, size_t, len,
95c96174 1829 unsigned int, flags)
1da177e4
LT
1830{
1831 return sys_sendto(fd, buff, len, flags, NULL, 0);
1832}
1833
1834/*
89bddce5 1835 * Receive a frame from the socket and optionally record the address of the
1da177e4
LT
1836 * sender. We verify the buffers are writable and if needed move the
1837 * sender address from kernel to user space.
1838 */
1839
3e0fa65f 1840SYSCALL_DEFINE6(recvfrom, int, fd, void __user *, ubuf, size_t, size,
95c96174 1841 unsigned int, flags, struct sockaddr __user *, addr,
3e0fa65f 1842 int __user *, addr_len)
1da177e4
LT
1843{
1844 struct socket *sock;
1845 struct iovec iov;
1846 struct msghdr msg;
230b1839 1847 struct sockaddr_storage address;
89bddce5 1848 int err, err2;
6cb153ca
BL
1849 int fput_needed;
1850
253eacc0
LT
1851 if (size > INT_MAX)
1852 size = INT_MAX;
de0fa95c 1853 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4 1854 if (!sock)
de0fa95c 1855 goto out;
1da177e4 1856
89bddce5
SH
1857 msg.msg_control = NULL;
1858 msg.msg_controllen = 0;
1859 msg.msg_iovlen = 1;
1860 msg.msg_iov = &iov;
1861 iov.iov_len = size;
1862 iov.iov_base = ubuf;
f3d33426
HFS
1863 /* Save some cycles and don't copy the address if not needed */
1864 msg.msg_name = addr ? (struct sockaddr *)&address : NULL;
1865 /* We assume all kernel code knows the size of sockaddr_storage */
1866 msg.msg_namelen = 0;
1da177e4
LT
1867 if (sock->file->f_flags & O_NONBLOCK)
1868 flags |= MSG_DONTWAIT;
89bddce5 1869 err = sock_recvmsg(sock, &msg, size, flags);
1da177e4 1870
89bddce5 1871 if (err >= 0 && addr != NULL) {
43db362d 1872 err2 = move_addr_to_user(&address,
230b1839 1873 msg.msg_namelen, addr, addr_len);
89bddce5
SH
1874 if (err2 < 0)
1875 err = err2;
1da177e4 1876 }
de0fa95c
PE
1877
1878 fput_light(sock->file, fput_needed);
4387ff75 1879out:
1da177e4
LT
1880 return err;
1881}
1882
1883/*
89bddce5 1884 * Receive a datagram from a socket.
1da177e4
LT
1885 */
1886
b7c0ddf5
JG
1887SYSCALL_DEFINE4(recv, int, fd, void __user *, ubuf, size_t, size,
1888 unsigned int, flags)
1da177e4
LT
1889{
1890 return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL);
1891}
1892
1893/*
1894 * Set a socket option. Because we don't know the option lengths we have
1895 * to pass the user mode parameter for the protocols to sort out.
1896 */
1897
20f37034
HC
1898SYSCALL_DEFINE5(setsockopt, int, fd, int, level, int, optname,
1899 char __user *, optval, int, optlen)
1da177e4 1900{
6cb153ca 1901 int err, fput_needed;
1da177e4
LT
1902 struct socket *sock;
1903
1904 if (optlen < 0)
1905 return -EINVAL;
89bddce5
SH
1906
1907 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1908 if (sock != NULL) {
1909 err = security_socket_setsockopt(sock, level, optname);
6cb153ca
BL
1910 if (err)
1911 goto out_put;
1da177e4
LT
1912
1913 if (level == SOL_SOCKET)
89bddce5
SH
1914 err =
1915 sock_setsockopt(sock, level, optname, optval,
1916 optlen);
1da177e4 1917 else
89bddce5
SH
1918 err =
1919 sock->ops->setsockopt(sock, level, optname, optval,
1920 optlen);
6cb153ca
BL
1921out_put:
1922 fput_light(sock->file, fput_needed);
1da177e4
LT
1923 }
1924 return err;
1925}
1926
1927/*
1928 * Get a socket option. Because we don't know the option lengths we have
1929 * to pass a user mode parameter for the protocols to sort out.
1930 */
1931
20f37034
HC
1932SYSCALL_DEFINE5(getsockopt, int, fd, int, level, int, optname,
1933 char __user *, optval, int __user *, optlen)
1da177e4 1934{
6cb153ca 1935 int err, fput_needed;
1da177e4
LT
1936 struct socket *sock;
1937
89bddce5
SH
1938 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1939 if (sock != NULL) {
6cb153ca
BL
1940 err = security_socket_getsockopt(sock, level, optname);
1941 if (err)
1942 goto out_put;
1da177e4
LT
1943
1944 if (level == SOL_SOCKET)
89bddce5
SH
1945 err =
1946 sock_getsockopt(sock, level, optname, optval,
1947 optlen);
1da177e4 1948 else
89bddce5
SH
1949 err =
1950 sock->ops->getsockopt(sock, level, optname, optval,
1951 optlen);
6cb153ca
BL
1952out_put:
1953 fput_light(sock->file, fput_needed);
1da177e4
LT
1954 }
1955 return err;
1956}
1957
1da177e4
LT
1958/*
1959 * Shutdown a socket.
1960 */
1961
754fe8d2 1962SYSCALL_DEFINE2(shutdown, int, fd, int, how)
1da177e4 1963{
6cb153ca 1964 int err, fput_needed;
1da177e4
LT
1965 struct socket *sock;
1966
89bddce5
SH
1967 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1968 if (sock != NULL) {
1da177e4 1969 err = security_socket_shutdown(sock, how);
6cb153ca
BL
1970 if (!err)
1971 err = sock->ops->shutdown(sock, how);
1972 fput_light(sock->file, fput_needed);
1da177e4
LT
1973 }
1974 return err;
1975}
1976
89bddce5 1977/* A couple of helpful macros for getting the address of the 32/64 bit
1da177e4
LT
1978 * fields which are the same type (int / unsigned) on our platforms.
1979 */
1980#define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member)
1981#define COMPAT_NAMELEN(msg) COMPAT_MSG(msg, msg_namelen)
1982#define COMPAT_FLAGS(msg) COMPAT_MSG(msg, msg_flags)
1983
c71d8ebe
TH
1984struct used_address {
1985 struct sockaddr_storage name;
1986 unsigned int name_len;
1987};
1988
08adb7da
AV
1989static ssize_t copy_msghdr_from_user(struct msghdr *kmsg,
1990 struct user_msghdr __user *umsg,
1991 struct sockaddr __user **save_addr,
1992 struct iovec **iov)
1661bf36 1993{
08adb7da
AV
1994 struct sockaddr __user *uaddr;
1995 struct iovec __user *uiov;
1996 ssize_t err;
1997
1998 if (!access_ok(VERIFY_READ, umsg, sizeof(*umsg)) ||
1999 __get_user(uaddr, &umsg->msg_name) ||
2000 __get_user(kmsg->msg_namelen, &umsg->msg_namelen) ||
2001 __get_user(uiov, &umsg->msg_iov) ||
2002 __get_user(kmsg->msg_iovlen, &umsg->msg_iovlen) ||
2003 __get_user(kmsg->msg_control, &umsg->msg_control) ||
2004 __get_user(kmsg->msg_controllen, &umsg->msg_controllen) ||
2005 __get_user(kmsg->msg_flags, &umsg->msg_flags))
1661bf36 2006 return -EFAULT;
dbb490b9 2007
08adb7da 2008 if (!uaddr)
6a2a2b3a
AS
2009 kmsg->msg_namelen = 0;
2010
dbb490b9
ML
2011 if (kmsg->msg_namelen < 0)
2012 return -EINVAL;
2013
1661bf36 2014 if (kmsg->msg_namelen > sizeof(struct sockaddr_storage))
db31c55a 2015 kmsg->msg_namelen = sizeof(struct sockaddr_storage);
08adb7da
AV
2016
2017 if (save_addr)
2018 *save_addr = uaddr;
2019
2020 if (uaddr && kmsg->msg_namelen) {
2021 if (!save_addr) {
2022 err = move_addr_to_kernel(uaddr, kmsg->msg_namelen,
2023 kmsg->msg_name);
2024 if (err < 0)
2025 return err;
2026 }
2027 } else {
2028 kmsg->msg_name = NULL;
2029 kmsg->msg_namelen = 0;
2030 }
2031
2032 if (kmsg->msg_iovlen > UIO_MAXIOV)
2033 return -EMSGSIZE;
2034
2035 err = rw_copy_check_uvector(save_addr ? READ : WRITE,
2036 uiov, kmsg->msg_iovlen,
2037 UIO_FASTIOV, *iov, iov);
2038 if (err >= 0)
2039 kmsg->msg_iov = *iov;
2040 return err;
1661bf36
DC
2041}
2042
666547ff 2043static int ___sys_sendmsg(struct socket *sock, struct user_msghdr __user *msg,
95c96174 2044 struct msghdr *msg_sys, unsigned int flags,
c71d8ebe 2045 struct used_address *used_address)
1da177e4 2046{
89bddce5
SH
2047 struct compat_msghdr __user *msg_compat =
2048 (struct compat_msghdr __user *)msg;
230b1839 2049 struct sockaddr_storage address;
1da177e4 2050 struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
b9d717a7 2051 unsigned char ctl[sizeof(struct cmsghdr) + 20]
89bddce5
SH
2052 __attribute__ ((aligned(sizeof(__kernel_size_t))));
2053 /* 20 is size of ipv6_pktinfo */
1da177e4 2054 unsigned char *ctl_buf = ctl;
08adb7da
AV
2055 int ctl_len, total_len;
2056 ssize_t err;
89bddce5 2057
08adb7da 2058 msg_sys->msg_name = &address;
1da177e4 2059
08449320 2060 if (MSG_CMSG_COMPAT & flags)
08adb7da 2061 err = get_compat_msghdr(msg_sys, msg_compat, NULL, &iov);
08449320 2062 else
08adb7da 2063 err = copy_msghdr_from_user(msg_sys, msg, NULL, &iov);
89bddce5 2064 if (err < 0)
1da177e4
LT
2065 goto out_freeiov;
2066 total_len = err;
2067
2068 err = -ENOBUFS;
2069
228e548e 2070 if (msg_sys->msg_controllen > INT_MAX)
1da177e4 2071 goto out_freeiov;
228e548e 2072 ctl_len = msg_sys->msg_controllen;
1da177e4 2073 if ((MSG_CMSG_COMPAT & flags) && ctl_len) {
89bddce5 2074 err =
228e548e 2075 cmsghdr_from_user_compat_to_kern(msg_sys, sock->sk, ctl,
89bddce5 2076 sizeof(ctl));
1da177e4
LT
2077 if (err)
2078 goto out_freeiov;
228e548e
AB
2079 ctl_buf = msg_sys->msg_control;
2080 ctl_len = msg_sys->msg_controllen;
1da177e4 2081 } else if (ctl_len) {
89bddce5 2082 if (ctl_len > sizeof(ctl)) {
1da177e4 2083 ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL);
89bddce5 2084 if (ctl_buf == NULL)
1da177e4
LT
2085 goto out_freeiov;
2086 }
2087 err = -EFAULT;
2088 /*
228e548e 2089 * Careful! Before this, msg_sys->msg_control contains a user pointer.
1da177e4
LT
2090 * Afterwards, it will be a kernel pointer. Thus the compiler-assisted
2091 * checking falls down on this.
2092 */
fb8621bb 2093 if (copy_from_user(ctl_buf,
228e548e 2094 (void __user __force *)msg_sys->msg_control,
89bddce5 2095 ctl_len))
1da177e4 2096 goto out_freectl;
228e548e 2097 msg_sys->msg_control = ctl_buf;
1da177e4 2098 }
228e548e 2099 msg_sys->msg_flags = flags;
1da177e4
LT
2100
2101 if (sock->file->f_flags & O_NONBLOCK)
228e548e 2102 msg_sys->msg_flags |= MSG_DONTWAIT;
c71d8ebe
TH
2103 /*
2104 * If this is sendmmsg() and current destination address is same as
2105 * previously succeeded address, omit asking LSM's decision.
2106 * used_address->name_len is initialized to UINT_MAX so that the first
2107 * destination address never matches.
2108 */
bc909d9d
MD
2109 if (used_address && msg_sys->msg_name &&
2110 used_address->name_len == msg_sys->msg_namelen &&
2111 !memcmp(&used_address->name, msg_sys->msg_name,
c71d8ebe
TH
2112 used_address->name_len)) {
2113 err = sock_sendmsg_nosec(sock, msg_sys, total_len);
2114 goto out_freectl;
2115 }
2116 err = sock_sendmsg(sock, msg_sys, total_len);
2117 /*
2118 * If this is sendmmsg() and sending to current destination address was
2119 * successful, remember it.
2120 */
2121 if (used_address && err >= 0) {
2122 used_address->name_len = msg_sys->msg_namelen;
bc909d9d
MD
2123 if (msg_sys->msg_name)
2124 memcpy(&used_address->name, msg_sys->msg_name,
2125 used_address->name_len);
c71d8ebe 2126 }
1da177e4
LT
2127
2128out_freectl:
89bddce5 2129 if (ctl_buf != ctl)
1da177e4
LT
2130 sock_kfree_s(sock->sk, ctl_buf, ctl_len);
2131out_freeiov:
2132 if (iov != iovstack)
a74e9106 2133 kfree(iov);
228e548e
AB
2134 return err;
2135}
2136
2137/*
2138 * BSD sendmsg interface
2139 */
2140
666547ff 2141long __sys_sendmsg(int fd, struct user_msghdr __user *msg, unsigned flags)
228e548e
AB
2142{
2143 int fput_needed, err;
2144 struct msghdr msg_sys;
1be374a0
AL
2145 struct socket *sock;
2146
1be374a0 2147 sock = sockfd_lookup_light(fd, &err, &fput_needed);
228e548e
AB
2148 if (!sock)
2149 goto out;
2150
a7526eb5 2151 err = ___sys_sendmsg(sock, msg, &msg_sys, flags, NULL);
228e548e 2152
6cb153ca 2153 fput_light(sock->file, fput_needed);
89bddce5 2154out:
1da177e4
LT
2155 return err;
2156}
2157
666547ff 2158SYSCALL_DEFINE3(sendmsg, int, fd, struct user_msghdr __user *, msg, unsigned int, flags)
a7526eb5
AL
2159{
2160 if (flags & MSG_CMSG_COMPAT)
2161 return -EINVAL;
2162 return __sys_sendmsg(fd, msg, flags);
2163}
2164
228e548e
AB
2165/*
2166 * Linux sendmmsg interface
2167 */
2168
2169int __sys_sendmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
2170 unsigned int flags)
2171{
2172 int fput_needed, err, datagrams;
2173 struct socket *sock;
2174 struct mmsghdr __user *entry;
2175 struct compat_mmsghdr __user *compat_entry;
2176 struct msghdr msg_sys;
c71d8ebe 2177 struct used_address used_address;
228e548e 2178
98382f41
AB
2179 if (vlen > UIO_MAXIOV)
2180 vlen = UIO_MAXIOV;
228e548e
AB
2181
2182 datagrams = 0;
2183
2184 sock = sockfd_lookup_light(fd, &err, &fput_needed);
2185 if (!sock)
2186 return err;
2187
c71d8ebe 2188 used_address.name_len = UINT_MAX;
228e548e
AB
2189 entry = mmsg;
2190 compat_entry = (struct compat_mmsghdr __user *)mmsg;
728ffb86 2191 err = 0;
228e548e
AB
2192
2193 while (datagrams < vlen) {
228e548e 2194 if (MSG_CMSG_COMPAT & flags) {
666547ff 2195 err = ___sys_sendmsg(sock, (struct user_msghdr __user *)compat_entry,
a7526eb5 2196 &msg_sys, flags, &used_address);
228e548e
AB
2197 if (err < 0)
2198 break;
2199 err = __put_user(err, &compat_entry->msg_len);
2200 ++compat_entry;
2201 } else {
a7526eb5 2202 err = ___sys_sendmsg(sock,
666547ff 2203 (struct user_msghdr __user *)entry,
a7526eb5 2204 &msg_sys, flags, &used_address);
228e548e
AB
2205 if (err < 0)
2206 break;
2207 err = put_user(err, &entry->msg_len);
2208 ++entry;
2209 }
2210
2211 if (err)
2212 break;
2213 ++datagrams;
2214 }
2215
228e548e
AB
2216 fput_light(sock->file, fput_needed);
2217
728ffb86
AB
2218 /* We only return an error if no datagrams were able to be sent */
2219 if (datagrams != 0)
228e548e
AB
2220 return datagrams;
2221
228e548e
AB
2222 return err;
2223}
2224
2225SYSCALL_DEFINE4(sendmmsg, int, fd, struct mmsghdr __user *, mmsg,
2226 unsigned int, vlen, unsigned int, flags)
2227{
1be374a0
AL
2228 if (flags & MSG_CMSG_COMPAT)
2229 return -EINVAL;
228e548e
AB
2230 return __sys_sendmmsg(fd, mmsg, vlen, flags);
2231}
2232
666547ff 2233static int ___sys_recvmsg(struct socket *sock, struct user_msghdr __user *msg,
95c96174 2234 struct msghdr *msg_sys, unsigned int flags, int nosec)
1da177e4 2235{
89bddce5
SH
2236 struct compat_msghdr __user *msg_compat =
2237 (struct compat_msghdr __user *)msg;
1da177e4 2238 struct iovec iovstack[UIO_FASTIOV];
89bddce5 2239 struct iovec *iov = iovstack;
1da177e4 2240 unsigned long cmsg_ptr;
08adb7da
AV
2241 int total_len, len;
2242 ssize_t err;
1da177e4
LT
2243
2244 /* kernel mode address */
230b1839 2245 struct sockaddr_storage addr;
1da177e4
LT
2246
2247 /* user mode address pointers */
2248 struct sockaddr __user *uaddr;
08adb7da 2249 int __user *uaddr_len = COMPAT_NAMELEN(msg);
89bddce5 2250
08adb7da 2251 msg_sys->msg_name = &addr;
1da177e4 2252
f3d33426 2253 if (MSG_CMSG_COMPAT & flags)
08adb7da 2254 err = get_compat_msghdr(msg_sys, msg_compat, &uaddr, &iov);
f3d33426 2255 else
08adb7da 2256 err = copy_msghdr_from_user(msg_sys, msg, &uaddr, &iov);
1da177e4
LT
2257 if (err < 0)
2258 goto out_freeiov;
89bddce5 2259 total_len = err;
1da177e4 2260
a2e27255
ACM
2261 cmsg_ptr = (unsigned long)msg_sys->msg_control;
2262 msg_sys->msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT);
89bddce5 2263
f3d33426
HFS
2264 /* We assume all kernel code knows the size of sockaddr_storage */
2265 msg_sys->msg_namelen = 0;
2266
1da177e4
LT
2267 if (sock->file->f_flags & O_NONBLOCK)
2268 flags |= MSG_DONTWAIT;
a2e27255
ACM
2269 err = (nosec ? sock_recvmsg_nosec : sock_recvmsg)(sock, msg_sys,
2270 total_len, flags);
1da177e4
LT
2271 if (err < 0)
2272 goto out_freeiov;
2273 len = err;
2274
2275 if (uaddr != NULL) {
43db362d 2276 err = move_addr_to_user(&addr,
a2e27255 2277 msg_sys->msg_namelen, uaddr,
89bddce5 2278 uaddr_len);
1da177e4
LT
2279 if (err < 0)
2280 goto out_freeiov;
2281 }
a2e27255 2282 err = __put_user((msg_sys->msg_flags & ~MSG_CMSG_COMPAT),
37f7f421 2283 COMPAT_FLAGS(msg));
1da177e4
LT
2284 if (err)
2285 goto out_freeiov;
2286 if (MSG_CMSG_COMPAT & flags)
a2e27255 2287 err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,
1da177e4
LT
2288 &msg_compat->msg_controllen);
2289 else
a2e27255 2290 err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,
1da177e4
LT
2291 &msg->msg_controllen);
2292 if (err)
2293 goto out_freeiov;
2294 err = len;
2295
2296out_freeiov:
2297 if (iov != iovstack)
a74e9106 2298 kfree(iov);
a2e27255
ACM
2299 return err;
2300}
2301
2302/*
2303 * BSD recvmsg interface
2304 */
2305
666547ff 2306long __sys_recvmsg(int fd, struct user_msghdr __user *msg, unsigned flags)
a2e27255
ACM
2307{
2308 int fput_needed, err;
2309 struct msghdr msg_sys;
1be374a0
AL
2310 struct socket *sock;
2311
1be374a0 2312 sock = sockfd_lookup_light(fd, &err, &fput_needed);
a2e27255
ACM
2313 if (!sock)
2314 goto out;
2315
a7526eb5 2316 err = ___sys_recvmsg(sock, msg, &msg_sys, flags, 0);
a2e27255 2317
6cb153ca 2318 fput_light(sock->file, fput_needed);
1da177e4
LT
2319out:
2320 return err;
2321}
2322
666547ff 2323SYSCALL_DEFINE3(recvmsg, int, fd, struct user_msghdr __user *, msg,
a7526eb5
AL
2324 unsigned int, flags)
2325{
2326 if (flags & MSG_CMSG_COMPAT)
2327 return -EINVAL;
2328 return __sys_recvmsg(fd, msg, flags);
2329}
2330
a2e27255
ACM
2331/*
2332 * Linux recvmmsg interface
2333 */
2334
2335int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
2336 unsigned int flags, struct timespec *timeout)
2337{
2338 int fput_needed, err, datagrams;
2339 struct socket *sock;
2340 struct mmsghdr __user *entry;
d7256d0e 2341 struct compat_mmsghdr __user *compat_entry;
a2e27255
ACM
2342 struct msghdr msg_sys;
2343 struct timespec end_time;
2344
2345 if (timeout &&
2346 poll_select_set_timeout(&end_time, timeout->tv_sec,
2347 timeout->tv_nsec))
2348 return -EINVAL;
2349
2350 datagrams = 0;
2351
2352 sock = sockfd_lookup_light(fd, &err, &fput_needed);
2353 if (!sock)
2354 return err;
2355
2356 err = sock_error(sock->sk);
2357 if (err)
2358 goto out_put;
2359
2360 entry = mmsg;
d7256d0e 2361 compat_entry = (struct compat_mmsghdr __user *)mmsg;
a2e27255
ACM
2362
2363 while (datagrams < vlen) {
2364 /*
2365 * No need to ask LSM for more than the first datagram.
2366 */
d7256d0e 2367 if (MSG_CMSG_COMPAT & flags) {
666547ff 2368 err = ___sys_recvmsg(sock, (struct user_msghdr __user *)compat_entry,
a7526eb5
AL
2369 &msg_sys, flags & ~MSG_WAITFORONE,
2370 datagrams);
d7256d0e
JMG
2371 if (err < 0)
2372 break;
2373 err = __put_user(err, &compat_entry->msg_len);
2374 ++compat_entry;
2375 } else {
a7526eb5 2376 err = ___sys_recvmsg(sock,
666547ff 2377 (struct user_msghdr __user *)entry,
a7526eb5
AL
2378 &msg_sys, flags & ~MSG_WAITFORONE,
2379 datagrams);
d7256d0e
JMG
2380 if (err < 0)
2381 break;
2382 err = put_user(err, &entry->msg_len);
2383 ++entry;
2384 }
2385
a2e27255
ACM
2386 if (err)
2387 break;
a2e27255
ACM
2388 ++datagrams;
2389
71c5c159
BB
2390 /* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */
2391 if (flags & MSG_WAITFORONE)
2392 flags |= MSG_DONTWAIT;
2393
a2e27255
ACM
2394 if (timeout) {
2395 ktime_get_ts(timeout);
2396 *timeout = timespec_sub(end_time, *timeout);
2397 if (timeout->tv_sec < 0) {
2398 timeout->tv_sec = timeout->tv_nsec = 0;
2399 break;
2400 }
2401
2402 /* Timeout, return less than vlen datagrams */
2403 if (timeout->tv_nsec == 0 && timeout->tv_sec == 0)
2404 break;
2405 }
2406
2407 /* Out of band data, return right away */
2408 if (msg_sys.msg_flags & MSG_OOB)
2409 break;
2410 }
2411
2412out_put:
2413 fput_light(sock->file, fput_needed);
1da177e4 2414
a2e27255
ACM
2415 if (err == 0)
2416 return datagrams;
2417
2418 if (datagrams != 0) {
2419 /*
2420 * We may return less entries than requested (vlen) if the
2421 * sock is non block and there aren't enough datagrams...
2422 */
2423 if (err != -EAGAIN) {
2424 /*
2425 * ... or if recvmsg returns an error after we
2426 * received some datagrams, where we record the
2427 * error to return on the next call or if the
2428 * app asks about it using getsockopt(SO_ERROR).
2429 */
2430 sock->sk->sk_err = -err;
2431 }
2432
2433 return datagrams;
2434 }
2435
2436 return err;
2437}
2438
2439SYSCALL_DEFINE5(recvmmsg, int, fd, struct mmsghdr __user *, mmsg,
2440 unsigned int, vlen, unsigned int, flags,
2441 struct timespec __user *, timeout)
2442{
2443 int datagrams;
2444 struct timespec timeout_sys;
2445
1be374a0
AL
2446 if (flags & MSG_CMSG_COMPAT)
2447 return -EINVAL;
2448
a2e27255
ACM
2449 if (!timeout)
2450 return __sys_recvmmsg(fd, mmsg, vlen, flags, NULL);
2451
2452 if (copy_from_user(&timeout_sys, timeout, sizeof(timeout_sys)))
2453 return -EFAULT;
2454
2455 datagrams = __sys_recvmmsg(fd, mmsg, vlen, flags, &timeout_sys);
2456
2457 if (datagrams > 0 &&
2458 copy_to_user(timeout, &timeout_sys, sizeof(timeout_sys)))
2459 datagrams = -EFAULT;
2460
2461 return datagrams;
2462}
2463
2464#ifdef __ARCH_WANT_SYS_SOCKETCALL
1da177e4
LT
2465/* Argument list sizes for sys_socketcall */
2466#define AL(x) ((x) * sizeof(unsigned long))
228e548e 2467static const unsigned char nargs[21] = {
c6d409cf
ED
2468 AL(0), AL(3), AL(3), AL(3), AL(2), AL(3),
2469 AL(3), AL(3), AL(4), AL(4), AL(4), AL(6),
2470 AL(6), AL(2), AL(5), AL(5), AL(3), AL(3),
228e548e 2471 AL(4), AL(5), AL(4)
89bddce5
SH
2472};
2473
1da177e4
LT
2474#undef AL
2475
2476/*
89bddce5 2477 * System call vectors.
1da177e4
LT
2478 *
2479 * Argument checking cleaned up. Saved 20% in size.
2480 * This function doesn't need to set the kernel lock because
89bddce5 2481 * it is set by the callees.
1da177e4
LT
2482 */
2483
3e0fa65f 2484SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)
1da177e4 2485{
2950fa9d 2486 unsigned long a[AUDITSC_ARGS];
89bddce5 2487 unsigned long a0, a1;
1da177e4 2488 int err;
47379052 2489 unsigned int len;
1da177e4 2490
228e548e 2491 if (call < 1 || call > SYS_SENDMMSG)
1da177e4
LT
2492 return -EINVAL;
2493
47379052
AV
2494 len = nargs[call];
2495 if (len > sizeof(a))
2496 return -EINVAL;
2497
1da177e4 2498 /* copy_from_user should be SMP safe. */
47379052 2499 if (copy_from_user(a, args, len))
1da177e4 2500 return -EFAULT;
3ec3b2fb 2501
2950fa9d
CG
2502 err = audit_socketcall(nargs[call] / sizeof(unsigned long), a);
2503 if (err)
2504 return err;
3ec3b2fb 2505
89bddce5
SH
2506 a0 = a[0];
2507 a1 = a[1];
2508
2509 switch (call) {
2510 case SYS_SOCKET:
2511 err = sys_socket(a0, a1, a[2]);
2512 break;
2513 case SYS_BIND:
2514 err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]);
2515 break;
2516 case SYS_CONNECT:
2517 err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
2518 break;
2519 case SYS_LISTEN:
2520 err = sys_listen(a0, a1);
2521 break;
2522 case SYS_ACCEPT:
de11defe
UD
2523 err = sys_accept4(a0, (struct sockaddr __user *)a1,
2524 (int __user *)a[2], 0);
89bddce5
SH
2525 break;
2526 case SYS_GETSOCKNAME:
2527 err =
2528 sys_getsockname(a0, (struct sockaddr __user *)a1,
2529 (int __user *)a[2]);
2530 break;
2531 case SYS_GETPEERNAME:
2532 err =
2533 sys_getpeername(a0, (struct sockaddr __user *)a1,
2534 (int __user *)a[2]);
2535 break;
2536 case SYS_SOCKETPAIR:
2537 err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]);
2538 break;
2539 case SYS_SEND:
2540 err = sys_send(a0, (void __user *)a1, a[2], a[3]);
2541 break;
2542 case SYS_SENDTO:
2543 err = sys_sendto(a0, (void __user *)a1, a[2], a[3],
2544 (struct sockaddr __user *)a[4], a[5]);
2545 break;
2546 case SYS_RECV:
2547 err = sys_recv(a0, (void __user *)a1, a[2], a[3]);
2548 break;
2549 case SYS_RECVFROM:
2550 err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
2551 (struct sockaddr __user *)a[4],
2552 (int __user *)a[5]);
2553 break;
2554 case SYS_SHUTDOWN:
2555 err = sys_shutdown(a0, a1);
2556 break;
2557 case SYS_SETSOCKOPT:
2558 err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]);
2559 break;
2560 case SYS_GETSOCKOPT:
2561 err =
2562 sys_getsockopt(a0, a1, a[2], (char __user *)a[3],
2563 (int __user *)a[4]);
2564 break;
2565 case SYS_SENDMSG:
666547ff 2566 err = sys_sendmsg(a0, (struct user_msghdr __user *)a1, a[2]);
89bddce5 2567 break;
228e548e
AB
2568 case SYS_SENDMMSG:
2569 err = sys_sendmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3]);
2570 break;
89bddce5 2571 case SYS_RECVMSG:
666547ff 2572 err = sys_recvmsg(a0, (struct user_msghdr __user *)a1, a[2]);
89bddce5 2573 break;
a2e27255
ACM
2574 case SYS_RECVMMSG:
2575 err = sys_recvmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3],
2576 (struct timespec __user *)a[4]);
2577 break;
de11defe
UD
2578 case SYS_ACCEPT4:
2579 err = sys_accept4(a0, (struct sockaddr __user *)a1,
2580 (int __user *)a[2], a[3]);
aaca0bdc 2581 break;
89bddce5
SH
2582 default:
2583 err = -EINVAL;
2584 break;
1da177e4
LT
2585 }
2586 return err;
2587}
2588
89bddce5 2589#endif /* __ARCH_WANT_SYS_SOCKETCALL */
1da177e4 2590
55737fda
SH
2591/**
2592 * sock_register - add a socket protocol handler
2593 * @ops: description of protocol
2594 *
1da177e4
LT
2595 * This function is called by a protocol handler that wants to
2596 * advertise its address family, and have it linked into the
e793c0f7 2597 * socket interface. The value ops->family corresponds to the
55737fda 2598 * socket system call protocol family.
1da177e4 2599 */
f0fd27d4 2600int sock_register(const struct net_proto_family *ops)
1da177e4
LT
2601{
2602 int err;
2603
2604 if (ops->family >= NPROTO) {
3410f22e 2605 pr_crit("protocol %d >= NPROTO(%d)\n", ops->family, NPROTO);
1da177e4
LT
2606 return -ENOBUFS;
2607 }
55737fda
SH
2608
2609 spin_lock(&net_family_lock);
190683a9
ED
2610 if (rcu_dereference_protected(net_families[ops->family],
2611 lockdep_is_held(&net_family_lock)))
55737fda
SH
2612 err = -EEXIST;
2613 else {
cf778b00 2614 rcu_assign_pointer(net_families[ops->family], ops);
1da177e4
LT
2615 err = 0;
2616 }
55737fda
SH
2617 spin_unlock(&net_family_lock);
2618
3410f22e 2619 pr_info("NET: Registered protocol family %d\n", ops->family);
1da177e4
LT
2620 return err;
2621}
c6d409cf 2622EXPORT_SYMBOL(sock_register);
1da177e4 2623
55737fda
SH
2624/**
2625 * sock_unregister - remove a protocol handler
2626 * @family: protocol family to remove
2627 *
1da177e4
LT
2628 * This function is called by a protocol handler that wants to
2629 * remove its address family, and have it unlinked from the
55737fda
SH
2630 * new socket creation.
2631 *
2632 * If protocol handler is a module, then it can use module reference
2633 * counts to protect against new references. If protocol handler is not
2634 * a module then it needs to provide its own protection in
2635 * the ops->create routine.
1da177e4 2636 */
f0fd27d4 2637void sock_unregister(int family)
1da177e4 2638{
f0fd27d4 2639 BUG_ON(family < 0 || family >= NPROTO);
1da177e4 2640
55737fda 2641 spin_lock(&net_family_lock);
a9b3cd7f 2642 RCU_INIT_POINTER(net_families[family], NULL);
55737fda
SH
2643 spin_unlock(&net_family_lock);
2644
2645 synchronize_rcu();
2646
3410f22e 2647 pr_info("NET: Unregistered protocol family %d\n", family);
1da177e4 2648}
c6d409cf 2649EXPORT_SYMBOL(sock_unregister);
1da177e4 2650
77d76ea3 2651static int __init sock_init(void)
1da177e4 2652{
b3e19d92 2653 int err;
2ca794e5
EB
2654 /*
2655 * Initialize the network sysctl infrastructure.
2656 */
2657 err = net_sysctl_init();
2658 if (err)
2659 goto out;
b3e19d92 2660
1da177e4 2661 /*
89bddce5 2662 * Initialize skbuff SLAB cache
1da177e4
LT
2663 */
2664 skb_init();
1da177e4
LT
2665
2666 /*
89bddce5 2667 * Initialize the protocols module.
1da177e4
LT
2668 */
2669
2670 init_inodecache();
b3e19d92
NP
2671
2672 err = register_filesystem(&sock_fs_type);
2673 if (err)
2674 goto out_fs;
1da177e4 2675 sock_mnt = kern_mount(&sock_fs_type);
b3e19d92
NP
2676 if (IS_ERR(sock_mnt)) {
2677 err = PTR_ERR(sock_mnt);
2678 goto out_mount;
2679 }
77d76ea3
AK
2680
2681 /* The real protocol initialization is performed in later initcalls.
1da177e4
LT
2682 */
2683
2684#ifdef CONFIG_NETFILTER
6d11cfdb
PNA
2685 err = netfilter_init();
2686 if (err)
2687 goto out;
1da177e4 2688#endif
cbeb321a 2689
408eccce 2690 ptp_classifier_init();
c1f19b51 2691
b3e19d92
NP
2692out:
2693 return err;
2694
2695out_mount:
2696 unregister_filesystem(&sock_fs_type);
2697out_fs:
2698 goto out;
1da177e4
LT
2699}
2700
77d76ea3
AK
2701core_initcall(sock_init); /* early initcall */
2702
1da177e4
LT
2703#ifdef CONFIG_PROC_FS
2704void socket_seq_show(struct seq_file *seq)
2705{
2706 int cpu;
2707 int counter = 0;
2708
6f912042 2709 for_each_possible_cpu(cpu)
89bddce5 2710 counter += per_cpu(sockets_in_use, cpu);
1da177e4
LT
2711
2712 /* It can be negative, by the way. 8) */
2713 if (counter < 0)
2714 counter = 0;
2715
2716 seq_printf(seq, "sockets: used %d\n", counter);
2717}
89bddce5 2718#endif /* CONFIG_PROC_FS */
1da177e4 2719
89bbfc95 2720#ifdef CONFIG_COMPAT
6b96018b 2721static int do_siocgstamp(struct net *net, struct socket *sock,
644595f8 2722 unsigned int cmd, void __user *up)
7a229387 2723{
7a229387
AB
2724 mm_segment_t old_fs = get_fs();
2725 struct timeval ktv;
2726 int err;
2727
2728 set_fs(KERNEL_DS);
6b96018b 2729 err = sock_do_ioctl(net, sock, cmd, (unsigned long)&ktv);
7a229387 2730 set_fs(old_fs);
644595f8 2731 if (!err)
ed6fe9d6 2732 err = compat_put_timeval(&ktv, up);
644595f8 2733
7a229387
AB
2734 return err;
2735}
2736
6b96018b 2737static int do_siocgstampns(struct net *net, struct socket *sock,
644595f8 2738 unsigned int cmd, void __user *up)
7a229387 2739{
7a229387
AB
2740 mm_segment_t old_fs = get_fs();
2741 struct timespec kts;
2742 int err;
2743
2744 set_fs(KERNEL_DS);
6b96018b 2745 err = sock_do_ioctl(net, sock, cmd, (unsigned long)&kts);
7a229387 2746 set_fs(old_fs);
644595f8 2747 if (!err)
ed6fe9d6 2748 err = compat_put_timespec(&kts, up);
644595f8 2749
7a229387
AB
2750 return err;
2751}
2752
6b96018b 2753static int dev_ifname32(struct net *net, struct compat_ifreq __user *uifr32)
7a229387
AB
2754{
2755 struct ifreq __user *uifr;
2756 int err;
2757
2758 uifr = compat_alloc_user_space(sizeof(struct ifreq));
6b96018b 2759 if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))
7a229387
AB
2760 return -EFAULT;
2761
6b96018b 2762 err = dev_ioctl(net, SIOCGIFNAME, uifr);
7a229387
AB
2763 if (err)
2764 return err;
2765
6b96018b 2766 if (copy_in_user(uifr32, uifr, sizeof(struct compat_ifreq)))
7a229387
AB
2767 return -EFAULT;
2768
2769 return 0;
2770}
2771
6b96018b 2772static int dev_ifconf(struct net *net, struct compat_ifconf __user *uifc32)
7a229387 2773{
6b96018b 2774 struct compat_ifconf ifc32;
7a229387
AB
2775 struct ifconf ifc;
2776 struct ifconf __user *uifc;
6b96018b 2777 struct compat_ifreq __user *ifr32;
7a229387
AB
2778 struct ifreq __user *ifr;
2779 unsigned int i, j;
2780 int err;
2781
6b96018b 2782 if (copy_from_user(&ifc32, uifc32, sizeof(struct compat_ifconf)))
7a229387
AB
2783 return -EFAULT;
2784
43da5f2e 2785 memset(&ifc, 0, sizeof(ifc));
7a229387
AB
2786 if (ifc32.ifcbuf == 0) {
2787 ifc32.ifc_len = 0;
2788 ifc.ifc_len = 0;
2789 ifc.ifc_req = NULL;
2790 uifc = compat_alloc_user_space(sizeof(struct ifconf));
2791 } else {
c6d409cf
ED
2792 size_t len = ((ifc32.ifc_len / sizeof(struct compat_ifreq)) + 1) *
2793 sizeof(struct ifreq);
7a229387
AB
2794 uifc = compat_alloc_user_space(sizeof(struct ifconf) + len);
2795 ifc.ifc_len = len;
2796 ifr = ifc.ifc_req = (void __user *)(uifc + 1);
2797 ifr32 = compat_ptr(ifc32.ifcbuf);
c6d409cf 2798 for (i = 0; i < ifc32.ifc_len; i += sizeof(struct compat_ifreq)) {
6b96018b 2799 if (copy_in_user(ifr, ifr32, sizeof(struct compat_ifreq)))
7a229387
AB
2800 return -EFAULT;
2801 ifr++;
2802 ifr32++;
2803 }
2804 }
2805 if (copy_to_user(uifc, &ifc, sizeof(struct ifconf)))
2806 return -EFAULT;
2807
6b96018b 2808 err = dev_ioctl(net, SIOCGIFCONF, uifc);
7a229387
AB
2809 if (err)
2810 return err;
2811
2812 if (copy_from_user(&ifc, uifc, sizeof(struct ifconf)))
2813 return -EFAULT;
2814
2815 ifr = ifc.ifc_req;
2816 ifr32 = compat_ptr(ifc32.ifcbuf);
2817 for (i = 0, j = 0;
c6d409cf
ED
2818 i + sizeof(struct compat_ifreq) <= ifc32.ifc_len && j < ifc.ifc_len;
2819 i += sizeof(struct compat_ifreq), j += sizeof(struct ifreq)) {
2820 if (copy_in_user(ifr32, ifr, sizeof(struct compat_ifreq)))
7a229387
AB
2821 return -EFAULT;
2822 ifr32++;
2823 ifr++;
2824 }
2825
2826 if (ifc32.ifcbuf == 0) {
2827 /* Translate from 64-bit structure multiple to
2828 * a 32-bit one.
2829 */
2830 i = ifc.ifc_len;
6b96018b 2831 i = ((i / sizeof(struct ifreq)) * sizeof(struct compat_ifreq));
7a229387
AB
2832 ifc32.ifc_len = i;
2833 } else {
2834 ifc32.ifc_len = i;
2835 }
6b96018b 2836 if (copy_to_user(uifc32, &ifc32, sizeof(struct compat_ifconf)))
7a229387
AB
2837 return -EFAULT;
2838
2839 return 0;
2840}
2841
6b96018b 2842static int ethtool_ioctl(struct net *net, struct compat_ifreq __user *ifr32)
7a229387 2843{
3a7da39d
BH
2844 struct compat_ethtool_rxnfc __user *compat_rxnfc;
2845 bool convert_in = false, convert_out = false;
2846 size_t buf_size = ALIGN(sizeof(struct ifreq), 8);
2847 struct ethtool_rxnfc __user *rxnfc;
7a229387 2848 struct ifreq __user *ifr;
3a7da39d
BH
2849 u32 rule_cnt = 0, actual_rule_cnt;
2850 u32 ethcmd;
7a229387 2851 u32 data;
3a7da39d 2852 int ret;
7a229387 2853
3a7da39d
BH
2854 if (get_user(data, &ifr32->ifr_ifru.ifru_data))
2855 return -EFAULT;
7a229387 2856
3a7da39d
BH
2857 compat_rxnfc = compat_ptr(data);
2858
2859 if (get_user(ethcmd, &compat_rxnfc->cmd))
7a229387
AB
2860 return -EFAULT;
2861
3a7da39d
BH
2862 /* Most ethtool structures are defined without padding.
2863 * Unfortunately struct ethtool_rxnfc is an exception.
2864 */
2865 switch (ethcmd) {
2866 default:
2867 break;
2868 case ETHTOOL_GRXCLSRLALL:
2869 /* Buffer size is variable */
2870 if (get_user(rule_cnt, &compat_rxnfc->rule_cnt))
2871 return -EFAULT;
2872 if (rule_cnt > KMALLOC_MAX_SIZE / sizeof(u32))
2873 return -ENOMEM;
2874 buf_size += rule_cnt * sizeof(u32);
2875 /* fall through */
2876 case ETHTOOL_GRXRINGS:
2877 case ETHTOOL_GRXCLSRLCNT:
2878 case ETHTOOL_GRXCLSRULE:
55664f32 2879 case ETHTOOL_SRXCLSRLINS:
3a7da39d
BH
2880 convert_out = true;
2881 /* fall through */
2882 case ETHTOOL_SRXCLSRLDEL:
3a7da39d
BH
2883 buf_size += sizeof(struct ethtool_rxnfc);
2884 convert_in = true;
2885 break;
2886 }
2887
2888 ifr = compat_alloc_user_space(buf_size);
954b1244 2889 rxnfc = (void __user *)ifr + ALIGN(sizeof(struct ifreq), 8);
3a7da39d
BH
2890
2891 if (copy_in_user(&ifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ))
7a229387
AB
2892 return -EFAULT;
2893
3a7da39d
BH
2894 if (put_user(convert_in ? rxnfc : compat_ptr(data),
2895 &ifr->ifr_ifru.ifru_data))
7a229387
AB
2896 return -EFAULT;
2897
3a7da39d 2898 if (convert_in) {
127fe533 2899 /* We expect there to be holes between fs.m_ext and
3a7da39d
BH
2900 * fs.ring_cookie and at the end of fs, but nowhere else.
2901 */
127fe533
AD
2902 BUILD_BUG_ON(offsetof(struct compat_ethtool_rxnfc, fs.m_ext) +
2903 sizeof(compat_rxnfc->fs.m_ext) !=
2904 offsetof(struct ethtool_rxnfc, fs.m_ext) +
2905 sizeof(rxnfc->fs.m_ext));
3a7da39d
BH
2906 BUILD_BUG_ON(
2907 offsetof(struct compat_ethtool_rxnfc, fs.location) -
2908 offsetof(struct compat_ethtool_rxnfc, fs.ring_cookie) !=
2909 offsetof(struct ethtool_rxnfc, fs.location) -
2910 offsetof(struct ethtool_rxnfc, fs.ring_cookie));
2911
2912 if (copy_in_user(rxnfc, compat_rxnfc,
954b1244
SH
2913 (void __user *)(&rxnfc->fs.m_ext + 1) -
2914 (void __user *)rxnfc) ||
3a7da39d
BH
2915 copy_in_user(&rxnfc->fs.ring_cookie,
2916 &compat_rxnfc->fs.ring_cookie,
954b1244
SH
2917 (void __user *)(&rxnfc->fs.location + 1) -
2918 (void __user *)&rxnfc->fs.ring_cookie) ||
3a7da39d
BH
2919 copy_in_user(&rxnfc->rule_cnt, &compat_rxnfc->rule_cnt,
2920 sizeof(rxnfc->rule_cnt)))
2921 return -EFAULT;
2922 }
2923
2924 ret = dev_ioctl(net, SIOCETHTOOL, ifr);
2925 if (ret)
2926 return ret;
2927
2928 if (convert_out) {
2929 if (copy_in_user(compat_rxnfc, rxnfc,
954b1244
SH
2930 (const void __user *)(&rxnfc->fs.m_ext + 1) -
2931 (const void __user *)rxnfc) ||
3a7da39d
BH
2932 copy_in_user(&compat_rxnfc->fs.ring_cookie,
2933 &rxnfc->fs.ring_cookie,
954b1244
SH
2934 (const void __user *)(&rxnfc->fs.location + 1) -
2935 (const void __user *)&rxnfc->fs.ring_cookie) ||
3a7da39d
BH
2936 copy_in_user(&compat_rxnfc->rule_cnt, &rxnfc->rule_cnt,
2937 sizeof(rxnfc->rule_cnt)))
2938 return -EFAULT;
2939
2940 if (ethcmd == ETHTOOL_GRXCLSRLALL) {
2941 /* As an optimisation, we only copy the actual
2942 * number of rules that the underlying
2943 * function returned. Since Mallory might
2944 * change the rule count in user memory, we
2945 * check that it is less than the rule count
2946 * originally given (as the user buffer size),
2947 * which has been range-checked.
2948 */
2949 if (get_user(actual_rule_cnt, &rxnfc->rule_cnt))
2950 return -EFAULT;
2951 if (actual_rule_cnt < rule_cnt)
2952 rule_cnt = actual_rule_cnt;
2953 if (copy_in_user(&compat_rxnfc->rule_locs[0],
2954 &rxnfc->rule_locs[0],
2955 rule_cnt * sizeof(u32)))
2956 return -EFAULT;
2957 }
2958 }
2959
2960 return 0;
7a229387
AB
2961}
2962
7a50a240
AB
2963static int compat_siocwandev(struct net *net, struct compat_ifreq __user *uifr32)
2964{
2965 void __user *uptr;
2966 compat_uptr_t uptr32;
2967 struct ifreq __user *uifr;
2968
c6d409cf 2969 uifr = compat_alloc_user_space(sizeof(*uifr));
7a50a240
AB
2970 if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))
2971 return -EFAULT;
2972
2973 if (get_user(uptr32, &uifr32->ifr_settings.ifs_ifsu))
2974 return -EFAULT;
2975
2976 uptr = compat_ptr(uptr32);
2977
2978 if (put_user(uptr, &uifr->ifr_settings.ifs_ifsu.raw_hdlc))
2979 return -EFAULT;
2980
2981 return dev_ioctl(net, SIOCWANDEV, uifr);
2982}
2983
6b96018b
AB
2984static int bond_ioctl(struct net *net, unsigned int cmd,
2985 struct compat_ifreq __user *ifr32)
7a229387
AB
2986{
2987 struct ifreq kifr;
7a229387
AB
2988 mm_segment_t old_fs;
2989 int err;
7a229387
AB
2990
2991 switch (cmd) {
2992 case SIOCBONDENSLAVE:
2993 case SIOCBONDRELEASE:
2994 case SIOCBONDSETHWADDR:
2995 case SIOCBONDCHANGEACTIVE:
6b96018b 2996 if (copy_from_user(&kifr, ifr32, sizeof(struct compat_ifreq)))
7a229387
AB
2997 return -EFAULT;
2998
2999 old_fs = get_fs();
c6d409cf 3000 set_fs(KERNEL_DS);
c3f52ae6 3001 err = dev_ioctl(net, cmd,
3002 (struct ifreq __user __force *) &kifr);
c6d409cf 3003 set_fs(old_fs);
7a229387
AB
3004
3005 return err;
7a229387 3006 default:
07d106d0 3007 return -ENOIOCTLCMD;
ccbd6a5a 3008 }
7a229387
AB
3009}
3010
590d4693
BH
3011/* Handle ioctls that use ifreq::ifr_data and just need struct ifreq converted */
3012static int compat_ifr_data_ioctl(struct net *net, unsigned int cmd,
6b96018b 3013 struct compat_ifreq __user *u_ifreq32)
7a229387
AB
3014{
3015 struct ifreq __user *u_ifreq64;
7a229387
AB
3016 char tmp_buf[IFNAMSIZ];
3017 void __user *data64;
3018 u32 data32;
3019
3020 if (copy_from_user(&tmp_buf[0], &(u_ifreq32->ifr_ifrn.ifrn_name[0]),
3021 IFNAMSIZ))
3022 return -EFAULT;
417c3522 3023 if (get_user(data32, &u_ifreq32->ifr_ifru.ifru_data))
7a229387
AB
3024 return -EFAULT;
3025 data64 = compat_ptr(data32);
3026
3027 u_ifreq64 = compat_alloc_user_space(sizeof(*u_ifreq64));
3028
7a229387
AB
3029 if (copy_to_user(&u_ifreq64->ifr_ifrn.ifrn_name[0], &tmp_buf[0],
3030 IFNAMSIZ))
3031 return -EFAULT;
417c3522 3032 if (put_user(data64, &u_ifreq64->ifr_ifru.ifru_data))
7a229387
AB
3033 return -EFAULT;
3034
6b96018b 3035 return dev_ioctl(net, cmd, u_ifreq64);
7a229387
AB
3036}
3037
6b96018b
AB
3038static int dev_ifsioc(struct net *net, struct socket *sock,
3039 unsigned int cmd, struct compat_ifreq __user *uifr32)
7a229387 3040{
a2116ed2 3041 struct ifreq __user *uifr;
7a229387
AB
3042 int err;
3043
a2116ed2
AB
3044 uifr = compat_alloc_user_space(sizeof(*uifr));
3045 if (copy_in_user(uifr, uifr32, sizeof(*uifr32)))
3046 return -EFAULT;
3047
3048 err = sock_do_ioctl(net, sock, cmd, (unsigned long)uifr);
3049
7a229387
AB
3050 if (!err) {
3051 switch (cmd) {
3052 case SIOCGIFFLAGS:
3053 case SIOCGIFMETRIC:
3054 case SIOCGIFMTU:
3055 case SIOCGIFMEM:
3056 case SIOCGIFHWADDR:
3057 case SIOCGIFINDEX:
3058 case SIOCGIFADDR:
3059 case SIOCGIFBRDADDR:
3060 case SIOCGIFDSTADDR:
3061 case SIOCGIFNETMASK:
fab2532b 3062 case SIOCGIFPFLAGS:
7a229387 3063 case SIOCGIFTXQLEN:
fab2532b
AB
3064 case SIOCGMIIPHY:
3065 case SIOCGMIIREG:
a2116ed2 3066 if (copy_in_user(uifr32, uifr, sizeof(*uifr32)))
7a229387
AB
3067 err = -EFAULT;
3068 break;
3069 }
3070 }
3071 return err;
3072}
3073
a2116ed2
AB
3074static int compat_sioc_ifmap(struct net *net, unsigned int cmd,
3075 struct compat_ifreq __user *uifr32)
3076{
3077 struct ifreq ifr;
3078 struct compat_ifmap __user *uifmap32;
3079 mm_segment_t old_fs;
3080 int err;
3081
3082 uifmap32 = &uifr32->ifr_ifru.ifru_map;
3083 err = copy_from_user(&ifr, uifr32, sizeof(ifr.ifr_name));
3ddc5b46
MD
3084 err |= get_user(ifr.ifr_map.mem_start, &uifmap32->mem_start);
3085 err |= get_user(ifr.ifr_map.mem_end, &uifmap32->mem_end);
3086 err |= get_user(ifr.ifr_map.base_addr, &uifmap32->base_addr);
3087 err |= get_user(ifr.ifr_map.irq, &uifmap32->irq);
3088 err |= get_user(ifr.ifr_map.dma, &uifmap32->dma);
3089 err |= get_user(ifr.ifr_map.port, &uifmap32->port);
a2116ed2
AB
3090 if (err)
3091 return -EFAULT;
3092
3093 old_fs = get_fs();
c6d409cf 3094 set_fs(KERNEL_DS);
c3f52ae6 3095 err = dev_ioctl(net, cmd, (void __user __force *)&ifr);
c6d409cf 3096 set_fs(old_fs);
a2116ed2
AB
3097
3098 if (cmd == SIOCGIFMAP && !err) {
3099 err = copy_to_user(uifr32, &ifr, sizeof(ifr.ifr_name));
3ddc5b46
MD
3100 err |= put_user(ifr.ifr_map.mem_start, &uifmap32->mem_start);
3101 err |= put_user(ifr.ifr_map.mem_end, &uifmap32->mem_end);
3102 err |= put_user(ifr.ifr_map.base_addr, &uifmap32->base_addr);
3103 err |= put_user(ifr.ifr_map.irq, &uifmap32->irq);
3104 err |= put_user(ifr.ifr_map.dma, &uifmap32->dma);
3105 err |= put_user(ifr.ifr_map.port, &uifmap32->port);
a2116ed2
AB
3106 if (err)
3107 err = -EFAULT;
3108 }
3109 return err;
3110}
3111
7a229387 3112struct rtentry32 {
c6d409cf 3113 u32 rt_pad1;
7a229387
AB
3114 struct sockaddr rt_dst; /* target address */
3115 struct sockaddr rt_gateway; /* gateway addr (RTF_GATEWAY) */
3116 struct sockaddr rt_genmask; /* target network mask (IP) */
c6d409cf
ED
3117 unsigned short rt_flags;
3118 short rt_pad2;
3119 u32 rt_pad3;
3120 unsigned char rt_tos;
3121 unsigned char rt_class;
3122 short rt_pad4;
3123 short rt_metric; /* +1 for binary compatibility! */
7a229387 3124 /* char * */ u32 rt_dev; /* forcing the device at add */
c6d409cf
ED
3125 u32 rt_mtu; /* per route MTU/Window */
3126 u32 rt_window; /* Window clamping */
7a229387
AB
3127 unsigned short rt_irtt; /* Initial RTT */
3128};
3129
3130struct in6_rtmsg32 {
3131 struct in6_addr rtmsg_dst;
3132 struct in6_addr rtmsg_src;
3133 struct in6_addr rtmsg_gateway;
3134 u32 rtmsg_type;
3135 u16 rtmsg_dst_len;
3136 u16 rtmsg_src_len;
3137 u32 rtmsg_metric;
3138 u32 rtmsg_info;
3139 u32 rtmsg_flags;
3140 s32 rtmsg_ifindex;
3141};
3142
6b96018b
AB
3143static int routing_ioctl(struct net *net, struct socket *sock,
3144 unsigned int cmd, void __user *argp)
7a229387
AB
3145{
3146 int ret;
3147 void *r = NULL;
3148 struct in6_rtmsg r6;
3149 struct rtentry r4;
3150 char devname[16];
3151 u32 rtdev;
3152 mm_segment_t old_fs = get_fs();
3153
6b96018b
AB
3154 if (sock && sock->sk && sock->sk->sk_family == AF_INET6) { /* ipv6 */
3155 struct in6_rtmsg32 __user *ur6 = argp;
c6d409cf 3156 ret = copy_from_user(&r6.rtmsg_dst, &(ur6->rtmsg_dst),
7a229387 3157 3 * sizeof(struct in6_addr));
3ddc5b46
MD
3158 ret |= get_user(r6.rtmsg_type, &(ur6->rtmsg_type));
3159 ret |= get_user(r6.rtmsg_dst_len, &(ur6->rtmsg_dst_len));
3160 ret |= get_user(r6.rtmsg_src_len, &(ur6->rtmsg_src_len));
3161 ret |= get_user(r6.rtmsg_metric, &(ur6->rtmsg_metric));
3162 ret |= get_user(r6.rtmsg_info, &(ur6->rtmsg_info));
3163 ret |= get_user(r6.rtmsg_flags, &(ur6->rtmsg_flags));
3164 ret |= get_user(r6.rtmsg_ifindex, &(ur6->rtmsg_ifindex));
7a229387
AB
3165
3166 r = (void *) &r6;
3167 } else { /* ipv4 */
6b96018b 3168 struct rtentry32 __user *ur4 = argp;
c6d409cf 3169 ret = copy_from_user(&r4.rt_dst, &(ur4->rt_dst),
7a229387 3170 3 * sizeof(struct sockaddr));
3ddc5b46
MD
3171 ret |= get_user(r4.rt_flags, &(ur4->rt_flags));
3172 ret |= get_user(r4.rt_metric, &(ur4->rt_metric));
3173 ret |= get_user(r4.rt_mtu, &(ur4->rt_mtu));
3174 ret |= get_user(r4.rt_window, &(ur4->rt_window));
3175 ret |= get_user(r4.rt_irtt, &(ur4->rt_irtt));
3176 ret |= get_user(rtdev, &(ur4->rt_dev));
7a229387 3177 if (rtdev) {
c6d409cf 3178 ret |= copy_from_user(devname, compat_ptr(rtdev), 15);
c3f52ae6 3179 r4.rt_dev = (char __user __force *)devname;
3180 devname[15] = 0;
7a229387
AB
3181 } else
3182 r4.rt_dev = NULL;
3183
3184 r = (void *) &r4;
3185 }
3186
3187 if (ret) {
3188 ret = -EFAULT;
3189 goto out;
3190 }
3191
c6d409cf 3192 set_fs(KERNEL_DS);
6b96018b 3193 ret = sock_do_ioctl(net, sock, cmd, (unsigned long) r);
c6d409cf 3194 set_fs(old_fs);
7a229387
AB
3195
3196out:
7a229387
AB
3197 return ret;
3198}
3199
3200/* Since old style bridge ioctl's endup using SIOCDEVPRIVATE
3201 * for some operations; this forces use of the newer bridge-utils that
25985edc 3202 * use compatible ioctls
7a229387 3203 */
6b96018b 3204static int old_bridge_ioctl(compat_ulong_t __user *argp)
7a229387 3205{
6b96018b 3206 compat_ulong_t tmp;
7a229387 3207
6b96018b 3208 if (get_user(tmp, argp))
7a229387
AB
3209 return -EFAULT;
3210 if (tmp == BRCTL_GET_VERSION)
3211 return BRCTL_VERSION + 1;
3212 return -EINVAL;
3213}
3214
6b96018b
AB
3215static int compat_sock_ioctl_trans(struct file *file, struct socket *sock,
3216 unsigned int cmd, unsigned long arg)
3217{
3218 void __user *argp = compat_ptr(arg);
3219 struct sock *sk = sock->sk;
3220 struct net *net = sock_net(sk);
7a229387 3221
6b96018b 3222 if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15))
590d4693 3223 return compat_ifr_data_ioctl(net, cmd, argp);
6b96018b
AB
3224
3225 switch (cmd) {
3226 case SIOCSIFBR:
3227 case SIOCGIFBR:
3228 return old_bridge_ioctl(argp);
3229 case SIOCGIFNAME:
3230 return dev_ifname32(net, argp);
3231 case SIOCGIFCONF:
3232 return dev_ifconf(net, argp);
3233 case SIOCETHTOOL:
3234 return ethtool_ioctl(net, argp);
7a50a240
AB
3235 case SIOCWANDEV:
3236 return compat_siocwandev(net, argp);
a2116ed2
AB
3237 case SIOCGIFMAP:
3238 case SIOCSIFMAP:
3239 return compat_sioc_ifmap(net, cmd, argp);
6b96018b
AB
3240 case SIOCBONDENSLAVE:
3241 case SIOCBONDRELEASE:
3242 case SIOCBONDSETHWADDR:
6b96018b
AB
3243 case SIOCBONDCHANGEACTIVE:
3244 return bond_ioctl(net, cmd, argp);
3245 case SIOCADDRT:
3246 case SIOCDELRT:
3247 return routing_ioctl(net, sock, cmd, argp);
3248 case SIOCGSTAMP:
3249 return do_siocgstamp(net, sock, cmd, argp);
3250 case SIOCGSTAMPNS:
3251 return do_siocgstampns(net, sock, cmd, argp);
590d4693
BH
3252 case SIOCBONDSLAVEINFOQUERY:
3253 case SIOCBONDINFOQUERY:
a2116ed2 3254 case SIOCSHWTSTAMP:
fd468c74 3255 case SIOCGHWTSTAMP:
590d4693 3256 return compat_ifr_data_ioctl(net, cmd, argp);
6b96018b
AB
3257
3258 case FIOSETOWN:
3259 case SIOCSPGRP:
3260 case FIOGETOWN:
3261 case SIOCGPGRP:
3262 case SIOCBRADDBR:
3263 case SIOCBRDELBR:
3264 case SIOCGIFVLAN:
3265 case SIOCSIFVLAN:
3266 case SIOCADDDLCI:
3267 case SIOCDELDLCI:
3268 return sock_ioctl(file, cmd, arg);
3269
3270 case SIOCGIFFLAGS:
3271 case SIOCSIFFLAGS:
3272 case SIOCGIFMETRIC:
3273 case SIOCSIFMETRIC:
3274 case SIOCGIFMTU:
3275 case SIOCSIFMTU:
3276 case SIOCGIFMEM:
3277 case SIOCSIFMEM:
3278 case SIOCGIFHWADDR:
3279 case SIOCSIFHWADDR:
3280 case SIOCADDMULTI:
3281 case SIOCDELMULTI:
3282 case SIOCGIFINDEX:
6b96018b
AB
3283 case SIOCGIFADDR:
3284 case SIOCSIFADDR:
3285 case SIOCSIFHWBROADCAST:
6b96018b 3286 case SIOCDIFADDR:
6b96018b
AB
3287 case SIOCGIFBRDADDR:
3288 case SIOCSIFBRDADDR:
3289 case SIOCGIFDSTADDR:
3290 case SIOCSIFDSTADDR:
3291 case SIOCGIFNETMASK:
3292 case SIOCSIFNETMASK:
3293 case SIOCSIFPFLAGS:
3294 case SIOCGIFPFLAGS:
3295 case SIOCGIFTXQLEN:
3296 case SIOCSIFTXQLEN:
3297 case SIOCBRADDIF:
3298 case SIOCBRDELIF:
9177efd3
AB
3299 case SIOCSIFNAME:
3300 case SIOCGMIIPHY:
3301 case SIOCGMIIREG:
3302 case SIOCSMIIREG:
6b96018b 3303 return dev_ifsioc(net, sock, cmd, argp);
9177efd3 3304
6b96018b
AB
3305 case SIOCSARP:
3306 case SIOCGARP:
3307 case SIOCDARP:
6b96018b 3308 case SIOCATMARK:
9177efd3
AB
3309 return sock_do_ioctl(net, sock, cmd, arg);
3310 }
3311
6b96018b
AB
3312 return -ENOIOCTLCMD;
3313}
7a229387 3314
95c96174 3315static long compat_sock_ioctl(struct file *file, unsigned int cmd,
89bddce5 3316 unsigned long arg)
89bbfc95
SP
3317{
3318 struct socket *sock = file->private_data;
3319 int ret = -ENOIOCTLCMD;
87de87d5
DM
3320 struct sock *sk;
3321 struct net *net;
3322
3323 sk = sock->sk;
3324 net = sock_net(sk);
89bbfc95
SP
3325
3326 if (sock->ops->compat_ioctl)
3327 ret = sock->ops->compat_ioctl(sock, cmd, arg);
3328
87de87d5
DM
3329 if (ret == -ENOIOCTLCMD &&
3330 (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST))
3331 ret = compat_wext_handle_ioctl(net, cmd, arg);
3332
6b96018b
AB
3333 if (ret == -ENOIOCTLCMD)
3334 ret = compat_sock_ioctl_trans(file, sock, cmd, arg);
3335
89bbfc95
SP
3336 return ret;
3337}
3338#endif
3339
ac5a488e
SS
3340int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen)
3341{
3342 return sock->ops->bind(sock, addr, addrlen);
3343}
c6d409cf 3344EXPORT_SYMBOL(kernel_bind);
ac5a488e
SS
3345
3346int kernel_listen(struct socket *sock, int backlog)
3347{
3348 return sock->ops->listen(sock, backlog);
3349}
c6d409cf 3350EXPORT_SYMBOL(kernel_listen);
ac5a488e
SS
3351
3352int kernel_accept(struct socket *sock, struct socket **newsock, int flags)
3353{
3354 struct sock *sk = sock->sk;
3355 int err;
3356
3357 err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol,
3358 newsock);
3359 if (err < 0)
3360 goto done;
3361
3362 err = sock->ops->accept(sock, *newsock, flags);
3363 if (err < 0) {
3364 sock_release(*newsock);
fa8705b0 3365 *newsock = NULL;
ac5a488e
SS
3366 goto done;
3367 }
3368
3369 (*newsock)->ops = sock->ops;
1b08534e 3370 __module_get((*newsock)->ops->owner);
ac5a488e
SS
3371
3372done:
3373 return err;
3374}
c6d409cf 3375EXPORT_SYMBOL(kernel_accept);
ac5a488e
SS
3376
3377int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen,
4768fbcb 3378 int flags)
ac5a488e
SS
3379{
3380 return sock->ops->connect(sock, addr, addrlen, flags);
3381}
c6d409cf 3382EXPORT_SYMBOL(kernel_connect);
ac5a488e
SS
3383
3384int kernel_getsockname(struct socket *sock, struct sockaddr *addr,
3385 int *addrlen)
3386{
3387 return sock->ops->getname(sock, addr, addrlen, 0);
3388}
c6d409cf 3389EXPORT_SYMBOL(kernel_getsockname);
ac5a488e
SS
3390
3391int kernel_getpeername(struct socket *sock, struct sockaddr *addr,
3392 int *addrlen)
3393{
3394 return sock->ops->getname(sock, addr, addrlen, 1);
3395}
c6d409cf 3396EXPORT_SYMBOL(kernel_getpeername);
ac5a488e
SS
3397
3398int kernel_getsockopt(struct socket *sock, int level, int optname,
3399 char *optval, int *optlen)
3400{
3401 mm_segment_t oldfs = get_fs();
fb8621bb
NK
3402 char __user *uoptval;
3403 int __user *uoptlen;
ac5a488e
SS
3404 int err;
3405
fb8621bb
NK
3406 uoptval = (char __user __force *) optval;
3407 uoptlen = (int __user __force *) optlen;
3408
ac5a488e
SS
3409 set_fs(KERNEL_DS);
3410 if (level == SOL_SOCKET)
fb8621bb 3411 err = sock_getsockopt(sock, level, optname, uoptval, uoptlen);
ac5a488e 3412 else
fb8621bb
NK
3413 err = sock->ops->getsockopt(sock, level, optname, uoptval,
3414 uoptlen);
ac5a488e
SS
3415 set_fs(oldfs);
3416 return err;
3417}
c6d409cf 3418EXPORT_SYMBOL(kernel_getsockopt);
ac5a488e
SS
3419
3420int kernel_setsockopt(struct socket *sock, int level, int optname,
b7058842 3421 char *optval, unsigned int optlen)
ac5a488e
SS
3422{
3423 mm_segment_t oldfs = get_fs();
fb8621bb 3424 char __user *uoptval;
ac5a488e
SS
3425 int err;
3426
fb8621bb
NK
3427 uoptval = (char __user __force *) optval;
3428
ac5a488e
SS
3429 set_fs(KERNEL_DS);
3430 if (level == SOL_SOCKET)
fb8621bb 3431 err = sock_setsockopt(sock, level, optname, uoptval, optlen);
ac5a488e 3432 else
fb8621bb 3433 err = sock->ops->setsockopt(sock, level, optname, uoptval,
ac5a488e
SS
3434 optlen);
3435 set_fs(oldfs);
3436 return err;
3437}
c6d409cf 3438EXPORT_SYMBOL(kernel_setsockopt);
ac5a488e
SS
3439
3440int kernel_sendpage(struct socket *sock, struct page *page, int offset,
3441 size_t size, int flags)
3442{
3443 if (sock->ops->sendpage)
3444 return sock->ops->sendpage(sock, page, offset, size, flags);
3445
3446 return sock_no_sendpage(sock, page, offset, size, flags);
3447}
c6d409cf 3448EXPORT_SYMBOL(kernel_sendpage);
ac5a488e
SS
3449
3450int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg)
3451{
3452 mm_segment_t oldfs = get_fs();
3453 int err;
3454
3455 set_fs(KERNEL_DS);
3456 err = sock->ops->ioctl(sock, cmd, arg);
3457 set_fs(oldfs);
3458
3459 return err;
3460}
c6d409cf 3461EXPORT_SYMBOL(kernel_sock_ioctl);
ac5a488e 3462
91cf45f0
TM
3463int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how)
3464{
3465 return sock->ops->shutdown(sock, how);
3466}
91cf45f0 3467EXPORT_SYMBOL(kernel_sock_shutdown);