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