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