?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
staging: brcm80211: cleanup mac80211 callback bss_info_changed
[zen-stable.git] / fs / ncpfs / inode.c
blob00a1d1c3d3a494c34dc02230509ffa88485a37ae
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 /* Althought 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");