URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [uclinux/] [uClinux-2.0.x/] [fs/] [ncpfs/] [dir.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

/*
 *  dir.c
 *
 *  Copyright (C) 1995, 1996 by Volker Lendecke
 *
 */
 
#include <linux/config.h>
 
#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 <linux/locks.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_dir_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,
           int must_be_dir);
 
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 inline int
ncp_namespace(struct inode *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)
{
        return
#ifdef CONFIG_NCPFS_OS2_NS
        (ncp_namespace(i) == NW_NS_OS2) ||
#endif  /* CONFIG_NCPFS_OS2_NS */
#ifdef CONFIG_NCPFS_NFS_NS
        (ncp_namespace(i) == NW_NS_NFS) ||
#endif  /* CONFIG_NCPFS_NFS_NS */
        0;
}
 
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 */
        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 */
};
 
 
/* Here we encapsulate the inode number handling that depends upon the
 * mount mode: When we mount a complete server, the memory address of
 * the ncp_inode_info is used as the inode number. When only a single
 * volume is mounted, then the dirEntNum is used as the inode
 * number. As this is unique for the complete volume, this should
 * enable the NFS exportability of a ncpfs-mounted volume.
 */
 
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)
{
        return ncp_single_volume(server)
                ? (info->finfo.i.dirEntNum == server->root.finfo.i.dirEntNum)?0:info->finfo.i.dirEntNum: (ino_t)info;
}
 
static inline int
ncp_is_server_root(struct inode *inode)
{
        struct ncp_server *s = NCP_SERVER(inode);
 
        return (   (!ncp_single_volume(s))
                && (inode->i_ino == ncp_info_ino(s, &(s->root))));
}
 
struct ncp_inode_info *
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;
 
        ino_t ino = inode->i_ino;
 
        do
        {
                if (ino == ncp_info_ino(server, this))
                {
                        return this;
                }
                this = this->next;
        }
        while (this != root);
 
        return NULL;
}
 
