0250e4ce489347f0a23fdbd551cd216a7abe208a
[linux-2.6.git] / fs / ncpfs / inode.c
1 /*
2  *  inode.c
3  *
4  *  Copyright (C) 1995, 1996 by Volker Lendecke
5  *  Modified for big endian by J.F. Chadima and David S. Miller
6  *  Modified 1997 Peter Waltenberg, Bill Hawes, David Woodhouse for 2.1 dcache
7  *  Modified 1998 Wolfram Pienkoss for NLS
8  *  Modified 2000 Ben Harris, University of Cambridge for NFS NS meta-info
9  *
10  */
11
12 #include <linux/module.h>
13
14 #include <asm/system.h>
15 #include <asm/uaccess.h>
16 #include <asm/byteorder.h>
17
18 #include <linux/time.h>
19 #include <linux/kernel.h>
20 #include <linux/mm.h>
21 #include <linux/string.h>
22 #include <linux/stat.h>
23 #include <linux/errno.h>
24 #include <linux/file.h>
25 #include <linux/fcntl.h>
26 #include <linux/slab.h>
27 #include <linux/vmalloc.h>
28 #include <linux/init.h>
29 #include <linux/vfs.h>
30 #include <linux/mount.h>
31 #include <linux/seq_file.h>
32 #include <linux/namei.h>
33
34 #include <net/sock.h>
35
36 #include "ncp_fs.h"
37 #include "getopt.h"
38
39 #define NCP_DEFAULT_FILE_MODE 0600
40 #define NCP_DEFAULT_DIR_MODE 0700
41 #define NCP_DEFAULT_TIME_OUT 10
42 #define NCP_DEFAULT_RETRY_COUNT 20
43
44 static void ncp_evict_inode(struct inode *);
45 static void ncp_put_super(struct super_block *);
46 static int  ncp_statfs(struct dentry *, struct kstatfs *);
47 static int  ncp_show_options(struct seq_file *, struct vfsmount *);
48
49 static struct kmem_cache * ncp_inode_cachep;
50
51 static struct inode *ncp_alloc_inode(struct super_block *sb)
52 {
53         struct ncp_inode_info *ei;
54         ei = (struct ncp_inode_info *)kmem_cache_alloc(ncp_inode_cachep, GFP_KERNEL);
55         if (!ei)
56                 return NULL;
57         return &ei->vfs_inode;
58 }
59
60 static void ncp_i_callback(struct rcu_head *head)
61 {
62         struct inode *inode = container_of(head, struct inode, i_rcu);
63         INIT_LIST_HEAD(&inode->i_dentry);
64         kmem_cache_free(ncp_inode_cachep, NCP_FINFO(inode));
65 }
66
67 static void ncp_destroy_inode(struct inode *inode)
68 {
69         call_rcu(&inode->i_rcu, ncp_i_callback);
70 }
71
72 static void init_once(void *foo)
73 {
74         struct ncp_inode_info *ei = (struct ncp_inode_info *) foo;
75
76         mutex_init(&ei->open_mutex);
77         inode_init_once(&ei->vfs_inode);
78 }
79
80 static int init_inodecache(void)
81 {
82         ncp_inode_cachep = kmem_cache_create("ncp_inode_cache",
83                                              sizeof(struct ncp_inode_info),
84                                              0, (SLAB_RECLAIM_ACCOUNT|
85                                                 SLAB_MEM_SPREAD),
86                                              init_once);
87         if (ncp_inode_cachep == NULL)
88                 return -ENOMEM;
89         return 0;
90 }
91
92 static void destroy_inodecache(void)
93 {
94         kmem_cache_destroy(ncp_inode_cachep);
95 }
96
97 static int ncp_remount(struct super_block *sb, int *flags, char* data)
98 {
99         *flags |= MS_NODIRATIME;
100         return 0;
101 }
102
103 static const struct super_operations ncp_sops =
104 {
105         .alloc_inode    = ncp_alloc_inode,
106         .destroy_inode  = ncp_destroy_inode,
107         .drop_inode     = generic_delete_inode,
108         .evict_inode    = ncp_evict_inode,
109         .put_super      = ncp_put_super,
110         .statfs         = ncp_statfs,
111         .remount_fs     = ncp_remount,
112         .show_options   = ncp_show_options,
113 };
114
115 /*
116  * Fill in the ncpfs-specific information in the inode.
117  */
118 static void ncp_update_dirent(struct inode *inode, struct ncp_entry_info *nwinfo)
119 {
120         NCP_FINFO(inode)->DosDirNum = nwinfo->i.DosDirNum;
121         NCP_FINFO(inode)->dirEntNum = nwinfo->i.dirEntNum;
122         NCP_FINFO(inode)->volNumber = nwinfo->volume;
123 }
124
125 void ncp_update_inode(struct inode *inode, struct ncp_entry_info *nwinfo)
126 {
127         ncp_update_dirent(inode, nwinfo);
128         NCP_FINFO(inode)->nwattr = nwinfo->i.attributes;
129         NCP_FINFO(inode)->access = nwinfo->access;
130         memcpy(NCP_FINFO(inode)->file_handle, nwinfo->file_handle,
131                         sizeof(nwinfo->file_handle));
132         DPRINTK("ncp_update_inode: updated %s, volnum=%d, dirent=%u\n",
133                 nwinfo->i.entryName, NCP_FINFO(inode)->volNumber,
134                 NCP_FINFO(inode)->dirEntNum);
135 }
136
137 static void ncp_update_dates(struct inode *inode, struct nw_info_struct *nwi)
138 {
139         /* NFS namespace mode overrides others if it's set. */
140         DPRINTK(KERN_DEBUG "ncp_update_dates_and_mode: (%s) nfs.mode=0%o\n",
141                 nwi->entryName, nwi->nfs.mode);
142         if (nwi->nfs.mode) {
143                 /* XXX Security? */
144                 inode->i_mode = nwi->nfs.mode;
145         }
146
147         inode->i_blocks = (i_size_read(inode) + NCP_BLOCK_SIZE - 1) >> NCP_BLOCK_SHIFT;
148
149         inode->i_mtime.tv_sec = ncp_date_dos2unix(nwi->modifyTime, nwi->modifyDate);
150         inode->i_ctime.tv_sec = ncp_date_dos2unix(nwi->creationTime, nwi->creationDate);
151         inode->i_atime.tv_sec = ncp_date_dos2unix(0, nwi->lastAccessDate);
152         inode->i_atime.tv_nsec = 0;
153         inode->i_mtime.tv_nsec = 0;
154         inode->i_ctime.tv_nsec = 0;
155 }
156
157 static void ncp_update_attrs(struct inode *inode, struct ncp_entry_info *nwinfo)
158 {
159         struct nw_info_struct *nwi = &nwinfo->i;
160         struct ncp_server *server = NCP_SERVER(inode);
161
162         if (nwi->attributes & aDIR) {
163                 inode->i_mode = server->m.dir_mode;
164                 /* for directories dataStreamSize seems to be some
165                    Object ID ??? */
166                 i_size_write(inode, NCP_BLOCK_SIZE);
167         } else {
168                 u32 size;
169
170                 inode->i_mode = server->m.file_mode;
171                 size = le32_to_cpu(nwi->dataStreamSize);
172                 i_size_write(inode, size);
173 #ifdef CONFIG_NCPFS_EXTRAS
174                 if ((server->m.flags & (NCP_MOUNT_EXTRAS|NCP_MOUNT_SYMLINKS)) 
175                  && (nwi->attributes & aSHARED)) {
176                         switch (nwi->attributes & (aHIDDEN|aSYSTEM)) {
177                                 case aHIDDEN:
178                                         if (server->m.flags & NCP_MOUNT_SYMLINKS) {
179                                                 if (/* (size >= NCP_MIN_SYMLINK_SIZE)
180                                                  && */ (size <= NCP_MAX_SYMLINK_SIZE)) {
181                                                         inode->i_mode = (inode->i_mode & ~S_IFMT) | S_IFLNK;
182                                                         NCP_FINFO(inode)->flags |= NCPI_KLUDGE_SYMLINK;
183                                                         break;
184                                                 }
185                                         }
186                                         /* FALLTHROUGH */
187                                 case 0:
188                                         if (server->m.flags & NCP_MOUNT_EXTRAS)
189                                                 inode->i_mode |= S_IRUGO;
190                                         break;
191                                 case aSYSTEM:
192                                         if (server->m.flags & NCP_MOUNT_EXTRAS)
193                                                 inode->i_mode |= (inode->i_mode >> 2) & S_IXUGO;
194                                         break;
195                                 /* case aSYSTEM|aHIDDEN: */
196                                 default:
197                                         /* reserved combination */
198                                         break;
199                         }
200                 }
201 #endif
202         }
203         if (nwi->attributes & aRONLY) inode->i_mode &= ~S_IWUGO;
204 }
205
206 void ncp_update_inode2(struct inode* inode, struct ncp_entry_info *nwinfo)
207 {
208         NCP_FINFO(inode)->flags = 0;
209         if (!atomic_read(&NCP_FINFO(inode)->opened)) {
210                 NCP_FINFO(inode)->nwattr = nwinfo->i.attributes;
211                 ncp_update_attrs(inode, nwinfo);
212         }
213
214         ncp_update_dates(inode, &nwinfo->i);
215         ncp_update_dirent(inode, nwinfo);
216 }
217
218 /*
219  * Fill in the inode based on the ncp_entry_info structure.  Used only for brand new inodes.
220  */
221 static void ncp_set_attr(struct inode *inode, struct ncp_entry_info *nwinfo)
222 {
223         struct ncp_server *server = NCP_SERVER(inode);
224
225         NCP_FINFO(inode)->flags = 0;
226         
227         ncp_update_attrs(inode, nwinfo);
228
229         DDPRINTK("ncp_read_inode: inode->i_mode = %u\n", inode->i_mode);
230
231         inode->i_nlink = 1;
232         inode->i_uid = server->m.uid;
233         inode->i_gid = server->m.gid;
234
235         ncp_update_dates(inode, &nwinfo->i);
236         ncp_update_inode(inode, nwinfo);
237 }
238
239 #if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
240 static const struct inode_operations ncp_symlink_inode_operations = {
241         .readlink       = generic_readlink,
242         .follow_link    = page_follow_link_light,
243         .put_link       = page_put_link,
244         .setattr        = ncp_notify_change,
245 };
246 #endif
247
248 /*
249  * Get a new inode.
250  */
251 struct inode * 
252 ncp_iget(struct super_block *sb, struct ncp_entry_info *info)
253 {
254         struct inode *inode;
255
256         if (info == NULL) {
257                 printk(KERN_ERR "ncp_iget: info is NULL\n");
258                 return NULL;
259         }
260
261         inode = new_inode(sb);
262         if (inode) {
263                 atomic_set(&NCP_FINFO(inode)->opened, info->opened);
264
265                 inode->i_mapping->backing_dev_info = sb->s_bdi;
266                 inode->i_ino = info->ino;
267                 ncp_set_attr(inode, info);
268                 if (S_ISREG(inode->i_mode)) {
269                         inode->i_op = &ncp_file_inode_operations;
270                         inode->i_fop = &ncp_file_operations;
271                 } else if (S_ISDIR(inode->i_mode)) {
272                         inode->i_op = &ncp_dir_inode_operations;
273                         inode->i_fop = &ncp_dir_operations;
274 #ifdef CONFIG_NCPFS_NFS_NS
275                 } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) || S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
276                         init_special_inode(inode, inode->i_mode,
277                                 new_decode_dev(info->i.nfs.rdev));
278 #endif
279 #if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
280                 } else if (S_ISLNK(inode->i_mode)) {
281                         inode->i_op = &ncp_symlink_inode_operations;
282                         inode->i_data.a_ops = &ncp_symlink_aops;
283 #endif
284                 } else {
285                         make_bad_inode(inode);
286                 }
287                 insert_inode_hash(inode);
288         } else
289                 printk(KERN_ERR "ncp_iget: iget failed!\n");
290         return inode;
291 }
292
293 static void
294 ncp_evict_inode(struct inode *inode)
295 {
296         truncate_inode_pages(&inode->i_data, 0);
297         end_writeback(inode);
298
299         if (S_ISDIR(inode->i_mode)) {
300                 DDPRINTK("ncp_evict_inode: put directory %ld\n", inode->i_ino);
301         }
302
303         if (ncp_make_closed(inode) != 0) {
304                 /* We can't do anything but complain. */
305                 printk(KERN_ERR "ncp_evict_inode: could not close\n");
306         }
307 }
308
309 static void ncp_stop_tasks(struct ncp_server *server) {
310         struct sock* sk = server->ncp_sock->sk;
311
312         lock_sock(sk);
313         sk->sk_error_report = server->error_report;
314         sk->sk_data_ready   = server->data_ready;
315         sk->sk_write_space  = server->write_space;
316         release_sock(sk);
317         del_timer_sync(&server->timeout_tm);
318
319         flush_work_sync(&server->rcv.tq);
320         if (sk->sk_socket->type == SOCK_STREAM)
321                 flush_work_sync(&server->tx.tq);
322         else
323                 flush_work_sync(&server->timeout_tq);
324 }
325
326 static int  ncp_show_options(struct seq_file *seq, struct vfsmount *mnt)
327 {
328         struct ncp_server *server = NCP_SBP(mnt->mnt_sb);
329         unsigned int tmp;
330
331         if (server->m.uid != 0)
332                 seq_printf(seq, ",uid=%u", server->m.uid);
333         if (server->m.gid != 0)
334                 seq_printf(seq, ",gid=%u", server->m.gid);
335         if (server->m.mounted_uid != 0)
336                 seq_printf(seq, ",owner=%u", server->m.mounted_uid);
337         tmp = server->m.file_mode & S_IALLUGO;
338         if (tmp != NCP_DEFAULT_FILE_MODE)
339                 seq_printf(seq, ",mode=0%o", tmp);
340         tmp = server->m.dir_mode & S_IALLUGO;
341         if (tmp != NCP_DEFAULT_DIR_MODE)
342                 seq_printf(seq, ",dirmode=0%o", tmp);
343         if (server->m.time_out != NCP_DEFAULT_TIME_OUT * HZ / 100) {
344                 tmp = server->m.time_out * 100 / HZ;
345                 seq_printf(seq, ",timeout=%u", tmp);
346         }
347         if (server->m.retry_count != NCP_DEFAULT_RETRY_COUNT)
348                 seq_printf(seq, ",retry=%u", server->m.retry_count);
349         if (server->m.flags != 0)
350                 seq_printf(seq, ",flags=%lu", server->m.flags);
351         if (server->m.wdog_pid != NULL)
352                 seq_printf(seq, ",wdogpid=%u", pid_vnr(server->m.wdog_pid));
353
354         return 0;
355 }
356
357 static const struct ncp_option ncp_opts[] = {
358         { "uid",        OPT_INT,        'u' },
359         { "gid",        OPT_INT,        'g' },
360         { "owner",      OPT_INT,        'o' },
361         { "mode",       OPT_INT,        'm' },
362         { "dirmode",    OPT_INT,        'd' },
363         { "timeout",    OPT_INT,        't' },
364         { "retry",      OPT_INT,        'r' },
365         { "flags",      OPT_INT,        'f' },
366         { "wdogpid",    OPT_INT,        'w' },
367         { "ncpfd",      OPT_INT,        'n' },
368         { "infofd",     OPT_INT,        'i' },  /* v5 */
369         { "version",    OPT_INT,        'v' },
370         { NULL,         0,              0 } };
371
372 static int ncp_parse_options(struct ncp_mount_data_kernel *data, char *options) {
373         int optval;
374         char *optarg;
375         unsigned long optint;
376         int version = 0;
377         int ret;
378
379         data->flags = 0;
380         data->int_flags = 0;
381         data->mounted_uid = 0;
382         data->wdog_pid = NULL;
383         data->ncp_fd = ~0;
384         data->time_out = NCP_DEFAULT_TIME_OUT;
385         data->retry_count = NCP_DEFAULT_RETRY_COUNT;
386         data->uid = 0;
387         data->gid = 0;
388         data->file_mode = NCP_DEFAULT_FILE_MODE;
389         data->dir_mode = NCP_DEFAULT_DIR_MODE;
390         data->info_fd = -1;
391         data->mounted_vol[0] = 0;
392         
393         while ((optval = ncp_getopt("ncpfs", &options, ncp_opts, NULL, &optarg, &optint)) != 0) {
394                 ret = optval;
395                 if (ret < 0)
396                         goto err;
397                 switch (optval) {
398                         case 'u':
399                                 data->uid = optint;
400                                 break;
401                         case 'g':
402                                 data->gid = optint;
403                                 break;
404                         case 'o':
405                                 data->mounted_uid = optint;
406                                 break;
407                         case 'm':
408                                 data->file_mode = optint;
409                                 break;
410                         case 'd':
411                                 data->dir_mode = optint;
412                                 break;
413                         case 't':
414                                 data->time_out = optint;
415                                 break;
416                         case 'r':
417                                 data->retry_count = optint;
418                                 break;
419                         case 'f':
420                                 data->flags = optint;
421                                 break;
422                         case 'w':
423                                 data->wdog_pid = find_get_pid(optint);
424                                 break;
425                         case 'n':
426                                 data->ncp_fd = optint;
427                                 break;
428                         case 'i':
429                                 data->info_fd = optint;
430                                 break;
431                         case 'v':
432                                 ret = -ECHRNG;
433                                 if (optint < NCP_MOUNT_VERSION_V4)
434                                         goto err;
435                                 if (optint > NCP_MOUNT_VERSION_V5)
436                                         goto err;
437                                 version = optint;
438                                 break;
439                         
440                 }
441         }
442         return 0;
443 err:
444         put_pid(data->wdog_pid);
445         data->wdog_pid = NULL;
446         return ret;
447 }
448
449 static int ncp_fill_super(struct super_block *sb, void *raw_data, int silent)
450 {
451         struct ncp_mount_data_kernel data;
452         struct ncp_server *server;
453         struct file *ncp_filp;
454         struct inode *root_inode;
455         struct inode *sock_inode;
456         struct socket *sock;
457         int error;
458         int default_bufsize;
459 #ifdef CONFIG_NCPFS_PACKET_SIGNING
460         int options;
461 #endif
462         struct ncp_entry_info finfo;
463
464         data.wdog_pid = NULL;
465         server = kzalloc(sizeof(struct ncp_server), GFP_KERNEL);
466         if (!server)
467                 return -ENOMEM;
468         sb->s_fs_info = server;
469
470         error = -EFAULT;
471         if (raw_data == NULL)
472                 goto out;
473         switch (*(int*)raw_data) {
474                 case NCP_MOUNT_VERSION:
475                         {
476                                 struct ncp_mount_data* md = (struct ncp_mount_data*)raw_data;
477
478                                 data.flags = md->flags;
479                                 data.int_flags = NCP_IMOUNT_LOGGEDIN_POSSIBLE;
480                                 data.mounted_uid = md->mounted_uid;
481                                 data.wdog_pid = find_get_pid(md->wdog_pid);
482                                 data.ncp_fd = md->ncp_fd;
483                                 data.time_out = md->time_out;
484                                 data.retry_count = md->retry_count;
485                                 data.uid = md->uid;
486                                 data.gid = md->gid;
487                                 data.file_mode = md->file_mode;
488                                 data.dir_mode = md->dir_mode;
489                                 data.info_fd = -1;
490                                 memcpy(data.mounted_vol, md->mounted_vol,
491                                         NCP_VOLNAME_LEN+1);
492                         }
493                         break;
494                 case NCP_MOUNT_VERSION_V4:
495                         {
496                                 struct ncp_mount_data_v4* md = (struct ncp_mount_data_v4*)raw_data;
497
498                                 data.flags = md->flags;
499                                 data.int_flags = 0;
500                                 data.mounted_uid = md->mounted_uid;
501                                 data.wdog_pid = find_get_pid(md->wdog_pid);
502                                 data.ncp_fd = md->ncp_fd;
503                                 data.time_out = md->time_out;
504                                 data.retry_count = md->retry_count;
505                                 data.uid = md->uid;
506                                 data.gid = md->gid;
507                                 data.file_mode = md->file_mode;
508                                 data.dir_mode = md->dir_mode;
509                                 data.info_fd = -1;
510                                 data.mounted_vol[0] = 0;
511                         }
512                         break;
513                 default:
514                         error = -ECHRNG;
515                         if (memcmp(raw_data, "vers", 4) == 0) {
516                                 error = ncp_parse_options(&data, raw_data);
517                         }
518                         if (error)
519                                 goto out;
520                         break;
521         }
522         error = -EBADF;
523         ncp_filp = fget(data.ncp_fd);
524         if (!ncp_filp)
525                 goto out;
526         error = -ENOTSOCK;
527         sock_inode = ncp_filp->f_path.dentry->d_inode;
528         if (!S_ISSOCK(sock_inode->i_mode))
529                 goto out_fput;
530         sock = SOCKET_I(sock_inode);
531         if (!sock)
532                 goto out_fput;
533                 
534         if (sock->type == SOCK_STREAM)
535                 default_bufsize = 0xF000;
536         else
537                 default_bufsize = 1024;
538
539         sb->s_flags |= MS_NODIRATIME;   /* probably even noatime */
540         sb->s_maxbytes = 0xFFFFFFFFU;
541         sb->s_blocksize = 1024; /* Eh...  Is this correct? */
542         sb->s_blocksize_bits = 10;
543         sb->s_magic = NCP_SUPER_MAGIC;
544         sb->s_op = &ncp_sops;
545         sb->s_d_op = &ncp_dentry_operations;
546         sb->s_bdi = &server->bdi;
547
548         server = NCP_SBP(sb);
549         memset(server, 0, sizeof(*server));
550
551         error = bdi_setup_and_register(&server->bdi, "ncpfs", BDI_CAP_MAP_COPY);
552         if (error)
553                 goto out_bdi;
554
555         server->ncp_filp = ncp_filp;
556         server->ncp_sock = sock;
557         
558         if (data.info_fd != -1) {
559                 struct socket *info_sock;
560
561                 error = -EBADF;
562                 server->info_filp = fget(data.info_fd);
563                 if (!server->info_filp)
564                         goto out_fput;
565                 error = -ENOTSOCK;
566                 sock_inode = server->info_filp->f_path.dentry->d_inode;
567                 if (!S_ISSOCK(sock_inode->i_mode))
568                         goto out_fput2;
569                 info_sock = SOCKET_I(sock_inode);
570                 if (!info_sock)
571                         goto out_fput2;
572                 error = -EBADFD;
573                 if (info_sock->type != SOCK_STREAM)
574                         goto out_fput2;
575                 server->info_sock = info_sock;
576         }
577
578 /*      server->lock = 0;       */
579         mutex_init(&server->mutex);
580         server->packet = NULL;
581 /*      server->buffer_size = 0;        */
582 /*      server->conn_status = 0;        */
583 /*      server->root_dentry = NULL;     */
584 /*      server->root_setuped = 0;       */
585         mutex_init(&server->root_setup_lock);
586 #ifdef CONFIG_NCPFS_PACKET_SIGNING
587 /*      server->sign_wanted = 0;        */
588 /*      server->sign_active = 0;        */
589 #endif
590         init_rwsem(&server->auth_rwsem);
591         server->auth.auth_type = NCP_AUTH_NONE;
592 /*      server->auth.object_name_len = 0;       */
593 /*      server->auth.object_name = NULL;        */
594 /*      server->auth.object_type = 0;           */
595 /*      server->priv.len = 0;                   */
596 /*      server->priv.data = NULL;               */
597
598         server->m = data;
599         /* Although anything producing this is buggy, it happens
600            now because of PATH_MAX changes.. */
601         if (server->m.time_out < 1) {
602                 server->m.time_out = 10;
603                 printk(KERN_INFO "You need to recompile your ncpfs utils..\n");
604         }
605         server->m.time_out = server->m.time_out * HZ / 100;
606         server->m.file_mode = (server->m.file_mode & S_IRWXUGO) | S_IFREG;
607         server->m.dir_mode = (server->m.dir_mode & S_IRWXUGO) | S_IFDIR;
608
609 #ifdef CONFIG_NCPFS_NLS
610         /* load the default NLS charsets */
611         server->nls_vol = load_nls_default();
612         server->nls_io = load_nls_default();
613 #endif /* CONFIG_NCPFS_NLS */
614
615         atomic_set(&server->dentry_ttl, 0);     /* no caching */
616
617         INIT_LIST_HEAD(&server->tx.requests);
618         mutex_init(&server->rcv.creq_mutex);
619         server->tx.creq         = NULL;
620         server->rcv.creq        = NULL;
621
622         init_timer(&server->timeout_tm);
623 #undef NCP_PACKET_SIZE
624 #define NCP_PACKET_SIZE 131072
625         error = -ENOMEM;
626         server->packet_size = NCP_PACKET_SIZE;
627         server->packet = vmalloc(NCP_PACKET_SIZE);
628         if (server->packet == NULL)
629                 goto out_nls;
630         server->txbuf = vmalloc(NCP_PACKET_SIZE);
631         if (server->txbuf == NULL)
632                 goto out_packet;
633         server->rxbuf = vmalloc(NCP_PACKET_SIZE);
634         if (server->rxbuf == NULL)
635                 goto out_txbuf;
636
637         lock_sock(sock->sk);
638         server->data_ready      = sock->sk->sk_data_ready;
639         server->write_space     = sock->sk->sk_write_space;
640         server->error_report    = sock->sk->sk_error_report;
641         sock->sk->sk_user_data  = server;
642         sock->sk->sk_data_ready   = ncp_tcp_data_ready;
643         sock->sk->sk_error_report = ncp_tcp_error_report;
644         if (sock->type == SOCK_STREAM) {
645                 server->rcv.ptr = (unsigned char*)&server->rcv.buf;
646                 server->rcv.len = 10;
647                 server->rcv.state = 0;
648                 INIT_WORK(&server->rcv.tq, ncp_tcp_rcv_proc);
649                 INIT_WORK(&server->tx.tq, ncp_tcp_tx_proc);
650                 sock->sk->sk_write_space = ncp_tcp_write_space;
651         } else {
652                 INIT_WORK(&server->rcv.tq, ncpdgram_rcv_proc);
653                 INIT_WORK(&server->timeout_tq, ncpdgram_timeout_proc);
654                 server->timeout_tm.data = (unsigned long)server;
655                 server->timeout_tm.function = ncpdgram_timeout_call;
656         }
657         release_sock(sock->sk);
658
659         ncp_lock_server(server);
660         error = ncp_connect(server);
661         ncp_unlock_server(server);
662         if (error < 0)
663                 goto out_rxbuf;
664         DPRINTK("ncp_fill_super: NCP_SBP(sb) = %x\n", (int) NCP_SBP(sb));
665
666         error = -EMSGSIZE;      /* -EREMOTESIDEINCOMPATIBLE */
667 #ifdef CONFIG_NCPFS_PACKET_SIGNING
668         if (ncp_negotiate_size_and_options(server, default_bufsize,
669                 NCP_DEFAULT_OPTIONS, &(server->buffer_size), &options) == 0)
670         {
671                 if (options != NCP_DEFAULT_OPTIONS)
672                 {
673                         if (ncp_negotiate_size_and_options(server, 
674                                 default_bufsize,
675                                 options & 2, 
676                                 &(server->buffer_size), &options) != 0)
677                                 
678                         {
679                                 goto out_disconnect;
680                         }
681                 }
682                 ncp_lock_server(server);
683                 if (options & 2)
684                         server->sign_wanted = 1;
685                 ncp_unlock_server(server);
686         }
687         else 
688 #endif  /* CONFIG_NCPFS_PACKET_SIGNING */
689         if (ncp_negotiate_buffersize(server, default_bufsize,
690                                      &(server->buffer_size)) != 0)
691                 goto out_disconnect;
692         DPRINTK("ncpfs: bufsize = %d\n", server->buffer_size);
693
694         memset(&finfo, 0, sizeof(finfo));
695         finfo.i.attributes      = aDIR;
696         finfo.i.dataStreamSize  = 0;    /* ignored */
697         finfo.i.dirEntNum       = 0;
698         finfo.i.DosDirNum       = 0;
699 #ifdef CONFIG_NCPFS_SMALLDOS
700         finfo.i.NSCreator       = NW_NS_DOS;
701 #endif
702         finfo.volume            = NCP_NUMBER_OF_VOLUMES;
703         /* set dates of mountpoint to Jan 1, 1986; 00:00 */
704         finfo.i.creationTime    = finfo.i.modifyTime
705                                 = cpu_to_le16(0x0000);
706         finfo.i.creationDate    = finfo.i.modifyDate
707                                 = finfo.i.lastAccessDate
708                                 = cpu_to_le16(0x0C21);
709         finfo.i.nameLen         = 0;
710         finfo.i.entryName[0]    = '\0';
711
712         finfo.opened            = 0;
713         finfo.ino               = 2;    /* tradition */
714
715         server->name_space[finfo.volume] = NW_NS_DOS;
716
717         error = -ENOMEM;
718         root_inode = ncp_iget(sb, &finfo);
719         if (!root_inode)
720                 goto out_disconnect;
721         DPRINTK("ncp_fill_super: root vol=%d\n", NCP_FINFO(root_inode)->volNumber);
722         sb->s_root = d_alloc_root(root_inode);
723         if (!sb->s_root)
724                 goto out_no_root;
725         return 0;
726
727 out_no_root:
728         iput(root_inode);
729 out_disconnect:
730         ncp_lock_server(server);
731         ncp_disconnect(server);
732         ncp_unlock_server(server);
733 out_rxbuf:
734         ncp_stop_tasks(server);
735         vfree(server->rxbuf);
736 out_txbuf:
737         vfree(server->txbuf);
738 out_packet:
739         vfree(server->packet);
740 out_nls:
741 #ifdef CONFIG_NCPFS_NLS
742         unload_nls(server->nls_io);
743         unload_nls(server->nls_vol);
744 #endif
745         mutex_destroy(&server->rcv.creq_mutex);
746         mutex_destroy(&server->root_setup_lock);
747         mutex_destroy(&server->mutex);
748 out_fput2:
749         if (server->info_filp)
750                 fput(server->info_filp);
751 out_fput:
752         bdi_destroy(&server->bdi);
753 out_bdi:
754         /* 23/12/1998 Marcin Dalecki <dalecki@cs.net.pl>:
755          * 
756          * The previously used put_filp(ncp_filp); was bogus, since
757          * it doesn't perform proper unlocking.
758          */
759         fput(ncp_filp);
760 out:
761         put_pid(data.wdog_pid);
762         sb->s_fs_info = NULL;
763         kfree(server);
764         return error;
765 }
766
767 static void ncp_put_super(struct super_block *sb)
768 {
769         struct ncp_server *server = NCP_SBP(sb);
770
771         ncp_lock_server(server);
772         ncp_disconnect(server);
773         ncp_unlock_server(server);
774
775         ncp_stop_tasks(server);
776
777 #ifdef CONFIG_NCPFS_NLS
778         /* unload the NLS charsets */
779         unload_nls(server->nls_vol);
780         unload_nls(server->nls_io);
781 #endif /* CONFIG_NCPFS_NLS */
782         mutex_destroy(&server->rcv.creq_mutex);
783         mutex_destroy(&server->root_setup_lock);
784         mutex_destroy(&server->mutex);
785
786         if (server->info_filp)
787                 fput(server->info_filp);
788         fput(server->ncp_filp);
789         kill_pid(server->m.wdog_pid, SIGTERM, 1);
790         put_pid(server->m.wdog_pid);
791
792         bdi_destroy(&server->bdi);
793         kfree(server->priv.data);
794         kfree(server->auth.object_name);
795         vfree(server->rxbuf);
796         vfree(server->txbuf);
797         vfree(server->packet);
798         sb->s_fs_info = NULL;
799         kfree(server);
800 }
801
802 static int ncp_statfs(struct dentry *dentry, struct kstatfs *buf)
803 {
804         struct dentry* d;
805         struct inode* i;
806         struct ncp_inode_info* ni;
807         struct ncp_server* s;
808         struct ncp_volume_info vi;
809         struct super_block *sb = dentry->d_sb;
810         int err;
811         __u8 dh;
812         
813         d = sb->s_root;
814         if (!d) {
815                 goto dflt;
816         }
817         i = d->d_inode;
818         if (!i) {
819                 goto dflt;
820         }
821         ni = NCP_FINFO(i);
822         if (!ni) {
823                 goto dflt;
824         }
825         s = NCP_SBP(sb);
826         if (!s) {
827                 goto dflt;
828         }
829         if (!s->m.mounted_vol[0]) {
830                 goto dflt;
831         }
832
833         err = ncp_dirhandle_alloc(s, ni->volNumber, ni->DosDirNum, &dh);
834         if (err) {
835                 goto dflt;
836         }
837         err = ncp_get_directory_info(s, dh, &vi);
838         ncp_dirhandle_free(s, dh);
839         if (err) {
840                 goto dflt;
841         }
842         buf->f_type = NCP_SUPER_MAGIC;
843         buf->f_bsize = vi.sectors_per_block * 512;
844         buf->f_blocks = vi.total_blocks;
845         buf->f_bfree = vi.free_blocks;
846         buf->f_bavail = vi.free_blocks;
847         buf->f_files = vi.total_dir_entries;
848         buf->f_ffree = vi.available_dir_entries;
849         buf->f_namelen = 12;
850         return 0;
851
852         /* We cannot say how much disk space is left on a mounted
853            NetWare Server, because free space is distributed over
854            volumes, and the current user might have disk quotas. So
855            free space is not that simple to determine. Our decision
856            here is to err conservatively. */
857
858 dflt:;
859         buf->f_type = NCP_SUPER_MAGIC;
860         buf->f_bsize = NCP_BLOCK_SIZE;
861         buf->f_blocks = 0;
862         buf->f_bfree = 0;
863         buf->f_bavail = 0;
864         buf->f_namelen = 12;
865         return 0;
866 }
867
868 int ncp_notify_change(struct dentry *dentry, struct iattr *attr)
869 {
870         struct inode *inode = dentry->d_inode;
871         int result = 0;
872         __le32 info_mask;
873         struct nw_modify_dos_info info;
874         struct ncp_server *server;
875
876         result = -EIO;
877
878         server = NCP_SERVER(inode);
879         if (!server)    /* How this could happen? */
880                 goto out;
881
882         /* ageing the dentry to force validation */
883         ncp_age_dentry(server, dentry);
884
885         result = inode_change_ok(inode, attr);
886         if (result < 0)
887                 goto out;
888
889         result = -EPERM;
890         if (((attr->ia_valid & ATTR_UID) &&
891              (attr->ia_uid != server->m.uid)))
892                 goto out;
893
894         if (((attr->ia_valid & ATTR_GID) &&
895              (attr->ia_gid != server->m.gid)))
896                 goto out;
897
898         if (((attr->ia_valid & ATTR_MODE) &&
899              (attr->ia_mode &
900               ~(S_IFREG | S_IFDIR | S_IRWXUGO))))
901                 goto out;
902
903         info_mask = 0;
904         memset(&info, 0, sizeof(info));
905
906 #if 1 
907         if ((attr->ia_valid & ATTR_MODE) != 0)
908         {
909                 umode_t newmode = attr->ia_mode;
910
911                 info_mask |= DM_ATTRIBUTES;
912
913                 if (S_ISDIR(inode->i_mode)) {
914                         newmode &= server->m.dir_mode;
915                 } else {
916 #ifdef CONFIG_NCPFS_EXTRAS                      
917                         if (server->m.flags & NCP_MOUNT_EXTRAS) {
918                                 /* any non-default execute bit set */
919                                 if (newmode & ~server->m.file_mode & S_IXUGO)
920                                         info.attributes |= aSHARED | aSYSTEM;
921                                 /* read for group/world and not in default file_mode */
922                                 else if (newmode & ~server->m.file_mode & S_IRUGO)
923                                         info.attributes |= aSHARED;
924                         } else
925 #endif
926                                 newmode &= server->m.file_mode;                 
927                 }
928                 if (newmode & S_IWUGO)
929                         info.attributes &= ~(aRONLY|aRENAMEINHIBIT|aDELETEINHIBIT);
930                 else
931                         info.attributes |=  (aRONLY|aRENAMEINHIBIT|aDELETEINHIBIT);
932
933 #ifdef CONFIG_NCPFS_NFS_NS
934                 if (ncp_is_nfs_extras(server, NCP_FINFO(inode)->volNumber)) {
935                         result = ncp_modify_nfs_info(server,
936                                                      NCP_FINFO(inode)->volNumber,
937                                                      NCP_FINFO(inode)->dirEntNum,
938                                                      attr->ia_mode, 0);
939                         if (result != 0)
940                                 goto out;
941                         info.attributes &= ~(aSHARED | aSYSTEM);
942                         {
943                                 /* mark partial success */
944                                 struct iattr tmpattr;
945                                 
946                                 tmpattr.ia_valid = ATTR_MODE;
947                                 tmpattr.ia_mode = attr->ia_mode;
948
949                                 setattr_copy(inode, &tmpattr);
950                                 mark_inode_dirty(inode);
951                         }
952                 }
953 #endif
954         }
955 #endif
956
957         /* Do SIZE before attributes, otherwise mtime together with size does not work...
958          */
959         if ((attr->ia_valid & ATTR_SIZE) != 0) {
960                 int written;
961
962                 DPRINTK("ncpfs: trying to change size to %ld\n",
963                         attr->ia_size);
964
965                 if ((result = ncp_make_open(inode, O_WRONLY)) < 0) {
966                         result = -EACCES;
967                         goto out;
968                 }
969                 ncp_write_kernel(NCP_SERVER(inode), NCP_FINFO(inode)->file_handle,
970                           attr->ia_size, 0, "", &written);
971
972                 /* According to ndir, the changes only take effect after
973                    closing the file */
974                 ncp_inode_close(inode);
975                 result = ncp_make_closed(inode);
976                 if (result)
977                         goto out;
978
979                 if (attr->ia_size != i_size_read(inode)) {
980                         result = vmtruncate(inode, attr->ia_size);
981                         if (result)
982                                 goto out;
983                         mark_inode_dirty(inode);
984                 }
985         }
986         if ((attr->ia_valid & ATTR_CTIME) != 0) {
987                 info_mask |= (DM_CREATE_TIME | DM_CREATE_DATE);
988                 ncp_date_unix2dos(attr->ia_ctime.tv_sec,
989                              &info.creationTime, &info.creationDate);
990         }
991         if ((attr->ia_valid & ATTR_MTIME) != 0) {
992                 info_mask |= (DM_MODIFY_TIME | DM_MODIFY_DATE);
993                 ncp_date_unix2dos(attr->ia_mtime.tv_sec,
994                                   &info.modifyTime, &info.modifyDate);
995         }
996         if ((attr->ia_valid & ATTR_ATIME) != 0) {
997                 __le16 dummy;
998                 info_mask |= (DM_LAST_ACCESS_DATE);
999                 ncp_date_unix2dos(attr->ia_atime.tv_sec,
1000                                   &dummy, &info.lastAccessDate);
1001         }
1002         if (info_mask != 0) {
1003                 result = ncp_modify_file_or_subdir_dos_info(NCP_SERVER(inode),
1004                                       inode, info_mask, &info);
1005                 if (result != 0) {
1006                         if (info_mask == (DM_CREATE_TIME | DM_CREATE_DATE)) {
1007                                 /* NetWare seems not to allow this. I
1008                                    do not know why. So, just tell the
1009                                    user everything went fine. This is
1010                                    a terrible hack, but I do not know
1011                                    how to do this correctly. */
1012                                 result = 0;
1013                         } else
1014                                 goto out;
1015                 }
1016 #ifdef CONFIG_NCPFS_STRONG              
1017                 if ((!result) && (info_mask & DM_ATTRIBUTES))
1018                         NCP_FINFO(inode)->nwattr = info.attributes;
1019 #endif
1020         }
1021         if (result)
1022                 goto out;
1023
1024         setattr_copy(inode, attr);
1025         mark_inode_dirty(inode);
1026
1027 out:
1028         if (result > 0)
1029                 result = -EACCES;
1030         return result;
1031 }
1032
1033 static struct dentry *ncp_mount(struct file_system_type *fs_type,
1034         int flags, const char *dev_name, void *data)
1035 {
1036         return mount_nodev(fs_type, flags, data, ncp_fill_super);
1037 }
1038
1039 static struct file_system_type ncp_fs_type = {
1040         .owner          = THIS_MODULE,
1041         .name           = "ncpfs",
1042         .mount          = ncp_mount,
1043         .kill_sb        = kill_anon_super,
1044         .fs_flags       = FS_BINARY_MOUNTDATA,
1045 };
1046
1047 static int __init init_ncp_fs(void)
1048 {
1049         int err;
1050         DPRINTK("ncpfs: init_ncp_fs called\n");
1051
1052         err = init_inodecache();
1053         if (err)
1054                 goto out1;
1055         err = register_filesystem(&ncp_fs_type);
1056         if (err)
1057                 goto out;
1058         return 0;
1059 out:
1060         destroy_inodecache();
1061 out1:
1062         return err;
1063 }
1064
1065 static void __exit exit_ncp_fs(void)
1066 {
1067         DPRINTK("ncpfs: exit_ncp_fs called\n");
1068         unregister_filesystem(&ncp_fs_type);
1069         destroy_inodecache();
1070 }
1071
1072 module_init(init_ncp_fs)
1073 module_exit(exit_ncp_fs)
1074 MODULE_LICENSE("GPL");