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