static int
ncp_dir_read(struct inode *inode, struct file *filp, char *buf, int 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 struct wait_queue *c_wait = NULL;
 
static inline void
ncp_lock_dircache(void)
{
        while (c_lock)
                sleep_on(&c_wait);
        c_lock = 1;
}
 
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)
{
        int result = 0;
        int i = 0;
        int index = 0;
        struct ncp_dirent *entry = NULL;
        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: 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 (!ncp_conn_valid(server))
        {
                return -EIO;
        }
 
        ncp_lock_dircache();
 
        if (c_entry == NULL)
        {
                i = sizeof (struct ncp_dirent) * NCP_READDIR_CACHE_SIZE;
                c_entry = (struct ncp_dirent *) vmalloc(i);
                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)
                {
                        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)
                {
                        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 ((entry == NULL) && c_seen_eof)
                {
                        goto finished;
                }
        }
 
        if (entry == NULL)
        {
                int entries;
                DDPRINTK("ncp_readdir: Not found in cache.\n");
 
                if (ncp_is_server_root(inode))
                {
                        entries = ncp_read_volume_list(server, filp->f_pos,
                                                       NCP_READDIR_CACHE_SIZE);
                        DPRINTK("ncp_read_volume_list returned %d\n", entries);
 
                }
                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)
                {
                        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;
                        c_size = entries;
                        entry = c_entry;
                        c_last_returned_index = 0;
                        index = 0;
 
                        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 */
                goto finished;
        }
 
        while (index < c_size)
        {
                ino_t ino;
 
                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
                         * matter. (You can argue a lot about this..) */
                        struct ncp_inode_info *ino_info;
                        ino_info = ncp_find_dir_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;
                        }
                        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)
                {
                        break;
                }
 
                if (   (inode->i_dev != c_dev)
                    || (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;
        }
 finished:
        ncp_unlock_dircache();
        return result;
}
 
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 - 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)
                        {
                                return (total_count - fpos);
                        }
                        else
                        {
                                DPRINTK("ncp_read_volumes: found vol: %s\n",
                                        info.volume_name);
 
                                if (ncp_lookup_volume(server,
                                                      info.volume_name,
                                                      &(entry->i)) != 0)
                                {
                                        DPRINTK("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_dev   = 0;
        c_ino   = 0;
        c_entry = NULL;
}
 
void
ncp_invalid_dir_cache(struct inode *ino)
{
        if ((ino->i_dev == c_dev) && (ino->i_ino == c_ino))
        {
                c_dev = 0;
                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;
        }
 
        vfree(c_entry);
        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, ncp_info_ino(NCP_SERVER(dir),
                                                   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;
        i->dirEntNum = i->DosDirNum = 0;
        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->nameLen = 0;
        i->entryName[0] = '\0';
 
        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)
{
        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)
        {
                return -ENOENT;
        }
        str_lower(server->root.finfo.i.entryName);
 
        return 0;
}
 
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_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);
 
        if (name == NULL)
        {
                return NULL;
        }
 
        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;
                }
                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;
        int down_case = 0;
        char name[len+1];
 
        *result = NULL;
 
        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))
        {
                iput(dir);
                return -EIO;
        }
 
        DPRINTK("ncp_lookup: %s, len %d\n", __name, len);
 
        /* 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, ncp_info_ino(server, parent));
                iput(dir);
                if (*result == 0)
                {
                        return -EACCES;
                }
                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;
                }
 
                /* Here we convert the inode_info address into an
                   inode number */
 
                *result = iget(dir->i_sb, ncp_info_ino(server, result_info));
                unlock_super(dir->i_sb);
                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;
        ncp_lock_dircache();
 
        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, 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);
        }
        ncp_unlock_dircache();
 
        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))
                {
                        str_upper(name);
                        down_case = 1;
                        res = ncp_lookup_volume(server, name, &(finfo.i));
                }
                else
                {
                        if (!ncp_preserve_case(dir))
                        {
                                str_upper(name);
                                down_case = 1;
                        }
                        res = ncp_obtain_info(server,
                                              NCP_ISTRUCT(dir)->volNumber,
                                              NCP_ISTRUCT(dir)->dirEntNum,
                                              name, &(finfo.i));
                }
                if (res != 0)
                {
                        unlock_super(dir->i_sb);
                        iput(dir);
                        return -ENOENT;
                }
        }
 
        finfo.opened = 0;
 
        if (down_case != 0)
        {
                str_lower(finfo.i.entryName);
        }
 
        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)
{
        struct nw_file_info finfo;
        __u8 _name[len+1];
        int error;
 
        *result = NULL;
 
        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)))
        {
                iput(dir);
                return -EIO;
        }
 
        strncpy(_name, name, len);
        _name[len] = '\0';
 
        if (!ncp_preserve_case(dir))
        {
                str_upper(_name);
        }
 
        lock_super(dir->i_sb);
        if ((error = ncp_open_create_file_or_subdir(NCP_SERVER(dir),
                                           NCP_ISTRUCT(dir), _name,
                                           OC_MODE_CREATE|OC_MODE_OPEN|
                                           OC_MODE_REPLACE,
                                           0, AR_READ|AR_WRITE,
                                           &finfo)) != 0)
        {
                unlock_super(dir->i_sb);
                iput(dir);
                if (error == 0x87) {
                        return -ENAMETOOLONG;
                }
                return -EACCES;
        }
 
        ncp_invalid_dir_cache(dir);
 
        if (!ncp_preserve_case(dir))
        {
                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);
                unlock_super(dir->i_sb);
                iput(dir);
                return -EINVAL;
        }
 
        unlock_super(dir->i_sb);
        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] == '.'))))
        {
                iput(dir);
                return -EEXIST;
        }
 
        strncpy(_name, name, len);
        _name[len] = '\0';
 
        if (!ncp_preserve_case(dir))
        {
                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_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)
        {
                error = -EACCES;
        }
        else
        {
                error = 0;
                ncp_invalid_dir_cache(dir);
        }
 
        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_conn_valid(NCP_SERVER(dir)))
        {
                iput(dir);
                return -EIO;
        }
        if (ncp_find_dir_inode(dir, name) != NULL)
        {
                error = -EBUSY;
        }
        else
        {
 
                strncpy(_name, name, len);
                _name[len] = '\0';
 
                if (!ncp_preserve_case(dir))
                {
                        str_upper(_name);
                }
 
                if ((error = ncp_del_file_or_subdir(NCP_SERVER(dir),
                                                    NCP_ISTRUCT(dir),
                                                    _name)) == 0)
                {
                        ncp_invalid_dir_cache(dir);
                }
                else
                {
                        error = -EACCES;
                }
        }
        iput(dir);
        return error;
}
 
 
#ifdef CONFIG_NCPFS_STRONG
/* try to delete a readonly file (NW R bit set) */
 
