FreeBSD/Linux Kernel Cross Reference
sys/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 General 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,
                               DT_DIR)) {
                           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), DT_DIR)) {
                           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, DT_UNKNOWN)) {
                                           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,
                                       DT_UNKNOWN)) {
                                   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,
                                       DT_UNKNOWN)) {
                                   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,
                                       DT_UNKNOWN)) {
                                   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;
   }

Cache object: 62c95ae0055d3e3da69d30550ecc9921