projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[media] drivers/media/video: fix memory leak of snd_cx18_init()
[deliverable/linux.git] / fs / ncpfs / inode.c
CommitLineData
1da177e4
LT		 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
1da177e4
LT		 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>
1da177e4 29#include <linux/vfs.h>
564cd138
MS		 30#include <linux/mount.h>
31#include <linux/seq_file.h>
34286d66 32#include <linux/namei.h>
1da177e4 33
1da177e4
LT		 34#include <net/sock.h>
35
32c419d9 36#include "ncp_fs.h"
1da177e4
LT		 37#include "getopt.h"
38
564cd138
MS		 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
94ee8494 44static void ncp_evict_inode(struct inode *);
1da177e4 45static void ncp_put_super(struct super_block *);
726c3342 46static int ncp_statfs(struct dentry *, struct kstatfs *);
564cd138 47static int ncp_show_options(struct seq_file *, struct vfsmount *);
1da177e4 48
e18b890b 49static struct kmem_cache * ncp_inode_cachep;
1da177e4
LT		 50
51static struct inode *ncp_alloc_inode(struct super_block *sb)
52{
53 struct ncp_inode_info *ei;
e94b1766 54 ei = (struct ncp_inode_info *)kmem_cache_alloc(ncp_inode_cachep, GFP_KERNEL);
1da177e4
LT		 55 if (!ei)
56 return NULL;
57 return &ei->vfs_inode;
58}
59
fa0d7e3d 60static void ncp_i_callback(struct rcu_head *head)
1da177e4 61{
fa0d7e3d
NP		 62 struct inode *inode = container_of(head, struct inode, i_rcu);
63 INIT_LIST_HEAD(&inode->i_dentry);
1da177e4
LT		 64 kmem_cache_free(ncp_inode_cachep, NCP_FINFO(inode));
65}
66
fa0d7e3d
NP		 67static void ncp_destroy_inode(struct inode *inode)
68{
69 call_rcu(&inode->i_rcu, ncp_i_callback);
70}
71
51cc5068 72static void init_once(void *foo)
1da177e4
LT		 73{
74 struct ncp_inode_info *ei = (struct ncp_inode_info *) foo;
75
a35afb83
CL		 76 mutex_init(&ei->open_mutex);
77 inode_init_once(&ei->vfs_inode);
1da177e4 78}
20c2df83 79
1da177e4
LT		 80static int init_inodecache(void)
81{
82 ncp_inode_cachep = kmem_cache_create("ncp_inode_cache",
83 sizeof(struct ncp_inode_info),
fffb60f9
PJ		 84 0, (SLAB_RECLAIM_ACCOUNT|
85 SLAB_MEM_SPREAD),
20c2df83 86 init_once);
1da177e4
LT		 87 if (ncp_inode_cachep == NULL)
88 return -ENOMEM;
89 return 0;
90}
91
92static void destroy_inodecache(void)
93{
1a1d92c1 94 kmem_cache_destroy(ncp_inode_cachep);
1da177e4
LT		 95}
96
97static int ncp_remount(struct super_block *sb, int *flags, char* data)
98{
99 *flags |= MS_NODIRATIME;
100 return 0;
101}
102
ee9b6d61 103static const struct super_operations ncp_sops =
1da177e4
LT		 104{
105 .alloc_inode = ncp_alloc_inode,
106 .destroy_inode = ncp_destroy_inode,
107 .drop_inode = generic_delete_inode,
94ee8494 108 .evict_inode = ncp_evict_inode,
1da177e4
LT		 109 .put_super = ncp_put_super,
110 .statfs = ncp_statfs,
111 .remount_fs = ncp_remount,
564cd138 112 .show_options = ncp_show_options,
1da177e4
LT		 113};
114
1da177e4
LT		 115/*
116 * Fill in the ncpfs-specific information in the inode.
117 */
118static 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
125void 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
137static 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
2e54eb96 147 inode->i_blocks = (i_size_read(inode) + NCP_BLOCK_SIZE - 1) >> NCP_BLOCK_SHIFT;
1da177e4
LT		 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
157static 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 ??? */
2e54eb96 166 i_size_write(inode, NCP_BLOCK_SIZE);
1da177e4 167 } else {
2e54eb96
PV		 168 u32 size;
169
1da177e4 170 inode->i_mode = server->m.file_mode;
2e54eb96
PV		 171 size = le32_to_cpu(nwi->dataStreamSize);
172 i_size_write(inode, size);
1da177e4
LT		 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) {
2e54eb96
PV		 179 if (/* (size >= NCP_MIN_SYMLINK_SIZE)
180 && */ (size <= NCP_MAX_SYMLINK_SIZE)) {
1da177e4
LT		 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
206void 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/*
2e54eb96 219 * Fill in the inode based on the ncp_entry_info structure. Used only for brand new inodes.
1da177e4
LT		 220 */
221static 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;
1da177e4
LT		 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)
92e1d5be 240static const struct inode_operations ncp_symlink_inode_operations = {
1da177e4
LT		 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 */
251struct inode *
252ncp_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
2e54eb96 265 inode->i_mapping->backing_dev_info = sb->s_bdi;
1da177e4
LT		 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
293static void
94ee8494 294ncp_evict_inode(struct inode *inode)
1da177e4 295{
fef26658 296 truncate_inode_pages(&inode->i_data, 0);
94ee8494 297 end_writeback(inode);
fef26658 298
1da177e4 299 if (S_ISDIR(inode->i_mode)) {
94ee8494 300 DDPRINTK("ncp_evict_inode: put directory %ld\n", inode->i_ino);
1da177e4
LT		 301 }
302
303 if (ncp_make_closed(inode) != 0) {
304 /* We can't do anything but complain. */
94ee8494 305 printk(KERN_ERR "ncp_evict_inode: could not close\n");
1da177e4 306 }
1da177e4
LT		 307}
308
309static void ncp_stop_tasks(struct ncp_server *server) {
310 struct sock* sk = server->ncp_sock->sk;
2a4df5d3
PV		 311
312 lock_sock(sk);
1da177e4
LT		 313 sk->sk_error_report = server->error_report;
314 sk->sk_data_ready = server->data_ready;
315 sk->sk_write_space = server->write_space;
2a4df5d3 316 release_sock(sk);
1da177e4 317 del_timer_sync(&server->timeout_tm);
5d8e4bdd
TH		 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);
1da177e4
LT		 324}
325
564cd138
MS		 326static 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
1da177e4
LT		 357static 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
372static 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;
1de24126 377 int ret;
1da177e4
LT		 378
379 data->flags = 0;
380 data->int_flags = 0;
381 data->mounted_uid = 0;
2154227a 382 data->wdog_pid = NULL;
1da177e4 383 data->ncp_fd = ~0;
564cd138
MS		 384 data->time_out = NCP_DEFAULT_TIME_OUT;
385 data->retry_count = NCP_DEFAULT_RETRY_COUNT;
1da177e4
LT		 386 data->uid = 0;
387 data->gid = 0;
564cd138
MS		 388 data->file_mode = NCP_DEFAULT_FILE_MODE;
389 data->dir_mode = NCP_DEFAULT_DIR_MODE;
1da177e4
LT		 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) {
1de24126
EB		 394 ret = optval;
395 if (ret < 0)
396 goto err;
1da177e4
LT		 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':
2154227a 423 data->wdog_pid = find_get_pid(optint);
1da177e4
LT		 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':
1de24126
EB		 432 ret = -ECHRNG;
433 if (optint < NCP_MOUNT_VERSION_V4)
434 goto err;
435 if (optint > NCP_MOUNT_VERSION_V5)
436 goto err;
1da177e4
LT		 437 version = optint;
438 break;
439
440 }
441 }
442 return 0;
1de24126
EB		 443err:
444 put_pid(data->wdog_pid);
445 data->wdog_pid = NULL;
446 return ret;
1da177e4
LT		 447}
448
449static 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
2a5cac17 464 memset(&data, 0, sizeof(data));
f8314dc6 465 server = kzalloc(sizeof(struct ncp_server), GFP_KERNEL);
1da177e4
LT		 466 if (!server)
467 return -ENOMEM;
468 sb->s_fs_info = server;
1da177e4
LT		 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;
2154227a 481 data.wdog_pid = find_get_pid(md->wdog_pid);
1da177e4
LT		 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;
1da177e4 499 data.mounted_uid = md->mounted_uid;
2154227a 500 data.wdog_pid = find_get_pid(md->wdog_pid);
1da177e4
LT		 501 data.ncp_fd = md->ncp_fd;
502 data.time_out = md->time_out;
503 data.retry_count = md->retry_count;
504 data.uid = md->uid;
505 data.gid = md->gid;
506 data.file_mode = md->file_mode;
507 data.dir_mode = md->dir_mode;
508 data.info_fd = -1;
1da177e4
LT		 509 }
510 break;
511 default:
512 error = -ECHRNG;
513 if (memcmp(raw_data, "vers", 4) == 0) {
514 error = ncp_parse_options(&data, raw_data);
515 }
516 if (error)
517 goto out;
518 break;
519 }
520 error = -EBADF;
521 ncp_filp = fget(data.ncp_fd);
522 if (!ncp_filp)
523 goto out;
524 error = -ENOTSOCK;
92e5baef 525 sock_inode = ncp_filp->f_path.dentry->d_inode;
1da177e4
LT		 526 if (!S_ISSOCK(sock_inode->i_mode))
527 goto out_fput;
528 sock = SOCKET_I(sock_inode);
529 if (!sock)
530 goto out_fput;
531
532 if (sock->type == SOCK_STREAM)
533 default_bufsize = 0xF000;
534 else
535 default_bufsize = 1024;
536
537 sb->s_flags |= MS_NODIRATIME; /* probably even noatime */
538 sb->s_maxbytes = 0xFFFFFFFFU;
539 sb->s_blocksize = 1024; /* Eh... Is this correct? */
540 sb->s_blocksize_bits = 10;
541 sb->s_magic = NCP_SUPER_MAGIC;
542 sb->s_op = &ncp_sops;
0378c405 543 sb->s_d_op = &ncp_dentry_operations;
f1970c73 544 sb->s_bdi = &server->bdi;
1da177e4
LT		 545
546 server = NCP_SBP(sb);
547 memset(server, 0, sizeof(*server));
548
f1970c73
JA		 549 error = bdi_setup_and_register(&server->bdi, "ncpfs", BDI_CAP_MAP_COPY);
550 if (error)
551 goto out_bdi;
552
1da177e4
LT		 553 server->ncp_filp = ncp_filp;
554 server->ncp_sock = sock;
555
556 if (data.info_fd != -1) {
557 struct socket *info_sock;
558
559 error = -EBADF;
560 server->info_filp = fget(data.info_fd);
561 if (!server->info_filp)
562 goto out_fput;
563 error = -ENOTSOCK;
92e5baef 564 sock_inode = server->info_filp->f_path.dentry->d_inode;
1da177e4
LT		 565 if (!S_ISSOCK(sock_inode->i_mode))
566 goto out_fput2;
567 info_sock = SOCKET_I(sock_inode);
568 if (!info_sock)
569 goto out_fput2;
570 error = -EBADFD;
571 if (info_sock->type != SOCK_STREAM)
572 goto out_fput2;
573 server->info_sock = info_sock;
574 }
575
576/* server->lock = 0; */
8e3f9045 577 mutex_init(&server->mutex);
1da177e4
LT		 578 server->packet = NULL;
579/* server->buffer_size = 0; */
580/* server->conn_status = 0; */
581/* server->root_dentry = NULL; */
582/* server->root_setuped = 0; */
2e54eb96 583 mutex_init(&server->root_setup_lock);
1da177e4
LT		 584#ifdef CONFIG_NCPFS_PACKET_SIGNING
585/* server->sign_wanted = 0; */
586/* server->sign_active = 0; */
587#endif
2e54eb96 588 init_rwsem(&server->auth_rwsem);
1da177e4
LT		 589 server->auth.auth_type = NCP_AUTH_NONE;
590/* server->auth.object_name_len = 0; */
591/* server->auth.object_name = NULL; */
592/* server->auth.object_type = 0; */
593/* server->priv.len = 0; */
594/* server->priv.data = NULL; */
595
596 server->m = data;
25985edc 597 /* Although anything producing this is buggy, it happens
1da177e4
LT		 598 now because of PATH_MAX changes.. */
599 if (server->m.time_out < 1) {
600 server->m.time_out = 10;
601 printk(KERN_INFO "You need to recompile your ncpfs utils..\n");
602 }
603 server->m.time_out = server->m.time_out * HZ / 100;
604 server->m.file_mode = (server->m.file_mode & S_IRWXUGO) | S_IFREG;
605 server->m.dir_mode = (server->m.dir_mode & S_IRWXUGO) | S_IFDIR;
606
607#ifdef CONFIG_NCPFS_NLS
608 /* load the default NLS charsets */
609 server->nls_vol = load_nls_default();
610 server->nls_io = load_nls_default();
611#endif /* CONFIG_NCPFS_NLS */
612
2e54eb96 613 atomic_set(&server->dentry_ttl, 0); /* no caching */
1da177e4
LT		 614
615 INIT_LIST_HEAD(&server->tx.requests);
8e3f9045 616 mutex_init(&server->rcv.creq_mutex);
1da177e4
LT		 617 server->tx.creq = NULL;
618 server->rcv.creq = NULL;
1da177e4
LT		 619
620 init_timer(&server->timeout_tm);
621#undef NCP_PACKET_SIZE
622#define NCP_PACKET_SIZE 131072
623 error = -ENOMEM;
624 server->packet_size = NCP_PACKET_SIZE;
625 server->packet = vmalloc(NCP_PACKET_SIZE);
626 if (server->packet == NULL)
627 goto out_nls;
c5f93cf1
PO		 628 server->txbuf = vmalloc(NCP_PACKET_SIZE);
629 if (server->txbuf == NULL)
630 goto out_packet;
631 server->rxbuf = vmalloc(NCP_PACKET_SIZE);
632 if (server->rxbuf == NULL)
633 goto out_txbuf;
1da177e4 634
2a4df5d3
PV		 635 lock_sock(sock->sk);
636 server->data_ready = sock->sk->sk_data_ready;
637 server->write_space = sock->sk->sk_write_space;
638 server->error_report = sock->sk->sk_error_report;
639 sock->sk->sk_user_data = server;
1da177e4
LT		 640 sock->sk->sk_data_ready = ncp_tcp_data_ready;
641 sock->sk->sk_error_report = ncp_tcp_error_report;
642 if (sock->type == SOCK_STREAM) {
643 server->rcv.ptr = (unsigned char*)&server->rcv.buf;
644 server->rcv.len = 10;
645 server->rcv.state = 0;
c4028958
DH		 646 INIT_WORK(&server->rcv.tq, ncp_tcp_rcv_proc);
647 INIT_WORK(&server->tx.tq, ncp_tcp_tx_proc);
1da177e4
LT		 648 sock->sk->sk_write_space = ncp_tcp_write_space;
649 } else {
c4028958
DH		 650 INIT_WORK(&server->rcv.tq, ncpdgram_rcv_proc);
651 INIT_WORK(&server->timeout_tq, ncpdgram_timeout_proc);
1da177e4
LT		 652 server->timeout_tm.data = (unsigned long)server;
653 server->timeout_tm.function = ncpdgram_timeout_call;
654 }
2a4df5d3 655 release_sock(sock->sk);
1da177e4
LT		 656
657 ncp_lock_server(server);
658 error = ncp_connect(server);
659 ncp_unlock_server(server);
660 if (error < 0)
c5f93cf1 661 goto out_rxbuf;
1da177e4
LT		 662 DPRINTK("ncp_fill_super: NCP_SBP(sb) = %x\n", (int) NCP_SBP(sb));
663
664 error = -EMSGSIZE; /* -EREMOTESIDEINCOMPATIBLE */
665#ifdef CONFIG_NCPFS_PACKET_SIGNING
666 if (ncp_negotiate_size_and_options(server, default_bufsize,
667 NCP_DEFAULT_OPTIONS, &(server->buffer_size), &options) == 0)
668 {
669 if (options != NCP_DEFAULT_OPTIONS)
670 {
671 if (ncp_negotiate_size_and_options(server,
672 default_bufsize,
673 options & 2,
674 &(server->buffer_size), &options) != 0)
675
676 {
677 goto out_disconnect;
678 }
679 }
2e54eb96 680 ncp_lock_server(server);
1da177e4
LT		 681 if (options & 2)
682 server->sign_wanted = 1;
2e54eb96 683 ncp_unlock_server(server);
1da177e4
LT		 684 }
685 else
686#endif /* CONFIG_NCPFS_PACKET_SIGNING */
687 if (ncp_negotiate_buffersize(server, default_bufsize,
688 &(server->buffer_size)) != 0)
689 goto out_disconnect;
690 DPRINTK("ncpfs: bufsize = %d\n", server->buffer_size);
691
692 memset(&finfo, 0, sizeof(finfo));
693 finfo.i.attributes = aDIR;
694 finfo.i.dataStreamSize = 0; /* ignored */
695 finfo.i.dirEntNum = 0;
696 finfo.i.DosDirNum = 0;
697#ifdef CONFIG_NCPFS_SMALLDOS
698 finfo.i.NSCreator = NW_NS_DOS;
699#endif
700 finfo.volume = NCP_NUMBER_OF_VOLUMES;
701 /* set dates of mountpoint to Jan 1, 1986; 00:00 */
702 finfo.i.creationTime = finfo.i.modifyTime
703 = cpu_to_le16(0x0000);
704 finfo.i.creationDate = finfo.i.modifyDate
705 = finfo.i.lastAccessDate
706 = cpu_to_le16(0x0C21);
707 finfo.i.nameLen = 0;
708 finfo.i.entryName[0] = '\0';
709
710 finfo.opened = 0;
711 finfo.ino = 2; /* tradition */
712
713 server->name_space[finfo.volume] = NW_NS_DOS;
714
715 error = -ENOMEM;
716 root_inode = ncp_iget(sb, &finfo);
717 if (!root_inode)
718 goto out_disconnect;
719 DPRINTK("ncp_fill_super: root vol=%d\n", NCP_FINFO(root_inode)->volNumber);
720 sb->s_root = d_alloc_root(root_inode);
721 if (!sb->s_root)
722 goto out_no_root;
1da177e4
LT		 723 return 0;
724
725out_no_root:
726 iput(root_inode);
727out_disconnect:
728 ncp_lock_server(server);
729 ncp_disconnect(server);
730 ncp_unlock_server(server);
c5f93cf1 731out_rxbuf:
1da177e4 732 ncp_stop_tasks(server);
c5f93cf1
PO		 733 vfree(server->rxbuf);
734out_txbuf:
735 vfree(server->txbuf);
736out_packet:
1da177e4
LT		 737 vfree(server->packet);
738out_nls:
739#ifdef CONFIG_NCPFS_NLS
740 unload_nls(server->nls_io);
741 unload_nls(server->nls_vol);
742#endif
2e54eb96
PV		 743 mutex_destroy(&server->rcv.creq_mutex);
744 mutex_destroy(&server->root_setup_lock);
745 mutex_destroy(&server->mutex);
1da177e4
LT		 746out_fput2:
747 if (server->info_filp)
748 fput(server->info_filp);
749out_fput:
f1970c73
JA		 750 bdi_destroy(&server->bdi);
751out_bdi:
1da177e4
LT		 752 /* 23/12/1998 Marcin Dalecki <dalecki@cs.net.pl>:
753 *
e956b4b7
MW		 754 * The previously used put_filp(ncp_filp); was bogus, since
755 * it doesn't perform proper unlocking.
1da177e4
LT		 756 */
757 fput(ncp_filp);
758out:
1de24126 759 put_pid(data.wdog_pid);
1da177e4
LT		 760 sb->s_fs_info = NULL;
761 kfree(server);
762 return error;
763}
764
765static void ncp_put_super(struct super_block *sb)
766{
767 struct ncp_server *server = NCP_SBP(sb);
768
769 ncp_lock_server(server);
770 ncp_disconnect(server);
771 ncp_unlock_server(server);
772
773 ncp_stop_tasks(server);
774
775#ifdef CONFIG_NCPFS_NLS
776 /* unload the NLS charsets */
6d729e44
TG		 777 unload_nls(server->nls_vol);
778 unload_nls(server->nls_io);
1da177e4 779#endif /* CONFIG_NCPFS_NLS */
2e54eb96
PV		 780 mutex_destroy(&server->rcv.creq_mutex);
781 mutex_destroy(&server->root_setup_lock);
782 mutex_destroy(&server->mutex);
1da177e4
LT		 783
784 if (server->info_filp)
785 fput(server->info_filp);
786 fput(server->ncp_filp);
2154227a
EB		 787 kill_pid(server->m.wdog_pid, SIGTERM, 1);
788 put_pid(server->m.wdog_pid);
1da177e4 789
f1970c73 790 bdi_destroy(&server->bdi);
44db77f3
PE		 791 kfree(server->priv.data);
792 kfree(server->auth.object_name);
c5f93cf1
PO		 793 vfree(server->rxbuf);
794 vfree(server->txbuf);
1da177e4
LT		 795 vfree(server->packet);
796 sb->s_fs_info = NULL;
797 kfree(server);
798}
799
726c3342 800static int ncp_statfs(struct dentry *dentry, struct kstatfs *buf)
1da177e4
LT		 801{
802 struct dentry* d;
803 struct inode* i;
804 struct ncp_inode_info* ni;
805 struct ncp_server* s;
806 struct ncp_volume_info vi;
726c3342 807 struct super_block *sb = dentry->d_sb;
1da177e4
LT		 808 int err;
809 __u8 dh;
810
811 d = sb->s_root;
812 if (!d) {
813 goto dflt;
814 }
815 i = d->d_inode;
816 if (!i) {
817 goto dflt;
818 }
819 ni = NCP_FINFO(i);
820 if (!ni) {
821 goto dflt;
822 }
823 s = NCP_SBP(sb);
824 if (!s) {
825 goto dflt;
826 }
827 if (!s->m.mounted_vol[0]) {
828 goto dflt;
829 }
830
831 err = ncp_dirhandle_alloc(s, ni->volNumber, ni->DosDirNum, &dh);
832 if (err) {
833 goto dflt;
834 }
835 err = ncp_get_directory_info(s, dh, &vi);
836 ncp_dirhandle_free(s, dh);
837 if (err) {
838 goto dflt;
839 }
840 buf->f_type = NCP_SUPER_MAGIC;
841 buf->f_bsize = vi.sectors_per_block * 512;
842 buf->f_blocks = vi.total_blocks;
843 buf->f_bfree = vi.free_blocks;
844 buf->f_bavail = vi.free_blocks;
845 buf->f_files = vi.total_dir_entries;
846 buf->f_ffree = vi.available_dir_entries;
847 buf->f_namelen = 12;
848 return 0;
849
850 /* We cannot say how much disk space is left on a mounted
851 NetWare Server, because free space is distributed over
852 volumes, and the current user might have disk quotas. So
853 free space is not that simple to determine. Our decision
854 here is to err conservatively. */
855
856dflt:;
857 buf->f_type = NCP_SUPER_MAGIC;
858 buf->f_bsize = NCP_BLOCK_SIZE;
859 buf->f_blocks = 0;
860 buf->f_bfree = 0;
861 buf->f_bavail = 0;
862 buf->f_namelen = 12;
863 return 0;
864}
865
866int ncp_notify_change(struct dentry *dentry, struct iattr *attr)
867{
868 struct inode *inode = dentry->d_inode;
869 int result = 0;
870 __le32 info_mask;
871 struct nw_modify_dos_info info;
872 struct ncp_server *server;
873
874 result = -EIO;
875
1da177e4 876 server = NCP_SERVER(inode);
2e54eb96 877 if (!server) /* How this could happen? */
1da177e4
LT		 878 goto out;
879
880 /* ageing the dentry to force validation */
881 ncp_age_dentry(server, dentry);
882
883 result = inode_change_ok(inode, attr);
884 if (result < 0)
885 goto out;
886
887 result = -EPERM;
888 if (((attr->ia_valid & ATTR_UID) &&
889 (attr->ia_uid != server->m.uid)))
890 goto out;
891
892 if (((attr->ia_valid & ATTR_GID) &&
893 (attr->ia_gid != server->m.gid)))
894 goto out;
895
896 if (((attr->ia_valid & ATTR_MODE) &&
897 (attr->ia_mode &
898 ~(S_IFREG | S_IFDIR | S_IRWXUGO))))
899 goto out;
900
901 info_mask = 0;
902 memset(&info, 0, sizeof(info));
903
904#if 1
905 if ((attr->ia_valid & ATTR_MODE) != 0)
906 {
907 umode_t newmode = attr->ia_mode;
908
909 info_mask |= DM_ATTRIBUTES;
910
911 if (S_ISDIR(inode->i_mode)) {
912 newmode &= server->m.dir_mode;
913 } else {
914#ifdef CONFIG_NCPFS_EXTRAS
915 if (server->m.flags & NCP_MOUNT_EXTRAS) {
916 /* any non-default execute bit set */
917 if (newmode & ~server->m.file_mode & S_IXUGO)
918 info.attributes |= aSHARED | aSYSTEM;
919 /* read for group/world and not in default file_mode */
920 else if (newmode & ~server->m.file_mode & S_IRUGO)
921 info.attributes |= aSHARED;
922 } else
923#endif
924 newmode &= server->m.file_mode;
925 }
926 if (newmode & S_IWUGO)
927 info.attributes &= ~(aRONLY|aRENAMEINHIBIT|aDELETEINHIBIT);
928 else
929 info.attributes |= (aRONLY|aRENAMEINHIBIT|aDELETEINHIBIT);
930
931#ifdef CONFIG_NCPFS_NFS_NS
932 if (ncp_is_nfs_extras(server, NCP_FINFO(inode)->volNumber)) {
933 result = ncp_modify_nfs_info(server,
934 NCP_FINFO(inode)->volNumber,
935 NCP_FINFO(inode)->dirEntNum,
936 attr->ia_mode, 0);
937 if (result != 0)
938 goto out;
939 info.attributes &= ~(aSHARED | aSYSTEM);
940 {
941 /* mark partial success */
942 struct iattr tmpattr;
943
944 tmpattr.ia_valid = ATTR_MODE;
945 tmpattr.ia_mode = attr->ia_mode;
946
1025774c
CH		 947 setattr_copy(inode, &tmpattr);
948 mark_inode_dirty(inode);
1da177e4
LT		 949 }
950 }
951#endif
952 }
953#endif
954
955 /* Do SIZE before attributes, otherwise mtime together with size does not work...
956 */
957 if ((attr->ia_valid & ATTR_SIZE) != 0) {
958 int written;
959
960 DPRINTK("ncpfs: trying to change size to %ld\n",
961 attr->ia_size);
962
963 if ((result = ncp_make_open(inode, O_WRONLY)) < 0) {
964 result = -EACCES;
965 goto out;
966 }
967 ncp_write_kernel(NCP_SERVER(inode), NCP_FINFO(inode)->file_handle,
968 attr->ia_size, 0, "", &written);
969
970 /* According to ndir, the changes only take effect after
971 closing the file */
972 ncp_inode_close(inode);
973 result = ncp_make_closed(inode);
974 if (result)
975 goto out;
1025774c
CH		 976
977 if (attr->ia_size != i_size_read(inode)) {
978 result = vmtruncate(inode, attr->ia_size);
1da177e4
LT		 979 if (result)
980 goto out;
1025774c 981 mark_inode_dirty(inode);
1da177e4
LT		 982 }
983 }
984 if ((attr->ia_valid & ATTR_CTIME) != 0) {
985 info_mask |= (DM_CREATE_TIME | DM_CREATE_DATE);
986 ncp_date_unix2dos(attr->ia_ctime.tv_sec,
987 &info.creationTime, &info.creationDate);
988 }
989 if ((attr->ia_valid & ATTR_MTIME) != 0) {
990 info_mask |= (DM_MODIFY_TIME | DM_MODIFY_DATE);
991 ncp_date_unix2dos(attr->ia_mtime.tv_sec,
992 &info.modifyTime, &info.modifyDate);
993 }
994 if ((attr->ia_valid & ATTR_ATIME) != 0) {
995 __le16 dummy;
996 info_mask |= (DM_LAST_ACCESS_DATE);
997 ncp_date_unix2dos(attr->ia_atime.tv_sec,
998 &dummy, &info.lastAccessDate);
999 }
1000 if (info_mask != 0) {
1001 result = ncp_modify_file_or_subdir_dos_info(NCP_SERVER(inode),
1002 inode, info_mask, &info);
1003 if (result != 0) {
1da177e4
LT		 1004 if (info_mask == (DM_CREATE_TIME | DM_CREATE_DATE)) {
1005 /* NetWare seems not to allow this. I
1006 do not know why. So, just tell the
1007 user everything went fine. This is
1008 a terrible hack, but I do not know
1009 how to do this correctly. */
1010 result = 0;
1011 } else
1012 goto out;
1013 }
1014#ifdef CONFIG_NCPFS_STRONG
1015 if ((!result) && (info_mask & DM_ATTRIBUTES))
1016 NCP_FINFO(inode)->nwattr = info.attributes;
1017#endif
1018 }
1025774c
CH		 1019 if (result)
1020 goto out;
1021
1022 setattr_copy(inode, attr);
1023 mark_inode_dirty(inode);
1024
1da177e4 1025out:
2e54eb96
PV		 1026 if (result > 0)
1027 result = -EACCES;
1da177e4
LT		 1028 return result;
1029}
1030
3c26ff6e
AV		 1031static struct dentry *ncp_mount(struct file_system_type *fs_type,
1032 int flags, const char *dev_name, void *data)
1da177e4 1033{
3c26ff6e 1034 return mount_nodev(fs_type, flags, data, ncp_fill_super);
1da177e4
LT		 1035}
1036
1037static struct file_system_type ncp_fs_type = {
1038 .owner = THIS_MODULE,
1039 .name = "ncpfs",
3c26ff6e 1040 .mount = ncp_mount,
1da177e4 1041 .kill_sb = kill_anon_super,
564cd138 1042 .fs_flags = FS_BINARY_MOUNTDATA,
1da177e4
LT		 1043};
1044
1045static int __init init_ncp_fs(void)
1046{
1047 int err;
7c28cbae 1048 DPRINTK("ncpfs: init_ncp_fs called\n");
1da177e4 1049
1da177e4
LT		 1050 err = init_inodecache();
1051 if (err)
1052 goto out1;
1053 err = register_filesystem(&ncp_fs_type);
1054 if (err)
1055 goto out;
1056 return 0;
1057out:
1058 destroy_inodecache();
1059out1:
1060 return err;
1061}
1062
1063static void __exit exit_ncp_fs(void)
1064{
7c28cbae 1065 DPRINTK("ncpfs: exit_ncp_fs called\n");
1da177e4
LT		 1066 unregister_filesystem(&ncp_fs_type);
1067 destroy_inodecache();
1da177e4
LT		 1068}
1069
1070module_init(init_ncp_fs)
1071module_exit(exit_ncp_fs)
1072MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.653445 seconds and 5 git commands to generate.