reorder alloc_fd/attach_fd in socketpair()
[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
198de4d7
AV
1399 err = sock_attach_fd(sock1, newfile1, flags & O_NONBLOCK);
1400 if (unlikely(err < 0)) {
db349509
AV
1401 put_filp(newfile1);
1402 put_unused_fd(fd1);
1da177e4 1403 goto out_release_both;
db349509 1404 }
1da177e4 1405
198de4d7
AV
1406 fd2 = sock_alloc_fd(&newfile2, flags & O_CLOEXEC);
1407 if (unlikely(fd2 < 0)) {
1408 err = fd2;
1409 fput(newfile1);
1410 put_unused_fd(fd1);
1411 sock_release(sock2);
1412 goto out;
db349509
AV
1413 }
1414
77d27200 1415 err = sock_attach_fd(sock2, newfile2, flags & O_NONBLOCK);
db349509 1416 if (unlikely(err < 0)) {
198de4d7
AV
1417 put_filp(newfile2);
1418 put_unused_fd(fd2);
db349509 1419 fput(newfile1);
198de4d7
AV
1420 put_unused_fd(fd1);
1421 sock_release(sock2);
1422 goto out;
db349509
AV
1423 }
1424
157cf649 1425 audit_fd_pair(fd1, fd2);
db349509
AV
1426 fd_install(fd1, newfile1);
1427 fd_install(fd2, newfile2);
1da177e4
LT
1428 /* fd1 and fd2 may be already another descriptors.
1429 * Not kernel problem.
1430 */
1431
89bddce5 1432 err = put_user(fd1, &usockvec[0]);
1da177e4
LT
1433 if (!err)
1434 err = put_user(fd2, &usockvec[1]);
1435 if (!err)
1436 return 0;
1437
1438 sys_close(fd2);
1439 sys_close(fd1);
1440 return err;
1441
1da177e4 1442out_release_both:
89bddce5 1443 sock_release(sock2);
1da177e4 1444out_release_1:
89bddce5 1445 sock_release(sock1);
1da177e4
LT
1446out:
1447 return err;
1448}
1449
1da177e4
LT
1450/*
1451 * Bind a name to a socket. Nothing much to do here since it's
1452 * the protocol's responsibility to handle the local address.
1453 *
1454 * We move the socket address to kernel space before we call
1455 * the protocol layer (having also checked the address is ok).
1456 */
1457
20f37034 1458SYSCALL_DEFINE3(bind, int, fd, struct sockaddr __user *, umyaddr, int, addrlen)
1da177e4
LT
1459{
1460 struct socket *sock;
230b1839 1461 struct sockaddr_storage address;
6cb153ca 1462 int err, fput_needed;
1da177e4 1463
89bddce5 1464 sock = sockfd_lookup_light(fd, &err, &fput_needed);
e71a4783 1465 if (sock) {
230b1839 1466 err = move_addr_to_kernel(umyaddr, addrlen, (struct sockaddr *)&address);
89bddce5
SH
1467 if (err >= 0) {
1468 err = security_socket_bind(sock,
230b1839 1469 (struct sockaddr *)&address,
89bddce5 1470 addrlen);
6cb153ca
BL
1471 if (!err)
1472 err = sock->ops->bind(sock,
89bddce5 1473 (struct sockaddr *)
230b1839 1474 &address, addrlen);
1da177e4 1475 }
6cb153ca 1476 fput_light(sock->file, fput_needed);
89bddce5 1477 }
1da177e4
LT
1478 return err;
1479}
1480
1da177e4
LT
1481/*
1482 * Perform a listen. Basically, we allow the protocol to do anything
1483 * necessary for a listen, and if that works, we mark the socket as
1484 * ready for listening.
1485 */
1486
3e0fa65f 1487SYSCALL_DEFINE2(listen, int, fd, int, backlog)
1da177e4
LT
1488{
1489 struct socket *sock;
6cb153ca 1490 int err, fput_needed;
b8e1f9b5 1491 int somaxconn;
89bddce5
SH
1492
1493 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1494 if (sock) {
8efa6e93 1495 somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn;
b8e1f9b5
PE
1496 if ((unsigned)backlog > somaxconn)
1497 backlog = somaxconn;
1da177e4
LT
1498
1499 err = security_socket_listen(sock, backlog);
6cb153ca
BL
1500 if (!err)
1501 err = sock->ops->listen(sock, backlog);
1da177e4 1502
6cb153ca 1503 fput_light(sock->file, fput_needed);
1da177e4
LT
1504 }
1505 return err;
1506}
1507
1da177e4
LT
1508/*
1509 * For accept, we attempt to create a new socket, set up the link
1510 * with the client, wake up the client, then return the new
1511 * connected fd. We collect the address of the connector in kernel
1512 * space and move it to user at the very end. This is unclean because
1513 * we open the socket then return an error.
1514 *
1515 * 1003.1g adds the ability to recvmsg() to query connection pending
1516 * status to recvmsg. We need to add that support in a way thats
1517 * clean when we restucture accept also.
1518 */
1519
20f37034
HC
1520SYSCALL_DEFINE4(accept4, int, fd, struct sockaddr __user *, upeer_sockaddr,
1521 int __user *, upeer_addrlen, int, flags)
1da177e4
LT
1522{
1523 struct socket *sock, *newsock;
39d8c1b6 1524 struct file *newfile;
6cb153ca 1525 int err, len, newfd, fput_needed;
230b1839 1526 struct sockaddr_storage address;
1da177e4 1527
77d27200 1528 if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
aaca0bdc
UD
1529 return -EINVAL;
1530
1531 if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1532 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1533
6cb153ca 1534 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4
LT
1535 if (!sock)
1536 goto out;
1537
1538 err = -ENFILE;
89bddce5 1539 if (!(newsock = sock_alloc()))
1da177e4
LT
1540 goto out_put;
1541
1542 newsock->type = sock->type;
1543 newsock->ops = sock->ops;
1544
1da177e4
LT
1545 /*
1546 * We don't need try_module_get here, as the listening socket (sock)
1547 * has the protocol module (sock->ops->owner) held.
1548 */
1549 __module_get(newsock->ops->owner);
1550
aaca0bdc 1551 newfd = sock_alloc_fd(&newfile, flags & O_CLOEXEC);
39d8c1b6
DM
1552 if (unlikely(newfd < 0)) {
1553 err = newfd;
9a1875e6
DM
1554 sock_release(newsock);
1555 goto out_put;
39d8c1b6
DM
1556 }
1557
77d27200 1558 err = sock_attach_fd(newsock, newfile, flags & O_NONBLOCK);
39d8c1b6 1559 if (err < 0)
79f4f642 1560 goto out_fd_simple;
39d8c1b6 1561
a79af59e
FF
1562 err = security_socket_accept(sock, newsock);
1563 if (err)
39d8c1b6 1564 goto out_fd;
a79af59e 1565
1da177e4
LT
1566 err = sock->ops->accept(sock, newsock, sock->file->f_flags);
1567 if (err < 0)
39d8c1b6 1568 goto out_fd;
1da177e4
LT
1569
1570 if (upeer_sockaddr) {
230b1839 1571 if (newsock->ops->getname(newsock, (struct sockaddr *)&address,
89bddce5 1572 &len, 2) < 0) {
1da177e4 1573 err = -ECONNABORTED;
39d8c1b6 1574 goto out_fd;
1da177e4 1575 }
230b1839
YH
1576 err = move_addr_to_user((struct sockaddr *)&address,
1577 len, upeer_sockaddr, upeer_addrlen);
1da177e4 1578 if (err < 0)
39d8c1b6 1579 goto out_fd;
1da177e4
LT
1580 }
1581
1582 /* File flags are not inherited via accept() unlike another OSes. */
1583
39d8c1b6
DM
1584 fd_install(newfd, newfile);
1585 err = newfd;
1da177e4 1586
1da177e4 1587out_put:
6cb153ca 1588 fput_light(sock->file, fput_needed);
1da177e4
LT
1589out:
1590 return err;
79f4f642
AD
1591out_fd_simple:
1592 sock_release(newsock);
1593 put_filp(newfile);
1594 put_unused_fd(newfd);
1595 goto out_put;
39d8c1b6 1596out_fd:
9606a216 1597 fput(newfile);
39d8c1b6 1598 put_unused_fd(newfd);
1da177e4
LT
1599 goto out_put;
1600}
1601
20f37034
HC
1602SYSCALL_DEFINE3(accept, int, fd, struct sockaddr __user *, upeer_sockaddr,
1603 int __user *, upeer_addrlen)
aaca0bdc 1604{
de11defe 1605 return sys_accept4(fd, upeer_sockaddr, upeer_addrlen, 0);
aaca0bdc
UD
1606}
1607
1da177e4
LT
1608/*
1609 * Attempt to connect to a socket with the server address. The address
1610 * is in user space so we verify it is OK and move it to kernel space.
1611 *
1612 * For 1003.1g we need to add clean support for a bind to AF_UNSPEC to
1613 * break bindings
1614 *
1615 * NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and
1616 * other SEQPACKET protocols that take time to connect() as it doesn't
1617 * include the -EINPROGRESS status for such sockets.
1618 */
1619
20f37034
HC
1620SYSCALL_DEFINE3(connect, int, fd, struct sockaddr __user *, uservaddr,
1621 int, addrlen)
1da177e4
LT
1622{
1623 struct socket *sock;
230b1839 1624 struct sockaddr_storage address;
6cb153ca 1625 int err, fput_needed;
1da177e4 1626
6cb153ca 1627 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4
LT
1628 if (!sock)
1629 goto out;
230b1839 1630 err = move_addr_to_kernel(uservaddr, addrlen, (struct sockaddr *)&address);
1da177e4
LT
1631 if (err < 0)
1632 goto out_put;
1633
89bddce5 1634 err =
230b1839 1635 security_socket_connect(sock, (struct sockaddr *)&address, addrlen);
1da177e4
LT
1636 if (err)
1637 goto out_put;
1638
230b1839 1639 err = sock->ops->connect(sock, (struct sockaddr *)&address, addrlen,
1da177e4
LT
1640 sock->file->f_flags);
1641out_put:
6cb153ca 1642 fput_light(sock->file, fput_needed);
1da177e4
LT
1643out:
1644 return err;
1645}
1646
1647/*
1648 * Get the local address ('name') of a socket object. Move the obtained
1649 * name to user space.
1650 */
1651
20f37034
HC
1652SYSCALL_DEFINE3(getsockname, int, fd, struct sockaddr __user *, usockaddr,
1653 int __user *, usockaddr_len)
1da177e4
LT
1654{
1655 struct socket *sock;
230b1839 1656 struct sockaddr_storage address;
6cb153ca 1657 int len, err, fput_needed;
89bddce5 1658
6cb153ca 1659 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4
LT
1660 if (!sock)
1661 goto out;
1662
1663 err = security_socket_getsockname(sock);
1664 if (err)
1665 goto out_put;
1666
230b1839 1667 err = sock->ops->getname(sock, (struct sockaddr *)&address, &len, 0);
1da177e4
LT
1668 if (err)
1669 goto out_put;
230b1839 1670 err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr, usockaddr_len);
1da177e4
LT
1671
1672out_put:
6cb153ca 1673 fput_light(sock->file, fput_needed);
1da177e4
LT
1674out:
1675 return err;
1676}
1677
1678/*
1679 * Get the remote address ('name') of a socket object. Move the obtained
1680 * name to user space.
1681 */
1682
20f37034
HC
1683SYSCALL_DEFINE3(getpeername, int, fd, struct sockaddr __user *, usockaddr,
1684 int __user *, usockaddr_len)
1da177e4
LT
1685{
1686 struct socket *sock;
230b1839 1687 struct sockaddr_storage address;
6cb153ca 1688 int len, err, fput_needed;
1da177e4 1689
89bddce5
SH
1690 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1691 if (sock != NULL) {
1da177e4
LT
1692 err = security_socket_getpeername(sock);
1693 if (err) {
6cb153ca 1694 fput_light(sock->file, fput_needed);
1da177e4
LT
1695 return err;
1696 }
1697
89bddce5 1698 err =
230b1839 1699 sock->ops->getname(sock, (struct sockaddr *)&address, &len,
89bddce5 1700 1);
1da177e4 1701 if (!err)
230b1839 1702 err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr,
89bddce5 1703 usockaddr_len);
6cb153ca 1704 fput_light(sock->file, fput_needed);
1da177e4
LT
1705 }
1706 return err;
1707}
1708
1709/*
1710 * Send a datagram to a given address. We move the address into kernel
1711 * space and check the user space data area is readable before invoking
1712 * the protocol.
1713 */
1714
3e0fa65f
HC
1715SYSCALL_DEFINE6(sendto, int, fd, void __user *, buff, size_t, len,
1716 unsigned, flags, struct sockaddr __user *, addr,
1717 int, addr_len)
1da177e4
LT
1718{
1719 struct socket *sock;
230b1839 1720 struct sockaddr_storage address;
1da177e4
LT
1721 int err;
1722 struct msghdr msg;
1723 struct iovec iov;
6cb153ca 1724 int fput_needed;
6cb153ca 1725
de0fa95c
PE
1726 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1727 if (!sock)
4387ff75 1728 goto out;
6cb153ca 1729
89bddce5
SH
1730 iov.iov_base = buff;
1731 iov.iov_len = len;
1732 msg.msg_name = NULL;
1733 msg.msg_iov = &iov;
1734 msg.msg_iovlen = 1;
1735 msg.msg_control = NULL;
1736 msg.msg_controllen = 0;
1737 msg.msg_namelen = 0;
6cb153ca 1738 if (addr) {
230b1839 1739 err = move_addr_to_kernel(addr, addr_len, (struct sockaddr *)&address);
1da177e4
LT
1740 if (err < 0)
1741 goto out_put;
230b1839 1742 msg.msg_name = (struct sockaddr *)&address;
89bddce5 1743 msg.msg_namelen = addr_len;
1da177e4
LT
1744 }
1745 if (sock->file->f_flags & O_NONBLOCK)
1746 flags |= MSG_DONTWAIT;
1747 msg.msg_flags = flags;
1748 err = sock_sendmsg(sock, &msg, len);
1749
89bddce5 1750out_put:
de0fa95c 1751 fput_light(sock->file, fput_needed);
4387ff75 1752out:
1da177e4
LT
1753 return err;
1754}
1755
1756/*
89bddce5 1757 * Send a datagram down a socket.
1da177e4
LT
1758 */
1759
3e0fa65f
HC
1760SYSCALL_DEFINE4(send, int, fd, void __user *, buff, size_t, len,
1761 unsigned, flags)
1da177e4
LT
1762{
1763 return sys_sendto(fd, buff, len, flags, NULL, 0);
1764}
1765
1766/*
89bddce5 1767 * Receive a frame from the socket and optionally record the address of the
1da177e4
LT
1768 * sender. We verify the buffers are writable and if needed move the
1769 * sender address from kernel to user space.
1770 */
1771
3e0fa65f
HC
1772SYSCALL_DEFINE6(recvfrom, int, fd, void __user *, ubuf, size_t, size,
1773 unsigned, flags, struct sockaddr __user *, addr,
1774 int __user *, addr_len)
1da177e4
LT
1775{
1776 struct socket *sock;
1777 struct iovec iov;
1778 struct msghdr msg;
230b1839 1779 struct sockaddr_storage address;
89bddce5 1780 int err, err2;
6cb153ca
BL
1781 int fput_needed;
1782
de0fa95c 1783 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4 1784 if (!sock)
de0fa95c 1785 goto out;
1da177e4 1786
89bddce5
SH
1787 msg.msg_control = NULL;
1788 msg.msg_controllen = 0;
1789 msg.msg_iovlen = 1;
1790 msg.msg_iov = &iov;
1791 iov.iov_len = size;
1792 iov.iov_base = ubuf;
230b1839
YH
1793 msg.msg_name = (struct sockaddr *)&address;
1794 msg.msg_namelen = sizeof(address);
1da177e4
LT
1795 if (sock->file->f_flags & O_NONBLOCK)
1796 flags |= MSG_DONTWAIT;
89bddce5 1797 err = sock_recvmsg(sock, &msg, size, flags);
1da177e4 1798
89bddce5 1799 if (err >= 0 && addr != NULL) {
230b1839
YH
1800 err2 = move_addr_to_user((struct sockaddr *)&address,
1801 msg.msg_namelen, addr, addr_len);
89bddce5
SH
1802 if (err2 < 0)
1803 err = err2;
1da177e4 1804 }
de0fa95c
PE
1805
1806 fput_light(sock->file, fput_needed);
4387ff75 1807out:
1da177e4
LT
1808 return err;
1809}
1810
1811/*
89bddce5 1812 * Receive a datagram from a socket.
1da177e4
LT
1813 */
1814
89bddce5
SH
1815asmlinkage long sys_recv(int fd, void __user *ubuf, size_t size,
1816 unsigned flags)
1da177e4
LT
1817{
1818 return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL);
1819}
1820
1821/*
1822 * Set a socket option. Because we don't know the option lengths we have
1823 * to pass the user mode parameter for the protocols to sort out.
1824 */
1825
20f37034
HC
1826SYSCALL_DEFINE5(setsockopt, int, fd, int, level, int, optname,
1827 char __user *, optval, int, optlen)
1da177e4 1828{
6cb153ca 1829 int err, fput_needed;
1da177e4
LT
1830 struct socket *sock;
1831
1832 if (optlen < 0)
1833 return -EINVAL;
89bddce5
SH
1834
1835 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1836 if (sock != NULL) {
1837 err = security_socket_setsockopt(sock, level, optname);
6cb153ca
BL
1838 if (err)
1839 goto out_put;
1da177e4
LT
1840
1841 if (level == SOL_SOCKET)
89bddce5
SH
1842 err =
1843 sock_setsockopt(sock, level, optname, optval,
1844 optlen);
1da177e4 1845 else
89bddce5
SH
1846 err =
1847 sock->ops->setsockopt(sock, level, optname, optval,
1848 optlen);
6cb153ca
BL
1849out_put:
1850 fput_light(sock->file, fput_needed);
1da177e4
LT
1851 }
1852 return err;
1853}
1854
1855/*
1856 * Get a socket option. Because we don't know the option lengths we have
1857 * to pass a user mode parameter for the protocols to sort out.
1858 */
1859
20f37034
HC
1860SYSCALL_DEFINE5(getsockopt, int, fd, int, level, int, optname,
1861 char __user *, optval, int __user *, optlen)
1da177e4 1862{
6cb153ca 1863 int err, fput_needed;
1da177e4
LT
1864 struct socket *sock;
1865
89bddce5
SH
1866 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1867 if (sock != NULL) {
6cb153ca
BL
1868 err = security_socket_getsockopt(sock, level, optname);
1869 if (err)
1870 goto out_put;
1da177e4
LT
1871
1872 if (level == SOL_SOCKET)
89bddce5
SH
1873 err =
1874 sock_getsockopt(sock, level, optname, optval,
1875 optlen);
1da177e4 1876 else
89bddce5
SH
1877 err =
1878 sock->ops->getsockopt(sock, level, optname, optval,
1879 optlen);
6cb153ca
BL
1880out_put:
1881 fput_light(sock->file, fput_needed);
1da177e4
LT
1882 }
1883 return err;
1884}
1885
1da177e4
LT
1886/*
1887 * Shutdown a socket.
1888 */
1889
754fe8d2 1890SYSCALL_DEFINE2(shutdown, int, fd, int, how)
1da177e4 1891{
6cb153ca 1892 int err, fput_needed;
1da177e4
LT
1893 struct socket *sock;
1894
89bddce5
SH
1895 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1896 if (sock != NULL) {
1da177e4 1897 err = security_socket_shutdown(sock, how);
6cb153ca
BL
1898 if (!err)
1899 err = sock->ops->shutdown(sock, how);
1900 fput_light(sock->file, fput_needed);
1da177e4
LT
1901 }
1902 return err;
1903}
1904
89bddce5 1905/* A couple of helpful macros for getting the address of the 32/64 bit
1da177e4
LT
1906 * fields which are the same type (int / unsigned) on our platforms.
1907 */
1908#define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member)
1909#define COMPAT_NAMELEN(msg) COMPAT_MSG(msg, msg_namelen)
1910#define COMPAT_FLAGS(msg) COMPAT_MSG(msg, msg_flags)
1911
1da177e4
LT
1912/*
1913 * BSD sendmsg interface
1914 */
1915
3e0fa65f 1916SYSCALL_DEFINE3(sendmsg, int, fd, struct msghdr __user *, msg, unsigned, flags)
1da177e4 1917{
89bddce5
SH
1918 struct compat_msghdr __user *msg_compat =
1919 (struct compat_msghdr __user *)msg;
1da177e4 1920 struct socket *sock;
230b1839 1921 struct sockaddr_storage address;
1da177e4 1922 struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
b9d717a7 1923 unsigned char ctl[sizeof(struct cmsghdr) + 20]
89bddce5
SH
1924 __attribute__ ((aligned(sizeof(__kernel_size_t))));
1925 /* 20 is size of ipv6_pktinfo */
1da177e4
LT
1926 unsigned char *ctl_buf = ctl;
1927 struct msghdr msg_sys;
1928 int err, ctl_len, iov_size, total_len;
6cb153ca 1929 int fput_needed;
89bddce5 1930
1da177e4
LT
1931 err = -EFAULT;
1932 if (MSG_CMSG_COMPAT & flags) {
1933 if (get_compat_msghdr(&msg_sys, msg_compat))
1934 return -EFAULT;
89bddce5
SH
1935 }
1936 else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr)))
1da177e4
LT
1937 return -EFAULT;
1938
6cb153ca 1939 sock = sockfd_lookup_light(fd, &err, &fput_needed);
89bddce5 1940 if (!sock)
1da177e4
LT
1941 goto out;
1942
1943 /* do not move before msg_sys is valid */
1944 err = -EMSGSIZE;
1945 if (msg_sys.msg_iovlen > UIO_MAXIOV)
1946 goto out_put;
1947
89bddce5 1948 /* Check whether to allocate the iovec area */
1da177e4
LT
1949 err = -ENOMEM;
1950 iov_size = msg_sys.msg_iovlen * sizeof(struct iovec);
1951 if (msg_sys.msg_iovlen > UIO_FASTIOV) {
1952 iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
1953 if (!iov)
1954 goto out_put;
1955 }
1956
1957 /* This will also move the address data into kernel space */
1958 if (MSG_CMSG_COMPAT & flags) {
230b1839
YH
1959 err = verify_compat_iovec(&msg_sys, iov,
1960 (struct sockaddr *)&address,
1961 VERIFY_READ);
1da177e4 1962 } else
230b1839
YH
1963 err = verify_iovec(&msg_sys, iov,
1964 (struct sockaddr *)&address,
1965 VERIFY_READ);
89bddce5 1966 if (err < 0)
1da177e4
LT
1967 goto out_freeiov;
1968 total_len = err;
1969
1970 err = -ENOBUFS;
1971
1972 if (msg_sys.msg_controllen > INT_MAX)
1973 goto out_freeiov;
89bddce5 1974 ctl_len = msg_sys.msg_controllen;
1da177e4 1975 if ((MSG_CMSG_COMPAT & flags) && ctl_len) {
89bddce5
SH
1976 err =
1977 cmsghdr_from_user_compat_to_kern(&msg_sys, sock->sk, ctl,
1978 sizeof(ctl));
1da177e4
LT
1979 if (err)
1980 goto out_freeiov;
1981 ctl_buf = msg_sys.msg_control;
8920e8f9 1982 ctl_len = msg_sys.msg_controllen;
1da177e4 1983 } else if (ctl_len) {
89bddce5 1984 if (ctl_len > sizeof(ctl)) {
1da177e4 1985 ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL);
89bddce5 1986 if (ctl_buf == NULL)
1da177e4
LT
1987 goto out_freeiov;
1988 }
1989 err = -EFAULT;
1990 /*
1991 * Careful! Before this, msg_sys.msg_control contains a user pointer.
1992 * Afterwards, it will be a kernel pointer. Thus the compiler-assisted
1993 * checking falls down on this.
1994 */
89bddce5
SH
1995 if (copy_from_user(ctl_buf, (void __user *)msg_sys.msg_control,
1996 ctl_len))
1da177e4
LT
1997 goto out_freectl;
1998 msg_sys.msg_control = ctl_buf;
1999 }
2000 msg_sys.msg_flags = flags;
2001
2002 if (sock->file->f_flags & O_NONBLOCK)
2003 msg_sys.msg_flags |= MSG_DONTWAIT;
2004 err = sock_sendmsg(sock, &msg_sys, total_len);
2005
2006out_freectl:
89bddce5 2007 if (ctl_buf != ctl)
1da177e4
LT
2008 sock_kfree_s(sock->sk, ctl_buf, ctl_len);
2009out_freeiov:
2010 if (iov != iovstack)
2011 sock_kfree_s(sock->sk, iov, iov_size);
2012out_put:
6cb153ca 2013 fput_light(sock->file, fput_needed);
89bddce5 2014out:
1da177e4
LT
2015 return err;
2016}
2017
a2e27255
ACM
2018static int __sys_recvmsg(struct socket *sock, struct msghdr __user *msg,
2019 struct msghdr *msg_sys, unsigned flags, int nosec)
1da177e4 2020{
89bddce5
SH
2021 struct compat_msghdr __user *msg_compat =
2022 (struct compat_msghdr __user *)msg;
1da177e4 2023 struct iovec iovstack[UIO_FASTIOV];
89bddce5 2024 struct iovec *iov = iovstack;
1da177e4
LT
2025 unsigned long cmsg_ptr;
2026 int err, iov_size, total_len, len;
2027
2028 /* kernel mode address */
230b1839 2029 struct sockaddr_storage addr;
1da177e4
LT
2030
2031 /* user mode address pointers */
2032 struct sockaddr __user *uaddr;
2033 int __user *uaddr_len;
89bddce5 2034
1da177e4 2035 if (MSG_CMSG_COMPAT & flags) {
a2e27255 2036 if (get_compat_msghdr(msg_sys, msg_compat))
1da177e4 2037 return -EFAULT;
89bddce5 2038 }
a2e27255 2039 else if (copy_from_user(msg_sys, msg, sizeof(struct msghdr)))
89bddce5 2040 return -EFAULT;
1da177e4 2041
1da177e4 2042 err = -EMSGSIZE;
a2e27255
ACM
2043 if (msg_sys->msg_iovlen > UIO_MAXIOV)
2044 goto out;
89bddce5
SH
2045
2046 /* Check whether to allocate the iovec area */
1da177e4 2047 err = -ENOMEM;
a2e27255
ACM
2048 iov_size = msg_sys->msg_iovlen * sizeof(struct iovec);
2049 if (msg_sys->msg_iovlen > UIO_FASTIOV) {
1da177e4
LT
2050 iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
2051 if (!iov)
a2e27255 2052 goto out;
1da177e4
LT
2053 }
2054
2055 /*
89bddce5
SH
2056 * Save the user-mode address (verify_iovec will change the
2057 * kernel msghdr to use the kernel address space)
1da177e4 2058 */
89bddce5 2059
a2e27255 2060 uaddr = (__force void __user *)msg_sys->msg_name;
1da177e4
LT
2061 uaddr_len = COMPAT_NAMELEN(msg);
2062 if (MSG_CMSG_COMPAT & flags) {
a2e27255 2063 err = verify_compat_iovec(msg_sys, iov,
230b1839
YH
2064 (struct sockaddr *)&addr,
2065 VERIFY_WRITE);
1da177e4 2066 } else
a2e27255 2067 err = verify_iovec(msg_sys, iov,
230b1839
YH
2068 (struct sockaddr *)&addr,
2069 VERIFY_WRITE);
1da177e4
LT
2070 if (err < 0)
2071 goto out_freeiov;
89bddce5 2072 total_len = err;
1da177e4 2073
a2e27255
ACM
2074 cmsg_ptr = (unsigned long)msg_sys->msg_control;
2075 msg_sys->msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT);
89bddce5 2076
1da177e4
LT
2077 if (sock->file->f_flags & O_NONBLOCK)
2078 flags |= MSG_DONTWAIT;
a2e27255
ACM
2079 err = (nosec ? sock_recvmsg_nosec : sock_recvmsg)(sock, msg_sys,
2080 total_len, flags);
1da177e4
LT
2081 if (err < 0)
2082 goto out_freeiov;
2083 len = err;
2084
2085 if (uaddr != NULL) {
230b1839 2086 err = move_addr_to_user((struct sockaddr *)&addr,
a2e27255 2087 msg_sys->msg_namelen, uaddr,
89bddce5 2088 uaddr_len);
1da177e4
LT
2089 if (err < 0)
2090 goto out_freeiov;
2091 }
a2e27255 2092 err = __put_user((msg_sys->msg_flags & ~MSG_CMSG_COMPAT),
37f7f421 2093 COMPAT_FLAGS(msg));
1da177e4
LT
2094 if (err)
2095 goto out_freeiov;
2096 if (MSG_CMSG_COMPAT & flags)
a2e27255 2097 err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,
1da177e4
LT
2098 &msg_compat->msg_controllen);
2099 else
a2e27255 2100 err = __put_user((unsigned long)msg_sys->msg_control - cmsg_ptr,
1da177e4
LT
2101 &msg->msg_controllen);
2102 if (err)
2103 goto out_freeiov;
2104 err = len;
2105
2106out_freeiov:
2107 if (iov != iovstack)
2108 sock_kfree_s(sock->sk, iov, iov_size);
a2e27255
ACM
2109out:
2110 return err;
2111}
2112
2113/*
2114 * BSD recvmsg interface
2115 */
2116
2117SYSCALL_DEFINE3(recvmsg, int, fd, struct msghdr __user *, msg,
2118 unsigned int, flags)
2119{
2120 int fput_needed, err;
2121 struct msghdr msg_sys;
2122 struct socket *sock = sockfd_lookup_light(fd, &err, &fput_needed);
2123
2124 if (!sock)
2125 goto out;
2126
2127 err = __sys_recvmsg(sock, msg, &msg_sys, flags, 0);
2128
6cb153ca 2129 fput_light(sock->file, fput_needed);
1da177e4
LT
2130out:
2131 return err;
2132}
2133
a2e27255
ACM
2134/*
2135 * Linux recvmmsg interface
2136 */
2137
2138int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
2139 unsigned int flags, struct timespec *timeout)
2140{
2141 int fput_needed, err, datagrams;
2142 struct socket *sock;
2143 struct mmsghdr __user *entry;
d7256d0e 2144 struct compat_mmsghdr __user *compat_entry;
a2e27255
ACM
2145 struct msghdr msg_sys;
2146 struct timespec end_time;
2147
2148 if (timeout &&
2149 poll_select_set_timeout(&end_time, timeout->tv_sec,
2150 timeout->tv_nsec))
2151 return -EINVAL;
2152
2153 datagrams = 0;
2154
2155 sock = sockfd_lookup_light(fd, &err, &fput_needed);
2156 if (!sock)
2157 return err;
2158
2159 err = sock_error(sock->sk);
2160 if (err)
2161 goto out_put;
2162
2163 entry = mmsg;
d7256d0e 2164 compat_entry = (struct compat_mmsghdr __user *)mmsg;
a2e27255
ACM
2165
2166 while (datagrams < vlen) {
2167 /*
2168 * No need to ask LSM for more than the first datagram.
2169 */
d7256d0e
JMG
2170 if (MSG_CMSG_COMPAT & flags) {
2171 err = __sys_recvmsg(sock, (struct msghdr __user *)compat_entry,
2172 &msg_sys, flags, datagrams);
2173 if (err < 0)
2174 break;
2175 err = __put_user(err, &compat_entry->msg_len);
2176 ++compat_entry;
2177 } else {
2178 err = __sys_recvmsg(sock, (struct msghdr __user *)entry,
2179 &msg_sys, flags, datagrams);
2180 if (err < 0)
2181 break;
2182 err = put_user(err, &entry->msg_len);
2183 ++entry;
2184 }
2185
a2e27255
ACM
2186 if (err)
2187 break;
a2e27255
ACM
2188 ++datagrams;
2189
2190 if (timeout) {
2191 ktime_get_ts(timeout);
2192 *timeout = timespec_sub(end_time, *timeout);
2193 if (timeout->tv_sec < 0) {
2194 timeout->tv_sec = timeout->tv_nsec = 0;
2195 break;
2196 }
2197
2198 /* Timeout, return less than vlen datagrams */
2199 if (timeout->tv_nsec == 0 && timeout->tv_sec == 0)
2200 break;
2201 }
2202
2203 /* Out of band data, return right away */
2204 if (msg_sys.msg_flags & MSG_OOB)
2205 break;
2206 }
2207
2208out_put:
2209 fput_light(sock->file, fput_needed);
1da177e4 2210
a2e27255
ACM
2211 if (err == 0)
2212 return datagrams;
2213
2214 if (datagrams != 0) {
2215 /*
2216 * We may return less entries than requested (vlen) if the
2217 * sock is non block and there aren't enough datagrams...
2218 */
2219 if (err != -EAGAIN) {
2220 /*
2221 * ... or if recvmsg returns an error after we
2222 * received some datagrams, where we record the
2223 * error to return on the next call or if the
2224 * app asks about it using getsockopt(SO_ERROR).
2225 */
2226 sock->sk->sk_err = -err;
2227 }
2228
2229 return datagrams;
2230 }
2231
2232 return err;
2233}
2234
2235SYSCALL_DEFINE5(recvmmsg, int, fd, struct mmsghdr __user *, mmsg,
2236 unsigned int, vlen, unsigned int, flags,
2237 struct timespec __user *, timeout)
2238{
2239 int datagrams;
2240 struct timespec timeout_sys;
2241
2242 if (!timeout)
2243 return __sys_recvmmsg(fd, mmsg, vlen, flags, NULL);
2244
2245 if (copy_from_user(&timeout_sys, timeout, sizeof(timeout_sys)))
2246 return -EFAULT;
2247
2248 datagrams = __sys_recvmmsg(fd, mmsg, vlen, flags, &timeout_sys);
2249
2250 if (datagrams > 0 &&
2251 copy_to_user(timeout, &timeout_sys, sizeof(timeout_sys)))
2252 datagrams = -EFAULT;
2253
2254 return datagrams;
2255}
2256
2257#ifdef __ARCH_WANT_SYS_SOCKETCALL
1da177e4
LT
2258/* Argument list sizes for sys_socketcall */
2259#define AL(x) ((x) * sizeof(unsigned long))
a2e27255 2260static const unsigned char nargs[20] = {
89bddce5
SH
2261 AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
2262 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
aaca0bdc 2263 AL(6),AL(2),AL(5),AL(5),AL(3),AL(3),
a2e27255 2264 AL(4),AL(5)
89bddce5
SH
2265};
2266
1da177e4
LT
2267#undef AL
2268
2269/*
89bddce5 2270 * System call vectors.
1da177e4
LT
2271 *
2272 * Argument checking cleaned up. Saved 20% in size.
2273 * This function doesn't need to set the kernel lock because
89bddce5 2274 * it is set by the callees.
1da177e4
LT
2275 */
2276
3e0fa65f 2277SYSCALL_DEFINE2(socketcall, int, call, unsigned long __user *, args)
1da177e4
LT
2278{
2279 unsigned long a[6];
89bddce5 2280 unsigned long a0, a1;
1da177e4 2281 int err;
47379052 2282 unsigned int len;
1da177e4 2283
a2e27255 2284 if (call < 1 || call > SYS_RECVMMSG)
1da177e4
LT
2285 return -EINVAL;
2286
47379052
AV
2287 len = nargs[call];
2288 if (len > sizeof(a))
2289 return -EINVAL;
2290
1da177e4 2291 /* copy_from_user should be SMP safe. */
47379052 2292 if (copy_from_user(a, args, len))
1da177e4 2293 return -EFAULT;
3ec3b2fb 2294
f3298dc4 2295 audit_socketcall(nargs[call] / sizeof(unsigned long), a);
3ec3b2fb 2296
89bddce5
SH
2297 a0 = a[0];
2298 a1 = a[1];
2299
2300 switch (call) {
2301 case SYS_SOCKET:
2302 err = sys_socket(a0, a1, a[2]);
2303 break;
2304 case SYS_BIND:
2305 err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]);
2306 break;
2307 case SYS_CONNECT:
2308 err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
2309 break;
2310 case SYS_LISTEN:
2311 err = sys_listen(a0, a1);
2312 break;
2313 case SYS_ACCEPT:
de11defe
UD
2314 err = sys_accept4(a0, (struct sockaddr __user *)a1,
2315 (int __user *)a[2], 0);
89bddce5
SH
2316 break;
2317 case SYS_GETSOCKNAME:
2318 err =
2319 sys_getsockname(a0, (struct sockaddr __user *)a1,
2320 (int __user *)a[2]);
2321 break;
2322 case SYS_GETPEERNAME:
2323 err =
2324 sys_getpeername(a0, (struct sockaddr __user *)a1,
2325 (int __user *)a[2]);
2326 break;
2327 case SYS_SOCKETPAIR:
2328 err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]);
2329 break;
2330 case SYS_SEND:
2331 err = sys_send(a0, (void __user *)a1, a[2], a[3]);
2332 break;
2333 case SYS_SENDTO:
2334 err = sys_sendto(a0, (void __user *)a1, a[2], a[3],
2335 (struct sockaddr __user *)a[4], a[5]);
2336 break;
2337 case SYS_RECV:
2338 err = sys_recv(a0, (void __user *)a1, a[2], a[3]);
2339 break;
2340 case SYS_RECVFROM:
2341 err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
2342 (struct sockaddr __user *)a[4],
2343 (int __user *)a[5]);
2344 break;
2345 case SYS_SHUTDOWN:
2346 err = sys_shutdown(a0, a1);
2347 break;
2348 case SYS_SETSOCKOPT:
2349 err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]);
2350 break;
2351 case SYS_GETSOCKOPT:
2352 err =
2353 sys_getsockopt(a0, a1, a[2], (char __user *)a[3],
2354 (int __user *)a[4]);
2355 break;
2356 case SYS_SENDMSG:
2357 err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]);
2358 break;
2359 case SYS_RECVMSG:
2360 err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]);
2361 break;
a2e27255
ACM
2362 case SYS_RECVMMSG:
2363 err = sys_recvmmsg(a0, (struct mmsghdr __user *)a1, a[2], a[3],
2364 (struct timespec __user *)a[4]);
2365 break;
de11defe
UD
2366 case SYS_ACCEPT4:
2367 err = sys_accept4(a0, (struct sockaddr __user *)a1,
2368 (int __user *)a[2], a[3]);
aaca0bdc 2369 break;
89bddce5
SH
2370 default:
2371 err = -EINVAL;
2372 break;
1da177e4
LT
2373 }
2374 return err;
2375}
2376
89bddce5 2377#endif /* __ARCH_WANT_SYS_SOCKETCALL */
1da177e4 2378
55737fda
SH
2379/**
2380 * sock_register - add a socket protocol handler
2381 * @ops: description of protocol
2382 *
1da177e4
LT
2383 * This function is called by a protocol handler that wants to
2384 * advertise its address family, and have it linked into the
55737fda
SH
2385 * socket interface. The value ops->family coresponds to the
2386 * socket system call protocol family.
1da177e4 2387 */
f0fd27d4 2388int sock_register(const struct net_proto_family *ops)
1da177e4
LT
2389{
2390 int err;
2391
2392 if (ops->family >= NPROTO) {
89bddce5
SH
2393 printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family,
2394 NPROTO);
1da177e4
LT
2395 return -ENOBUFS;
2396 }
55737fda
SH
2397
2398 spin_lock(&net_family_lock);
2399 if (net_families[ops->family])
2400 err = -EEXIST;
2401 else {
89bddce5 2402 net_families[ops->family] = ops;
1da177e4
LT
2403 err = 0;
2404 }
55737fda
SH
2405 spin_unlock(&net_family_lock);
2406
89bddce5 2407 printk(KERN_INFO "NET: Registered protocol family %d\n", ops->family);
1da177e4
LT
2408 return err;
2409}
2410
55737fda
SH
2411/**
2412 * sock_unregister - remove a protocol handler
2413 * @family: protocol family to remove
2414 *
1da177e4
LT
2415 * This function is called by a protocol handler that wants to
2416 * remove its address family, and have it unlinked from the
55737fda
SH
2417 * new socket creation.
2418 *
2419 * If protocol handler is a module, then it can use module reference
2420 * counts to protect against new references. If protocol handler is not
2421 * a module then it needs to provide its own protection in
2422 * the ops->create routine.
1da177e4 2423 */
f0fd27d4 2424void sock_unregister(int family)
1da177e4 2425{
f0fd27d4 2426 BUG_ON(family < 0 || family >= NPROTO);
1da177e4 2427
55737fda 2428 spin_lock(&net_family_lock);
89bddce5 2429 net_families[family] = NULL;
55737fda
SH
2430 spin_unlock(&net_family_lock);
2431
2432 synchronize_rcu();
2433
89bddce5 2434 printk(KERN_INFO "NET: Unregistered protocol family %d\n", family);
1da177e4
LT
2435}
2436
77d76ea3 2437static int __init sock_init(void)
1da177e4
LT
2438{
2439 /*
89bddce5 2440 * Initialize sock SLAB cache.
1da177e4 2441 */
89bddce5 2442
1da177e4
LT
2443 sk_init();
2444
1da177e4 2445 /*
89bddce5 2446 * Initialize skbuff SLAB cache
1da177e4
LT
2447 */
2448 skb_init();
1da177e4
LT
2449
2450 /*
89bddce5 2451 * Initialize the protocols module.
1da177e4
LT
2452 */
2453
2454 init_inodecache();
2455 register_filesystem(&sock_fs_type);
2456 sock_mnt = kern_mount(&sock_fs_type);
77d76ea3
AK
2457
2458 /* The real protocol initialization is performed in later initcalls.
1da177e4
LT
2459 */
2460
2461#ifdef CONFIG_NETFILTER
2462 netfilter_init();
2463#endif
cbeb321a
DM
2464
2465 return 0;
1da177e4
LT
2466}
2467
77d76ea3
AK
2468core_initcall(sock_init); /* early initcall */
2469
1da177e4
LT
2470#ifdef CONFIG_PROC_FS
2471void socket_seq_show(struct seq_file *seq)
2472{
2473 int cpu;
2474 int counter = 0;
2475
6f912042 2476 for_each_possible_cpu(cpu)
89bddce5 2477 counter += per_cpu(sockets_in_use, cpu);
1da177e4
LT
2478
2479 /* It can be negative, by the way. 8) */
2480 if (counter < 0)
2481 counter = 0;
2482
2483 seq_printf(seq, "sockets: used %d\n", counter);
2484}
89bddce5 2485#endif /* CONFIG_PROC_FS */
1da177e4 2486
89bbfc95 2487#ifdef CONFIG_COMPAT
6b96018b
AB
2488static int do_siocgstamp(struct net *net, struct socket *sock,
2489 unsigned int cmd, struct compat_timeval __user *up)
7a229387 2490{
7a229387
AB
2491 mm_segment_t old_fs = get_fs();
2492 struct timeval ktv;
2493 int err;
2494
2495 set_fs(KERNEL_DS);
6b96018b 2496 err = sock_do_ioctl(net, sock, cmd, (unsigned long)&ktv);
7a229387
AB
2497 set_fs(old_fs);
2498 if (!err) {
2499 err = put_user(ktv.tv_sec, &up->tv_sec);
2500 err |= __put_user(ktv.tv_usec, &up->tv_usec);
2501 }
2502 return err;
2503}
2504
6b96018b
AB
2505static int do_siocgstampns(struct net *net, struct socket *sock,
2506 unsigned int cmd, struct compat_timespec __user *up)
7a229387 2507{
7a229387
AB
2508 mm_segment_t old_fs = get_fs();
2509 struct timespec kts;
2510 int err;
2511
2512 set_fs(KERNEL_DS);
6b96018b 2513 err = sock_do_ioctl(net, sock, cmd, (unsigned long)&kts);
7a229387
AB
2514 set_fs(old_fs);
2515 if (!err) {
2516 err = put_user(kts.tv_sec, &up->tv_sec);
2517 err |= __put_user(kts.tv_nsec, &up->tv_nsec);
2518 }
2519 return err;
2520}
2521
6b96018b 2522static int dev_ifname32(struct net *net, struct compat_ifreq __user *uifr32)
7a229387
AB
2523{
2524 struct ifreq __user *uifr;
2525 int err;
2526
2527 uifr = compat_alloc_user_space(sizeof(struct ifreq));
6b96018b 2528 if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))
7a229387
AB
2529 return -EFAULT;
2530
6b96018b 2531 err = dev_ioctl(net, SIOCGIFNAME, uifr);
7a229387
AB
2532 if (err)
2533 return err;
2534
6b96018b 2535 if (copy_in_user(uifr32, uifr, sizeof(struct compat_ifreq)))
7a229387
AB
2536 return -EFAULT;
2537
2538 return 0;
2539}
2540
6b96018b 2541static int dev_ifconf(struct net *net, struct compat_ifconf __user *uifc32)
7a229387 2542{
6b96018b 2543 struct compat_ifconf ifc32;
7a229387
AB
2544 struct ifconf ifc;
2545 struct ifconf __user *uifc;
6b96018b 2546 struct compat_ifreq __user *ifr32;
7a229387
AB
2547 struct ifreq __user *ifr;
2548 unsigned int i, j;
2549 int err;
2550
6b96018b 2551 if (copy_from_user(&ifc32, uifc32, sizeof(struct compat_ifconf)))
7a229387
AB
2552 return -EFAULT;
2553
2554 if (ifc32.ifcbuf == 0) {
2555 ifc32.ifc_len = 0;
2556 ifc.ifc_len = 0;
2557 ifc.ifc_req = NULL;
2558 uifc = compat_alloc_user_space(sizeof(struct ifconf));
2559 } else {
6b96018b 2560 size_t len =((ifc32.ifc_len / sizeof (struct compat_ifreq)) + 1) *
7a229387
AB
2561 sizeof (struct ifreq);
2562 uifc = compat_alloc_user_space(sizeof(struct ifconf) + len);
2563 ifc.ifc_len = len;
2564 ifr = ifc.ifc_req = (void __user *)(uifc + 1);
2565 ifr32 = compat_ptr(ifc32.ifcbuf);
6b96018b
AB
2566 for (i = 0; i < ifc32.ifc_len; i += sizeof (struct compat_ifreq)) {
2567 if (copy_in_user(ifr, ifr32, sizeof(struct compat_ifreq)))
7a229387
AB
2568 return -EFAULT;
2569 ifr++;
2570 ifr32++;
2571 }
2572 }
2573 if (copy_to_user(uifc, &ifc, sizeof(struct ifconf)))
2574 return -EFAULT;
2575
6b96018b 2576 err = dev_ioctl(net, SIOCGIFCONF, uifc);
7a229387
AB
2577 if (err)
2578 return err;
2579
2580 if (copy_from_user(&ifc, uifc, sizeof(struct ifconf)))
2581 return -EFAULT;
2582
2583 ifr = ifc.ifc_req;
2584 ifr32 = compat_ptr(ifc32.ifcbuf);
2585 for (i = 0, j = 0;
6b96018b
AB
2586 i + sizeof (struct compat_ifreq) <= ifc32.ifc_len && j < ifc.ifc_len;
2587 i += sizeof (struct compat_ifreq), j += sizeof (struct ifreq)) {
2588 if (copy_in_user(ifr32, ifr, sizeof (struct compat_ifreq)))
7a229387
AB
2589 return -EFAULT;
2590 ifr32++;
2591 ifr++;
2592 }
2593
2594 if (ifc32.ifcbuf == 0) {
2595 /* Translate from 64-bit structure multiple to
2596 * a 32-bit one.
2597 */
2598 i = ifc.ifc_len;
6b96018b 2599 i = ((i / sizeof(struct ifreq)) * sizeof(struct compat_ifreq));
7a229387
AB
2600 ifc32.ifc_len = i;
2601 } else {
2602 ifc32.ifc_len = i;
2603 }
6b96018b 2604 if (copy_to_user(uifc32, &ifc32, sizeof(struct compat_ifconf)))
7a229387
AB
2605 return -EFAULT;
2606
2607 return 0;
2608}
2609
6b96018b 2610static int ethtool_ioctl(struct net *net, struct compat_ifreq __user *ifr32)
7a229387
AB
2611{
2612 struct ifreq __user *ifr;
7a229387
AB
2613 u32 data;
2614 void __user *datap;
2615
2616 ifr = compat_alloc_user_space(sizeof(*ifr));
7a229387
AB
2617
2618 if (copy_in_user(&ifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ))
2619 return -EFAULT;
2620
2621 if (get_user(data, &ifr32->ifr_ifru.ifru_data))
2622 return -EFAULT;
2623
2624 datap = compat_ptr(data);
2625 if (put_user(datap, &ifr->ifr_ifru.ifru_data))
2626 return -EFAULT;
2627
6b96018b 2628 return dev_ioctl(net, SIOCETHTOOL, ifr);
7a229387
AB
2629}
2630
7a50a240
AB
2631static int compat_siocwandev(struct net *net, struct compat_ifreq __user *uifr32)
2632{
2633 void __user *uptr;
2634 compat_uptr_t uptr32;
2635 struct ifreq __user *uifr;
2636
2637 uifr = compat_alloc_user_space(sizeof (*uifr));
2638 if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))
2639 return -EFAULT;
2640
2641 if (get_user(uptr32, &uifr32->ifr_settings.ifs_ifsu))
2642 return -EFAULT;
2643
2644 uptr = compat_ptr(uptr32);
2645
2646 if (put_user(uptr, &uifr->ifr_settings.ifs_ifsu.raw_hdlc))
2647 return -EFAULT;
2648
2649 return dev_ioctl(net, SIOCWANDEV, uifr);
2650}
2651
6b96018b
AB
2652static int bond_ioctl(struct net *net, unsigned int cmd,
2653 struct compat_ifreq __user *ifr32)
7a229387
AB
2654{
2655 struct ifreq kifr;
2656 struct ifreq __user *uifr;
7a229387
AB
2657 mm_segment_t old_fs;
2658 int err;
2659 u32 data;
2660 void __user *datap;
2661
2662 switch (cmd) {
2663 case SIOCBONDENSLAVE:
2664 case SIOCBONDRELEASE:
2665 case SIOCBONDSETHWADDR:
2666 case SIOCBONDCHANGEACTIVE:
6b96018b 2667 if (copy_from_user(&kifr, ifr32, sizeof(struct compat_ifreq)))
7a229387
AB
2668 return -EFAULT;
2669
2670 old_fs = get_fs();
2671 set_fs (KERNEL_DS);
6b96018b 2672 err = dev_ioctl(net, cmd, &kifr);
7a229387
AB
2673 set_fs (old_fs);
2674
2675 return err;
2676 case SIOCBONDSLAVEINFOQUERY:
2677 case SIOCBONDINFOQUERY:
2678 uifr = compat_alloc_user_space(sizeof(*uifr));
2679 if (copy_in_user(&uifr->ifr_name, &ifr32->ifr_name, IFNAMSIZ))
2680 return -EFAULT;
2681
2682 if (get_user(data, &ifr32->ifr_ifru.ifru_data))
2683 return -EFAULT;
2684
2685 datap = compat_ptr(data);
2686 if (put_user(datap, &uifr->ifr_ifru.ifru_data))
2687 return -EFAULT;
2688
6b96018b 2689 return dev_ioctl(net, cmd, uifr);
7a229387
AB
2690 default:
2691 return -EINVAL;
2692 };
2693}
2694
6b96018b
AB
2695static int siocdevprivate_ioctl(struct net *net, unsigned int cmd,
2696 struct compat_ifreq __user *u_ifreq32)
7a229387
AB
2697{
2698 struct ifreq __user *u_ifreq64;
7a229387
AB
2699 char tmp_buf[IFNAMSIZ];
2700 void __user *data64;
2701 u32 data32;
2702
2703 if (copy_from_user(&tmp_buf[0], &(u_ifreq32->ifr_ifrn.ifrn_name[0]),
2704 IFNAMSIZ))
2705 return -EFAULT;
2706 if (__get_user(data32, &u_ifreq32->ifr_ifru.ifru_data))
2707 return -EFAULT;
2708 data64 = compat_ptr(data32);
2709
2710 u_ifreq64 = compat_alloc_user_space(sizeof(*u_ifreq64));
2711
2712 /* Don't check these user accesses, just let that get trapped
2713 * in the ioctl handler instead.
2714 */
2715 if (copy_to_user(&u_ifreq64->ifr_ifrn.ifrn_name[0], &tmp_buf[0],
2716 IFNAMSIZ))
2717 return -EFAULT;
2718 if (__put_user(data64, &u_ifreq64->ifr_ifru.ifru_data))
2719 return -EFAULT;
2720
6b96018b 2721 return dev_ioctl(net, cmd, u_ifreq64);
7a229387
AB
2722}
2723
6b96018b
AB
2724static int dev_ifsioc(struct net *net, struct socket *sock,
2725 unsigned int cmd, struct compat_ifreq __user *uifr32)
7a229387 2726{
a2116ed2 2727 struct ifreq __user *uifr;
7a229387
AB
2728 int err;
2729
a2116ed2
AB
2730 uifr = compat_alloc_user_space(sizeof(*uifr));
2731 if (copy_in_user(uifr, uifr32, sizeof(*uifr32)))
2732 return -EFAULT;
2733
2734 err = sock_do_ioctl(net, sock, cmd, (unsigned long)uifr);
2735
7a229387
AB
2736 if (!err) {
2737 switch (cmd) {
2738 case SIOCGIFFLAGS:
2739 case SIOCGIFMETRIC:
2740 case SIOCGIFMTU:
2741 case SIOCGIFMEM:
2742 case SIOCGIFHWADDR:
2743 case SIOCGIFINDEX:
2744 case SIOCGIFADDR:
2745 case SIOCGIFBRDADDR:
2746 case SIOCGIFDSTADDR:
2747 case SIOCGIFNETMASK:
fab2532b 2748 case SIOCGIFPFLAGS:
7a229387 2749 case SIOCGIFTXQLEN:
fab2532b
AB
2750 case SIOCGMIIPHY:
2751 case SIOCGMIIREG:
a2116ed2 2752 if (copy_in_user(uifr32, uifr, sizeof(*uifr32)))
7a229387
AB
2753 err = -EFAULT;
2754 break;
2755 }
2756 }
2757 return err;
2758}
2759
a2116ed2
AB
2760static int compat_sioc_ifmap(struct net *net, unsigned int cmd,
2761 struct compat_ifreq __user *uifr32)
2762{
2763 struct ifreq ifr;
2764 struct compat_ifmap __user *uifmap32;
2765 mm_segment_t old_fs;
2766 int err;
2767
2768 uifmap32 = &uifr32->ifr_ifru.ifru_map;
2769 err = copy_from_user(&ifr, uifr32, sizeof(ifr.ifr_name));
2770 err |= __get_user(ifr.ifr_map.mem_start, &uifmap32->mem_start);
2771 err |= __get_user(ifr.ifr_map.mem_end, &uifmap32->mem_end);
2772 err |= __get_user(ifr.ifr_map.base_addr, &uifmap32->base_addr);
2773 err |= __get_user(ifr.ifr_map.irq, &uifmap32->irq);
2774 err |= __get_user(ifr.ifr_map.dma, &uifmap32->dma);
2775 err |= __get_user(ifr.ifr_map.port, &uifmap32->port);
2776 if (err)
2777 return -EFAULT;
2778
2779 old_fs = get_fs();
2780 set_fs (KERNEL_DS);
2781 err = dev_ioctl(net, cmd, (void __user *)&ifr);
2782 set_fs (old_fs);
2783
2784 if (cmd == SIOCGIFMAP && !err) {
2785 err = copy_to_user(uifr32, &ifr, sizeof(ifr.ifr_name));
2786 err |= __put_user(ifr.ifr_map.mem_start, &uifmap32->mem_start);
2787 err |= __put_user(ifr.ifr_map.mem_end, &uifmap32->mem_end);
2788 err |= __put_user(ifr.ifr_map.base_addr, &uifmap32->base_addr);
2789 err |= __put_user(ifr.ifr_map.irq, &uifmap32->irq);
2790 err |= __put_user(ifr.ifr_map.dma, &uifmap32->dma);
2791 err |= __put_user(ifr.ifr_map.port, &uifmap32->port);
2792 if (err)
2793 err = -EFAULT;
2794 }
2795 return err;
2796}
2797
2798static int compat_siocshwtstamp(struct net *net, struct compat_ifreq __user *uifr32)
2799{
2800 void __user *uptr;
2801 compat_uptr_t uptr32;
2802 struct ifreq __user *uifr;
2803
2804 uifr = compat_alloc_user_space(sizeof (*uifr));
2805 if (copy_in_user(uifr, uifr32, sizeof(struct compat_ifreq)))
2806 return -EFAULT;
2807
2808 if (get_user(uptr32, &uifr32->ifr_data))
2809 return -EFAULT;
2810
2811 uptr = compat_ptr(uptr32);
2812
2813 if (put_user(uptr, &uifr->ifr_data))
2814 return -EFAULT;
2815
2816 return dev_ioctl(net, SIOCSHWTSTAMP, uifr);
2817}
2818
7a229387
AB
2819struct rtentry32 {
2820 u32 rt_pad1;
2821 struct sockaddr rt_dst; /* target address */
2822 struct sockaddr rt_gateway; /* gateway addr (RTF_GATEWAY) */
2823 struct sockaddr rt_genmask; /* target network mask (IP) */
2824 unsigned short rt_flags;
2825 short rt_pad2;
2826 u32 rt_pad3;
2827 unsigned char rt_tos;
2828 unsigned char rt_class;
2829 short rt_pad4;
2830 short rt_metric; /* +1 for binary compatibility! */
2831 /* char * */ u32 rt_dev; /* forcing the device at add */
2832 u32 rt_mtu; /* per route MTU/Window */
2833 u32 rt_window; /* Window clamping */
2834 unsigned short rt_irtt; /* Initial RTT */
2835};
2836
2837struct in6_rtmsg32 {
2838 struct in6_addr rtmsg_dst;
2839 struct in6_addr rtmsg_src;
2840 struct in6_addr rtmsg_gateway;
2841 u32 rtmsg_type;
2842 u16 rtmsg_dst_len;
2843 u16 rtmsg_src_len;
2844 u32 rtmsg_metric;
2845 u32 rtmsg_info;
2846 u32 rtmsg_flags;
2847 s32 rtmsg_ifindex;
2848};
2849
6b96018b
AB
2850static int routing_ioctl(struct net *net, struct socket *sock,
2851 unsigned int cmd, void __user *argp)
7a229387
AB
2852{
2853 int ret;
2854 void *r = NULL;
2855 struct in6_rtmsg r6;
2856 struct rtentry r4;
2857 char devname[16];
2858 u32 rtdev;
2859 mm_segment_t old_fs = get_fs();
2860
6b96018b
AB
2861 if (sock && sock->sk && sock->sk->sk_family == AF_INET6) { /* ipv6 */
2862 struct in6_rtmsg32 __user *ur6 = argp;
7a229387
AB
2863 ret = copy_from_user (&r6.rtmsg_dst, &(ur6->rtmsg_dst),
2864 3 * sizeof(struct in6_addr));
2865 ret |= __get_user (r6.rtmsg_type, &(ur6->rtmsg_type));
2866 ret |= __get_user (r6.rtmsg_dst_len, &(ur6->rtmsg_dst_len));
2867 ret |= __get_user (r6.rtmsg_src_len, &(ur6->rtmsg_src_len));
2868 ret |= __get_user (r6.rtmsg_metric, &(ur6->rtmsg_metric));
2869 ret |= __get_user (r6.rtmsg_info, &(ur6->rtmsg_info));
2870 ret |= __get_user (r6.rtmsg_flags, &(ur6->rtmsg_flags));
2871 ret |= __get_user (r6.rtmsg_ifindex, &(ur6->rtmsg_ifindex));
2872
2873 r = (void *) &r6;
2874 } else { /* ipv4 */
6b96018b 2875 struct rtentry32 __user *ur4 = argp;
7a229387
AB
2876 ret = copy_from_user (&r4.rt_dst, &(ur4->rt_dst),
2877 3 * sizeof(struct sockaddr));
2878 ret |= __get_user (r4.rt_flags, &(ur4->rt_flags));
2879 ret |= __get_user (r4.rt_metric, &(ur4->rt_metric));
2880 ret |= __get_user (r4.rt_mtu, &(ur4->rt_mtu));
2881 ret |= __get_user (r4.rt_window, &(ur4->rt_window));
2882 ret |= __get_user (r4.rt_irtt, &(ur4->rt_irtt));
2883 ret |= __get_user (rtdev, &(ur4->rt_dev));
2884 if (rtdev) {
2885 ret |= copy_from_user (devname, compat_ptr(rtdev), 15);
2886 r4.rt_dev = devname; devname[15] = 0;
2887 } else
2888 r4.rt_dev = NULL;
2889
2890 r = (void *) &r4;
2891 }
2892
2893 if (ret) {
2894 ret = -EFAULT;
2895 goto out;
2896 }
2897
2898 set_fs (KERNEL_DS);
6b96018b 2899 ret = sock_do_ioctl(net, sock, cmd, (unsigned long) r);
7a229387
AB
2900 set_fs (old_fs);
2901
2902out:
7a229387
AB
2903 return ret;
2904}
2905
2906/* Since old style bridge ioctl's endup using SIOCDEVPRIVATE
2907 * for some operations; this forces use of the newer bridge-utils that
2908 * use compatiable ioctls
2909 */
6b96018b 2910static int old_bridge_ioctl(compat_ulong_t __user *argp)
7a229387 2911{
6b96018b 2912 compat_ulong_t tmp;
7a229387 2913
6b96018b 2914 if (get_user(tmp, argp))
7a229387
AB
2915 return -EFAULT;
2916 if (tmp == BRCTL_GET_VERSION)
2917 return BRCTL_VERSION + 1;
2918 return -EINVAL;
2919}
2920
6b96018b
AB
2921static int compat_sock_ioctl_trans(struct file *file, struct socket *sock,
2922 unsigned int cmd, unsigned long arg)
2923{
2924 void __user *argp = compat_ptr(arg);
2925 struct sock *sk = sock->sk;
2926 struct net *net = sock_net(sk);
7a229387 2927
6b96018b
AB
2928 if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15))
2929 return siocdevprivate_ioctl(net, cmd, argp);
2930
2931 switch (cmd) {
2932 case SIOCSIFBR:
2933 case SIOCGIFBR:
2934 return old_bridge_ioctl(argp);
2935 case SIOCGIFNAME:
2936 return dev_ifname32(net, argp);
2937 case SIOCGIFCONF:
2938 return dev_ifconf(net, argp);
2939 case SIOCETHTOOL:
2940 return ethtool_ioctl(net, argp);
7a50a240
AB
2941 case SIOCWANDEV:
2942 return compat_siocwandev(net, argp);
a2116ed2
AB
2943 case SIOCGIFMAP:
2944 case SIOCSIFMAP:
2945 return compat_sioc_ifmap(net, cmd, argp);
6b96018b
AB
2946 case SIOCBONDENSLAVE:
2947 case SIOCBONDRELEASE:
2948 case SIOCBONDSETHWADDR:
2949 case SIOCBONDSLAVEINFOQUERY:
2950 case SIOCBONDINFOQUERY:
2951 case SIOCBONDCHANGEACTIVE:
2952 return bond_ioctl(net, cmd, argp);
2953 case SIOCADDRT:
2954 case SIOCDELRT:
2955 return routing_ioctl(net, sock, cmd, argp);
2956 case SIOCGSTAMP:
2957 return do_siocgstamp(net, sock, cmd, argp);
2958 case SIOCGSTAMPNS:
2959 return do_siocgstampns(net, sock, cmd, argp);
a2116ed2
AB
2960 case SIOCSHWTSTAMP:
2961 return compat_siocshwtstamp(net, argp);
6b96018b
AB
2962
2963 case FIOSETOWN:
2964 case SIOCSPGRP:
2965 case FIOGETOWN:
2966 case SIOCGPGRP:
2967 case SIOCBRADDBR:
2968 case SIOCBRDELBR:
2969 case SIOCGIFVLAN:
2970 case SIOCSIFVLAN:
2971 case SIOCADDDLCI:
2972 case SIOCDELDLCI:
2973 return sock_ioctl(file, cmd, arg);
2974
2975 case SIOCGIFFLAGS:
2976 case SIOCSIFFLAGS:
2977 case SIOCGIFMETRIC:
2978 case SIOCSIFMETRIC:
2979 case SIOCGIFMTU:
2980 case SIOCSIFMTU:
2981 case SIOCGIFMEM:
2982 case SIOCSIFMEM:
2983 case SIOCGIFHWADDR:
2984 case SIOCSIFHWADDR:
2985 case SIOCADDMULTI:
2986 case SIOCDELMULTI:
2987 case SIOCGIFINDEX:
6b96018b
AB
2988 case SIOCGIFADDR:
2989 case SIOCSIFADDR:
2990 case SIOCSIFHWBROADCAST:
6b96018b 2991 case SIOCDIFADDR:
6b96018b
AB
2992 case SIOCGIFBRDADDR:
2993 case SIOCSIFBRDADDR:
2994 case SIOCGIFDSTADDR:
2995 case SIOCSIFDSTADDR:
2996 case SIOCGIFNETMASK:
2997 case SIOCSIFNETMASK:
2998 case SIOCSIFPFLAGS:
2999 case SIOCGIFPFLAGS:
3000 case SIOCGIFTXQLEN:
3001 case SIOCSIFTXQLEN:
3002 case SIOCBRADDIF:
3003 case SIOCBRDELIF:
9177efd3
AB
3004 case SIOCSIFNAME:
3005 case SIOCGMIIPHY:
3006 case SIOCGMIIREG:
3007 case SIOCSMIIREG:
6b96018b 3008 return dev_ifsioc(net, sock, cmd, argp);
9177efd3 3009
6b96018b
AB
3010 case SIOCSARP:
3011 case SIOCGARP:
3012 case SIOCDARP:
6b96018b 3013 case SIOCATMARK:
9177efd3
AB
3014 return sock_do_ioctl(net, sock, cmd, arg);
3015 }
3016
3017 /* Prevent warning from compat_sys_ioctl, these always
3018 * result in -EINVAL in the native case anyway. */
3019 switch (cmd) {
3020 case SIOCRTMSG:
3021 case SIOCGIFCOUNT:
6b96018b
AB
3022 case SIOCSRARP:
3023 case SIOCGRARP:
3024 case SIOCDRARP:
9177efd3
AB
3025 case SIOCSIFLINK:
3026 case SIOCGIFSLAVE:
3027 case SIOCSIFSLAVE:
3028 return -EINVAL;
6b96018b
AB
3029 }
3030
3031 return -ENOIOCTLCMD;
3032}
7a229387 3033
89bbfc95 3034static long compat_sock_ioctl(struct file *file, unsigned cmd,
89bddce5 3035 unsigned long arg)
89bbfc95
SP
3036{
3037 struct socket *sock = file->private_data;
3038 int ret = -ENOIOCTLCMD;
87de87d5
DM
3039 struct sock *sk;
3040 struct net *net;
3041
3042 sk = sock->sk;
3043 net = sock_net(sk);
89bbfc95
SP
3044
3045 if (sock->ops->compat_ioctl)
3046 ret = sock->ops->compat_ioctl(sock, cmd, arg);
3047
87de87d5
DM
3048 if (ret == -ENOIOCTLCMD &&
3049 (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST))
3050 ret = compat_wext_handle_ioctl(net, cmd, arg);
3051
6b96018b
AB
3052 if (ret == -ENOIOCTLCMD)
3053 ret = compat_sock_ioctl_trans(file, sock, cmd, arg);
3054
89bbfc95
SP
3055 return ret;
3056}
3057#endif
3058
ac5a488e
SS
3059int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen)
3060{
3061 return sock->ops->bind(sock, addr, addrlen);
3062}
3063
3064int kernel_listen(struct socket *sock, int backlog)
3065{
3066 return sock->ops->listen(sock, backlog);
3067}
3068
3069int kernel_accept(struct socket *sock, struct socket **newsock, int flags)
3070{
3071 struct sock *sk = sock->sk;
3072 int err;
3073
3074 err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol,
3075 newsock);
3076 if (err < 0)
3077 goto done;
3078
3079 err = sock->ops->accept(sock, *newsock, flags);
3080 if (err < 0) {
3081 sock_release(*newsock);
fa8705b0 3082 *newsock = NULL;
ac5a488e
SS
3083 goto done;
3084 }
3085
3086 (*newsock)->ops = sock->ops;
1b08534e 3087 __module_get((*newsock)->ops->owner);
ac5a488e
SS
3088
3089done:
3090 return err;
3091}
3092
3093int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen,
4768fbcb 3094 int flags)
ac5a488e
SS
3095{
3096 return sock->ops->connect(sock, addr, addrlen, flags);
3097}
3098
3099int kernel_getsockname(struct socket *sock, struct sockaddr *addr,
3100 int *addrlen)
3101{
3102 return sock->ops->getname(sock, addr, addrlen, 0);
3103}
3104
3105int kernel_getpeername(struct socket *sock, struct sockaddr *addr,
3106 int *addrlen)
3107{
3108 return sock->ops->getname(sock, addr, addrlen, 1);
3109}
3110
3111int kernel_getsockopt(struct socket *sock, int level, int optname,
3112 char *optval, int *optlen)
3113{
3114 mm_segment_t oldfs = get_fs();
3115 int err;
3116
3117 set_fs(KERNEL_DS);
3118 if (level == SOL_SOCKET)
3119 err = sock_getsockopt(sock, level, optname, optval, optlen);
3120 else
3121 err = sock->ops->getsockopt(sock, level, optname, optval,
3122 optlen);
3123 set_fs(oldfs);
3124 return err;
3125}
3126
3127int kernel_setsockopt(struct socket *sock, int level, int optname,
b7058842 3128 char *optval, unsigned int optlen)
ac5a488e
SS
3129{
3130 mm_segment_t oldfs = get_fs();
3131 int err;
3132
3133 set_fs(KERNEL_DS);
3134 if (level == SOL_SOCKET)
3135 err = sock_setsockopt(sock, level, optname, optval, optlen);
3136 else
3137 err = sock->ops->setsockopt(sock, level, optname, optval,
3138 optlen);
3139 set_fs(oldfs);
3140 return err;
3141}
3142
3143int kernel_sendpage(struct socket *sock, struct page *page, int offset,
3144 size_t size, int flags)
3145{
3146 if (sock->ops->sendpage)
3147 return sock->ops->sendpage(sock, page, offset, size, flags);
3148
3149 return sock_no_sendpage(sock, page, offset, size, flags);
3150}
3151
3152int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg)
3153{
3154 mm_segment_t oldfs = get_fs();
3155 int err;
3156
3157 set_fs(KERNEL_DS);
3158 err = sock->ops->ioctl(sock, cmd, arg);
3159 set_fs(oldfs);
3160
3161 return err;
3162}
3163
91cf45f0
TM
3164int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how)
3165{
3166 return sock->ops->shutdown(sock, how);
3167}
3168
1da177e4
LT
3169EXPORT_SYMBOL(sock_create);
3170EXPORT_SYMBOL(sock_create_kern);
3171EXPORT_SYMBOL(sock_create_lite);
3172EXPORT_SYMBOL(sock_map_fd);
3173EXPORT_SYMBOL(sock_recvmsg);
3174EXPORT_SYMBOL(sock_register);
3175EXPORT_SYMBOL(sock_release);
3176EXPORT_SYMBOL(sock_sendmsg);
3177EXPORT_SYMBOL(sock_unregister);
3178EXPORT_SYMBOL(sock_wake_async);
3179EXPORT_SYMBOL(sockfd_lookup);
3180EXPORT_SYMBOL(kernel_sendmsg);
3181EXPORT_SYMBOL(kernel_recvmsg);
ac5a488e
SS
3182EXPORT_SYMBOL(kernel_bind);
3183EXPORT_SYMBOL(kernel_listen);
3184EXPORT_SYMBOL(kernel_accept);
3185EXPORT_SYMBOL(kernel_connect);
3186EXPORT_SYMBOL(kernel_getsockname);
3187EXPORT_SYMBOL(kernel_getpeername);
3188EXPORT_SYMBOL(kernel_getsockopt);
3189EXPORT_SYMBOL(kernel_setsockopt);
3190EXPORT_SYMBOL(kernel_sendpage);
3191EXPORT_SYMBOL(kernel_sock_ioctl);
91cf45f0 3192EXPORT_SYMBOL(kernel_sock_shutdown);