Merge branch 'oom_fixes'
[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
140c55d4 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
6e3e939f 629 if (sock_flag(sk, SOCK_WIFI_STATUS))
140c55d4
ED
630 flags |= SKBTX_WIFI_STATUS;
631
632 *tx_flags = flags;
20d49473
PO
633}
634EXPORT_SYMBOL(sock_tx_timestamp);
635
228e548e
AB
636static inline int __sock_sendmsg_nosec(struct kiocb *iocb, struct socket *sock,
637 struct msghdr *msg, size_t size)
1da177e4
LT
638{
639 struct sock_iocb *si = kiocb_to_siocb(iocb);
1da177e4
LT
640
641 si->sock = sock;
642 si->scm = NULL;
643 si->msg = msg;
644 si->size = size;
645
1da177e4
LT
646 return sock->ops->sendmsg(iocb, sock, msg, size);
647}
648
228e548e
AB
649static inline int __sock_sendmsg(struct kiocb *iocb, struct socket *sock,
650 struct msghdr *msg, size_t size)
651{
652 int err = security_socket_sendmsg(sock, msg, size);
653
654 return err ?: __sock_sendmsg_nosec(iocb, sock, msg, size);
655}
656
1da177e4
LT
657int sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
658{
659 struct kiocb iocb;
660 struct sock_iocb siocb;
661 int ret;
662
663 init_sync_kiocb(&iocb, NULL);
664 iocb.private = &siocb;
665 ret = __sock_sendmsg(&iocb, sock, msg, size);
666 if (-EIOCBQUEUED == ret)
667 ret = wait_on_sync_kiocb(&iocb);
668 return ret;
669}
c6d409cf 670EXPORT_SYMBOL(sock_sendmsg);
1da177e4 671
894dc24c 672static int sock_sendmsg_nosec(struct socket *sock, struct msghdr *msg, size_t size)
228e548e
AB
673{
674 struct kiocb iocb;
675 struct sock_iocb siocb;
676 int ret;
677
678 init_sync_kiocb(&iocb, NULL);
679 iocb.private = &siocb;
680 ret = __sock_sendmsg_nosec(&iocb, sock, msg, size);
681 if (-EIOCBQUEUED == ret)
682 ret = wait_on_sync_kiocb(&iocb);
683 return ret;
684}
685
1da177e4
LT
686int kernel_sendmsg(struct socket *sock, struct msghdr *msg,
687 struct kvec *vec, size_t num, size_t size)
688{
689 mm_segment_t oldfs = get_fs();
690 int result;
691
692 set_fs(KERNEL_DS);
693 /*
694 * the following is safe, since for compiler definitions of kvec and
695 * iovec are identical, yielding the same in-core layout and alignment
696 */
89bddce5 697 msg->msg_iov = (struct iovec *)vec;
1da177e4
LT
698 msg->msg_iovlen = num;
699 result = sock_sendmsg(sock, msg, size);
700 set_fs(oldfs);
701 return result;
702}
c6d409cf 703EXPORT_SYMBOL(kernel_sendmsg);
1da177e4 704
92f37fd2
ED
705/*
706 * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
707 */
708void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
709 struct sk_buff *skb)
710{
20d49473 711 int need_software_tstamp = sock_flag(sk, SOCK_RCVTSTAMP);
f24b9be5 712 struct scm_timestamping tss;
20d49473
PO
713 int empty = 1;
714 struct skb_shared_hwtstamps *shhwtstamps =
715 skb_hwtstamps(skb);
716
717 /* Race occurred between timestamp enabling and packet
718 receiving. Fill in the current time for now. */
719 if (need_software_tstamp && skb->tstamp.tv64 == 0)
720 __net_timestamp(skb);
721
722 if (need_software_tstamp) {
723 if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
724 struct timeval tv;
725 skb_get_timestamp(skb, &tv);
726 put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP,
727 sizeof(tv), &tv);
728 } else {
f24b9be5
WB
729 struct timespec ts;
730 skb_get_timestampns(skb, &ts);
20d49473 731 put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS,
f24b9be5 732 sizeof(ts), &ts);
20d49473
PO
733 }
734 }
735
f24b9be5 736 memset(&tss, 0, sizeof(tss));
c199105d 737 if ((sk->sk_tsflags & SOF_TIMESTAMPING_SOFTWARE) &&
f24b9be5 738 ktime_to_timespec_cond(skb->tstamp, tss.ts + 0))
20d49473 739 empty = 0;
4d276eb6 740 if (shhwtstamps &&
b9f40e21 741 (sk->sk_tsflags & SOF_TIMESTAMPING_RAW_HARDWARE) &&
f24b9be5 742 ktime_to_timespec_cond(shhwtstamps->hwtstamp, tss.ts + 2))
4d276eb6 743 empty = 0;
20d49473
PO
744 if (!empty)
745 put_cmsg(msg, SOL_SOCKET,
f24b9be5 746 SCM_TIMESTAMPING, sizeof(tss), &tss);
92f37fd2 747}
7c81fd8b
ACM
748EXPORT_SYMBOL_GPL(__sock_recv_timestamp);
749
6e3e939f
JB
750void __sock_recv_wifi_status(struct msghdr *msg, struct sock *sk,
751 struct sk_buff *skb)
752{
753 int ack;
754
755 if (!sock_flag(sk, SOCK_WIFI_STATUS))
756 return;
757 if (!skb->wifi_acked_valid)
758 return;
759
760 ack = skb->wifi_acked;
761
762 put_cmsg(msg, SOL_SOCKET, SCM_WIFI_STATUS, sizeof(ack), &ack);
763}
764EXPORT_SYMBOL_GPL(__sock_recv_wifi_status);
765
11165f14 766static inline void sock_recv_drops(struct msghdr *msg, struct sock *sk,
767 struct sk_buff *skb)
3b885787
NH
768{
769 if (sock_flag(sk, SOCK_RXQ_OVFL) && skb && skb->dropcount)
770 put_cmsg(msg, SOL_SOCKET, SO_RXQ_OVFL,
771 sizeof(__u32), &skb->dropcount);
772}
773
767dd033 774void __sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk,
3b885787
NH
775 struct sk_buff *skb)
776{
777 sock_recv_timestamp(msg, sk, skb);
778 sock_recv_drops(msg, sk, skb);
779}
767dd033 780EXPORT_SYMBOL_GPL(__sock_recv_ts_and_drops);
3b885787 781
a2e27255
ACM
782static inline int __sock_recvmsg_nosec(struct kiocb *iocb, struct socket *sock,
783 struct msghdr *msg, size_t size, int flags)
1da177e4 784{
1da177e4
LT
785 struct sock_iocb *si = kiocb_to_siocb(iocb);
786
787 si->sock = sock;
788 si->scm = NULL;
789 si->msg = msg;
790 si->size = size;
791 si->flags = flags;
792
1da177e4
LT
793 return sock->ops->recvmsg(iocb, sock, msg, size, flags);
794}
795
a2e27255
ACM
796static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock,
797 struct msghdr *msg, size_t size, int flags)
798{
799 int err = security_socket_recvmsg(sock, msg, size, flags);
800
801 return err ?: __sock_recvmsg_nosec(iocb, sock, msg, size, flags);
802}
803
89bddce5 804int sock_recvmsg(struct socket *sock, struct msghdr *msg,
1da177e4
LT
805 size_t size, int flags)
806{
807 struct kiocb iocb;
808 struct sock_iocb siocb;
809 int ret;
810
89bddce5 811 init_sync_kiocb(&iocb, NULL);
1da177e4
LT
812 iocb.private = &siocb;
813 ret = __sock_recvmsg(&iocb, sock, msg, size, flags);
814 if (-EIOCBQUEUED == ret)
815 ret = wait_on_sync_kiocb(&iocb);
816 return ret;
817}
c6d409cf 818EXPORT_SYMBOL(sock_recvmsg);
1da177e4 819
a2e27255
ACM
820static int sock_recvmsg_nosec(struct socket *sock, struct msghdr *msg,
821 size_t size, int flags)
822{
823 struct kiocb iocb;
824 struct sock_iocb siocb;
825 int ret;
826
827 init_sync_kiocb(&iocb, NULL);
828 iocb.private = &siocb;
829 ret = __sock_recvmsg_nosec(&iocb, sock, msg, size, flags);
830 if (-EIOCBQUEUED == ret)
831 ret = wait_on_sync_kiocb(&iocb);
832 return ret;
833}
834
c1249c0a
ML
835/**
836 * kernel_recvmsg - Receive a message from a socket (kernel space)
837 * @sock: The socket to receive the message from
838 * @msg: Received message
839 * @vec: Input s/g array for message data
840 * @num: Size of input s/g array
841 * @size: Number of bytes to read
842 * @flags: Message flags (MSG_DONTWAIT, etc...)
843 *
844 * On return the msg structure contains the scatter/gather array passed in the
845 * vec argument. The array is modified so that it consists of the unfilled
846 * portion of the original array.
847 *
848 * The returned value is the total number of bytes received, or an error.
849 */
89bddce5
SH
850int kernel_recvmsg(struct socket *sock, struct msghdr *msg,
851 struct kvec *vec, size_t num, size_t size, int flags)
1da177e4
LT
852{
853 mm_segment_t oldfs = get_fs();
854 int result;
855
856 set_fs(KERNEL_DS);
857 /*
858 * the following is safe, since for compiler definitions of kvec and
859 * iovec are identical, yielding the same in-core layout and alignment
860 */
89bddce5 861 msg->msg_iov = (struct iovec *)vec, msg->msg_iovlen = num;
1da177e4
LT
862 result = sock_recvmsg(sock, msg, size, flags);
863 set_fs(oldfs);
864 return result;
865}
c6d409cf 866EXPORT_SYMBOL(kernel_recvmsg);
1da177e4 867
ce1d4d3e
CH
868static ssize_t sock_sendpage(struct file *file, struct page *page,
869 int offset, size_t size, loff_t *ppos, int more)
1da177e4 870{
1da177e4
LT
871 struct socket *sock;
872 int flags;
873
ce1d4d3e
CH
874 sock = file->private_data;
875
35f9c09f
ED
876 flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
877 /* more is a combination of MSG_MORE and MSG_SENDPAGE_NOTLAST */
878 flags |= more;
ce1d4d3e 879
e6949583 880 return kernel_sendpage(sock, page, offset, size, flags);
ce1d4d3e 881}
1da177e4 882
9c55e01c 883static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
c6d409cf 884 struct pipe_inode_info *pipe, size_t len,
9c55e01c
JA
885 unsigned int flags)
886{
887 struct socket *sock = file->private_data;
888
997b37da
RDC
889 if (unlikely(!sock->ops->splice_read))
890 return -EINVAL;
891
9c55e01c
JA
892 return sock->ops->splice_read(sock, ppos, pipe, len, flags);
893}
894
ce1d4d3e 895static struct sock_iocb *alloc_sock_iocb(struct kiocb *iocb,
89bddce5 896 struct sock_iocb *siocb)
ce1d4d3e 897{
d29c445b
KO
898 if (!is_sync_kiocb(iocb))
899 BUG();
1da177e4 900
ce1d4d3e 901 siocb->kiocb = iocb;
ce1d4d3e
CH
902 iocb->private = siocb;
903 return siocb;
1da177e4
LT
904}
905
ce1d4d3e 906static ssize_t do_sock_read(struct msghdr *msg, struct kiocb *iocb,
027445c3
BP
907 struct file *file, const struct iovec *iov,
908 unsigned long nr_segs)
ce1d4d3e
CH
909{
910 struct socket *sock = file->private_data;
911 size_t size = 0;
912 int i;
1da177e4 913
89bddce5
SH
914 for (i = 0; i < nr_segs; i++)
915 size += iov[i].iov_len;
1da177e4 916
ce1d4d3e
CH
917 msg->msg_name = NULL;
918 msg->msg_namelen = 0;
919 msg->msg_control = NULL;
920 msg->msg_controllen = 0;
89bddce5 921 msg->msg_iov = (struct iovec *)iov;
ce1d4d3e
CH
922 msg->msg_iovlen = nr_segs;
923 msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
924
925 return __sock_recvmsg(iocb, sock, msg, size, msg->msg_flags);
926}
927
027445c3
BP
928static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov,
929 unsigned long nr_segs, loff_t pos)
ce1d4d3e
CH
930{
931 struct sock_iocb siocb, *x;
932
1da177e4
LT
933 if (pos != 0)
934 return -ESPIPE;
027445c3 935
73a7075e 936 if (iocb->ki_nbytes == 0) /* Match SYS5 behaviour */
1da177e4
LT
937 return 0;
938
027445c3
BP
939
940 x = alloc_sock_iocb(iocb, &siocb);
ce1d4d3e
CH
941 if (!x)
942 return -ENOMEM;
027445c3 943 return do_sock_read(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs);
1da177e4
LT
944}
945
ce1d4d3e 946static ssize_t do_sock_write(struct msghdr *msg, struct kiocb *iocb,
027445c3
BP
947 struct file *file, const struct iovec *iov,
948 unsigned long nr_segs)
1da177e4 949{
ce1d4d3e
CH
950 struct socket *sock = file->private_data;
951 size_t size = 0;
952 int i;
1da177e4 953
89bddce5
SH
954 for (i = 0; i < nr_segs; i++)
955 size += iov[i].iov_len;
1da177e4 956
ce1d4d3e
CH
957 msg->msg_name = NULL;
958 msg->msg_namelen = 0;
959 msg->msg_control = NULL;
960 msg->msg_controllen = 0;
89bddce5 961 msg->msg_iov = (struct iovec *)iov;
ce1d4d3e
CH
962 msg->msg_iovlen = nr_segs;
963 msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
964 if (sock->type == SOCK_SEQPACKET)
965 msg->msg_flags |= MSG_EOR;
1da177e4 966
ce1d4d3e 967 return __sock_sendmsg(iocb, sock, msg, size);
1da177e4
LT
968}
969
027445c3
BP
970static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov,
971 unsigned long nr_segs, loff_t pos)
ce1d4d3e
CH
972{
973 struct sock_iocb siocb, *x;
1da177e4 974
ce1d4d3e
CH
975 if (pos != 0)
976 return -ESPIPE;
027445c3 977
027445c3 978 x = alloc_sock_iocb(iocb, &siocb);
ce1d4d3e
CH
979 if (!x)
980 return -ENOMEM;
1da177e4 981
027445c3 982 return do_sock_write(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs);
1da177e4
LT
983}
984
1da177e4
LT
985/*
986 * Atomic setting of ioctl hooks to avoid race
987 * with module unload.
988 */
989
4a3e2f71 990static DEFINE_MUTEX(br_ioctl_mutex);
c6d409cf 991static int (*br_ioctl_hook) (struct net *, unsigned int cmd, void __user *arg);
1da177e4 992
881d966b 993void brioctl_set(int (*hook) (struct net *, unsigned int, void __user *))
1da177e4 994{
4a3e2f71 995 mutex_lock(&br_ioctl_mutex);
1da177e4 996 br_ioctl_hook = hook;
4a3e2f71 997 mutex_unlock(&br_ioctl_mutex);
1da177e4
LT
998}
999EXPORT_SYMBOL(brioctl_set);
1000
4a3e2f71 1001static DEFINE_MUTEX(vlan_ioctl_mutex);
881d966b 1002static int (*vlan_ioctl_hook) (struct net *, void __user *arg);
1da177e4 1003
881d966b 1004void vlan_ioctl_set(int (*hook) (struct net *, void __user *))
1da177e4 1005{
4a3e2f71 1006 mutex_lock(&vlan_ioctl_mutex);
1da177e4 1007 vlan_ioctl_hook = hook;
4a3e2f71 1008 mutex_unlock(&vlan_ioctl_mutex);
1da177e4
LT
1009}
1010EXPORT_SYMBOL(vlan_ioctl_set);
1011
4a3e2f71 1012static DEFINE_MUTEX(dlci_ioctl_mutex);
89bddce5 1013static int (*dlci_ioctl_hook) (unsigned int, void __user *);
1da177e4 1014
89bddce5 1015void dlci_ioctl_set(int (*hook) (unsigned int, void __user *))
1da177e4 1016{
4a3e2f71 1017 mutex_lock(&dlci_ioctl_mutex);
1da177e4 1018 dlci_ioctl_hook = hook;
4a3e2f71 1019 mutex_unlock(&dlci_ioctl_mutex);
1da177e4
LT
1020}
1021EXPORT_SYMBOL(dlci_ioctl_set);
1022
6b96018b
AB
1023static long sock_do_ioctl(struct net *net, struct socket *sock,
1024 unsigned int cmd, unsigned long arg)
1025{
1026 int err;
1027 void __user *argp = (void __user *)arg;
1028
1029 err = sock->ops->ioctl(sock, cmd, arg);
1030
1031 /*
1032 * If this ioctl is unknown try to hand it down
1033 * to the NIC driver.
1034 */
1035 if (err == -ENOIOCTLCMD)
1036 err = dev_ioctl(net, cmd, argp);
1037
1038 return err;
1039}
1040
1da177e4
LT
1041/*
1042 * With an ioctl, arg may well be a user mode pointer, but we don't know
1043 * what to do with it - that's up to the protocol still.
1044 */
1045
1046static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
1047{
1048 struct socket *sock;
881d966b 1049 struct sock *sk;
1da177e4
LT
1050 void __user *argp = (void __user *)arg;
1051 int pid, err;
881d966b 1052 struct net *net;
1da177e4 1053
b69aee04 1054 sock = file->private_data;
881d966b 1055 sk = sock->sk;
3b1e0a65 1056 net = sock_net(sk);
1da177e4 1057 if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) {
881d966b 1058 err = dev_ioctl(net, cmd, argp);
1da177e4 1059 } else
3d23e349 1060#ifdef CONFIG_WEXT_CORE
1da177e4 1061 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {
881d966b 1062 err = dev_ioctl(net, cmd, argp);
1da177e4 1063 } else
3d23e349 1064#endif
89bddce5 1065 switch (cmd) {
1da177e4
LT
1066 case FIOSETOWN:
1067 case SIOCSPGRP:
1068 err = -EFAULT;
1069 if (get_user(pid, (int __user *)argp))
1070 break;
1071 err = f_setown(sock->file, pid, 1);
1072 break;
1073 case FIOGETOWN:
1074 case SIOCGPGRP:
609d7fa9 1075 err = put_user(f_getown(sock->file),
89bddce5 1076 (int __user *)argp);
1da177e4
LT
1077 break;
1078 case SIOCGIFBR:
1079 case SIOCSIFBR:
1080 case SIOCBRADDBR:
1081 case SIOCBRDELBR:
1082 err = -ENOPKG;
1083 if (!br_ioctl_hook)
1084 request_module("bridge");
1085
4a3e2f71 1086 mutex_lock(&br_ioctl_mutex);
89bddce5 1087 if (br_ioctl_hook)
881d966b 1088 err = br_ioctl_hook(net, cmd, argp);
4a3e2f71 1089 mutex_unlock(&br_ioctl_mutex);
1da177e4
LT
1090 break;
1091 case SIOCGIFVLAN:
1092 case SIOCSIFVLAN:
1093 err = -ENOPKG;
1094 if (!vlan_ioctl_hook)
1095 request_module("8021q");
1096
4a3e2f71 1097 mutex_lock(&vlan_ioctl_mutex);
1da177e4 1098 if (vlan_ioctl_hook)
881d966b 1099 err = vlan_ioctl_hook(net, argp);
4a3e2f71 1100 mutex_unlock(&vlan_ioctl_mutex);
1da177e4 1101 break;
1da177e4
LT
1102 case SIOCADDDLCI:
1103 case SIOCDELDLCI:
1104 err = -ENOPKG;
1105 if (!dlci_ioctl_hook)
1106 request_module("dlci");
1107
7512cbf6
PE
1108 mutex_lock(&dlci_ioctl_mutex);
1109 if (dlci_ioctl_hook)
1da177e4 1110 err = dlci_ioctl_hook(cmd, argp);
7512cbf6 1111 mutex_unlock(&dlci_ioctl_mutex);
1da177e4
LT
1112 break;
1113 default:
6b96018b 1114 err = sock_do_ioctl(net, sock, cmd, arg);
1da177e4 1115 break;
89bddce5 1116 }
1da177e4
LT
1117 return err;
1118}
1119
1120int sock_create_lite(int family, int type, int protocol, struct socket **res)
1121{
1122 int err;
1123 struct socket *sock = NULL;
89bddce5 1124
1da177e4
LT
1125 err = security_socket_create(family, type, protocol, 1);
1126 if (err)
1127 goto out;
1128
1129 sock = sock_alloc();
1130 if (!sock) {
1131 err = -ENOMEM;
1132 goto out;
1133 }
1134
1da177e4 1135 sock->type = type;
7420ed23
VY
1136 err = security_socket_post_create(sock, family, type, protocol, 1);
1137 if (err)
1138 goto out_release;
1139
1da177e4
LT
1140out:
1141 *res = sock;
1142 return err;
7420ed23
VY
1143out_release:
1144 sock_release(sock);
1145 sock = NULL;
1146 goto out;
1da177e4 1147}
c6d409cf 1148EXPORT_SYMBOL(sock_create_lite);
1da177e4
LT
1149
1150/* No kernel lock held - perfect */
89bddce5 1151static unsigned int sock_poll(struct file *file, poll_table *wait)
1da177e4 1152{
cbf55001 1153 unsigned int busy_flag = 0;
1da177e4
LT
1154 struct socket *sock;
1155
1156 /*
89bddce5 1157 * We can't return errors to poll, so it's either yes or no.
1da177e4 1158 */
b69aee04 1159 sock = file->private_data;
2d48d67f 1160
cbf55001 1161 if (sk_can_busy_loop(sock->sk)) {
2d48d67f 1162 /* this socket can poll_ll so tell the system call */
cbf55001 1163 busy_flag = POLL_BUSY_LOOP;
2d48d67f
ET
1164
1165 /* once, only if requested by syscall */
cbf55001
ET
1166 if (wait && (wait->_key & POLL_BUSY_LOOP))
1167 sk_busy_loop(sock->sk, 1);
2d48d67f
ET
1168 }
1169
cbf55001 1170 return busy_flag | sock->ops->poll(file, sock, wait);
1da177e4
LT
1171}
1172
89bddce5 1173static int sock_mmap(struct file *file, struct vm_area_struct *vma)
1da177e4 1174{
b69aee04 1175 struct socket *sock = file->private_data;
1da177e4
LT
1176
1177 return sock->ops->mmap(file, sock, vma);
1178}
1179
20380731 1180static int sock_close(struct inode *inode, struct file *filp)
1da177e4 1181{
1da177e4
LT
1182 sock_release(SOCKET_I(inode));
1183 return 0;
1184}
1185
1186/*
1187 * Update the socket async list
1188 *
1189 * Fasync_list locking strategy.
1190 *
1191 * 1. fasync_list is modified only under process context socket lock
1192 * i.e. under semaphore.
1193 * 2. fasync_list is used under read_lock(&sk->sk_callback_lock)
989a2979 1194 * or under socket lock
1da177e4
LT
1195 */
1196
1197static int sock_fasync(int fd, struct file *filp, int on)
1198{
989a2979
ED
1199 struct socket *sock = filp->private_data;
1200 struct sock *sk = sock->sk;
eaefd110 1201 struct socket_wq *wq;
1da177e4 1202
989a2979 1203 if (sk == NULL)
1da177e4 1204 return -EINVAL;
1da177e4
LT
1205
1206 lock_sock(sk);
eaefd110
ED
1207 wq = rcu_dereference_protected(sock->wq, sock_owned_by_user(sk));
1208 fasync_helper(fd, filp, on, &wq->fasync_list);
1da177e4 1209
eaefd110 1210 if (!wq->fasync_list)
989a2979
ED
1211 sock_reset_flag(sk, SOCK_FASYNC);
1212 else
bcdce719 1213 sock_set_flag(sk, SOCK_FASYNC);
1da177e4 1214
989a2979 1215 release_sock(sk);
1da177e4
LT
1216 return 0;
1217}
1218
43815482 1219/* This function may be called only under socket lock or callback_lock or rcu_lock */
1da177e4
LT
1220
1221int sock_wake_async(struct socket *sock, int how, int band)
1222{
43815482
ED
1223 struct socket_wq *wq;
1224
1225 if (!sock)
1226 return -1;
1227 rcu_read_lock();
1228 wq = rcu_dereference(sock->wq);
1229 if (!wq || !wq->fasync_list) {
1230 rcu_read_unlock();
1da177e4 1231 return -1;
43815482 1232 }
89bddce5 1233 switch (how) {
8d8ad9d7 1234 case SOCK_WAKE_WAITD:
1da177e4
LT
1235 if (test_bit(SOCK_ASYNC_WAITDATA, &sock->flags))
1236 break;
1237 goto call_kill;
8d8ad9d7 1238 case SOCK_WAKE_SPACE:
1da177e4
LT
1239 if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags))
1240 break;
1241 /* fall through */
8d8ad9d7 1242 case SOCK_WAKE_IO:
89bddce5 1243call_kill:
43815482 1244 kill_fasync(&wq->fasync_list, SIGIO, band);
1da177e4 1245 break;
8d8ad9d7 1246 case SOCK_WAKE_URG:
43815482 1247 kill_fasync(&wq->fasync_list, SIGURG, band);
1da177e4 1248 }
43815482 1249 rcu_read_unlock();
1da177e4
LT
1250 return 0;
1251}
c6d409cf 1252EXPORT_SYMBOL(sock_wake_async);
1da177e4 1253
721db93a 1254int __sock_create(struct net *net, int family, int type, int protocol,
89bddce5 1255 struct socket **res, int kern)
1da177e4
LT
1256{
1257 int err;
1258 struct socket *sock;
55737fda 1259 const struct net_proto_family *pf;
1da177e4
LT
1260
1261 /*
89bddce5 1262 * Check protocol is in range
1da177e4
LT
1263 */
1264 if (family < 0 || family >= NPROTO)
1265 return -EAFNOSUPPORT;
1266 if (type < 0 || type >= SOCK_MAX)
1267 return -EINVAL;
1268
1269 /* Compatibility.
1270
1271 This uglymoron is moved from INET layer to here to avoid
1272 deadlock in module load.
1273 */
1274 if (family == PF_INET && type == SOCK_PACKET) {
89bddce5 1275 static int warned;
1da177e4
LT
1276 if (!warned) {
1277 warned = 1;
3410f22e
YY
1278 pr_info("%s uses obsolete (PF_INET,SOCK_PACKET)\n",
1279 current->comm);
1da177e4
LT
1280 }
1281 family = PF_PACKET;
1282 }
1283
1284 err = security_socket_create(family, type, protocol, kern);
1285 if (err)
1286 return err;
89bddce5 1287
55737fda
SH
1288 /*
1289 * Allocate the socket and allow the family to set things up. if
1290 * the protocol is 0, the family is instructed to select an appropriate
1291 * default.
1292 */
1293 sock = sock_alloc();
1294 if (!sock) {
e87cc472 1295 net_warn_ratelimited("socket: no more sockets\n");
55737fda
SH
1296 return -ENFILE; /* Not exactly a match, but its the
1297 closest posix thing */
1298 }
1299
1300 sock->type = type;
1301
95a5afca 1302#ifdef CONFIG_MODULES
89bddce5
SH
1303 /* Attempt to load a protocol module if the find failed.
1304 *
1305 * 12/09/1996 Marcin: But! this makes REALLY only sense, if the user
1da177e4
LT
1306 * requested real, full-featured networking support upon configuration.
1307 * Otherwise module support will break!
1308 */
190683a9 1309 if (rcu_access_pointer(net_families[family]) == NULL)
89bddce5 1310 request_module("net-pf-%d", family);
1da177e4
LT
1311#endif
1312
55737fda
SH
1313 rcu_read_lock();
1314 pf = rcu_dereference(net_families[family]);
1315 err = -EAFNOSUPPORT;
1316 if (!pf)
1317 goto out_release;
1da177e4
LT
1318
1319 /*
1320 * We will call the ->create function, that possibly is in a loadable
1321 * module, so we have to bump that loadable module refcnt first.
1322 */
55737fda 1323 if (!try_module_get(pf->owner))
1da177e4
LT
1324 goto out_release;
1325
55737fda
SH
1326 /* Now protected by module ref count */
1327 rcu_read_unlock();
1328
3f378b68 1329 err = pf->create(net, sock, protocol, kern);
55737fda 1330 if (err < 0)
1da177e4 1331 goto out_module_put;
a79af59e 1332
1da177e4
LT
1333 /*
1334 * Now to bump the refcnt of the [loadable] module that owns this
1335 * socket at sock_release time we decrement its refcnt.
1336 */
55737fda
SH
1337 if (!try_module_get(sock->ops->owner))
1338 goto out_module_busy;
1339
1da177e4
LT
1340 /*
1341 * Now that we're done with the ->create function, the [loadable]
1342 * module can have its refcnt decremented
1343 */
55737fda 1344 module_put(pf->owner);
7420ed23
VY
1345 err = security_socket_post_create(sock, family, type, protocol, kern);
1346 if (err)
3b185525 1347 goto out_sock_release;
55737fda 1348 *res = sock;
1da177e4 1349
55737fda
SH
1350 return 0;
1351
1352out_module_busy:
1353 err = -EAFNOSUPPORT;
1da177e4 1354out_module_put:
55737fda
SH
1355 sock->ops = NULL;
1356 module_put(pf->owner);
1357out_sock_release:
1da177e4 1358 sock_release(sock);
55737fda
SH
1359 return err;
1360
1361out_release:
1362 rcu_read_unlock();
1363 goto out_sock_release;
1da177e4 1364}
721db93a 1365EXPORT_SYMBOL(__sock_create);
1da177e4
LT
1366
1367int sock_create(int family, int type, int protocol, struct socket **res)
1368{
1b8d7ae4 1369 return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);
1da177e4 1370}
c6d409cf 1371EXPORT_SYMBOL(sock_create);
1da177e4
LT
1372
1373int sock_create_kern(int family, int type, int protocol, struct socket **res)
1374{
1b8d7ae4 1375 return __sock_create(&init_net, family, type, protocol, res, 1);
1da177e4 1376}
c6d409cf 1377EXPORT_SYMBOL(sock_create_kern);
1da177e4 1378
3e0fa65f 1379SYSCALL_DEFINE3(socket, int, family, int, type, int, protocol)
1da177e4
LT
1380{
1381 int retval;
1382 struct socket *sock;
a677a039
UD
1383 int flags;
1384
e38b36f3
UD
1385 /* Check the SOCK_* constants for consistency. */
1386 BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);
1387 BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK);
1388 BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);
1389 BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);
1390
a677a039 1391 flags = type & ~SOCK_TYPE_MASK;
77d27200 1392 if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
a677a039
UD
1393 return -EINVAL;
1394 type &= SOCK_TYPE_MASK;
1da177e4 1395
aaca0bdc
UD
1396 if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1397 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1398
1da177e4
LT
1399 retval = sock_create(family, type, protocol, &sock);
1400 if (retval < 0)
1401 goto out;
1402
77d27200 1403 retval = sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));
1da177e4
LT
1404 if (retval < 0)
1405 goto out_release;
1406
1407out:
1408 /* It may be already another descriptor 8) Not kernel problem. */
1409 return retval;
1410
1411out_release:
1412 sock_release(sock);
1413 return retval;
1414}
1415
1416/*
1417 * Create a pair of connected sockets.
1418 */
1419
3e0fa65f
HC
1420SYSCALL_DEFINE4(socketpair, int, family, int, type, int, protocol,
1421 int __user *, usockvec)
1da177e4
LT
1422{
1423 struct socket *sock1, *sock2;
1424 int fd1, fd2, err;
db349509 1425 struct file *newfile1, *newfile2;
a677a039
UD
1426 int flags;
1427
1428 flags = type & ~SOCK_TYPE_MASK;
77d27200 1429 if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
a677a039
UD
1430 return -EINVAL;
1431 type &= SOCK_TYPE_MASK;
1da177e4 1432
aaca0bdc
UD
1433 if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1434 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1435
1da177e4
LT
1436 /*
1437 * Obtain the first socket and check if the underlying protocol
1438 * supports the socketpair call.
1439 */
1440
1441 err = sock_create(family, type, protocol, &sock1);
1442 if (err < 0)
1443 goto out;
1444
1445 err = sock_create(family, type, protocol, &sock2);
1446 if (err < 0)
1447 goto out_release_1;
1448
1449 err = sock1->ops->socketpair(sock1, sock2);
89bddce5 1450 if (err < 0)
1da177e4
LT
1451 goto out_release_both;
1452
28407630 1453 fd1 = get_unused_fd_flags(flags);
bf3c23d1
DM
1454 if (unlikely(fd1 < 0)) {
1455 err = fd1;
db349509 1456 goto out_release_both;
bf3c23d1 1457 }
d73aa286 1458
28407630 1459 fd2 = get_unused_fd_flags(flags);
198de4d7
AV
1460 if (unlikely(fd2 < 0)) {
1461 err = fd2;
d73aa286 1462 goto out_put_unused_1;
28407630
AV
1463 }
1464
aab174f0 1465 newfile1 = sock_alloc_file(sock1, flags, NULL);
28407630
AV
1466 if (unlikely(IS_ERR(newfile1))) {
1467 err = PTR_ERR(newfile1);
d73aa286 1468 goto out_put_unused_both;
28407630
AV
1469 }
1470
aab174f0 1471 newfile2 = sock_alloc_file(sock2, flags, NULL);
28407630
AV
1472 if (IS_ERR(newfile2)) {
1473 err = PTR_ERR(newfile2);
d73aa286 1474 goto out_fput_1;
db349509
AV
1475 }
1476
d73aa286
YD
1477 err = put_user(fd1, &usockvec[0]);
1478 if (err)
1479 goto out_fput_both;
1480
1481 err = put_user(fd2, &usockvec[1]);
1482 if (err)
1483 goto out_fput_both;
1484
157cf649 1485 audit_fd_pair(fd1, fd2);
d73aa286 1486
db349509
AV
1487 fd_install(fd1, newfile1);
1488 fd_install(fd2, newfile2);
1da177e4
LT
1489 /* fd1 and fd2 may be already another descriptors.
1490 * Not kernel problem.
1491 */
1492
d73aa286 1493 return 0;
1da177e4 1494
d73aa286
YD
1495out_fput_both:
1496 fput(newfile2);
1497 fput(newfile1);
1498 put_unused_fd(fd2);
1499 put_unused_fd(fd1);
1500 goto out;
1501
1502out_fput_1:
1503 fput(newfile1);
1504 put_unused_fd(fd2);
1505 put_unused_fd(fd1);
1506 sock_release(sock2);
1507 goto out;
1da177e4 1508
d73aa286
YD
1509out_put_unused_both:
1510 put_unused_fd(fd2);
1511out_put_unused_1:
1512 put_unused_fd(fd1);
1da177e4 1513out_release_both:
89bddce5 1514 sock_release(sock2);
1da177e4 1515out_release_1:
89bddce5 1516 sock_release(sock1);
1da177e4
LT
1517out:
1518 return err;
1519}
1520
1da177e4
LT
1521/*
1522 * Bind a name to a socket. Nothing much to do here since it's
1523 * the protocol's responsibility to handle the local address.
1524 *
1525 * We move the socket address to kernel space before we call
1526 * the protocol layer (having also checked the address is ok).
1527 */
1528
20f37034 1529SYSCALL_DEFINE3(bind, int, fd, struct sockaddr __user *, umyaddr, int, addrlen)
1da177e4
LT
1530{
1531 struct socket *sock;
230b1839 1532 struct sockaddr_storage address;
6cb153ca 1533 int err, fput_needed;
1da177e4 1534
89bddce5 1535 sock = sockfd_lookup_light(fd, &err, &fput_needed);
e71a4783 1536 if (sock) {
43db362d 1537 err = move_addr_to_kernel(umyaddr, addrlen, &address);
89bddce5
SH
1538 if (err >= 0) {
1539 err = security_socket_bind(sock,
230b1839 1540 (struct sockaddr *)&address,
89bddce5 1541 addrlen);
6cb153ca
BL
1542 if (!err)
1543 err = sock->ops->bind(sock,
89bddce5 1544 (struct sockaddr *)
230b1839 1545 &address, addrlen);
1da177e4 1546 }
6cb153ca 1547 fput_light(sock->file, fput_needed);
89bddce5 1548 }
1da177e4
LT
1549 return err;
1550}
1551
1da177e4
LT
1552/*
1553 * Perform a listen. Basically, we allow the protocol to do anything
1554 * necessary for a listen, and if that works, we mark the socket as
1555 * ready for listening.
1556 */
1557
3e0fa65f 1558SYSCALL_DEFINE2(listen, int, fd, int, backlog)
1da177e4
LT
1559{
1560 struct socket *sock;
6cb153ca 1561 int err, fput_needed;
b8e1f9b5 1562 int somaxconn;
89bddce5
SH
1563
1564 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1565 if (sock) {
8efa6e93 1566 somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn;
95c96174 1567 if ((unsigned int)backlog > somaxconn)
b8e1f9b5 1568 backlog = somaxconn;
1da177e4
LT
1569
1570 err = security_socket_listen(sock, backlog);
6cb153ca
BL
1571 if (!err)
1572 err = sock->ops->listen(sock, backlog);
1da177e4 1573
6cb153ca 1574 fput_light(sock->file, fput_needed);
1da177e4
LT
1575 }
1576 return err;
1577}
1578
1da177e4
LT
1579/*
1580 * For accept, we attempt to create a new socket, set up the link
1581 * with the client, wake up the client, then return the new
1582 * connected fd. We collect the address of the connector in kernel
1583 * space and move it to user at the very end. This is unclean because
1584 * we open the socket then return an error.
1585 *
1586 * 1003.1g adds the ability to recvmsg() to query connection pending
1587 * status to recvmsg. We need to add that support in a way thats
1588 * clean when we restucture accept also.
1589 */
1590
20f37034
HC
1591SYSCALL_DEFINE4(accept4, int, fd, struct sockaddr __user *, upeer_sockaddr,
1592 int __user *, upeer_addrlen, int, flags)
1da177e4
LT
1593{
1594 struct socket *sock, *newsock;
39d8c1b6 1595 struct file *newfile;
6cb153ca 1596 int err, len, newfd, fput_needed;
230b1839 1597 struct sockaddr_storage address;
1da177e4 1598
77d27200 1599 if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
aaca0bdc
UD
1600 return -EINVAL;
1601
1602 if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1603 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1604
6cb153ca 1605 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4
LT
1606 if (!sock)
1607 goto out;
1608
1609 err = -ENFILE;
c6d409cf
ED
1610 newsock = sock_alloc();
1611 if (!newsock)
1da177e4
LT
1612 goto out_put;
1613
1614 newsock->type = sock->type;
1615 newsock->ops = sock->ops;
1616
1da177e4
LT
1617 /*
1618 * We don't need try_module_get here, as the listening socket (sock)
1619 * has the protocol module (sock->ops->owner) held.
1620 */
1621 __module_get(newsock->ops->owner);
1622
28407630 1623 newfd = get_unused_fd_flags(flags);
39d8c1b6
DM
1624 if (unlikely(newfd < 0)) {
1625 err = newfd;
9a1875e6
DM
1626 sock_release(newsock);
1627 goto out_put;
39d8c1b6 1628 }
aab174f0 1629 newfile = sock_alloc_file(newsock, flags, sock->sk->sk_prot_creator->name);
28407630
AV
1630 if (unlikely(IS_ERR(newfile))) {
1631 err = PTR_ERR(newfile);
1632 put_unused_fd(newfd);
1633 sock_release(newsock);
1634 goto out_put;
1635 }
39d8c1b6 1636
a79af59e
FF
1637 err = security_socket_accept(sock, newsock);
1638 if (err)
39d8c1b6 1639 goto out_fd;
a79af59e 1640
1da177e4
LT
1641 err = sock->ops->accept(sock, newsock, sock->file->f_flags);
1642 if (err < 0)
39d8c1b6 1643 goto out_fd;
1da177e4
LT
1644
1645 if (upeer_sockaddr) {
230b1839 1646 if (newsock->ops->getname(newsock, (struct sockaddr *)&address,
89bddce5 1647 &len, 2) < 0) {
1da177e4 1648 err = -ECONNABORTED;
39d8c1b6 1649 goto out_fd;
1da177e4 1650 }
43db362d 1651 err = move_addr_to_user(&address,
230b1839 1652 len, upeer_sockaddr, upeer_addrlen);
1da177e4 1653 if (err < 0)
39d8c1b6 1654 goto out_fd;
1da177e4
LT
1655 }
1656
1657 /* File flags are not inherited via accept() unlike another OSes. */
1658
39d8c1b6
DM
1659 fd_install(newfd, newfile);
1660 err = newfd;
1da177e4 1661
1da177e4 1662out_put:
6cb153ca 1663 fput_light(sock->file, fput_needed);
1da177e4
LT
1664out:
1665 return err;
39d8c1b6 1666out_fd:
9606a216 1667 fput(newfile);
39d8c1b6 1668 put_unused_fd(newfd);
1da177e4
LT
1669 goto out_put;
1670}
1671
20f37034
HC
1672SYSCALL_DEFINE3(accept, int, fd, struct sockaddr __user *, upeer_sockaddr,
1673 int __user *, upeer_addrlen)
aaca0bdc 1674{
de11defe 1675 return sys_accept4(fd, upeer_sockaddr, upeer_addrlen, 0);
aaca0bdc
UD
1676}
1677
1da177e4
LT
1678/*
1679 * Attempt to connect to a socket with the server address. The address
1680 * is in user space so we verify it is OK and move it to kernel space.
1681 *
1682 * For 1003.1g we need to add clean support for a bind to AF_UNSPEC to
1683 * break bindings
1684 *
1685 * NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and
1686 * other SEQPACKET protocols that take time to connect() as it doesn't
1687 * include the -EINPROGRESS status for such sockets.
1688 */
1689
20f37034
HC
1690SYSCALL_DEFINE3(connect, int, fd, struct sockaddr __user *, uservaddr,
1691 int, addrlen)
1da177e4
LT
1692{
1693 struct socket *sock;
230b1839 1694 struct sockaddr_storage address;
6cb153ca 1695 int err, fput_needed;
1da177e4 1696
6cb153ca 1697 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4
LT
1698 if (!sock)
1699 goto out;
43db362d 1700 err = move_addr_to_kernel(uservaddr, addrlen, &address);
1da177e4
LT
1701 if (err < 0)
1702 goto out_put;
1703
89bddce5 1704 err =
230b1839 1705 security_socket_connect(sock, (struct sockaddr *)&address, addrlen);
1da177e4
LT
1706 if (err)
1707 goto out_put;
1708
230b1839 1709 err = sock->ops->connect(sock, (struct sockaddr *)&address, addrlen,
1da177e4
LT
1710 sock->file->f_flags);
1711out_put:
6cb153ca 1712 fput_light(sock->file, fput_needed);
1da177e4
LT
1713out:
1714 return err;
1715}
1716
1717/*
1718 * Get the local address ('name') of a socket object. Move the obtained
1719 * name to user space.
1720 */
1721
20f37034
HC
1722SYSCALL_DEFINE3(getsockname, int, fd, struct sockaddr __user *, usockaddr,
1723 int __user *, usockaddr_len)
1da177e4
LT
1724{
1725 struct socket *sock;
230b1839 1726 struct sockaddr_storage address;
6cb153ca 1727 int len, err, fput_needed;
89bddce5 1728
6cb153ca 1729 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4
LT
1730 if (!sock)
1731 goto out;
1732
1733 err = security_socket_getsockname(sock);
1734 if (err)
1735 goto out_put;
1736
230b1839 1737 err = sock->ops->getname(sock, (struct sockaddr *)&address, &len, 0);
1da177e4
LT
1738 if (err)
1739 goto out_put;
43db362d 1740 err = move_addr_to_user(&address, len, usockaddr, usockaddr_len);
1da177e4
LT
1741
1742out_put:
6cb153ca 1743 fput_light(sock->file, fput_needed);
1da177e4
LT
1744out:
1745 return err;
1746}
1747
1748/*
1749 * Get the remote address ('name') of a socket object. Move the obtained
1750 * name to user space.
1751 */
1752
20f37034
HC
1753SYSCALL_DEFINE3(getpeername, int, fd, struct sockaddr __user *, usockaddr,
1754 int __user *, usockaddr_len)
1da177e4
LT
1755{
1756 struct socket *sock;
230b1839 1757 struct sockaddr_storage address;
6cb153ca 1758 int len, err, fput_needed;
1da177e4 1759
89bddce5
SH
1760 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1761 if (sock != NULL) {
1da177e4
LT
1762 err = security_socket_getpeername(sock);
1763 if (err) {
6cb153ca 1764 fput_light(sock->file, fput_needed);
1da177e4
LT
1765 return err;
1766 }
1767
89bddce5 1768 err =
230b1839 1769 sock->ops->getname(sock, (struct sockaddr *)&address, &len,
89bddce5 1770 1);
1da177e4 1771 if (!err)
43db362d 1772 err = move_addr_to_user(&address, len, usockaddr,
89bddce5 1773 usockaddr_len);
6cb153ca 1774 fput_light(sock->file, fput_needed);
1da177e4
LT
1775 }
1776 return err;
1777}
1778
1779/*
1780 * Send a datagram to a given address. We move the address into kernel
1781 * space and check the user space data area is readable before invoking
1782 * the protocol.
1783 */
1784
3e0fa65f 1785SYSCALL_DEFINE6(sendto, int, fd, void __user *, buff, size_t, len,
95c96174 1786 unsigned int, flags, struct sockaddr __user *, addr,
3e0fa65f 1787 int, addr_len)
1da177e4
LT
1788{
1789 struct socket *sock;
230b1839 1790 struct sockaddr_storage address;
1da177e4
LT
1791 int err;
1792 struct msghdr msg;
1793 struct iovec iov;
6cb153ca 1794 int fput_needed;
6cb153ca 1795
253eacc0
LT
1796 if (len > INT_MAX)
1797 len = INT_MAX;
de0fa95c
PE
1798 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1799 if (!sock)
4387ff75 1800 goto out;
6cb153ca 1801
89bddce5
SH
1802 iov.iov_base = buff;
1803 iov.iov_len = len;
1804 msg.msg_name = NULL;
1805 msg.msg_iov = &iov;
1806 msg.msg_iovlen = 1;
1807 msg.msg_control = NULL;
1808 msg.msg_controllen = 0;
1809 msg.msg_namelen = 0;
6cb153ca 1810 if (addr) {
43db362d 1811 err = move_addr_to_kernel(addr, addr_len, &address);
1da177e4
LT
1812 if (err < 0)
1813 goto out_put;
230b1839 1814 msg.msg_name = (struct sockaddr *)&address;
89bddce5 1815 msg.msg_namelen = addr_len;
1da177e4
LT
1816 }
1817 if (sock->file->f_flags & O_NONBLOCK)
1818 flags |= MSG_DONTWAIT;
1819 msg.msg_flags = flags;
1820 err = sock_sendmsg(sock, &msg, len);
1821
89bddce5 1822out_put:
de0fa95c 1823 fput_light(sock->file, fput_needed);
4387ff75 1824out:
1da177e4
LT
1825 return err;
1826}
1827
1828/*
89bddce5 1829 * Send a datagram down a socket.
1da177e4
LT
1830 */
1831
3e0fa65f 1832SYSCALL_DEFINE4(send, int, fd, void __user *, buff, size_t, len,
95c96174 1833 unsigned int, flags)
1da177e4
LT
1834{
1835 return sys_sendto(fd, buff, len, flags, NULL, 0);
1836}
1837
1838/*
89bddce5 1839 * Receive a frame from the socket and optionally record the address of the
1da177e4
LT
1840 * sender. We verify the buffers are writable and if needed move the
1841 * sender address from kernel to user space.
1842 */
1843
3e0fa65f 1844SYSCALL_DEFINE6(recvfrom, int, fd, void __user *, ubuf, size_t, size,
95c96174 1845 unsigned int, flags, struct sockaddr __user *, addr,
3e0fa65f 1846 int __user *, addr_len)
1da177e4
LT
1847{
1848 struct socket *sock;
1849 struct iovec iov;
1850 struct msghdr msg;
230b1839 1851 struct sockaddr_storage address;
89bddce5 1852 int err, err2;
6cb153ca
BL
1853 int fput_needed;
1854
253eacc0
LT
1855 if (size > INT_MAX)
1856 size = INT_MAX;
de0fa95c 1857 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4 1858 if (!sock)
de0fa95c 1859 goto out;
1da177e4 1860
89bddce5
SH
1861 msg.msg_control = NULL;
1862 msg.msg_controllen = 0;
1863 msg.msg_iovlen = 1;
1864 msg.msg_iov = &iov;
1865 iov.iov_len = size;
1866 iov.iov_base = ubuf;
f3d33426
HFS
1867 /* Save some cycles and don't copy the address if not needed */
1868 msg.msg_name = addr ? (struct sockaddr *)&address : NULL;
1869 /* We assume all kernel code knows the size of sockaddr_storage */
1870 msg.msg_namelen = 0;
1da177e4
LT
1871 if (sock->file->f_flags & O_NONBLOCK)
1872 flags |= MSG_DONTWAIT;
89bddce5 1873 err = sock_recvmsg(sock, &msg, size, flags);
1da177e4 1874
89bddce5 1875 if (err >= 0 && addr != NULL) {
43db362d 1876 err2 = move_addr_to_user(&address,
230b1839 1877 msg.msg_namelen, addr, addr_len);
89bddce5
SH
1878 if (err2 < 0)
1879 err = err2;
1da177e4 1880 }
de0fa95c
PE
1881
1882 fput_light(sock->file, fput_needed);
4387ff75 1883out:
1da177e4
LT
1884 return err;
1885}
1886
1887/*
89bddce5 1888 * Receive a datagram from a socket.
1da177e4
LT
1889 */
1890
b7c0ddf5
JG
1891SYSCALL_DEFINE4(recv, int, fd, void __user *, ubuf, size_t, size,
1892 unsigned int, flags)
1da177e4
LT
1893{
1894 return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL);
1895}
1896
1897/*
1898 * Set a socket option. Because we don't know the option lengths we have
1899 * to pass the user mode parameter for the protocols to sort out.
1900 */
1901
20f37034
HC
1902SYSCALL_DEFINE5(setsockopt, int, fd, int, level, int, optname,
1903 char __user *, optval, int, optlen)
1da177e4 1904{
6cb153ca 1905 int err, fput_needed;
1da177e4
LT
1906 struct socket *sock;
1907
1908 if (optlen < 0)
1909 return -EINVAL;
89bddce5
SH
1910
1911 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1912 if (sock != NULL) {
1913 err = security_socket_setsockopt(sock, level, optname);
6cb153ca
BL
1914 if (err)
1915 goto out_put;
1da177e4
LT
1916
1917 if (level == SOL_SOCKET)
89bddce5
SH
1918 err =
1919 sock_setsockopt(sock, level, optname, optval,
1920 optlen);
1da177e4 1921 else
89bddce5
SH
1922 err =
1923 sock->ops->setsockopt(sock, level, optname, optval,
1924 optlen);
6cb153ca
BL
1925out_put:
1926 fput_light(sock->file, fput_needed);
1da177e4
LT
1927 }
1928 return err;
1929}
1930
1931/*
1932 * Get a socket option. Because we don't know the option lengths we have
1933 * to pass a user mode parameter for the protocols to sort out.
1934 */
1935
20f37034
HC
1936SYSCALL_DEFINE5(getsockopt, int, fd, int, level, int, optname,
1937 char __user *, optval, int __user *, optlen)
1da177e4 1938{
6cb153ca 1939 int err, fput_needed;
1da177e4
LT
1940 struct socket *sock;
1941
89bddce5
SH
1942 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1943 if (sock != NULL) {
6cb153ca
BL
1944 err = security_socket_getsockopt(sock, level, optname);
1945 if (err)
1946 goto out_put;
1da177e4
LT
1947
1948 if (level == SOL_SOCKET)
89bddce5
SH
1949 err =
1950 sock_getsockopt(sock, level, optname, optval,
1951 optlen);
1da177e4 1952 else
89bddce5
SH
1953 err =
1954 sock->ops->getsockopt(sock, level, optname, optval,
1955 optlen);
6cb153ca
BL
1956out_put:
1957 fput_light(sock->file, fput_needed);
1da177e4
LT
1958 }
1959 return err;
1960}
1961
1da177e4
LT
1962/*
1963 * Shutdown a socket.
1964 */
1965
754fe8d2 1966SYSCALL_DEFINE2(shutdown, int, fd, int, how)
1da177e4 1967{
6cb153ca 1968 int err, fput_needed;
1da177e4
LT
1969 struct socket *sock;
1970
89bddce5
SH
1971 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1972 if (sock != NULL) {
1da177e4 1973 err = security_socket_shutdown(sock, how);
6cb153ca
BL
1974 if (!err)
1975 err = sock->ops->shutdown(sock, how);
1976 fput_light(sock->file, fput_needed);
1da177e4
LT
1977 }
1978 return err;
1979}
1980
89bddce5 1981/* A couple of helpful macros for getting the address of the 32/64 bit
1da177e4
LT
1982 * fields which are the same type (int / unsigned) on our platforms.
1983 */
1984#define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member)
1985#define COMPAT_NAMELEN(msg) COMPAT_MSG(msg, msg_namelen)
1986#define COMPAT_FLAGS(msg) COMPAT_MSG(msg, msg_flags)
1987
c71d8ebe
TH
1988struct used_address {
1989 struct sockaddr_storage name;
1990 unsigned int name_len;
1991};
1992
1661bf36
DC
1993static int copy_msghdr_from_user(struct msghdr *kmsg,
1994 struct msghdr __user *umsg)
1995{
1996 if (copy_from_user(kmsg, umsg, sizeof(struct msghdr)))
1997 return -EFAULT;
dbb490b9
ML
1998
1999 if (kmsg->msg_namelen < 0)
2000 return -EINVAL;
2001
1661bf36 2002 if (kmsg->msg_namelen > sizeof(struct sockaddr_storage))
db31c55a 2003 kmsg->msg_namelen = sizeof(struct sockaddr_storage);
1661bf36
DC
2004 return 0;
2005}
2006
a7526eb5 2007static int ___sys_sendmsg(struct socket *sock, struct msghdr __user *msg,
95c96174 2008 struct msghdr *msg_sys, unsigned int flags,
c71d8ebe 2009 struct used_address *used_address)
1da177e4 2010{
89bddce5
SH
2011 struct compat_msghdr __user *msg_compat =
2012 (struct compat_msghdr __user *)msg;
230b1839 2013 struct sockaddr_storage address;
1da177e4 2014 struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
b9d717a7 2015 unsigned char ctl[sizeof(struct cmsghdr) + 20]
89bddce5
SH
2016 __attribute__ ((aligned(sizeof(__kernel_size_t))));
2017 /* 20 is size of ipv6_pktinfo */
1da177e4 2018 unsigned char *ctl_buf = ctl;
a74e9106 2019 int err, ctl_len, total_len;
89bddce5 2020
1da177e4
LT
2021 err = -EFAULT;
2022 if (MSG_CMSG_COMPAT & flags) {
228e548e 2023 if (get_compat_msghdr(msg_sys, msg_compat))
1da177e4 2024 return -EFAULT;
1661bf36
DC
2025 } else {
2026 err = copy_msghdr_from_user(msg_sys, msg);
2027 if (err)
2028 return err;
2029 }
1da177e4 2030
228e548e 2031 if (msg_sys->msg_iovlen > UIO_FASTIOV) {
a74e9106
ED
2032 err = -EMSGSIZE;
2033 if (msg_sys->msg_iovlen > UIO_MAXIOV)
2034 goto out;
2035 err = -ENOMEM;
2036 iov = kmalloc(msg_sys->msg_iovlen * sizeof(struct iovec),
2037 GFP_KERNEL);
1da177e4 2038 if (!iov)
228e548e 2039 goto out;
1da177e4
LT
2040 }
2041
2042 /* This will also move the address data into kernel space */
2043 if (MSG_CMSG_COMPAT & flags) {
43db362d 2044 err = verify_compat_iovec(msg_sys, iov, &address, VERIFY_READ);
1da177e4 2045 } else
43db362d 2046 err = verify_iovec(msg_sys, iov, &address, VERIFY_READ);
89bddce5 2047 if (err < 0)
1da177e4
LT
2048 goto out_freeiov;
2049 total_len = err;
2050
2051 err = -ENOBUFS;
2052
228e548e 2053 if (msg_sys->msg_controllen > INT_MAX)
1da177e4 2054 goto out_freeiov;
228e548e 2055 ctl_len = msg_sys->msg_controllen;
1da177e4 2056 if ((MSG_CMSG_COMPAT & flags) && ctl_len) {
89bddce5 2057 err =
228e548e 2058 cmsghdr_from_user_compat_to_kern(msg_sys, sock->sk, ctl,
89bddce5 2059 sizeof(ctl));
1da177e4
LT
2060 if (err)
2061 goto out_freeiov;
228e548e
AB
2062 ctl_buf = msg_sys->msg_control;
2063 ctl_len = msg_sys->msg_controllen;
1da177e4 2064 } else if (ctl_len) {
89bddce5 2065 if (ctl_len > sizeof(ctl)) {
1da177e4 2066 ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL);
89bddce5 2067 if (ctl_buf == NULL)
1da177e4
LT
2068 goto out_freeiov;
2069 }
2070 err = -EFAULT;
2071 /*
228e548e 2072 * Careful! Before this, msg_sys->msg_control contains a user pointer.
1da177e4
LT
2073 * Afterwards, it will be a kernel pointer. Thus the compiler-assisted
2074 * checking falls down on this.
2075 */
fb8621bb 2076 if (copy_from_user(ctl_buf,
228e548e 2077 (void __user __force *)msg_sys->msg_control,
89bddce5 2078 ctl_len))
1da177e4 2079 goto out_freectl;
228e548e 2080 msg_sys->msg_control = ctl_buf;
1da177e4 2081 }
228e548e 2082 msg_sys->msg_flags = flags;
1da177e4
LT
2083
2084 if (sock->file->f_flags & O_NONBLOCK)
228e548e 2085 msg_sys->msg_flags |= MSG_DONTWAIT;
c71d8ebe
TH
2086 /*
2087 * If this is sendmmsg() and current destination address is same as
2088 * previously succeeded address, omit asking LSM's decision.
2089 * used_address->name_len is initialized to UINT_MAX so that the first
2090 * destination address never matches.
2091 */
bc909d9d
MD
2092 if (used_address && msg_sys->msg_name &&
2093 used_address->name_len == msg_sys->msg_namelen &&
2094 !memcmp(&used_address->name, msg_sys->msg_name,
c71d8ebe
TH
2095 used_address->name_len)) {
2096 err = sock_sendmsg_nosec(sock, msg_sys, total_len);
2097 goto out_freectl;
2098 }
2099 err = sock_sendmsg(sock, msg_sys, total_len);
2100 /*
2101 * If this is sendmmsg() and sending to current destination address was
2102 * successful, remember it.
2103 */
2104 if (used_address && err >= 0) {
2105 used_address->name_len = msg_sys->msg_namelen;
bc909d9d
MD
2106 if (msg_sys->msg_name)
2107 memcpy(&used_address->name, msg_sys->msg_name,
2108 used_address->name_len);
c71d8ebe 2109 }
1da177e4
LT
2110
2111out_freectl:
89bddce5 2112 if (ctl_buf != ctl)
1da177e4
LT
2113 sock_kfree_s(sock->sk, ctl_buf, ctl_len);
2114out_freeiov:
2115 if (iov != iovstack)
a74e9106 2116 kfree(iov);
228e548e
AB
2117out:
2118 return err;
2119}
2120
2121/*
2122 * BSD sendmsg interface
2123 */
2124
a7526eb5 2125long __sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags)
228e548e
AB
2126{
2127 int fput_needed, err;
2128 struct msghdr msg_sys;
1be374a0
AL
2129 struct socket *sock;
2130
1be374a0 2131 sock = sockfd_lookup_light(fd, &err, &fput_needed);
228e548e
AB
2132 if (!sock)
2133 goto out;
2134
a7526eb5 2135 err = ___sys_sendmsg(sock, msg, &msg_sys, flags, NULL);
228e548e 2136
6cb153ca 2137 fput_light(sock->file, fput_needed);
89bddce5 2138out:
1da177e4
LT
2139 return err;
2140}
2141
a7526eb5
AL
2142SYSCALL_DEFINE3(sendmsg, int, fd, struct msghdr __user *, msg, unsigned int, flags)
2143{
2144 if (flags & MSG_CMSG_COMPAT)
2145 return -EINVAL;
2146 return __sys_sendmsg(fd, msg, flags);
2147}
2148
228e548e
AB
2149/*
2150 * Linux sendmmsg interface
2151 */
2152
2153int __sys_sendmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
2154 unsigned int flags)
2155{
2156 int fput_needed, err, datagrams;
2157 struct socket *sock;
2158 struct mmsghdr __user *entry;
2159 struct compat_mmsghdr __user *compat_entry;
2160 struct msghdr msg_sys;
c71d8ebe 2161 struct used_address used_address;
228e548e 2162
98382f41
AB
2163 if (vlen > UIO_MAXIOV)
2164 vlen = UIO_MAXIOV;
228e548e
AB
2165
2166 datagrams = 0;
2167
2168 sock = sockfd_lookup_light(fd, &err, &fput_needed);
2169 if (!sock)
2170 return err;
2171
c71d8ebe 2172 used_address.name_len = UINT_MAX;
228e548e
AB
2173 entry = mmsg;
2174 compat_entry = (struct compat_mmsghdr __user *)mmsg;
728ffb86 2175 err = 0;
228e548e
AB
2176
2177 while (datagrams < vlen) {
228e548e 2178 if (MSG_CMSG_COMPAT & flags) {
a7526eb5
AL
2179 err = ___sys_sendmsg(sock, (struct msghdr __user *)compat_entry,
2180 &msg_sys, flags, &used_address);
228e548e
AB
2181 if (err < 0)
2182 break;
2183 err = __put_user(err, &compat_entry->msg_len);
2184 ++compat_entry;
2185 } else {
a7526eb5
AL
2186 err = ___sys_sendmsg(sock,
2187 (struct msghdr __user *)entry,
2188 &msg_sys, flags, &used_address);
228e548e
AB
2189 if (err < 0)
2190 break;
2191 err = put_user(err, &entry->msg_len);
2192 ++entry;
2193 }
2194
2195 if (err)
2196 break;
2197 ++datagrams;
2198 }
2199
228e548e
AB
2200 fput_light(sock->file, fput_needed);
2201
728ffb86
AB
2202 /* We only return an error if no datagrams were able to be sent */
2203 if (datagrams != 0)
228e548e
AB
2204 return datagrams;
2205
228e548e
AB
2206 return err;
2207}
2208
2209SYSCALL_DEFINE4(sendmmsg, int, fd, struct mmsghdr __user *, mmsg,
2210 unsigned int, vlen, unsigned int, flags)
2211{
1be374a0
AL
2212 if (flags & MSG_CMSG_COMPAT)
2213 return -EINVAL;
228e548e
AB
2214 return __sys_sendmmsg(fd, mmsg, vlen, flags);
2215}
2216
a7526eb5 2217static int ___sys_recvmsg(struct socket *sock, struct msghdr __user *msg,
95c96174 2218 struct msghdr *msg_sys, unsigned int flags, int nosec)
1da177e4 2219{
89bddce5
SH
2220 struct compat_msghdr __user *msg_compat =
2221 (struct compat_msghdr __user *)msg;
1da177e4 2222 struct iovec iovstack[UIO_FASTIOV];
89bddce5 2223 struct iovec *iov = iovstack;
1da177e4 2224 unsigned long cmsg_ptr;
a74e9106 2225 int err, total_len, len;
1da177e4
LT
2226
2227 /* kernel mode address */
230b1839 2228 struct sockaddr_storage addr;
1da177e4
LT
2229
2230 /* user mode address pointers */
2231 struct sockaddr __user *uaddr;
2232 int __user *uaddr_len;
89bddce5 2233
1da177e4 2234 if (MSG_CMSG_COMPAT & flags) {
a2e27255 2235 if (get_compat_msghdr(msg_sys, msg_compat))
1da177e4 2236 return -EFAULT;
1661bf36
DC
2237 } else {
2238 err = copy_msghdr_from_user(msg_sys, msg);
2239 if (err)
2240 return err;
2241 }
1da177e4 2242
a2e27255 2243 if (msg_sys->msg_iovlen > UIO_FASTIOV) {
a74e9106
ED
2244 err = -EMSGSIZE;
2245 if (msg_sys->msg_iovlen > UIO_MAXIOV)
2246 goto out;
2247 err = -ENOMEM;
2248 iov = kmalloc(msg_sys->msg_iovlen * sizeof(struct iovec),
2249 GFP_KERNEL);
1da177e4 2250 if (!iov)
a2e27255 2251 goto out;
1da177e4
LT
2252 }
2253
f3d33426
HFS
2254 /* Save the user-mode address (verify_iovec will change the
2255 * kernel msghdr to use the kernel address space)
1da177e4 2256 */
a2e27255 2257 uaddr = (__force void __user *)msg_sys->msg_name;
1da177e4 2258 uaddr_len = COMPAT_NAMELEN(msg);
f3d33426 2259 if (MSG_CMSG_COMPAT & flags)
43db362d 2260 err = verify_compat_iovec(msg_sys, iov, &addr, VERIFY_WRITE);
f3d33426 2261 else
43db362d 2262 err = verify_iovec(msg_sys, iov, &addr, VERIFY_WRITE);
1da177e4
LT
2263 if (err < 0)
2264 goto out_freeiov;
89bddce5 2265 total_len = err;
1da177e4 2266
a2e27255
ACM
2267 cmsg_ptr = (unsigned long)msg_sys->msg_control;
2268 msg_sys->msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT);
89bddce5 2269
f3d33426
HFS
2270 /* We assume all kernel code knows the size of sockaddr_storage */
2271 msg_sys->msg_namelen = 0;
2272
1da177e4
LT
2273 if (sock->file->f_flags & O_NONBLOCK)
2274 flags |= MSG_DONTWAIT;
a2e27255
ACM
2275 err = (nosec ? sock_recvmsg_nosec : sock_recvmsg)(sock, msg_sys,
2276 total_len, flags);
1da177e4
LT
2277 if (err < 0)
2278 goto out_freeiov;
2279 len = err;
2280
2281 if (uaddr != NULL) {
43db362d 2282 err = move_addr_to_user(&addr,
a2e27255 2283 msg_sys->msg_namelen, uaddr,
89bddce5 2284 uaddr_len);
1da177e4
LT
2285 if (err < 0)
2286 goto out_freeiov;
2287 }
a2e27255 2288 err = __put_user((msg_sys->msg_flags & ~MSG_CMSG_COMPAT),
37f7f421 2289 COMPAT_FLAGS(msg));
1da177e4
LT
2290 if (err)
2291 goto out_freeiov;
2292 if (MSG_CMSG_COMPAT & flags)
a2e27255 2293 err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,
1da177e4
LT
2294 &msg_compat->msg_controllen);
2295 else
a2e27255 2296 err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,
1da177e4
LT
2297 &msg->msg_controllen);
2298 if (err)
2299 goto out_freeiov;
2300 err = len;
2301
2302out_freeiov:
2303 if (iov != iovstack)
a74e9106 2304 kfree(iov);
a2e27255
ACM
2305out:
2306 return err;
2307}
2308
2309/*
2310 * BSD recvmsg interface
2311 */
2312
a7526eb5 2313long __sys_recvmsg(int fd, struct msghdr __user *msg, unsigned flags)
a2e27255
ACM
2314{
2315 int fput_needed, err;
2316 struct msghdr msg_sys;
1be374a0
AL
2317 struct socket *sock;
2318
1be374a0 2319 sock = sockfd_lookup_light(fd, &err, &fput_needed);
a2e27255
ACM
2320 if (!sock)
2321 goto out;
2322
a7526eb5 2323 err = ___sys_recvmsg(sock, msg, &msg_sys, flags, 0);
a2e27255 2324
6cb153ca 2325 fput_light(sock->file, fput_needed);
1da177e4
LT
2326out:
2327 return err;
2328}
2329
a7526eb5
AL
2330SYSCALL_DEFINE3(recvmsg, int, fd, struct msghdr __user *, msg,
2331 unsigned int, flags)
2332{
2333 if (flags & MSG_CMSG_COMPAT)
2334 return -EINVAL;
2335 return __sys_recvmsg(fd, msg, flags);
2336}
2337
a2e27255
ACM
2338/*
2339 * Linux recvmmsg interface
2340 */
2341
2342int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
2343 unsigned int flags, struct timespec *timeout)
2344{
2345 int fput_needed, err, datagrams;
2346 struct socket *sock;
2347 struct mmsghdr __user *entry;
d7256d0e 2348 struct compat_mmsghdr __user *compat_entry;
a2e27255
ACM
2349 struct msghdr msg_sys;
2350 struct timespec end_time;
2351
2352 if (timeout &&
2353 poll_select_set_timeout(&end_time, timeout->tv_sec,
2354 timeout->tv_nsec))
2355 return -EINVAL;
2356
2357 datagrams = 0;
2358
2359 sock = sockfd_lookup_light(fd, &err, &fput_needed);
2360 if (!sock)
2361 return err;
2362
2363 err = sock_error(sock->sk);
2364 if (err)
2365 goto out_put;
2366
2367 entry = mmsg;
d7256d0e 2368 compat_entry = (struct compat_mmsghdr __user *)mmsg;
a2e27255
ACM
2369
2370 while (datagrams < vlen) {
2371 /*
2372 * No need to ask LSM for more than the first datagram.
2373 */
d7256d0e 2374 if (MSG_CMSG_COMPAT & flags) {
a7526eb5
AL
2375 err = ___sys_recvmsg(sock, (struct msghdr __user *)compat_entry,
2376 &msg_sys, flags & ~MSG_WAITFORONE,
2377 datagrams);
d7256d0e
JMG
2378 if (err < 0)
2379 break;
2380 err = __put_user(err, &compat_entry->msg_len);
2381 ++compat_entry;
2382 } else {
a7526eb5
AL
2383 err = ___sys_recvmsg(sock,
2384 (struct msghdr __user *)entry,
2385 &msg_sys, flags & ~MSG_WAITFORONE,
2386 datagrams);
d7256d0e
JMG
2387 if (err < 0)
2388 break;
2389 err = put_user(err, &entry->msg_len);
2390 ++entry;
2391 }
2392
a2e27255
ACM
2393 if (err)
2394 break;
a2e27255
ACM
2395 ++datagrams;
2396
71c5c159
BB
2397 /* MSG_WAITFORONE turns on MSG_DONTWAIT after one packet */
2398 if (flags & MSG_WAITFORONE)
2399 flags |= MSG_DONTWAIT;
2400
a2e27255
ACM
2401 if (timeout) {
2402 ktime_get_ts(timeout);
2403 *timeout = timespec_sub(end_time, *timeout);
2404 if (timeout->tv_sec < 0) {
2405 timeout->tv_sec = timeout->tv_nsec = 0;
2406 break;
2407 }
2408
2409 /* Timeout, return less than vlen datagrams */
2410 if (timeout->tv_nsec == 0 && timeout->tv_sec == 0)
2411 break;
2412 }
2413
2414 /* Out of band data, return right away */
2415 if (msg_sys.msg_flags & MSG_OOB)
2416 break;
2417 }
2418
2419out_put:
2420 fput_light(sock->file, fput_needed);
1da177e4 2421
a2e27255
ACM
2422 if (err == 0)
2423 return datagrams;
2424
2425 if (datagrams != 0) {
2426 /*
2427 * We may return less entries than requested (vlen) if the
2428 * sock is non block and there aren't enough datagrams...
2429 */
2430 if (err != -EAGAIN) {
2431 /*
2432 * ... or if recvmsg returns an error after we
2433 * received some datagrams, where we record the
2434 * error to return on the next call or if the
2435 * app asks about it using getsockopt(SO_ERROR).
2436 */
2437 sock->sk->sk_err = -err;
2438 }
2439
2440 return datagrams;
2441 }
2442
2443 return err;
2444}
2445
2446SYSCALL_DEFINE5(recvmmsg, int, fd, struct mmsghdr __user *, mmsg,
2447 unsigned int, vlen, unsigned int, flags,
2448 struct timespec __user *, timeout)
2449{
2450 int datagrams;
2451 struct timespec timeout_sys;
2452
1be374a0
AL
2453 if (flags & MSG_CMSG_COMPAT)
2454 return -EINVAL;
2455
a2e27255
ACM
2456 if (!timeout)
2457 return __sys_recvmmsg(fd, mmsg, vlen, flags, NULL);
2458
2459 if (copy_from_user(&timeout_sys, timeout, sizeof(timeout_sys)))
2460 return -EFAULT;
2461
2462 datagrams = __sys_recvmmsg(fd, mmsg, vlen, flags, &timeout_sys);
2463
2464 if (datagrams > 0 &&
2465 copy_to_user(timeout, &timeout_sys, sizeof(timeout_sys)))
2466 datagrams = -EFAULT;
2467
2468 return datagrams;
2469}
2470
2471#ifdef __ARCH_WANT_SYS_SOCKETCALL
1da177e4
LT
2472/* Argument list sizes for sys_socketcall */
2473#define AL(x) ((x) * sizeof(unsigned long))
228e548e 2474static const unsigned char nargs[21] = {
c6d409cf
ED
2475 AL(0), AL(3), AL(3), AL(3), AL(2), AL(3),
2476 AL(3), AL(3), AL(4), AL(4), AL(4), AL(6),
2477 AL(6), AL(2), AL(5), AL(5), AL(3), AL(3),
228e548e 2478 AL(4), AL(5), AL(4)
89bddce5
SH
2479};
2480
1da177e4
LT
2481#undef AL
2482
2483/*
89bddce5 2484 * System call vectors.
1da177e4
LT
2485 *
2486 * Argument checking cleaned up. Saved 20% in size.
2487 * This function doesn't need to set the kernel lock because
89bddce5 2488 * it is set by the callees.
1da177e4
LT
2489 */
2490
3e0fa65f 2491SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)
1da177e4 2492{
2950fa9d 2493 unsigned long a[AUDITSC_ARGS];
89bddce5 2494 unsigned long a0, a1;
1da177e4 2495 int err;
47379052 2496 unsigned int len;
1da177e4 2497
228e548e 2498 if (call < 1 || call > SYS_SENDMMSG)
1da177e4
LT
2499 return -EINVAL;
2500
47379052
AV
2501 len = nargs[call];
2502 if (len > sizeof(a))
2503 return -EINVAL;
2504
1da177e4 2505 /* copy_from_user should be SMP safe. */
47379052 2506 if (copy_from_user(a, args, len))
1da177e4 2507 return -EFAULT;
3ec3b2fb 2508
2950fa9d
CG
2509 err = audit_socketcall(nargs[call] / sizeof(unsigned long), a);
2510 if (err)
2511 return err;
3ec3b2fb 2512
89bddce5
SH
2513 a0 = a[0];
2514 a1 = a[1];
2515
2516 switch (call) {
2517 case SYS_SOCKET:
2518 err = sys_socket(a0, a1, a[2]);
2519 break;
2520 case SYS_BIND:
2521 err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]);
2522 break;
2523 case SYS_CONNECT:
2524 err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
2525 break;
2526 case SYS_LISTEN:
2527 err = sys_listen(a0, a1);
2528 break;
2529 case SYS_ACCEPT:
de11defe
UD
2530 err = sys_accept4(a0, (struct sockaddr __user *)a1,
2531 (int __user *)a[2], 0);
89bddce5
SH
2532 break;
2533 case SYS_GETSOCKNAME:
2534 err =
2535 sys_getsockname(a0, (struct sockaddr __user *)a1,
2536 (int __user *)a[2]);
2537 break;
2538 case SYS_GETPEERNAME:
2539 err =
2540 sys_getpeername(a0, (struct sockaddr __user *)a1,
2541 (int __user *)a[2]);
2542 break;
2543 case SYS_SOCKETPAIR:
2544 err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]);
2545 break;
2546 case SYS_SEND:
2547 err = sys_send(a0, (void __user *)a1, a[2], a[3]);
2548 break;
2549 case SYS_SENDTO:
2550 err = sys_sendto(a0, (void __user *)a1, a[2], a[3],
2551 (struct sockaddr __user *)a[4], a[5]);
2552 break;
2553 case SYS_RECV:
2554 err = sys_recv(a0, (void __user *)a1, a[2], a[3]);
2555 break;
2556 case SYS_RECVFROM:
2557 err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
2558 (struct sockaddr __user *)a[4],
2559 (int __user *)a[5]);
2560 break;
2561 case SYS_SHUTDOWN:
2562 err = sys_shutdown(a0, a1);
2563 break;
2564 case SYS_SETSOCKOPT:
2565 err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]);
2566 break;
2567 case SYS_GETSOCKOPT:
2568 err =
2569 sys_getsockopt(a0, a1, a[2], (char __user *)a[3],
2570 (int __user *)a[4]);
2571 break;
2572 case SYS_SENDMSG:
2573 err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]);
2574 break;
228e548e
AB
2575 case SYS_SENDMMSG:
2576 err = sys_sendmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3]);
2577 break;
89bddce5
SH
2578 case SYS_RECVMSG:
2579 err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]);
2580 break;
a2e27255
ACM
2581 case SYS_RECVMMSG:
2582 err = sys_recvmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3],
2583 (struct timespec __user *)a[4]);
2584 break;
de11defe
UD
2585 case SYS_ACCEPT4:
2586 err = sys_accept4(a0, (struct sockaddr __user *)a1,
2587 (int __user *)a[2], a[3]);
aaca0bdc 2588 break;
89bddce5
SH
2589 default:
2590 err = -EINVAL;
2591 break;
1da177e4
LT
2592 }
2593 return err;
2594}
2595
89bddce5 2596#endif /* __ARCH_WANT_SYS_SOCKETCALL */
1da177e4 2597
55737fda
SH
2598/**
2599 * sock_register - add a socket protocol handler
2600 * @ops: description of protocol
2601 *
1da177e4
LT
2602 * This function is called by a protocol handler that wants to
2603 * advertise its address family, and have it linked into the
e793c0f7 2604 * socket interface. The value ops->family corresponds to the
55737fda 2605 * socket system call protocol family.
1da177e4 2606 */
f0fd27d4 2607int sock_register(const struct net_proto_family *ops)
1da177e4
LT
2608{
2609 int err;
2610
2611 if (ops->family >= NPROTO) {
3410f22e 2612 pr_crit("protocol %d >= NPROTO(%d)\n", ops->family, NPROTO);
1da177e4
LT
2613 return -ENOBUFS;
2614 }
55737fda
SH
2615
2616 spin_lock(&net_family_lock);
190683a9
ED
2617 if (rcu_dereference_protected(net_families[ops->family],
2618 lockdep_is_held(&net_family_lock)))
55737fda
SH
2619 err = -EEXIST;
2620 else {
cf778b00 2621 rcu_assign_pointer(net_families[ops->family], ops);
1da177e4
LT
2622 err = 0;
2623 }
55737fda
SH
2624 spin_unlock(&net_family_lock);
2625
3410f22e 2626 pr_info("NET: Registered protocol family %d\n", ops->family);
1da177e4
LT
2627 return err;
2628}
c6d409cf 2629EXPORT_SYMBOL(sock_register);
1da177e4 2630
55737fda
SH
2631/**
2632 * sock_unregister - remove a protocol handler
2633 * @family: protocol family to remove
2634 *
1da177e4
LT
2635 * This function is called by a protocol handler that wants to
2636 * remove its address family, and have it unlinked from the
55737fda
SH
2637 * new socket creation.
2638 *
2639 * If protocol handler is a module, then it can use module reference
2640 * counts to protect against new references. If protocol handler is not
2641 * a module then it needs to provide its own protection in
2642 * the ops->create routine.
1da177e4 2643 */
f0fd27d4 2644void sock_unregister(int family)
1da177e4 2645{
f0fd27d4 2646 BUG_ON(family < 0 || family >= NPROTO);
1da177e4 2647
55737fda 2648 spin_lock(&net_family_lock);
a9b3cd7f 2649 RCU_INIT_POINTER(net_families[family], NULL);
55737fda
SH
2650 spin_unlock(&net_family_lock);
2651
2652 synchronize_rcu();
2653
3410f22e 2654 pr_info("NET: Unregistered protocol family %d\n", family);
1da177e4 2655}
c6d409cf 2656EXPORT_SYMBOL(sock_unregister);
1da177e4 2657
77d76ea3 2658static int __init sock_init(void)
1da177e4 2659{
b3e19d92 2660 int err;
2ca794e5
EB
2661 /*
2662 * Initialize the network sysctl infrastructure.
2663 */
2664 err = net_sysctl_init();
2665 if (err)
2666 goto out;
b3e19d92 2667
1da177e4 2668 /*
89bddce5 2669 * Initialize skbuff SLAB cache
1da177e4
LT
2670 */
2671 skb_init();
1da177e4
LT
2672
2673 /*
89bddce5 2674 * Initialize the protocols module.
1da177e4
LT
2675 */
2676
2677 init_inodecache();
b3e19d92
NP
2678
2679 err = register_filesystem(&sock_fs_type);
2680 if (err)
2681 goto out_fs;
1da177e4 2682 sock_mnt = kern_mount(&sock_fs_type);
b3e19d92
NP
2683 if (IS_ERR(sock_mnt)) {
2684 err = PTR_ERR(sock_mnt);
2685 goto out_mount;
2686 }
77d76ea3
AK
2687
2688 /* The real protocol initialization is performed in later initcalls.
1da177e4
LT
2689 */
2690
2691#ifdef CONFIG_NETFILTER
6d11cfdb
PNA
2692 err = netfilter_init();
2693 if (err)
2694 goto out;
1da177e4 2695#endif
cbeb321a 2696
408eccce 2697 ptp_classifier_init();
c1f19b51 2698
b3e19d92
NP
2699out:
2700 return err;
2701
2702out_mount:
2703 unregister_filesystem(&sock_fs_type);
2704out_fs:
2705 goto out;
1da177e4
LT
2706}
2707
77d76ea3
AK
2708core_initcall(sock_init); /* early initcall */
2709
1da177e4
LT
2710#ifdef CONFIG_PROC_FS
2711void socket_seq_show(struct seq_file *seq)
2712{
2713 int cpu;
2714 int counter = 0;
2715
6f912042 2716 for_each_possible_cpu(cpu)
89bddce5 2717 counter += per_cpu(sockets_in_use, cpu);
1da177e4
LT
2718
2719 /* It can be negative, by the way. 8) */
2720 if (counter < 0)
2721 counter = 0;
2722
2723 seq_printf(seq, "sockets: used %d\n", counter);
2724}
89bddce5 2725#endif /* CONFIG_PROC_FS */
1da177e4 2726
89bbfc95 2727#ifdef CONFIG_COMPAT
6b96018b 2728static int do_siocgstamp(struct net *net, struct socket *sock,
644595f8 2729 unsigned int cmd, void __user *up)
7a229387 2730{
7a229387
AB
2731 mm_segment_t old_fs = get_fs();
2732 struct timeval ktv;
2733 int err;
2734
2735 set_fs(KERNEL_DS);
6b96018b 2736 err = sock_do_ioctl(net, sock, cmd, (unsigned long)&ktv);
7a229387 2737 set_fs(old_fs);
644595f8 2738 if (!err)
ed6fe9d6 2739 err = compat_put_timeval(&ktv, up);
644595f8 2740
7a229387
AB
2741 return err;
2742}
2743
6b96018b 2744static int do_siocgstampns(struct net *net, struct socket *sock,
644595f8 2745 unsigned int cmd, void __user *up)
7a229387 2746{
7a229387
AB
2747 mm_segment_t old_fs = get_fs();
2748 struct timespec kts;
2749 int err;
2750
2751 set_fs(KERNEL_DS);
6b96018b 2752 err = sock_do_ioctl(net, sock, cmd, (unsigned long)&kts);
7a229387 2753 set_fs(old_fs);
644595f8 2754 if (!err)
ed6fe9d6 2755 err = compat_put_timespec(&kts, up);
644595f8 2756
7a229387
AB
2757 return err;
2758}
2759
6b96018b 2760static int dev_ifname32(struct net *net, struct compat_ifreq __user *uifr32)
7a229387
AB
2761{
2762 struct ifreq __user *uifr;
2763 int err;
2764
2765 uifr = compat_alloc_user_space(sizeof(struct ifreq));
6b96018b 2766 if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))
7a229387
AB
2767 return -EFAULT;
2768
6b96018b 2769 err = dev_ioctl(net, SIOCGIFNAME, uifr);
7a229387
AB
2770 if (err)
2771 return err;
2772
6b96018b 2773 if (copy_in_user(uifr32, uifr, sizeof(struct compat_ifreq)))
7a229387
AB
2774 return -EFAULT;
2775
2776 return 0;
2777}
2778
6b96018b 2779static int dev_ifconf(struct net *net, struct compat_ifconf __user *uifc32)
7a229387 2780{
6b96018b 2781 struct compat_ifconf ifc32;
7a229387
AB
2782 struct ifconf ifc;
2783 struct ifconf __user *uifc;
6b96018b 2784 struct compat_ifreq __user *ifr32;
7a229387
AB
2785 struct ifreq __user *ifr;
2786 unsigned int i, j;
2787 int err;
2788
6b96018b 2789 if (copy_from_user(&ifc32, uifc32, sizeof(struct compat_ifconf)))
7a229387
AB
2790 return -EFAULT;
2791
43da5f2e 2792 memset(&ifc, 0, sizeof(ifc));
7a229387
AB
2793 if (ifc32.ifcbuf == 0) {
2794 ifc32.ifc_len = 0;
2795 ifc.ifc_len = 0;
2796 ifc.ifc_req = NULL;
2797 uifc = compat_alloc_user_space(sizeof(struct ifconf));
2798 } else {
c6d409cf
ED
2799 size_t len = ((ifc32.ifc_len / sizeof(struct compat_ifreq)) + 1) *
2800 sizeof(struct ifreq);
7a229387
AB
2801 uifc = compat_alloc_user_space(sizeof(struct ifconf) + len);
2802 ifc.ifc_len = len;
2803 ifr = ifc.ifc_req = (void __user *)(uifc + 1);
2804 ifr32 = compat_ptr(ifc32.ifcbuf);
c6d409cf 2805 for (i = 0; i < ifc32.ifc_len; i += sizeof(struct compat_ifreq)) {
6b96018b 2806 if (copy_in_user(ifr, ifr32, sizeof(struct compat_ifreq)))
7a229387
AB
2807 return -EFAULT;
2808 ifr++;
2809 ifr32++;
2810 }
2811 }
2812 if (copy_to_user(uifc, &ifc, sizeof(struct ifconf)))
2813 return -EFAULT;
2814
6b96018b 2815 err = dev_ioctl(net, SIOCGIFCONF, uifc);
7a229387
AB
2816 if (err)
2817 return err;
2818
2819 if (copy_from_user(&ifc, uifc, sizeof(struct ifconf)))
2820 return -EFAULT;
2821
2822 ifr = ifc.ifc_req;
2823 ifr32 = compat_ptr(ifc32.ifcbuf);
2824 for (i = 0, j = 0;
c6d409cf
ED
2825 i + sizeof(struct compat_ifreq) <= ifc32.ifc_len && j < ifc.ifc_len;
2826 i += sizeof(struct compat_ifreq), j += sizeof(struct ifreq)) {
2827 if (copy_in_user(ifr32, ifr, sizeof(struct compat_ifreq)))
7a229387
AB
2828 return -EFAULT;
2829 ifr32++;
2830 ifr++;
2831 }
2832
2833 if (ifc32.ifcbuf == 0) {
2834 /* Translate from 64-bit structure multiple to
2835 * a 32-bit one.
2836 */
2837 i = ifc.ifc_len;
6b96018b 2838 i = ((i / sizeof(struct ifreq)) * sizeof(struct compat_ifreq));
7a229387
AB
2839 ifc32.ifc_len = i;
2840 } else {
2841 ifc32.ifc_len = i;
2842 }
6b96018b 2843 if (copy_to_user(uifc32, &ifc32, sizeof(struct compat_ifconf)))
7a229387
AB
2844 return -EFAULT;
2845
2846 return 0;
2847}
2848
6b96018b 2849static int ethtool_ioctl(struct net *net, struct compat_ifreq __user *ifr32)
7a229387 2850{
3a7da39d
BH
2851 struct compat_ethtool_rxnfc __user *compat_rxnfc;
2852 bool convert_in = false, convert_out = false;
2853 size_t buf_size = ALIGN(sizeof(struct ifreq), 8);
2854 struct ethtool_rxnfc __user *rxnfc;
7a229387 2855 struct ifreq __user *ifr;
3a7da39d
BH
2856 u32 rule_cnt = 0, actual_rule_cnt;
2857 u32 ethcmd;
7a229387 2858 u32 data;
3a7da39d 2859 int ret;
7a229387 2860
3a7da39d
BH
2861 if (get_user(data, &ifr32->ifr_ifru.ifru_data))
2862 return -EFAULT;
7a229387 2863
3a7da39d
BH
2864 compat_rxnfc = compat_ptr(data);
2865
2866 if (get_user(ethcmd, &compat_rxnfc->cmd))
7a229387
AB
2867 return -EFAULT;
2868
3a7da39d
BH
2869 /* Most ethtool structures are defined without padding.
2870 * Unfortunately struct ethtool_rxnfc is an exception.
2871 */
2872 switch (ethcmd) {
2873 default:
2874 break;
2875 case ETHTOOL_GRXCLSRLALL:
2876 /* Buffer size is variable */
2877 if (get_user(rule_cnt, &compat_rxnfc->rule_cnt))
2878 return -EFAULT;
2879 if (rule_cnt > KMALLOC_MAX_SIZE / sizeof(u32))
2880 return -ENOMEM;
2881 buf_size += rule_cnt * sizeof(u32);
2882 /* fall through */
2883 case ETHTOOL_GRXRINGS:
2884 case ETHTOOL_GRXCLSRLCNT:
2885 case ETHTOOL_GRXCLSRULE:
55664f32 2886 case ETHTOOL_SRXCLSRLINS:
3a7da39d
BH
2887 convert_out = true;
2888 /* fall through */
2889 case ETHTOOL_SRXCLSRLDEL:
3a7da39d
BH
2890 buf_size += sizeof(struct ethtool_rxnfc);
2891 convert_in = true;
2892 break;
2893 }
2894
2895 ifr = compat_alloc_user_space(buf_size);
954b1244 2896 rxnfc = (void __user *)ifr + ALIGN(sizeof(struct ifreq), 8);
3a7da39d
BH
2897
2898 if (copy_in_user(&ifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ))
7a229387
AB
2899 return -EFAULT;
2900
3a7da39d
BH
2901 if (put_user(convert_in ? rxnfc : compat_ptr(data),
2902 &ifr->ifr_ifru.ifru_data))
7a229387
AB
2903 return -EFAULT;
2904
3a7da39d 2905 if (convert_in) {
127fe533 2906 /* We expect there to be holes between fs.m_ext and
3a7da39d
BH
2907 * fs.ring_cookie and at the end of fs, but nowhere else.
2908 */
127fe533
AD
2909 BUILD_BUG_ON(offsetof(struct compat_ethtool_rxnfc, fs.m_ext) +
2910 sizeof(compat_rxnfc->fs.m_ext) !=
2911 offsetof(struct ethtool_rxnfc, fs.m_ext) +
2912 sizeof(rxnfc->fs.m_ext));
3a7da39d
BH
2913 BUILD_BUG_ON(
2914 offsetof(struct compat_ethtool_rxnfc, fs.location) -
2915 offsetof(struct compat_ethtool_rxnfc, fs.ring_cookie) !=
2916 offsetof(struct ethtool_rxnfc, fs.location) -
2917 offsetof(struct ethtool_rxnfc, fs.ring_cookie));
2918
2919 if (copy_in_user(rxnfc, compat_rxnfc,
954b1244
SH
2920 (void __user *)(&rxnfc->fs.m_ext + 1) -
2921 (void __user *)rxnfc) ||
3a7da39d
BH
2922 copy_in_user(&rxnfc->fs.ring_cookie,
2923 &compat_rxnfc->fs.ring_cookie,
954b1244
SH
2924 (void __user *)(&rxnfc->fs.location + 1) -
2925 (void __user *)&rxnfc->fs.ring_cookie) ||
3a7da39d
BH
2926 copy_in_user(&rxnfc->rule_cnt, &compat_rxnfc->rule_cnt,
2927 sizeof(rxnfc->rule_cnt)))
2928 return -EFAULT;
2929 }
2930
2931 ret = dev_ioctl(net, SIOCETHTOOL, ifr);
2932 if (ret)
2933 return ret;
2934
2935 if (convert_out) {
2936 if (copy_in_user(compat_rxnfc, rxnfc,
954b1244
SH
2937 (const void __user *)(&rxnfc->fs.m_ext + 1) -
2938 (const void __user *)rxnfc) ||
3a7da39d
BH
2939 copy_in_user(&compat_rxnfc->fs.ring_cookie,
2940 &rxnfc->fs.ring_cookie,
954b1244
SH
2941 (const void __user *)(&rxnfc->fs.location + 1) -
2942 (const void __user *)&rxnfc->fs.ring_cookie) ||
3a7da39d
BH
2943 copy_in_user(&compat_rxnfc->rule_cnt, &rxnfc->rule_cnt,
2944 sizeof(rxnfc->rule_cnt)))
2945 return -EFAULT;
2946
2947 if (ethcmd == ETHTOOL_GRXCLSRLALL) {
2948 /* As an optimisation, we only copy the actual
2949 * number of rules that the underlying
2950 * function returned. Since Mallory might
2951 * change the rule count in user memory, we
2952 * check that it is less than the rule count
2953 * originally given (as the user buffer size),
2954 * which has been range-checked.
2955 */
2956 if (get_user(actual_rule_cnt, &rxnfc->rule_cnt))
2957 return -EFAULT;
2958 if (actual_rule_cnt < rule_cnt)
2959 rule_cnt = actual_rule_cnt;
2960 if (copy_in_user(&compat_rxnfc->rule_locs[0],
2961 &rxnfc->rule_locs[0],
2962 rule_cnt * sizeof(u32)))
2963 return -EFAULT;
2964 }
2965 }
2966
2967 return 0;
7a229387
AB
2968}
2969
7a50a240
AB
2970static int compat_siocwandev(struct net *net, struct compat_ifreq __user *uifr32)
2971{
2972 void __user *uptr;
2973 compat_uptr_t uptr32;
2974 struct ifreq __user *uifr;
2975
c6d409cf 2976 uifr = compat_alloc_user_space(sizeof(*uifr));
7a50a240
AB
2977 if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))
2978 return -EFAULT;
2979
2980 if (get_user(uptr32, &uifr32->ifr_settings.ifs_ifsu))
2981 return -EFAULT;
2982
2983 uptr = compat_ptr(uptr32);
2984
2985 if (put_user(uptr, &uifr->ifr_settings.ifs_ifsu.raw_hdlc))
2986 return -EFAULT;
2987
2988 return dev_ioctl(net, SIOCWANDEV, uifr);
2989}
2990
6b96018b
AB
2991static int bond_ioctl(struct net *net, unsigned int cmd,
2992 struct compat_ifreq __user *ifr32)
7a229387
AB
2993{
2994 struct ifreq kifr;
7a229387
AB
2995 mm_segment_t old_fs;
2996 int err;
7a229387
AB
2997
2998 switch (cmd) {
2999 case SIOCBONDENSLAVE:
3000 case SIOCBONDRELEASE:
3001 case SIOCBONDSETHWADDR:
3002 case SIOCBONDCHANGEACTIVE:
6b96018b 3003 if (copy_from_user(&kifr, ifr32, sizeof(struct compat_ifreq)))
7a229387
AB
3004 return -EFAULT;
3005
3006 old_fs = get_fs();
c6d409cf 3007 set_fs(KERNEL_DS);
c3f52ae6 3008 err = dev_ioctl(net, cmd,
3009 (struct ifreq __user __force *) &kifr);
c6d409cf 3010 set_fs(old_fs);
7a229387
AB
3011
3012 return err;
7a229387 3013 default:
07d106d0 3014 return -ENOIOCTLCMD;
ccbd6a5a 3015 }
7a229387
AB
3016}
3017
590d4693
BH
3018/* Handle ioctls that use ifreq::ifr_data and just need struct ifreq converted */
3019static int compat_ifr_data_ioctl(struct net *net, unsigned int cmd,
6b96018b 3020 struct compat_ifreq __user *u_ifreq32)
7a229387
AB
3021{
3022 struct ifreq __user *u_ifreq64;
7a229387
AB
3023 char tmp_buf[IFNAMSIZ];
3024 void __user *data64;
3025 u32 data32;
3026
3027 if (copy_from_user(&tmp_buf[0], &(u_ifreq32->ifr_ifrn.ifrn_name[0]),
3028 IFNAMSIZ))
3029 return -EFAULT;
417c3522 3030 if (get_user(data32, &u_ifreq32->ifr_ifru.ifru_data))
7a229387
AB
3031 return -EFAULT;
3032 data64 = compat_ptr(data32);
3033
3034 u_ifreq64 = compat_alloc_user_space(sizeof(*u_ifreq64));
3035
7a229387
AB
3036 if (copy_to_user(&u_ifreq64->ifr_ifrn.ifrn_name[0], &tmp_buf[0],
3037 IFNAMSIZ))
3038 return -EFAULT;
417c3522 3039 if (put_user(data64, &u_ifreq64->ifr_ifru.ifru_data))
7a229387
AB
3040 return -EFAULT;
3041
6b96018b 3042 return dev_ioctl(net, cmd, u_ifreq64);
7a229387
AB
3043}
3044
6b96018b
AB
3045static int dev_ifsioc(struct net *net, struct socket *sock,
3046 unsigned int cmd, struct compat_ifreq __user *uifr32)
7a229387 3047{
a2116ed2 3048 struct ifreq __user *uifr;
7a229387
AB
3049 int err;
3050
a2116ed2
AB
3051 uifr = compat_alloc_user_space(sizeof(*uifr));
3052 if (copy_in_user(uifr, uifr32, sizeof(*uifr32)))
3053 return -EFAULT;
3054
3055 err = sock_do_ioctl(net, sock, cmd, (unsigned long)uifr);
3056
7a229387
AB
3057 if (!err) {
3058 switch (cmd) {
3059 case SIOCGIFFLAGS:
3060 case SIOCGIFMETRIC:
3061 case SIOCGIFMTU:
3062 case SIOCGIFMEM:
3063 case SIOCGIFHWADDR:
3064 case SIOCGIFINDEX:
3065 case SIOCGIFADDR:
3066 case SIOCGIFBRDADDR:
3067 case SIOCGIFDSTADDR:
3068 case SIOCGIFNETMASK:
fab2532b 3069 case SIOCGIFPFLAGS:
7a229387 3070 case SIOCGIFTXQLEN:
fab2532b
AB
3071 case SIOCGMIIPHY:
3072 case SIOCGMIIREG:
a2116ed2 3073 if (copy_in_user(uifr32, uifr, sizeof(*uifr32)))
7a229387
AB
3074 err = -EFAULT;
3075 break;
3076 }
3077 }
3078 return err;
3079}
3080
a2116ed2
AB
3081static int compat_sioc_ifmap(struct net *net, unsigned int cmd,
3082 struct compat_ifreq __user *uifr32)
3083{
3084 struct ifreq ifr;
3085 struct compat_ifmap __user *uifmap32;
3086 mm_segment_t old_fs;
3087 int err;
3088
3089 uifmap32 = &uifr32->ifr_ifru.ifru_map;
3090 err = copy_from_user(&ifr, uifr32, sizeof(ifr.ifr_name));
3ddc5b46
MD
3091 err |= get_user(ifr.ifr_map.mem_start, &uifmap32->mem_start);
3092 err |= get_user(ifr.ifr_map.mem_end, &uifmap32->mem_end);
3093 err |= get_user(ifr.ifr_map.base_addr, &uifmap32->base_addr);
3094 err |= get_user(ifr.ifr_map.irq, &uifmap32->irq);
3095 err |= get_user(ifr.ifr_map.dma, &uifmap32->dma);
3096 err |= get_user(ifr.ifr_map.port, &uifmap32->port);
a2116ed2
AB
3097 if (err)
3098 return -EFAULT;
3099
3100 old_fs = get_fs();
c6d409cf 3101 set_fs(KERNEL_DS);
c3f52ae6 3102 err = dev_ioctl(net, cmd, (void __user __force *)&ifr);
c6d409cf 3103 set_fs(old_fs);
a2116ed2
AB
3104
3105 if (cmd == SIOCGIFMAP && !err) {
3106 err = copy_to_user(uifr32, &ifr, sizeof(ifr.ifr_name));
3ddc5b46
MD
3107 err |= put_user(ifr.ifr_map.mem_start, &uifmap32->mem_start);
3108 err |= put_user(ifr.ifr_map.mem_end, &uifmap32->mem_end);
3109 err |= put_user(ifr.ifr_map.base_addr, &uifmap32->base_addr);
3110 err |= put_user(ifr.ifr_map.irq, &uifmap32->irq);
3111 err |= put_user(ifr.ifr_map.dma, &uifmap32->dma);
3112 err |= put_user(ifr.ifr_map.port, &uifmap32->port);
a2116ed2
AB
3113 if (err)
3114 err = -EFAULT;
3115 }
3116 return err;
3117}
3118
7a229387 3119struct rtentry32 {
c6d409cf 3120 u32 rt_pad1;
7a229387
AB
3121 struct sockaddr rt_dst; /* target address */
3122 struct sockaddr rt_gateway; /* gateway addr (RTF_GATEWAY) */
3123 struct sockaddr rt_genmask; /* target network mask (IP) */
c6d409cf
ED
3124 unsigned short rt_flags;
3125 short rt_pad2;
3126 u32 rt_pad3;
3127 unsigned char rt_tos;
3128 unsigned char rt_class;
3129 short rt_pad4;
3130 short rt_metric; /* +1 for binary compatibility! */
7a229387 3131 /* char * */ u32 rt_dev; /* forcing the device at add */
c6d409cf
ED
3132 u32 rt_mtu; /* per route MTU/Window */
3133 u32 rt_window; /* Window clamping */
7a229387
AB
3134 unsigned short rt_irtt; /* Initial RTT */
3135};
3136
3137struct in6_rtmsg32 {
3138 struct in6_addr rtmsg_dst;
3139 struct in6_addr rtmsg_src;
3140 struct in6_addr rtmsg_gateway;
3141 u32 rtmsg_type;
3142 u16 rtmsg_dst_len;
3143 u16 rtmsg_src_len;
3144 u32 rtmsg_metric;
3145 u32 rtmsg_info;
3146 u32 rtmsg_flags;
3147 s32 rtmsg_ifindex;
3148};
3149
6b96018b
AB
3150static int routing_ioctl(struct net *net, struct socket *sock,
3151 unsigned int cmd, void __user *argp)
7a229387
AB
3152{
3153 int ret;
3154 void *r = NULL;
3155 struct in6_rtmsg r6;
3156 struct rtentry r4;
3157 char devname[16];
3158 u32 rtdev;
3159 mm_segment_t old_fs = get_fs();
3160
6b96018b
AB
3161 if (sock && sock->sk && sock->sk->sk_family == AF_INET6) { /* ipv6 */
3162 struct in6_rtmsg32 __user *ur6 = argp;
c6d409cf 3163 ret = copy_from_user(&r6.rtmsg_dst, &(ur6->rtmsg_dst),
7a229387 3164 3 * sizeof(struct in6_addr));
3ddc5b46
MD
3165 ret |= get_user(r6.rtmsg_type, &(ur6->rtmsg_type));
3166 ret |= get_user(r6.rtmsg_dst_len, &(ur6->rtmsg_dst_len));
3167 ret |= get_user(r6.rtmsg_src_len, &(ur6->rtmsg_src_len));
3168 ret |= get_user(r6.rtmsg_metric, &(ur6->rtmsg_metric));
3169 ret |= get_user(r6.rtmsg_info, &(ur6->rtmsg_info));
3170 ret |= get_user(r6.rtmsg_flags, &(ur6->rtmsg_flags));
3171 ret |= get_user(r6.rtmsg_ifindex, &(ur6->rtmsg_ifindex));
7a229387
AB
3172
3173 r = (void *) &r6;
3174 } else { /* ipv4 */
6b96018b 3175 struct rtentry32 __user *ur4 = argp;
c6d409cf 3176 ret = copy_from_user(&r4.rt_dst, &(ur4->rt_dst),
7a229387 3177 3 * sizeof(struct sockaddr));
3ddc5b46
MD
3178 ret |= get_user(r4.rt_flags, &(ur4->rt_flags));
3179 ret |= get_user(r4.rt_metric, &(ur4->rt_metric));
3180 ret |= get_user(r4.rt_mtu, &(ur4->rt_mtu));
3181 ret |= get_user(r4.rt_window, &(ur4->rt_window));
3182 ret |= get_user(r4.rt_irtt, &(ur4->rt_irtt));
3183 ret |= get_user(rtdev, &(ur4->rt_dev));
7a229387 3184 if (rtdev) {
c6d409cf 3185 ret |= copy_from_user(devname, compat_ptr(rtdev), 15);
c3f52ae6 3186 r4.rt_dev = (char __user __force *)devname;
3187 devname[15] = 0;
7a229387
AB
3188 } else
3189 r4.rt_dev = NULL;
3190
3191 r = (void *) &r4;
3192 }
3193
3194 if (ret) {
3195 ret = -EFAULT;
3196 goto out;
3197 }
3198
c6d409cf 3199 set_fs(KERNEL_DS);
6b96018b 3200 ret = sock_do_ioctl(net, sock, cmd, (unsigned long) r);
c6d409cf 3201 set_fs(old_fs);
7a229387
AB
3202
3203out:
7a229387
AB
3204 return ret;
3205}
3206
3207/* Since old style bridge ioctl's endup using SIOCDEVPRIVATE
3208 * for some operations; this forces use of the newer bridge-utils that
25985edc 3209 * use compatible ioctls
7a229387 3210 */
6b96018b 3211static int old_bridge_ioctl(compat_ulong_t __user *argp)
7a229387 3212{
6b96018b 3213 compat_ulong_t tmp;
7a229387 3214
6b96018b 3215 if (get_user(tmp, argp))
7a229387
AB
3216 return -EFAULT;
3217 if (tmp == BRCTL_GET_VERSION)
3218 return BRCTL_VERSION + 1;
3219 return -EINVAL;
3220}
3221
6b96018b
AB
3222static int compat_sock_ioctl_trans(struct file *file, struct socket *sock,
3223 unsigned int cmd, unsigned long arg)
3224{
3225 void __user *argp = compat_ptr(arg);
3226 struct sock *sk = sock->sk;
3227 struct net *net = sock_net(sk);
7a229387 3228
6b96018b 3229 if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15))
590d4693 3230 return compat_ifr_data_ioctl(net, cmd, argp);
6b96018b
AB
3231
3232 switch (cmd) {
3233 case SIOCSIFBR:
3234 case SIOCGIFBR:
3235 return old_bridge_ioctl(argp);
3236 case SIOCGIFNAME:
3237 return dev_ifname32(net, argp);
3238 case SIOCGIFCONF:
3239 return dev_ifconf(net, argp);
3240 case SIOCETHTOOL:
3241 return ethtool_ioctl(net, argp);
7a50a240
AB
3242 case SIOCWANDEV:
3243 return compat_siocwandev(net, argp);
a2116ed2
AB
3244 case SIOCGIFMAP:
3245 case SIOCSIFMAP:
3246 return compat_sioc_ifmap(net, cmd, argp);
6b96018b
AB
3247 case SIOCBONDENSLAVE:
3248 case SIOCBONDRELEASE:
3249 case SIOCBONDSETHWADDR:
6b96018b
AB
3250 case SIOCBONDCHANGEACTIVE:
3251 return bond_ioctl(net, cmd, argp);
3252 case SIOCADDRT:
3253 case SIOCDELRT:
3254 return routing_ioctl(net, sock, cmd, argp);
3255 case SIOCGSTAMP:
3256 return do_siocgstamp(net, sock, cmd, argp);
3257 case SIOCGSTAMPNS:
3258 return do_siocgstampns(net, sock, cmd, argp);
590d4693
BH
3259 case SIOCBONDSLAVEINFOQUERY:
3260 case SIOCBONDINFOQUERY:
a2116ed2 3261 case SIOCSHWTSTAMP:
fd468c74 3262 case SIOCGHWTSTAMP:
590d4693 3263 return compat_ifr_data_ioctl(net, cmd, argp);
6b96018b
AB
3264
3265 case FIOSETOWN:
3266 case SIOCSPGRP:
3267 case FIOGETOWN:
3268 case SIOCGPGRP:
3269 case SIOCBRADDBR:
3270 case SIOCBRDELBR:
3271 case SIOCGIFVLAN:
3272 case SIOCSIFVLAN:
3273 case SIOCADDDLCI:
3274 case SIOCDELDLCI:
3275 return sock_ioctl(file, cmd, arg);
3276
3277 case SIOCGIFFLAGS:
3278 case SIOCSIFFLAGS:
3279 case SIOCGIFMETRIC:
3280 case SIOCSIFMETRIC:
3281 case SIOCGIFMTU:
3282 case SIOCSIFMTU:
3283 case SIOCGIFMEM:
3284 case SIOCSIFMEM:
3285 case SIOCGIFHWADDR:
3286 case SIOCSIFHWADDR:
3287 case SIOCADDMULTI:
3288 case SIOCDELMULTI:
3289 case SIOCGIFINDEX:
6b96018b
AB
3290 case SIOCGIFADDR:
3291 case SIOCSIFADDR:
3292 case SIOCSIFHWBROADCAST:
6b96018b 3293 case SIOCDIFADDR:
6b96018b
AB
3294 case SIOCGIFBRDADDR:
3295 case SIOCSIFBRDADDR:
3296 case SIOCGIFDSTADDR:
3297 case SIOCSIFDSTADDR:
3298 case SIOCGIFNETMASK:
3299 case SIOCSIFNETMASK:
3300 case SIOCSIFPFLAGS:
3301 case SIOCGIFPFLAGS:
3302 case SIOCGIFTXQLEN:
3303 case SIOCSIFTXQLEN:
3304 case SIOCBRADDIF:
3305 case SIOCBRDELIF:
9177efd3
AB
3306 case SIOCSIFNAME:
3307 case SIOCGMIIPHY:
3308 case SIOCGMIIREG:
3309 case SIOCSMIIREG:
6b96018b 3310 return dev_ifsioc(net, sock, cmd, argp);
9177efd3 3311
6b96018b
AB
3312 case SIOCSARP:
3313 case SIOCGARP:
3314 case SIOCDARP:
6b96018b 3315 case SIOCATMARK:
9177efd3
AB
3316 return sock_do_ioctl(net, sock, cmd, arg);
3317 }
3318
6b96018b
AB
3319 return -ENOIOCTLCMD;
3320}
7a229387 3321
95c96174 3322static long compat_sock_ioctl(struct file *file, unsigned int cmd,
89bddce5 3323 unsigned long arg)
89bbfc95
SP
3324{
3325 struct socket *sock = file->private_data;
3326 int ret = -ENOIOCTLCMD;
87de87d5
DM
3327 struct sock *sk;
3328 struct net *net;
3329
3330 sk = sock->sk;
3331 net = sock_net(sk);
89bbfc95
SP
3332
3333 if (sock->ops->compat_ioctl)
3334 ret = sock->ops->compat_ioctl(sock, cmd, arg);
3335
87de87d5
DM
3336 if (ret == -ENOIOCTLCMD &&
3337 (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST))
3338 ret = compat_wext_handle_ioctl(net, cmd, arg);
3339
6b96018b
AB
3340 if (ret == -ENOIOCTLCMD)
3341 ret = compat_sock_ioctl_trans(file, sock, cmd, arg);
3342
89bbfc95
SP
3343 return ret;
3344}
3345#endif
3346
ac5a488e
SS
3347int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen)
3348{
3349 return sock->ops->bind(sock, addr, addrlen);
3350}
c6d409cf 3351EXPORT_SYMBOL(kernel_bind);
ac5a488e
SS
3352
3353int kernel_listen(struct socket *sock, int backlog)
3354{
3355 return sock->ops->listen(sock, backlog);
3356}
c6d409cf 3357EXPORT_SYMBOL(kernel_listen);
ac5a488e
SS
3358
3359int kernel_accept(struct socket *sock, struct socket **newsock, int flags)
3360{
3361 struct sock *sk = sock->sk;
3362 int err;
3363
3364 err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol,
3365 newsock);
3366 if (err < 0)
3367 goto done;
3368
3369 err = sock->ops->accept(sock, *newsock, flags);
3370 if (err < 0) {
3371 sock_release(*newsock);
fa8705b0 3372 *newsock = NULL;
ac5a488e
SS
3373 goto done;
3374 }
3375
3376 (*newsock)->ops = sock->ops;
1b08534e 3377 __module_get((*newsock)->ops->owner);
ac5a488e
SS
3378
3379done:
3380 return err;
3381}
c6d409cf 3382EXPORT_SYMBOL(kernel_accept);
ac5a488e
SS
3383
3384int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen,
4768fbcb 3385 int flags)
ac5a488e
SS
3386{
3387 return sock->ops->connect(sock, addr, addrlen, flags);
3388}
c6d409cf 3389EXPORT_SYMBOL(kernel_connect);
ac5a488e
SS
3390
3391int kernel_getsockname(struct socket *sock, struct sockaddr *addr,
3392 int *addrlen)
3393{
3394 return sock->ops->getname(sock, addr, addrlen, 0);
3395}
c6d409cf 3396EXPORT_SYMBOL(kernel_getsockname);
ac5a488e
SS
3397
3398int kernel_getpeername(struct socket *sock, struct sockaddr *addr,
3399 int *addrlen)
3400{
3401 return sock->ops->getname(sock, addr, addrlen, 1);
3402}
c6d409cf 3403EXPORT_SYMBOL(kernel_getpeername);
ac5a488e
SS
3404
3405int kernel_getsockopt(struct socket *sock, int level, int optname,
3406 char *optval, int *optlen)
3407{
3408 mm_segment_t oldfs = get_fs();
fb8621bb
NK
3409 char __user *uoptval;
3410 int __user *uoptlen;
ac5a488e
SS
3411 int err;
3412
fb8621bb
NK
3413 uoptval = (char __user __force *) optval;
3414 uoptlen = (int __user __force *) optlen;
3415
ac5a488e
SS
3416 set_fs(KERNEL_DS);
3417 if (level == SOL_SOCKET)
fb8621bb 3418 err = sock_getsockopt(sock, level, optname, uoptval, uoptlen);
ac5a488e 3419 else
fb8621bb
NK
3420 err = sock->ops->getsockopt(sock, level, optname, uoptval,
3421 uoptlen);
ac5a488e
SS
3422 set_fs(oldfs);
3423 return err;
3424}
c6d409cf 3425EXPORT_SYMBOL(kernel_getsockopt);
ac5a488e
SS
3426
3427int kernel_setsockopt(struct socket *sock, int level, int optname,
b7058842 3428 char *optval, unsigned int optlen)
ac5a488e
SS
3429{
3430 mm_segment_t oldfs = get_fs();
fb8621bb 3431 char __user *uoptval;
ac5a488e
SS
3432 int err;
3433
fb8621bb
NK
3434 uoptval = (char __user __force *) optval;
3435
ac5a488e
SS
3436 set_fs(KERNEL_DS);
3437 if (level == SOL_SOCKET)
fb8621bb 3438 err = sock_setsockopt(sock, level, optname, uoptval, optlen);
ac5a488e 3439 else
fb8621bb 3440 err = sock->ops->setsockopt(sock, level, optname, uoptval,
ac5a488e
SS
3441 optlen);
3442 set_fs(oldfs);
3443 return err;
3444}
c6d409cf 3445EXPORT_SYMBOL(kernel_setsockopt);
ac5a488e
SS
3446
3447int kernel_sendpage(struct socket *sock, struct page *page, int offset,
3448 size_t size, int flags)
3449{
3450 if (sock->ops->sendpage)
3451 return sock->ops->sendpage(sock, page, offset, size, flags);
3452
3453 return sock_no_sendpage(sock, page, offset, size, flags);
3454}
c6d409cf 3455EXPORT_SYMBOL(kernel_sendpage);
ac5a488e
SS
3456
3457int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg)
3458{
3459 mm_segment_t oldfs = get_fs();
3460 int err;
3461
3462 set_fs(KERNEL_DS);
3463 err = sock->ops->ioctl(sock, cmd, arg);
3464 set_fs(oldfs);
3465
3466 return err;
3467}
c6d409cf 3468EXPORT_SYMBOL(kernel_sock_ioctl);
ac5a488e 3469
91cf45f0
TM
3470int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how)
3471{
3472 return sock->ops->shutdown(sock, how);
3473}
91cf45f0 3474EXPORT_SYMBOL(kernel_sock_shutdown);