/* * 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> #include <linux/smp_lock.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; lock_kernel(); 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: unlock_kernel(); 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; lock_kernel(); 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)) { goto out; } 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)) { goto out; } 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)) { goto out; } while (filp->f_pos < (dir->i_size - 2)) { if (hfs_cat_next(entry, &brec, 1, &cnid, &type)) { goto out; } 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); goto out; } } ++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)) { goto out; } } 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)) { goto out; } } ++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)) { goto out; } } ++filp->f_pos; } out: unlock_kernel(); 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; lock_kernel(); 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); } unlock_kernel(); 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; int error = 0; lock_kernel(); entry = HFS_I(dir)->entry; 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; } } } unlock_kernel(); 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; int error = 0; lock_kernel(); entry = HFS_I(old_dir)->entry; 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; } } unlock_kernel(); return error; }