patch-2.1.78 linux/fs/hfs/dir_nat.c

• Lines: 487
• Date: Sun Jan 4 10:40:17 1998
• Orig file: v2.1.77/linux/fs/hfs/dir_nat.c
• Orig date: Wed Dec 31 16:00:00 1969

diff -u --recursive --new-file v2.1.77/linux/fs/hfs/dir_nat.c linux/fs/hfs/dir_nat.c
@@ -0,0 +1,486 @@
+/*
+ * 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 int 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
+
+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[] = {
+	{0,			""},
+};
+
+#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])
+
+static struct file_operations hfs_nat_dir_operations = {
+	NULL,			/* lseek - default */
+	hfs_dir_read,		/* read - invalid */
+	NULL,			/* write - bad */
+	nat_readdir,		/* readdir */
+	NULL,			/* select - default */
+	NULL,			/* ioctl - default */
+	NULL,			/* mmap - none */
+	NULL,			/* no special open code */
+	NULL,			/* no special release code */
+	file_fsync,		/* fsync - default */
+        NULL,			/* fasync - default */
+        NULL,			/* check_media_change - none */
+        NULL,			/* revalidate - none */
+	NULL                    /* lock - none */
+};
+
+struct inode_operations hfs_nat_ndir_inode_operations = {
+	&hfs_nat_dir_operations,/* default directory file-ops */
+	hfs_create,		/* create */
+	nat_lookup,		/* lookup */
+	NULL,			/* link */
+	hfs_unlink,		/* unlink */
+	NULL,			/* symlink */
+	hfs_mkdir,		/* mkdir */
+	nat_rmdir,		/* rmdir */
+	hfs_mknod,		/* mknod */
+	hfs_rename,		/* rename */
+	NULL,			/* readlink */
+	NULL,			/* follow_link */
+	NULL,			/* readpage */
+	NULL,			/* writepage */
+	NULL,			/* bmap */
+	NULL,			/* truncate */
+	NULL,			/* permission */
+	NULL,			/* smap */
+	NULL,                   /* updatepage */
+	NULL                    /* revalidate */
+};
+
+struct inode_operations hfs_nat_hdir_inode_operations = {
+	&hfs_nat_dir_operations,/* default directory file-ops */
+	hfs_create,		/* create */
+	nat_lookup,		/* lookup */
+	NULL,			/* link */
+	nat_hdr_unlink,		/* unlink */
+	NULL,			/* symlink */
+	NULL,			/* mkdir */
+	NULL,			/* rmdir */
+	NULL,			/* mknod */
+	nat_hdr_rename,		/* rename */
+	NULL,			/* readlink */
+	NULL,			/* follow_link */
+	NULL,			/* readpage */
+	NULL,			/* writepage */
+	NULL,			/* bmap */
+	NULL,			/* truncate */
+	NULL,			/* permission */
+	NULL,			/* smap */
+	NULL,                   /* updatepage */
+	NULL                    /* revalidate */
+};
+
+/*================ 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 int 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;
+
+	if (!dir || !S_ISDIR(dir->i_mode)) {
+		goto done;
+	}
+
+	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);
+
+	/* Check for "." */
+	if (hfs_streq(&cname, DOT)) {
+		/* this little trick skips the iget and iput */
+	        d_add(dentry, dir);
+		return 0;
+	}
+
+	/* Check for "..". */
+	if (hfs_streq(&cname, DOT_DOT)) {
+		struct hfs_cat_entry *parent;
+
+		if (dtype != HFS_NAT_NDIR) {
+			/* Case for ".." in ".AppleDouble" */
+			parent = entry;
+			++entry->count; /* __hfs_iget() eats one */
+		} else {
+			/* Case for ".." in a normal directory */
+			parent = hfs_cat_parent(entry);
+		}
+		inode = hfs_iget(parent, HFS_NAT_NDIR, dentry);
+		goto done;
+	}
+
+	/* 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, DOT_APPLEDOUBLE)) {
+			++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, DOT_PARENT)) {
+			++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);
+		inode = NULL;
+	}
+
+done:
+	d_add(dentry, inode);
+	return 0;
+}
+
+/*
+ * 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;
+
+	if (!dir || !dir->i_sb || !S_ISDIR(dir->i_mode)) {
+		return -EBADF;
+	}
+
+        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 - 1)) {
+		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 - 1)) {
+			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 - 1)) {
+		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;
+	}
+
+	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(const ino_t type, struct dentry *dentry)
+{
+  struct dentry *de;
+  
+  switch (type) {
+  case HFS_NAT_HDR: /* given .AppleDouble/name */
+    /* look for name */
+    de = hfs_lookup_dentry(dentry->d_name.name,
+			   dentry->d_name.len,
+			   dentry->d_parent->d_parent);
+    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(DOT_APPLEDOUBLE, dentry->d_parent, 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, DOT_APPLEDOUBLE)) {
+		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, DOT_PARENT)) {
+			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, DOT_PARENT)) {
+			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;
+}