URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [fs/] [hfs/] [dir_nat.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/*
 * 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;
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [fs/] [hfs/] [dir_nat.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* linux/fs/hfs/dir_nat.c`
3			`*`
4			`* Copyright (C) 1995-1997 Paul H. Hargrove`
5			`* This file may be distributed under the terms of the GNU General Public License.`
6			`*`
7			`* This file contains the inode_operations and file_operations`
8			`* structures for HFS directories.`
9			`*`
10			`* Based on the minix file system code, (C) 1991, 1992 by Linus Torvalds`
11			`*`
12			`* The source code distributions of Netatalk, versions 1.3.3b2 and`
13			`* 1.4b2, were used as a specification of the location and format of`
14			`* files used by Netatalk's afpd. No code from Netatalk appears in`
15			* hfs_fs. hfs_fs is not a work ``derived'' from Netatalk in the
16			`* sense of intellectual property law.`
17			`*`
18			`* "XXX" in a comment is a note to myself to consider changing something.`
19			`*`
20			`* In function preconditions the term "valid" applied to a pointer to`
21			`* a structure means that the pointer is non-NULL and the structure it`
22			`* points to has all fields initialized to consistent values.`
23			`*/`
24
25			`#include "hfs.h"`
26			`#include <linux/hfs_fs_sb.h>`
27			`#include <linux/hfs_fs_i.h>`
28			`#include <linux/hfs_fs.h>`
29
30			`/================ Forward declarations ================/`
31
32			`static struct dentry nat_lookup(struct inode , struct dentry *);`
33			`static int nat_readdir(struct file , void , filldir_t);`
34			`static int nat_rmdir(struct inode , struct dentry );`
35			`static int nat_hdr_unlink(struct inode , struct dentry );`
36			`static int nat_hdr_rename(struct inode , struct dentry ,`
37			`struct inode , struct dentry );`
38
39			`/================ Global variables ================/`
40
41			`#define DOT_LEN 1`
42			`#define DOT_DOT_LEN 2`
43			`#define DOT_APPLEDOUBLE_LEN 12`
44			`#define DOT_PARENT_LEN 7`
45			`#define ROOTINFO_LEN 8`
46
47			`const struct hfs_name hfs_nat_reserved1[] = {`
48			`{DOT_LEN, "."},`
49			`{DOT_DOT_LEN, ".."},`
50			`{DOT_APPLEDOUBLE_LEN, ".AppleDouble"},`
51			`{DOT_PARENT_LEN, ".Parent"},`
52			`{0, ""},`
53			`};`
54
55			`const struct hfs_name hfs_nat_reserved2[] = {`
56			`{ROOTINFO_LEN, "RootInfo"},`
57			`};`
58
59			`#define DOT (&hfs_nat_reserved1[0])`
60			`#define DOT_DOT (&hfs_nat_reserved1[1])`
61			`#define DOT_APPLEDOUBLE (&hfs_nat_reserved1[2])`
62			`#define DOT_PARENT (&hfs_nat_reserved1[3])`
63			`#define ROOTINFO (&hfs_nat_reserved2[0])`
64
65			`struct file_operations hfs_nat_dir_operations = {`
66			`read: generic_read_dir,`
67			`readdir: nat_readdir,`
68			`fsync: file_fsync,`
69			`};`
70
71			`struct inode_operations hfs_nat_ndir_inode_operations = {`
72			`create: hfs_create,`
73			`lookup: nat_lookup,`
74			`unlink: hfs_unlink,`
75			`mkdir: hfs_mkdir,`
76			`rmdir: nat_rmdir,`
77			`rename: hfs_rename,`
78			`setattr: hfs_notify_change,`
79			`};`
80
81			`struct inode_operations hfs_nat_hdir_inode_operations = {`
82			`create: hfs_create,`
83			`lookup: nat_lookup,`
84			`unlink: nat_hdr_unlink,`
85			`rename: nat_hdr_rename,`
86			`setattr: hfs_notify_change,`
87			`};`
88
89			`/================ File-local functions ================/`
90
91			`/*`
92			`* nat_lookup()`
93			`*`
94			`* This is the lookup() entry in the inode_operations structure for`
95			`* HFS directories in the Netatalk scheme. The purpose is to generate`
96			`* the inode corresponding to an entry in a directory, given the inode`
97			`* for the directory and the name (and its length) of the entry.`
98			`*/`
99			`static struct dentry nat_lookup(struct inode dir, struct dentry *dentry)`
100			`{`
101			`ino_t dtype;`
102			`struct hfs_name cname;`
103			`struct hfs_cat_entry *entry;`
104			`struct hfs_cat_key key;`
105			`struct inode *inode = NULL;`
106
107			`dentry->d_op = &hfs_dentry_operations;`
108			`entry = HFS_I(dir)->entry;`
109			`dtype = HFS_ITYPE(dir->i_ino);`
110
111			`/* Perform name-mangling */`
112			`hfs_nameout(dir, &cname, dentry->d_name.name, dentry->d_name.len);`
113
114			`/* no need to check for "." or ".." */`
115
116			`/* Check for ".AppleDouble" if in a normal directory,`
117			`and for ".Parent" in ".AppleDouble". */`
118			`if (dtype==HFS_NAT_NDIR) {`
119			`/* Check for ".AppleDouble" */`
120			`if (hfs_streq(cname.Name, cname.Len,`
121			`DOT_APPLEDOUBLE->Name, DOT_APPLEDOUBLE_LEN)) {`
122			`++entry->count; /* __hfs_iget() eats one */`
123			`inode = hfs_iget(entry, HFS_NAT_HDIR, dentry);`
124			`goto done;`
125			`}`
126			`} else if (dtype==HFS_NAT_HDIR) {`
127			`if (hfs_streq(cname.Name, cname.Len,`
128			`DOT_PARENT->Name, DOT_PARENT_LEN)) {`
129			`++entry->count; /* __hfs_iget() eats one */`
130			`inode = hfs_iget(entry, HFS_NAT_HDR, dentry);`
131			`goto done;`
132			`}`
133
134			`if ((entry->cnid == htonl(HFS_ROOT_CNID)) &&`
135			`hfs_streq(cname.Name, cname.Len,`
136			`ROOTINFO->Name, ROOTINFO_LEN)) {`
137			`++entry->count; /* __hfs_iget() eats one */`
138			`inode = hfs_iget(entry, HFS_NAT_HDR, dentry);`
139			`goto done;`
140			`}`
141			`}`
142
143			`/* Do an hfs_iget() on the mangled name. */`
144			`hfs_cat_build_key(entry->cnid, &cname, &key);`
145			`inode = hfs_iget(hfs_cat_get(entry->mdb, &key),`
146			`HFS_I(dir)->file_type, dentry);`
147
148			`/* Don't return a header file for a directory other than .Parent */`
149			`if (inode && (dtype == HFS_NAT_HDIR) &&`
150			`(HFS_I(inode)->entry != entry) &&`
151			`(HFS_I(inode)->entry->type == HFS_CDR_DIR)) {`
152			`iput(inode); /* this does an hfs_cat_put */`
153			`inode = NULL;`
154			`}`
155
156			`done:`
157			`d_add(dentry, inode);`
158			`return NULL;`
159			`}`
160
161			`/*`
162			`* nat_readdir()`
163			`*`
164			`* This is the readdir() entry in the file_operations structure for`
165			`* HFS directories in the netatalk scheme. The purpose is to`
166			`* enumerate the entries in a directory, given the inode of the`
167			`* directory and a struct file which indicates the location in the`
168			`* directory. The struct file is updated so that the next call with`
169			`* the same dir and filp will produce the next directory entry. The`
170			`* entries are returned in dirent, which is "filled-in" by calling`
171			`* filldir(). This allows the same readdir() function be used for`
172			`* different dirent formats. We try to read in as many entries as we`
173			`* can before filldir() refuses to take any more.`
174			`*`
175			`* Note that the Netatalk format doesn't have the problem with`
176			`* metadata for covered directories that exists in the other formats,`
177			`* since the metadata is contained within the directory.`
178			`*/`
179			`static int nat_readdir(struct file * filp,`
180			`void * dirent, filldir_t filldir)`
181			`{`
182			`ino_t type;`
183			`int skip_dirs;`
184			`struct hfs_brec brec;`
185			`struct hfs_cat_entry *entry;`
186			`struct inode *dir = filp->f_dentry->d_inode;`
187
188			`entry = HFS_I(dir)->entry;`
189			`type = HFS_ITYPE(dir->i_ino);`
190			`skip_dirs = (type == HFS_NAT_HDIR);`
191
192			`if (filp->f_pos == 0) {`
193			`/* Entry 0 is for "." */`
194			`if (filldir(dirent, DOT->Name, DOT_LEN, 0, dir->i_ino,`
195			`DT_DIR)) {`
196			`return 0;`
197			`}`
198			`filp->f_pos = 1;`
199			`}`
200
201			`if (filp->f_pos == 1) {`
202			`/* Entry 1 is for ".." */`
203			`hfs_u32 cnid;`
204
205			`if (type == HFS_NAT_NDIR) {`
206			`cnid = hfs_get_nl(entry->key.ParID);`
207			`} else {`
208			`cnid = entry->cnid;`
209			`}`
210
211			`if (filldir(dirent, DOT_DOT->Name,`
212			`DOT_DOT_LEN, 1, ntohl(cnid), DT_DIR)) {`
213			`return 0;`
214			`}`
215			`filp->f_pos = 2;`
216			`}`
217
218			`if (filp->f_pos < (dir->i_size - 2)) {`
219			`hfs_u32 cnid;`
220			`hfs_u8 type;`
221
222			`if (hfs_cat_open(entry, &brec) \|\|`
223			`hfs_cat_next(entry, &brec, filp->f_pos - 2, &cnid, &type)) {`
224			`return 0;`
225			`}`
226			`while (filp->f_pos < (dir->i_size - 2)) {`
227			`if (hfs_cat_next(entry, &brec, 1, &cnid, &type)) {`
228			`return 0;`
229			`}`
230			`if (!skip_dirs \|\| (type != HFS_CDR_DIR)) {`
231			`ino_t ino;`
232			`unsigned int len;`
233			`unsigned char tmp_name[HFS_NAMEMAX];`
234
235			`ino = ntohl(cnid) \| HFS_I(dir)->file_type;`
236			`len = hfs_namein(dir, tmp_name,`
237			`&((struct hfs_cat_key *)brec.key)->CName);`
238			`if (filldir(dirent, tmp_name, len,`
239			`filp->f_pos, ino, DT_UNKNOWN)) {`
240			`hfs_cat_close(entry, &brec);`
241			`return 0;`
242			`}`
243			`}`
244			`++filp->f_pos;`
245			`}`
246			`hfs_cat_close(entry, &brec);`
247			`}`
248
249			`if (filp->f_pos == (dir->i_size - 2)) {`
250			`if (type == HFS_NAT_NDIR) {`
251			`/* In normal dirs entry 2 is for ".AppleDouble" */`
252			`if (filldir(dirent, DOT_APPLEDOUBLE->Name,`
253			`DOT_APPLEDOUBLE_LEN, filp->f_pos,`
254			`ntohl(entry->cnid) \| HFS_NAT_HDIR,`
255			`DT_UNKNOWN)) {`
256			`return 0;`
257			`}`
258			`} else if (type == HFS_NAT_HDIR) {`
259			`/* In .AppleDouble entry 2 is for ".Parent" */`
260			`if (filldir(dirent, DOT_PARENT->Name,`
261			`DOT_PARENT_LEN, filp->f_pos,`
262			`ntohl(entry->cnid) \| HFS_NAT_HDR,`
263			`DT_UNKNOWN)) {`
264			`return 0;`
265			`}`
266			`}`
267			`++filp->f_pos;`
268			`}`
269
270			`if (filp->f_pos == (dir->i_size - 1)) {`
271			`/* handle ROOT/.AppleDouble/RootInfo as the last entry. */`
272			`if ((entry->cnid == htonl(HFS_ROOT_CNID)) &&`
273			`(type == HFS_NAT_HDIR)) {`
274			`if (filldir(dirent, ROOTINFO->Name,`
275			`ROOTINFO_LEN, filp->f_pos,`
276			`ntohl(entry->cnid) \| HFS_NAT_HDR,`
277			`DT_UNKNOWN)) {`
278			`return 0;`
279			`}`
280			`}`
281			`++filp->f_pos;`
282			`}`
283
284			`return 0;`
285			`}`
286
287			`/* due to the dcache caching negative dentries for non-existent files,`
288			`* we need to drop those entries when a file silently gets created.`
289			`* as far as i can tell, the calls that need to do this are the file`
290			`* related calls (create, rename, and mknod). the directory calls`
291			`* should be immune. the relevant calls in dir.c call drop_dentry`
292			`* upon successful completion. */`
293			`void hfs_nat_drop_dentry(struct dentry *dentry, const ino_t type)`
294			`{`
295			`struct dentry *de;`
296
297			`switch (type) {`
298			`case HFS_NAT_HDR: /* given .AppleDouble/name */`
299			`/* look for name */`
300			`de = hfs_lookup_dentry(dentry->d_parent->d_parent,`
301			`dentry->d_name.name, dentry->d_name.len);`
302
303			`if (de) {`
304			`if (!de->d_inode)`
305			`d_drop(de);`
306			`dput(de);`
307			`}`
308			`break;`
309			`case HFS_NAT_DATA: /* given name */`
310			`/* look for .AppleDouble/name */`
311			`hfs_drop_special(dentry->d_parent, DOT_APPLEDOUBLE, dentry);`
312			`break;`
313			`}`
314
315			`}`
316
317			`/*`
318			`* nat_rmdir()`
319			`*`
320			`* This is the rmdir() entry in the inode_operations structure for`
321			`* Netatalk directories. The purpose is to delete an existing`
322			`* directory, given the inode for the parent directory and the name`
323			`* (and its length) of the existing directory.`
324			`*`
325			`* We handle .AppleDouble and call hfs_rmdir() for all other cases.`
326			`*/`
327			`static int nat_rmdir(struct inode parent, struct dentry dentry)`
328			`{`
329			`struct hfs_cat_entry *entry = HFS_I(parent)->entry;`
330			`struct hfs_name cname;`
331			`int error;`
332
333			`hfs_nameout(parent, &cname, dentry->d_name.name, dentry->d_name.len);`
334			`if (hfs_streq(cname.Name, cname.Len,`
335			`DOT_APPLEDOUBLE->Name, DOT_APPLEDOUBLE_LEN)) {`
336			`if (!HFS_SB(parent->i_sb)->s_afpd) {`
337			`/* Not in AFPD compatibility mode */`
338			`error = -EPERM;`
339			`} else if (entry->u.dir.files \|\| entry->u.dir.dirs) {`
340			`/* AFPD compatible, but the directory is not empty */`
341			`error = -ENOTEMPTY;`
342			`} else {`
343			`/* AFPD compatible, so pretend to succeed */`
344			`error = 0;`
345			`}`
346			`} else {`
347			`error = hfs_rmdir(parent, dentry);`
348			`}`
349			`return error;`
350			`}`
351
352			`/*`
353			`* nat_hdr_unlink()`
354			`*`
355			`* This is the unlink() entry in the inode_operations structure for`
356			`* Netatalk .AppleDouble directories. The purpose is to delete an`
357			`* existing file, given the inode for the parent directory and the name`
358			`* (and its length) of the existing file.`
359			`*`
360			`* WE DON'T ACTUALLY DELETE HEADER THE FILE.`
361			`* In non-afpd-compatible mode:`
362			`* We return -EPERM.`
363			`* In afpd-compatible mode:`
364			`* We return success if the file exists or is .Parent.`
365			`* Otherwise we return -ENOENT.`
366			`*/`
367			`static int nat_hdr_unlink(struct inode dir, struct dentry dentry)`
368			`{`
369			`struct hfs_cat_entry *entry = HFS_I(dir)->entry;`
370			`int error = 0;`
371
372			`if (!HFS_SB(dir->i_sb)->s_afpd) {`
373			`/* Not in AFPD compatibility mode */`
374			`error = -EPERM;`
375			`} else {`
376			`struct hfs_name cname;`
377
378			`hfs_nameout(dir, &cname, dentry->d_name.name,`
379			`dentry->d_name.len);`
380			`if (!hfs_streq(cname.Name, cname.Len,`
381			`DOT_PARENT->Name, DOT_PARENT_LEN)) {`
382			`struct hfs_cat_entry *victim;`
383			`struct hfs_cat_key key;`
384
385			`hfs_cat_build_key(entry->cnid, &cname, &key);`
386			`victim = hfs_cat_get(entry->mdb, &key);`
387
388			`if (victim) {`
389			`/* pretend to succeed */`
390			`hfs_cat_put(victim);`
391			`} else {`
392			`error = -ENOENT;`
393			`}`
394			`}`
395			`}`
396			`return error;`
397			`}`
398
399			`/*`
400			`* nat_hdr_rename()`
401			`*`
402			`* This is the rename() entry in the inode_operations structure for`
403			`* Netatalk header directories. The purpose is to rename an existing`
404			`* file given the inode for the current directory and the name`
405			`* (and its length) of the existing file and the inode for the new`
406			`* directory and the name (and its length) of the new file/directory.`
407			`*`
408			`* WE NEVER MOVE ANYTHING.`
409			`* In non-afpd-compatible mode:`
410			`* We return -EPERM.`
411			`* In afpd-compatible mode:`
412			`* If the source header doesn't exist, we return -ENOENT.`
413			`* If the destination is not a header directory we return -EPERM.`
414			`* We return success if the destination is also a header directory`
415			`* and the header exists or is ".Parent".`
416			`*/`
417			`static int nat_hdr_rename(struct inode old_dir, struct dentry old_dentry,`
418			`struct inode new_dir, struct dentry new_dentry)`
419			`{`
420			`struct hfs_cat_entry *entry = HFS_I(old_dir)->entry;`
421			`int error = 0;`
422
423			`if (!HFS_SB(old_dir->i_sb)->s_afpd) {`
424			`/* Not in AFPD compatibility mode */`
425			`error = -EPERM;`
426			`} else {`
427			`struct hfs_name cname;`
428
429			`hfs_nameout(old_dir, &cname, old_dentry->d_name.name,`
430			`old_dentry->d_name.len);`
431			`if (!hfs_streq(cname.Name, cname.Len,`
432			`DOT_PARENT->Name, DOT_PARENT_LEN)) {`
433			`struct hfs_cat_entry *victim;`
434			`struct hfs_cat_key key;`
435
436			`hfs_cat_build_key(entry->cnid, &cname, &key);`
437			`victim = hfs_cat_get(entry->mdb, &key);`
438
439			`if (victim) {`
440			`/* pretend to succeed */`
441			`hfs_cat_put(victim);`
442			`} else {`
443			`error = -ENOENT;`
444			`}`
445			`}`
446
447			`if (!error && (HFS_ITYPE(new_dir->i_ino) != HFS_NAT_HDIR)) {`
448			`error = -EPERM;`
449			`}`
450			`}`
451			`return error;`
452			`}`