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