1 files changed, 412 insertions, 610 deletions

diff --git a/fs/ncpfs/dir.c b/fs/ncpfs/dir.c
index ede71765f..e62e26e47 100644
--- a/fs/ncpfs/dir.c
+++ b/fs/ncpfs/dir.c
@@ -2,6 +2,7 @@
  *  dir.c
  *
  *  Copyright (C) 1995, 1996 by Volker Lendecke
+ *  Modified for big endian by J.F. Chadima and David S. Miller
  *
  */
 
@@ -14,105 +15,100 @@
 #include <linux/mm.h>
 #include <linux/ncp_fs.h>
 #include <asm/uaccess.h>
+#include <asm/byteorder.h>
 #include <linux/errno.h>
 #include <linux/locks.h>
 #include "ncplib_kernel.h"
 
+
 struct ncp_dirent {
 	struct nw_info_struct i;
-	struct nw_search_sequence s; /* given back for i */
+	struct nw_search_sequence s;	/* given back for i */
 	unsigned long f_pos;
 };
 
 static long
-ncp_dir_read(struct inode *inode, struct file *filp, char *buf, unsigned long count);
+ ncp_dir_read(struct inode *inode, struct file *filp, char *buf, unsigned long count);
 
-static int 
-ncp_readdir(struct inode *inode, struct file *filp,
-            void *dirent, filldir_t filldir);
+static int
+ ncp_readdir(struct inode *inode, struct file *filp,
+	     void *dirent, filldir_t filldir);
 
 static int
-ncp_read_volume_list(struct ncp_server *server, int start_with,
-		     int cache_size);
+ ncp_read_volume_list(struct ncp_server *server, int start_with,
+		      int cache_size);
 
 static int
-ncp_do_readdir(struct ncp_server *server, struct inode *dir, int fpos,
-	       int cache_size, struct ncp_dirent *entry);
+ ncp_do_readdir(struct ncp_server *server, struct inode *dir, int fpos,
+		int cache_size, struct ncp_dirent *entry);
 
 static struct inode *
-ncp_iget(struct inode *dir, struct nw_file_info *finfo);
+ ncp_iget(struct inode *dir, struct nw_file_info *finfo);
 
 static struct ncp_inode_info *
-ncp_find_dir_inode(struct inode *dir, const char *name);
+ ncp_find_dir_inode(struct inode *dir, const char *name);
 
 static int
-ncp_lookup(struct inode *dir, const char *__name,
-           int len, struct inode **result);
+ ncp_lookup(struct inode *dir, const char *__name,
+	    int len, struct inode **result);
 
-static int 
-ncp_create(struct inode *dir, const char *name, int len, int mode, 
-           struct inode **result);
+static int
+ ncp_create(struct inode *dir, const char *name, int len, int mode,
+	    struct inode **result);
 
-static int 
-ncp_mkdir(struct inode *dir, const char *name, int len, int mode);
+static int
+ ncp_mkdir(struct inode *dir, const char *name, int len, int mode);
 
-static int 
-ncp_rmdir(struct inode *dir, const char *name, int len);
+static int
+ ncp_rmdir(struct inode *dir, const char *name, int len);
 
 static int
-ncp_unlink(struct inode *dir, const char *name, int len);
+ ncp_unlink(struct inode *dir, const char *name, int len);
 
 static int
-ncp_rename(struct inode *old_dir, const char *old_name, int old_len, 
-           struct inode *new_dir, const char *new_name, int new_len,
-           int must_be_dir);
+ ncp_rename(struct inode *old_dir, const char *old_name, int old_len,
+	    struct inode *new_dir, const char *new_name, int new_len,
+	    int must_be_dir);
 
