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