Viewing file:  dir_nat.c (12.66 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
/*
* 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;
}
|