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