Import 2.3.48

[davej-history.git] / fs / hfs / dir_nat.c

/*
 * linux/fs/hfs/dir_nat.c
 *
 * Copyright (C) 1995-1997  Paul H. Hargrove
 * This file may be distributed under the terms of the GNU Public License.
 *
 * This file contains the inode_operations and file_operations
 * structures for HFS directories.
 *
 * Based on the minix file system code, (C) 1991, 1992 by Linus Torvalds
 *
 * The source code distributions of Netatalk, versions 1.3.3b2 and
 * 1.4b2, were used as a specification of the location and format of
 * files used by Netatalk's afpd.  No code from Netatalk appears in
 * hfs_fs.  hfs_fs is not a work ``derived'' from Netatalk in the
 * sense of intellectual property law.
 *
 * "XXX" in a comment is a note to myself to consider changing something.
 *
 * In function preconditions the term "valid" applied to a pointer to
 * a structure means that the pointer is non-NULL and the structure it
 * points to has all fields initialized to consistent values.
 */

#include "hfs.h"
#include <linux/hfs_fs_sb.h>
#include <linux/hfs_fs_i.h>
#include <linux/hfs_fs.h>

/*================ Forward declarations ================*/

static struct dentry *nat_lookup(struct inode *, struct dentry *);
static int nat_readdir(struct file *, void *, filldir_t);
static int nat_rmdir(struct inode *, struct dentry *);
static int nat_hdr_unlink(struct inode *, struct dentry *);
static int nat_hdr_rename(struct inode *, struct dentry *,
                          struct inode *, struct dentry *);

/*================ Global variables ================*/

#define DOT_LEN                 1
#define DOT_DOT_LEN             2
#define DOT_APPLEDOUBLE_LEN     12
#define DOT_PARENT_LEN          7
#define ROOTINFO_LEN            8

const struct hfs_name hfs_nat_reserved1[] = {
        {DOT_LEN,               "."},
        {DOT_DOT_LEN,           ".."},
        {DOT_APPLEDOUBLE_LEN,   ".AppleDouble"},
        {DOT_PARENT_LEN,        ".Parent"},
        {0,                     ""},
};

const struct hfs_name hfs_nat_reserved2[] = {
        {ROOTINFO_LEN,                  "RootInfo"},
};

#define DOT             (&hfs_nat_reserved1[0])
#define DOT_DOT         (&hfs_nat_reserved1[1])
#define DOT_APPLEDOUBLE (&hfs_nat_reserved1[2])
#define DOT_PARENT      (&hfs_nat_reserved1[3])
#define ROOTINFO        (&hfs_nat_reserved2[0])

struct file_operations hfs_nat_dir_operations = {
        read:           generic_read_dir,
        readdir:        nat_readdir,
        fsync:          file_fsync,
};

struct inode_operations hfs_nat_ndir_inode_operations = {
        create:         hfs_create,
        lookup:         nat_lookup,
        unlink:         hfs_unlink,
        mkdir:          hfs_mkdir,
        rmdir:          nat_rmdir,
        rename:         hfs_rename,
        setattr:        hfs_notify_change,
};

struct inode_operations hfs_nat_hdir_inode_operations = {
        create:         hfs_create,
        lookup:         nat_lookup,
        unlink:         nat_hdr_unlink,
        rename:         nat_hdr_rename,
        setattr:        hfs_notify_change,
};

/*================ File-local functions ================*/

/*
 * nat_lookup()
 *
 * This is the lookup() entry in the inode_operations structure for
 * HFS directories in the Netatalk scheme.  The purpose is to generate
 * the inode corresponding to an entry in a directory, given the inode
 * for the directory and the name (and its length) of the entry.
 */
static struct dentry *nat_lookup(struct inode * dir, struct dentry *dentry)
{
        ino_t dtype;
        struct hfs_name cname;
        struct hfs_cat_entry *entry;
        struct hfs_cat_key key;
        struct inode *inode = NULL;

        dentry->d_op = &hfs_dentry_operations;
        entry = HFS_I(dir)->entry;
        dtype = HFS_ITYPE(dir->i_ino);

