patch-1.3.53 linux/fs/ncpfs/dir.c
Next file: linux/fs/ncpfs/file.c
Previous file: linux/fs/ncpfs/Makefile
Back to the patch index
Back to the overall index
- Lines: 1044
- Date:
Tue Jan 2 14:18:43 1996
- Orig file:
v1.3.52/linux/fs/ncpfs/dir.c
- Orig date:
Thu Jan 1 02:00:00 1970
diff -u --recursive --new-file v1.3.52/linux/fs/ncpfs/dir.c linux/fs/ncpfs/dir.c
@@ -0,0 +1,1043 @@
+/*
+ * dir.c
+ *
+ * Copyright (C) 1995 by Volker Lendecke
+ *
+ */
+
+#include <linux/sched.h>
+#include <linux/errno.h>
+#include <linux/stat.h>
+#include <linux/kernel.h>
+#include <linux/malloc.h>
+#include <linux/mm.h>
+#include <linux/ncp_fs.h>
+#include <asm/segment.h>
+#include <linux/errno.h>
+#include "ncplib_kernel.h"
+
+struct ncp_dirent {
+ struct nw_info_struct i;
+ struct nw_search_sequence s; /* given back for i */
+ unsigned long f_pos;
+};
+
+static int
+ncp_dir_read(struct inode *inode, struct file *filp, char *buf, int count);
+
+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);
+
+static int
+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);
+
+static struct ncp_inode_info *
+ncp_find_inode(struct inode *dir, const char *name);
+
+static int
+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_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_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);
+
+static inline void
+str_upper(char *name)
+{
+ while (*name)
+ {
+ if (*name >= 'a' && *name <= 'z')
+ {
+ *name -= ('a' - 'A');
+ }
+ name++;
+ }
+}
+
+static inline void
+str_lower(char *name)
+{
+ while (*name)
+ {
+ if (*name >= 'A' && *name <= 'Z')
+ {
+ *name += ('a' - 'A');
+ }
+ name ++;
+ }
+}
+
+static struct file_operations ncp_dir_operations = {
+ NULL, /* lseek - default */
+ ncp_dir_read, /* read - bad */
+ NULL, /* write - bad */
+ ncp_readdir, /* readdir */
+ NULL, /* select - default */
+ ncp_ioctl, /* ioctl - default */
+ NULL, /* mmap */
+ NULL, /* no special open code */
+ NULL, /* no special release code */
+ NULL /* fsync */
+};
+
+struct inode_operations ncp_dir_inode_operations = {
+ &ncp_dir_operations, /* default directory file ops */
+ ncp_create, /* create */
+ ncp_lookup, /* lookup */
+ NULL, /* link */
+ ncp_unlink, /* unlink */
+ NULL, /* symlink */
+ ncp_mkdir, /* mkdir */
+ ncp_rmdir, /* rmdir */
+ NULL, /* mknod */
+ ncp_rename, /* rename */
+ NULL, /* readlink */
+ NULL, /* follow_link */
+ NULL, /* bmap */
+ NULL, /* truncate */
+ NULL, /* permission */
+ NULL /* smap */
+};
+
+
+static int
+ncp_dir_read(struct inode *inode, struct file *filp, char *buf, int count)
+{
+ return -EISDIR;
+}
+
+/* In ncpfs, we have unique inodes across all mounted filesystems, for
+ all inodes that are in memory. That's why it's enough to index the
+ directory cache by the inode number. */
+
+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
+ncp_readdir(struct inode *inode, struct file *filp,
+ void *dirent, filldir_t filldir)
+{
+ int result, i = 0;
+ int index = 0;
+ struct ncp_dirent *entry = NULL;
+ struct ncp_server *server = NCP_SERVER(inode);
+ struct ncp_inode_info *dir = (struct ncp_inode_info *)(inode->i_ino);
+
+ 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))
+ {
+ printk("ncp_readdir: inode is NULL or not a directory\n");
+ return -EBADF;
+ }
+
+ if (c_entry == NULL)
+ {
+ i = sizeof (struct ncp_dirent) * NCP_READDIR_CACHE_SIZE;
+ c_entry = (struct ncp_dirent *) ncp_kmalloc(i, GFP_KERNEL);
+ if (c_entry == NULL)
+ {
+ printk("ncp_readdir: no MEMORY for cache\n");
+ return -ENOMEM;
+ }
+ }
+
+ if (filp->f_pos == 0)
+ {
+ ncp_invalid_dir_cache(inode->i_ino);
+ if (filldir(dirent,".",1, filp->f_pos, (int)dir) < 0)
+ {
+ return 0;
+ }
+ filp->f_pos += 1;
+ }
+
+ if (filp->f_pos == 1)
+ {
+ if (filldir(dirent,"..",2, filp->f_pos, (int)(dir->dir)) < 0)
+ {
+ return 0;
+ }
+ filp->f_pos += 1;
+ }
+
+ if (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)
+ {
+ return 0;
+ }
+ }
+
+ if (entry == NULL)
+ {
+ DDPRINTK("ncp_readdir: Not found in cache.\n");
+
+ if (inode->i_ino == (int)&(server->root))
+ {
+ result = ncp_read_volume_list(server, filp->f_pos,
+ NCP_READDIR_CACHE_SIZE);
+ DPRINTK("ncp_read_volume_list returned %d\n", result);
+
+ }
+ else
+ {
+ result = ncp_do_readdir(server, inode, filp->f_pos,
+ NCP_READDIR_CACHE_SIZE,
+ c_entry);
+ DPRINTK("ncp_readdir returned %d\n", result);
+ }
+
+ if (result < 0)
+ {
+ c_ino = 0;
+ return result;
+ }
+
+ if (result > 0)
+ {
+ c_seen_eof = (result < NCP_READDIR_CACHE_SIZE);
+ c_ino = inode->i_ino;
+ c_size = result;
+ entry = c_entry;
+ c_last_returned_index = 0;
+ index = 0;
+
+ for (i = 0; i < c_size; i++)
+ {
+ str_lower(c_entry[i].i.entryName);
+ }
+ }
+ }
+
+ if (entry == NULL)
+ {
+ /* Nothing found, even from a ncp call */
+ return 0;
+ }
+
+ while (index < c_size)
+ {
+ /* We found it. 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
+ matter. (You can argue a lot about this..) */
+
+ struct ncp_inode_info *ino_info;
+ ino_info = ncp_find_inode(inode, entry->i.entryName);
+
+ /* 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)
+ {
+ ino_info = (struct ncp_inode_info *) 1;
+ }
+
+ 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_t)ino_info) < 0)
+ {
+ break;
+ }
+
+ if ( (inode->i_ino != c_ino)
+ || (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;
+ }
+ return 0;
+}
+
+static int
+ncp_read_volume_list(struct ncp_server *server, int fpos, int cache_size)
+{
+ struct ncp_dirent *entry = c_entry;
+
+ int total_count = 2;
+ int i;
+
+#if 1
+ if (fpos < 2)
+ {
+ printk("OOPS, we expect fpos >= 2");
+ fpos = 2;
+ }
+#endif
+
+ 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)
+ {
+ return total_count;
+ }
+
+ 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)
+ {
+ return (total_count - fpos);
+ }
+ else
+ {
+ DPRINTK("ncp_read_volumes: found vol: %s\n",
+ info.volume_name);
+
+ if (ncp_do_lookup(server, NULL,
+ info.volume_name,
+ &(entry->i)) != 0)
+ {
+ printk("ncpfs: could not lookup vol "
+ "%s\n", info.volume_name);
+ continue;
+ }
+
+ entry->f_pos = total_count;
+ entry += 1;
+ }
+ total_count += 1;
+ }
+ }
+ 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 struct nw_search_sequence seq;
+ static struct inode *last_dir;
+ static int total_count;
+
+#if 1
+ if (fpos < 2)
+ {
+ printk("OOPS, we expect fpos >= 2");
+ fpos = 2;
+ }
+#endif
+ DPRINTK("ncp_do_readdir: fpos = %d\n", fpos);
+
+ if (fpos == 2)
+ {
+ last_dir = NULL;
+ total_count = 2;
+ }
+
+ 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)
+ {
+ DPRINTK("ncp_init_search failed\n");
+ return total_count - fpos;
+ }
+ }
+
+ while (total_count < fpos + cache_size)
+ {
+ if (ncp_search_for_file_or_subdir(server, &seq,
+ &(entry->i)) != 0)
+ {
+ return total_count - fpos;
+ }
+
+ if (total_count < fpos)
+ {
+ DPRINTK("ncp_do_readdir: skipped file: %s\n",
+ entry->i.entryName);
+ }
+ else
+ {
+ DDPRINTK("ncp_do_r: file: %s, f_pos=%d,total_count=%d",
+ entry->i.entryName, fpos, total_count);
+ entry->s = seq;
+ entry->f_pos = total_count;
+ entry += 1;
+ }
+ total_count += 1;
+ }
+ return (total_count - fpos);
+}
+
+void
+ncp_init_dir_cache(void)
+{
+ c_ino = 0;
+ c_entry = NULL;
+}
+
+void
+ncp_invalid_dir_cache(unsigned long ino)
+{
+ if (ino == c_ino)
+ {
+ c_ino = 0;
+ c_seen_eof = 0;
+ }
+}
+
+void
+ncp_free_dir_cache(void)
+{
+ DPRINTK("ncp_free_dir_cache: enter\n");
+
+ if (c_entry == NULL)
+ {
+ return;
+ }
+
+ ncp_kfree_s(c_entry,
+ sizeof(struct ncp_dirent) * NCP_READDIR_CACHE_SIZE);
+ c_entry = NULL;
+
+ DPRINTK("ncp_free_dir_cache: exit\n");
+}
+
+
+static struct inode *
+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;
+
+ if (dir == NULL)
+ {
+ printk("ncp_iget: dir is NULL\n");
+ return 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);
+
+ if (new_inode_info == NULL)
+ {
+ printk("ncp_iget: could not alloc mem for %s\n",
+ finfo->i.entryName);
+ 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;
+
+ 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. */
+
+ 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;
+
+ if (!(inode = iget(dir->i_sb, (int)new_inode_info)))
+ {
+ printk("ncp_iget: iget failed!");
+ return NULL;
+ }
+
+ return inode;
+}
+
+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;
+
+ 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));
+
+ if (dir == i) return;
+
+ (dir->nused)--;
+ i = dir;
+ }
+}
+
+void
+ncp_init_root(struct ncp_server *server)
+{
+ 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);
+
+ root->finfo.opened = 0;
+ i->attributes = aDIR;
+ i->dataStreamSize = 1024;
+ ncp_date_unix2dos(0, &(i->creationTime), &(i->creationDate));
+ ncp_date_unix2dos(0, &(i->modifyTime), &(i->modifyDate));
+ ncp_date_unix2dos(0, &dummy, &(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;
+}
+
+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 */
+#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;
+}
+
+/* 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_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);
+
+ if (name == NULL)
+ {
+ return NULL;
+ }
+
+ do
+ {
+ if ( (result->dir->finfo.i.DosDirNum == dir_info->DosDirNum)
+ && (strcmp(result->finfo.i.entryName, name) == 0))
+ {
+ return result;
+ }
+ result = result->next;
+
+ }
+ while (result != &(server->root));
+
+ return NULL;
+}
+
+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;
+
+ *result = NULL;
+
+ if (!dir || !S_ISDIR(dir->i_mode))
+ {
+ printk("ncp_lookup: inode is NULL or not a directory.\n");
+ iput(dir);
+ return -ENOENT;
+ }
+
+ DDPRINTK("ncp_lookup: %s, len %d\n", __name, len);
+
+ server = NCP_SERVER(dir);
+
+ /* Fast cheat for . */
+ if (len == 0 || (len == 1 && __name[0] == '.'))
+ {
+ *result = dir;
+ return 0;
+ }
+
+ /* ..and for .. */
+ if (len == 2 && __name[0] == '.' && __name[1] == '.')
+ {
+ struct ncp_inode_info *parent = NCP_INOP(dir)->dir;
+
+ if (parent->state == NCP_INODE_CACHED)
+ {
+ parent->state = NCP_INODE_LOOKED_UP;
+ }
+
+ *result = iget(dir->i_sb, (int)parent);
+ iput(dir);
+ if (*result == 0)
+ {
+ return -EACCES;
+ }
+ else
+ {
+ return 0;
+ }
+ }
+
+ result_info = ncp_find_inode(dir, __name);
+
+ 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 */
+
+ *result = iget(dir->i_sb, (int)result_info);
+ 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. */
+
+ found_in_cache = 0;
+
+ if (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, c_entry[i].i.entryName);
+
+ 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;
+ }
+ while (i != first);
+ }
+
+ if (found_in_cache == 0)
+ {
+ char this_name[len+1];
+
+ memcpy(this_name, __name, len);
+ this_name[len] = 0;
+ str_upper(this_name);
+
+ DDPRINTK("ncp_lookup: do_lookup on %s/%s\n",
+ NCP_ISTRUCT(dir)->entryName, this_name);
+
+ if (ncp_do_lookup(server,
+ dir->i_ino == (int)&(NCP_SERVER(dir)->root)
+ ? NULL : NCP_ISTRUCT(dir),
+ this_name,
+ &(finfo.i)) != 0)
+ {
+ iput(dir);
+ return -ENOENT;
+ }
+ }
+
+ finfo.opened = 0;
+ str_lower(finfo.i.entryName);
+
+ if (!(*result = ncp_iget(dir, &finfo)))
+ {
+ iput(dir);
+ return -EACCES;
+ }
+
+ iput(dir);
+ return 0;
+}
+
+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];
+
+ *result = NULL;
+
+ if (!dir || !S_ISDIR(dir->i_mode))
+ {
+ printk("ncp_create: inode is NULL or not a directory\n");
+ iput(dir);
+ return -ENOENT;
+ }
+
+ strncpy(_name, name, len);
+ _name[len] = '\0';
+ str_upper(_name);
+
+ if (ncp_open_create_file_or_subdir(NCP_SERVER(dir),
+ NCP_ISTRUCT(dir), _name,
+ OC_MODE_CREATE|OC_MODE_OPEN,
+ 0, AR_READ|AR_WRITE,
+ &finfo) != 0)
+ {
+ iput(dir);
+ return -EACCES;
+ }
+
+ ncp_invalid_dir_cache(dir->i_ino);
+
+ str_lower(finfo.i.entryName);
+ finfo.access = O_RDWR;
+
+ if (!(*result = ncp_iget(dir, &finfo)) < 0)
+ {
+ ncp_close_file(NCP_SERVER(dir), finfo.file_handle);
+ iput(dir);
+ return -EINVAL;
+ }
+
+ iput(dir);
+ return 0;
+}
+
+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];
+
+ if ( (name[0] == '.')
+ && ( (len == 1)
+ || ( (len == 2)
+ && (name[1] == '.'))))
+ {
+ return -EEXIST;
+ }
+
+ strncpy(_name, name, len);
+ _name[len] = '\0';
+ str_upper(_name);
+
+ if (!dir || !S_ISDIR(dir->i_mode))
+ {
+ printk("ncp_mkdir: inode is NULL or not a directory\n");
+ iput(dir);
+ return -ENOENT;
+ }
+
+ if (ncp_open_create_file_or_subdir(NCP_SERVER(dir),
+ NCP_ISTRUCT(dir), _name,
+ OC_MODE_CREATE, aDIR, 0xffff,
+ &new_dir) != 0)
+ {
+ error = -EACCES;
+ }
+ else
+ {
+ error = 0;
+ ncp_invalid_dir_cache(dir->i_ino);
+ }
+
+ iput(dir);
+ return error;
+}
+
+static int
+ncp_rmdir(struct inode *dir, const char *name, int len)
+{
+ int error;
+ __u8 _name[len+1];
+
+ if (!dir || !S_ISDIR(dir->i_mode))
+ {
+ printk("ncp_rmdir: inode is NULL or not a directory\n");
+ iput(dir);
+ return -ENOENT;
+ }
+ if (ncp_find_inode(dir, name) != NULL)
+ {
+ error = -EBUSY;
+ }
+ else
+ {
+
+ strncpy(_name, name, len);
+ _name[len] = '\0';
+ str_upper(_name);
+
+ if ((error = ncp_del_file_or_subdir(NCP_SERVER(dir),
+ NCP_ISTRUCT(dir),
+ _name)) == 0)
+ {
+ ncp_invalid_dir_cache(dir->i_ino);
+ }
+ else
+ {
+ error = -EINVAL;
+ }
+ }
+ iput(dir);
+ return error;
+}
+
+static int
+ncp_unlink(struct inode *dir, const char *name, int len)
+{
+ int error;
+ __u8 _name[len+1];
+
+ if (!dir || !S_ISDIR(dir->i_mode))
+ {
+ printk("ncp_unlink: inode is NULL or not a directory\n");
+ iput(dir);
+ return -ENOENT;
+ }
+ if (ncp_find_inode(dir, name) != NULL)
+ {
+ error = -EBUSY;
+ }
+ else
+ {
+ strncpy(_name, name, len);
+ _name[len] = '\0';
+ str_upper(_name);
+
+ if ((error = ncp_del_file_or_subdir(NCP_SERVER(dir),
+ NCP_ISTRUCT(dir),
+ _name)) == 0)
+ {
+ ncp_invalid_dir_cache(dir->i_ino);
+ }
+ else
+ {
+ error = -EINVAL;
+ }
+ }
+ 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 res;
+ char _old_name[old_len+1];
+ char _new_name[new_len+1];
+
+ 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;
+ }
+
+ 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;
+ }
+
+ if ( (ncp_find_inode(old_dir, old_name) != NULL)
+ || (ncp_find_inode(new_dir, new_name) != NULL))
+ {
+ res = -EBUSY;
+ goto finished;
+ }
+
+ strncpy(_old_name, old_name, old_len);
+ _old_name[old_len] = '\0';
+ str_upper(_old_name);
+
+ strncpy(_new_name, new_name, new_len);
+ _new_name[new_len] = '\0';
+ 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->i_ino);
+ ncp_invalid_dir_cache(new_dir->i_ino);
+ }
+ else
+ {
+ res = -EACCES;
+ }
+
+ finished:
+ iput(old_dir);
+ iput(new_dir);
+ return res;
+}
+
+/* The following routines are taken directly from msdos-fs */
+
+/* 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 };
+ /* JanFebMarApr May Jun Jul Aug Sep Oct Nov Dec */
+
+
+extern struct timezone sys_tz;
+
+static int
+utc2local(int time)
+{
+ return time - sys_tz.tz_minuteswest*60;
+}
+
+static int
+local2utc(int time)
+{
+ return time + sys_tz.tz_minuteswest*60;
+}
+
+/* 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 month,year,secs;
+
+ 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 */
+ 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)
+{
+ 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;
+ if (day == 59 && !(year & 3)) {
+ nl_day = day;
+ month = 2;
+ }
+ else {
+ nl_day = (year & 3) || day <= 59 ? day : day-1;
+ for (month = 0; month < 12; month++)
+ if (day_n[month] > nl_day) break;
+ }
+ *date = nl_day-day_n[month-1]+1+(month << 5)+(year << 9);
+}
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen, slshen@lbl.gov
with Sam's (original) version of this