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/module.h>
14 #include <asm/system.h>
15 #include <asm/uaccess.h>
16 #include <asm/byteorder.h>
18 #include <linux/time.h>
19 #include <linux/kernel.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>
32 #include <linux/ncp_fs.h>
36 #include "ncplib_kernel.h"
39 static void ncp_delete_inode(struct inode *);
40 static void ncp_put_super(struct super_block *);
41 static int ncp_statfs(struct dentry *, struct kstatfs *);
43 static kmem_cache_t * ncp_inode_cachep;
45 static struct inode *ncp_alloc_inode(struct super_block *sb)
47 struct ncp_inode_info *ei;
48 ei = (struct ncp_inode_info *)kmem_cache_alloc(ncp_inode_cachep, SLAB_KERNEL);
51 return &ei->vfs_inode;
54 static void ncp_destroy_inode(struct inode *inode)
56 kmem_cache_free(ncp_inode_cachep, NCP_FINFO(inode));
59 static void init_once(void * foo, kmem_cache_t * cachep, unsigned long flags)
61 struct ncp_inode_info *ei = (struct ncp_inode_info *) foo;
63 if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
64 SLAB_CTOR_CONSTRUCTOR) {
65 mutex_init(&ei->open_mutex);
66 inode_init_once(&ei->vfs_inode);
70 static int init_inodecache(void)
72 ncp_inode_cachep = kmem_cache_create("ncp_inode_cache",
73 sizeof(struct ncp_inode_info),
74 0, (SLAB_RECLAIM_ACCOUNT|
77 if (ncp_inode_cachep == NULL)
82 static void destroy_inodecache(void)
84 kmem_cache_destroy(ncp_inode_cachep);
87 static int ncp_remount(struct super_block *sb, int *flags, char* data)
89 *flags |= MS_NODIRATIME;
93 static struct super_operations ncp_sops =
95 .alloc_inode = ncp_alloc_inode,
96 .destroy_inode = ncp_destroy_inode,
97 .drop_inode = generic_delete_inode,
98 .delete_inode = ncp_delete_inode,
99 .put_super = ncp_put_super,
100 .statfs = ncp_statfs,
101 .remount_fs = ncp_remount,
104 extern struct dentry_operations ncp_root_dentry_operations;
105 #if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
106 extern const struct address_space_operations ncp_symlink_aops;
107 extern int ncp_symlink(struct inode*, struct dentry*, const char*);
111 * Fill in the ncpfs-specific information in the inode.
113 static void ncp_update_dirent(struct inode *inode, struct ncp_entry_info *nwinfo)
115 NCP_FINFO(inode)->DosDirNum = nwinfo->i.DosDirNum;
116 NCP_FINFO(inode)->dirEntNum = nwinfo->i.dirEntNum;
117 NCP_FINFO(inode)->volNumber = nwinfo->volume;
120 void ncp_update_inode(struct inode *inode, struct ncp_entry_info *nwinfo)
122 ncp_update_dirent(inode, nwinfo);
123 NCP_FINFO(inode)->nwattr = nwinfo->i.attributes;
124 NCP_FINFO(inode)->access = nwinfo->access;
125 memcpy(NCP_FINFO(inode)->file_handle, nwinfo->file_handle,
126 sizeof(nwinfo->file_handle));
127 DPRINTK("ncp_update_inode: updated %s, volnum=%d, dirent=%u\n",
128 nwinfo->i.entryName, NCP_FINFO(inode)->volNumber,
129 NCP_FINFO(inode)->dirEntNum);
132 static void ncp_update_dates(struct inode *inode, struct nw_info_struct *nwi)
134 /* NFS namespace mode overrides others if it's set. */
135 DPRINTK(KERN_DEBUG "ncp_update_dates_and_mode: (%s) nfs.mode=0%o\n",
136 nwi->entryName, nwi->nfs.mode);
139 inode->i_mode = nwi->nfs.mode;
142 inode->i_blocks = (inode->i_size + NCP_BLOCK_SIZE - 1) >> NCP_BLOCK_SHIFT;
144 inode->i_mtime.tv_sec = ncp_date_dos2unix(nwi->modifyTime, nwi->modifyDate);
145 inode->i_ctime.tv_sec = ncp_date_dos2unix(nwi->creationTime, nwi->creationDate);
146 inode->i_atime.tv_sec = ncp_date_dos2unix(0, nwi->lastAccessDate);
147 inode->i_atime.tv_nsec = 0;
148 inode->i_mtime.tv_nsec = 0;
149 inode->i_ctime.tv_nsec = 0;
152 static void ncp_update_attrs(struct inode *inode, struct ncp_entry_info *nwinfo)
154 struct nw_info_struct *nwi = &nwinfo->i;
155 struct ncp_server *server = NCP_SERVER(inode);
157 if (nwi->attributes & aDIR) {
158 inode->i_mode = server->m.dir_mode;
159 /* for directories dataStreamSize seems to be some
161 inode->i_size = NCP_BLOCK_SIZE;
163 inode->i_mode = server->m.file_mode;
164 inode->i_size = le32_to_cpu(nwi->dataStreamSize);
165 #ifdef CONFIG_NCPFS_EXTRAS
166 if ((server->m.flags & (NCP_MOUNT_EXTRAS|NCP_MOUNT_SYMLINKS))
167 && (nwi->attributes & aSHARED)) {
168 switch (nwi->attributes & (aHIDDEN|aSYSTEM)) {
170 if (server->m.flags & NCP_MOUNT_SYMLINKS) {
171 if (/* (inode->i_size >= NCP_MIN_SYMLINK_SIZE)
172 && */ (inode->i_size <= NCP_MAX_SYMLINK_SIZE)) {
173 inode->i_mode = (inode->i_mode & ~S_IFMT) | S_IFLNK;
174 NCP_FINFO(inode)->flags |= NCPI_KLUDGE_SYMLINK;
180 if (server->m.flags & NCP_MOUNT_EXTRAS)
181 inode->i_mode |= S_IRUGO;
184 if (server->m.flags & NCP_MOUNT_EXTRAS)
185 inode->i_mode |= (inode->i_mode >> 2) & S_IXUGO;
187 /* case aSYSTEM|aHIDDEN: */
189 /* reserved combination */
195 if (nwi->attributes & aRONLY) inode->i_mode &= ~S_IWUGO;
198 void ncp_update_inode2(struct inode* inode, struct ncp_entry_info *nwinfo)
200 NCP_FINFO(inode)->flags = 0;
201 if (!atomic_read(&NCP_FINFO(inode)->opened)) {
202 NCP_FINFO(inode)->nwattr = nwinfo->i.attributes;
203 ncp_update_attrs(inode, nwinfo);
206 ncp_update_dates(inode, &nwinfo->i);
207 ncp_update_dirent(inode, nwinfo);
211 * Fill in the inode based on the ncp_entry_info structure.
213 static void ncp_set_attr(struct inode *inode, struct ncp_entry_info *nwinfo)
215 struct ncp_server *server = NCP_SERVER(inode);
217 NCP_FINFO(inode)->flags = 0;
219 ncp_update_attrs(inode, nwinfo);
221 DDPRINTK("ncp_read_inode: inode->i_mode = %u\n", inode->i_mode);
224 inode->i_uid = server->m.uid;
225 inode->i_gid = server->m.gid;
226 inode->i_blksize = NCP_BLOCK_SIZE;
228 ncp_update_dates(inode, &nwinfo->i);
229 ncp_update_inode(inode, nwinfo);
232 #if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
233 static struct inode_operations ncp_symlink_inode_operations = {
234 .readlink = generic_readlink,
235 .follow_link = page_follow_link_light,
236 .put_link = page_put_link,
237 .setattr = ncp_notify_change,
245 ncp_iget(struct super_block *sb, struct ncp_entry_info *info)
250 printk(KERN_ERR "ncp_iget: info is NULL\n");
254 inode = new_inode(sb);
256 atomic_set(&NCP_FINFO(inode)->opened, info->opened);
258 inode->i_ino = info->ino;
259 ncp_set_attr(inode, info);
260 if (S_ISREG(inode->i_mode)) {
261 inode->i_op = &ncp_file_inode_operations;
262 inode->i_fop = &ncp_file_operations;
263 } else if (S_ISDIR(inode->i_mode)) {
264 inode->i_op = &ncp_dir_inode_operations;
265 inode->i_fop = &ncp_dir_operations;
266 #ifdef CONFIG_NCPFS_NFS_NS
267 } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) || S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
268 init_special_inode(inode, inode->i_mode,
269 new_decode_dev(info->i.nfs.rdev));
271 #if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
272 } else if (S_ISLNK(inode->i_mode)) {
273 inode->i_op = &ncp_symlink_inode_operations;
274 inode->i_data.a_ops = &ncp_symlink_aops;
277 make_bad_inode(inode);
279 insert_inode_hash(inode);
281 printk(KERN_ERR "ncp_iget: iget failed!\n");
286 ncp_delete_inode(struct inode *inode)
288 truncate_inode_pages(&inode->i_data, 0);
290 if (S_ISDIR(inode->i_mode)) {
291 DDPRINTK("ncp_delete_inode: put directory %ld\n", inode->i_ino);
294 if (ncp_make_closed(inode) != 0) {
295 /* We can't do anything but complain. */
296 printk(KERN_ERR "ncp_delete_inode: could not close\n");
301 static void ncp_stop_tasks(struct ncp_server *server) {
302 struct sock* sk = server->ncp_sock->sk;
304 sk->sk_error_report = server->error_report;
305 sk->sk_data_ready = server->data_ready;
306 sk->sk_write_space = server->write_space;
307 del_timer_sync(&server->timeout_tm);
308 flush_scheduled_work();
311 static const struct ncp_option ncp_opts[] = {
312 { "uid", OPT_INT, 'u' },
313 { "gid", OPT_INT, 'g' },
314 { "owner", OPT_INT, 'o' },
315 { "mode", OPT_INT, 'm' },
316 { "dirmode", OPT_INT, 'd' },
317 { "timeout", OPT_INT, 't' },
318 { "retry", OPT_INT, 'r' },
319 { "flags", OPT_INT, 'f' },
320 { "wdogpid", OPT_INT, 'w' },
321 { "ncpfd", OPT_INT, 'n' },
322 { "infofd", OPT_INT, 'i' }, /* v5 */
323 { "version", OPT_INT, 'v' },
326 static int ncp_parse_options(struct ncp_mount_data_kernel *data, char *options) {
329 unsigned long optint;
334 data->mounted_uid = 0;
338 data->retry_count = 20;
341 data->file_mode = 0600;
342 data->dir_mode = 0700;
344 data->mounted_vol[0] = 0;
346 while ((optval = ncp_getopt("ncpfs", &options, ncp_opts, NULL, &optarg, &optint)) != 0) {
357 data->mounted_uid = optint;
360 data->file_mode = optint;
363 data->dir_mode = optint;
366 data->time_out = optint;
369 data->retry_count = optint;
372 data->flags = optint;
375 data->wdog_pid = optint;
378 data->ncp_fd = optint;
381 data->info_fd = optint;
384 if (optint < NCP_MOUNT_VERSION_V4) {
387 if (optint > NCP_MOUNT_VERSION_V5) {
398 static int ncp_fill_super(struct super_block *sb, void *raw_data, int silent)
400 struct ncp_mount_data_kernel data;
401 struct ncp_server *server;
402 struct file *ncp_filp;
403 struct inode *root_inode;
404 struct inode *sock_inode;
408 #ifdef CONFIG_NCPFS_PACKET_SIGNING
411 struct ncp_entry_info finfo;
413 server = kzalloc(sizeof(struct ncp_server), GFP_KERNEL);
416 sb->s_fs_info = server;
419 if (raw_data == NULL)
421 switch (*(int*)raw_data) {
422 case NCP_MOUNT_VERSION:
424 struct ncp_mount_data* md = (struct ncp_mount_data*)raw_data;
426 data.flags = md->flags;
427 data.int_flags = NCP_IMOUNT_LOGGEDIN_POSSIBLE;
428 data.mounted_uid = md->mounted_uid;
429 data.wdog_pid = md->wdog_pid;
430 data.ncp_fd = md->ncp_fd;
431 data.time_out = md->time_out;
432 data.retry_count = md->retry_count;
435 data.file_mode = md->file_mode;
436 data.dir_mode = md->dir_mode;
438 memcpy(data.mounted_vol, md->mounted_vol,
442 case NCP_MOUNT_VERSION_V4:
444 struct ncp_mount_data_v4* md = (struct ncp_mount_data_v4*)raw_data;
446 data.flags = md->flags;
448 data.mounted_uid = md->mounted_uid;
449 data.wdog_pid = md->wdog_pid;
450 data.ncp_fd = md->ncp_fd;
451 data.time_out = md->time_out;
452 data.retry_count = md->retry_count;
455 data.file_mode = md->file_mode;
456 data.dir_mode = md->dir_mode;
458 data.mounted_vol[0] = 0;
463 if (memcmp(raw_data, "vers", 4) == 0) {
464 error = ncp_parse_options(&data, raw_data);
471 ncp_filp = fget(data.ncp_fd);
475 sock_inode = ncp_filp->f_dentry->d_inode;
476 if (!S_ISSOCK(sock_inode->i_mode))
478 sock = SOCKET_I(sock_inode);
482 if (sock->type == SOCK_STREAM)
483 default_bufsize = 0xF000;
485 default_bufsize = 1024;
487 sb->s_flags |= MS_NODIRATIME; /* probably even noatime */
488 sb->s_maxbytes = 0xFFFFFFFFU;
489 sb->s_blocksize = 1024; /* Eh... Is this correct? */
490 sb->s_blocksize_bits = 10;
491 sb->s_magic = NCP_SUPER_MAGIC;
492 sb->s_op = &ncp_sops;
494 server = NCP_SBP(sb);
495 memset(server, 0, sizeof(*server));
497 server->ncp_filp = ncp_filp;
498 server->ncp_sock = sock;
500 if (data.info_fd != -1) {
501 struct socket *info_sock;
504 server->info_filp = fget(data.info_fd);
505 if (!server->info_filp)
508 sock_inode = server->info_filp->f_dentry->d_inode;
509 if (!S_ISSOCK(sock_inode->i_mode))
511 info_sock = SOCKET_I(sock_inode);
515 if (info_sock->type != SOCK_STREAM)
517 server->info_sock = info_sock;
520 /* server->lock = 0; */
521 mutex_init(&server->mutex);
522 server->packet = NULL;
523 /* server->buffer_size = 0; */
524 /* server->conn_status = 0; */
525 /* server->root_dentry = NULL; */
526 /* server->root_setuped = 0; */
527 #ifdef CONFIG_NCPFS_PACKET_SIGNING
528 /* server->sign_wanted = 0; */
529 /* server->sign_active = 0; */
531 server->auth.auth_type = NCP_AUTH_NONE;
532 /* server->auth.object_name_len = 0; */
533 /* server->auth.object_name = NULL; */
534 /* server->auth.object_type = 0; */
535 /* server->priv.len = 0; */
536 /* server->priv.data = NULL; */
539 /* Althought anything producing this is buggy, it happens
540 now because of PATH_MAX changes.. */
541 if (server->m.time_out < 1) {
542 server->m.time_out = 10;
543 printk(KERN_INFO "You need to recompile your ncpfs utils..\n");
545 server->m.time_out = server->m.time_out * HZ / 100;
546 server->m.file_mode = (server->m.file_mode & S_IRWXUGO) | S_IFREG;
547 server->m.dir_mode = (server->m.dir_mode & S_IRWXUGO) | S_IFDIR;
549 #ifdef CONFIG_NCPFS_NLS
550 /* load the default NLS charsets */
551 server->nls_vol = load_nls_default();
552 server->nls_io = load_nls_default();
553 #endif /* CONFIG_NCPFS_NLS */
555 server->dentry_ttl = 0; /* no caching */
557 INIT_LIST_HEAD(&server->tx.requests);
558 mutex_init(&server->rcv.creq_mutex);
559 server->tx.creq = NULL;
560 server->rcv.creq = NULL;
561 server->data_ready = sock->sk->sk_data_ready;
562 server->write_space = sock->sk->sk_write_space;
563 server->error_report = sock->sk->sk_error_report;
564 sock->sk->sk_user_data = server;
566 init_timer(&server->timeout_tm);
567 #undef NCP_PACKET_SIZE
568 #define NCP_PACKET_SIZE 131072
570 server->packet_size = NCP_PACKET_SIZE;
571 server->packet = vmalloc(NCP_PACKET_SIZE);
572 if (server->packet == NULL)
575 sock->sk->sk_data_ready = ncp_tcp_data_ready;
576 sock->sk->sk_error_report = ncp_tcp_error_report;
577 if (sock->type == SOCK_STREAM) {
578 server->rcv.ptr = (unsigned char*)&server->rcv.buf;
579 server->rcv.len = 10;
580 server->rcv.state = 0;
581 INIT_WORK(&server->rcv.tq, ncp_tcp_rcv_proc, server);
582 INIT_WORK(&server->tx.tq, ncp_tcp_tx_proc, server);
583 sock->sk->sk_write_space = ncp_tcp_write_space;
585 INIT_WORK(&server->rcv.tq, ncpdgram_rcv_proc, server);
586 INIT_WORK(&server->timeout_tq, ncpdgram_timeout_proc, server);
587 server->timeout_tm.data = (unsigned long)server;
588 server->timeout_tm.function = ncpdgram_timeout_call;
591 ncp_lock_server(server);
592 error = ncp_connect(server);
593 ncp_unlock_server(server);
596 DPRINTK("ncp_fill_super: NCP_SBP(sb) = %x\n", (int) NCP_SBP(sb));
598 error = -EMSGSIZE; /* -EREMOTESIDEINCOMPATIBLE */
599 #ifdef CONFIG_NCPFS_PACKET_SIGNING
600 if (ncp_negotiate_size_and_options(server, default_bufsize,
601 NCP_DEFAULT_OPTIONS, &(server->buffer_size), &options) == 0)
603 if (options != NCP_DEFAULT_OPTIONS)
605 if (ncp_negotiate_size_and_options(server,
608 &(server->buffer_size), &options) != 0)
615 server->sign_wanted = 1;
618 #endif /* CONFIG_NCPFS_PACKET_SIGNING */
619 if (ncp_negotiate_buffersize(server, default_bufsize,
620 &(server->buffer_size)) != 0)
622 DPRINTK("ncpfs: bufsize = %d\n", server->buffer_size);
624 memset(&finfo, 0, sizeof(finfo));
625 finfo.i.attributes = aDIR;
626 finfo.i.dataStreamSize = 0; /* ignored */
627 finfo.i.dirEntNum = 0;
628 finfo.i.DosDirNum = 0;
629 #ifdef CONFIG_NCPFS_SMALLDOS
630 finfo.i.NSCreator = NW_NS_DOS;
632 finfo.volume = NCP_NUMBER_OF_VOLUMES;
633 /* set dates of mountpoint to Jan 1, 1986; 00:00 */
634 finfo.i.creationTime = finfo.i.modifyTime
635 = cpu_to_le16(0x0000);
636 finfo.i.creationDate = finfo.i.modifyDate
637 = finfo.i.lastAccessDate
638 = cpu_to_le16(0x0C21);
640 finfo.i.entryName[0] = '\0';
643 finfo.ino = 2; /* tradition */
645 server->name_space[finfo.volume] = NW_NS_DOS;
648 root_inode = ncp_iget(sb, &finfo);
651 DPRINTK("ncp_fill_super: root vol=%d\n", NCP_FINFO(root_inode)->volNumber);
652 sb->s_root = d_alloc_root(root_inode);
655 sb->s_root->d_op = &ncp_root_dentry_operations;
661 ncp_lock_server(server);
662 ncp_disconnect(server);
663 ncp_unlock_server(server);
665 ncp_stop_tasks(server);
666 vfree(server->packet);
668 #ifdef CONFIG_NCPFS_NLS
669 unload_nls(server->nls_io);
670 unload_nls(server->nls_vol);
673 if (server->info_filp)
674 fput(server->info_filp);
676 /* 23/12/1998 Marcin Dalecki <dalecki@cs.net.pl>:
678 * The previously used put_filp(ncp_filp); was bogous, since
679 * it doesn't proper unlocking.
683 sb->s_fs_info = NULL;
688 static void ncp_put_super(struct super_block *sb)
690 struct ncp_server *server = NCP_SBP(sb);
692 ncp_lock_server(server);
693 ncp_disconnect(server);
694 ncp_unlock_server(server);
696 ncp_stop_tasks(server);
698 #ifdef CONFIG_NCPFS_NLS
699 /* unload the NLS charsets */
702 unload_nls(server->nls_vol);
703 server->nls_vol = NULL;
707 unload_nls(server->nls_io);
708 server->nls_io = NULL;
710 #endif /* CONFIG_NCPFS_NLS */
712 if (server->info_filp)
713 fput(server->info_filp);
714 fput(server->ncp_filp);
715 kill_proc(server->m.wdog_pid, SIGTERM, 1);
717 kfree(server->priv.data);
718 kfree(server->auth.object_name);
719 vfree(server->packet);
720 sb->s_fs_info = NULL;
724 static int ncp_statfs(struct dentry *dentry, struct kstatfs *buf)
728 struct ncp_inode_info* ni;
729 struct ncp_server* s;
730 struct ncp_volume_info vi;
731 struct super_block *sb = dentry->d_sb;
751 if (!s->m.mounted_vol[0]) {
755 err = ncp_dirhandle_alloc(s, ni->volNumber, ni->DosDirNum, &dh);
759 err = ncp_get_directory_info(s, dh, &vi);
760 ncp_dirhandle_free(s, dh);
764 buf->f_type = NCP_SUPER_MAGIC;
765 buf->f_bsize = vi.sectors_per_block * 512;
766 buf->f_blocks = vi.total_blocks;
767 buf->f_bfree = vi.free_blocks;
768 buf->f_bavail = vi.free_blocks;
769 buf->f_files = vi.total_dir_entries;
770 buf->f_ffree = vi.available_dir_entries;
774 /* We cannot say how much disk space is left on a mounted
775 NetWare Server, because free space is distributed over
776 volumes, and the current user might have disk quotas. So
777 free space is not that simple to determine. Our decision
778 here is to err conservatively. */
781 buf->f_type = NCP_SUPER_MAGIC;
782 buf->f_bsize = NCP_BLOCK_SIZE;
790 int ncp_notify_change(struct dentry *dentry, struct iattr *attr)
792 struct inode *inode = dentry->d_inode;
795 struct nw_modify_dos_info info;
796 struct ncp_server *server;
802 server = NCP_SERVER(inode);
803 if ((!server) || !ncp_conn_valid(server))
806 /* ageing the dentry to force validation */
807 ncp_age_dentry(server, dentry);
809 result = inode_change_ok(inode, attr);
814 if (((attr->ia_valid & ATTR_UID) &&
815 (attr->ia_uid != server->m.uid)))
818 if (((attr->ia_valid & ATTR_GID) &&
819 (attr->ia_gid != server->m.gid)))
822 if (((attr->ia_valid & ATTR_MODE) &&
824 ~(S_IFREG | S_IFDIR | S_IRWXUGO))))
828 memset(&info, 0, sizeof(info));
831 if ((attr->ia_valid & ATTR_MODE) != 0)
833 umode_t newmode = attr->ia_mode;
835 info_mask |= DM_ATTRIBUTES;
837 if (S_ISDIR(inode->i_mode)) {
838 newmode &= server->m.dir_mode;
840 #ifdef CONFIG_NCPFS_EXTRAS
841 if (server->m.flags & NCP_MOUNT_EXTRAS) {
842 /* any non-default execute bit set */
843 if (newmode & ~server->m.file_mode & S_IXUGO)
844 info.attributes |= aSHARED | aSYSTEM;
845 /* read for group/world and not in default file_mode */
846 else if (newmode & ~server->m.file_mode & S_IRUGO)
847 info.attributes |= aSHARED;
850 newmode &= server->m.file_mode;
852 if (newmode & S_IWUGO)
853 info.attributes &= ~(aRONLY|aRENAMEINHIBIT|aDELETEINHIBIT);
855 info.attributes |= (aRONLY|aRENAMEINHIBIT|aDELETEINHIBIT);
857 #ifdef CONFIG_NCPFS_NFS_NS
858 if (ncp_is_nfs_extras(server, NCP_FINFO(inode)->volNumber)) {
859 result = ncp_modify_nfs_info(server,
860 NCP_FINFO(inode)->volNumber,
861 NCP_FINFO(inode)->dirEntNum,
865 info.attributes &= ~(aSHARED | aSYSTEM);
867 /* mark partial success */
868 struct iattr tmpattr;
870 tmpattr.ia_valid = ATTR_MODE;
871 tmpattr.ia_mode = attr->ia_mode;
873 result = inode_setattr(inode, &tmpattr);
882 /* Do SIZE before attributes, otherwise mtime together with size does not work...
884 if ((attr->ia_valid & ATTR_SIZE) != 0) {
887 DPRINTK("ncpfs: trying to change size to %ld\n",
890 if ((result = ncp_make_open(inode, O_WRONLY)) < 0) {
894 ncp_write_kernel(NCP_SERVER(inode), NCP_FINFO(inode)->file_handle,
895 attr->ia_size, 0, "", &written);
897 /* According to ndir, the changes only take effect after
899 ncp_inode_close(inode);
900 result = ncp_make_closed(inode);
904 struct iattr tmpattr;
906 tmpattr.ia_valid = ATTR_SIZE;
907 tmpattr.ia_size = attr->ia_size;
909 result = inode_setattr(inode, &tmpattr);
914 if ((attr->ia_valid & ATTR_CTIME) != 0) {
915 info_mask |= (DM_CREATE_TIME | DM_CREATE_DATE);
916 ncp_date_unix2dos(attr->ia_ctime.tv_sec,
917 &info.creationTime, &info.creationDate);
919 if ((attr->ia_valid & ATTR_MTIME) != 0) {
920 info_mask |= (DM_MODIFY_TIME | DM_MODIFY_DATE);
921 ncp_date_unix2dos(attr->ia_mtime.tv_sec,
922 &info.modifyTime, &info.modifyDate);
924 if ((attr->ia_valid & ATTR_ATIME) != 0) {
926 info_mask |= (DM_LAST_ACCESS_DATE);
927 ncp_date_unix2dos(attr->ia_atime.tv_sec,
928 &dummy, &info.lastAccessDate);
930 if (info_mask != 0) {
931 result = ncp_modify_file_or_subdir_dos_info(NCP_SERVER(inode),
932 inode, info_mask, &info);
936 if (info_mask == (DM_CREATE_TIME | DM_CREATE_DATE)) {
937 /* NetWare seems not to allow this. I
938 do not know why. So, just tell the
939 user everything went fine. This is
940 a terrible hack, but I do not know
941 how to do this correctly. */
946 #ifdef CONFIG_NCPFS_STRONG
947 if ((!result) && (info_mask & DM_ATTRIBUTES))
948 NCP_FINFO(inode)->nwattr = info.attributes;
952 result = inode_setattr(inode, attr);
958 static int ncp_get_sb(struct file_system_type *fs_type,
959 int flags, const char *dev_name, void *data, struct vfsmount *mnt)
961 return get_sb_nodev(fs_type, flags, data, ncp_fill_super, mnt);
964 static struct file_system_type ncp_fs_type = {
965 .owner = THIS_MODULE,
967 .get_sb = ncp_get_sb,
968 .kill_sb = kill_anon_super,
971 static int __init init_ncp_fs(void)
974 DPRINTK("ncpfs: init_module called\n");
976 err = init_inodecache();
979 err = register_filesystem(&ncp_fs_type);
984 destroy_inodecache();
989 static void __exit exit_ncp_fs(void)
991 DPRINTK("ncpfs: cleanup_module called\n");
992 unregister_filesystem(&ncp_fs_type);
993 destroy_inodecache();
996 module_init(init_ncp_fs)
997 module_exit(exit_ncp_fs)
998 MODULE_LICENSE("GPL");