        /* Perform name-mangling */
        hfs_nameout(dir, &cname, dentry->d_name.name, dentry->d_name.len);

        /* no need to check for "."  or ".." */

        /* Check for ".AppleDouble" if in a normal directory,
           and for ".Parent" in ".AppleDouble". */
        if (dtype==HFS_NAT_NDIR) {
                /* Check for ".AppleDouble" */
                if (hfs_streq(cname.Name, cname.Len, 
                              DOT_APPLEDOUBLE->Name, DOT_APPLEDOUBLE_LEN)) {
                        ++entry->count; /* __hfs_iget() eats one */
                        inode = hfs_iget(entry, HFS_NAT_HDIR, dentry);
                        goto done;
                }
        } else if (dtype==HFS_NAT_HDIR) {
                if (hfs_streq(cname.Name, cname.Len, 
                              DOT_PARENT->Name, DOT_PARENT_LEN)) {
                        ++entry->count; /* __hfs_iget() eats one */
                        inode = hfs_iget(entry, HFS_NAT_HDR, dentry);
                        goto done;
                }

                if ((entry->cnid == htonl(HFS_ROOT_CNID)) &&
                    hfs_streq(cname.Name, cname.Len, 
                              ROOTINFO->Name, ROOTINFO_LEN)) {
                        ++entry->count; /* __hfs_iget() eats one */
                        inode = hfs_iget(entry, HFS_NAT_HDR, dentry);
                        goto done;
                }
        }

        /* Do an hfs_iget() on the mangled name. */
        hfs_cat_build_key(entry->cnid, &cname, &key);
        inode = hfs_iget(hfs_cat_get(entry->mdb, &key), 
                         HFS_I(dir)->file_type, dentry);

        /* Don't return a header file for a directory other than .Parent */
        if (inode && (dtype == HFS_NAT_HDIR) &&
            (HFS_I(inode)->entry != entry) &&
            (HFS_I(inode)->entry->type == HFS_CDR_DIR)) {
                iput(inode); /* this does an hfs_cat_put */
                inode = NULL;
        }

done:
        d_add(dentry, inode);
        return NULL;
}

/*
 * nat_readdir()
 *
 * This is the readdir() entry in the file_operations structure for
 * HFS directories in the netatalk scheme.  The purpose is to
 * enumerate the entries in a directory, given the inode of the
 * directory and a struct file which indicates the location in the
 * directory.  The struct file is updated so that the next call with
 * the same dir and filp will produce the next directory entry.  The
 * entries are returned in dirent, which is "filled-in" by calling
 * filldir().  This allows the same readdir() function be used for
 * different dirent formats.  We try to read in as many entries as we
 * can before filldir() refuses to take any more.
 *
 * Note that the Netatalk format doesn't have the problem with
 * metadata for covered directories that exists in the other formats,
 * since the metadata is contained within the directory.
 */
