1 /*
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 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 }
453
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.