Documentation cleanup: trivial misspelling, punctuation, and grammar corrections.
[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
4ba9b9d0 268static void init_once(struct kmem_cache *cachep, 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
c019bbc6 1514#ifdef HAVE_SET_RESTORE_SIGMASK
aaca0bdc
UD
1515asmlinkage long sys_paccept(int fd, struct sockaddr __user *upeer_sockaddr,
1516 int __user *upeer_addrlen,
1517 const sigset_t __user *sigmask,
1518 size_t sigsetsize, int flags)
1519{
1520 sigset_t ksigmask, sigsaved;
1521 int ret;
1522
1523 if (sigmask) {
1524 /* XXX: Don't preclude handling different sized sigset_t's. */
1525 if (sigsetsize != sizeof(sigset_t))
1526 return -EINVAL;
1527 if (copy_from_user(&ksigmask, sigmask, sizeof(ksigmask)))
1528 return -EFAULT;
1529
1530 sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP));
1531 sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
1532 }
1533
1534 ret = do_accept(fd, upeer_sockaddr, upeer_addrlen, flags);
1535
1536 if (ret < 0 && signal_pending(current)) {
1537 /*
1538 * Don't restore the signal mask yet. Let do_signal() deliver
1539 * the signal on the way back to userspace, before the signal
1540 * mask is restored.
1541 */
1542 if (sigmask) {
1543 memcpy(&current->saved_sigmask, &sigsaved,
1544 sizeof(sigsaved));
1545 set_restore_sigmask();
1546 }
1547 } else if (sigmask)
1548 sigprocmask(SIG_SETMASK, &sigsaved, NULL);
1549
1550 return ret;
1551}
c019bbc6
UD
1552#else
1553asmlinkage long sys_paccept(int fd, struct sockaddr __user *upeer_sockaddr,
1554 int __user *upeer_addrlen,
1555 const sigset_t __user *sigmask,
1556 size_t sigsetsize, int flags)
1557{
1558 /* The platform does not support restoring the signal mask in the
1559 * return path. So we do not allow using paccept() with a signal
1560 * mask. */
1561 if (sigmask)
1562 return -EINVAL;
1563
1564 return do_accept(fd, upeer_sockaddr, upeer_addrlen, flags);
1565}
1566#endif
aaca0bdc
UD
1567
1568asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr,
1569 int __user *upeer_addrlen)
1570{
1571 return do_accept(fd, upeer_sockaddr, upeer_addrlen, 0);
1572}
1573
1da177e4
LT
1574/*
1575 * Attempt to connect to a socket with the server address. The address
1576 * is in user space so we verify it is OK and move it to kernel space.
1577 *
1578 * For 1003.1g we need to add clean support for a bind to AF_UNSPEC to
1579 * break bindings
1580 *
1581 * NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and
1582 * other SEQPACKET protocols that take time to connect() as it doesn't
1583 * include the -EINPROGRESS status for such sockets.
1584 */
1585
89bddce5
SH
1586asmlinkage long sys_connect(int fd, struct sockaddr __user *uservaddr,
1587 int addrlen)
1da177e4
LT
1588{
1589 struct socket *sock;
230b1839 1590 struct sockaddr_storage address;
6cb153ca 1591 int err, fput_needed;
1da177e4 1592
6cb153ca 1593 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4
LT
1594 if (!sock)
1595 goto out;
230b1839 1596 err = move_addr_to_kernel(uservaddr, addrlen, (struct sockaddr *)&address);
1da177e4
LT
1597 if (err < 0)
1598 goto out_put;
1599
89bddce5 1600 err =
230b1839 1601 security_socket_connect(sock, (struct sockaddr *)&address, addrlen);
1da177e4
LT
1602 if (err)
1603 goto out_put;
1604
230b1839 1605 err = sock->ops->connect(sock, (struct sockaddr *)&address, addrlen,
1da177e4
LT
1606 sock->file->f_flags);
1607out_put:
6cb153ca 1608 fput_light(sock->file, fput_needed);
1da177e4
LT
1609out:
1610 return err;
1611}
1612
1613/*
1614 * Get the local address ('name') of a socket object. Move the obtained
1615 * name to user space.
1616 */
1617
89bddce5
SH
1618asmlinkage long sys_getsockname(int fd, struct sockaddr __user *usockaddr,
1619 int __user *usockaddr_len)
1da177e4
LT
1620{
1621 struct socket *sock;
230b1839 1622 struct sockaddr_storage address;
6cb153ca 1623 int len, err, fput_needed;
89bddce5 1624
6cb153ca 1625 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4
LT
1626 if (!sock)
1627 goto out;
1628
1629 err = security_socket_getsockname(sock);
1630 if (err)
1631 goto out_put;
1632
230b1839 1633 err = sock->ops->getname(sock, (struct sockaddr *)&address, &len, 0);
1da177e4
LT
1634 if (err)
1635 goto out_put;
230b1839 1636 err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr, usockaddr_len);
1da177e4
LT
1637
1638out_put:
6cb153ca 1639 fput_light(sock->file, fput_needed);
1da177e4
LT
1640out:
1641 return err;
1642}
1643
1644/*
1645 * Get the remote address ('name') of a socket object. Move the obtained
1646 * name to user space.
1647 */
1648
89bddce5
SH
1649asmlinkage long sys_getpeername(int fd, struct sockaddr __user *usockaddr,
1650 int __user *usockaddr_len)
1da177e4
LT
1651{
1652 struct socket *sock;
230b1839 1653 struct sockaddr_storage address;
6cb153ca 1654 int len, err, fput_needed;
1da177e4 1655
89bddce5
SH
1656 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1657 if (sock != NULL) {
1da177e4
LT
1658 err = security_socket_getpeername(sock);
1659 if (err) {
6cb153ca 1660 fput_light(sock->file, fput_needed);
1da177e4
LT
1661 return err;
1662 }
1663
89bddce5 1664 err =
230b1839 1665 sock->ops->getname(sock, (struct sockaddr *)&address, &len,
89bddce5 1666 1);
1da177e4 1667 if (!err)
230b1839 1668 err = move_addr_to_user((struct sockaddr *)&address, len, usockaddr,
89bddce5 1669 usockaddr_len);
6cb153ca 1670 fput_light(sock->file, fput_needed);
1da177e4
LT
1671 }
1672 return err;
1673}
1674
1675/*
1676 * Send a datagram to a given address. We move the address into kernel
1677 * space and check the user space data area is readable before invoking
1678 * the protocol.
1679 */
1680
89bddce5
SH
1681asmlinkage long sys_sendto(int fd, void __user *buff, size_t len,
1682 unsigned flags, struct sockaddr __user *addr,
1683 int addr_len)
1da177e4
LT
1684{
1685 struct socket *sock;
230b1839 1686 struct sockaddr_storage address;
1da177e4
LT
1687 int err;
1688 struct msghdr msg;
1689 struct iovec iov;
6cb153ca 1690 int fput_needed;
6cb153ca 1691
de0fa95c
PE
1692 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1693 if (!sock)
4387ff75 1694 goto out;
6cb153ca 1695
89bddce5
SH
1696 iov.iov_base = buff;
1697 iov.iov_len = len;
1698 msg.msg_name = NULL;
1699 msg.msg_iov = &iov;
1700 msg.msg_iovlen = 1;
1701 msg.msg_control = NULL;
1702 msg.msg_controllen = 0;
1703 msg.msg_namelen = 0;
6cb153ca 1704 if (addr) {
230b1839 1705 err = move_addr_to_kernel(addr, addr_len, (struct sockaddr *)&address);
1da177e4
LT
1706 if (err < 0)
1707 goto out_put;
230b1839 1708 msg.msg_name = (struct sockaddr *)&address;
89bddce5 1709 msg.msg_namelen = addr_len;
1da177e4
LT
1710 }
1711 if (sock->file->f_flags & O_NONBLOCK)
1712 flags |= MSG_DONTWAIT;
1713 msg.msg_flags = flags;
1714 err = sock_sendmsg(sock, &msg, len);
1715
89bddce5 1716out_put:
de0fa95c 1717 fput_light(sock->file, fput_needed);
4387ff75 1718out:
1da177e4
LT
1719 return err;
1720}
1721
1722/*
89bddce5 1723 * Send a datagram down a socket.
1da177e4
LT
1724 */
1725
89bddce5 1726asmlinkage long sys_send(int fd, void __user *buff, size_t len, unsigned flags)
1da177e4
LT
1727{
1728 return sys_sendto(fd, buff, len, flags, NULL, 0);
1729}
1730
1731/*
89bddce5 1732 * Receive a frame from the socket and optionally record the address of the
1da177e4
LT
1733 * sender. We verify the buffers are writable and if needed move the
1734 * sender address from kernel to user space.
1735 */
1736
89bddce5
SH
1737asmlinkage long sys_recvfrom(int fd, void __user *ubuf, size_t size,
1738 unsigned flags, struct sockaddr __user *addr,
1739 int __user *addr_len)
1da177e4
LT
1740{
1741 struct socket *sock;
1742 struct iovec iov;
1743 struct msghdr msg;
230b1839 1744 struct sockaddr_storage address;
89bddce5 1745 int err, err2;
6cb153ca
BL
1746 int fput_needed;
1747
de0fa95c 1748 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4 1749 if (!sock)
de0fa95c 1750 goto out;
1da177e4 1751
89bddce5
SH
1752 msg.msg_control = NULL;
1753 msg.msg_controllen = 0;
1754 msg.msg_iovlen = 1;
1755 msg.msg_iov = &iov;
1756 iov.iov_len = size;
1757 iov.iov_base = ubuf;
230b1839
YH
1758 msg.msg_name = (struct sockaddr *)&address;
1759 msg.msg_namelen = sizeof(address);
1da177e4
LT
1760 if (sock->file->f_flags & O_NONBLOCK)
1761 flags |= MSG_DONTWAIT;
89bddce5 1762 err = sock_recvmsg(sock, &msg, size, flags);
1da177e4 1763
89bddce5 1764 if (err >= 0 && addr != NULL) {
230b1839
YH
1765 err2 = move_addr_to_user((struct sockaddr *)&address,
1766 msg.msg_namelen, addr, addr_len);
89bddce5
SH
1767 if (err2 < 0)
1768 err = err2;
1da177e4 1769 }
de0fa95c
PE
1770
1771 fput_light(sock->file, fput_needed);
4387ff75 1772out:
1da177e4
LT
1773 return err;
1774}
1775
1776/*
89bddce5 1777 * Receive a datagram from a socket.
1da177e4
LT
1778 */
1779
89bddce5
SH
1780asmlinkage long sys_recv(int fd, void __user *ubuf, size_t size,
1781 unsigned flags)
1da177e4
LT
1782{
1783 return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL);
1784}
1785
1786/*
1787 * Set a socket option. Because we don't know the option lengths we have
1788 * to pass the user mode parameter for the protocols to sort out.
1789 */
1790
89bddce5
SH
1791asmlinkage long sys_setsockopt(int fd, int level, int optname,
1792 char __user *optval, int optlen)
1da177e4 1793{
6cb153ca 1794 int err, fput_needed;
1da177e4
LT
1795 struct socket *sock;
1796
1797 if (optlen < 0)
1798 return -EINVAL;
89bddce5
SH
1799
1800 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1801 if (sock != NULL) {
1802 err = security_socket_setsockopt(sock, level, optname);
6cb153ca
BL
1803 if (err)
1804 goto out_put;
1da177e4
LT
1805
1806 if (level == SOL_SOCKET)
89bddce5
SH
1807 err =
1808 sock_setsockopt(sock, level, optname, optval,
1809 optlen);
1da177e4 1810 else
89bddce5
SH
1811 err =
1812 sock->ops->setsockopt(sock, level, optname, optval,
1813 optlen);
6cb153ca
BL
1814out_put:
1815 fput_light(sock->file, fput_needed);
1da177e4
LT
1816 }
1817 return err;
1818}
1819
1820/*
1821 * Get a socket option. Because we don't know the option lengths we have
1822 * to pass a user mode parameter for the protocols to sort out.
1823 */
1824
89bddce5
SH
1825asmlinkage long sys_getsockopt(int fd, int level, int optname,
1826 char __user *optval, int __user *optlen)
1da177e4 1827{
6cb153ca 1828 int err, fput_needed;
1da177e4
LT
1829 struct socket *sock;
1830
89bddce5
SH
1831 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1832 if (sock != NULL) {
6cb153ca
BL
1833 err = security_socket_getsockopt(sock, level, optname);
1834 if (err)
1835 goto out_put;
1da177e4
LT
1836
1837 if (level == SOL_SOCKET)
89bddce5
SH
1838 err =
1839 sock_getsockopt(sock, level, optname, optval,
1840 optlen);
1da177e4 1841 else
89bddce5
SH
1842 err =
1843 sock->ops->getsockopt(sock, level, optname, optval,
1844 optlen);
6cb153ca
BL
1845out_put:
1846 fput_light(sock->file, fput_needed);
1da177e4
LT
1847 }
1848 return err;
1849}
1850
1da177e4
LT
1851/*
1852 * Shutdown a socket.
1853 */
1854
1855asmlinkage long sys_shutdown(int fd, int how)
1856{
6cb153ca 1857 int err, fput_needed;
1da177e4
LT
1858 struct socket *sock;
1859
89bddce5
SH
1860 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1861 if (sock != NULL) {
1da177e4 1862 err = security_socket_shutdown(sock, how);
6cb153ca
BL
1863 if (!err)
1864 err = sock->ops->shutdown(sock, how);
1865 fput_light(sock->file, fput_needed);
1da177e4
LT
1866 }
1867 return err;
1868}
1869
89bddce5 1870/* A couple of helpful macros for getting the address of the 32/64 bit
1da177e4
LT
1871 * fields which are the same type (int / unsigned) on our platforms.
1872 */
1873#define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member)
1874#define COMPAT_NAMELEN(msg) COMPAT_MSG(msg, msg_namelen)
1875#define COMPAT_FLAGS(msg) COMPAT_MSG(msg, msg_flags)
1876
1da177e4
LT
1877/*
1878 * BSD sendmsg interface
1879 */
1880
1881asmlinkage long sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags)
1882{
89bddce5
SH
1883 struct compat_msghdr __user *msg_compat =
1884 (struct compat_msghdr __user *)msg;
1da177e4 1885 struct socket *sock;
230b1839 1886 struct sockaddr_storage address;
1da177e4 1887 struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
b9d717a7 1888 unsigned char ctl[sizeof(struct cmsghdr) + 20]
89bddce5
SH
1889 __attribute__ ((aligned(sizeof(__kernel_size_t))));
1890 /* 20 is size of ipv6_pktinfo */
1da177e4
LT
1891 unsigned char *ctl_buf = ctl;
1892 struct msghdr msg_sys;
1893 int err, ctl_len, iov_size, total_len;
6cb153ca 1894 int fput_needed;
89bddce5 1895
1da177e4
LT
1896 err = -EFAULT;
1897 if (MSG_CMSG_COMPAT & flags) {
1898 if (get_compat_msghdr(&msg_sys, msg_compat))
1899 return -EFAULT;
89bddce5
SH
1900 }
1901 else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr)))
1da177e4
LT
1902 return -EFAULT;
1903
6cb153ca 1904 sock = sockfd_lookup_light(fd, &err, &fput_needed);
89bddce5 1905 if (!sock)
1da177e4
LT
1906 goto out;
1907
1908 /* do not move before msg_sys is valid */
1909 err = -EMSGSIZE;
1910 if (msg_sys.msg_iovlen > UIO_MAXIOV)
1911 goto out_put;
1912
89bddce5 1913 /* Check whether to allocate the iovec area */
1da177e4
LT
1914 err = -ENOMEM;
1915 iov_size = msg_sys.msg_iovlen * sizeof(struct iovec);
1916 if (msg_sys.msg_iovlen > UIO_FASTIOV) {
1917 iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
1918 if (!iov)
1919 goto out_put;
1920 }
1921
1922 /* This will also move the address data into kernel space */
1923 if (MSG_CMSG_COMPAT & flags) {
230b1839
YH
1924 err = verify_compat_iovec(&msg_sys, iov,
1925 (struct sockaddr *)&address,
1926 VERIFY_READ);
1da177e4 1927 } else
230b1839
YH
1928 err = verify_iovec(&msg_sys, iov,
1929 (struct sockaddr *)&address,
1930 VERIFY_READ);
89bddce5 1931 if (err < 0)
1da177e4
LT
1932 goto out_freeiov;
1933 total_len = err;
1934
1935 err = -ENOBUFS;
1936
1937 if (msg_sys.msg_controllen > INT_MAX)
1938 goto out_freeiov;
89bddce5 1939 ctl_len = msg_sys.msg_controllen;
1da177e4 1940 if ((MSG_CMSG_COMPAT & flags) && ctl_len) {
89bddce5
SH
1941 err =
1942 cmsghdr_from_user_compat_to_kern(&msg_sys, sock->sk, ctl,
1943 sizeof(ctl));
1da177e4
LT
1944 if (err)
1945 goto out_freeiov;
1946 ctl_buf = msg_sys.msg_control;
8920e8f9 1947 ctl_len = msg_sys.msg_controllen;
1da177e4 1948 } else if (ctl_len) {
89bddce5 1949 if (ctl_len > sizeof(ctl)) {
1da177e4 1950 ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL);
89bddce5 1951 if (ctl_buf == NULL)
1da177e4
LT
1952 goto out_freeiov;
1953 }
1954 err = -EFAULT;
1955 /*
1956 * Careful! Before this, msg_sys.msg_control contains a user pointer.
1957 * Afterwards, it will be a kernel pointer. Thus the compiler-assisted
1958 * checking falls down on this.
1959 */
89bddce5
SH
1960 if (copy_from_user(ctl_buf, (void __user *)msg_sys.msg_control,
1961 ctl_len))
1da177e4
LT
1962 goto out_freectl;
1963 msg_sys.msg_control = ctl_buf;
1964 }
1965 msg_sys.msg_flags = flags;
1966
1967 if (sock->file->f_flags & O_NONBLOCK)
1968 msg_sys.msg_flags |= MSG_DONTWAIT;
1969 err = sock_sendmsg(sock, &msg_sys, total_len);
1970
1971out_freectl:
89bddce5 1972 if (ctl_buf != ctl)
1da177e4
LT
1973 sock_kfree_s(sock->sk, ctl_buf, ctl_len);
1974out_freeiov:
1975 if (iov != iovstack)
1976 sock_kfree_s(sock->sk, iov, iov_size);
1977out_put:
6cb153ca 1978 fput_light(sock->file, fput_needed);
89bddce5 1979out:
1da177e4
LT
1980 return err;
1981}
1982
1983/*
1984 * BSD recvmsg interface
1985 */
1986
89bddce5
SH
1987asmlinkage long sys_recvmsg(int fd, struct msghdr __user *msg,
1988 unsigned int flags)
1da177e4 1989{
89bddce5
SH
1990 struct compat_msghdr __user *msg_compat =
1991 (struct compat_msghdr __user *)msg;
1da177e4
LT
1992 struct socket *sock;
1993 struct iovec iovstack[UIO_FASTIOV];
89bddce5 1994 struct iovec *iov = iovstack;
1da177e4
LT
1995 struct msghdr msg_sys;
1996 unsigned long cmsg_ptr;
1997 int err, iov_size, total_len, len;
6cb153ca 1998 int fput_needed;
1da177e4
LT
1999
2000 /* kernel mode address */
230b1839 2001 struct sockaddr_storage addr;
1da177e4
LT
2002
2003 /* user mode address pointers */
2004 struct sockaddr __user *uaddr;
2005 int __user *uaddr_len;
89bddce5 2006
1da177e4
LT
2007 if (MSG_CMSG_COMPAT & flags) {
2008 if (get_compat_msghdr(&msg_sys, msg_compat))
2009 return -EFAULT;
89bddce5
SH
2010 }
2011 else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr)))
2012 return -EFAULT;
1da177e4 2013
6cb153ca 2014 sock = sockfd_lookup_light(fd, &err, &fput_needed);
1da177e4
LT
2015 if (!sock)
2016 goto out;
2017
2018 err = -EMSGSIZE;
2019 if (msg_sys.msg_iovlen > UIO_MAXIOV)
2020 goto out_put;
89bddce5
SH
2021
2022 /* Check whether to allocate the iovec area */
1da177e4
LT
2023 err = -ENOMEM;
2024 iov_size = msg_sys.msg_iovlen * sizeof(struct iovec);
2025 if (msg_sys.msg_iovlen > UIO_FASTIOV) {
2026 iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
2027 if (!iov)
2028 goto out_put;
2029 }
2030
2031 /*
89bddce5
SH
2032 * Save the user-mode address (verify_iovec will change the
2033 * kernel msghdr to use the kernel address space)
1da177e4 2034 */
89bddce5 2035
cfcabdcc 2036 uaddr = (__force void __user *)msg_sys.msg_name;
1da177e4
LT
2037 uaddr_len = COMPAT_NAMELEN(msg);
2038 if (MSG_CMSG_COMPAT & flags) {
230b1839
YH
2039 err = verify_compat_iovec(&msg_sys, iov,
2040 (struct sockaddr *)&addr,
2041 VERIFY_WRITE);
1da177e4 2042 } else
230b1839
YH
2043 err = verify_iovec(&msg_sys, iov,
2044 (struct sockaddr *)&addr,
2045 VERIFY_WRITE);
1da177e4
LT
2046 if (err < 0)
2047 goto out_freeiov;
89bddce5 2048 total_len = err;
1da177e4
LT
2049
2050 cmsg_ptr = (unsigned long)msg_sys.msg_control;
4a19542e 2051 msg_sys.msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT);
89bddce5 2052
1da177e4
LT
2053 if (sock->file->f_flags & O_NONBLOCK)
2054 flags |= MSG_DONTWAIT;
2055 err = sock_recvmsg(sock, &msg_sys, total_len, flags);
2056 if (err < 0)
2057 goto out_freeiov;
2058 len = err;
2059
2060 if (uaddr != NULL) {
230b1839
YH
2061 err = move_addr_to_user((struct sockaddr *)&addr,
2062 msg_sys.msg_namelen, uaddr,
89bddce5 2063 uaddr_len);
1da177e4
LT
2064 if (err < 0)
2065 goto out_freeiov;
2066 }
37f7f421
DM
2067 err = __put_user((msg_sys.msg_flags & ~MSG_CMSG_COMPAT),
2068 COMPAT_FLAGS(msg));
1da177e4
LT
2069 if (err)
2070 goto out_freeiov;
2071 if (MSG_CMSG_COMPAT & flags)
89bddce5 2072 err = __put_user((unsigned long)msg_sys.msg_control - cmsg_ptr,
1da177e4
LT
2073 &msg_compat->msg_controllen);
2074 else
89bddce5 2075 err = __put_user((unsigned long)msg_sys.msg_control - cmsg_ptr,
1da177e4
LT
2076 &msg->msg_controllen);
2077 if (err)
2078 goto out_freeiov;
2079 err = len;
2080
2081out_freeiov:
2082 if (iov != iovstack)
2083 sock_kfree_s(sock->sk, iov, iov_size);
2084out_put:
6cb153ca 2085 fput_light(sock->file, fput_needed);
1da177e4
LT
2086out:
2087 return err;
2088}
2089
2090#ifdef __ARCH_WANT_SYS_SOCKETCALL
2091
2092/* Argument list sizes for sys_socketcall */
2093#define AL(x) ((x) * sizeof(unsigned long))
aaca0bdc 2094static const unsigned char nargs[19]={
89bddce5
SH
2095 AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
2096 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
aaca0bdc
UD
2097 AL(6),AL(2),AL(5),AL(5),AL(3),AL(3),
2098 AL(6)
89bddce5
SH
2099};
2100
1da177e4
LT
2101#undef AL
2102
2103/*
89bddce5 2104 * System call vectors.
1da177e4
LT
2105 *
2106 * Argument checking cleaned up. Saved 20% in size.
2107 * This function doesn't need to set the kernel lock because
89bddce5 2108 * it is set by the callees.
1da177e4
LT
2109 */
2110
2111asmlinkage long sys_socketcall(int call, unsigned long __user *args)
2112{
2113 unsigned long a[6];
89bddce5 2114 unsigned long a0, a1;
1da177e4
LT
2115 int err;
2116
aaca0bdc 2117 if (call < 1 || call > SYS_PACCEPT)
1da177e4
LT
2118 return -EINVAL;
2119
2120 /* copy_from_user should be SMP safe. */
2121 if (copy_from_user(a, args, nargs[call]))
2122 return -EFAULT;
3ec3b2fb 2123
89bddce5 2124 err = audit_socketcall(nargs[call] / sizeof(unsigned long), a);
3ec3b2fb
DW
2125 if (err)
2126 return err;
2127
89bddce5
SH
2128 a0 = a[0];
2129 a1 = a[1];
2130
2131 switch (call) {
2132 case SYS_SOCKET:
2133 err = sys_socket(a0, a1, a[2]);
2134 break;
2135 case SYS_BIND:
2136 err = sys_bind(a0, (struct sockaddr __user *)a1, a[2]);
2137 break;
2138 case SYS_CONNECT:
2139 err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
2140 break;
2141 case SYS_LISTEN:
2142 err = sys_listen(a0, a1);
2143 break;
2144 case SYS_ACCEPT:
2145 err =
aaca0bdc
UD
2146 do_accept(a0, (struct sockaddr __user *)a1,
2147 (int __user *)a[2], 0);
89bddce5
SH
2148 break;
2149 case SYS_GETSOCKNAME:
2150 err =
2151 sys_getsockname(a0, (struct sockaddr __user *)a1,
2152 (int __user *)a[2]);
2153 break;
2154 case SYS_GETPEERNAME:
2155 err =
2156 sys_getpeername(a0, (struct sockaddr __user *)a1,
2157 (int __user *)a[2]);
2158 break;
2159 case SYS_SOCKETPAIR:
2160 err = sys_socketpair(a0, a1, a[2], (int __user *)a[3]);
2161 break;
2162 case SYS_SEND:
2163 err = sys_send(a0, (void __user *)a1, a[2], a[3]);
2164 break;
2165 case SYS_SENDTO:
2166 err = sys_sendto(a0, (void __user *)a1, a[2], a[3],
2167 (struct sockaddr __user *)a[4], a[5]);
2168 break;
2169 case SYS_RECV:
2170 err = sys_recv(a0, (void __user *)a1, a[2], a[3]);
2171 break;
2172 case SYS_RECVFROM:
2173 err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
2174 (struct sockaddr __user *)a[4],
2175 (int __user *)a[5]);
2176 break;
2177 case SYS_SHUTDOWN:
2178 err = sys_shutdown(a0, a1);
2179 break;
2180 case SYS_SETSOCKOPT:
2181 err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]);
2182 break;
2183 case SYS_GETSOCKOPT:
2184 err =
2185 sys_getsockopt(a0, a1, a[2], (char __user *)a[3],
2186 (int __user *)a[4]);
2187 break;
2188 case SYS_SENDMSG:
2189 err = sys_sendmsg(a0, (struct msghdr __user *)a1, a[2]);
2190 break;
2191 case SYS_RECVMSG:
2192 err = sys_recvmsg(a0, (struct msghdr __user *)a1, a[2]);
2193 break;
aaca0bdc
UD
2194 case SYS_PACCEPT:
2195 err =
2196 sys_paccept(a0, (struct sockaddr __user *)a1,
2197 (int __user *)a[2],
2198 (const sigset_t __user *) a[3],
2199 a[4], a[5]);
2200 break;
89bddce5
SH
2201 default:
2202 err = -EINVAL;
2203 break;
1da177e4
LT
2204 }
2205 return err;
2206}
2207
89bddce5 2208#endif /* __ARCH_WANT_SYS_SOCKETCALL */
1da177e4 2209
55737fda
SH
2210/**
2211 * sock_register - add a socket protocol handler
2212 * @ops: description of protocol
2213 *
1da177e4
LT
2214 * This function is called by a protocol handler that wants to
2215 * advertise its address family, and have it linked into the
55737fda
SH
2216 * socket interface. The value ops->family coresponds to the
2217 * socket system call protocol family.
1da177e4 2218 */
f0fd27d4 2219int sock_register(const struct net_proto_family *ops)
1da177e4
LT
2220{
2221 int err;
2222
2223 if (ops->family >= NPROTO) {
89bddce5
SH
2224 printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family,
2225 NPROTO);
1da177e4
LT
2226 return -ENOBUFS;
2227 }
55737fda
SH
2228
2229 spin_lock(&net_family_lock);
2230 if (net_families[ops->family])
2231 err = -EEXIST;
2232 else {
89bddce5 2233 net_families[ops->family] = ops;
1da177e4
LT
2234 err = 0;
2235 }
55737fda
SH
2236 spin_unlock(&net_family_lock);
2237
89bddce5 2238 printk(KERN_INFO "NET: Registered protocol family %d\n", ops->family);
1da177e4
LT
2239 return err;
2240}
2241
55737fda
SH
2242/**
2243 * sock_unregister - remove a protocol handler
2244 * @family: protocol family to remove
2245 *
1da177e4
LT
2246 * This function is called by a protocol handler that wants to
2247 * remove its address family, and have it unlinked from the
55737fda
SH
2248 * new socket creation.
2249 *
2250 * If protocol handler is a module, then it can use module reference
2251 * counts to protect against new references. If protocol handler is not
2252 * a module then it needs to provide its own protection in
2253 * the ops->create routine.
1da177e4 2254 */
f0fd27d4 2255void sock_unregister(int family)
1da177e4 2256{
f0fd27d4 2257 BUG_ON(family < 0 || family >= NPROTO);
1da177e4 2258
55737fda 2259 spin_lock(&net_family_lock);
89bddce5 2260 net_families[family] = NULL;
55737fda
SH
2261 spin_unlock(&net_family_lock);
2262
2263 synchronize_rcu();
2264
89bddce5 2265 printk(KERN_INFO "NET: Unregistered protocol family %d\n", family);
1da177e4
LT
2266}
2267
77d76ea3 2268static int __init sock_init(void)
1da177e4
LT
2269{
2270 /*
89bddce5 2271 * Initialize sock SLAB cache.
1da177e4 2272 */
89bddce5 2273
1da177e4
LT
2274 sk_init();
2275
1da177e4 2276 /*
89bddce5 2277 * Initialize skbuff SLAB cache
1da177e4
LT
2278 */
2279 skb_init();
1da177e4
LT
2280
2281 /*
89bddce5 2282 * Initialize the protocols module.
1da177e4
LT
2283 */
2284
2285 init_inodecache();
2286 register_filesystem(&sock_fs_type);
2287 sock_mnt = kern_mount(&sock_fs_type);
77d76ea3
AK
2288
2289 /* The real protocol initialization is performed in later initcalls.
1da177e4
LT
2290 */
2291
2292#ifdef CONFIG_NETFILTER
2293 netfilter_init();
2294#endif
cbeb321a
DM
2295
2296 return 0;
1da177e4
LT
2297}
2298
77d76ea3
AK
2299core_initcall(sock_init); /* early initcall */
2300
1da177e4
LT
2301#ifdef CONFIG_PROC_FS
2302void socket_seq_show(struct seq_file *seq)
2303{
2304 int cpu;
2305 int counter = 0;
2306
6f912042 2307 for_each_possible_cpu(cpu)
89bddce5 2308 counter += per_cpu(sockets_in_use, cpu);
1da177e4
LT
2309
2310 /* It can be negative, by the way. 8) */
2311 if (counter < 0)
2312 counter = 0;
2313
2314 seq_printf(seq, "sockets: used %d\n", counter);
2315}
89bddce5 2316#endif /* CONFIG_PROC_FS */
1da177e4 2317
89bbfc95
SP
2318#ifdef CONFIG_COMPAT
2319static long compat_sock_ioctl(struct file *file, unsigned cmd,
89bddce5 2320 unsigned long arg)
89bbfc95
SP
2321{
2322 struct socket *sock = file->private_data;
2323 int ret = -ENOIOCTLCMD;
87de87d5
DM
2324 struct sock *sk;
2325 struct net *net;
2326
2327 sk = sock->sk;
2328 net = sock_net(sk);
89bbfc95
SP
2329
2330 if (sock->ops->compat_ioctl)
2331 ret = sock->ops->compat_ioctl(sock, cmd, arg);
2332
87de87d5
DM
2333 if (ret == -ENOIOCTLCMD &&
2334 (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST))
2335 ret = compat_wext_handle_ioctl(net, cmd, arg);
2336
89bbfc95
SP
2337 return ret;
2338}
2339#endif
2340
ac5a488e
SS
2341int kernel_bind(struct socket *sock, struct sockaddr *addr, int addrlen)
2342{
2343 return sock->ops->bind(sock, addr, addrlen);
2344}
2345
2346int kernel_listen(struct socket *sock, int backlog)
2347{
2348 return sock->ops->listen(sock, backlog);
2349}
2350
2351int kernel_accept(struct socket *sock, struct socket **newsock, int flags)
2352{
2353 struct sock *sk = sock->sk;
2354 int err;
2355
2356 err = sock_create_lite(sk->sk_family, sk->sk_type, sk->sk_protocol,
2357 newsock);
2358 if (err < 0)
2359 goto done;
2360
2361 err = sock->ops->accept(sock, *newsock, flags);
2362 if (err < 0) {
2363 sock_release(*newsock);
fa8705b0 2364 *newsock = NULL;
ac5a488e
SS
2365 goto done;
2366 }
2367
2368 (*newsock)->ops = sock->ops;
2369
2370done:
2371 return err;
2372}
2373
2374int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen,
4768fbcb 2375 int flags)
ac5a488e
SS
2376{
2377 return sock->ops->connect(sock, addr, addrlen, flags);
2378}
2379
2380int kernel_getsockname(struct socket *sock, struct sockaddr *addr,
2381 int *addrlen)
2382{
2383 return sock->ops->getname(sock, addr, addrlen, 0);
2384}
2385
2386int kernel_getpeername(struct socket *sock, struct sockaddr *addr,
2387 int *addrlen)
2388{
2389 return sock->ops->getname(sock, addr, addrlen, 1);
2390}
2391
2392int kernel_getsockopt(struct socket *sock, int level, int optname,
2393 char *optval, int *optlen)
2394{
2395 mm_segment_t oldfs = get_fs();
2396 int err;
2397
2398 set_fs(KERNEL_DS);
2399 if (level == SOL_SOCKET)
2400 err = sock_getsockopt(sock, level, optname, optval, optlen);
2401 else
2402 err = sock->ops->getsockopt(sock, level, optname, optval,
2403 optlen);
2404 set_fs(oldfs);
2405 return err;
2406}
2407
2408int kernel_setsockopt(struct socket *sock, int level, int optname,
2409 char *optval, int optlen)
2410{
2411 mm_segment_t oldfs = get_fs();
2412 int err;
2413
2414 set_fs(KERNEL_DS);
2415 if (level == SOL_SOCKET)
2416 err = sock_setsockopt(sock, level, optname, optval, optlen);
2417 else
2418 err = sock->ops->setsockopt(sock, level, optname, optval,
2419 optlen);
2420 set_fs(oldfs);
2421 return err;
2422}
2423
2424int kernel_sendpage(struct socket *sock, struct page *page, int offset,
2425 size_t size, int flags)
2426{
2427 if (sock->ops->sendpage)
2428 return sock->ops->sendpage(sock, page, offset, size, flags);
2429
2430 return sock_no_sendpage(sock, page, offset, size, flags);
2431}
2432
2433int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg)
2434{
2435 mm_segment_t oldfs = get_fs();
2436 int err;
2437
2438 set_fs(KERNEL_DS);
2439 err = sock->ops->ioctl(sock, cmd, arg);
2440 set_fs(oldfs);
2441
2442 return err;
2443}
2444
91cf45f0
TM
2445int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how)
2446{
2447 return sock->ops->shutdown(sock, how);
2448}
2449
1da177e4
LT
2450EXPORT_SYMBOL(sock_create);
2451EXPORT_SYMBOL(sock_create_kern);
2452EXPORT_SYMBOL(sock_create_lite);
2453EXPORT_SYMBOL(sock_map_fd);
2454EXPORT_SYMBOL(sock_recvmsg);
2455EXPORT_SYMBOL(sock_register);
2456EXPORT_SYMBOL(sock_release);
2457EXPORT_SYMBOL(sock_sendmsg);
2458EXPORT_SYMBOL(sock_unregister);
2459EXPORT_SYMBOL(sock_wake_async);
2460EXPORT_SYMBOL(sockfd_lookup);
2461EXPORT_SYMBOL(kernel_sendmsg);
2462EXPORT_SYMBOL(kernel_recvmsg);
ac5a488e
SS
2463EXPORT_SYMBOL(kernel_bind);
2464EXPORT_SYMBOL(kernel_listen);
2465EXPORT_SYMBOL(kernel_accept);
2466EXPORT_SYMBOL(kernel_connect);
2467EXPORT_SYMBOL(kernel_getsockname);
2468EXPORT_SYMBOL(kernel_getpeername);
2469EXPORT_SYMBOL(kernel_getsockopt);
2470EXPORT_SYMBOL(kernel_setsockopt);
2471EXPORT_SYMBOL(kernel_sendpage);
2472EXPORT_SYMBOL(kernel_sock_ioctl);
91cf45f0 2473EXPORT_SYMBOL(kernel_sock_shutdown);