static int nat_readdir(struct file * filp,
                       void * dirent, filldir_t filldir)
{
        ino_t type;
        int skip_dirs;
        struct hfs_brec brec;
        struct hfs_cat_entry *entry;
        struct inode *dir = filp->f_dentry->d_inode;

        entry = HFS_I(dir)->entry;
        type = HFS_ITYPE(dir->i_ino);
        skip_dirs = (type == HFS_NAT_HDIR);

        if (filp->f_pos == 0) {
                /* Entry 0 is for "." */
                if (filldir(dirent, DOT->Name, DOT_LEN, 0, dir->i_ino)) {
                        return 0;
                }
                filp->f_pos = 1;
        }

        if (filp->f_pos == 1) {
                /* Entry 1 is for ".." */
                hfs_u32 cnid;

                if (type == HFS_NAT_NDIR) {
                        cnid = hfs_get_nl(entry->key.ParID);
                } else {
                        cnid = entry->cnid;
                }

                if (filldir(dirent, DOT_DOT->Name,
                            DOT_DOT_LEN, 1, ntohl(cnid))) {
                        return 0;
                }
                filp->f_pos = 2;
        }

        if (filp->f_pos < (dir->i_size - 2)) {
                hfs_u32 cnid;
                hfs_u8 type;

                if (hfs_cat_open(entry, &brec) ||
                    hfs_cat_next(entry, &brec, filp->f_pos - 2, &cnid, &type)) {
                        return 0;
                }
                while (filp->f_pos < (dir->i_size - 2)) {
                        if (hfs_cat_next(entry, &brec, 1, &cnid, &type)) {
                                return 0;
                        }
                        if (!skip_dirs || (type != HFS_CDR_DIR)) {
                                ino_t ino;
                                unsigned int len;
                                unsigned char tmp_name[HFS_NAMEMAX];

                                ino = ntohl(cnid) | HFS_I(dir)->file_type;
                                len = hfs_namein(dir, tmp_name,
                                    &((struct hfs_cat_key *)brec.key)->CName);
                                if (filldir(dirent, tmp_name, len,
                                            filp->f_pos, ino)) {
                                        hfs_cat_close(entry, &brec);
                                        return 0;
                                }
                        }
                        ++filp->f_pos;
                }
                hfs_cat_close(entry, &brec);
        }

        if (filp->f_pos == (dir->i_size - 2)) {
                if (type == HFS_NAT_NDIR) {
                        /* In normal dirs entry 2 is for ".AppleDouble" */
                        if (filldir(dirent, DOT_APPLEDOUBLE->Name,
                                    DOT_APPLEDOUBLE_LEN, filp->f_pos,
                                    ntohl(entry->cnid) | HFS_NAT_HDIR)) {
                                return 0;
                        }
                } else if (type == HFS_NAT_HDIR) {
                        /* In .AppleDouble entry 2 is for ".Parent" */
                        if (filldir(dirent, DOT_PARENT->Name,
                                    DOT_PARENT_LEN, filp->f_pos,
                                    ntohl(entry->cnid) | HFS_NAT_HDR)) {
                                return 0;
                        }
                }
                ++filp->f_pos;
        }

        if (filp->f_pos == (dir->i_size - 1)) {
                /* handle ROOT/.AppleDouble/RootInfo as the last entry. */
                if ((entry->cnid == htonl(HFS_ROOT_CNID)) &&
                    (type == HFS_NAT_HDIR)) {
                        if (filldir(dirent, ROOTINFO->Name,
                                    ROOTINFO_LEN, filp->f_pos,
                                    ntohl(entry->cnid) | HFS_NAT_HDR)) {
                                return 0;
                        }
                }
                ++filp->f_pos;
        }

        return 0;
}

/* due to the dcache caching negative dentries for non-existent files,
 * we need to drop those entries when a file silently gets created.
 * as far as i can tell, the calls that need to do this are the file
 * related calls (create, rename, and mknod). the directory calls
 * should be immune. the relevant calls in dir.c call drop_dentry 
 * upon successful completion. */
void hfs_nat_drop_dentry(struct dentry *dentry, const ino_t type)
{
  struct dentry *de;
  
  switch (type) {
  case HFS_NAT_HDR: /* given .AppleDouble/name */
    /* look for name */
    de = hfs_lookup_dentry(dentry->d_parent->d_parent,
                           dentry->d_name.name, dentry->d_name.len);

    if (de) {
      if (!de->d_inode)
        d_drop(de);
      dput(de);
    }
    break;
  case HFS_NAT_DATA: /* given name */
    /* look for .AppleDouble/name */
    hfs_drop_special(dentry->d_parent, DOT_APPLEDOUBLE, dentry);
    break;
  }

}

/*
 * nat_rmdir()
 *
 * This is the rmdir() entry in the inode_operations structure for
 * Netatalk directories.  The purpose is to delete an existing
 * directory, given the inode for the parent directory and the name
 * (and its length) of the existing directory.
 *
 * We handle .AppleDouble and call hfs_rmdir() for all other cases.
 */
