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