static int
ncp_force_unlink(struct inode *dir,char *name,int len)
{
        int res=0x9c,res2;
        struct inode *_inode;
        struct iattr ia;
 
        /* remove the Read-Only flag on the NW server */
 
        dir->i_count++;
        res2=ncp_lookup(dir,name,len,&_inode);
        if (res2)
        {
                goto leave_me; /* abort operation */
        }
        memset(&ia,0,sizeof(struct iattr));
        ia.ia_mode = _inode->i_mode;
        ia.ia_mode |= NCP_SERVER(dir)->m.file_mode & 0222;  /* set write bits */
        ia.ia_valid = ATTR_MODE;
 
        res2=ncp_notify_change(_inode,&ia);
        if (res2)
        {
                iput(_inode);
                goto leave_me;
        }
 
        /* now try again the delete operation */
 
        res2 = ncp_del_file_or_subdir(NCP_SERVER(dir),NCP_ISTRUCT(dir),name);
 
        res=res2; /* save status to use as return value */
 
        res=res2;
        if (res2)  /* delete failed, set R bit again */
        {
                memset(&ia,0,sizeof(struct iattr));
                ia.ia_mode = _inode->i_mode;
                ia.ia_mode &= ~(NCP_SERVER(dir)->m.file_mode & 0222);  /* clear write bits */
                ia.ia_valid = ATTR_MODE;
 
                res2=ncp_notify_change(_inode,&ia);
                if (res2)
                {
                        iput(_inode);
                        goto leave_me;
                }
        }
        iput(_inode);
 
 leave_me:
        return(res);
}
#endif  /* CONFIG_NCPFS_STRONG */
 
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_conn_valid(NCP_SERVER(dir)))
        {
                iput(dir);
                return -EIO;
        }
        if (ncp_find_dir_inode(dir, name) != NULL)
        {
                error = -EBUSY;
        }
        else
        {
                strncpy(_name, name, len);
                _name[len] = '\0';
 
                if (!ncp_preserve_case(dir))
                {
                        str_upper(_name);
                }
 
                error = ncp_del_file_or_subdir(NCP_SERVER(dir),
                                               NCP_ISTRUCT(dir),
                                               _name);
#ifdef CONFIG_NCPFS_STRONG
                if (error == 0x9c && NCP_SERVER(dir)->m.flags & NCP_MOUNT_STRONG)  /* readonly */
                {
                        error = ncp_force_unlink(dir,_name,len); /* special treatment */
                }
#endif  /* CONFIG_NCPFS_STRONG */
 
                if (error == 0) {
                        ncp_invalid_dir_cache(dir);
                } else if (error == 0xFF) {
                        error = -ENOENT;
                } else {
                        error = -EACCES;
                }
        }
        iput(dir);
        return error;
}
 
#ifdef CONFIG_NCPFS_STRONG
static int
ncp_force_rename(struct inode *old_dir, const char *old_name, char *_old_name, int old_len,
                 struct inode *new_dir, const char *new_name, char *_new_name, int new_len)
{
        int res=0x90,res2;
        char _rename_old[old_len+1];
        char _rename_new[new_len+1];
        struct inode *_inode,*x_dir;
        struct iattr ia;
 
        strncpy(_rename_old,old_name,old_len);
        _rename_old[old_len] = 0;
        strncpy(_rename_new,new_name,new_len);
        _rename_new[new_len] = 0;
 
        /* remove the Read-Only flag on the NW server */
 
        old_dir->i_count++;
        res2=ncp_lookup(old_dir,_rename_old,old_len,&_inode);
        if (res2)
        {
                goto leave_me;
        }
        memset(&ia,0,sizeof(struct iattr));
        ia.ia_mode = _inode->i_mode;
        ia.ia_mode |= NCP_SERVER(old_dir)->m.file_mode & 0222;  /* set write bits */
        ia.ia_valid = ATTR_MODE;
 