static int nat_rmdir(struct inode *parent, struct dentry *dentry)
{
        struct hfs_cat_entry *entry = HFS_I(parent)->entry;
        struct hfs_name cname;
        int error;

        hfs_nameout(parent, &cname, dentry->d_name.name, dentry->d_name.len);
        if (hfs_streq(cname.Name, cname.Len,
                      DOT_APPLEDOUBLE->Name, DOT_APPLEDOUBLE_LEN)) {
                if (!HFS_SB(parent->i_sb)->s_afpd) {
                        /* Not in AFPD compatibility mode */
                        error = -EPERM;
                } else if (entry->u.dir.files || entry->u.dir.dirs) {
                        /* AFPD compatible, but the directory is not empty */
                        error = -ENOTEMPTY;
                } else {
                        /* AFPD compatible, so pretend to succeed */
                        error = 0;
                }
        } else {
                error = hfs_rmdir(parent, dentry);
        }
        return error;
}

/*
 * nat_hdr_unlink()
 *
 * This is the unlink() entry in the inode_operations structure for
 * Netatalk .AppleDouble directories.  The purpose is to delete an
 * existing file, given the inode for the parent directory and the name
 * (and its length) of the existing file.
 *
 * WE DON'T ACTUALLY DELETE HEADER THE FILE.
 * In non-afpd-compatible mode:
 *   We return -EPERM.
 * In afpd-compatible mode:
 *   We return success if the file exists or is .Parent.
 *   Otherwise we return -ENOENT.
 */
static int nat_hdr_unlink(struct inode *dir, struct dentry *dentry)
{
        struct hfs_cat_entry *entry = HFS_I(dir)->entry;
        int error = 0;

        if (!HFS_SB(dir->i_sb)->s_afpd) {
                /* Not in AFPD compatibility mode */
                error = -EPERM;
        } else {
                struct hfs_name cname;

                hfs_nameout(dir, &cname, dentry->d_name.name, 
                            dentry->d_name.len);
                if (!hfs_streq(cname.Name, cname.Len,
                               DOT_PARENT->Name, DOT_PARENT_LEN)) {
                        struct hfs_cat_entry *victim;
                        struct hfs_cat_key key;

                        hfs_cat_build_key(entry->cnid, &cname, &key);
                        victim = hfs_cat_get(entry->mdb, &key);

                        if (victim) {
                                /* pretend to succeed */
                                hfs_cat_put(victim);
                        } else {
                                error = -ENOENT;
                        }
                }
        }
        return error;
}

/*
 * nat_hdr_rename()
 *
 * This is the rename() entry in the inode_operations structure for
 * Netatalk header directories.  The purpose is to rename an existing
 * file given the inode for the current directory and the name 
 * (and its length) of the existing file and the inode for the new
 * directory and the name (and its length) of the new file/directory.
 *
 * WE NEVER MOVE ANYTHING.
 * In non-afpd-compatible mode:
 *   We return -EPERM.
 * In afpd-compatible mode:
 *   If the source header doesn't exist, we return -ENOENT.
 *   If the destination is not a header directory we return -EPERM.
 *   We return success if the destination is also a header directory
 *    and the header exists or is ".Parent".
 */
static int nat_hdr_rename(struct inode *old_dir, struct dentry *old_dentry,
                          struct inode *new_dir, struct dentry *new_dentry)
{
        struct hfs_cat_entry *entry = HFS_I(old_dir)->entry;
        int error = 0;

        if (!HFS_SB(old_dir->i_sb)->s_afpd) {
                /* Not in AFPD compatibility mode */
                error = -EPERM;
        } else {
                struct hfs_name cname;

                hfs_nameout(old_dir, &cname, old_dentry->d_name.name,
                            old_dentry->d_name.len);
                if (!hfs_streq(cname.Name, cname.Len, 
                               DOT_PARENT->Name, DOT_PARENT_LEN)) {
                        struct hfs_cat_entry *victim;
                        struct hfs_cat_key key;

                        hfs_cat_build_key(entry->cnid, &cname, &key);
                        victim = hfs_cat_get(entry->mdb, &key);

                        if (victim) {
                                /* pretend to succeed */
                                hfs_cat_put(victim);
                        } else {
                                error = -ENOENT;
                        }
                }

                if (!error && (HFS_ITYPE(new_dir->i_ino) != HFS_NAT_HDIR)) {
                        error = -EPERM;
                }
        }
        return error;
}