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>
7 * Ross Biro, <bir7@leland.Stanford.Edu>
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)
45 * Tigran Aivazian : Made listen(2) backlog sanity checks
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
56 * paradigm.
57 *
58 * Based upon Swansea University Computer Society NET3.039
59 */
60
61 #include <linux/config.h>
62 #include <linux/mm.h>
63 #include <linux/smp_lock.h>
64 #include <linux/socket.h>
65 #include <linux/file.h>
66 #include <linux/net.h>
67 #include <linux/interrupt.h>
68 #include <linux/netdevice.h>
69 #include <linux/proc_fs.h>
70 #include <linux/seq_file.h>
71 #include <linux/wanrouter.h>
72 #include <linux/if_bridge.h>
73 #include <linux/init.h>
74 #include <linux/poll.h>
75 #include <linux/cache.h>
76 #include <linux/module.h>
77 #include <linux/highmem.h>
78 #include <linux/divert.h>
79 #include <linux/mount.h>
80 #include <linux/security.h>
81 #include <linux/syscalls.h>
82 #include <linux/compat.h>
83 #include <linux/kmod.h>
84
85 #ifdef CONFIG_NET_RADIO
86 #include <linux/wireless.h> /* Note : will define WIRELESS_EXT */
87 #endif /* CONFIG_NET_RADIO */
88
89 #include <asm/uaccess.h>
90 #include <asm/unistd.h>
91
92 #include <net/compat.h>
93
94 #include <net/sock.h>
95 #include <linux/netfilter.h>
96
97 static int sock_no_open(struct inode *irrelevant, struct file *dontcare);
98 static ssize_t sock_aio_read(struct kiocb *iocb, char __user *buf,
99 size_t size, loff_t pos);
100 static ssize_t sock_aio_write(struct kiocb *iocb, const char __user *buf,
101 size_t size, loff_t pos);
102 static int sock_mmap(struct file *file, struct vm_area_struct * vma);
103
104 static int sock_close(struct inode *inode, struct file *file);
105 static unsigned int sock_poll(struct file *file,
106 struct poll_table_struct *wait);
107 static long sock_ioctl(struct file *file,
108 unsigned int cmd, unsigned long arg);
109 static int sock_fasync(int fd, struct file *filp, int on);
110 static ssize_t sock_readv(struct file *file, const struct iovec *vector,
111 unsigned long count, loff_t *ppos);
112 static ssize_t sock_writev(struct file *file, const struct iovec *vector,
113 unsigned long count, loff_t *ppos);
114 static ssize_t sock_sendpage(struct file *file, struct page *page,
115 int offset, size_t size, loff_t *ppos, int more);
116
117
118 /*
119 * Socket files have a set of 'special' operations as well as the generic file ones. These don't appear
120 * in the operation structures but are done directly via the socketcall() multiplexor.
121 */
122
123 static struct file_operations socket_file_ops = {
124 .owner = THIS_MODULE,
125 .llseek = no_llseek,
126 .aio_read = sock_aio_read,
127 .aio_write = sock_aio_write,
128 .poll = sock_poll,
129 .unlocked_ioctl = sock_ioctl,
130 .mmap = sock_mmap,
131 .open = sock_no_open, /* special open code to disallow open via /proc */
132 .release = sock_close,
133 .fasync = sock_fasync,
134 .readv = sock_readv,
135 .writev = sock_writev,
136 .sendpage = sock_sendpage
137 };
138
139 /*
140 * The protocol list. Each protocol is registered in here.
141 */
142
143 static struct net_proto_family *net_families[NPROTO];
144
145 #if defined(CONFIG_SMP) || defined(CONFIG_PREEMPT)
146 static atomic_t net_family_lockct = ATOMIC_INIT(0);
147 static DEFINE_SPINLOCK(net_family_lock);
148
149 /* The strategy is: modifications net_family vector are short, do not
150 sleep and veeery rare, but read access should be free of any exclusive
151 locks.
152 */
153
154 static void net_family_write_lock(void)
155 {
156 spin_lock(&net_family_lock);
157 while (atomic_read(&net_family_lockct) != 0) {
158 spin_unlock(&net_family_lock);
159
160 yield();
161
162 spin_lock(&net_family_lock);
163 }
164 }
165
166 static __inline__ void net_family_write_unlock(void)
167 {
168 spin_unlock(&net_family_lock);
169 }
170
171 static __inline__ void net_family_read_lock(void)
172 {
173 atomic_inc(&net_family_lockct);
174 spin_unlock_wait(&net_family_lock);
175 }
176
177 static __inline__ void net_family_read_unlock(void)
178 {
179 atomic_dec(&net_family_lockct);
180 }
181
182 #else
183 #define net_family_write_lock() do { } while(0)
184 #define net_family_write_unlock() do { } while(0)
185 #define net_family_read_lock() do { } while(0)
186 #define net_family_read_unlock() do { } while(0)
187 #endif
188
189
190 /*
191 * Statistics counters of the socket lists
192 */
193
194 static DEFINE_PER_CPU(int, sockets_in_use) = 0;
195
196 /*
197 * Support routines. Move socket addresses back and forth across the kernel/user
198 * divide and look after the messy bits.
199 */
200
201 #define MAX_SOCK_ADDR 128 /* 108 for Unix domain -
202 16 for IP, 16 for IPX,
203 24 for IPv6,
204 about 80 for AX.25
205 must be at least one bigger than
206 the AF_UNIX size (see net/unix/af_unix.c
207 :unix_mkname()).
208 */
209
210 /**
211 * move_addr_to_kernel - copy a socket address into kernel space
212 * @uaddr: Address in user space
213 * @kaddr: Address in kernel space
214 * @ulen: Length in user space
215 *
216 * The address is copied into kernel space. If the provided address is
217 * too long an error code of -EINVAL is returned. If the copy gives
218 * invalid addresses -EFAULT is returned. On a success 0 is returned.
219 */
220
221 int move_addr_to_kernel(void __user *uaddr, int ulen, void *kaddr)
222 {
223 if(ulen<0||ulen>MAX_SOCK_ADDR)
224 return -EINVAL;
225 if(ulen==0)
226 return 0;
227 if(copy_from_user(kaddr,uaddr,ulen))
228 return -EFAULT;
229 return 0;
230 }
231
232 /**
233 * move_addr_to_user - copy an address to user space
234 * @kaddr: kernel space address
235 * @klen: length of address in kernel
236 * @uaddr: user space address
237 * @ulen: pointer to user length field
238 *
239 * The value pointed to by ulen on entry is the buffer length available.
240 * This is overwritten with the buffer space used. -EINVAL is returned
241 * if an overlong buffer is specified or a negative buffer size. -EFAULT
242 * is returned if either the buffer or the length field are not
243 * accessible.
244 * After copying the data up to the limit the user specifies, the true
245 * length of the data is written over the length limit the user
246 * specified. Zero is returned for a success.
247 */
248
249 int move_addr_to_user(void *kaddr, int klen, void __user *uaddr, int __user *ulen)
250 {
251 int err;
252 int len;
253
254 if((err=get_user(len, ulen)))
255 return err;
256 if(len>klen)
257 len=klen;
258 if(len<0 || len> MAX_SOCK_ADDR)
259 return -EINVAL;
260 if(len)
261 {
262 if(copy_to_user(uaddr,kaddr,len))
263 return -EFAULT;
264 }
265 /*
266 * "fromlen shall refer to the value before truncation.."
267 * 1003.1g
268 */
269 return __put_user(klen, ulen);
270 }
271
272 #define SOCKFS_MAGIC 0x534F434B
273
274 static kmem_cache_t * sock_inode_cachep;
275
276 static struct inode *sock_alloc_inode(struct super_block *sb)
277 {
278 struct socket_alloc *ei;
279 ei = (struct socket_alloc *)kmem_cache_alloc(sock_inode_cachep, SLAB_KERNEL);
280 if (!ei)
281 return NULL;
282 init_waitqueue_head(&ei->socket.wait);
283
284 ei->socket.fasync_list = NULL;
285 ei->socket.state = SS_UNCONNECTED;
286 ei->socket.flags = 0;
287 ei->socket.ops = NULL;
288 ei->socket.sk = NULL;
289 ei->socket.file = NULL;
290 ei->socket.passcred = 0;
291
292 return &ei->vfs_inode;
293 }
294
295 static void sock_destroy_inode(struct inode *inode)
296 {
297 kmem_cache_free(sock_inode_cachep,
298 container_of(inode, struct socket_alloc, vfs_inode));
299 }
300
301 static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
302 {
303 struct socket_alloc *ei = (struct socket_alloc *) foo;
304
305 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
306 SLAB_CTOR_CONSTRUCTOR)
307 inode_init_once(&ei->vfs_inode);
308 }
309
310 static int init_inodecache(void)
311 {
312 sock_inode_cachep = kmem_cache_create("sock_inode_cache",
313 sizeof(struct socket_alloc),
314 0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT,
315 init_once, NULL);
316 if (sock_inode_cachep == NULL)
317 return -ENOMEM;
318 return 0;
319 }
320
321 static struct super_operations sockfs_ops = {
322 .alloc_inode = sock_alloc_inode,
323 .destroy_inode =sock_destroy_inode,
324 .statfs = simple_statfs,
325 };
326
327 static struct super_block *sockfs_get_sb(struct file_system_type *fs_type,
328 int flags, const char *dev_name, void *data)
329 {
330 return get_sb_pseudo(fs_type, "socket:", &sockfs_ops, SOCKFS_MAGIC);
331 }
332
333 static struct vfsmount *sock_mnt;
334
335 static struct file_system_type sock_fs_type = {
336 .name = "sockfs",
337 .get_sb = sockfs_get_sb,
338 .kill_sb = kill_anon_super,
339 };
340 static int sockfs_delete_dentry(struct dentry *dentry)
341 {
342 return 1;
343 }
344 static struct dentry_operations sockfs_dentry_operations = {
345 .d_delete = sockfs_delete_dentry,
346 };
347
348 /*
349 * Obtains the first available file descriptor and sets it up for use.
350 *
351 * This function creates file structure and maps it to fd space
352 * of current process. On success it returns file descriptor
353 * and file struct implicitly stored in sock->file.
354 * Note that another thread may close file descriptor before we return
355 * from this function. We use the fact that now we do not refer
356 * to socket after mapping. If one day we will need it, this
357 * function will increment ref. count on file by 1.
358 *
359 * In any case returned fd MAY BE not valid!
360 * This race condition is unavoidable
361 * with shared fd spaces, we cannot solve it inside kernel,
362 * but we take care of internal coherence yet.
363 */
364
365 int sock_map_fd(struct socket *sock)
366 {
367 int fd;
368 struct qstr this;
369 char name[32];
370
371 /*
372 * Find a file descriptor suitable for return to the user.
373 */
374
375 fd = get_unused_fd();
376 if (fd >= 0) {
377 struct file *file = get_empty_filp();
378
379 if (!file) {
380 put_unused_fd(fd);
381 fd = -ENFILE;
382 goto out;
383 }
384
385 sprintf(name, "[%lu]", SOCK_INODE(sock)->i_ino);
386 this.name = name;
387 this.len = strlen(name);
388 this.hash = SOCK_INODE(sock)->i_ino;
389
390 file->f_dentry = d_alloc(sock_mnt->mnt_sb->s_root, &this);
391 if (!file->f_dentry) {
392 put_filp(file);
393 put_unused_fd(fd);
394 fd = -ENOMEM;
395 goto out;
396 }
397 file->f_dentry->d_op = &sockfs_dentry_operations;
398 d_add(file->f_dentry, SOCK_INODE(sock));
399 file->f_vfsmnt = mntget(sock_mnt);
400 file->f_mapping = file->f_dentry->d_inode->i_mapping;
401
402 sock->file = file;
403 file->f_op = SOCK_INODE(sock)->i_fop = &socket_file_ops;
404 file->f_mode = FMODE_READ | FMODE_WRITE;
405 file->f_flags = O_RDWR;
406 file->f_pos = 0;
407 fd_install(fd, file);
408 }
409
410 out:
411 return fd;
412 }
413
414 /**
415 * sockfd_lookup - Go from a file number to its socket slot
416 * @fd: file handle
417 * @err: pointer to an error code return
418 *
419 * The file handle passed in is locked and the socket it is bound
420 * too is returned. If an error occurs the err pointer is overwritten
421 * with a negative errno code and NULL is returned. The function checks
422 * for both invalid handles and passing a handle which is not a socket.
423 *
424 * On a success the socket object pointer is returned.
425 */
426
427 struct socket *sockfd_lookup(int fd, int *err)
428 {
429 struct file *file;
430 struct inode *inode;
431 struct socket *sock;
432
433 if (!(file = fget(fd)))
434 {
435 *err = -EBADF;
436 return NULL;
437 }
438
439 inode = file->f_dentry->d_inode;
440 if (!inode->i_sock || !(sock = SOCKET_I(inode)))
441 {
442 *err = -ENOTSOCK;
443 fput(file);
444 return NULL;
445 }
446
447 if (sock->file != file) {
448 printk(KERN_ERR "socki_lookup: socket file changed!\n");
449 sock->file = file;
450 }
451 return sock;
452 }
453
454 /**
455 * sock_alloc - allocate a socket
456 *
457 * Allocate a new inode and socket object. The two are bound together
458 * and initialised. The socket is then returned. If we are out of inodes
459 * NULL is returned.
460 */
461
462 static struct socket *sock_alloc(void)
463 {
464 struct inode * inode;
465 struct socket * sock;
466
467 inode = new_inode(sock_mnt->mnt_sb);
468 if (!inode)
469 return NULL;
470
471 sock = SOCKET_I(inode);
472
473 inode->i_mode = S_IFSOCK|S_IRWXUGO;
474 inode->i_sock = 1;
475 inode->i_uid = current->fsuid;
476 inode->i_gid = current->fsgid;
477
478 get_cpu_var(sockets_in_use)++;
479 put_cpu_var(sockets_in_use);
480 return sock;
481 }
482
483 /*
484 * In theory you can't get an open on this inode, but /proc provides
485 * a back door. Remember to keep it shut otherwise you'll let the
486 * creepy crawlies in.
487 */
488
489 static int sock_no_open(struct inode *irrelevant, struct file *dontcare)
490 {
491 return -ENXIO;
492 }
493
494 struct file_operations bad_sock_fops = {
495 .owner = THIS_MODULE,
496 .open = sock_no_open,
497 };
498
499 /**
500 * sock_release - close a socket
501 * @sock: socket to close
502 *
503 * The socket is released from the protocol stack if it has a release
504 * callback, and the inode is then released if the socket is bound to
505 * an inode not a file.
506 */
507
508 void sock_release(struct socket *sock)
509 {
510 if (sock->ops) {
511 struct module *owner = sock->ops->owner;
512
513 sock->ops->release(sock);
514 sock->ops = NULL;
515 module_put(owner);
516 }
517
518 if (sock->fasync_list)
519 printk(KERN_ERR "sock_release: fasync list not empty!\n");
520
521 get_cpu_var(sockets_in_use)--;
522 put_cpu_var(sockets_in_use);
523 if (!sock->file) {
524 iput(SOCK_INODE(sock));
525 return;
526 }
527 sock->file=NULL;
528 }
529
530 static inline int __sock_sendmsg(struct kiocb *iocb, struct socket *sock,
531 struct msghdr *msg, size_t size)
532 {
533 struct sock_iocb *si = kiocb_to_siocb(iocb);
534 int err;
535
536 si->sock = sock;
537 si->scm = NULL;
538 si->msg = msg;
539 si->size = size;
540
541 err = security_socket_sendmsg(sock, msg, size);
542 if (err)
543 return err;
544
545 return sock->ops->sendmsg(iocb, sock, msg, size);
546 }
547
548 int sock_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
549 {
550 struct kiocb iocb;
551 struct sock_iocb siocb;
552 int ret;
553
554 init_sync_kiocb(&iocb, NULL);
555 iocb.private = &siocb;
556 ret = __sock_sendmsg(&iocb, sock, msg, size);
557 if (-EIOCBQUEUED == ret)
558 ret = wait_on_sync_kiocb(&iocb);
559 return ret;
560 }
561
562 int kernel_sendmsg(struct socket *sock, struct msghdr *msg,
563 struct kvec *vec, size_t num, size_t size)
564 {
565 mm_segment_t oldfs = get_fs();
566 int result;
567
568 set_fs(KERNEL_DS);
569 /*
570 * the following is safe, since for compiler definitions of kvec and
571 * iovec are identical, yielding the same in-core layout and alignment
572 */
573 msg->msg_iov = (struct iovec *)vec,
574 msg->msg_iovlen = num;
575 result = sock_sendmsg(sock, msg, size);
576 set_fs(oldfs);
577 return result;
578 }
579
580 static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock,
581 struct msghdr *msg, size_t size, int flags)
582 {
583 int err;
584 struct sock_iocb *si = kiocb_to_siocb(iocb);
585
586 si->sock = sock;
587 si->scm = NULL;
588 si->msg = msg;
589 si->size = size;
590 si->flags = flags;
591
592 err = security_socket_recvmsg(sock, msg, size, flags);
593 if (err)
594 return err;
595
596 return sock->ops->recvmsg(iocb, sock, msg, size, flags);
597 }
598
599 int sock_recvmsg(struct socket *sock, struct msghdr *msg,
600 size_t size, int flags)
601 {
602 struct kiocb iocb;
603 struct sock_iocb siocb;
604 int ret;
605
606 init_sync_kiocb(&iocb, NULL);
607 iocb.private = &siocb;
608 ret = __sock_recvmsg(&iocb, sock, msg, size, flags);
609 if (-EIOCBQUEUED == ret)
610 ret = wait_on_sync_kiocb(&iocb);
611 return ret;
612 }
613
614 int kernel_recvmsg(struct socket *sock, struct msghdr *msg,
615 struct kvec *vec, size_t num,
616 size_t size, int flags)
617 {
618 mm_segment_t oldfs = get_fs();
619 int result;
620
621 set_fs(KERNEL_DS);
622 /*
623 * the following is safe, since for compiler definitions of kvec and
624 * iovec are identical, yielding the same in-core layout and alignment
625 */
626 msg->msg_iov = (struct iovec *)vec,
627 msg->msg_iovlen = num;
628 result = sock_recvmsg(sock, msg, size, flags);
629 set_fs(oldfs);
630 return result;
631 }
632
633 static void sock_aio_dtor(struct kiocb *iocb)
634 {
635 kfree(iocb->private);
636 }
637
638 /*
639 * Read data from a socket. ubuf is a user mode pointer. We make sure the user
640 * area ubuf...ubuf+size-1 is writable before asking the protocol.
641 */
642
643 static ssize_t sock_aio_read(struct kiocb *iocb, char __user *ubuf,
644 size_t size, loff_t pos)
645 {
646 struct sock_iocb *x, siocb;
647 struct socket *sock;
648 int flags;
649
650 if (pos != 0)
651 return -ESPIPE;
652 if (size==0) /* Match SYS5 behaviour */
653 return 0;
654
655 if (is_sync_kiocb(iocb))
656 x = &siocb;
657 else {
658 x = kmalloc(sizeof(struct sock_iocb), GFP_KERNEL);
659 if (!x)
660 return -ENOMEM;
661 iocb->ki_dtor = sock_aio_dtor;
662 }
663 iocb->private = x;
664 x->kiocb = iocb;
665 sock = SOCKET_I(iocb->ki_filp->f_dentry->d_inode);
666
667 x->async_msg.msg_name = NULL;
668 x->async_msg.msg_namelen = 0;
669 x->async_msg.msg_iov = &x->async_iov;
670 x->async_msg.msg_iovlen = 1;
671 x->async_msg.msg_control = NULL;
672 x->async_msg.msg_controllen = 0;
673 x->async_iov.iov_base = ubuf;
674 x->async_iov.iov_len = size;
675 flags = !(iocb->ki_filp->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT;
676
677 return __sock_recvmsg(iocb, sock, &x->async_msg, size, flags);
678 }
679
680
681 /*
682 * Write data to a socket. We verify that the user area ubuf..ubuf+size-1
683 * is readable by the user process.
684 */
685
686 static ssize_t sock_aio_write(struct kiocb *iocb, const char __user *ubuf,
687 size_t size, loff_t pos)
688 {
689 struct sock_iocb *x, siocb;
690 struct socket *sock;
691
692 if (pos != 0)
693 return -ESPIPE;
694 if(size==0) /* Match SYS5 behaviour */
695 return 0;
696
697 if (is_sync_kiocb(iocb))
698 x = &siocb;
699 else {
700 x = kmalloc(sizeof(struct sock_iocb), GFP_KERNEL);
701 if (!x)
702 return -ENOMEM;
703 iocb->ki_dtor = sock_aio_dtor;
704 }
705 iocb->private = x;
706 x->kiocb = iocb;
707 sock = SOCKET_I(iocb->ki_filp->f_dentry->d_inode);
708
709 x->async_msg.msg_name = NULL;
710 x->async_msg.msg_namelen = 0;
711 x->async_msg.msg_iov = &x->async_iov;
712 x->async_msg.msg_iovlen = 1;
713 x->async_msg.msg_control = NULL;
714 x->async_msg.msg_controllen = 0;
715 x->async_msg.msg_flags = !(iocb->ki_filp->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT;
716 if (sock->type == SOCK_SEQPACKET)
717 x->async_msg.msg_flags |= MSG_EOR;
718 x->async_iov.iov_base = (void __user *)ubuf;
719 x->async_iov.iov_len = size;
720
721 return __sock_sendmsg(iocb, sock, &x->async_msg, size);
722 }
723
724 ssize_t sock_sendpage(struct file *file, struct page *page,
725 int offset, size_t size, loff_t *ppos, int more)
726 {
727 struct socket *sock;
728 int flags;
729
730 sock = SOCKET_I(file->f_dentry->d_inode);
731
732 flags = !(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT;
733 if (more)
734 flags |= MSG_MORE;
735
736 return sock->ops->sendpage(sock, page, offset, size, flags);
737 }
738
739 static int sock_readv_writev(int type, struct inode * inode,
740 struct file * file, const struct iovec * iov,
741 long count, size_t size)
742 {
743 struct msghdr msg;
744 struct socket *sock;
745
746 sock = SOCKET_I(inode);
747
748 msg.msg_name = NULL;
749 msg.msg_namelen = 0;
750 msg.msg_control = NULL;
751 msg.msg_controllen = 0;
752 msg.msg_iov = (struct iovec *) iov;
753 msg.msg_iovlen = count;
754 msg.msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
755
756 /* read() does a VERIFY_WRITE */
757 if (type == VERIFY_WRITE)
758 return sock_recvmsg(sock, &msg, size, msg.msg_flags);
759
760 if (sock->type == SOCK_SEQPACKET)
761 msg.msg_flags |= MSG_EOR;
762
763 return sock_sendmsg(sock, &msg, size);
764 }
765
766 static ssize_t sock_readv(struct file *file, const struct iovec *vector,
767 unsigned long count, loff_t *ppos)
768 {
769 size_t tot_len = 0;
770 int i;
771 for (i = 0 ; i < count ; i++)
772 tot_len += vector[i].iov_len;
773 return sock_readv_writev(VERIFY_WRITE, file->f_dentry->d_inode,
774 file, vector, count, tot_len);
775 }
776
777 static ssize_t sock_writev(struct file *file, const struct iovec *vector,
778 unsigned long count, loff_t *ppos)
779 {
780 size_t tot_len = 0;
781 int i;
782 for (i = 0 ; i < count ; i++)
783 tot_len += vector[i].iov_len;
784 return sock_readv_writev(VERIFY_READ, file->f_dentry->d_inode,
785 file, vector, count, tot_len);
786 }
787
788
789 /*
790 * Atomic setting of ioctl hooks to avoid race
791 * with module unload.
792 */
793
794 static DECLARE_MUTEX(br_ioctl_mutex);
795 static int (*br_ioctl_hook)(unsigned int cmd, void __user *arg) = NULL;
796
797 void brioctl_set(int (*hook)(unsigned int, void __user *))
798 {
799 down(&br_ioctl_mutex);
800 br_ioctl_hook = hook;
801 up(&br_ioctl_mutex);
802 }
803 EXPORT_SYMBOL(brioctl_set);
804
805 static DECLARE_MUTEX(vlan_ioctl_mutex);
806 static int (*vlan_ioctl_hook)(void __user *arg);
807
808 void vlan_ioctl_set(int (*hook)(void __user *))
809 {
810 down(&vlan_ioctl_mutex);
811 vlan_ioctl_hook = hook;
812 up(&vlan_ioctl_mutex);
813 }
814 EXPORT_SYMBOL(vlan_ioctl_set);
815
816 static DECLARE_MUTEX(dlci_ioctl_mutex);
817 static int (*dlci_ioctl_hook)(unsigned int, void __user *);
818
819 void dlci_ioctl_set(int (*hook)(unsigned int, void __user *))
820 {
821 down(&dlci_ioctl_mutex);
822 dlci_ioctl_hook = hook;
823 up(&dlci_ioctl_mutex);
824 }
825 EXPORT_SYMBOL(dlci_ioctl_set);
826
827 /*
828 * With an ioctl, arg may well be a user mode pointer, but we don't know
829 * what to do with it - that's up to the protocol still.
830 */
831
832 static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
833 {
834 struct socket *sock;
835 void __user *argp = (void __user *)arg;
836 int pid, err;
837
838 sock = SOCKET_I(file->f_dentry->d_inode);
839 if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) {
840 err = dev_ioctl(cmd, argp);
841 } else
842 #ifdef WIRELESS_EXT
843 if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {
844 err = dev_ioctl(cmd, argp);
845 } else
846 #endif /* WIRELESS_EXT */
847 switch (cmd) {
848 case FIOSETOWN:
849 case SIOCSPGRP:
850 err = -EFAULT;
851 if (get_user(pid, (int __user *)argp))
852 break;
853 err = f_setown(sock->file, pid, 1);
854 break;
855 case FIOGETOWN:
856 case SIOCGPGRP:
857 err = put_user(sock->file->f_owner.pid, (int __user *)argp);
858 break;
859 case SIOCGIFBR:
860 case SIOCSIFBR:
861 case SIOCBRADDBR:
862 case SIOCBRDELBR:
863 err = -ENOPKG;
864 if (!br_ioctl_hook)
865 request_module("bridge");
866
867 down(&br_ioctl_mutex);
868 if (br_ioctl_hook)
869 err = br_ioctl_hook(cmd, argp);
870 up(&br_ioctl_mutex);
871 break;
872 case SIOCGIFVLAN:
873 case SIOCSIFVLAN:
874 err = -ENOPKG;
875 if (!vlan_ioctl_hook)
876 request_module("8021q");
877
878 down(&vlan_ioctl_mutex);
879 if (vlan_ioctl_hook)
880 err = vlan_ioctl_hook(argp);
881 up(&vlan_ioctl_mutex);
882 break;
883 case SIOCGIFDIVERT:
884 case SIOCSIFDIVERT:
885 /* Convert this to call through a hook */
886 err = divert_ioctl(cmd, argp);
887 break;
888 case SIOCADDDLCI:
889 case SIOCDELDLCI:
890 err = -ENOPKG;
891 if (!dlci_ioctl_hook)
892 request_module("dlci");
893
894 if (dlci_ioctl_hook) {
895 down(&dlci_ioctl_mutex);
896 err = dlci_ioctl_hook(cmd, argp);
897 up(&dlci_ioctl_mutex);
898 }
899 break;
900 default:
901 err = sock->ops->ioctl(sock, cmd, arg);
902 break;
903 }
904 return err;
905 }
906
907 int sock_create_lite(int family, int type, int protocol, struct socket **res)
908 {
909 int err;
910 struct socket *sock = NULL;
911
912 err = security_socket_create(family, type, protocol, 1);
913 if (err)
914 goto out;
915
916 sock = sock_alloc();
917 if (!sock) {
918 err = -ENOMEM;
919 goto out;
920 }
921
922 security_socket_post_create(sock, family, type, protocol, 1);
923 sock->type = type;
924 out:
925 *res = sock;
926 return err;
927 }
928
929 /* No kernel lock held - perfect */
930 static unsigned int sock_poll(struct file *file, poll_table * wait)
931 {
932 struct socket *sock;
933
934 /*
935 * We can't return errors to poll, so it's either yes or no.
936 */
937 sock = SOCKET_I(file->f_dentry->d_inode);
938 return sock->ops->poll(file, sock, wait);
939 }
940
941 static int sock_mmap(struct file * file, struct vm_area_struct * vma)
942 {
943 struct socket *sock = SOCKET_I(file->f_dentry->d_inode);
944
945 return sock->ops->mmap(file, sock, vma);
946 }
947
948 int sock_close(struct inode *inode, struct file *filp)
949 {
950 /*
951 * It was possible the inode is NULL we were
952 * closing an unfinished socket.
953 */
954
955 if (!inode)
956 {
957 printk(KERN_DEBUG "sock_close: NULL inode\n");
958 return 0;
959 }
960 sock_fasync(-1, filp, 0);
961 sock_release(SOCKET_I(inode));
962 return 0;
963 }
964
965 /*
966 * Update the socket async list
967 *
968 * Fasync_list locking strategy.
969 *
970 * 1. fasync_list is modified only under process context socket lock
971 * i.e. under semaphore.
972 * 2. fasync_list is used under read_lock(&sk->sk_callback_lock)
973 * or under socket lock.
974 * 3. fasync_list can be used from softirq context, so that
975 * modification under socket lock have to be enhanced with
976 * write_lock_bh(&sk->sk_callback_lock).
977 * --ANK (990710)
978 */
979
980 static int sock_fasync(int fd, struct file *filp, int on)
981 {
982 struct fasync_struct *fa, *fna=NULL, **prev;
983 struct socket *sock;
984 struct sock *sk;
985
986 if (on)
987 {
988 fna=(struct fasync_struct *)kmalloc(sizeof(struct fasync_struct), GFP_KERNEL);
989 if(fna==NULL)
990 return -ENOMEM;
991 }
992
993 sock = SOCKET_I(filp->f_dentry->d_inode);
994
995 if ((sk=sock->sk) == NULL) {
996 if (fna)
997 kfree(fna);
998 return -EINVAL;
999 }
1000
1001 lock_sock(sk);
1002
1003 prev=&(sock->fasync_list);
1004
1005 for (fa=*prev; fa!=NULL; prev=&fa->fa_next,fa=*prev)
1006 if (fa->fa_file==filp)
1007 break;
1008
1009 if(on)
1010 {
1011 if(fa!=NULL)
1012 {
1013 write_lock_bh(&sk->sk_callback_lock);
1014 fa->fa_fd=fd;
1015 write_unlock_bh(&sk->sk_callback_lock);
1016
1017 kfree(fna);
1018 goto out;
1019 }
1020 fna->fa_file=filp;
1021 fna->fa_fd=fd;
1022 fna->magic=FASYNC_MAGIC;
1023 fna->fa_next=sock->fasync_list;
1024 write_lock_bh(&sk->sk_callback_lock);
1025 sock->fasync_list=fna;
1026 write_unlock_bh(&sk->sk_callback_lock);
1027 }
1028 else
1029 {
1030 if (fa!=NULL)
1031 {
1032 write_lock_bh(&sk->sk_callback_lock);
1033 *prev=fa->fa_next;
1034 write_unlock_bh(&sk->sk_callback_lock);
1035 kfree(fa);
1036 }
1037 }
1038
1039 out:
1040 release_sock(sock->sk);
1041 return 0;
1042 }
1043
1044 /* This function may be called only under socket lock or callback_lock */
1045
1046 int sock_wake_async(struct socket *sock, int how, int band)
1047 {
1048 if (!sock || !sock->fasync_list)
1049 return -1;
1050 switch (how)
1051 {
1052 case 1:
1053
1054 if (test_bit(SOCK_ASYNC_WAITDATA, &sock->flags))
1055 break;
1056 goto call_kill;
1057 case 2:
1058 if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags))
1059 break;
1060 /* fall through */
1061 case 0:
1062 call_kill:
1063 __kill_fasync(sock->fasync_list, SIGIO, band);
1064 break;
1065 case 3:
1066 __kill_fasync(sock->fasync_list, SIGURG, band);
1067 }
1068 return 0;
1069 }
1070
1071 static int __sock_create(int family, int type, int protocol, struct socket **res, int kern)
1072 {
1073 int err;
1074 struct socket *sock;
1075
1076 /*
1077 * Check protocol is in range
1078 */
1079 if (family < 0 || family >= NPROTO)
1080 return -EAFNOSUPPORT;
1081 if (type < 0 || type >= SOCK_MAX)
1082 return -EINVAL;
1083
1084 /* Compatibility.
1085
1086 This uglymoron is moved from INET layer to here to avoid
1087 deadlock in module load.
1088 */
1089 if (family == PF_INET && type == SOCK_PACKET) {
1090 static int warned;
1091 if (!warned) {
1092 warned = 1;
1093 printk(KERN_INFO "%s uses obsolete (PF_INET,SOCK_PACKET)\n", current->comm);
1094 }
1095 family = PF_PACKET;
1096 }
1097
1098 err = security_socket_create(family, type, protocol, kern);
1099 if (err)
1100 return err;
1101
1102 #if defined(CONFIG_KMOD)
1103 /* Attempt to load a protocol module if the find failed.
1104 *
1105 * 12/09/1996 Marcin: But! this makes REALLY only sense, if the user
1106 * requested real, full-featured networking support upon configuration.
1107 * Otherwise module support will break!
1108 */
1109 if (net_families[family]==NULL)
1110 {
1111 request_module("net-pf-%d",family);
1112 }
1113 #endif
1114
1115 net_family_read_lock();
1116 if (net_families[family] == NULL) {
1117 err = -EAFNOSUPPORT;
1118 goto out;
1119 }
1120
1121 /*
1122 * Allocate the socket and allow the family to set things up. if
1123 * the protocol is 0, the family is instructed to select an appropriate
1124 * default.
1125 */
1126
1127 if (!(sock = sock_alloc())) {
1128 printk(KERN_WARNING "socket: no more sockets\n");
1129 err = -ENFILE; /* Not exactly a match, but its the
1130 closest posix thing */
1131 goto out;
1132 }
1133
1134 sock->type = type;
1135
1136 /*
1137 * We will call the ->create function, that possibly is in a loadable
1138 * module, so we have to bump that loadable module refcnt first.
1139 */
1140 err = -EAFNOSUPPORT;
1141 if (!try_module_get(net_families[family]->owner))
1142 goto out_release;
1143
1144 if ((err = net_families[family]->create(sock, protocol)) < 0)
1145 goto out_module_put;
1146 /*
1147 * Now to bump the refcnt of the [loadable] module that owns this
1148 * socket at sock_release time we decrement its refcnt.
1149 */
1150 if (!try_module_get(sock->ops->owner)) {
1151 sock->ops = NULL;
1152 goto out_module_put;
1153 }
1154 /*
1155 * Now that we're done with the ->create function, the [loadable]
1156 * module can have its refcnt decremented
1157 */
1158 module_put(net_families[family]->owner);
1159 *res = sock;
1160 security_socket_post_create(sock, family, type, protocol, kern);
1161
1162 out:
1163 net_family_read_unlock();
1164 return err;
1165 out_module_put:
1166 module_put(net_families[family]->owner);
1167 out_release:
1168 sock_release(sock);
1169 goto out;
1170 }
1171
1172 int sock_create(int family, int type, int protocol, struct socket **res)
1173 {
1174 return __sock_create(family, type, protocol, res, 0);
1175 }
1176
1177 int sock_create_kern(int family, int type, int protocol, struct socket **res)
1178 {
1179 return __sock_create(family, type, protocol, res, 1);
1180 }
1181
1182 asmlinkage long sys_socket(int family, int type, int protocol)
1183 {
1184 int retval;
1185 struct socket *sock;
1186
1187 retval = sock_create(family, type, protocol, &sock);
1188 if (retval < 0)
1189 goto out;
1190
1191 retval = sock_map_fd(sock);
1192 if (retval < 0)
1193 goto out_release;
1194
1195 out:
1196 /* It may be already another descriptor 8) Not kernel problem. */
1197 return retval;
1198
1199 out_release:
1200 sock_release(sock);
1201 return retval;
1202 }
1203
1204 /*
1205 * Create a pair of connected sockets.
1206 */
1207
1208 asmlinkage long sys_socketpair(int family, int type, int protocol, int __user *usockvec)
1209 {
1210 struct socket *sock1, *sock2;
1211 int fd1, fd2, err;
1212
1213 /*
1214 * Obtain the first socket and check if the underlying protocol
1215 * supports the socketpair call.
1216 */
1217
1218 err = sock_create(family, type, protocol, &sock1);
1219 if (err < 0)
1220 goto out;
1221
1222 err = sock_create(family, type, protocol, &sock2);
1223 if (err < 0)
1224 goto out_release_1;
1225
1226 err = sock1->ops->socketpair(sock1, sock2);
1227 if (err < 0)
1228 goto out_release_both;
1229
1230 fd1 = fd2 = -1;
1231
1232 err = sock_map_fd(sock1);
1233 if (err < 0)
1234 goto out_release_both;
1235 fd1 = err;
1236
1237 err = sock_map_fd(sock2);
1238 if (err < 0)
1239 goto out_close_1;
1240 fd2 = err;
1241
1242 /* fd1 and fd2 may be already another descriptors.
1243 * Not kernel problem.
1244 */
1245
1246 err = put_user(fd1, &usockvec[0]);
1247 if (!err)
1248 err = put_user(fd2, &usockvec[1]);
1249 if (!err)
1250 return 0;
1251
1252 sys_close(fd2);
1253 sys_close(fd1);
1254 return err;
1255
1256 out_close_1:
1257 sock_release(sock2);
1258 sys_close(fd1);
1259 return err;
1260
1261 out_release_both:
1262 sock_release(sock2);
1263 out_release_1:
1264 sock_release(sock1);
1265 out:
1266 return err;
1267 }
1268
1269
1270 /*
1271 * Bind a name to a socket. Nothing much to do here since it's
1272 * the protocol's responsibility to handle the local address.
1273 *
1274 * We move the socket address to kernel space before we call
1275 * the protocol layer (having also checked the address is ok).
1276 */
1277
1278 asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen)
1279 {
1280 struct socket *sock;
1281 char address[MAX_SOCK_ADDR];
1282 int err;
1283
1284 if((sock = sockfd_lookup(fd,&err))!=NULL)
1285 {
1286 if((err=move_addr_to_kernel(umyaddr,addrlen,address))>=0) {
1287 err = security_socket_bind(sock, (struct sockaddr *)address, addrlen);
1288 if (err) {
1289 sockfd_put(sock);
1290 return err;
1291 }
1292 err = sock->ops->bind(sock, (struct sockaddr *)address, addrlen);
1293 }
1294 sockfd_put(sock);
1295 }
1296 return err;
1297 }
1298
1299
1300 /*
1301 * Perform a listen. Basically, we allow the protocol to do anything
1302 * necessary for a listen, and if that works, we mark the socket as
1303 * ready for listening.
1304 */
1305
1306 int sysctl_somaxconn = SOMAXCONN;
1307
1308 asmlinkage long sys_listen(int fd, int backlog)
1309 {
1310 struct socket *sock;
1311 int err;
1312
1313 if ((sock = sockfd_lookup(fd, &err)) != NULL) {
1314 if ((unsigned) backlog > sysctl_somaxconn)
1315 backlog = sysctl_somaxconn;
1316
1317 err = security_socket_listen(sock, backlog);
1318 if (err) {
1319 sockfd_put(sock);
1320 return err;
1321 }
1322
1323 err=sock->ops->listen(sock, backlog);
1324 sockfd_put(sock);
1325 }
1326 return err;
1327 }
1328
1329
1330 /*
1331 * For accept, we attempt to create a new socket, set up the link
1332 * with the client, wake up the client, then return the new
1333 * connected fd. We collect the address of the connector in kernel
1334 * space and move it to user at the very end. This is unclean because
1335 * we open the socket then return an error.
1336 *
1337 * 1003.1g adds the ability to recvmsg() to query connection pending
1338 * status to recvmsg. We need to add that support in a way thats
1339 * clean when we restucture accept also.
1340 */
1341
1342 asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr, int __user *upeer_addrlen)
1343 {
1344 struct socket *sock, *newsock;
1345 int err, len;
1346 char address[MAX_SOCK_ADDR];
1347
1348 sock = sockfd_lookup(fd, &err);
1349 if (!sock)
1350 goto out;
1351
1352 err = -ENFILE;
1353 if (!(newsock = sock_alloc()))
1354 goto out_put;
1355
1356 newsock->type = sock->type;
1357 newsock->ops = sock->ops;
1358
1359 err = security_socket_accept(sock, newsock);
1360 if (err)
1361 goto out_release;
1362
1363 /*
1364 * We don't need try_module_get here, as the listening socket (sock)
1365 * has the protocol module (sock->ops->owner) held.
1366 */
1367 __module_get(newsock->ops->owner);
1368
1369 err = sock->ops->accept(sock, newsock, sock->file->f_flags);
1370 if (err < 0)
1371 goto out_release;
1372
1373 if (upeer_sockaddr) {
1374 if(newsock->ops->getname(newsock, (struct sockaddr *)address, &len, 2)<0) {
1375 err = -ECONNABORTED;
1376 goto out_release;
1377 }
1378 err = move_addr_to_user(address, len, upeer_sockaddr, upeer_addrlen);
1379 if (err < 0)
1380 goto out_release;
1381 }
1382
1383 /* File flags are not inherited via accept() unlike another OSes. */
1384
1385 if ((err = sock_map_fd(newsock)) < 0)
1386 goto out_release;
1387
1388 security_socket_post_accept(sock, newsock);
1389
1390 out_put:
1391 sockfd_put(sock);
1392 out:
1393 return err;
1394 out_release:
1395 sock_release(newsock);
1396 goto out_put;
1397 }
1398
1399
1400 /*
1401 * Attempt to connect to a socket with the server address. The address
1402 * is in user space so we verify it is OK and move it to kernel space.
1403 *
1404 * For 1003.1g we need to add clean support for a bind to AF_UNSPEC to
1405 * break bindings
1406 *
1407 * NOTE: 1003.1g draft 6.3 is broken with respect to AX.25/NetROM and
1408 * other SEQPACKET protocols that take time to connect() as it doesn't
1409 * include the -EINPROGRESS status for such sockets.
1410 */
1411
1412 asmlinkage long sys_connect(int fd, struct sockaddr __user *uservaddr, int addrlen)
1413 {
1414 struct socket *sock;
1415 char address[MAX_SOCK_ADDR];
1416 int err;
1417
1418 sock = sockfd_lookup(fd, &err);
1419 if (!sock)
1420 goto out;
1421 err = move_addr_to_kernel(uservaddr, addrlen, address);
1422 if (err < 0)
1423 goto out_put;
1424
1425 err = security_socket_connect(sock, (struct sockaddr *)address, addrlen);
1426 if (err)
1427 goto out_put;
1428
1429 err = sock->ops->connect(sock, (struct sockaddr *) address, addrlen,
1430 sock->file->f_flags);
1431 out_put:
1432 sockfd_put(sock);
1433 out:
1434 return err;
1435 }
1436
1437 /*
1438 * Get the local address ('name') of a socket object. Move the obtained
1439 * name to user space.
1440 */
1441
1442 asmlinkage long sys_getsockname(int fd, struct sockaddr __user *usockaddr, int __user *usockaddr_len)
1443 {
1444 struct socket *sock;
1445 char address[MAX_SOCK_ADDR];
1446 int len, err;
1447
1448 sock = sockfd_lookup(fd, &err);
1449 if (!sock)
1450 goto out;
1451
1452 err = security_socket_getsockname(sock);
1453 if (err)
1454 goto out_put;
1455
1456 err = sock->ops->getname(sock, (struct sockaddr *)address, &len, 0);
1457 if (err)
1458 goto out_put;
1459 err = move_addr_to_user(address, len, usockaddr, usockaddr_len);
1460
1461 out_put:
1462 sockfd_put(sock);
1463 out:
1464 return err;
1465 }
1466
1467 /*
1468 * Get the remote address ('name') of a socket object. Move the obtained
1469 * name to user space.
1470 */
1471
1472 asmlinkage long sys_getpeername(int fd, struct sockaddr __user *usockaddr, int __user *usockaddr_len)
1473 {
1474 struct socket *sock;
1475 char address[MAX_SOCK_ADDR];
1476 int len, err;
1477
1478 if ((sock = sockfd_lookup(fd, &err))!=NULL)
1479 {
1480 err = security_socket_getpeername(sock);
1481 if (err) {
1482 sockfd_put(sock);
1483 return err;
1484 }
1485
1486 err = sock->ops->getname(sock, (struct sockaddr *)address, &len, 1);
1487 if (!err)
1488 err=move_addr_to_user(address,len, usockaddr, usockaddr_len);
1489 sockfd_put(sock);
1490 }
1491 return err;
1492 }
1493
1494 /*
1495 * Send a datagram to a given address. We move the address into kernel
1496 * space and check the user space data area is readable before invoking
1497 * the protocol.
1498 */
1499
1500 asmlinkage long sys_sendto(int fd, void __user * buff, size_t len, unsigned flags,
1501 struct sockaddr __user *addr, int addr_len)
1502 {
1503 struct socket *sock;
1504 char address[MAX_SOCK_ADDR];
1505 int err;
1506 struct msghdr msg;
1507 struct iovec iov;
1508
1509 sock = sockfd_lookup(fd, &err);
1510 if (!sock)
1511 goto out;
1512 iov.iov_base=buff;
1513 iov.iov_len=len;
1514 msg.msg_name=NULL;
1515 msg.msg_iov=&iov;
1516 msg.msg_iovlen=1;
1517 msg.msg_control=NULL;
1518 msg.msg_controllen=0;
1519 msg.msg_namelen=0;
1520 if(addr)
1521 {
1522 err = move_addr_to_kernel(addr, addr_len, address);
1523 if (err < 0)
1524 goto out_put;
1525 msg.msg_name=address;
1526 msg.msg_namelen=addr_len;
1527 }
1528 if (sock->file->f_flags & O_NONBLOCK)
1529 flags |= MSG_DONTWAIT;
1530 msg.msg_flags = flags;
1531 err = sock_sendmsg(sock, &msg, len);
1532
1533 out_put:
1534 sockfd_put(sock);
1535 out:
1536 return err;
1537 }
1538
1539 /*
1540 * Send a datagram down a socket.
1541 */
1542
1543 asmlinkage long sys_send(int fd, void __user * buff, size_t len, unsigned flags)
1544 {
1545 return sys_sendto(fd, buff, len, flags, NULL, 0);
1546 }
1547
1548 /*
1549 * Receive a frame from the socket and optionally record the address of the
1550 * sender. We verify the buffers are writable and if needed move the
1551 * sender address from kernel to user space.
1552 */
1553
1554 asmlinkage long sys_recvfrom(int fd, void __user * ubuf, size_t size, unsigned flags,
1555 struct sockaddr __user *addr, int __user *addr_len)
1556 {
1557 struct socket *sock;
1558 struct iovec iov;
1559 struct msghdr msg;
1560 char address[MAX_SOCK_ADDR];
1561 int err,err2;
1562
1563 sock = sockfd_lookup(fd, &err);
1564 if (!sock)
1565 goto out;
1566
1567 msg.msg_control=NULL;
1568 msg.msg_controllen=0;
1569 msg.msg_iovlen=1;
1570 msg.msg_iov=&iov;
1571 iov.iov_len=size;
1572 iov.iov_base=ubuf;
1573 msg.msg_name=address;
1574 msg.msg_namelen=MAX_SOCK_ADDR;
1575 if (sock->file->f_flags & O_NONBLOCK)
1576 flags |= MSG_DONTWAIT;
1577 err=sock_recvmsg(sock, &msg, size, flags);
1578
1579 if(err >= 0 && addr != NULL)
1580 {
1581 err2=move_addr_to_user(address, msg.msg_namelen, addr, addr_len);
1582 if(err2<0)
1583 err=err2;
1584 }
1585 sockfd_put(sock);
1586 out:
1587 return err;
1588 }
1589
1590 /*
1591 * Receive a datagram from a socket.
1592 */
1593
1594 asmlinkage long sys_recv(int fd, void __user * ubuf, size_t size, unsigned flags)
1595 {
1596 return sys_recvfrom(fd, ubuf, size, flags, NULL, NULL);
1597 }
1598
1599 /*
1600 * Set a socket option. Because we don't know the option lengths we have
1601 * to pass the user mode parameter for the protocols to sort out.
1602 */
1603
1604 asmlinkage long sys_setsockopt(int fd, int level, int optname, char __user *optval, int optlen)
1605 {
1606 int err;
1607 struct socket *sock;
1608
1609 if (optlen < 0)
1610 return -EINVAL;
1611
1612 if ((sock = sockfd_lookup(fd, &err))!=NULL)
1613 {
1614 err = security_socket_setsockopt(sock,level,optname);
1615 if (err) {
1616 sockfd_put(sock);
1617 return err;
1618 }
1619
1620 if (level == SOL_SOCKET)
1621 err=sock_setsockopt(sock,level,optname,optval,optlen);
1622 else
1623 err=sock->ops->setsockopt(sock, level, optname, optval, optlen);
1624 sockfd_put(sock);
1625 }
1626 return err;
1627 }
1628
1629 /*
1630 * Get a socket option. Because we don't know the option lengths we have
1631 * to pass a user mode parameter for the protocols to sort out.
1632 */
1633
1634 asmlinkage long sys_getsockopt(int fd, int level, int optname, char __user *optval, int __user *optlen)
1635 {
1636 int err;
1637 struct socket *sock;
1638
1639 if ((sock = sockfd_lookup(fd, &err))!=NULL)
1640 {
1641 err = security_socket_getsockopt(sock, level,
1642 optname);
1643 if (err) {
1644 sockfd_put(sock);
1645 return err;
1646 }
1647
1648 if (level == SOL_SOCKET)
1649 err=sock_getsockopt(sock,level,optname,optval,optlen);
1650 else
1651 err=sock->ops->getsockopt(sock, level, optname, optval, optlen);
1652 sockfd_put(sock);
1653 }
1654 return err;
1655 }
1656
1657
1658 /*
1659 * Shutdown a socket.
1660 */
1661
1662 asmlinkage long sys_shutdown(int fd, int how)
1663 {
1664 int err;
1665 struct socket *sock;
1666
1667 if ((sock = sockfd_lookup(fd, &err))!=NULL)
1668 {
1669 err = security_socket_shutdown(sock, how);
1670 if (err) {
1671 sockfd_put(sock);
1672 return err;
1673 }
1674
1675 err=sock->ops->shutdown(sock, how);
1676 sockfd_put(sock);
1677 }
1678 return err;
1679 }
1680
1681 /* A couple of helpful macros for getting the address of the 32/64 bit
1682 * fields which are the same type (int / unsigned) on our platforms.
1683 */
1684 #define COMPAT_MSG(msg, member) ((MSG_CMSG_COMPAT & flags) ? &msg##_compat->member : &msg->member)
1685 #define COMPAT_NAMELEN(msg) COMPAT_MSG(msg, msg_namelen)
1686 #define COMPAT_FLAGS(msg) COMPAT_MSG(msg, msg_flags)
1687
1688
1689 /*
1690 * BSD sendmsg interface
1691 */
1692
1693 asmlinkage long sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags)
1694 {
1695 struct compat_msghdr __user *msg_compat = (struct compat_msghdr __user *)msg;
1696 struct socket *sock;
1697 char address[MAX_SOCK_ADDR];
1698 struct iovec iovstack[UIO_FASTIOV], *iov = iovstack;
1699 unsigned char ctl[sizeof(struct cmsghdr) + 20]; /* 20 is size of ipv6_pktinfo */
1700 unsigned char *ctl_buf = ctl;
1701 struct msghdr msg_sys;
1702 int err, ctl_len, iov_size, total_len;
1703
1704 err = -EFAULT;
1705 if (MSG_CMSG_COMPAT & flags) {
1706 if (get_compat_msghdr(&msg_sys, msg_compat))
1707 return -EFAULT;
1708 } else if (copy_from_user(&msg_sys, msg, sizeof(struct msghdr)))
1709 return -EFAULT;
1710
1711 sock = sockfd_lookup(fd, &err);
1712 if (!sock)
1713 goto out;
1714
1715 /* do not move before msg_sys is valid */
1716 err = -EMSGSIZE;
1717 if (msg_sys.msg_iovlen > UIO_MAXIOV)
1718 goto out_put;
1719
1720 /* Check whether to allocate the iovec area*/
1721 err = -ENOMEM;
1722 iov_size = msg_sys.msg_iovlen * sizeof(struct iovec);
1723 if (msg_sys.msg_iovlen > UIO_FASTIOV) {
1724 iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
1725 if (!iov)
1726 goto out_put;
1727 }
1728
1729 /* This will also move the address data into kernel space */
1730 if (MSG_CMSG_COMPAT & flags) {
1731 err = verify_compat_iovec(&msg_sys, iov, address, VERIFY_READ);
1732 } else
1733 err = verify_iovec(&msg_sys, iov, address, VERIFY_READ);
1734 if (err < 0)
1735 goto out_freeiov;
1736 total_len = err;
1737
1738 err = -ENOBUFS;
1739
1740 if (msg_sys.msg_controllen > INT_MAX)
1741 goto out_freeiov;
1742 ctl_len = msg_sys.msg_controllen;
1743 if ((MSG_CMSG_COMPAT & flags) && ctl_len) {
1744 err = cmsghdr_from_user_compat_to_kern(&msg_sys, ctl, sizeof(ctl));
1745 if (err)
1746 goto out_freeiov;
1747 ctl_buf = msg_sys.msg_control;
1748 } else if (ctl_len) {
1749 if (ctl_len > sizeof(ctl))
1750 {
1751 ctl_buf = sock_kmalloc(sock->sk, ctl_len, GFP_KERNEL);
1752 if (ctl_buf == NULL)
1753 goto out_freeiov;
1754 }
1755 err = -EFAULT;
1756 /*
1757 * Careful! Before this, msg_sys.msg_control contains a user pointer.
1758 * Afterwards, it will be a kernel pointer. Thus the compiler-assisted
1759 * checking falls down on this.
1760 */
1761 if (copy_from_user(ctl_buf, (void __user *) msg_sys.msg_control, ctl_len))
1762 goto out_freectl;
1763 msg_sys.msg_control = ctl_buf;
1764 }
1765 msg_sys.msg_flags = flags;
1766
1767 if (sock->file->f_flags & O_NONBLOCK)
1768 msg_sys.msg_flags |= MSG_DONTWAIT;
1769 err = sock_sendmsg(sock, &msg_sys, total_len);
1770
1771 out_freectl:
1772 if (ctl_buf != ctl)
1773 sock_kfree_s(sock->sk, ctl_buf, ctl_len);
1774 out_freeiov:
1775 if (iov != iovstack)
1776 sock_kfree_s(sock->sk, iov, iov_size);
1777 out_put:
1778 sockfd_put(sock);
1779 out:
1780 return err;
1781 }
1782
1783 /*
1784 * BSD recvmsg interface
1785 */
1786
1787 asmlinkage long sys_recvmsg(int fd, struct msghdr __user *msg, unsigned int flags)
1788 {
1789 struct compat_msghdr __user *msg_compat = (struct compat_msghdr __user *)msg;
1790 struct socket *sock;
1791 struct iovec iovstack[UIO_FASTIOV];
1792 struct iovec *iov=iovstack;
1793 struct msghdr msg_sys;
1794 unsigned long cmsg_ptr;
1795 int err, iov_size, total_len, len;
1796
1797 /* kernel mode address */
1798 char addr[MAX_SOCK_ADDR];
1799
1800 /* user mode address pointers */
1801 struct sockaddr __user *uaddr;
1802 int __user *uaddr_len;
1803
1804 if (MSG_CMSG_COMPAT & flags) {
1805 if (get_compat_msghdr(&msg_sys, msg_compat))
1806 return -EFAULT;
1807 } else
1808 if (copy_from_user(&msg_sys,msg,sizeof(struct msghdr)))
1809 return -EFAULT;
1810
1811 sock = sockfd_lookup(fd, &err);
1812 if (!sock)
1813 goto out;
1814
1815 err = -EMSGSIZE;
1816 if (msg_sys.msg_iovlen > UIO_MAXIOV)
1817 goto out_put;
1818
1819 /* Check whether to allocate the iovec area*/
1820 err = -ENOMEM;
1821 iov_size = msg_sys.msg_iovlen * sizeof(struct iovec);
1822 if (msg_sys.msg_iovlen > UIO_FASTIOV) {
1823 iov = sock_kmalloc(sock->sk, iov_size, GFP_KERNEL);
1824 if (!iov)
1825 goto out_put;
1826 }
1827
1828 /*
1829 * Save the user-mode address (verify_iovec will change the
1830 * kernel msghdr to use the kernel address space)
1831 */
1832
1833 uaddr = (void __user *) msg_sys.msg_name;
1834 uaddr_len = COMPAT_NAMELEN(msg);
1835 if (MSG_CMSG_COMPAT & flags) {
1836 err = verify_compat_iovec(&msg_sys, iov, addr, VERIFY_WRITE);
1837 } else
1838 err = verify_iovec(&msg_sys, iov, addr, VERIFY_WRITE);
1839 if (err < 0)
1840 goto out_freeiov;
1841 total_len=err;
1842
1843 cmsg_ptr = (unsigned long)msg_sys.msg_control;
1844 msg_sys.msg_flags = 0;
1845 if (MSG_CMSG_COMPAT & flags)
1846 msg_sys.msg_flags = MSG_CMSG_COMPAT;
1847
1848 if (sock->file->f_flags & O_NONBLOCK)
1849 flags |= MSG_DONTWAIT;
1850 err = sock_recvmsg(sock, &msg_sys, total_len, flags);
1851 if (err < 0)
1852 goto out_freeiov;
1853 len = err;
1854
1855 if (uaddr != NULL) {
1856 err = move_addr_to_user(addr, msg_sys.msg_namelen, uaddr, uaddr_len);
1857 if (err < 0)
1858 goto out_freeiov;
1859 }
1860 err = __put_user(msg_sys.msg_flags, COMPAT_FLAGS(msg));
1861 if (err)
1862 goto out_freeiov;
1863 if (MSG_CMSG_COMPAT & flags)
1864 err = __put_user((unsigned long)msg_sys.msg_control-cmsg_ptr,
1865 &msg_compat->msg_controllen);
1866 else
1867 err = __put_user((unsigned long)msg_sys.msg_control-cmsg_ptr,
1868 &msg->msg_controllen);
1869 if (err)
1870 goto out_freeiov;
1871 err = len;
1872
1873 out_freeiov:
1874 if (iov != iovstack)
1875 sock_kfree_s(sock->sk, iov, iov_size);
1876 out_put:
1877 sockfd_put(sock);
1878 out:
1879 return err;
1880 }
1881
1882 #ifdef __ARCH_WANT_SYS_SOCKETCALL
1883
1884 /* Argument list sizes for sys_socketcall */
1885 #define AL(x) ((x) * sizeof(unsigned long))
1886 static unsigned char nargs[18]={AL(0),AL(3),AL(3),AL(3),AL(2),AL(3),
1887 AL(3),AL(3),AL(4),AL(4),AL(4),AL(6),
1888 AL(6),AL(2),AL(5),AL(5),AL(3),AL(3)};
1889 #undef AL
1890
1891 /*
1892 * System call vectors.
1893 *
1894 * Argument checking cleaned up. Saved 20% in size.
1895 * This function doesn't need to set the kernel lock because
1896 * it is set by the callees.
1897 */
1898
1899 asmlinkage long sys_socketcall(int call, unsigned long __user *args)
1900 {
1901 unsigned long a[6];
1902 unsigned long a0,a1;
1903 int err;
1904
1905 if(call<1||call>SYS_RECVMSG)
1906 return -EINVAL;
1907
1908 /* copy_from_user should be SMP safe. */
1909 if (copy_from_user(a, args, nargs[call]))
1910 return -EFAULT;
1911
1912 a0=a[0];
1913 a1=a[1];
1914
1915 switch(call)
1916 {
1917 case SYS_SOCKET:
1918 err = sys_socket(a0,a1,a[2]);
1919 break;
1920 case SYS_BIND:
1921 err = sys_bind(a0,(struct sockaddr __user *)a1, a[2]);
1922 break;
1923 case SYS_CONNECT:
1924 err = sys_connect(a0, (struct sockaddr __user *)a1, a[2]);
1925 break;
1926 case SYS_LISTEN:
1927 err = sys_listen(a0,a1);
1928 break;
1929 case SYS_ACCEPT:
1930 err = sys_accept(a0,(struct sockaddr __user *)a1, (int __user *)a[2]);
1931 break;
1932 case SYS_GETSOCKNAME:
1933 err = sys_getsockname(a0,(struct sockaddr __user *)a1, (int __user *)a[2]);
1934 break;
1935 case SYS_GETPEERNAME:
1936 err = sys_getpeername(a0, (struct sockaddr __user *)a1, (int __user *)a[2]);
1937 break;
1938 case SYS_SOCKETPAIR:
1939 err = sys_socketpair(a0,a1, a[2], (int __user *)a[3]);
1940 break;
1941 case SYS_SEND:
1942 err = sys_send(a0, (void __user *)a1, a[2], a[3]);
1943 break;
1944 case SYS_SENDTO:
1945 err = sys_sendto(a0,(void __user *)a1, a[2], a[3],
1946 (struct sockaddr __user *)a[4], a[5]);
1947 break;
1948 case SYS_RECV:
1949 err = sys_recv(a0, (void __user *)a1, a[2], a[3]);
1950 break;
1951 case SYS_RECVFROM:
1952 err = sys_recvfrom(a0, (void __user *)a1, a[2], a[3],
1953 (struct sockaddr __user *)a[4], (int __user *)a[5]);
1954 break;
1955 case SYS_SHUTDOWN:
1956 err = sys_shutdown(a0,a1);
1957 break;
1958 case SYS_SETSOCKOPT:
1959 err = sys_setsockopt(a0, a1, a[2], (char __user *)a[3], a[4]);
1960 break;
1961 case SYS_GETSOCKOPT:
1962 err = sys_getsockopt(a0, a1, a[2], (char __user *)a[3], (int __user *)a[4]);
1963 break;
1964 case SYS_SENDMSG:
1965 err = sys_sendmsg(a0, (struct msghdr __user *) a1, a[2]);
1966 break;
1967 case SYS_RECVMSG:
1968 err = sys_recvmsg(a0, (struct msghdr __user *) a1, a[2]);
1969 break;
1970 default:
1971 err = -EINVAL;
1972 break;
1973 }
1974 return err;
1975 }
1976
1977 #endif /* __ARCH_WANT_SYS_SOCKETCALL */
1978
1979 /*
1980 * This function is called by a protocol handler that wants to
1981 * advertise its address family, and have it linked into the
1982 * SOCKET module.
1983 */
1984
1985 int sock_register(struct net_proto_family *ops)
1986 {
1987 int err;
1988
1989 if (ops->family >= NPROTO) {
1990 printk(KERN_CRIT "protocol %d >= NPROTO(%d)\n", ops->family, NPROTO);
1991 return -ENOBUFS;
1992 }
1993 net_family_write_lock();
1994 err = -EEXIST;
1995 if (net_families[ops->family] == NULL) {
1996 net_families[ops->family]=ops;
1997 err = 0;
1998 }
1999 net_family_write_unlock();
2000 printk(KERN_INFO "NET: Registered protocol family %d\n",
2001 ops->family);
2002 return err;
2003 }
2004
2005 /*
2006 * This function is called by a protocol handler that wants to
2007 * remove its address family, and have it unlinked from the
2008 * SOCKET module.
2009 */
2010
2011 int sock_unregister(int family)
2012 {
2013 if (family < 0 || family >= NPROTO)
2014 return -1;
2015
2016 net_family_write_lock();
2017 net_families[family]=NULL;
2018 net_family_write_unlock();
2019 printk(KERN_INFO "NET: Unregistered protocol family %d\n",
2020 family);
2021 return 0;
2022 }
2023
2024
2025 extern void sk_init(void);
2026
2027 void __init sock_init(void)
2028 {
2029 /*
2030 * Initialize sock SLAB cache.
2031 */
2032
2033 sk_init();
2034
2035 #ifdef SLAB_SKB
2036 /*
2037 * Initialize skbuff SLAB cache
2038 */
2039 skb_init();
2040 #endif
2041
2042 /*
2043 * Initialize the protocols module.
2044 */
2045
2046 init_inodecache();
2047 register_filesystem(&sock_fs_type);
2048 sock_mnt = kern_mount(&sock_fs_type);
2049 /* The real protocol initialization is performed when
2050 * do_initcalls is run.
2051 */
2052
2053 #ifdef CONFIG_NETFILTER
2054 netfilter_init();
2055 #endif
2056 }
2057
2058 #ifdef CONFIG_PROC_FS
2059 void socket_seq_show(struct seq_file *seq)
2060 {
2061 int cpu;
2062 int counter = 0;
2063
2064 for (cpu = 0; cpu < NR_CPUS; cpu++)
2065 counter += per_cpu(sockets_in_use, cpu);
2066
2067 /* It can be negative, by the way. 8) */
2068 if (counter < 0)
2069 counter = 0;
2070
2071 seq_printf(seq, "sockets: used %d\n", counter);
2072 }
2073 #endif /* CONFIG_PROC_FS */
2074
2075 /* ABI emulation layers need these two */
2076 EXPORT_SYMBOL(move_addr_to_kernel);
2077 EXPORT_SYMBOL(move_addr_to_user);
2078 EXPORT_SYMBOL(sock_create);
2079 EXPORT_SYMBOL(sock_create_kern);
2080 EXPORT_SYMBOL(sock_create_lite);
2081 EXPORT_SYMBOL(sock_map_fd);
2082 EXPORT_SYMBOL(sock_recvmsg);
2083 EXPORT_SYMBOL(sock_register);
2084 EXPORT_SYMBOL(sock_release);
2085 EXPORT_SYMBOL(sock_sendmsg);
2086 EXPORT_SYMBOL(sock_unregister);
2087 EXPORT_SYMBOL(sock_wake_async);
2088 EXPORT_SYMBOL(sockfd_lookup);
2089 EXPORT_SYMBOL(kernel_sendmsg);
2090 EXPORT_SYMBOL(kernel_recvmsg);
2091
|
This page was automatically generated by the
LXR engine.
|