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
12 #include <linux/config.h>
13 #include <linux/module.h>
15 #include <asm/system.h>
16 #include <asm/uaccess.h>
17 #include <asm/byteorder.h>
19 #include <linux/time.h>
20 #include <linux/kernel.h>
22 #include <linux/string.h>
23 #include <linux/stat.h>
24 #include <linux/errno.h>
25 #include <linux/file.h>
26 #include <linux/fcntl.h>
27 #include <linux/slab.h>
28 #include <linux/vmalloc.h>
29 #include <linux/init.h>
30 #include <linux/smp_lock.h>
31 #include <linux/vfs.h>
33 #include <linux/ncp_fs.h>
37 #include "ncplib_kernel.h"
40 static void ncp_delete_inode(struct inode *);
41 static void ncp_put_super(struct super_block *);
42 static int ncp_statfs(struct super_block *, struct kstatfs *);
44 static kmem_cache_t * ncp_inode_cachep;
46 static struct inode *ncp_alloc_inode(struct super_block *sb)
48 struct ncp_inode_info *ei;
49 ei = (struct ncp_inode_info *)kmem_cache_alloc(ncp_inode_cachep, SLAB_KERNEL);
52 return &ei->vfs_inode;
55 static void ncp_destroy_inode(struct inode *inode)
57 kmem_cache_free(ncp_inode_cachep, NCP_FINFO(inode));
60 static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
62 struct ncp_inode_info *ei = (struct ncp_inode_info *) foo;
64 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
65 SLAB_CTOR_CONSTRUCTOR) {
66 init_MUTEX(&ei->open_sem);
67 inode_init_once(&ei->vfs_inode);
71 static int init_inodecache(void)
73 ncp_inode_cachep = kmem_cache_create("ncp_inode_cache",
74 sizeof(struct ncp_inode_info),
75 0, SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT,
77 if (ncp_inode_cachep == NULL)
82 static void destroy_inodecache(void)
84 if (kmem_cache_destroy(ncp_inode_cachep))
85 printk(KERN_INFO "ncp_inode_cache: not all structures were freed\n");
88 static int ncp_remount(struct super_block *sb, int *flags, char* data)
90 *flags |= MS_NODIRATIME;
94 static struct super_operations ncp_sops =
96 .alloc_inode = ncp_alloc_inode,
97 .destroy_inode = ncp_destroy_inode,
98 .drop_inode = generic_delete_inode,
99 .delete_inode = ncp_delete_inode,
100 .put_super = ncp_put_super,
101 .statfs = ncp_statfs,
102 .remount_fs = ncp_remount,
105 extern struct dentry_operations ncp_root_dentry_operations;
106 #if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
107 extern struct address_space_operations ncp_symlink_aops;
108 extern int ncp_symlink(struct inode*, struct dentry*, const char*);
112 * Fill in the ncpfs-specific information in the inode.
114 static void ncp_update_dirent(struct inode *inode, struct ncp_entry_info *nwinfo)
116 NCP_FINFO(inode)->DosDirNum = nwinfo->i.DosDirNum;
117 NCP_FINFO(inode)->dirEntNum = nwinfo->i.dirEntNum;
118 NCP_FINFO(inode)->volNumber = nwinfo->volume;
121 void ncp_update_inode(struct inode *inode, struct ncp_entry_info *nwinfo)
123 ncp_update_dirent(inode, nwinfo);
124 NCP_FINFO(inode)->nwattr = nwinfo->i.attributes;
125 NCP_FINFO(inode)->access = nwinfo->access;
126 memcpy(NCP_FINFO(inode)->file_handle, nwinfo->file_handle,
127 sizeof(nwinfo->file_handle));
128 DPRINTK("ncp_update_inode: updated %s, volnum=%d, dirent=%u\n",
129 nwinfo->i.entryName, NCP_FINFO(inode)->volNumber,
130 NCP_FINFO(inode)->dirEntNum);
133 static void ncp_update_dates(struct inode *inode, struct nw_info_struct *nwi)
135 /* NFS namespace mode overrides others if it's set. */
136 DPRINTK(KERN_DEBUG "ncp_update_dates_and_mode: (%s) nfs.mode=0%o\n",
137 nwi->entryName, nwi->nfs.mode);
140 inode->i_mode = nwi->nfs.mode;
143 inode->i_blocks = (inode->i_size + NCP_BLOCK_SIZE - 1) >> NCP_BLOCK_SHIFT;
145 inode->i_mtime.tv_sec = ncp_date_dos2unix(le16_to_cpu(nwi->modifyTime),
146 le16_to_cpu(nwi->modifyDate));
147 inode->i_ctime.tv_sec = ncp_date_dos2unix(le16_to_cpu(nwi->creationTime),
148 le16_to_cpu(nwi->creationDate));
149 inode->i_atime.tv_sec = ncp_date_dos2unix(0,
150 le16_to_cpu(nwi->lastAccessDate));
151 inode->i_atime.tv_nsec = 0;
152 inode->i_mtime.tv_nsec = 0;
153 inode->i_ctime.tv_nsec = 0;
156 static void ncp_update_attrs(struct inode *inode, struct ncp_entry_info *nwinfo)
158 struct nw_info_struct *nwi = &nwinfo->i;
159 struct ncp_server *server = NCP_SERVER(inode);
161 if (nwi->attributes & aDIR) {
162 inode->i_mode = server->m.dir_mode;
163 /* for directories dataStreamSize seems to be some
165 inode->i_size = NCP_BLOCK_SIZE;
167 inode->i_mode = server->m.file_mode;
168 inode->i_size = le32_to_cpu(nwi->dataStreamSize);
169 #ifdef CONFIG_NCPFS_EXTRAS
170 if ((server->m.flags & (NCP_MOUNT_EXTRAS|NCP_MOUNT_SYMLINKS))
171 && (nwi->attributes & aSHARED)) {
172 switch (nwi->attributes & (aHIDDEN|aSYSTEM)) {
174 if (server->m.flags & NCP_MOUNT_SYMLINKS) {
175 if (/* (inode->i_size >= NCP_MIN_SYMLINK_SIZE)
176 && */ (inode->i_size <= NCP_MAX_SYMLINK_SIZE)) {
177 inode->i_mode = (inode->i_mode & ~S_IFMT) | S_IFLNK;
178 NCP_FINFO(inode)->flags |= NCPI_KLUDGE_SYMLINK;
184 if (server->m.flags & NCP_MOUNT_EXTRAS)
185 inode->i_mode |= S_IRUGO;
188 if (server->m.flags & NCP_MOUNT_EXTRAS)
189 inode->i_mode |= (inode->i_mode >> 2) & S_IXUGO;
191 /* case aSYSTEM|aHIDDEN: */
193 /* reserved combination */
199 if (nwi->attributes & aRONLY) inode->i_mode &= ~S_IWUGO;
202 void ncp_update_inode2(struct inode* inode, struct ncp_entry_info *nwinfo)
204 NCP_FINFO(inode)->flags = 0;
205 if (!atomic_read(&NCP_FINFO(inode)->opened)) {
206 NCP_FINFO(inode)->nwattr = nwinfo->i.attributes;
207 ncp_update_attrs(inode, nwinfo);
210 ncp_update_dates(inode, &nwinfo->i);
211 ncp_update_dirent(inode, nwinfo);
215 * Fill in the inode based on the ncp_entry_info structure.
217 static void ncp_set_attr(struct inode *inode, struct ncp_entry_info *nwinfo)
219 struct ncp_server *server = NCP_SERVER(inode);
221 NCP_FINFO(inode)->flags = 0;
223 ncp_update_attrs(inode, nwinfo);
225 DDPRINTK("ncp_read_inode: inode->i_mode = %u\n", inode->i_mode);
228 inode->i_uid = server->m.uid;
229 inode->i_gid = server->m.gid;
230 inode->i_blksize = NCP_BLOCK_SIZE;
232 ncp_update_dates(inode, &nwinfo->i);
233 ncp_update_inode(inode, nwinfo);
236 #if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
237 static struct inode_operations ncp_symlink_inode_operations = {
238 .readlink = page_readlink,
239 .follow_link = page_follow_link,
240 .setattr = ncp_notify_change,
248 ncp_iget(struct super_block *sb, struct ncp_entry_info *info)
253 printk(KERN_ERR "ncp_iget: info is NULL\n");
257 inode = new_inode(sb);
259 atomic_set(&NCP_FINFO(inode)->opened, info->opened);
261 inode->i_ino = info->ino;
262 ncp_set_attr(inode, info);
263 if (S_ISREG(inode->i_mode)) {
264 inode->i_op = &ncp_file_inode_operations;
265 inode->i_fop = &ncp_file_operations;
266 } else if (S_ISDIR(inode->i_mode)) {
267 inode->i_op = &ncp_dir_inode_operations;
268 inode->i_fop = &ncp_dir_operations;
269 #ifdef CONFIG_NCPFS_NFS_NS
270 } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) || S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
271 init_special_inode(inode, inode->i_mode,
272 new_decode_dev(info->i.nfs.rdev));
274 #if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
275 } else if (S_ISLNK(inode->i_mode)) {
276 inode->i_op = &ncp_symlink_inode_operations;
277 inode->i_data.a_ops = &ncp_symlink_aops;
280 make_bad_inode(inode);
282 insert_inode_hash(inode);
284 printk(KERN_ERR "ncp_iget: iget failed!\n");
289 ncp_delete_inode(struct inode *inode)
291 if (S_ISDIR(inode->i_mode)) {
292 DDPRINTK("ncp_delete_inode: put directory %ld\n", inode->i_ino);
295 if (ncp_make_closed(inode) != 0) {
296 /* We can't do anything but complain. */
297 printk(KERN_ERR "ncp_delete_inode: could not close\n");
302 static void ncp_stop_tasks(struct ncp_server *server) {
303 struct sock* sk = server->ncp_sock->sk;
305 sk->sk_error_report = server->error_report;
306 sk->sk_data_ready = server->data_ready;
307 sk->sk_write_space = server->write_space;
308 del_timer_sync(&server->timeout_tm);
309 flush_scheduled_work();
312 static const struct ncp_option ncp_opts[] = {
313 { "uid", OPT_INT, 'u' },
314 { "gid", OPT_INT, 'g' },
315 { "owner", OPT_INT, 'o' },
316 { "mode", OPT_INT, 'm' },
317 { "dirmode", OPT_INT, 'd' },
318 { "timeout", OPT_INT, 't' },
319 { "retry", OPT_INT, 'r' },
320 { "flags", OPT_INT, 'f' },
321 { "wdogpid", OPT_INT, 'w' },
322 { "ncpfd", OPT_INT, 'n' },
323 { "infofd", OPT_INT, 'i' }, /* v5 */
324 { "version", OPT_INT, 'v' },
327 static int ncp_parse_options(struct ncp_mount_data_kernel *data, char *options) {
330 unsigned long optint;
335 data->mounted_uid = 0;
339 data->retry_count = 20;
342 data->file_mode = 0600;
343 data->dir_mode = 0700;
345 data->mounted_vol[0] = 0;
347 while ((optval = ncp_getopt("ncpfs", &options, ncp_opts, NULL, &optarg, &optint)) != 0) {
358 data->mounted_uid = optint;
361 data->file_mode = optint;
364 data->dir_mode = optint;
367 data->time_out = optint;
370 data->retry_count = optint;
373 data->flags = optint;
376 data->wdog_pid = optint;
379 data->ncp_fd = optint;
382 data->info_fd = optint;
385 if (optint < NCP_MOUNT_VERSION_V4) {
388 if (optint > NCP_MOUNT_VERSION_V5) {
399 static int ncp_fill_super(struct super_block *sb, void *raw_data, int silent)
401 struct ncp_mount_data_kernel data;
402 struct ncp_server *server;
403 struct file *ncp_filp;
404 struct inode *root_inode;
405 struct inode *sock_inode;
409 #ifdef CONFIG_NCPFS_PACKET_SIGNING
412 struct ncp_entry_info finfo;
414 server = kmalloc(sizeof(struct ncp_server), GFP_KERNEL);
417 sb->s_fs_info = server;
418 memset(server, 0, sizeof(struct ncp_server));
421 if (raw_data == NULL)
423 switch (*(int*)raw_data) {
424 case NCP_MOUNT_VERSION:
426 struct ncp_mount_data* md = (struct ncp_mount_data*)raw_data;
428 data.flags = md->flags;
429 data.int_flags = NCP_IMOUNT_LOGGEDIN_POSSIBLE;
430 data.mounted_uid = md->mounted_uid;
431 data.wdog_pid = md->wdog_pid;
432 data.ncp_fd = md->ncp_fd;
433 data.time_out = md->time_out;
434 data.retry_count = md->retry_count;
437 data.file_mode = md->file_mode;
438 data.dir_mode = md->dir_mode;
440 memcpy(data.mounted_vol, md->mounted_vol,
444 case NCP_MOUNT_VERSION_V4:
446 struct ncp_mount_data_v4* md = (struct ncp_mount_data_v4*)raw_data;
448 data.flags = md->flags;
450 data.mounted_uid = md->mounted_uid;
451 data.wdog_pid = md->wdog_pid;
452 data.ncp_fd = md->ncp_fd;
453 data.time_out = md->time_out;
454 data.retry_count = md->retry_count;
457 data.file_mode = md->file_mode;
458 data.dir_mode = md->dir_mode;
460 data.mounted_vol[0] = 0;
465 if (*(__u32*)raw_data == cpu_to_be32(0x76657273)) {
466 error = ncp_parse_options(&data, raw_data);
473 ncp_filp = fget(data.ncp_fd);
477 sock_inode = ncp_filp->f_dentry->d_inode;
478 if (!S_ISSOCK(sock_inode->i_mode))
480 sock = SOCKET_I(sock_inode);
484 if (sock->type == SOCK_STREAM)
485 default_bufsize = 0xF000;
487 default_bufsize = 1024;
489 sb->s_flags |= MS_NODIRATIME; /* probably even noatime */
490 sb->s_maxbytes = 0xFFFFFFFFU;
491 sb->s_blocksize = 1024; /* Eh... Is this correct? */
492 sb->s_blocksize_bits = 10;
493 sb->s_magic = NCP_SUPER_MAGIC;
494 sb->s_op = &ncp_sops;
496 server = NCP_SBP(sb);
497 memset(server, 0, sizeof(*server));
499 server->ncp_filp = ncp_filp;
500 server->ncp_sock = sock;
502 if (data.info_fd != -1) {
503 struct socket *info_sock;
506 server->info_filp = fget(data.info_fd);
507 if (!server->info_filp)
510 sock_inode = server->info_filp->f_dentry->d_inode;
511 if (!S_ISSOCK(sock_inode->i_mode))
513 info_sock = SOCKET_I(sock_inode);
517 if (info_sock->type != SOCK_STREAM)
519 server->info_sock = info_sock;
522 /* server->lock = 0; */
523 init_MUTEX(&server->sem);
524 server->packet = NULL;
525 /* server->buffer_size = 0; */
526 /* server->conn_status = 0; */
527 /* server->root_dentry = NULL; */
528 /* server->root_setuped = 0; */
529 #ifdef CONFIG_NCPFS_PACKET_SIGNING
530 /* server->sign_wanted = 0; */
531 /* server->sign_active = 0; */
533 server->auth.auth_type = NCP_AUTH_NONE;
534 /* server->auth.object_name_len = 0; */
535 /* server->auth.object_name = NULL; */
536 /* server->auth.object_type = 0; */
537 /* server->priv.len = 0; */
538 /* server->priv.data = NULL; */
541 /* Althought anything producing this is buggy, it happens
542 now because of PATH_MAX changes.. */
543 if (server->m.time_out < 1) {
544 server->m.time_out = 10;
545 printk(KERN_INFO "You need to recompile your ncpfs utils..\n");
547 server->m.time_out = server->m.time_out * HZ / 100;
548 server->m.file_mode = (server->m.file_mode & S_IRWXUGO) | S_IFREG;
549 server->m.dir_mode = (server->m.dir_mode & S_IRWXUGO) | S_IFDIR;
551 #ifdef CONFIG_NCPFS_NLS
552 /* load the default NLS charsets */
553 server->nls_vol = load_nls_default();
554 server->nls_io = load_nls_default();
555 #endif /* CONFIG_NCPFS_NLS */
557 server->dentry_ttl = 0; /* no caching */
559 INIT_LIST_HEAD(&server->tx.requests);
560 init_MUTEX(&server->rcv.creq_sem);
561 server->tx.creq = NULL;
562 server->rcv.creq = NULL;
563 server->data_ready = sock->sk->sk_data_ready;
564 server->write_space = sock->sk->sk_write_space;
565 server->error_report = sock->sk->sk_error_report;
566 sock->sk->sk_user_data = server;
568 init_timer(&server->timeout_tm);
569 #undef NCP_PACKET_SIZE
570 #define NCP_PACKET_SIZE 131072
572 server->packet_size = NCP_PACKET_SIZE;
573 server->packet = vmalloc(NCP_PACKET_SIZE);
574 if (server->packet == NULL)
577 sock->sk->sk_data_ready = ncp_tcp_data_ready;
578 sock->sk->sk_error_report = ncp_tcp_error_report;
579 if (sock->type == SOCK_STREAM) {
580 server->rcv.ptr = (unsigned char*)&server->rcv.buf;
581 server->rcv.len = 10;
582 server->rcv.state = 0;
583 INIT_WORK(&server->rcv.tq, ncp_tcp_rcv_proc, server);
584 INIT_WORK(&server->tx.tq, ncp_tcp_tx_proc, server);
585 sock->sk->sk_write_space = ncp_tcp_write_space;
587 INIT_WORK(&server->rcv.tq, ncpdgram_rcv_proc, server);
588 INIT_WORK(&server->timeout_tq, ncpdgram_timeout_proc, server);
589 server->timeout_tm.data = (unsigned long)server;
590 server->timeout_tm.function = ncpdgram_timeout_call;
593 ncp_lock_server(server);
594 error = ncp_connect(server);
595 ncp_unlock_server(server);
598 DPRINTK("ncp_fill_super: NCP_SBP(sb) = %x\n", (int) NCP_SBP(sb));
600 error = -EMSGSIZE; /* -EREMOTESIDEINCOMPATIBLE */
601 #ifdef CONFIG_NCPFS_PACKET_SIGNING
602 if (ncp_negotiate_size_and_options(server, default_bufsize,
603 NCP_DEFAULT_OPTIONS, &(server->buffer_size), &options) == 0)
605 if (options != NCP_DEFAULT_OPTIONS)
607 if (ncp_negotiate_size_and_options(server,
610 &(server->buffer_size), &options) != 0)
617 server->sign_wanted = 1;
620 #endif /* CONFIG_NCPFS_PACKET_SIGNING */
621 if (ncp_negotiate_buffersize(server, default_bufsize,
622 &(server->buffer_size)) != 0)
624 DPRINTK("ncpfs: bufsize = %d\n", server->buffer_size);
626 memset(&finfo, 0, sizeof(finfo));
627 finfo.i.attributes = aDIR;
628 finfo.i.dataStreamSize = NCP_BLOCK_SIZE;
629 finfo.i.dirEntNum = 0;
630 finfo.i.DosDirNum = 0;
631 #ifdef CONFIG_NCPFS_SMALLDOS
632 finfo.i.NSCreator = NW_NS_DOS;
634 finfo.volume = NCP_NUMBER_OF_VOLUMES;
635 /* set dates of mountpoint to Jan 1, 1986; 00:00 */
636 finfo.i.creationTime = finfo.i.modifyTime
637 = cpu_to_le16(0x0000);
638 finfo.i.creationDate = finfo.i.modifyDate
639 = finfo.i.lastAccessDate
640 = cpu_to_le16(0x0C21);
642 finfo.i.entryName[0] = '\0';
645 finfo.ino = 2; /* tradition */
647 server->name_space[finfo.volume] = NW_NS_DOS;
650 root_inode = ncp_iget(sb, &finfo);
653 DPRINTK("ncp_fill_super: root vol=%d\n", NCP_FINFO(root_inode)->volNumber);
654 sb->s_root = d_alloc_root(root_inode);
657 sb->s_root->d_op = &ncp_root_dentry_operations;
663 ncp_lock_server(server);
664 ncp_disconnect(server);
665 ncp_unlock_server(server);
667 ncp_stop_tasks(server);
668 vfree(server->packet);
670 #ifdef CONFIG_NCPFS_NLS
671 unload_nls(server->nls_io);
672 unload_nls(server->nls_vol);
675 if (server->info_filp)
676 fput(server->info_filp);
678 /* 23/12/1998 Marcin Dalecki <dalecki@cs.net.pl>:
680 * The previously used put_filp(ncp_filp); was bogous, since
681 * it doesn't proper unlocking.
685 sb->s_fs_info = NULL;
690 static void ncp_put_super(struct super_block *sb)
692 struct ncp_server *server = NCP_SBP(sb);
694 ncp_lock_server(server);
695 ncp_disconnect(server);
696 ncp_unlock_server(server);
698 ncp_stop_tasks(server);
700 #ifdef CONFIG_NCPFS_NLS
701 /* unload the NLS charsets */
704 unload_nls(server->nls_vol);
705 server->nls_vol = NULL;
709 unload_nls(server->nls_io);
710 server->nls_io = NULL;
712 #endif /* CONFIG_NCPFS_NLS */
714 if (server->info_filp)
715 fput(server->info_filp);
716 fput(server->ncp_filp);
717 kill_proc(server->m.wdog_pid, SIGTERM, 1);
719 if (server->priv.data)
720 ncp_kfree_s(server->priv.data, server->priv.len);
721 if (server->auth.object_name)
722 ncp_kfree_s(server->auth.object_name, server->auth.object_name_len);
723 vfree(server->packet);
724 sb->s_fs_info = NULL;
728 static int ncp_statfs(struct super_block *sb, struct kstatfs *buf)
732 struct ncp_inode_info* ni;
733 struct ncp_server* s;
734 struct ncp_volume_info vi;
754 if (!s->m.mounted_vol[0]) {
758 err = ncp_dirhandle_alloc(s, ni->volNumber, ni->DosDirNum, &dh);
762 err = ncp_get_directory_info(s, dh, &vi);
763 ncp_dirhandle_free(s, dh);
767 buf->f_type = NCP_SUPER_MAGIC;
768 buf->f_bsize = vi.sectors_per_block * 512;
769 buf->f_blocks = vi.total_blocks;
770 buf->f_bfree = vi.free_blocks;
771 buf->f_bavail = vi.free_blocks;
772 buf->f_files = vi.total_dir_entries;
773 buf->f_ffree = vi.available_dir_entries;
777 /* We cannot say how much disk space is left on a mounted
778 NetWare Server, because free space is distributed over
779 volumes, and the current user might have disk quotas. So
780 free space is not that simple to determine. Our decision
781 here is to err conservatively. */
784 buf->f_type = NCP_SUPER_MAGIC;
785 buf->f_bsize = NCP_BLOCK_SIZE;
793 int ncp_notify_change(struct dentry *dentry, struct iattr *attr)
795 struct inode *inode = dentry->d_inode;
798 struct nw_modify_dos_info info;
799 struct ncp_server *server;
805 server = NCP_SERVER(inode);
806 if ((!server) || !ncp_conn_valid(server))
809 /* ageing the dentry to force validation */
810 ncp_age_dentry(server, dentry);
812 result = inode_change_ok(inode, attr);
817 if (((attr->ia_valid & ATTR_UID) &&
818 (attr->ia_uid != server->m.uid)))
821 if (((attr->ia_valid & ATTR_GID) &&
822 (attr->ia_gid != server->m.gid)))
825 if (((attr->ia_valid & ATTR_MODE) &&
827 ~(S_IFREG | S_IFDIR | S_IRWXUGO))))
831 memset(&info, 0, sizeof(info));
834 if ((attr->ia_valid & ATTR_MODE) != 0)
836 umode_t newmode = attr->ia_mode;
838 info_mask |= DM_ATTRIBUTES;
840 if (S_ISDIR(inode->i_mode)) {
841 newmode &= server->m.dir_mode;
843 #ifdef CONFIG_NCPFS_EXTRAS
844 if (server->m.flags & NCP_MOUNT_EXTRAS) {
845 /* any non-default execute bit set */
846 if (newmode & ~server->m.file_mode & S_IXUGO)
847 info.attributes |= aSHARED | aSYSTEM;
848 /* read for group/world and not in default file_mode */
849 else if (newmode & ~server->m.file_mode & S_IRUGO)
850 info.attributes |= aSHARED;
853 newmode &= server->m.file_mode;
855 if (newmode & S_IWUGO)
856 info.attributes &= ~(aRONLY|aRENAMEINHIBIT|aDELETEINHIBIT);
858 info.attributes |= (aRONLY|aRENAMEINHIBIT|aDELETEINHIBIT);
860 #ifdef CONFIG_NCPFS_NFS_NS
861 if (ncp_is_nfs_extras(server, NCP_FINFO(inode)->volNumber)) {
862 result = ncp_modify_nfs_info(server,
863 NCP_FINFO(inode)->volNumber,
864 NCP_FINFO(inode)->dirEntNum,
868 info.attributes &= ~(aSHARED | aSYSTEM);
870 /* mark partial success */
871 struct iattr tmpattr;
873 tmpattr.ia_valid = ATTR_MODE;
874 tmpattr.ia_mode = attr->ia_mode;
876 inode_setattr(inode, &tmpattr);
883 /* Do SIZE before attributes, otherwise mtime together with size does not work...
885 if ((attr->ia_valid & ATTR_SIZE) != 0) {
888 DPRINTK("ncpfs: trying to change size to %ld\n",
891 if ((result = ncp_make_open(inode, O_WRONLY)) < 0) {
895 ncp_write_kernel(NCP_SERVER(inode), NCP_FINFO(inode)->file_handle,
896 attr->ia_size, 0, "", &written);
898 /* According to ndir, the changes only take effect after
900 ncp_inode_close(inode);
901 result = ncp_make_closed(inode);
903 struct iattr tmpattr;
905 tmpattr.ia_valid = ATTR_SIZE;
906 tmpattr.ia_size = attr->ia_size;
908 inode_setattr(inode, &tmpattr);
911 if ((attr->ia_valid & ATTR_CTIME) != 0) {
912 info_mask |= (DM_CREATE_TIME | DM_CREATE_DATE);
913 ncp_date_unix2dos(attr->ia_ctime.tv_sec,
914 &(info.creationTime), &(info.creationDate));
915 info.creationTime = le16_to_cpu(info.creationTime);
916 info.creationDate = le16_to_cpu(info.creationDate);
918 if ((attr->ia_valid & ATTR_MTIME) != 0) {
919 info_mask |= (DM_MODIFY_TIME | DM_MODIFY_DATE);
920 ncp_date_unix2dos(attr->ia_mtime.tv_sec,
921 &(info.modifyTime), &(info.modifyDate));
922 info.modifyTime = le16_to_cpu(info.modifyTime);
923 info.modifyDate = le16_to_cpu(info.modifyDate);
925 if ((attr->ia_valid & ATTR_ATIME) != 0) {
927 info_mask |= (DM_LAST_ACCESS_DATE);
928 ncp_date_unix2dos(attr->ia_atime.tv_sec,
929 &(dummy), &(info.lastAccessDate));
930 info.lastAccessDate = le16_to_cpu(info.lastAccessDate);
932 if (info_mask != 0) {
933 result = ncp_modify_file_or_subdir_dos_info(NCP_SERVER(inode),
934 inode, info_mask, &info);
938 if (info_mask == (DM_CREATE_TIME | DM_CREATE_DATE)) {
939 /* NetWare seems not to allow this. I
940 do not know why. So, just tell the
941 user everything went fine. This is
942 a terrible hack, but I do not know
943 how to do this correctly. */
948 #ifdef CONFIG_NCPFS_STRONG
949 if ((!result) && (info_mask & DM_ATTRIBUTES))
950 NCP_FINFO(inode)->nwattr = info.attributes;
954 inode_setattr(inode, attr);
960 #ifdef DEBUG_NCP_MALLOC
962 int ncp_current_malloced;
965 static struct super_block *ncp_get_sb(struct file_system_type *fs_type,
966 int flags, const char *dev_name, void *data)
968 return get_sb_nodev(fs_type, flags, data, ncp_fill_super);
971 static struct file_system_type ncp_fs_type = {
972 .owner = THIS_MODULE,
974 .get_sb = ncp_get_sb,
975 .kill_sb = kill_anon_super,
978 static int __init init_ncp_fs(void)
981 DPRINTK("ncpfs: init_module called\n");
983 #ifdef DEBUG_NCP_MALLOC
985 ncp_current_malloced = 0;
987 err = init_inodecache();
990 err = register_filesystem(&ncp_fs_type);
995 destroy_inodecache();
1000 static void __exit exit_ncp_fs(void)
1002 DPRINTK("ncpfs: cleanup_module called\n");
1003 unregister_filesystem(&ncp_fs_type);
1004 destroy_inodecache();
1005 #ifdef DEBUG_NCP_MALLOC
1006 PRINTK("ncp_malloced: %d\n", ncp_malloced);
1007 PRINTK("ncp_current_malloced: %d\n", ncp_current_malloced);
1011 module_init(init_ncp_fs)
1012 module_exit(exit_ncp_fs)
1013 MODULE_LICENSE("GPL");