ipv4: Add a missing rcu_assign_pointer() in routing cache.
[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>
c019bbc6 72#include <linux/thread_info.h>
1da177e4
LT
73#include <linux/wanrouter.h>
74#include <linux/if_bridge.h>
20380731
ACM
75#include <linux/if_frad.h>
76#include <linux/if_vlan.h>
1da177e4
LT
77#include <linux/init.h>
78#include <linux/poll.h>
79#include <linux/cache.h>
80#include <linux/module.h>
81#include <linux/highmem.h>
1da177e4
LT
82#include <linux/mount.h>
83#include <linux/security.h>
84#include <linux/syscalls.h>
85#include <linux/compat.h>
86#include <linux/kmod.h>
3ec3b2fb 87#include <linux/audit.h>
d86b5e0e 88#include <linux/wireless.h>
1b8d7ae4 89#include <linux/nsproxy.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
100static int sock_no_open(struct inode *irrelevant, struct file *dontcare);
027445c3
BP
101static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov,
102 unsigned long nr_segs, loff_t pos);
103static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov,
104 unsigned long nr_segs, loff_t pos);
89bddce5 105static int sock_mmap(struct file *file, struct vm_area_struct *vma);
1da177e4
LT
106
107static int sock_close(struct inode *inode, struct file *file);
108static unsigned int sock_poll(struct file *file,
109 struct poll_table_struct *wait);
89bddce5 110static long sock_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
89bbfc95
SP
111#ifdef CONFIG_COMPAT
112static long compat_sock_ioctl(struct file *file,
89bddce5 113 unsigned int cmd, unsigned long arg);
89bbfc95 114#endif
1da177e4 115static int sock_fasync(int fd, struct file *filp, int on);
1da177e4
LT
116static ssize_t sock_sendpage(struct file *file, struct page *page,
117 int offset, size_t size, loff_t *ppos, int more);
9c55e01c
JA
118static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
119 struct pipe_inode_info *pipe, size_t len,
120 unsigned int flags);
1da177e4 121
1da177e4
LT
122/*
123 * Socket files have a set of 'special' operations as well as the generic file ones. These don't appear
124 * in the operation structures but are done directly via the socketcall() multiplexor.
125 */
126
da7071d7 127static const struct file_operations socket_file_ops = {
1da177e4
LT
128 .owner = THIS_MODULE,
129 .llseek = no_llseek,
130 .aio_read = sock_aio_read,
131 .aio_write = sock_aio_write,
132 .poll = sock_poll,
133 .unlocked_ioctl = sock_ioctl,
89bbfc95
SP
134#ifdef CONFIG_COMPAT
135 .compat_ioctl = compat_sock_ioctl,
136#endif
1da177e4
LT
137 .mmap = sock_mmap,
138 .open = sock_no_open, /* special open code to disallow open via /proc */
139 .release = sock_close,
140 .fasync = sock_fasync,
5274f052
JA
141 .sendpage = sock_sendpage,
142 .splice_write = generic_splice_sendpage,
9c55e01c 143 .splice_read = sock_splice_read,
1da177e4
LT
144};
145
146/*
147 * The protocol list. Each protocol is registered in here.
148 */
149
1da177e4 150static DEFINE_SPINLOCK(net_family_lock);
f0fd27d4 151static const struct net_proto_family *net_families[NPROTO] __read_mostly;
1da177e4 152
1da177e4
LT
153/*
154 * Statistics counters of the socket lists
155 */
156
157static DEFINE_PER_CPU(int, sockets_in_use) = 0;
158
159/*
89bddce5
SH
160 * Support routines.
161 * Move socket addresses back and forth across the kernel/user
162 * divide and look after the messy bits.
1da177e4
LT
163 */
164
89bddce5 165#define MAX_SOCK_ADDR 128 /* 108 for Unix domain -
1da177e4
LT
166 16 for IP, 16 for IPX,
167 24 for IPv6,
89bddce5 168 about 80 for AX.25
1da177e4
LT
169 must be at least one bigger than
170 the AF_UNIX size (see net/unix/af_unix.c
89bddce5 171 :unix_mkname()).
1da177e4 172 */
89bddce5 173
1da177e4
LT
174/**
175 * move_addr_to_kernel - copy a socket address into kernel space
176 * @uaddr: Address in user space
177 * @kaddr: Address in kernel space
178 * @ulen: Length in user space
179 *
180 * The address is copied into kernel space. If the provided address is
181 * too long an error code of -EINVAL is returned. If the copy gives
182 * invalid addresses -EFAULT is returned. On a success 0 is returned.
183 */
184
230b1839 185int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr *kaddr)
1da177e4 186{
230b1839 187 if (ulen < 0 || ulen > sizeof(struct sockaddr_storage))
1da177e4 188 return -EINVAL;
89bddce5 189 if (ulen == 0)
1da177e4 190 return 0;
89bddce5 191 if (copy_from_user(kaddr, uaddr, ulen))
1da177e4 192 return -EFAULT;
3ec3b2fb 193 return audit_sockaddr(ulen, kaddr);
1da177e4
LT
194}
195
196/**
197 * move_addr_to_user - copy an address to user space
198 * @kaddr: kernel space address
199 * @klen: length of address in kernel
200 * @uaddr: user space address
201 * @ulen: pointer to user length field
202 *
203 * The value pointed to by ulen on entry is the buffer length available.
204 * This is overwritten with the buffer space used. -EINVAL is returned
205 * if an overlong buffer is specified or a negative buffer size. -EFAULT
206 * is returned if either the buffer or the length field are not
207 * accessible.
208 * After copying the data up to the limit the user specifies, the true
209 * length of the data is written over the length limit the user
210 * specified. Zero is returned for a success.
211 */
89bddce5 212
230b1839 213int move_addr_to_user(struct sockaddr *kaddr, int klen, void __user *uaddr,
89bddce5 214 int __user *ulen)
1da177e4
LT
215{
216 int err;
217 int len;
218
89bddce5
SH
219 err = get_user(len, ulen);
220 if (err)
1da177e4 221 return err;
89bddce5
SH
222 if (len > klen)
223 len = klen;
230b1839 224 if (len < 0 || len > sizeof(struct sockaddr_storage))
1da177e4 225 return -EINVAL;
89bddce5 226 if (len) {
d6fe3945
SG
227 if (audit_sockaddr(klen, kaddr))
228 return -ENOMEM;
89bddce5 229 if (copy_to_user(uaddr, kaddr, len))
1da177e4
LT
230 return -EFAULT;
231 }
232 /*
89bddce5
SH
233 * "fromlen shall refer to the value before truncation.."
234 * 1003.1g
1da177e4
LT
235 */
236 return __put_user(klen, ulen);
237}
238
239#define SOCKFS_MAGIC 0x534F434B
240
e18b890b 241static struct kmem_cache *sock_inode_cachep __read_mostly;
1da177e4
LT
242
243static struct inode *sock_alloc_inode(struct super_block *sb)
244{
245 struct socket_alloc *ei;
89bddce5 246
e94b1766 247 ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL);
1da177e4
LT
248 if (!ei)
249 return NULL;
250 init_waitqueue_head(&ei->socket.wait);
89bddce5 251
1da177e4
LT
252 ei->socket.fasync_list = NULL;
253 ei->socket.state = SS_UNCONNECTED;
254 ei->socket.flags = 0;
255 ei->socket.ops = NULL;
256 ei->socket.sk = NULL;
257 ei->socket.file = NULL;
1da177e4
LT
258
259 return &ei->vfs_inode;
260}
261
262static void sock_destroy_inode(struct inode *inode)
263{
264 kmem_cache_free(sock_inode_cachep,
265 container_of(inode, struct socket_alloc, vfs_inode));
266}
267
51cc5068 268static void init_once(void *foo)
1da177e4 269{
89bddce5 270 struct socket_alloc *ei = (struct socket_alloc *)foo;
1da177e4 271
a35afb83 272 inode_init_once(&ei->vfs_inode);
1da177e4 273}
89bddce5 274
1da177e4
LT
275static int init_inodecache(void)
276{
277 sock_inode_cachep = kmem_cache_create("sock_inode_cache",
89bddce5
SH
278 sizeof(struct socket_alloc),
279 0,
280 (SLAB_HWCACHE_ALIGN |
281 SLAB_RECLAIM_ACCOUNT |
282 SLAB_MEM_SPREAD),
20c2df83 283 init_once);
1da177e4
LT
284 if (sock_inode_cachep == NULL)
285 return -ENOMEM;
286 return 0;
287}
288
289static struct super_operations sockfs_ops = {
290 .alloc_inode = sock_alloc_inode,
291 .destroy_inode =sock_destroy_inode,
292 .statfs = simple_statfs,
293};
294
454e2398 295static int sockfs_get_sb(struct file_system_type *fs_type,
89bddce5
SH
296 int flags, const char *dev_name, void *data,
297 struct vfsmount *mnt)
1da177e4 298{
454e2398
DH
299 return get_sb_pseudo(fs_type, "socket:", &sockfs_ops, SOCKFS_MAGIC,
300 mnt);
1da177e4
LT
301}
302
ba89966c 303static struct vfsmount *sock_mnt __read_mostly;
1da177e4
LT
304
305static struct file_system_type sock_fs_type = {
306 .name = "sockfs",
307 .get_sb = sockfs_get_sb,
308 .kill_sb = kill_anon_super,
309};
89bddce5 310
1da177e4
LT
311static int sockfs_delete_dentry(struct dentry *dentry)
312{
304e61e6
ED
313 /*
314 * At creation time, we pretended this dentry was hashed
315 * (by clearing DCACHE_UNHASHED bit in d_flags)
316 * At delete time, we restore the truth : not hashed.
317 * (so that dput() can proceed correctly)
318 */
319 dentry->d_flags |= DCACHE_UNHASHED;
320 return 0;
1da177e4 321}
c23fbb6b
ED
322
323/*
324 * sockfs_dname() is called from d_path().
325 */
326static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen)
327{
328 return dynamic_dname(dentry, buffer, buflen, "socket:[%lu]",
329 dentry->d_inode->i_ino);
330}
331
1da177e4 332static struct dentry_operations sockfs_dentry_operations = {
89bddce5 333 .d_delete = sockfs_delete_dentry,
c23fbb6b 334 .d_dname = sockfs_dname,
1da177e4
LT
335};
336
337/*
338 * Obtains the first available file descriptor and sets it up for use.
339 *
39d8c1b6
DM
340 * These functions create file structures and maps them to fd space
341 * of the current process. On success it returns file descriptor
1da177e4
LT
342 * and file struct implicitly stored in sock->file.
343 * Note that another thread may close file descriptor before we return
344 * from this function. We use the fact that now we do not refer
345 * to socket after mapping. If one day we will need it, this
346 * function will increment ref. count on file by 1.
347 *
348 * In any case returned fd MAY BE not valid!
349 * This race condition is unavoidable
350 * with shared fd spaces, we cannot solve it inside kernel,
351 * but we take care of internal coherence yet.
352 */
353
a677a039 354static int sock_alloc_fd(struct file **filep, int flags)
1da177e4
LT
355{
356 int fd;
1da177e4 357
a677a039 358 fd = get_unused_fd_flags(flags);
39d8c1b6 359 if (likely(fd >= 0)) {
1da177e4
LT
360 struct file *file = get_empty_filp();
361
39d8c1b6
DM
362 *filep = file;
363 if (unlikely(!file)) {
1da177e4 364 put_unused_fd(fd);
39d8c1b6 365 return -ENFILE;
1da177e4 366 }
39d8c1b6
DM
367 } else
368 *filep = NULL;
369 return fd;
370}
1da177e4 371
77d27200 372static int sock_attach_fd(struct socket *sock, struct file *file, int flags)
39d8c1b6 373{
ce8d2cdf 374 struct dentry *dentry;
c23fbb6b 375 struct qstr name = { .name = "" };
39d8c1b6 376
ce8d2cdf
DH
377 dentry = d_alloc(sock_mnt->mnt_sb->s_root, &name);
378 if (unlikely(!dentry))
39d8c1b6
DM
379 return -ENOMEM;
380
ce8d2cdf 381 dentry->d_op = &sockfs_dentry_operations;
304e61e6
ED
382 /*
383 * We dont want to push this dentry into global dentry hash table.
384 * We pretend dentry is already hashed, by unsetting DCACHE_UNHASHED
385 * This permits a working /proc/$pid/fd/XXX on sockets
386 */
ce8d2cdf
DH
387 dentry->d_flags &= ~DCACHE_UNHASHED;
388 d_instantiate(dentry, SOCK_INODE(sock));
39d8c1b6
DM
389
390 sock->file = file;
ce8d2cdf
DH
391 init_file(file, sock_mnt, dentry, FMODE_READ | FMODE_WRITE,
392 &socket_file_ops);
393 SOCK_INODE(sock)->i_fop = &socket_file_ops;
77d27200 394 file->f_flags = O_RDWR | (flags & O_NONBLOCK);
39d8c1b6
DM
395 file->f_pos = 0;
396 file->private_data = sock;
1da177e4 397
39d8c1b6
DM
398 return 0;
399}
400
a677a039 401int sock_map_fd(struct socket *sock, int flags)
39d8c1b6
DM
402{
403 struct file *newfile;
a677a039 404 int fd = sock_alloc_fd(&newfile, flags);
39d8c1b6
DM
405
406 if (likely(fd >= 0)) {
77d27200 407 int err = sock_attach_fd(sock, newfile, flags);
39d8c1b6
DM
408
409 if (unlikely(err < 0)) {
410 put_filp(newfile);
1da177e4 411 put_unused_fd(fd);
39d8c1b6 412 return err;
1da177e4 413 }
39d8c1b6 414 fd_install(fd, newfile);
1da177e4 415 }
1da177e4
LT
416 return fd;
417}
418
6cb153ca
BL
419static struct socket *sock_from_file(struct file *file, int *err)
420{
6cb153ca
BL
421 if (file->f_op == &socket_file_ops)
422 return file->private_data; /* set in sock_map_fd */
423
23bb80d2
ED
424 *err = -ENOTSOCK;
425 return NULL;
6cb153ca
BL
426}
427
1da177e4
LT
428/**
429 * sockfd_lookup - Go from a file number to its socket slot
430 * @fd: file handle
431 * @err: pointer to an error code return
432 *
433 * The file handle passed in is locked and the socket it is bound
434 * too is returned. If an error occurs the err pointer is overwritten
435 * with a negative errno code and NULL is returned. The function checks
436 * for both invalid handles and passing a handle which is not a socket.
437 *
438 * On a success the socket object pointer is returned.
439 */
440
441struct socket *sockfd_lookup(int fd, int *err)
442{
443 struct file *file;
1da177e4
LT
444 struct socket *sock;
445
89bddce5
SH
446 file = fget(fd);
447 if (!file) {
1da177e4
LT
448 *err = -EBADF;
449 return NULL;
450 }
89bddce5 451
6cb153ca
BL
452 sock = sock_from_file(file, err);
453 if (!sock)
1da177e4 454 fput(file);
6cb153ca
BL
455 return sock;
456}
1da177e4 457
6cb153ca
BL
458static struct socket *sockfd_lookup_light(int fd, int *err, int *fput_needed)
459{
460 struct file *file;
461 struct socket *sock;
462
3672558c 463 *err = -EBADF;
6cb153ca
BL
464 file = fget_light(fd, fput_needed);
465 if (file) {
466 sock = sock_from_file(file, err);
467 if (sock)
468 return sock;
469 fput_light(file, *fput_needed);
1da177e4 470 }
6cb153ca 471 return NULL;
1da177e4
LT
472}
473
474/**
475 * sock_alloc - allocate a socket
89bddce5 476 *
1da177e4
LT
477 * Allocate a new inode and socket object. The two are bound together
478 * and initialised. The socket is then returned. If we are out of inodes
479 * NULL is returned.
480 */
481
482static struct socket *sock_alloc(void)
483{
89bddce5
SH
484 struct inode *inode;
485 struct socket *sock;
1da177e4
LT
486
487 inode = new_inode(sock_mnt->mnt_sb);
488 if (!inode)
489 return NULL;
490
491 sock = SOCKET_I(inode);
492
89bddce5 493 inode->i_mode = S_IFSOCK | S_IRWXUGO;
1da177e4
LT
494 inode->i_uid = current->fsuid;
495 inode->i_gid = current->fsgid;
496
497 get_cpu_var(sockets_in_use)++;
498 put_cpu_var(sockets_in_use);
499 return sock;
500}
501
502/*
503 * In theory you can't get an open on this inode, but /proc provides
504 * a back door. Remember to keep it shut otherwise you'll let the
505 * creepy crawlies in.
506 */
89bddce5 507
1da177e4
LT
508static int sock_no_open(struct inode *irrelevant, struct file *dontcare)
509{
510 return -ENXIO;
511}
512
4b6f5d20 513const struct file_operations bad_sock_fops = {
1da177e4
LT
514 .owner = THIS_MODULE,
515 .open = sock_no_open,
516};
517
518/**
519 * sock_release - close a socket
520 * @sock: socket to close
521 *
522 * The socket is released from the protocol stack if it has a release
523 * callback, and the inode is then released if the socket is bound to
89bddce5 524 * an inode not a file.
1da177e4 525 */
89bddce5 526
1da177e4
LT
527void sock_release(struct socket *sock)
528{
529 if (sock->ops) {
530 struct module *owner = sock->ops->owner;
531
532 sock->ops->release(sock);
533 sock->ops = NULL;
534 module_put(owner);
535 }
536
537 if (sock->fasync_list)
538 printk(KERN_ERR "sock_release: fasync list not empty!\n");
539
540 get_cpu_var(sockets_in_use)--;
541 put_cpu_var(sockets_in_use);
542 if (!sock->file) {
543 iput(SOCK_INODE(sock));
544 return;
545 }
89bddce5 546 sock->file = NULL;
1da177e4
LT
547}
548
89bddce5 549static inline int __sock_sendmsg(struct kiocb *iocb, struct socket *sock,
1da177e4
LT
550 struct msghdr *msg, size_t size)
551{
552 struct sock_iocb *si = kiocb_to_siocb(iocb);
553 int err;
554
555 si->sock = sock;
556 si->scm = NULL;
557 si->msg = msg;
558 si->size = size;
559
560 err = security_socket_sendmsg(sock, msg, size);
561 if (err)
562 return err;
563
564 return sock->ops->sendmsg(iocb, sock, msg, size);
565}
566
567int sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
568{
569 struct kiocb iocb;
570 struct sock_iocb siocb;
571 int ret;
572
573 init_sync_kiocb(&iocb, NULL);
574 iocb.private = &siocb;
575 ret = __sock_sendmsg(&iocb, sock, msg, size);
576 if (-EIOCBQUEUED == ret)
577 ret = wait_on_sync_kiocb(&iocb);
578 return ret;
579}
580
581int kernel_sendmsg(struct socket *sock, struct msghdr *msg,
582 struct kvec *vec, size_t num, size_t size)
583{
584 mm_segment_t oldfs = get_fs();
585 int result;
586
587 set_fs(KERNEL_DS);
588 /*
589 * the following is safe, since for compiler definitions of kvec and
590 * iovec are identical, yielding the same in-core layout and alignment
591 */
89bddce5 592 msg->msg_iov = (struct iovec *)vec;
1da177e4
LT
593 msg->msg_iovlen = num;
594 result = sock_sendmsg(sock, msg, size);
595 set_fs(oldfs);
596 return result;
597}
598
92f37fd2
ED
599/*
600 * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
601 */
602void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
603 struct sk_buff *skb)
604{
605 ktime_t kt = skb->tstamp;
606
607 if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
608 struct timeval tv;
609 /* Race occurred between timestamp enabling and packet
610 receiving. Fill in the current time for now. */
611 if (kt.tv64 == 0)
612 kt = ktime_get_real();
613 skb->tstamp = kt;
614 tv = ktime_to_timeval(kt);
615 put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP, sizeof(tv), &tv);
616 } else {
617 struct timespec ts;
618 /* Race occurred between timestamp enabling and packet
619 receiving. Fill in the current time for now. */
620 if (kt.tv64 == 0)
621 kt = ktime_get_real();
622 skb->tstamp = kt;
623 ts = ktime_to_timespec(kt);
624 put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS, sizeof(ts), &ts);
625 }
626}
627
7c81fd8b
ACM
628EXPORT_SYMBOL_GPL(__sock_recv_timestamp);
629
89bddce5 630static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock,
1da177e4
LT
631 struct msghdr *msg, size_t size, int flags)
632{
633 int err;
634 struct sock_iocb *si = kiocb_to_siocb(iocb);
635
636 si->sock = sock;
637 si->scm = NULL;
638 si->msg = msg;
639 si->size = size;
640 si->flags = flags;
641
642 err = security_socket_recvmsg(sock, msg, size, flags);
643 if (err)
644 return err;
645
646 return sock->ops->recvmsg(iocb, sock, msg, size, flags);
647}
648
89bddce5 649int sock_recvmsg(struct socket *sock, struct msghdr *msg,
1da177e4
LT
650 size_t size, int flags)
651{
652 struct kiocb iocb;
653 struct sock_iocb siocb;
654 int ret;
655
89bddce5 656 init_sync_kiocb(&iocb, NULL);
1da177e4
LT
657 iocb.private = &siocb;
658 ret = __sock_recvmsg(&iocb, sock, msg, size, flags);
659 if (-EIOCBQUEUED == ret)
660 ret = wait_on_sync_kiocb(&iocb);
661 return ret;
662}
663
89bddce5
SH
664int kernel_recvmsg(struct socket *sock, struct msghdr *msg,
665 struct kvec *vec, size_t num, size_t size, int flags)
1da177e4
LT
666{
667 mm_segment_t oldfs = get_fs();
668 int result;
669
670 set_fs(KERNEL_DS);
671 /*
672 * the following is safe, since for compiler definitions of kvec and
673 * iovec are identical, yielding the same in-core layout and alignment
674 */
89bddce5 675 msg->msg_iov = (struct iovec *)vec, msg->msg_iovlen = num;
1da177e4
LT
676 result = sock_recvmsg(sock, msg, size, flags);
677 set_fs(oldfs);
678 return result;
679}
680
681static void sock_aio_dtor(struct kiocb *iocb)
682{
683 kfree(iocb->private);
684}
685
ce1d4d3e
CH
686static ssize_t sock_sendpage(struct file *file, struct page *page,
687 int offset, size_t size, loff_t *ppos, int more)
1da177e4 688{
1da177e4
LT
689 struct socket *sock;
690 int flags;
691
ce1d4d3e
CH
692 sock = file->private_data;
693
694 flags = !(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT;
695 if (more)
696 flags |= MSG_MORE;
697
698 return sock->ops->sendpage(sock, page, offset, size, flags);
699}
1da177e4 700
9c55e01c
JA
701static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
702 struct pipe_inode_info *pipe, size_t len,
703 unsigned int flags)
704{
705 struct socket *sock = file->private_data;
706
997b37da
RDC
707 if (unlikely(!sock->ops->splice_read))
708 return -EINVAL;
709
9c55e01c
JA
710 return sock->ops->splice_read(sock, ppos, pipe, len, flags);
711}
712
ce1d4d3e 713static struct sock_iocb *alloc_sock_iocb(struct kiocb *iocb,
89bddce5 714 struct sock_iocb *siocb)
ce1d4d3e
CH
715{
716 if (!is_sync_kiocb(iocb)) {
717 siocb = kmalloc(sizeof(*siocb), GFP_KERNEL);
718 if (!siocb)
719 return NULL;
1da177e4
LT
720 iocb->ki_dtor = sock_aio_dtor;
721 }
1da177e4 722
ce1d4d3e 723 siocb->kiocb = iocb;
ce1d4d3e
CH
724 iocb->private = siocb;
725 return siocb;
1da177e4
LT
726}
727
ce1d4d3e 728static ssize_t do_sock_read(struct msghdr *msg, struct kiocb *iocb,
027445c3
BP
729 struct file *file, const struct iovec *iov,
730 unsigned long nr_segs)
ce1d4d3e
CH
731{
732 struct socket *sock = file->private_data;
733 size_t size = 0;
734 int i;
1da177e4 735
89bddce5
SH
736 for (i = 0; i < nr_segs; i++)
737 size += iov[i].iov_len;
1da177e4 738
ce1d4d3e
CH
739 msg->msg_name = NULL;
740 msg->msg_namelen = 0;
741 msg->msg_control = NULL;
742 msg->msg_controllen = 0;
89bddce5 743 msg->msg_iov = (struct iovec *)iov;
ce1d4d3e
CH
744 msg->msg_iovlen = nr_segs;
745 msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
746
747 return __sock_recvmsg(iocb, sock, msg, size, msg->msg_flags);
748}
749
027445c3
BP
750static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov,
751 unsigned long nr_segs, loff_t pos)
ce1d4d3e
CH
752{
753 struct sock_iocb siocb, *x;
754
1da177e4
LT
755 if (pos != 0)
756 return -ESPIPE;
027445c3
BP
757
758 if (iocb->ki_left == 0) /* Match SYS5 behaviour */
1da177e4
LT
759 return 0;
760
027445c3
BP
761
762 x = alloc_sock_iocb(iocb, &siocb);
ce1d4d3e
CH
763 if (!x)
764 return -ENOMEM;
027445c3 765 return do_sock_read(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs);
1da177e4
LT
766}
767
ce1d4d3e 768static ssize_t do_sock_write(struct msghdr *msg, struct kiocb *iocb,
027445c3
BP
769 struct file *file, const struct iovec *iov,
770 unsigned long nr_segs)
1da177e4 771{
ce1d4d3e
CH
772 struct socket *sock = file->private_data;
773 size_t size = 0;
774 int i;
1da177e4 775
89bddce5
SH
776 for (i = 0; i < nr_segs; i++)
777 size += iov[i].iov_len;
1da177e4 778
ce1d4d3e
CH
779 msg->msg_name = NULL;
780 msg->msg_namelen = 0;
781 msg->msg_control = NULL;
782 msg->msg_controllen = 0;
89bddce5 783 msg->msg_iov = (struct iovec *)iov;
ce1d4d3e
CH
784 msg->msg_iovlen = nr_segs;
785 msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
786 if (sock->type == SOCK_SEQPACKET)
787 msg->msg_flags |= MSG_EOR;
1da177e4 788
ce1d4d3e 789 return __sock_sendmsg(iocb, sock, msg, size);
1da177e4
LT
790}
791
027445c3
BP
792static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov,
793 unsigned long nr_segs, loff_t pos)
ce1d4d3e
CH
794{
795 struct sock_iocb siocb, *x;
1da177e4 796
ce1d4d3e
CH
797 if (pos != 0)
798 return -ESPIPE;
027445c3 799
027445c3 800 x = alloc_sock_iocb(iocb, &siocb);
ce1d4d3e
CH
801 if (!x)
802 return -ENOMEM;
1da177e4 803
027445c3 804 return do_sock_write(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs);
1da177e4
LT
805}
806
1da177e4
LT
807/*
808 * Atomic setting of ioctl hooks to avoid race
809 * with module unload.
810 */
811
4a3e2f71 812static DEFINE_MUTEX(br_ioctl_mutex);
881d966b 813static int (*br_ioctl_hook) (struct net *, unsigned int cmd, void __user *arg) = NULL;
1da177e4 814
881d966b 815void brioctl_set(int (*hook) (struct net *, unsigned int, void __user *))
1da177e4 816{
4a3e2f71 817 mutex_lock(&br_ioctl_mutex);
1da177e4 818 br_ioctl_hook = hook;
4a3e2f71 819 mutex_unlock(&br_ioctl_mutex);
1da177e4 820}
89bddce5 821
1da177e4
LT
822EXPORT_SYMBOL(brioctl_set);
823
4a3e2f71 824static DEFINE_MUTEX(vlan_ioctl_mutex);
881d966b 825static int (*vlan_ioctl_hook) (struct net *, void __user *arg);
1da177e4 826
881d966b 827void vlan_ioctl_set(int (*hook) (struct net *, void __user *))
1da177e4 828{
4a3e2f71 829 mutex_lock(&vlan_ioctl_mutex);
1da177e4 830 vlan_ioctl_hook = hook;
4a3e2f71 831 mutex_unlock(&vlan_ioctl_mutex);
1da177e4 832}
89bddce5 833
1da177e4
LT
834EXPORT_SYMBOL(vlan_ioctl_set);
835
4a3e2f71 836static DEFINE_MUTEX(dlci_ioctl_mutex);
89bddce5 837static int (*dlci_ioctl_hook) (unsigned int, void __user *);
1da177e4 838
89bddce5 839void dlci_ioctl_set(int (*hook) (unsigned int, void __user *))
1da177e4 840{
4a3e2f71 841 mutex_lock(&dlci_ioctl_mutex);
1da177e4 842 dlci_ioctl_hook = hook;
4a3e2f71 843 mutex_unlock(&dlci_ioctl_mutex);
1da177e4 844}
89bddce5 845
1da177e4
LT
846EXPORT_SYMBOL(dlci_ioctl_set);
847
848/*
849 * With an ioctl, arg may well be a user mode pointer, but we don't know
850 * what to do with it - that's up to the protocol still.
851 */
852
853static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
854{
855 struct socket *sock;
881d966b 856 struct sock *sk;
1da177e4
LT
857 void __user *argp = (void __user *)arg;
858 int pid, err;
881d966b 859 struct net *net;
1da177e4 860
b69aee04 861 sock = file->private_data;
881d966b 862 sk = sock->sk;
3b1e0a65 863 net = sock_net(sk);
1da177e4 864 if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) {
881d966b 865 err = dev_ioctl(net, cmd, argp);
1da177e4 866 } else
d86b5e0e 867#ifdef CONFIG_WIRELESS_EXT
1da177e4 868 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {
881d966b 869 err = dev_ioctl(net, cmd, argp);
1da177e4 870 } else
89bddce5
SH
871#endif /* CONFIG_WIRELESS_EXT */
872 switch (cmd) {
1da177e4
LT
873 case FIOSETOWN:
874 case SIOCSPGRP:
875 err = -EFAULT;
876 if (get_user(pid, (int __user *)argp))
877 break;
878 err = f_setown(sock->file, pid, 1);
879 break;
880 case FIOGETOWN:
881 case SIOCGPGRP:
609d7fa9 882 err = put_user(f_getown(sock->file),
89bddce5 883 (int __user *)argp);
1da177e4
LT
884 break;
885 case SIOCGIFBR:
886 case SIOCSIFBR:
887 case SIOCBRADDBR:
888 case SIOCBRDELBR:
889 err = -ENOPKG;
890 if (!br_ioctl_hook)
891 request_module("bridge");
892
4a3e2f71 893 mutex_lock(&br_ioctl_mutex);
89bddce5 894 if (br_ioctl_hook)
881d966b 895 err = br_ioctl_hook(net, cmd, argp);
4a3e2f71 896 mutex_unlock(&br_ioctl_mutex);
1da177e4
LT
897 break;
898 case SIOCGIFVLAN:
899 case SIOCSIFVLAN:
900 err = -ENOPKG;
901 if (!vlan_ioctl_hook)
902 request_module("8021q");
903
4a3e2f71 904 mutex_lock(&vlan_ioctl_mutex);
1da177e4 905 if (vlan_ioctl_hook)
881d966b 906 err = vlan_ioctl_hook(net, argp);
4a3e2f71 907 mutex_unlock(&vlan_ioctl_mutex);
1da177e4 908 break;
1da177e4
LT
909 case SIOCADDDLCI:
910 case SIOCDELDLCI:
911 err = -ENOPKG;
912 if (!dlci_ioctl_hook)
913 request_module("dlci");
914
7512cbf6
PE
915 mutex_lock(&dlci_ioctl_mutex);
916 if (dlci_ioctl_hook)
1da177e4 917 err = dlci_ioctl_hook(cmd, argp);
7512cbf6 918 mutex_unlock(&dlci_ioctl_mutex);
1da177e4
LT
919 break;
920 default:
921 err = sock->ops->ioctl(sock, cmd, arg);
b5e5fa5e
CH
922
923 /*
924 * If this ioctl is unknown try to hand it down
925 * to the NIC driver.
926 */
927 if (err == -ENOIOCTLCMD)
881d966b 928 err = dev_ioctl(net, cmd, argp);
1da177e4 929 break;
89bddce5 930 }
1da177e4
LT
931 return err;
932}
933
934int sock_create_lite(int family, int type, int protocol, struct socket **res)
935{
936 int err;
937 struct socket *sock = NULL;
89bddce5 938
1da177e4
LT
939 err = security_socket_create(family, type, protocol, 1);
940 if (err)
941 goto out;
942
943 sock = sock_alloc();
944 if (!sock) {
945 err = -ENOMEM;
946 goto out;
947 }
948
1da177e4 949 sock->type = type;
7420ed23
VY
950 err = security_socket_post_create(sock, family, type, protocol, 1);
951 if (err)
952 goto out_release;
953
1da177e4
LT
954out:
955 *res = sock;
956 return err;
7420ed23
VY
957out_release:
958 sock_release(sock);
959 sock = NULL;
960 goto out;
1da177e4
LT
961}
962
963/* No kernel lock held - perfect */
89bddce5 964static unsigned int sock_poll(struct file *file, poll_table *wait)
1da177e4
LT
965{
966 struct socket *sock;
967
968 /*
89bddce5 969 * We can't return errors to poll, so it's either yes or no.
1da177e4 970 */
b69aee04 971 sock = file->private_data;
1da177e4
LT
972 return sock->ops->poll(file, sock, wait);
973}
974
89bddce5 975static int sock_mmap(struct file *file, struct vm_area_struct *vma)
1da177e4 976{
b69aee04 977 struct socket *sock = file->private_data;
1da177e4
LT
978
979 return sock->ops->mmap(file, sock, vma);
980}
981
20380731 982static int sock_close(struct inode *inode, struct file *filp)
1da177e4
LT
983{
984 /*
89bddce5
SH
985 * It was possible the inode is NULL we were
986 * closing an unfinished socket.
1da177e4
LT
987 */
988
89bddce5 989 if (!inode) {
1da177e4
LT
990 printk(KERN_DEBUG "sock_close: NULL inode\n");
991 return 0;
992 }
993 sock_fasync(-1, filp, 0);
994 sock_release(SOCKET_I(inode));
995 return 0;
996}
997
998/*
999 * Update the socket async list
1000 *
1001 * Fasync_list locking strategy.
1002 *
1003 * 1. fasync_list is modified only under process context socket lock
1004 * i.e. under semaphore.
1005 * 2. fasync_list is used under read_lock(&sk->sk_callback_lock)
1006 * or under socket lock.
1007 * 3. fasync_list can be used from softirq context, so that
1008 * modification under socket lock have to be enhanced with
1009 * write_lock_bh(&sk->sk_callback_lock).
1010 * --ANK (990710)
1011 */
1012
1013static int sock_fasync(int fd, struct file *filp, int on)
1014{
89bddce5 1015 struct fasync_struct *fa, *fna = NULL, **prev;
1da177e4
LT
1016 struct socket *sock;
1017 struct sock *sk;
1018
89bddce5 1019 if (on) {
8b3a7005 1020 fna = kmalloc(sizeof(struct fasync_struct), GFP_KERNEL);
89bddce5 1021 if (fna == NULL)
1da177e4
LT
1022 return -ENOMEM;
1023 }
1024
b69aee04 1025 sock = filp->private_data;
1da177e4 1026
89bddce5
SH
1027 sk = sock->sk;
1028 if (sk == NULL) {
1da177e4
LT
1029 kfree(fna);
1030 return -EINVAL;
1031 }
1032
1033 lock_sock(sk);
1034
89bddce5 1035 prev = &(sock->fasync_list);
1da177e4 1036
89bddce5
SH
1037 for (fa = *prev; fa != NULL; prev = &fa->fa_next, fa = *prev)
1038 if (fa->fa_file == filp)
1da177e4
LT
1039 break;
1040
89bddce5
SH
1041 if (on) {
1042 if (fa != NULL) {
1da177e4 1043 write_lock_bh(&sk->sk_callback_lock);
89bddce5 1044 fa->fa_fd = fd;
1da177e4
LT
1045 write_unlock_bh(&sk->sk_callback_lock);
1046
1047 kfree(fna);
1048 goto out;
1049 }
89bddce5
SH
1050 fna->fa_file = filp;
1051 fna->fa_fd = fd;
1052 fna->magic = FASYNC_MAGIC;
1053 fna->fa_next = sock->fasync_list;
1da177e4 1054 write_lock_bh(&sk->sk_callback_lock);
89bddce5 1055 sock->fasync_list = fna;
1da177e4 1056 write_unlock_bh(&sk->sk_callback_lock);
89bddce5
SH
1057 } else {
1058 if (fa != NULL) {
1da177e4 1059 write_lock_bh(&sk->sk_callback_lock);
89bddce5 1060 *prev = fa->fa_next;
1da177e4
LT
1061 write_unlock_bh(&sk->sk_callback_lock);
1062 kfree(fa);
1063 }
1064 }
1065
1066out:
1067 release_sock(sock->sk);
1068 return 0;
1069}
1070
1071/* This function may be called only under socket lock or callback_lock */
1072
1073int sock_wake_async(struct socket *sock, int how, int band)
1074{
1075 if (!sock || !sock->fasync_list)
1076 return -1;
89bddce5 1077 switch (how) {
8d8ad9d7 1078 case SOCK_WAKE_WAITD:
1da177e4
LT
1079 if (test_bit(SOCK_ASYNC_WAITDATA, &sock->flags))
1080 break;
1081 goto call_kill;
8d8ad9d7 1082 case SOCK_WAKE_SPACE:
1da177e4
LT
1083 if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags))
1084 break;
1085 /* fall through */
8d8ad9d7 1086 case SOCK_WAKE_IO:
89bddce5 1087call_kill:
1da177e4
LT
1088 __kill_fasync(sock->fasync_list, SIGIO, band);
1089 break;
8d8ad9d7 1090 case SOCK_WAKE_URG:
1da177e4
LT
1091 __kill_fasync(sock->fasync_list, SIGURG, band);
1092 }
1093 return 0;
1094}
1095
1b8d7ae4 1096static int __sock_create(struct net *net, int family, int type, int protocol,
89bddce5 1097 struct socket **res, int kern)
1da177e4
LT
1098{
1099 int err;
1100 struct socket *sock;
55737fda 1101 const struct net_proto_family *pf;
1da177e4
LT
1102
1103 /*
89bddce5 1104 * Check protocol is in range
1da177e4
LT
1105 */
1106 if (family < 0 || family >= NPROTO)
1107 return -EAFNOSUPPORT;
1108 if (type < 0 || type >= SOCK_MAX)
1109 return -EINVAL;
1110
1111 /* Compatibility.
1112
1113 This uglymoron is moved from INET layer to here to avoid
1114 deadlock in module load.
1115 */
1116 if (family == PF_INET && type == SOCK_PACKET) {
89bddce5 1117 static int warned;
1da177e4
LT
1118 if (!warned) {
1119 warned = 1;
89bddce5
SH
1120 printk(KERN_INFO "%s uses obsolete (PF_INET,SOCK_PACKET)\n",
1121 current->comm);
1da177e4
LT
1122 }
1123 family = PF_PACKET;
1124 }
1125
1126 err = security_socket_create(family, type, protocol, kern);
1127 if (err)
1128 return err;
89bddce5 1129
55737fda
SH
1130 /*
1131 * Allocate the socket and allow the family to set things up. if
1132 * the protocol is 0, the family is instructed to select an appropriate
1133 * default.
1134 */
1135 sock = sock_alloc();
1136 if (!sock) {
1137 if (net_ratelimit())
1138 printk(KERN_WARNING "socket: no more sockets\n");
1139 return -ENFILE; /* Not exactly a match, but its the
1140 closest posix thing */
1141 }
1142
1143 sock->type = type;
1144
1da177e4 1145#if defined(CONFIG_KMOD)
89bddce5
SH
1146 /* Attempt to load a protocol module if the find failed.
1147 *
1148 * 12/09/1996 Marcin: But! this makes REALLY only sense, if the user
1da177e4
LT
1149 * requested real, full-featured networking support upon configuration.
1150 * Otherwise module support will break!
1151 */
55737fda 1152 if (net_families[family] == NULL)
89bddce5 1153 request_module("net-pf-%d", family);
1da177e4
LT
1154#endif
1155
55737fda
SH
1156 rcu_read_lock();
1157 pf = rcu_dereference(net_families[family]);
1158 err = -EAFNOSUPPORT;
1159 if (!pf)
1160 goto out_release;
1da177e4
LT
1161
1162 /*
1163 * We will call the ->create function, that possibly is in a loadable
1164 * module, so we have to bump that loadable module refcnt first.
1165 */
55737fda 1166 if (!try_module_get(pf->owner))
1da177e4
LT
1167 goto out_release;
1168
55737fda
SH
1169 /* Now protected by module ref count */
1170 rcu_read_unlock();
1171
1b8d7ae4 1172 err = pf->create(net, sock, protocol);
55737fda 1173 if (err < 0)
1da177e4 1174 goto out_module_put;
a79af59e 1175
1da177e4
LT
1176 /*
1177 * Now to bump the refcnt of the [loadable] module that owns this
1178 * socket at sock_release time we decrement its refcnt.
1179 */
55737fda
SH
1180 if (!try_module_get(sock->ops->owner))
1181 goto out_module_busy;
1182
1da177e4
LT
1183 /*
1184 * Now that we're done with the ->create function, the [loadable]
1185 * module can have its refcnt decremented
1186 */
55737fda 1187 module_put(pf->owner);
7420ed23
VY
1188 err = security_socket_post_create(sock, family, type, protocol, kern);
1189 if (err)
3b185525 1190 goto out_sock_release;
55737fda 1191 *res = sock;
1da177e4 1192
55737fda
SH
1193 return 0;
1194
1195out_module_busy:
1196 err = -EAFNOSUPPORT;
1da177e4 1197out_module_put:
55737fda
SH
1198 sock->ops = NULL;
1199 module_put(pf->owner);
1200out_sock_release:
1da177e4 1201 sock_release(sock);
55737fda
SH
1202 return err;
1203
1204out_release:
1205 rcu_read_unlock();
1206 goto out_sock_release;
1da177e4
LT
1207}
1208
1209int sock_create(int family, int type, int protocol, struct socket **res)
1210{
1b8d7ae4 1211 return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);
1da177e4
LT
1212}
1213
1214int sock_create_kern(int family, int type, int protocol, struct socket **res)
1215{
1b8d7ae4 1216 return __sock_create(&init_net, family, type, protocol, res, 1);
1da177e4
LT
1217}
1218
1219asmlinkage long sys_socket(int family, int type, int protocol)
1220{
1221 int retval;
1222 struct socket *sock;
a677a039
UD
1223 int flags;
1224
e38b36f3
UD
1225 /* Check the SOCK_* constants for consistency. */
1226 BUILD_BUG_ON(SOCK_CLOEXEC != O_CLOEXEC);
1227 BUILD_BUG_ON((SOCK_MAX | SOCK_TYPE_MASK) != SOCK_TYPE_MASK);
1228 BUILD_BUG_ON(SOCK_CLOEXEC & SOCK_TYPE_MASK);
1229 BUILD_BUG_ON(SOCK_NONBLOCK & SOCK_TYPE_MASK);
1230
a677a039 1231 flags = type & ~SOCK_TYPE_MASK;
77d27200 1232 if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
a677a039
UD
1233 return -EINVAL;
1234 type &= SOCK_TYPE_MASK;
1da177e4 1235
aaca0bdc
UD
1236 if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1237 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1238
1da177e4
LT
1239 retval = sock_create(family, type, protocol, &sock);
1240 if (retval < 0)
1241 goto out;
1242
77d27200 1243 retval = sock_map_fd(sock, flags & (O_CLOEXEC | O_NONBLOCK));
1da177e4
LT
1244 if (retval < 0)
1245 goto out_release;
1246
1247out:
1248 /* It may be already another descriptor 8) Not kernel problem. */
1249 return retval;
1250
1251out_release:
1252 sock_release(sock);
1253 return retval;
1254}
1255
1256/*
1257 * Create a pair of connected sockets.
1258 */
1259
89bddce5
SH
1260asmlinkage long sys_socketpair(int family, int type, int protocol,
1261 int __user *usockvec)
1da177e4
LT
1262{
1263 struct socket *sock1, *sock2;
1264 int fd1, fd2, err;
db349509 1265 struct file *newfile1, *newfile2;
a677a039
UD
1266 int flags;
1267
1268 flags = type & ~SOCK_TYPE_MASK;
77d27200 1269 if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
a677a039
UD
1270 return -EINVAL;
1271 type &= SOCK_TYPE_MASK;
1da177e4 1272
aaca0bdc
UD
1273 if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1274 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1275
1da177e4
LT
1276 /*
1277 * Obtain the first socket and check if the underlying protocol
1278 * supports the socketpair call.
1279 */
1280
1281 err = sock_create(family, type, protocol, &sock1);
1282 if (err < 0)
1283 goto out;
1284
1285 err = sock_create(family, type, protocol, &sock2);
1286 if (err < 0)
1287 goto out_release_1;
1288
1289 err = sock1->ops->socketpair(sock1, sock2);
89bddce5 1290 if (err < 0)
1da177e4
LT
1291 goto out_release_both;
1292
a677a039 1293 fd1 = sock_alloc_fd(&newfile1, flags & O_CLOEXEC);
bf3c23d1
DM
1294 if (unlikely(fd1 < 0)) {
1295 err = fd1;
db349509 1296 goto out_release_both;
bf3c23d1 1297 }
1da177e4 1298
a677a039 1299 fd2 = sock_alloc_fd(&newfile2, flags & O_CLOEXEC);
db349509 1300 if (unlikely(fd2 < 0)) {
bf3c23d1 1301 err = fd2;
db349509
AV
1302 put_filp(newfile1);
1303 put_unused_fd(fd1);
1da177e4 1304 goto out_release_both;
db349509 1305 }
1da177e4 1306
77d27200 1307 err = sock_attach_fd(sock1, newfile1, flags & O_NONBLOCK);
db349509
AV
1308 if (unlikely(err < 0)) {
1309 goto out_fd2;
1310 }
1311
77d27200 1312 err = sock_attach_fd(sock2, newfile2, flags & O_NONBLOCK);
db349509
AV
1313 if (unlikely(err < 0)) {
1314 fput(newfile1);
1315 goto out_fd1;
1316 }
1317
1318 err = audit_fd_pair(fd1, fd2);
1319 if (err < 0) {
1320 fput(newfile1);
1321 fput(newfile2);
1322 goto out_fd;
1323 }
1da177e4 1324
db349509
AV
1325 fd_install(fd1, newfile1);
1326 fd_install(fd2, newfile2);
1da177e4
LT
1327 /* fd1 and fd2 may be already another descriptors.
1328 * Not kernel problem.
1329 */
1330
89bddce5 1331 err = put_user(fd1, &usockvec[0]);
1da177e4
LT
1332 if (!err)
1333 err = put_user(fd2, &usockvec[1]);
1334 if (!err)
1335 return 0;
1336
1337 sys_close(fd2);
1338 sys_close(fd1);
1339 return err;
1340
1da177e4 1341out_release_both:
89bddce5 1342 sock_release(sock2);
1da177e4 1343out_release_1:
89bddce5 1344 sock_release(sock1);
1da177e4
LT
1345out:
1346 return err;
db349509
AV
1347
1348out_fd2:
1349 put_filp(newfile1);
1350 sock_release(sock1);
1351out_fd1:
1352 put_filp(newfile2);
1353 sock_release(sock2);
1354out_fd:
1355 put_unused_fd(fd1);
1356 put_unused_fd(fd2);
1357 goto out;
1da177e4
LT
1358}
1359
1da177e4
LT
1360/*
1361 * Bind a name to a socket. Nothing much to do here since it's
1362 * the protocol's responsibility to handle the local address.
1363 *
1364 * We move the socket address to kernel space before we call
1365 * the protocol layer (having also checked the address is ok).
1366 */
1367
1368asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen)
1369{
1370 struct socket *sock;
230b1839 1371 struct sockaddr_storage address;
6cb153ca 1372 int err, fput_needed;
1da177e4 1373
89bddce5 1374 sock = sockfd_lookup_light(fd, &err, &fput_needed);
e71a4783 1375 if (sock) {
230b1839 1376 err = move_addr_to_kernel(umyaddr, addrlen, (struct sockaddr *)&address);
89bddce5
SH
1377 if (err >= 0) {
1378 err = security_socket_bind(sock,
230b1839 1379 (struct sockaddr *)&address,
89bddce5 1380 addrlen);
6cb153ca
BL
1381 if (!err)
1382 err = sock->ops->bind(sock,
89bddce5 1383 (struct sockaddr *)
230b1839 1384 &address, addrlen);
1da177e4 1385 }
6cb153ca 1386 fput_light(sock->file, fput_needed);
89bddce5 1387 }
1da177e4
LT
1388 return err;
1389}
1390
1da177e4
LT
1391/*
1392 * Perform a listen. Basically, we allow the protocol to do anything
1393 * necessary for a listen, and if that works, we mark the socket as
1394 * ready for listening.
1395 */
1396
1da177e4
LT
1397asmlinkage long sys_listen(int fd, int backlog)
1398{
1399 struct socket *sock;
6cb153ca 1400 int err, fput_needed;
b8e1f9b5 1401 int somaxconn;
89bddce5
SH
1402
1403 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1404 if (sock) {
8efa6e93 1405 somaxconn = sock_net(sock->sk)->core.sysctl_somaxconn;
b8e1f9b5
PE
1406 if ((unsigned)backlog > somaxconn)
1407 backlog = somaxconn;
1da177e4
LT
1408
1409 err = security_socket_listen(sock, backlog);
6cb153ca
BL
1410 if (!err)
1411 err = sock->ops->listen(sock, backlog);
1da177e4 1412
6cb153ca 1413 fput_light(sock->file, fput_needed);
1da177e4
LT
1414 }
1415 return err;
1416}
1417
1da177e4
LT
1418/*
1419 * For accept, we attempt to create a new socket, set up the link
1420 * with the client, wake up the client, then return the new
1421 * connected fd. We collect the address of the connector in kernel
1422 * space and move it to user at the very end. This is unclean because
1423 * we open the socket then return an error.
1424 *
1425 * 1003.1g adds the ability to recvmsg() to query connection pending
1426 * status to recvmsg. We need to add that support in a way thats
1427 * clean when we restucture accept also.
1428 */
1429
aaca0bdc
UD
1430long do_accept(int fd, struct sockaddr __user *upeer_sockaddr,
1431 int __user *upeer_addrlen, int flags)
1da177e4
LT
1432{
1433 struct socket *sock, *newsock;
39d8c1b6 1434 struct file *newfile;
6cb153ca 1435 int err, len, newfd, fput_needed;
230b1839 1436 struct sockaddr_storage address;
1da177e4 1437
77d27200 1438 if (flags & ~(SOCK_CLOEXEC | SOCK_NONBLOCK))
aaca0bdc
UD
1439 return -EINVAL;
1440
1441 if (SOCK_NONBLOCK != O_NONBLOCK && (flags & SOCK_NONBLOCK))
1442 flags = (flags & ~SOCK_NONBLOCK) | O_NONBLOCK;
1443
6cb153ca 1444 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4
LT
1445 if (!sock)
1446 goto out;
1447
1448 err = -ENFILE;
89bddce5 1449 if (!(newsock = sock_alloc()))
1da177e4
LT
1450 goto out_put;
1451
1452 newsock->type = sock->type;
1453 newsock->ops = sock->ops;
1454
1da177e4
LT
1455 /*
1456 * We don't need try_module_get here, as the listening socket (sock)
1457 * has the protocol module (sock->ops->owner) held.
1458 */
1459 __module_get(newsock->ops->owner);
1460
aaca0bdc 1461 newfd = sock_alloc_fd(&newfile, flags & O_CLOEXEC);
39d8c1b6
DM
1462 if (unlikely(newfd < 0)) {
1463 err = newfd;
9a1875e6
DM
1464 sock_release(newsock);
1465 goto out_put;
39d8c1b6
DM
1466 }
1467
77d27200 1468 err = sock_attach_fd(newsock, newfile, flags & O_NONBLOCK);
39d8c1b6 1469 if (err < 0)
79f4f642 1470 goto out_fd_simple;
39d8c1b6 1471
a79af59e
FF
1472 err = security_socket_accept(sock, newsock);
1473 if (err)
39d8c1b6 1474 goto out_fd;
a79af59e 1475
1da177e4
LT
1476 err = sock->ops->accept(sock, newsock, sock->file->f_flags);
1477 if (err < 0)
39d8c1b6 1478 goto out_fd;
1da177e4
LT
1479
1480 if (upeer_sockaddr) {
230b1839 1481 if (newsock->ops->getname(newsock, (struct sockaddr *)&address,
89bddce5 1482 &len, 2) < 0) {
1da177e4 1483 err = -ECONNABORTED;
39d8c1b6 1484 goto out_fd;
1da177e4 1485 }
230b1839
YH
1486 err = move_addr_to_user((struct sockaddr *)&address,
1487 len, upeer_sockaddr, upeer_addrlen);
1da177e4 1488 if (err < 0)
39d8c1b6 1489 goto out_fd;
1da177e4
LT
1490 }
1491
1492 /* File flags are not inherited via accept() unlike another OSes. */
1493
39d8c1b6
DM
1494 fd_install(newfd, newfile);
1495 err = newfd;
1da177e4
LT
1496
1497 security_socket_post_accept(sock, newsock);
1498
1499out_put:
6cb153ca 1500 fput_light(sock->file, fput_needed);
1da177e4
LT
1501out:
1502 return err;
79f4f642
AD
1503out_fd_simple:
1504 sock_release(newsock);
1505 put_filp(newfile);
1506 put_unused_fd(newfd);
1507 goto out_put;
39d8c1b6 1508out_fd:
9606a216 1509 fput(newfile);
39d8c1b6 1510 put_unused_fd(newfd);
1da177e4
LT
1511 goto out_put;
1512}
1513
2d4c8266 1514#if 0
c019bbc6 1515#ifdef HAVE_SET_RESTORE_SIGMASK
aaca0bdc
UD
1516asmlinkage long sys_paccept(int fd, struct sockaddr __user *upeer_sockaddr,
1517 int __user *upeer_addrlen,
1518 const sigset_t __user *sigmask,
1519 size_t sigsetsize, int flags)
1520{
1521 sigset_t ksigmask, sigsaved;
1522 int ret;
1523
1524 if (sigmask) {
1525 /* XXX: Don't preclude handling different sized sigset_t's. */
1526 if (sigsetsize != sizeof(sigset_t))
1527 return -EINVAL;
1528 if (copy_from_user(&ksigmask, sigmask, sizeof(ksigmask)))
1529 return -EFAULT;
1530
1531 sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
1532 sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
1533 }
1534
1535 ret = do_accept(fd, upeer_sockaddr, upeer_addrlen, flags);
1536
1537 if (ret < 0 && signal_pending(current)) {
1538 /*
1539 * Don't restore the signal mask yet. Let do_signal() deliver
1540 * the signal on the way back to userspace, before the signal
1541 * mask is restored.
1542 */
1543 if (sigmask) {
1544 memcpy(&current->saved_sigmask, &sigsaved,
1545 sizeof(sigsaved));
1546 set_restore_sigmask();
1547 }
1548 } else if (sigmask)
1549 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
1550
1551 return ret;
1552}
c019bbc6
UD
1553#else
1554asmlinkage long sys_paccept(int fd, struct sockaddr __user *upeer_sockaddr,
1555 int __user *upeer_addrlen,
1556 const sigset_t __user *sigmask,
1557 size_t sigsetsize, int flags)
1558{
1559 /* The platform does not support restoring the signal mask in the
1560 * return path. So we do not allow using paccept() with a signal
1561 * mask. */
1562 if (sigmask)
1563 return -EINVAL;
1564
1565 return do_accept(fd, upeer_sockaddr, upeer_addrlen, flags);
1566}
1567#endif
2d4c8266 1568#endif
aaca0bdc
UD
1569
1570asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr,
1571 int __user *upeer_addrlen)
1572{
1573 return do_accept(fd, upeer_sockaddr, upeer_addrlen, 0);
1574}
1575
1da177e4
LT
1576/*
1577 * Attempt to connect to a socket with the server address. The address
1578 * is in user space so we verify it is OK and move it to kernel space.
1579 *
1580 * For 1003.1g we need to add clean support for a bind to AF_UNSPEC to
1581 * break bindings
1582 *
1583 * NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and
1584 * other SEQPACKET protocols that take time to connect() as it doesn't
1585 * include the -EINPROGRESS status for such sockets.
1586 */
1587
89bddce5
SH
1588asmlinkage long sys_connect(int fd, struct sockaddr __user *uservaddr,
1589 int addrlen)
1da177e4
LT
1590{
1591 struct socket *sock;
230b1839 1592 struct sockaddr_storage address;
6cb153ca 1593 int err, fput_needed;
1da177e4 1594
6cb153ca 1595 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4
LT
1596 if (!sock)
1597 goto out;
230b1839 1598 err = move_addr_to_kernel(uservaddr, addrlen, (struct sockaddr *)&address);
1da177e4
LT
1599 if (err < 0)
1600 goto out_put;
1601
89bddce5 1602 err =
230b1839 1603 security_socket_connect(sock, (struct sockaddr *)&address, addrlen);
1da177e4
LT
1604 if (err)
1605 goto out_put;
1606
230b1839 1607 err = sock->ops->connect(sock, (struct sockaddr *)&address, addrlen,
1da177e4
LT
1608 sock->file->f_flags);
1609out_put:
6cb153ca 1610 fput_light(sock->file, fput_needed);
1da177e4
LT
1611out:
1612 return err;
1613}
1614
1615/*
1616 * Get the local address ('name') of a socket object. Move the obtained
1617 * name to user space.
1618 */
1619
89bddce5
SH
1620asmlinkage long sys_getsockname(int fd, struct sockaddr __user *usockaddr,
1621 int __user *usockaddr_len)
1da177e4
LT
1622{
1623 struct socket *sock;
230b1839 1624 struct sockaddr_storage address;
6cb153ca 1625 int len, err, fput_needed;
89bddce5 1626
6cb153ca 1627 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4
LT
1628 if (!sock)
1629 goto out;
1630
1631 err = security_socket_getsockname(sock);
1632 if (err)
1633 goto out_put;
1634
230b1839 1635 err = sock->ops->getname(sock, (struct sockaddr *)&address, &len, 0);
1da177e4
LT
1636 if (err)
1637 goto out_put;
230b1839 1638 err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr, usockaddr_len);
1da177e4
LT
1639
1640out_put:
6cb153ca 1641 fput_light(sock->file, fput_needed);
1da177e4
LT
1642out:
1643 return err;
1644}
1645
1646/*
1647 * Get the remote address ('name') of a socket object. Move the obtained
1648 * name to user space.
1649 */
1650
89bddce5
SH
1651asmlinkage long sys_getpeername(int fd, struct sockaddr __user *usockaddr,
1652 int __user *usockaddr_len)
1da177e4
LT
1653{
1654 struct socket *sock;
230b1839 1655 struct sockaddr_storage address;
6cb153ca 1656 int len, err, fput_needed;
1da177e4 1657
89bddce5
SH
1658 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1659 if (sock != NULL) {
1da177e4
LT
1660 err = security_socket_getpeername(sock);
1661 if (err) {
6cb153ca 1662 fput_light(sock->file, fput_needed);
1da177e4
LT
1663 return err;
1664 }
1665
89bddce5 1666 err =
230b1839 1667 sock->ops->getname(sock, (struct sockaddr *)&address, &len,
89bddce5 1668 1);
1da177e4 1669 if (!err)
230b1839 1670 err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr,
89bddce5 1671 usockaddr_len);
6cb153ca 1672 fput_light(sock->file, fput_needed);
1da177e4
LT
1673 }
1674 return err;
1675}
1676
1677/*
1678 * Send a datagram to a given address. We move the address into kernel
1679 * space and check the user space data area is readable before invoking
1680 * the protocol.
1681 */
1682
89bddce5
SH
1683asmlinkage long sys_sendto(int fd, void __user *buff, size_t len,
1684 unsigned flags, struct sockaddr __user *addr,
1685 int addr_len)
1da177e4
LT
1686{
1687 struct socket *sock;
230b1839 1688 struct sockaddr_storage address;
1da177e4
LT
1689 int err;
1690 struct msghdr msg;
1691 struct iovec iov;
6cb153ca 1692 int fput_needed;
6cb153ca 1693
de0fa95c
PE
1694 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1695 if (!sock)
4387ff75 1696 goto out;
6cb153ca 1697
89bddce5
SH
1698 iov.iov_base = buff;
1699 iov.iov_len = len;
1700 msg.msg_name = NULL;
1701 msg.msg_iov = &iov;
1702 msg.msg_iovlen = 1;
1703 msg.msg_control = NULL;
1704 msg.msg_controllen = 0;
1705 msg.msg_namelen = 0;
6cb153ca 1706 if (addr) {
230b1839 1707 err = move_addr_to_kernel(addr, addr_len, (struct sockaddr *)&address);
1da177e4
LT
1708 if (err < 0)
1709 goto out_put;
230b1839 1710 msg.msg_name = (struct sockaddr *)&address;
89bddce5 1711 msg.msg_namelen = addr_len;
1da177e4
LT
1712 }
1713 if (sock->file->f_flags & O_NONBLOCK)
1714 flags |= MSG_DONTWAIT;
1715 msg.msg_flags = flags;
1716 err = sock_sendmsg(sock, &msg, len);
1717
89bddce5 1718out_put:
de0fa95c 1719 fput_light(sock->file, fput_needed);
4387ff75 1720out:
1da177e4
LT
1721 return err;
1722}
1723
1724/*
89bddce5 1725 * Send a datagram down a socket.
1da177e4
LT
1726 */
1727
89bddce5 1728asmlinkage long sys_send(int fd, void __user *buff, size_t len, unsigned flags)
1da177e4
LT
1729{
1730 return sys_sendto(fd, buff, len, flags, NULL, 0);
1731}
1732
1733/*
89bddce5 1734 * Receive a frame from the socket and optionally record the address of the
1da177e4
LT
1735 * sender. We verify the buffers are writable and if needed move the
1736 * sender address from kernel to user space.
1737 */
1738
89bddce5
SH
1739asmlinkage long sys_recvfrom(int fd, void __user *ubuf, size_t size,
1740 unsigned flags, struct sockaddr __user *addr,
1741 int __user *addr_len)
1da177e4
LT
1742{
1743 struct socket *sock;
1744 struct iovec iov;
1745 struct msghdr msg;
230b1839 1746 struct sockaddr_storage address;
89bddce5 1747 int err, err2;
6cb153ca
BL
1748 int fput_needed;
1749
de0fa95c 1750 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4 1751 if (!sock)
de0fa95c 1752 goto out;
1da177e4 1753
89bddce5
SH
1754 msg.msg_control = NULL;
1755 msg.msg_controllen = 0;
1756 msg.msg_iovlen = 1;
1757 msg.msg_iov = &iov;
1758 iov.iov_len = size;
1759 iov.iov_base = ubuf;
230b1839
YH
1760 msg.msg_name = (struct sockaddr *)&address;
1761 msg.msg_namelen = sizeof(address);
1da177e4
LT
1762 if (sock->file->f_flags & O_NONBLOCK)
1763 flags |= MSG_DONTWAIT;
89bddce5 1764 err = sock_recvmsg(sock, &msg, size, flags);
1da177e4 1765
89bddce5 1766 if (err >= 0 && addr != NULL) {
230b1839
YH
1767 err2 = move_addr_to_user((struct sockaddr *)&address,
1768 msg.msg_namelen, addr, addr_len);
89bddce5
SH
1769 if (err2 < 0)
1770 err = err2;
1da177e4 1771 }
de0fa95c
PE
1772
1773 fput_light(sock->file, fput_needed);
4387ff75 1774out:
1da177e4
LT
1775 return err;
1776}
1777
1778/*
89bddce5 1779 * Receive a datagram from a socket.
1da177e4
LT
1780 */
1781
89bddce5
SH
1782asmlinkage long sys_recv(int fd, void __user *ubuf, size_t size,
1783 unsigned flags)
1da177e4
LT
1784{
1785 return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL);
1786}
1787
1788/*
1789 * Set a socket option. Because we don't know the option lengths we have
1790 * to pass the user mode parameter for the protocols to sort out.
1791 */
1792
89bddce5
SH
1793asmlinkage long sys_setsockopt(int fd, int level, int optname,
1794 char __user *optval, int optlen)
1da177e4 1795{
6cb153ca 1796 int err, fput_needed;
1da177e4
LT
1797 struct socket *sock;
1798
1799 if (optlen < 0)
1800 return -EINVAL;
89bddce5
SH
1801
1802 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1803 if (sock != NULL) {
1804 err = security_socket_setsockopt(sock, level, optname);
6cb153ca
BL
1805 if (err)
1806 goto out_put;
1da177e4
LT
1807
1808 if (level == SOL_SOCKET)
89bddce5
SH
1809 err =
1810 sock_setsockopt(sock, level, optname, optval,
1811 optlen);
1da177e4 1812 else
89bddce5
SH
1813 err =
1814 sock->ops->setsockopt(sock, level, optname, optval,
1815 optlen);
6cb153ca
BL
1816out_put:
1817 fput_light(sock->file, fput_needed);
1da177e4
LT
1818 }
1819 return err;
1820}
1821
1822/*
1823 * Get a socket option. Because we don't know the option lengths we have
1824 * to pass a user mode parameter for the protocols to sort out.
1825 */
1826
89bddce5
SH
1827asmlinkage long sys_getsockopt(int fd, int level, int optname,
1828 char __user *optval, int __user *optlen)
1da177e4 1829{
6cb153ca 1830 int err, fput_needed;
1da177e4
LT
1831 struct socket *sock;
1832
89bddce5
SH
1833 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1834 if (sock != NULL) {
6cb153ca
BL
1835 err = security_socket_getsockopt(sock, level, optname);
1836 if (err)
1837 goto out_put;
1da177e4
LT
1838
1839 if (level == SOL_SOCKET)
89bddce5
SH
1840 err =
1841 sock_getsockopt(sock, level, optname, optval,
1842 optlen);
1da177e4 1843 else
89bddce5
SH
1844 err =
1845 sock->ops->getsockopt(sock, level, optname, optval,
1846 optlen);
6cb153ca
BL
1847out_put:
1848 fput_light(sock->file, fput_needed);
1da177e4
LT
1849 }
1850 return err;
1851}
1852
1da177e4
LT
1853/*
1854 * Shutdown a socket.
1855 */
1856
1857asmlinkage long sys_shutdown(int fd, int how)
1858{
6cb153ca 1859 int err, fput_needed;
1da177e4
LT
1860 struct socket *sock;
1861
89bddce5
SH
1862 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1863 if (sock != NULL) {
1da177e4 1864 err = security_socket_shutdown(sock, how);
6cb153ca
BL
1865 if (!err)
1866 err = sock->ops->shutdown(sock, how);
1867 fput_light(sock->file, fput_needed);
1da177e4
LT
1868 }
1869 return err;
1870}
1871
89bddce5 1872/* A couple of helpful macros for getting the address of the 32/64 bit
1da177e4
LT
1873 * fields which are the same type (int / unsigned) on our platforms.
1874 */
1875#define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member)
1876#define COMPAT_NAMELEN(msg) COMPAT_MSG(msg, msg_namelen)
1877#define COMPAT_FLAGS(msg) COMPAT_MSG(msg, msg_flags)
1878
1da177e4
LT
1879/*
1880 * BSD sendmsg interface
1881 */
1882
1883asmlinkage long sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags)
1884{
89bddce5
SH
1885 struct compat_msghdr __user *msg_compat =
1886 (struct compat_msghdr __user *)msg;
1da177e4 1887 struct socket *sock;
230b1839 1888 struct sockaddr_storage address;
1da177e4 1889 struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
b9d717a7 1890 unsigned char ctl[sizeof(struct cmsghdr) + 20]
89bddce5
SH
1891 __attribute__ ((aligned(sizeof(__kernel_size_t))));
1892 /* 20 is size of ipv6_pktinfo */
1da177e4
LT
1893 unsigned char *ctl_buf = ctl;
1894 struct msghdr msg_sys;
1895 int err, ctl_len, iov_size, total_len;
6cb153ca 1896 int fput_needed;
89bddce5 1897
1da177e4
LT
1898 err = -EFAULT;
1899 if (MSG_CMSG_COMPAT & flags) {
1900 if (get_compat_msghdr(&msg_sys, msg_compat))
1901 return -EFAULT;
89bddce5
SH
1902 }
1903 else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr)))
1da177e4
LT
1904 return -EFAULT;
1905
6cb153ca 1906 sock = sockfd_lookup_light(fd, &err, &fput_needed);
89bddce5 1907 if (!sock)
1da177e4
LT
1908 goto out;
1909
1910 /* do not move before msg_sys is valid */
1911 err = -EMSGSIZE;
1912 if (msg_sys.msg_iovlen > UIO_MAXIOV)
1913 goto out_put;
1914
89bddce5 1915 /* Check whether to allocate the iovec area */
1da177e4
LT
1916 err = -ENOMEM;
1917 iov_size = msg_sys.msg_iovlen * sizeof(struct iovec);
1918 if (msg_sys.msg_iovlen > UIO_FASTIOV) {
1919 iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
1920 if (!iov)
1921 goto out_put;
1922 }
1923
1924 /* This will also move the address data into kernel space */
1925 if (MSG_CMSG_COMPAT & flags) {
230b1839
YH
1926 err = verify_compat_iovec(&msg_sys, iov,
1927 (struct sockaddr *)&address,
1928 VERIFY_READ);
1da177e4 1929 } else
230b1839
YH
1930 err = verify_iovec(&msg_sys, iov,
1931 (struct sockaddr *)&address,
1932 VERIFY_READ);
89bddce5 1933 if (err < 0)
1da177e4
LT
1934 goto out_freeiov;
1935 total_len = err;
1936
1937 err = -ENOBUFS;
1938
1939 if (msg_sys.msg_controllen > INT_MAX)
1940 goto out_freeiov;
89bddce5 1941 ctl_len = msg_sys.msg_controllen;
1da177e4 1942 if ((MSG_CMSG_COMPAT & flags) && ctl_len) {
89bddce5
SH
1943 err =
1944 cmsghdr_from_user_compat_to_kern(&msg_sys, sock->sk, ctl,
1945 sizeof(ctl));
1da177e4
LT
1946 if (err)
1947 goto out_freeiov;
1948 ctl_buf = msg_sys.msg_control;
8920e8f9 1949 ctl_len = msg_sys.msg_controllen;
1da177e4 1950 } else if (ctl_len) {
89bddce5 1951 if (ctl_len > sizeof(ctl)) {
1da177e4 1952 ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL);
89bddce5 1953 if (ctl_buf == NULL)
1da177e4
LT
1954 goto out_freeiov;
1955 }
1956 err = -EFAULT;
1957 /*
1958 * Careful! Before this, msg_sys.msg_control contains a user pointer.
1959 * Afterwards, it will be a kernel pointer. Thus the compiler-assisted
1960 * checking falls down on this.
1961 */
89bddce5
SH
1962 if (copy_from_user(ctl_buf, (void __user *)msg_sys.msg_control,
1963 ctl_len))
1da177e4
LT
1964 goto out_freectl;
1965 msg_sys.msg_control = ctl_buf;
1966 }
1967 msg_sys.msg_flags = flags;
1968
1969 if (sock->file->f_flags & O_NONBLOCK)
1970 msg_sys.msg_flags |= MSG_DONTWAIT;
1971 err = sock_sendmsg(sock, &msg_sys, total_len);
1972
1973out_freectl:
89bddce5 1974 if (ctl_buf != ctl)
1da177e4
LT
1975 sock_kfree_s(sock->sk, ctl_buf, ctl_len);
1976out_freeiov:
1977 if (iov != iovstack)
1978 sock_kfree_s(sock->sk, iov, iov_size);
1979out_put:
6cb153ca 1980 fput_light(sock->file, fput_needed);
89bddce5 1981out:
1da177e4
LT
1982 return err;
1983}
1984
1985/*
1986 * BSD recvmsg interface
1987 */
1988
89bddce5
SH
1989asmlinkage long sys_recvmsg(int fd, struct msghdr __user *msg,
1990 unsigned int flags)
1da177e4 1991{
89bddce5
SH
1992 struct compat_msghdr __user *msg_compat =
1993 (struct compat_msghdr __user *)msg;
1da177e4
LT
1994 struct socket *sock;
1995 struct iovec iovstack[UIO_FASTIOV];
89bddce5 1996 struct iovec *iov = iovstack;
1da177e4
LT
1997 struct msghdr msg_sys;
1998 unsigned long cmsg_ptr;
1999 int err, iov_size, total_len, len;
6cb153ca 2000 int fput_needed;
1da177e4
LT
2001
2002 /* kernel mode address */
230b1839 2003 struct sockaddr_storage addr;
1da177e4
LT
2004
2005 /* user mode address pointers */
2006 struct sockaddr __user *uaddr;
2007 int __user *uaddr_len;
89bddce5 2008
1da177e4
LT
2009 if (MSG_CMSG_COMPAT & flags) {
2010 if (get_compat_msghdr(&msg_sys, msg_compat))
2011 return -EFAULT;
89bddce5
SH
2012 }
2013 else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr)))
2014 return -EFAULT;
1da177e4 2015
6cb153ca 2016 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4
LT
2017 if (!sock)
2018 goto out;
2019
2020 err = -EMSGSIZE;
2021 if (msg_sys.msg_iovlen > UIO_MAXIOV)
2022 goto out_put;
89bddce5
SH
2023
2024 /* Check whether to allocate the iovec area */
1da177e4
LT
2025 err = -ENOMEM;
2026 iov_size = msg_sys.msg_iovlen * sizeof(struct iovec);
2027 if (msg_sys.msg_iovlen > UIO_FASTIOV) {
2028 iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
2029 if (!iov)
2030 goto out_put;
2031 }
2032
2033 /*
89bddce5
SH
2034 * Save the user-mode address (verify_iovec will change the
2035 * kernel msghdr to use the kernel address space)
1da177e4 2036 */
89bddce5 2037
cfcabdcc 2038 uaddr = (__force void __user *)msg_sys.msg_name;
1da177e4
LT
2039 uaddr_len = COMPAT_NAMELEN(msg);
2040 if (MSG_CMSG_COMPAT & flags) {
230b1839
YH
2041 err = verify_compat_iovec(&msg_sys, iov,
2042 (struct sockaddr *)&addr,
2043 VERIFY_WRITE);
1da177e4 2044 } else
230b1839
YH
2045 err = verify_iovec(&msg_sys, iov,
2046 (struct sockaddr *)&addr,
2047 VERIFY_WRITE);
1da177e4
LT
2048 if (err < 0)
2049 goto out_freeiov;
89bddce5 2050 total_len = err;
1da177e4
LT
2051
2052 cmsg_ptr = (unsigned long)msg_sys.msg_control;
4a19542e 2053 msg_sys.msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT);
89bddce5 2054
1da177e4
LT
2055 if (sock->file->f_flags & O_NONBLOCK)
2056 flags |= MSG_DONTWAIT;
2057 err = sock_recvmsg(sock, &msg_sys, total_len, flags);
2058 if (err < 0)
2059 goto out_freeiov;
2060 len = err;
2061
2062 if (uaddr != NULL) {
230b1839
YH
2063 err = move_addr_to_user((struct sockaddr *)&addr,
2064 msg_sys.msg_namelen, uaddr,
89bddce5 2065 uaddr_len);
1da177e4
LT
2066 if (err < 0)
2067 goto out_freeiov;
2068 }
37f7f421
DM
2069 err = __put_user((msg_sys.msg_flags & ~MSG_CMSG_COMPAT),
2070 COMPAT_FLAGS(msg));
1da177e4
LT
2071 if (err)
2072 goto out_freeiov;
2073 if (MSG_CMSG_COMPAT & flags)
89bddce5 2074 err = __put_user((unsigned long)msg_sys.msg_control - cmsg_ptr,
1da177e4
LT
2075 &msg_compat->msg_controllen);
2076 else
89bddce5 2077 err = __put_user((unsigned long)msg_sys.msg_control - cmsg_ptr,
1da177e4
LT
2078 &msg->msg_controllen);
2079 if (err)
2080 goto out_freeiov;
2081 err = len;
2082
2083out_freeiov:
2084 if (iov != iovstack)
2085 sock_kfree_s(sock->sk, iov, iov_size);
2086out_put:
6cb153ca 2087 fput_light(sock->file, fput_needed);
1da177e4
LT
2088out:
2089 return err;
2090}
2091
2092#ifdef __ARCH_WANT_SYS_SOCKETCALL
2093
2094/* Argument list sizes for sys_socketcall */
2095#define AL(x) ((x) * sizeof(unsigned long))
aaca0bdc 2096static const unsigned char nargs[19]={
89bddce5
SH
2097 AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
2098 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
aaca0bdc
UD
2099 AL(6),AL(2),AL(5),AL(5),AL(3),AL(3),
2100 AL(6)
89bddce5
SH
2101};
2102
1da177e4
LT
2103#undef AL
2104
2105/*
89bddce5 2106 * System call vectors.
1da177e4
LT
2107 *
2108 * Argument checking cleaned up. Saved 20% in size.
2109 * This function doesn't need to set the kernel lock because
89bddce5 2110 * it is set by the callees.
1da177e4
LT
2111 */
2112
2113asmlinkage long sys_socketcall(int call, unsigned long __user *args)
2114{
2115 unsigned long a[6];
89bddce5 2116 unsigned long a0, a1;
1da177e4
LT
2117 int err;
2118
aaca0bdc 2119 if (call < 1 || call > SYS_PACCEPT)
1da177e4
LT
2120 return -EINVAL;
2121
2122 /* copy_from_user should be SMP safe. */
2123 if (copy_from_user(a, args, nargs[call]))
2124 return -EFAULT;
3ec3b2fb 2125
89bddce5 2126 err = audit_socketcall(nargs[call] / sizeof(unsigned long), a);
3ec3b2fb
DW
2127 if (err)
2128 return err;
2129
89bddce5
SH
2130 a0 = a[0];
2131 a1 = a[1];
2132
2133 switch (call) {
2134 case SYS_SOCKET:
2135 err = sys_socket(a0, a1, a[2]);
2136 break;
2137 case SYS_BIND:
2138 err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]);
2139 break;
2140 case SYS_CONNECT:
2141 err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
2142 break;
2143 case SYS_LISTEN:
2144 err = sys_listen(a0, a1);
2145 break;
2146 case SYS_ACCEPT:
2147 err =
aaca0bdc
UD
2148 do_accept(a0, (struct sockaddr __user *)a1,
2149 (int __user *)a[2], 0);
89bddce5
SH
2150 break;
2151 case SYS_GETSOCKNAME:
2152 err =
2153 sys_getsockname(a0, (struct sockaddr __user *)a1,
2154 (int __user *)a[2]);
2155 break;
2156 case SYS_GETPEERNAME:
2157 err =
2158 sys_getpeername(a0, (struct sockaddr __user *)a1,
2159 (int __user *)a[2]);
2160 break;
2161 case SYS_SOCKETPAIR:
2162 err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]);
2163 break;
2164 case SYS_SEND:
2165 err = sys_send(a0, (void __user *)a1, a[2], a[3]);
2166 break;
2167 case SYS_SENDTO:
2168 err = sys_sendto(a0, (void __user *)a1, a[2], a[3],
2169 (struct sockaddr __user *)a[4], a[5]);
2170 break;
2171 case SYS_RECV:
2172 err = sys_recv(a0, (void __user *)a1, a[2], a[3]);
2173 break;
2174 case SYS_RECVFROM:
2175 err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
2176 (struct sockaddr __user *)a[4],
2177 (int __user *)a[5]);
2178 break;
2179 case SYS_SHUTDOWN:
2180 err = sys_shutdown(a0, a1);
2181 break;
2182 case SYS_SETSOCKOPT:
2183 err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]);
2184 break;
2185 case SYS_GETSOCKOPT:
2186 err =
2187 sys_getsockopt(a0, a1, a[2], (char __user *)a[3],
2188 (int __user *)a[4]);
2189 break;
2190 case SYS_SENDMSG:
2191 err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]);
2192 break;
2193 case SYS_RECVMSG:
2194 err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]);
2195 break;
aaca0bdc
UD
2196 case SYS_PACCEPT:
2197 err =
2198 sys_paccept(a0, (struct sockaddr __user *)a1,
2199 (int __user *)a[2],
2200 (const sigset_t __user *) a[3],
2201 a[4], a[5]);
2202 break;
89bddce5
SH
2203 default:
2204 err = -EINVAL;
2205 break;
1da177e4
LT
2206 }
2207 return err;
2208}
2209
89bddce5 2210#endif /* __ARCH_WANT_SYS_SOCKETCALL */
1da177e4 2211
55737fda
SH
2212/**
2213 * sock_register - add a socket protocol handler
2214 * @ops: description of protocol
2215 *
1da177e4
LT
2216 * This function is called by a protocol handler that wants to
2217 * advertise its address family, and have it linked into the
55737fda
SH
2218 * socket interface. The value ops->family coresponds to the
2219 * socket system call protocol family.
1da177e4 2220 */
f0fd27d4 2221int sock_register(const struct net_proto_family *ops)
1da177e4
LT
2222{
2223 int err;
2224
2225 if (ops->family >= NPROTO) {
89bddce5
SH
2226 printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family,
2227 NPROTO);
1da177e4
LT
2228 return -ENOBUFS;
2229 }
55737fda
SH
2230
2231 spin_lock(&net_family_lock);
2232 if (net_families[ops->family])
2233 err = -EEXIST;
2234 else {
89bddce5 2235 net_families[ops->family] = ops;
1da177e4
LT
2236 err = 0;
2237 }
55737fda
SH
2238 spin_unlock(&net_family_lock);
2239
89bddce5 2240 printk(KERN_INFO "NET: Registered protocol family %d\n", ops->family);
1da177e4
LT
2241 return err;
2242}
2243
55737fda
SH
2244/**
2245 * sock_unregister - remove a protocol handler
2246 * @family: protocol family to remove
2247 *
1da177e4
LT
2248 * This function is called by a protocol handler that wants to
2249 * remove its address family, and have it unlinked from the
55737fda
SH
2250 * new socket creation.
2251 *
2252 * If protocol handler is a module, then it can use module reference
2253 * counts to protect against new references. If protocol handler is not
2254 * a module then it needs to provide its own protection in
2255 * the ops->create routine.
1da177e4 2256 */
f0fd27d4 2257void sock_unregister(int family)
1da177e4 2258{
f0fd27d4 2259 BUG_ON(family < 0 || family >= NPROTO);
1da177e4 2260
55737fda 2261 spin_lock(&net_family_lock);
89bddce5 2262 net_families[family] = NULL;
55737fda
SH
2263 spin_unlock(&net_family_lock);
2264
2265 synchronize_rcu();
2266
89bddce5 2267 printk(KERN_INFO "NET: Unregistered protocol family %d\n", family);
1da177e4
LT
2268}
2269
77d76ea3 2270static int __init sock_init(void)
1da177e4
LT
2271{
2272 /*
89bddce5 2273 * Initialize sock SLAB cache.
1da177e4 2274 */
89bddce5 2275
1da177e4
LT
2276 sk_init();
2277
1da177e4 2278 /*
89bddce5 2279 * Initialize skbuff SLAB cache
1da177e4
LT
2280 */
2281 skb_init();
1da177e4
LT
2282
2283 /*
89bddce5 2284 * Initialize the protocols module.
1da177e4
LT
2285 */
2286
2287 init_inodecache();
2288 register_filesystem(&sock_fs_type);
2289 sock_mnt = kern_mount(&sock_fs_type);
77d76ea3
AK
2290
2291 /* The real protocol initialization is performed in later initcalls.
1da177e4
LT
2292 */
2293
2294#ifdef CONFIG_NETFILTER
2295 netfilter_init();
2296#endif
cbeb321a
DM
2297
2298 return 0;
1da177e4
LT
2299}
2300
77d76ea3
AK
2301core_initcall(sock_init); /* early initcall */
2302
1da177e4
LT
2303#ifdef CONFIG_PROC_FS
2304void socket_seq_show(struct seq_file *seq)
2305{
2306 int cpu;
2307 int counter = 0;
2308
6f912042 2309 for_each_possible_cpu(cpu)
89bddce5 2310 counter += per_cpu(sockets_in_use, cpu);
1da177e4
LT
2311
2312 /* It can be negative, by the way. 8) */
2313 if (counter < 0)
2314 counter = 0;
2315
2316 seq_printf(seq, "sockets: used %d\n", counter);
2317}
89bddce5 2318#endif /* CONFIG_PROC_FS */
1da177e4 2319
89bbfc95
SP
2320#ifdef CONFIG_COMPAT
2321static long compat_sock_ioctl(struct file *file, unsigned cmd,
89bddce5 2322 unsigned long arg)
89bbfc95
SP
2323{
2324 struct socket *sock = file->private_data;
2325 int ret = -ENOIOCTLCMD;
87de87d5
DM
2326 struct sock *sk;
2327 struct net *net;
2328
2329 sk = sock->sk;
2330 net = sock_net(sk);
89bbfc95
SP
2331
2332 if (sock->ops->compat_ioctl)
2333 ret = sock->ops->compat_ioctl(sock, cmd, arg);
2334
87de87d5
DM
2335 if (ret == -ENOIOCTLCMD &&
2336 (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST))
2337 ret = compat_wext_handle_ioctl(net, cmd, arg);
2338
89bbfc95
SP
2339 return ret;
2340}
2341#endif
2342
ac5a488e
SS
2343int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen)
2344{
2345 return sock->ops->bind(sock, addr, addrlen);
2346}
2347
2348int kernel_listen(struct socket *sock, int backlog)
2349{
2350 return sock->ops->listen(sock, backlog);
2351}
2352
2353int kernel_accept(struct socket *sock, struct socket **newsock, int flags)
2354{
2355 struct sock *sk = sock->sk;
2356 int err;
2357
2358 err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol,
2359 newsock);
2360 if (err < 0)
2361 goto done;
2362
2363 err = sock->ops->accept(sock, *newsock, flags);
2364 if (err < 0) {
2365 sock_release(*newsock);
fa8705b0 2366 *newsock = NULL;
ac5a488e
SS
2367 goto done;
2368 }
2369
2370 (*newsock)->ops = sock->ops;
2371
2372done:
2373 return err;
2374}
2375
2376int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen,
4768fbcb 2377 int flags)
ac5a488e
SS
2378{
2379 return sock->ops->connect(sock, addr, addrlen, flags);
2380}
2381
2382int kernel_getsockname(struct socket *sock, struct sockaddr *addr,
2383 int *addrlen)
2384{
2385 return sock->ops->getname(sock, addr, addrlen, 0);
2386}
2387
2388int kernel_getpeername(struct socket *sock, struct sockaddr *addr,
2389 int *addrlen)
2390{
2391 return sock->ops->getname(sock, addr, addrlen, 1);
2392}
2393
2394int kernel_getsockopt(struct socket *sock, int level, int optname,
2395 char *optval, int *optlen)
2396{
2397 mm_segment_t oldfs = get_fs();
2398 int err;
2399
2400 set_fs(KERNEL_DS);
2401 if (level == SOL_SOCKET)
2402 err = sock_getsockopt(sock, level, optname, optval, optlen);
2403 else
2404 err = sock->ops->getsockopt(sock, level, optname, optval,
2405 optlen);
2406 set_fs(oldfs);
2407 return err;
2408}
2409
2410int kernel_setsockopt(struct socket *sock, int level, int optname,
2411 char *optval, int optlen)
2412{
2413 mm_segment_t oldfs = get_fs();
2414 int err;
2415
2416 set_fs(KERNEL_DS);
2417 if (level == SOL_SOCKET)
2418 err = sock_setsockopt(sock, level, optname, optval, optlen);
2419 else
2420 err = sock->ops->setsockopt(sock, level, optname, optval,
2421 optlen);
2422 set_fs(oldfs);
2423 return err;
2424}
2425
2426int kernel_sendpage(struct socket *sock, struct page *page, int offset,
2427 size_t size, int flags)
2428{
2429 if (sock->ops->sendpage)
2430 return sock->ops->sendpage(sock, page, offset, size, flags);
2431
2432 return sock_no_sendpage(sock, page, offset, size, flags);
2433}
2434
2435int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg)
2436{
2437 mm_segment_t oldfs = get_fs();
2438 int err;
2439
2440 set_fs(KERNEL_DS);
2441 err = sock->ops->ioctl(sock, cmd, arg);
2442 set_fs(oldfs);
2443
2444 return err;
2445}
2446
91cf45f0
TM
2447int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how)
2448{
2449 return sock->ops->shutdown(sock, how);
2450}
2451
1da177e4
LT
2452EXPORT_SYMBOL(sock_create);
2453EXPORT_SYMBOL(sock_create_kern);
2454EXPORT_SYMBOL(sock_create_lite);
2455EXPORT_SYMBOL(sock_map_fd);
2456EXPORT_SYMBOL(sock_recvmsg);
2457EXPORT_SYMBOL(sock_register);
2458EXPORT_SYMBOL(sock_release);
2459EXPORT_SYMBOL(sock_sendmsg);
2460EXPORT_SYMBOL(sock_unregister);
2461EXPORT_SYMBOL(sock_wake_async);
2462EXPORT_SYMBOL(sockfd_lookup);
2463EXPORT_SYMBOL(kernel_sendmsg);
2464EXPORT_SYMBOL(kernel_recvmsg);
ac5a488e
SS
2465EXPORT_SYMBOL(kernel_bind);
2466EXPORT_SYMBOL(kernel_listen);
2467EXPORT_SYMBOL(kernel_accept);
2468EXPORT_SYMBOL(kernel_connect);
2469EXPORT_SYMBOL(kernel_getsockname);
2470EXPORT_SYMBOL(kernel_getpeername);
2471EXPORT_SYMBOL(kernel_getsockopt);
2472EXPORT_SYMBOL(kernel_setsockopt);
2473EXPORT_SYMBOL(kernel_sendpage);
2474EXPORT_SYMBOL(kernel_sock_ioctl);
91cf45f0 2475EXPORT_SYMBOL(kernel_sock_shutdown);