        res2=ncp_notify_change(_inode,&ia);
        if (res2)
        {
                iput(_inode);
                goto leave_me;
        }
 
        /* now try again the rename operation */
        res2 = ncp_ren_or_mov_file_or_subdir(NCP_SERVER(old_dir),
                                             NCP_ISTRUCT(old_dir), _old_name,
                                             NCP_ISTRUCT(new_dir), _new_name);
 
        res=res2;
        if (!res2)  /* rename succeeded, get a new inode for the new file */
        {
                x_dir=new_dir;
                new_dir->i_count++;
                iput(_inode);
                res2=ncp_lookup(new_dir,_rename_new,new_len,&_inode);
                if (res2)
                {
                        goto leave_me;
                }
        }
        else
        {
                x_dir=old_dir;
        }
 
        memset(&ia,0,sizeof(struct iattr));
        ia.ia_mode = _inode->i_mode;
        ia.ia_mode &= ~(NCP_SERVER(x_dir)->m.file_mode & 0222);  /* clear write bits */
        ia.ia_valid = ATTR_MODE;
 
        res2=ncp_notify_change(_inode,&ia);
        iput(_inode);
        if (res2)
        {
                printk(KERN_INFO "ncpfs: ncp_notify_change (2) failed: %08x\n",res2);
                goto leave_me;
        }
 
 leave_me:
        return(res);
}
#endif  /* CONFIG_NCPFS_STRONG */
 
 
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];
 
        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 (!ncp_conn_valid(NCP_SERVER(old_dir)))
        {
                res = -EIO;
                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_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))
        {
                str_upper(_old_name);
        }
 
        strncpy(_new_name, new_name, new_len);
        _new_name[new_len] = '\0';
 
        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);
 
#ifdef CONFIG_NCPFS_STRONG
        if (res == 0x90 && NCP_SERVER(old_dir)->m.flags & NCP_MOUNT_STRONG) /* file is readonly */
        {
                res=ncp_force_rename(old_dir,old_name,_old_name,old_len,new_dir,new_name,_new_name,new_len);
        }
#endif  /* CONFIG_NCPFS_STRONG */
 
        if (res == 0)
        {
                ncp_invalid_dir_cache(old_dir);
                ncp_invalid_dir_cache(new_dir);
        }
        else
        {
                if (res == 0x9E)
                        res = -ENAMETOOLONG;
                else if (res == 0xFF)
                        res = -ENOENT;
                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 + sys_tz.tz_dsttime*3600;
}
 
static int
local2utc(int time)
{
        return time + sys_tz.tz_minuteswest*60 - sys_tz.tz_dsttime*3600;
}
 
/* 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);
}
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [uclinux/] [uClinux-2.0.x/] [fs/] [ncpfs/] [dir.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	199	simons	`/*`
2			`* dir.c`
3			`*`
4			`* Copyright (C) 1995, 1996 by Volker Lendecke`
5			`*`
6			`*/`
7
8			`#include <linux/config.h>`
9
10			`#include <linux/sched.h>`
11			`#include <linux/errno.h>`
12			`#include <linux/stat.h>`
13			`#include <linux/kernel.h>`
14			`#include <linux/malloc.h>`
15			`#include <linux/mm.h>`
16			`#include <linux/ncp_fs.h>`
17			`#include <asm/segment.h>`
18			`#include <linux/errno.h>`
19			`#include <linux/locks.h>`
20			`#include "ncplib_kernel.h"`
21
22			`struct ncp_dirent {`
23			`struct nw_info_struct i;`
24			`struct nw_search_sequence s; /* given back for i */`
25			`unsigned long f_pos;`
26			`};`
27
28			`static int`
29			`ncp_dir_read(struct inode inode, struct file filp, char *buf, int count);`
30
31			`static int`
32			`ncp_readdir(struct inode inode, struct file filp,`
33			`void *dirent, filldir_t filldir);`
34
35			`static int`
36			`ncp_read_volume_list(struct ncp_server *server, int start_with,`
37			`int cache_size);`
38
39			`static int`
40			`ncp_do_readdir(struct ncp_server server, struct inode dir, int fpos,`