-static inline void
-str_upper(char *name)
+static inline void str_upper(char *name)
 {
-	while (*name)
-	{
-		if (*name >= 'a' && *name <= 'z')
-		{
+	while (*name) {
+		if (*name >= 'a' && *name <= 'z') {
 			*name -= ('a' - 'A');
 		}
 		name++;
 	}
 }
 
-static inline void
-str_lower(char *name)
+static inline void str_lower(char *name)
 {
-	while (*name)
-	{
-		if (*name >= 'A' && *name <= 'Z')
-		{
+	while (*name) {
+		if (*name >= 'A' && *name <= 'Z') {
 			*name += ('a' - 'A');
 		}
-		name ++;
+		name++;
 	}
 }
 
-static inline int
-ncp_namespace(struct inode *i)
+static inline int ncp_namespace(struct inode *i)
 {
-	struct ncp_server *server   = NCP_SERVER(i);
+	struct ncp_server *server = NCP_SERVER(i);
 	struct nw_info_struct *info = NCP_ISTRUCT(i);
 	return server->name_space[info->volNumber];
 }
 
-static inline int
-ncp_preserve_case(struct inode *i)
+static inline int ncp_preserve_case(struct inode *i)
 {
 	return (ncp_namespace(i) == NW_NS_OS2);
 }
 
-static struct file_operations ncp_dir_operations = {
-        NULL,			/* lseek - default */
+static struct file_operations ncp_dir_operations =
+{
+	NULL,			/* lseek - default */
 	ncp_dir_read,		/* read - bad */
 	NULL,			/* write - bad */
 	ncp_readdir,		/* readdir */
-	NULL,			/* select - default */
+	NULL,			/* poll - default */
 	ncp_ioctl,		/* ioctl */
 	NULL,			/* mmap */
 	NULL,			/* no special open code */
@@ -120,23 +116,24 @@ static struct file_operations ncp_dir_operations = {
 	NULL			/* fsync */
 };
 
-struct inode_operations ncp_dir_inode_operations = {
+struct inode_operations ncp_dir_inode_operations =
+{
 	&ncp_dir_operations,	/* default directory file ops */
 	ncp_create,		/* create */
-	ncp_lookup,    		/* lookup */
+	ncp_lookup,		/* lookup */
 	NULL,			/* link */
-	ncp_unlink,    		/* unlink */
+	ncp_unlink,		/* unlink */
 	NULL,			/* symlink */
-	ncp_mkdir,     		/* mkdir */
-	ncp_rmdir,     		/* rmdir */
+	ncp_mkdir,		/* mkdir */
+	ncp_rmdir,		/* rmdir */
 	NULL,			/* mknod */
-	ncp_rename,    		/* rename */
+	ncp_rename,		/* rename */
 	NULL,			/* readlink */
 	NULL,			/* follow_link */
 	NULL,			/* bmap */
 	NULL,			/* truncate */
 	NULL,			/* permission */
-	NULL                    /* smap */
+	NULL			/* smap */
 };
 
 
@@ -148,223 +145,181 @@ struct inode_operations ncp_dir_inode_operations = {
  * enable the NFS exportability of a ncpfs-mounted volume.
  */
 
-static inline int
-ncp_single_volume(struct ncp_server *server)
+static inline int ncp_single_volume(struct ncp_server *server)
 {
 	return (server->m.mounted_vol[0] != '\0');
 }
 
 inline ino_t
-ncp_info_ino(struct ncp_server *server, struct ncp_inode_info *info)
+ ncp_info_ino(struct ncp_server * server, struct ncp_inode_info * info)
 {
 	return ncp_single_volume(server)
-		? info->finfo.i.dirEntNum : (ino_t)info;
+	    ? info->finfo.i.dirEntNum : (ino_t) info;
 }
 
-static inline int
-ncp_is_server_root(struct inode *inode)
+static inline int ncp_is_server_root(struct inode *inode)
 {
 	struct ncp_server *s = NCP_SERVER(inode);
 
-	return (   (!ncp_single_volume(s))
+	return ((!ncp_single_volume(s))
 		&& (inode->i_ino == ncp_info_ino(s, &(s->root))));
 }
 
 struct ncp_inode_info *
-ncp_find_inode(struct inode *inode)
+ ncp_find_inode(struct inode *inode)
 {
 	struct ncp_server *server = NCP_SERVER(inode);
-        struct ncp_inode_info *root = &(server->root);
-        struct ncp_inode_info *this = root;
+	struct ncp_inode_info *root = &(server->root);
+	struct ncp_inode_info *this = root;
 
 	ino_t ino = inode->i_ino;
 
-        do
-	{
-                if (ino == ncp_info_ino(server, this))
-		{
+	do {
+		if (ino == ncp_info_ino(server, this)) {
 			return this;
 		}
 		this = this->next;
-        }
+	}
 	while (this != root);
 
 	return NULL;
 }
-	
-static long
-ncp_dir_read(struct inode *inode, struct file *filp, char *buf, unsigned long count)
+
+static long ncp_dir_read(struct inode *inode, struct file *filp, char *buf, unsigned long count)
 {
 	return -EISDIR;
 }
 
-static kdev_t             c_dev = 0;
-static unsigned long      c_ino = 0;
-static int                c_size;
-static int                c_seen_eof;
-static int                c_last_returned_index;
-static struct ncp_dirent* c_entry = NULL;
-static int                c_lock = 0;
+static kdev_t c_dev = 0;
+static unsigned long c_ino = 0;
+static int c_size;
+static int c_seen_eof;
+static int c_last_returned_index;
+static struct ncp_dirent *c_entry = NULL;
+static int c_lock = 0;
 static struct wait_queue *c_wait = NULL;
 
-static inline void
-ncp_lock_dircache(void)
+static inline void ncp_lock_dircache(void)
 {
 	while (c_lock)
 		sleep_on(&c_wait);
 	c_lock = 1;
 }
 
-static inline void
-ncp_unlock_dircache(void)
+static inline void ncp_unlock_dircache(void)
 {
 	c_lock = 0;
 	wake_up(&c_wait);
 }
 
-static int
-ncp_readdir(struct inode *inode, struct file *filp,
-            void *dirent, filldir_t filldir)
+static int ncp_readdir(struct inode *inode, struct file *filp,
+		       void *dirent, filldir_t filldir)
 {
 	int result = 0;
 	int i = 0;
-        int index = 0;
+	int index = 0;
 	struct ncp_dirent *entry = NULL;
-        struct ncp_server *server = NCP_SERVER(inode);
+	struct ncp_server *server = NCP_SERVER(inode);
 	struct ncp_inode_info *dir = NCP_INOP(inode);
 
-	DDPRINTK("ncp_readdir: filp->f_pos = %d\n", (int)filp->f_pos);
+	DDPRINTK("ncp_readdir: filp->f_pos = %d\n", (int) filp->f_pos);
 	DDPRINTK("ncp_readdir: inode->i_ino = %ld, c_ino = %ld\n",
 		 inode->i_ino, c_ino);
 
-	if (!inode || !S_ISDIR(inode->i_mode))
-	{
+	if (!inode || !S_ISDIR(inode->i_mode)) {
 		printk("ncp_readdir: inode is NULL or not a directory\n");
 		return -EBADF;
 	}
-
-	if (!ncp_conn_valid(server))
-	{
+	if (!ncp_conn_valid(server)) {
 		return -EIO;
 	}
-
 	ncp_lock_dircache();
 
-	if (c_entry == NULL) 
-	{
-		i = sizeof (struct ncp_dirent) * NCP_READDIR_CACHE_SIZE;
+	if (c_entry == NULL) {
+		i = sizeof(struct ncp_dirent) * NCP_READDIR_CACHE_SIZE;
 		c_entry = (struct ncp_dirent *) vmalloc(i);
-		if (c_entry == NULL)
-		{
+		if (c_entry == NULL) {
 			printk("ncp_readdir: no MEMORY for cache\n");
 			result = -ENOMEM;
 			goto finished;
 		}
 	}
-
-        if (filp->f_pos == 0)
-	{
-                ncp_invalid_dir_cache(inode);
-		if (filldir(dirent,".",1, filp->f_pos,
-			    ncp_info_ino(server, dir)) < 0)
-		{
+	if (filp->f_pos == 0) {
+		ncp_invalid_dir_cache(inode);
+		if (filldir(dirent, ".", 1, filp->f_pos,
+			    ncp_info_ino(server, dir)) < 0) {
 			goto finished;
 		}
 		filp->f_pos += 1;
-        }
-
-	if (filp->f_pos == 1)
-	{
-		if (filldir(dirent,"..",2, filp->f_pos,
-			    ncp_info_ino(server, dir->dir)) < 0)
-		{
+	}
+	if (filp->f_pos == 1) {
+		if (filldir(dirent, "..", 2, filp->f_pos,
+			    ncp_info_ino(server, dir->dir)) < 0) {
 			goto finished;
 		}
 		filp->f_pos += 1;
 	}
-
-	if ((inode->i_dev == c_dev) && (inode->i_ino == c_ino))
-	{
-		for (i = 0; i < c_size; i++)
-		{
-			if (filp->f_pos == c_entry[i].f_pos)
-			{
-                                entry = &c_entry[i];
-                                c_last_returned_index = i;
-                                index = i;
-                                break;
+	if ((inode->i_dev == c_dev) && (inode->i_ino == c_ino)) {
+		for (i = 0; i < c_size; i++) {
+			if (filp->f_pos == c_entry[i].f_pos) {
+				entry = &c_entry[i];
+				c_last_returned_index = i;
+				index = i;
+				break;
 			}
 		}
-                if ((entry == NULL) && c_seen_eof)
-		{
+		if ((entry == NULL) && c_seen_eof) {
 			goto finished;
 		}
 	}
-
-	if (entry == NULL)
-	{
+	if (entry == NULL) {
 		int entries;
 		DDPRINTK("ncp_readdir: Not found in cache.\n");
 
-		if (ncp_is_server_root(inode))
-		{
+		if (ncp_is_server_root(inode)) {
 			entries = ncp_read_volume_list(server, filp->f_pos,
-						       NCP_READDIR_CACHE_SIZE);
+						 NCP_READDIR_CACHE_SIZE);
 			DPRINTK("ncp_read_volume_list returned %d\n", entries);
 
-		}
-		else
-		{
+		} else {
 			entries = ncp_do_readdir(server, inode, filp->f_pos,
 						 NCP_READDIR_CACHE_SIZE,
 						 c_entry);
 			DPRINTK("ncp_readdir returned %d\n", entries);
 		}
 
-		if (entries < 0)
-		{
+		if (entries < 0) {
 			c_dev = 0;
 			c_ino = 0;
 			result = entries;
 			goto finished;
 		}
-
-		if (entries > 0)
-		{
-                        c_seen_eof = (entries < NCP_READDIR_CACHE_SIZE);
-			c_dev  = inode->i_dev;
-			c_ino  = inode->i_ino;
+		if (entries > 0) {
+			c_seen_eof = (entries < NCP_READDIR_CACHE_SIZE);
+			c_dev = inode->i_dev;
+			c_ino = inode->i_ino;
 			c_size = entries;
 			entry = c_entry;
-                        c_last_returned_index = 0;
-                        index = 0;
+			c_last_returned_index = 0;
+			index = 0;
 
-			if (!ncp_preserve_case(inode))
-			{
-				for (i = 0; i < c_size; i++)
-				{
+			if (!ncp_preserve_case(inode)) {
+				for (i = 0; i < c_size; i++) {
 					str_lower(c_entry[i].i.entryName);
 				}
 			}
 		}
 	}
-
-        if (entry == NULL)
-	{
-                /* Nothing found, even from a ncp call */
+	if (entry == NULL) {
+		/* Nothing found, even from a ncp call */
 		goto finished;
-        }
-
-        while (index < c_size)
-	{
+	}
+	while (index < c_size) {
 		ino_t ino;
 
-		if (ncp_single_volume(server))
-		{
-			ino = (ino_t)(entry->i.dirEntNum);
-		}
-		else
-		{
+		if (ncp_single_volume(server)) {
+			ino = (ino_t) (entry->i.dirEntNum);
+		} else {
 			/* For getwd() we have to return the correct
 			 * inode in d_ino if the inode is currently in
 			 * use. Otherwise the inode number does not
@@ -376,41 +331,36 @@ ncp_readdir(struct inode *inode, struct file *filp,
 			/* Some programs seem to be confused about a
 			 * zero inode number, so we set it to one.
 			 * Thanks to Gordon Chaffee for this one. */
-			if (ino_info == NULL)
-			{
+			if (ino_info == NULL) {
 				ino_info = (struct ncp_inode_info *) 1;
 			}
-			ino = (ino_t)(ino_info);
+			ino = (ino_t) (ino_info);
 		}
 
 		DDPRINTK("ncp_readdir: entry->path= %s\n", entry->i.entryName);
 		DDPRINTK("ncp_readdir: entry->f_pos = %ld\n", entry->f_pos);
 
-                if (filldir(dirent, entry->i.entryName, entry->i.nameLen,
-                            entry->f_pos, ino) < 0)
-		{
+		if (filldir(dirent, entry->i.entryName, entry->i.nameLen,
+			    entry->f_pos, ino) < 0) {
 			break;
-                }
-
-		if (   (inode->i_dev != c_dev)
+		}
+		if ((inode->i_dev != c_dev)
 		    || (inode->i_ino != c_ino)
-		    || (entry->f_pos != filp->f_pos))
-		{
+		    || (entry->f_pos != filp->f_pos)) {
 			/* Someone has destroyed the cache while we slept
 			   in filldir */
 			break;
 		}
-                filp->f_pos += 1;
-                index += 1;
-                entry += 1;
+		filp->f_pos += 1;
+		index += 1;
+		entry += 1;
 	}
- finished:
+      finished:
 	ncp_unlock_dircache();
 	return result;
 }
 
-static int
-ncp_read_volume_list(struct ncp_server *server, int fpos, int cache_size)
+static int ncp_read_volume_list(struct ncp_server *server, int fpos, int cache_size)
 {
 	struct ncp_dirent *entry = c_entry;
 
@@ -418,47 +368,35 @@ ncp_read_volume_list(struct ncp_server *server, int fpos, int cache_size)
 	int i;
 
 #if 1
-	if (fpos < 2)
-	{
+	if (fpos < 2) {
 		printk("OOPS, we expect fpos >= 2");
 		fpos = 2;
 	}
 #endif
 
-	for (i=0; i<NCP_NUMBER_OF_VOLUMES; i++)
-	{
+	for (i = 0; i < NCP_NUMBER_OF_VOLUMES; i++) {
 		struct ncp_volume_info info;
 
-		if (ncp_get_volume_info_with_number(server, i, &info) != 0)
-		{
+		if (ncp_get_volume_info_with_number(server, i, &info) != 0) {
 			return (total_count - fpos);
 		}
-
-		if (strlen(info.volume_name) > 0)
-		{
-			if (total_count < fpos)
-			{
+		if (strlen(info.volume_name) > 0) {
+			if (total_count < fpos) {
 				DPRINTK("ncp_read_volumes: skipped vol: %s\n",
 					info.volume_name);
-			}
-			else if (total_count >= fpos + cache_size)
-			{
+			} else if (total_count >= fpos + cache_size) {
 				return (total_count - fpos);
-			}
-			else
-			{
+			} else {
 				DPRINTK("ncp_read_volumes: found vol: %s\n",
 					info.volume_name);
 
 				if (ncp_lookup_volume(server,
 						      info.volume_name,
-						      &(entry->i)) != 0)
-				{
+						      &(entry->i)) != 0) {
 					DPRINTK("ncpfs: could not lookup vol "
 						"%s\n", info.volume_name);
 					continue;
 				}
-
 				entry->f_pos = total_count;
 				entry += 1;
 			}
@@ -468,59 +406,46 @@ ncp_read_volume_list(struct ncp_server *server, int fpos, int cache_size)
 	return (total_count - fpos);
 }
 
-static int
-ncp_do_readdir(struct ncp_server *server, struct inode *dir, int fpos,
-	       int cache_size, struct ncp_dirent *entry)
+static int ncp_do_readdir(struct ncp_server *server, struct inode *dir, int fpos,
+			  int cache_size, struct ncp_dirent *entry)
 {
 	static struct nw_search_sequence seq;
 	static struct inode *last_dir;
 	static int total_count;
 
 #if 1
-	if (fpos < 2)
-	{
+	if (fpos < 2) {
 		printk("OOPS, we expect fpos >= 2");
 		fpos = 2;
 	}
 #endif
 	DPRINTK("ncp_do_readdir: fpos = %d\n", fpos);
 
-	if (fpos == 2)
-	{
+	if (fpos == 2) {
 		last_dir = NULL;
 		total_count = 2;
 	}
-
-	if ((fpos != total_count) || (dir != last_dir))
-	{
+	if ((fpos != total_count) || (dir != last_dir)) {
 		total_count = 2;
 		last_dir = dir;
 
 		DPRINTK("ncp_do_readdir: re-used seq for %s\n",
 			NCP_ISTRUCT(dir)->entryName);
 
-		if (ncp_initialize_search(server, NCP_ISTRUCT(dir), &seq)!=0)
-		{
+		if (ncp_initialize_search(server, NCP_ISTRUCT(dir), &seq) != 0) {
 			DPRINTK("ncp_init_search failed\n");
 			return total_count - fpos;
 		}
 	}
-
-	while (total_count < fpos + cache_size)
-	{
+	while (total_count < fpos + cache_size) {
 		if (ncp_search_for_file_or_subdir(server, &seq,
-						  &(entry->i)) != 0)
-		{
+						  &(entry->i)) != 0) {
 			return total_count - fpos;
 		}
-
-		if (total_count < fpos)
-		{
+		if (total_count < fpos) {
 			DPRINTK("ncp_do_readdir: skipped file: %s\n",
 				entry->i.entryName);
-		}
-		else
-		{
+		} else {
 			DDPRINTK("ncp_do_r: file: %s, f_pos=%d,total_count=%d",
 				 entry->i.entryName, fpos, total_count);
 			entry->s = seq;
@@ -532,168 +457,150 @@ ncp_do_readdir(struct ncp_server *server, struct inode *dir, int fpos,
 	return (total_count - fpos);
 }
 
-void
-ncp_init_dir_cache(void)
+void ncp_init_dir_cache(void)
 {
-	c_dev   = 0;
-        c_ino   = 0;
-        c_entry = NULL;
+	c_dev = 0;
+	c_ino = 0;
+	c_entry = NULL;
 }
 
-void
-ncp_invalid_dir_cache(struct inode *ino)
+void ncp_invalid_dir_cache(struct inode *ino)
 {
-	if ((ino->i_dev == c_dev) && (ino->i_ino == c_ino))
-	{
+	if ((ino->i_dev == c_dev) && (ino->i_ino == c_ino)) {
 		c_dev = 0;
-                c_ino = 0;
-                c_seen_eof = 0;
-        }
+		c_ino = 0;
+		c_seen_eof = 0;
+	}
 }
 
-void
-ncp_free_dir_cache(void)
+void ncp_free_dir_cache(void)
 {
-        DPRINTK("ncp_free_dir_cache: enter\n");
-        
-        if (c_entry == NULL)
-	{
-                return;
-	}
+	DPRINTK("ncp_free_dir_cache: enter\n");
 
+	if (c_entry == NULL) {
+		return;
+	}
 	vfree(c_entry);
 	c_entry = NULL;
 
-        DPRINTK("ncp_free_dir_cache: exit\n");
+	DPRINTK("ncp_free_dir_cache: exit\n");
 }
 
 
 static struct inode *
-ncp_iget(struct inode *dir, struct nw_file_info *finfo)
+ ncp_iget(struct inode *dir, struct nw_file_info *finfo)
 {
 	struct inode *inode;
-        struct ncp_inode_info *new_inode_info;
-        struct ncp_inode_info *root;
+	struct ncp_inode_info *new_inode_info;
+	struct ncp_inode_info *root;
 
-	if (dir == NULL)
-	{
+	if (dir == NULL) {
 		printk("ncp_iget: dir is NULL\n");
 		return NULL;
 	}
-
-	if (finfo == NULL)
-	{
+	if (finfo == NULL) {
 		printk("ncp_iget: finfo is NULL\n");
 		return NULL;
 	}
+	new_inode_info = ncp_kmalloc(sizeof(struct ncp_inode_info),
+				     GFP_KERNEL);
 
-        new_inode_info = ncp_kmalloc(sizeof(struct ncp_inode_info),
-                                     GFP_KERNEL);
-
-        if (new_inode_info == NULL)
-	{
-                printk("ncp_iget: could not alloc mem for %s\n",
+	if (new_inode_info == NULL) {
+		printk("ncp_iget: could not alloc mem for %s\n",
 		       finfo->i.entryName);
-                return NULL;
-        }
+		return NULL;
+	}
+	new_inode_info->state = NCP_INODE_LOOKED_UP;
+	new_inode_info->nused = 0;
+	new_inode_info->dir = NCP_INOP(dir);
+	new_inode_info->finfo = *finfo;
 
-        new_inode_info->state = NCP_INODE_LOOKED_UP;
-        new_inode_info->nused = 0;
-        new_inode_info->dir   = NCP_INOP(dir);
-        new_inode_info->finfo = *finfo;
+	NCP_INOP(dir)->nused += 1;
 
-        NCP_INOP(dir)->nused += 1;
+	/* We have to link the new inode_info into the doubly linked
+	   list of inode_infos to make a complete linear search
+	   possible. */
 
-        /* We have to link the new inode_info into the doubly linked
-           list of inode_infos to make a complete linear search
-           possible. */
+	root = &(NCP_SERVER(dir)->root);
 
-        root = &(NCP_SERVER(dir)->root);
+	new_inode_info->prev = root;
+	new_inode_info->next = root->next;
+	root->next->prev = new_inode_info;
+	root->next = new_inode_info;
 
-        new_inode_info->prev = root;
-        new_inode_info->next = root->next;
-        root->next->prev = new_inode_info;
-        root->next = new_inode_info;
-        
 	if (!(inode = iget(dir->i_sb, ncp_info_ino(NCP_SERVER(dir),
-						   new_inode_info))))
-	{
+						   new_inode_info)))) {
 		printk("ncp_iget: iget failed!");
 		return NULL;
 	}
-
 	return inode;
 }
 
-void
-ncp_free_inode_info(struct ncp_inode_info *i)
+void ncp_free_inode_info(struct ncp_inode_info *i)
 {
-        if (i == NULL)
-	{
-                printk("ncp_free_inode: i == NULL\n");
-                return;
-        }
-
-        i->state = NCP_INODE_CACHED;
-        while ((i->nused == 0) && (i->state == NCP_INODE_CACHED))
-	{
-                struct ncp_inode_info *dir = i->dir;
+	if (i == NULL) {
+		printk("ncp_free_inode: i == NULL\n");
+		return;
+	}
+	i->state = NCP_INODE_CACHED;
+	while ((i->nused == 0) && (i->state == NCP_INODE_CACHED)) {
+		struct ncp_inode_info *dir = i->dir;
 
-                i->next->prev = i->prev;
-                i->prev->next = i->next;
+		i->next->prev = i->prev;
+		i->prev->next = i->next;
 
 		DDPRINTK("ncp_free_inode_info: freeing %s\n",
 			 i->finfo.i.entryName);
 
-                ncp_kfree_s(i, sizeof(struct ncp_inode_info));
+		ncp_kfree_s(i, sizeof(struct ncp_inode_info));
 
-                if (dir == i) return;
+		if (dir == i)
+			return;
 
-                (dir->nused)--;
-                i = dir;
-        }
+		(dir->nused)--;
+		i = dir;
+	}
 }
-        
-void
-ncp_init_root(struct ncp_server *server)
+
+void ncp_init_root(struct ncp_server *server)
 {
-        struct ncp_inode_info *root = &(server->root);
+	struct ncp_inode_info *root = &(server->root);
 	struct nw_info_struct *i = &(root->finfo.i);
 	unsigned short dummy;
 
-	DPRINTK("ncp_init_root: server %s\n", server->m.server_name);
-	DPRINTK("ncp_init_root: i = %x\n", (int)i);
+	DPRINTK("ncp_init_root: i = %x\n", (int) i);
 
-        root->finfo.opened = 0;
-	i->attributes  = aDIR;
+	root->finfo.opened = 0;
+	i->attributes = aDIR;
 	i->dataStreamSize = 1024;
 	i->dirEntNum = i->DosDirNum = 0;
-	i->volNumber = NCP_NUMBER_OF_VOLUMES+1;	/* illegal volnum */
+	i->volNumber = NCP_NUMBER_OF_VOLUMES + 1;	/* illegal volnum */
 	ncp_date_unix2dos(0, &(i->creationTime), &(i->creationDate));
 	ncp_date_unix2dos(0, &(i->modifyTime), &(i->modifyDate));
 	ncp_date_unix2dos(0, &dummy, &(i->lastAccessDate));
+	i->creationTime = le16_to_cpu(i->creationTime);
+	i->creationDate = le16_to_cpu(i->creationDate);
+	i->modifyTime = le16_to_cpu(i->modifyTime);
+	i->modifyDate = le16_to_cpu(i->modifyDate);
+	i->lastAccessDate = le16_to_cpu(i->lastAccessDate);
 	i->nameLen = 0;
 	i->entryName[0] = '\0';
 
-        root->state = NCP_INODE_LOOKED_UP;
-        root->nused = 1;
-        root->dir   = root;
-        root->next = root->prev = root;
-        return;
+	root->state = NCP_INODE_LOOKED_UP;
+	root->nused = 1;
+	root->dir = root;
+	root->next = root->prev = root;
+	return;
 }
 
-int
-ncp_conn_logged_in(struct ncp_server *server)
+int ncp_conn_logged_in(struct ncp_server *server)
 {
-	if (server->m.mounted_vol[0] == '\0')
-	{
+	if (server->m.mounted_vol[0] == '\0') {
 		return 0;
 	}
-
 	str_upper(server->m.mounted_vol);
 	if (ncp_lookup_volume(server, server->m.mounted_vol,
-			      &(server->root.finfo.i)) != 0)
-	{
+			      &(server->root.finfo.i)) != 0) {
 		return -ENOENT;
 	}
 	str_lower(server->root.finfo.i.entryName);
@@ -701,202 +608,166 @@ ncp_conn_logged_in(struct ncp_server *server)
 	return 0;
 }
 
-void
-ncp_free_all_inodes(struct ncp_server *server)
+void ncp_free_all_inodes(struct ncp_server *server)
 {
-        /* Here nothing should be to do. I do not know whether it's
-           better to leave some memory allocated or be stuck in an
-           endless loop */
+	/* Here nothing should be to do. I do not know whether it's
+	   better to leave some memory allocated or be stuck in an
+	   endless loop */
 #if 1
-        struct ncp_inode_info *root = &(server->root);
-
-        if (root->next != root)
-	{
-                printk("ncp_free_all_inodes: INODES LEFT!!!\n");
-        }
-
-        while (root->next != root)
-	{
-                printk("ncp_free_all_inodes: freeing inode\n");
-                ncp_free_inode_info(root->next);
-                /* In case we have an endless loop.. */
-                schedule();
-        }
-#endif        
-        
-        return;
+	struct ncp_inode_info *root = &(server->root);
+
+	if (root->next != root) {
+		printk("ncp_free_all_inodes: INODES LEFT!!!\n");
+	}
+	while (root->next != root) {
+		printk("ncp_free_all_inodes: freeing inode\n");
+		ncp_free_inode_info(root->next);
+		/* In case we have an endless loop.. */
+		schedule();
+	}
+#endif
+
+	return;
 }
 
 /* We will search the inode that belongs to this name, currently by a
    complete linear search through the inodes belonging to this
    filesystem. This has to be fixed. */
 static struct ncp_inode_info *
-ncp_find_dir_inode(struct inode *dir, const char *name)
+ ncp_find_dir_inode(struct inode *dir, const char *name)
 {
 	struct ncp_server *server = NCP_SERVER(dir);
 	struct nw_info_struct *dir_info = NCP_ISTRUCT(dir);
-        struct ncp_inode_info *result = &(server->root);
+	struct ncp_inode_info *result = &(server->root);
 
-        if (name == NULL)
-	{
-                return NULL;
+	if (name == NULL) {
+		return NULL;
 	}
-
-        do
-	{
-		if (   (result->dir->finfo.i.dirEntNum == dir_info->dirEntNum)
-		    && (result->dir->finfo.i.volNumber == dir_info->volNumber)
+	do {
+		if ((result->dir->finfo.i.dirEntNum == dir_info->dirEntNum)
+		&& (result->dir->finfo.i.volNumber == dir_info->volNumber)
 		    && (strcmp(result->finfo.i.entryName, name) == 0)
-		    /* The root dir is never looked up using this
-		     * routine.  Without the following test a root
-		     * directory 'sys' in a volume named 'sys' could
-		     * never be looked up, because
-		     * server->root->dir==server->root. */
-		    && (result != &(server->root)))
-		{
-                        return result;
+		/* The root dir is never looked up using this
+		 * routine.  Without the following test a root
+		 * directory 'sys' in a volume named 'sys' could
+		 * never be looked up, because
+		 * server->root->dir==server->root. */
+		    && (result != &(server->root))) {
+			return result;
 		}
-                result = result->next;
+		result = result->next;
 
-        }
+	}
 	while (result != &(server->root));
 
-        return NULL;
+	return NULL;
 }
 
-static int 
-ncp_lookup(struct inode *dir, const char *__name, int len,
-           struct inode **result)
+static int ncp_lookup(struct inode *dir, const char *__name, int len,
+		      struct inode **result)
 {
 	struct nw_file_info finfo;
 	struct ncp_server *server;
 	struct ncp_inode_info *result_info;
 	int found_in_cache;
 	int down_case = 0;
-	char name[len+1];
+	char name[len + 1];
 
 	*result = NULL;
 
-	if (!dir || !S_ISDIR(dir->i_mode))
-	{
+	if (!dir || !S_ISDIR(dir->i_mode)) {
 		printk("ncp_lookup: inode is NULL or not a directory.\n");
 		iput(dir);
 		return -ENOENT;
 	}
-
 	server = NCP_SERVER(dir);
 
-	if (!ncp_conn_valid(server))
-	{
+	if (!ncp_conn_valid(server)) {
 		iput(dir);
 		return -EIO;
 	}
-
 	DPRINTK("ncp_lookup: %s, len %d\n", __name, len);
 
 	/* Fast cheat for . */
-	if (len == 0 || (len == 1 && __name[0] == '.'))
-	{
+	if (len == 0 || (len == 1 && __name[0] == '.')) {
 		*result = dir;
 		return 0;
 	}
-
 	/* ..and for .. */
-	if (len == 2 && __name[0] == '.' && __name[1] == '.')
-	{
+	if (len == 2 && __name[0] == '.' && __name[1] == '.') {
 		struct ncp_inode_info *parent = NCP_INOP(dir)->dir;
 
-		if (parent->state == NCP_INODE_CACHED)
-		{
+		if (parent->state == NCP_INODE_CACHED) {
 			parent->state = NCP_INODE_LOOKED_UP;
 		}
-
 		*result = iget(dir->i_sb, ncp_info_ino(server, parent));
 		iput(dir);
-		if (*result == 0)
-		{
+		if (*result == 0) {
 			return -EACCES;
-		}
-		else
-		{
+		} else {
 			return 0;
 		}
 	}
-
 	memcpy(name, __name, len);
 	name[len] = 0;
 	lock_super(dir->i_sb);
 	result_info = ncp_find_dir_inode(dir, name);
 
-        if (result_info != 0)
-	{
-                if (result_info->state == NCP_INODE_CACHED)
-		{
-                        result_info->state = NCP_INODE_LOOKED_UP;
+	if (result_info != 0) {
+		if (result_info->state == NCP_INODE_CACHED) {
+			result_info->state = NCP_INODE_LOOKED_UP;
 		}
+		/* Here we convert the inode_info address into an
+		   inode number */
 
-                /* Here we convert the inode_info address into an
-                   inode number */
-
-                *result = iget(dir->i_sb, ncp_info_ino(server, result_info));
+		*result = iget(dir->i_sb, ncp_info_ino(server, result_info));
 		unlock_super(dir->i_sb);
-                iput(dir);
-
-                if (*result == NULL)
-		{
-                        return -EACCES;
-                }
+		iput(dir);
 
+		if (*result == NULL) {
+			return -EACCES;
+		}
 		return 0;
-        }
-
-        /* If the file is in the dir cache, we do not have to ask the
-           server. */
+	}
+	/* If the file is in the dir cache, we do not have to ask the
+	   server. */
 
-        found_in_cache = 0;
+	found_in_cache = 0;
 	ncp_lock_dircache();
 
-        if ((dir->i_dev == c_dev) && (dir->i_ino == c_ino))
-	{
-                int first = c_last_returned_index;
-                int i;
+	if ((dir->i_dev == c_dev) && (dir->i_ino == c_ino)) {
+		int first = c_last_returned_index;
+		int i;
 
-                i = first;
-                do
-		{
-                        DDPRINTK("ncp_lookup: trying index: %d, name: %s\n",
+		i = first;
+		do {
+			DDPRINTK("ncp_lookup: trying index: %d, name: %s\n",
 				 i, c_entry[i].i.entryName);
 
-                        if (strcmp(c_entry[i].i.entryName, name) == 0)
-			{
-                                DPRINTK("ncp_lookup: found in cache!\n");
+			if (strcmp(c_entry[i].i.entryName, name) == 0) {
+				DPRINTK("ncp_lookup: found in cache!\n");
 				finfo.i = c_entry[i].i;
 				found_in_cache = 1;
 				break;
-                        }
-                        i = (i + 1) % c_size;
-                }
+			}
+			i = (i + 1) % c_size;
+		}
 		while (i != first);
-        }
+	}
 	ncp_unlock_dircache();
 
-        if (found_in_cache == 0)
-	{
+	if (found_in_cache == 0) {
 		int res;
 
 		DDPRINTK("ncp_lookup: do_lookup on %s/%s\n",
 			 NCP_ISTRUCT(dir)->entryName, name);
 
-		if (ncp_is_server_root(dir))
-		{
+		if (ncp_is_server_root(dir)) {
 			str_upper(name);
 			down_case = 1;
 			res = ncp_lookup_volume(server, name, &(finfo.i));
-		}
-		else
-		{
-			if (!ncp_preserve_case(dir))
-			{
+		} else {
+			if (!ncp_preserve_case(dir)) {
 				str_upper(name);
 				down_case = 1;
 			}
@@ -905,313 +776,246 @@ ncp_lookup(struct inode *dir, const char *__name, int len,
 					      NCP_ISTRUCT(dir)->dirEntNum,
 					      name, &(finfo.i));
 		}
-		if (res != 0)
-		{
+		if (res != 0) {
 			unlock_super(dir->i_sb);
-                        iput(dir);
-                        return -ENOENT;
-                }
-        }
-
+			iput(dir);
+			return -ENOENT;
+		}
+	}
 	finfo.opened = 0;
 
-	if (down_case != 0)
-	{
+	if (down_case != 0) {
 		str_lower(finfo.i.entryName);
 	}
-
-	if (!(*result = ncp_iget(dir, &finfo)))
-	{
+	if (!(*result = ncp_iget(dir, &finfo))) {
 		unlock_super(dir->i_sb);
 		iput(dir);
 		return -EACCES;
 	}
-
 	unlock_super(dir->i_sb);
 	iput(dir);
 	return 0;
 }
 
-static int 
-ncp_create(struct inode *dir, const char *name, int len, int mode,
-           struct inode **result)
+static int ncp_create(struct inode *dir, const char *name, int len, int mode,
+		      struct inode **result)
 {
 	struct nw_file_info finfo;
-	__u8 _name[len+1];
+	__u8 _name[len + 1];
 
 	*result = NULL;
 
-	if (!dir || !S_ISDIR(dir->i_mode))
-	{
+	if (!dir || !S_ISDIR(dir->i_mode)) {
 		printk("ncp_create: inode is NULL or not a directory\n");
 		iput(dir);
 		return -ENOENT;
 	}
-	if (!ncp_conn_valid(NCP_SERVER(dir)))
-	{
+	if (!ncp_conn_valid(NCP_SERVER(dir))) {
 		iput(dir);
 		return -EIO;
 	}
-
 	strncpy(_name, name, len);
 	_name[len] = '\0';
 
-	if (!ncp_preserve_case(dir))
-	{
+	if (!ncp_preserve_case(dir)) {
 		str_upper(_name);
 	}
-
 	lock_super(dir->i_sb);
 	if (ncp_open_create_file_or_subdir(NCP_SERVER(dir),
 					   NCP_ISTRUCT(dir), _name,
-					   OC_MODE_CREATE|OC_MODE_OPEN|
+					   OC_MODE_CREATE | OC_MODE_OPEN |
 					   OC_MODE_REPLACE,
-					   0, AR_READ|AR_WRITE,
-					   &finfo) != 0)
-	{
+					   0, AR_READ | AR_WRITE,
+					   &finfo) != 0) {
 		unlock_super(dir->i_sb);
 		iput(dir);
 		return -EACCES;
 	}
-
 	ncp_invalid_dir_cache(dir);
 
-	if (!ncp_preserve_case(dir))
-	{
+	if (!ncp_preserve_case(dir)) {
 		str_lower(finfo.i.entryName);
 	}
-
 	finfo.access = O_RDWR;
 
-	if (!(*result = ncp_iget(dir, &finfo)) < 0)
-	{
+	if (!(*result = ncp_iget(dir, &finfo)) < 0) {
 		ncp_close_file(NCP_SERVER(dir), finfo.file_handle);
 		unlock_super(dir->i_sb);
 		iput(dir);
 		return -EINVAL;
 	}
-
 	unlock_super(dir->i_sb);
 	iput(dir);
-	return 0;	
+	return 0;
 }
 
-static int
-ncp_mkdir(struct inode *dir, const char *name, int len, int mode)
+static int ncp_mkdir(struct inode *dir, const char *name, int len, int mode)
 {
 	int error;
 	struct nw_file_info new_dir;
-	__u8 _name[len+1];
+	__u8 _name[len + 1];
 
-	if (   (name[0] == '.')
-	    && (   (len == 1)
-		|| (   (len == 2)
-		    && (name[1] == '.'))))
-	{
+	if ((name[0] == '.')
+	    && ((len == 1)
+		|| ((len == 2)
+		    && (name[1] == '.')))) {
 		iput(dir);
 		return -EEXIST;
 	}
-
 	strncpy(_name, name, len);
 	_name[len] = '\0';
 
-	if (!ncp_preserve_case(dir))
-	{
+	if (!ncp_preserve_case(dir)) {
 		str_upper(_name);
 	}
-
-	if (!dir || !S_ISDIR(dir->i_mode))
-	{
+	if (!dir || !S_ISDIR(dir->i_mode)) {
 		printk("ncp_mkdir: inode is NULL or not a directory\n");
 		iput(dir);
 		return -ENOENT;
 	}
-	if (!ncp_conn_valid(NCP_SERVER(dir)))
-	{
+	if (!ncp_conn_valid(NCP_SERVER(dir))) {
 		iput(dir);
 		return -EIO;
 	}
-
 	if (ncp_open_create_file_or_subdir(NCP_SERVER(dir),
 					   NCP_ISTRUCT(dir), _name,
 					   OC_MODE_CREATE, aDIR, 0xffff,
-					   &new_dir) != 0)
-	{
+					   &new_dir) != 0) {
 		error = -EACCES;
-	}
-	else
-	{
+	} else {
 		error = 0;
-                ncp_invalid_dir_cache(dir);
-        }
+		ncp_invalid_dir_cache(dir);
+	}
 
 	iput(dir);
 	return error;
 }
 
-static int
-ncp_rmdir(struct inode *dir, const char *name, int len)
+static int ncp_rmdir(struct inode *dir, const char *name, int len)
 {
 	int error;
-	__u8 _name[len+1];
+	__u8 _name[len + 1];
 
-	if (!dir || !S_ISDIR(dir->i_mode))
-	{
+	if (!dir || !S_ISDIR(dir->i_mode)) {
 		printk("ncp_rmdir: inode is NULL or not a directory\n");
 		iput(dir);
 		return -ENOENT;
 	}
-	if (!ncp_conn_valid(NCP_SERVER(dir)))
-	{
+	if (!ncp_conn_valid(NCP_SERVER(dir))) {
 		iput(dir);
 		return -EIO;
 	}
-        if (ncp_find_dir_inode(dir, name) != NULL)
-	{
+	if (ncp_find_dir_inode(dir, name) != NULL) {
 		iput(dir);
-                error = -EBUSY;
-        }
-	else
-	{
+		error = -EBUSY;
+	} else {
 
 		strncpy(_name, name, len);
 		_name[len] = '\0';
 
-		if (!ncp_preserve_case(dir))
-		{
+		if (!ncp_preserve_case(dir)) {
 			str_upper(_name);
 		}
-
-                if ((error = ncp_del_file_or_subdir(NCP_SERVER(dir),
+		if ((error = ncp_del_file_or_subdir(NCP_SERVER(dir),
 						    NCP_ISTRUCT(dir),
-						    _name)) == 0)
-		{
-                        ncp_invalid_dir_cache(dir);
-		}
-		else
-		{
+						    _name)) == 0) {
+			ncp_invalid_dir_cache(dir);
+		} else {
 			error = -EACCES;
 		}
-        }
+	}
 	iput(dir);
 	return error;
 }
 
-static int
-ncp_unlink(struct inode *dir, const char *name, int len)
+static int ncp_unlink(struct inode *dir, const char *name, int len)
 {
 	int error;
-	__u8 _name[len+1];
+	__u8 _name[len + 1];
 
-	if (!dir || !S_ISDIR(dir->i_mode))
-	{
+	if (!dir || !S_ISDIR(dir->i_mode)) {
 		printk("ncp_unlink: inode is NULL or not a directory\n");
 		iput(dir);
 		return -ENOENT;
 	}
-	if (!ncp_conn_valid(NCP_SERVER(dir)))
-	{
+	if (!ncp_conn_valid(NCP_SERVER(dir))) {
 		iput(dir);
 		return -EIO;
 	}
-        if (ncp_find_dir_inode(dir, name) != NULL)
-	{
+	if (ncp_find_dir_inode(dir, name) != NULL) {
 		iput(dir);
-                error = -EBUSY;
-        }
-	else
-	{
+		error = -EBUSY;
+	} else {
 		strncpy(_name, name, len);
 		_name[len] = '\0';
 
-		if (!ncp_preserve_case(dir))
-		{
+		if (!ncp_preserve_case(dir)) {
 			str_upper(_name);
 		}
-
-                if ((error = ncp_del_file_or_subdir(NCP_SERVER(dir),
+		if ((error = ncp_del_file_or_subdir(NCP_SERVER(dir),
 						    NCP_ISTRUCT(dir),
-						    _name)) == 0)
-		{
-                        ncp_invalid_dir_cache(dir);
-		}
-		else
-		{
+						    _name)) == 0) {
+			ncp_invalid_dir_cache(dir);
+		} else {
 			error = -EACCES;
 		}
-        }
+	}
 	iput(dir);
 	return error;
 }
 
-static int
-ncp_rename(struct inode *old_dir, const char *old_name, int old_len,
-           struct inode *new_dir, const char *new_name, int new_len,
-           int must_be_dir)
+static int ncp_rename(struct inode *old_dir, const char *old_name, int old_len,
+		struct inode *new_dir, const char *new_name, int new_len,
+		      int must_be_dir)
 {
 	int res;
-	char _old_name[old_len+1];
-	char _new_name[new_len+1];
+	char _old_name[old_len + 1];
+	char _new_name[new_len + 1];
 
-	if (!old_dir || !S_ISDIR(old_dir->i_mode))
-	{
+	if (!old_dir || !S_ISDIR(old_dir->i_mode)) {
 		printk("ncp_rename: old inode is NULL or not a directory\n");
-                res = -ENOENT;
-                goto finished;
+		res = -ENOENT;
+		goto finished;
 	}
-
-	if (!ncp_conn_valid(NCP_SERVER(old_dir)))
-	{
+	if (!ncp_conn_valid(NCP_SERVER(old_dir))) {
 		res = -EIO;
 		goto finished;
 	}
-
-	if (!new_dir || !S_ISDIR(new_dir->i_mode))
-	{
+	if (!new_dir || !S_ISDIR(new_dir->i_mode)) {
 		printk("ncp_rename: new inode is NULL or not a directory\n");
-                res = -ENOENT;
-                goto finished;
+		res = -ENOENT;
+		goto finished;
+	}
+	if ((ncp_find_dir_inode(old_dir, old_name) != NULL)
+	    || (ncp_find_dir_inode(new_dir, new_name) != NULL)) {
+		res = -EBUSY;
+		goto finished;
 	}
-
-        if (   (ncp_find_dir_inode(old_dir, old_name) != NULL)
-            || (ncp_find_dir_inode(new_dir, new_name) != NULL))
-	{
-                res = -EBUSY;
-                goto finished;
-        }
-
 	strncpy(_old_name, old_name, old_len);
 	_old_name[old_len] = '\0';
 
-	if (!ncp_preserve_case(old_dir))
-	{
+	if (!ncp_preserve_case(old_dir)) {
 		str_upper(_old_name);
 	}
-
 	strncpy(_new_name, new_name, new_len);
 	_new_name[new_len] = '\0';
 
-	if (!ncp_preserve_case(new_dir))
-	{
+	if (!ncp_preserve_case(new_dir)) {
 		str_upper(_new_name);
 	}
-
 	res = ncp_ren_or_mov_file_or_subdir(NCP_SERVER(old_dir),
-					    NCP_ISTRUCT(old_dir), _old_name,
-					    NCP_ISTRUCT(new_dir), _new_name);
-
-        if (res == 0)
-	{
-                ncp_invalid_dir_cache(old_dir);
-                ncp_invalid_dir_cache(new_dir);
-        }
-	else
-	{
+					 NCP_ISTRUCT(old_dir), _old_name,
+					NCP_ISTRUCT(new_dir), _new_name);
+
+	if (res == 0) {
+		ncp_invalid_dir_cache(old_dir);
+		ncp_invalid_dir_cache(new_dir);
+	} else {
 		res = -EACCES;
 	}
-	
- finished:
-	iput(old_dir); 
+
+      finished:
+	iput(old_dir);
 	iput(new_dir);
 	return res;
 }
@@ -1220,64 +1024,62 @@ ncp_rename(struct inode *old_dir, const char *old_name, int old_len,
 
 /* Linear day numbers of the respective 1sts in non-leap years. */
 
-static int day_n[] = { 0,31,59,90,120,151,181,212,243,273,304,334,0,0,0,0 };
+static int day_n[] =
+{0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 0, 0, 0, 0};
 		  /* JanFebMarApr May Jun Jul Aug Sep Oct Nov Dec */
 
 
 extern struct timezone sys_tz;
 
-static int
-utc2local(int time)
+static int utc2local(int time)
 {
-        return time - sys_tz.tz_minuteswest*60 +
+	return time - sys_tz.tz_minuteswest * 60 +
 	    (sys_tz.tz_dsttime ? 3600 : 0);
 }
 
-static int
-local2utc(int time)
+static int local2utc(int time)
 {
-        return time + sys_tz.tz_minuteswest*60 -
+	return time + sys_tz.tz_minuteswest * 60 -
 	    (sys_tz.tz_dsttime ? 3600 : 0);
 }
 
 /* Convert a MS-DOS time/date pair to a UNIX date (seconds since 1 1 70). */
 
-int
-ncp_date_dos2unix(unsigned short time,unsigned short date)
+int ncp_date_dos2unix(unsigned short time, unsigned short date)
 {
-	int month,year,secs;
+	int month, year, secs;
 
-	month = ((date >> 5) & 15)-1;
+	month = ((date >> 5) & 15) - 1;
 	year = date >> 9;
-	secs = (time & 31)*2+60*((time >> 5) & 63)+(time >> 11)*3600+86400*
-	    ((date & 31)-1+day_n[month]+(year/4)+year*365-((year & 3) == 0 &&
-	    month < 2 ? 1 : 0)+3653);
-			/* days since 1.1.70 plus 80's leap day */
+	secs = (time & 31) * 2 + 60 * ((time >> 5) & 63) + (time >> 11) * 3600 + 86400 *
+	    ((date & 31) - 1 + day_n[month] + (year / 4) + year * 365 - ((year & 3) == 0 &&
+					      month < 2 ? 1 : 0) + 3653);
+	/* days since 1.1.70 plus 80's leap day */
 	return local2utc(secs);
 }
 
 
 /* Convert linear UNIX date to a MS-DOS time/date pair. */
-void
-ncp_date_unix2dos(int unix_date,unsigned short *time, unsigned short *date)
+void ncp_date_unix2dos(int unix_date, unsigned short *time, unsigned short *date)
 {
-	int day,year,nl_day,month;
+	int day, year, nl_day, month;
 
 	unix_date = utc2local(unix_date);
-	*time = (unix_date % 60)/2+(((unix_date/60) % 60) << 5)+
-	    (((unix_date/3600) % 24) << 11);
-	day = unix_date/86400-3652;
-	year = day/365;
-	if ((year+3)/4+365*year > day) year--;
-	day -= (year+3)/4+365*year;
+	*time = (unix_date % 60) / 2 + (((unix_date / 60) % 60) << 5) +
+	    (((unix_date / 3600) % 24) << 11);
+	day = unix_date / 86400 - 3652;
+	year = day / 365;
+	if ((year + 3) / 4 + 365 * year > day)
+		year--;
+	day -= (year + 3) / 4 + 365 * year;
 	if (day == 59 && !(year & 3)) {
 		nl_day = day;
 		month = 2;
-	}
-	else {
-		nl_day = (year & 3) || day <= 59 ? day : day-1;
+	} else {
+		nl_day = (year & 3) || day <= 59 ? day : day - 1;
 		for (month = 0; month < 12; month++)
-			if (day_n[month] > nl_day) break;
+			if (day_n[month] > nl_day)
+				break;
 	}
-	*date = nl_day-day_n[month-1]+1+(month << 5)+(year << 9);
+	*date = nl_day - day_n[month - 1] + 1 + (month << 5) + (year << 9);
 }