projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'dmaengine-3.17' of git://git.kernel.org/pub/scm/linux/kernel/git/djbw...
[deliverable/linux.git] / fs / ncpfs / dir.c
1 /*
2 * dir.c
3 *
4 * Copyright (C) 1995, 1996 by Volker Lendecke
5 * Modified for big endian by J.F. Chadima and David S. Miller
6 * Modified 1997 Peter Waltenberg, Bill Hawes, David Woodhouse for 2.1 dcache
7 * Modified 1998, 1999 Wolfram Pienkoss for NLS
8 * Modified 1999 Wolfram Pienkoss for directory caching
9 * Modified 2000 Ben Harris, University of Cambridge for NFS NS meta-info
10 *
11 */
12
13
14 #include <linux/time.h>
15 #include <linux/errno.h>
16 #include <linux/stat.h>
17 #include <linux/kernel.h>
18 #include <linux/vmalloc.h>
19 #include <linux/mm.h>
20 #include <linux/namei.h>
21 #include <asm/uaccess.h>
22 #include <asm/byteorder.h>
23
24 #include "ncp_fs.h"
25
26 static void ncp_read_volume_list(struct file *, struct dir_context *,
27 struct ncp_cache_control *);
28 static void ncp_do_readdir(struct file *, struct dir_context *,
29 struct ncp_cache_control *);
30
31 static int ncp_readdir(struct file *, struct dir_context *);
32
33 static int ncp_create(struct inode *, struct dentry *, umode_t, bool);
34 static struct dentry *ncp_lookup(struct inode *, struct dentry *, unsigned int);
35 static int ncp_unlink(struct inode *, struct dentry *);
36 static int ncp_mkdir(struct inode *, struct dentry *, umode_t);
37 static int ncp_rmdir(struct inode *, struct dentry *);
38 static int ncp_rename(struct inode *, struct dentry *,
39 struct inode *, struct dentry *);
40 static int ncp_mknod(struct inode * dir, struct dentry *dentry,
41 umode_t mode, dev_t rdev);
42 #if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
43 extern int ncp_symlink(struct inode *, struct dentry *, const char *);
44 #else
45 #define ncp_symlink NULL
46 #endif
47
48 const struct file_operations ncp_dir_operations =
49 {
50 .llseek = generic_file_llseek,
51 .read = generic_read_dir,
52 .iterate = ncp_readdir,
53 .unlocked_ioctl = ncp_ioctl,
54 #ifdef CONFIG_COMPAT
55 .compat_ioctl = ncp_compat_ioctl,
56 #endif
57 };
58
59 const struct inode_operations ncp_dir_inode_operations =
60 {
61 .create = ncp_create,
62 .lookup = ncp_lookup,
63 .unlink = ncp_unlink,
64 .symlink = ncp_symlink,
65 .mkdir = ncp_mkdir,
66 .rmdir = ncp_rmdir,
67 .mknod = ncp_mknod,
68 .rename = ncp_rename,
69 .setattr = ncp_notify_change,
70 };
71
72 /*
73 * Dentry operations routines
74 */
75 static int ncp_lookup_validate(struct dentry *, unsigned int);
76 static int ncp_hash_dentry(const struct dentry *, struct qstr *);
77 static int ncp_compare_dentry(const struct dentry *, const struct dentry *,
78 unsigned int, const char *, const struct qstr *);
79 static int ncp_delete_dentry(const struct dentry *);
80
81 const struct dentry_operations ncp_dentry_operations =
82 {
83 .d_revalidate = ncp_lookup_validate,
84 .d_hash = ncp_hash_dentry,
85 .d_compare = ncp_compare_dentry,
86 .d_delete = ncp_delete_dentry,
87 };
88
89 #define ncp_namespace(i) (NCP_SERVER(i)->name_space[NCP_FINFO(i)->volNumber])
90
91 static inline int ncp_preserve_entry_case(struct inode *i, __u32 nscreator)
92 {
93 #ifdef CONFIG_NCPFS_SMALLDOS
94 int ns = ncp_namespace(i);
95
96 if ((ns == NW_NS_DOS)
97 #ifdef CONFIG_NCPFS_OS2_NS
98 || ((ns == NW_NS_OS2) && (nscreator == NW_NS_DOS))
99 #endif /* CONFIG_NCPFS_OS2_NS */
100 )
101 return 0;
102 #endif /* CONFIG_NCPFS_SMALLDOS */
103 return 1;
104 }
105
106 #define ncp_preserve_case(i) (ncp_namespace(i) != NW_NS_DOS)
107
108 static inline int ncp_case_sensitive(const struct inode *i)
109 {
110 #ifdef CONFIG_NCPFS_NFS_NS
111 return ncp_namespace(i) == NW_NS_NFS;
112 #else
113 return 0;
114 #endif /* CONFIG_NCPFS_NFS_NS */
115 }
116
117 /*
118 * Note: leave the hash unchanged if the directory
119 * is case-sensitive.
120 *
121 * Accessing the parent inode can be racy under RCU pathwalking.
122 * Use ACCESS_ONCE() to make sure we use _one_ particular inode,
123 * the callers will handle races.
124 */
125 static int
126 ncp_hash_dentry(const struct dentry *dentry, struct qstr *this)
127 {
128 struct inode *inode = ACCESS_ONCE(dentry->d_inode);
129
130 if (!inode)
131 return 0;
132
133 if (!ncp_case_sensitive(inode)) {
134 struct super_block *sb = dentry->d_sb;
135 struct nls_table *t;
136 unsigned long hash;
137 int i;
138
139 t = NCP_IO_TABLE(sb);
140 hash = init_name_hash();
141 for (i=0; i<this->len ; i++)
142 hash = partial_name_hash(ncp_tolower(t, this->name[i]),
143 hash);
144 this->hash = end_name_hash(hash);
145 }
146 return 0;
147 }
148
149 /*
150 * Accessing the parent inode can be racy under RCU pathwalking.
151 * Use ACCESS_ONCE() to make sure we use _one_ particular inode,
152 * the callers will handle races.
153 */
154 static int
155 ncp_compare_dentry(const struct dentry *parent, const struct dentry *dentry,
156 unsigned int len, const char *str, const struct qstr *name)
157 {
158 struct inode *pinode;
159
160 if (len != name->len)
161 return 1;
162
163 pinode = ACCESS_ONCE(parent->d_inode);
164 if (!pinode)
165 return 1;
166
167 if (ncp_case_sensitive(pinode))
168 return strncmp(str, name->name, len);
169
170 return ncp_strnicmp(NCP_IO_TABLE(pinode->i_sb), str, name->name, len);
171 }
172
173 /*
174 * This is the callback from dput() when d_count is going to 0.
175 * We use this to unhash dentries with bad inodes.
176 * Closing files can be safely postponed until iput() - it's done there anyway.
177 */
178 static int
179 ncp_delete_dentry(const struct dentry * dentry)
180 {
181 struct inode *inode = dentry->d_inode;
182
183 if (inode) {
184 if (is_bad_inode(inode))
185 return 1;
186 } else
187 {
188 /* N.B. Unhash negative dentries? */
189 }
190 return 0;
191 }
192
193 static inline int
194 ncp_single_volume(struct ncp_server *server)
195 {
196 return (server->m.mounted_vol[0] != '\0');
197 }
198
199 static inline int ncp_is_server_root(struct inode *inode)
200 {
201 return (!ncp_single_volume(NCP_SERVER(inode)) &&
202 inode == inode->i_sb->s_root->d_inode);
203 }
204
205
206 /*
207 * This is the callback when the dcache has a lookup hit.
208 */
209
210
211 #ifdef CONFIG_NCPFS_STRONG
212 /* try to delete a readonly file (NW R bit set) */
213
214 static int
215 ncp_force_unlink(struct inode *dir, struct dentry* dentry)
216 {
217 int res=0x9c,res2;
218 struct nw_modify_dos_info info;
219 __le32 old_nwattr;
220 struct inode *inode;
221
222 memset(&info, 0, sizeof(info));
223
224 /* remove the Read-Only flag on the NW server */
225 inode = dentry->d_inode;
226
227 old_nwattr = NCP_FINFO(inode)->nwattr;
228 info.attributes = old_nwattr & ~(aRONLY|aDELETEINHIBIT|aRENAMEINHIBIT);
229 res2 = ncp_modify_file_or_subdir_dos_info_path(NCP_SERVER(inode), inode, NULL, DM_ATTRIBUTES, &info);
230 if (res2)
231 goto leave_me;
232
233 /* now try again the delete operation */
234 res = ncp_del_file_or_subdir2(NCP_SERVER(dir), dentry);
235
236 if (res) /* delete failed, set R bit again */
237 {
238 info.attributes = old_nwattr;
239 res2 = ncp_modify_file_or_subdir_dos_info_path(NCP_SERVER(inode), inode, NULL, DM_ATTRIBUTES, &info);
240 if (res2)
241 goto leave_me;
242 }
243 leave_me:
244 return(res);
245 }
246 #endif /* CONFIG_NCPFS_STRONG */
247
248 #ifdef CONFIG_NCPFS_STRONG
249 static int
250 ncp_force_rename(struct inode *old_dir, struct dentry* old_dentry, char *_old_name,
251 struct inode *new_dir, struct dentry* new_dentry, char *_new_name)
252 {
253 struct nw_modify_dos_info info;
254 int res=0x90,res2;
255 struct inode *old_inode = old_dentry->d_inode;
256 __le32 old_nwattr = NCP_FINFO(old_inode)->nwattr;
257 __le32 new_nwattr = 0; /* shut compiler warning */
258 int old_nwattr_changed = 0;
259 int new_nwattr_changed = 0;
260
261 memset(&info, 0, sizeof(info));
262
263 /* remove the Read-Only flag on the NW server */
264
265 info.attributes = old_nwattr & ~(aRONLY|aRENAMEINHIBIT|aDELETEINHIBIT);
266 res2 = ncp_modify_file_or_subdir_dos_info_path(NCP_SERVER(old_inode), old_inode, NULL, DM_ATTRIBUTES, &info);
267 if (!res2)
268 old_nwattr_changed = 1;
269 if (new_dentry && new_dentry->d_inode) {
270 new_nwattr = NCP_FINFO(new_dentry->d_inode)->nwattr;
271 info.attributes = new_nwattr & ~(aRONLY|aRENAMEINHIBIT|aDELETEINHIBIT);
272 res2 = ncp_modify_file_or_subdir_dos_info_path(NCP_SERVER(new_dir), new_dir, _new_name, DM_ATTRIBUTES, &info);
273 if (!res2)
274 new_nwattr_changed = 1;
275 }
276 /* now try again the rename operation */
277 /* but only if something really happened */
278 if (new_nwattr_changed || old_nwattr_changed) {
279 res = ncp_ren_or_mov_file_or_subdir(NCP_SERVER(old_dir),
280 old_dir, _old_name,
281 new_dir, _new_name);
282 }
283 if (res)
284 goto leave_me;
285 /* file was successfully renamed, so:
286 do not set attributes on old file - it no longer exists
287 copy attributes from old file to new */
288 new_nwattr_changed = old_nwattr_changed;
289 new_nwattr = old_nwattr;
290 old_nwattr_changed = 0;
291
292 leave_me:;
293 if (old_nwattr_changed) {
294 info.attributes = old_nwattr;
295 res2 = ncp_modify_file_or_subdir_dos_info_path(NCP_SERVER(old_inode), old_inode, NULL, DM_ATTRIBUTES, &info);
296 /* ignore errors */
297 }
298 if (new_nwattr_changed) {
299 info.attributes = new_nwattr;
300 res2 = ncp_modify_file_or_subdir_dos_info_path(NCP_SERVER(new_dir), new_dir, _new_name, DM_ATTRIBUTES, &info);
301 /* ignore errors */
302 }
303 return(res);
304 }
305 #endif /* CONFIG_NCPFS_STRONG */
306
307
308 static int
309 ncp_lookup_validate(struct dentry *dentry, unsigned int flags)
310 {
311 struct ncp_server *server;
312 struct dentry *parent;
313 struct inode *dir;
314 struct ncp_entry_info finfo;
315 int res, val = 0, len;
316 __u8 __name[NCP_MAXPATHLEN + 1];
317
318 if (dentry == dentry->d_sb->s_root)
319 return 1;
320
321 if (flags & LOOKUP_RCU)
322 return -ECHILD;
323
324 parent = dget_parent(dentry);
325 dir = parent->d_inode;
326
327 if (!dentry->d_inode)
328 goto finished;
329
330 server = NCP_SERVER(dir);
331
332 /*
333 * Inspired by smbfs:
334 * The default validation is based on dentry age:
335 * We set the max age at mount time. (But each
336 * successful server lookup renews the timestamp.)
337 */
338 val = NCP_TEST_AGE(server, dentry);
339 if (val)
340 goto finished;
341
342 ncp_dbg(2, "%pd2 not valid, age=%ld, server lookup\n",
343 dentry, NCP_GET_AGE(dentry));
344
345 len = sizeof(__name);
346 if (ncp_is_server_root(dir)) {
347 res = ncp_io2vol(server, __name, &len, dentry->d_name.name,
348 dentry->d_name.len, 1);
349 if (!res) {
350 res = ncp_lookup_volume(server, __name, &(finfo.i));
351 if (!res)
352 ncp_update_known_namespace(server, finfo.i.volNumber, NULL);
353 }
354 } else {
355 res = ncp_io2vol(server, __name, &len, dentry->d_name.name,
356 dentry->d_name.len, !ncp_preserve_case(dir));
357 if (!res)
358 res = ncp_obtain_info(server, dir, __name, &(finfo.i));
359 }
360 finfo.volume = finfo.i.volNumber;
361 ncp_dbg(2, "looked for %pd/%s, res=%d\n",
362 dentry->d_parent, __name, res);
363 /*
364 * If we didn't find it, or if it has a different dirEntNum to
365 * what we remember, it's not valid any more.
366 */
367 if (!res) {
368 struct inode *inode = dentry->d_inode;
369
370 mutex_lock(&inode->i_mutex);
371 if (finfo.i.dirEntNum == NCP_FINFO(inode)->dirEntNum) {
372 ncp_new_dentry(dentry);
373 val=1;
374 } else
375 ncp_dbg(2, "found, but dirEntNum changed\n");
376
377 ncp_update_inode2(inode, &finfo);
378 mutex_unlock(&inode->i_mutex);
379 }
380
381 finished:
382 ncp_dbg(2, "result=%d\n", val);
383 dput(parent);
384 return val;
385 }
386
387 static struct dentry *
388 ncp_dget_fpos(struct dentry *dentry, struct dentry *parent, unsigned long fpos)
389 {
390 struct dentry *dent = dentry;
391 struct list_head *next;
392
393 if (d_validate(dent, parent)) {
394 if (dent->d_name.len <= NCP_MAXPATHLEN &&
395 (unsigned long)dent->d_fsdata == fpos) {
396 if (!dent->d_inode) {
397 dput(dent);
398 dent = NULL;
399 }
400 return dent;
401 }
402 dput(dent);
403 }
404
405 /* If a pointer is invalid, we search the dentry. */
406 spin_lock(&parent->d_lock);
407 next = parent->d_subdirs.next;
408 while (next != &parent->d_subdirs) {
409 dent = list_entry(next, struct dentry, d_u.d_child);
410 if ((unsigned long)dent->d_fsdata == fpos) {
411 if (dent->d_inode)
412 dget(dent);
413 else
414 dent = NULL;
415 spin_unlock(&parent->d_lock);
416 goto out;
417 }
418 next = next->next;
419 }
420 spin_unlock(&parent->d_lock);
421 return NULL;
422
423 out:
424 return dent;
425 }
426
427 static time_t ncp_obtain_mtime(struct dentry *dentry)
428 {
429 struct inode *inode = dentry->d_inode;
430 struct ncp_server *server = NCP_SERVER(inode);
431 struct nw_info_struct i;
432
433 if (!ncp_conn_valid(server) || ncp_is_server_root(inode))
434 return 0;
435
436 if (ncp_obtain_info(server, inode, NULL, &i))
437 return 0;
438
439 return ncp_date_dos2unix(i.modifyTime, i.modifyDate);
440 }
441
442 static int ncp_readdir(struct file *file, struct dir_context *ctx)
443 {
444 struct dentry *dentry = file->f_path.dentry;
445 struct inode *inode = dentry->d_inode;
446 struct page *page = NULL;
447 struct ncp_server *server = NCP_SERVER(inode);
448 union ncp_dir_cache *cache = NULL;
449 struct ncp_cache_control ctl;
450 int result, mtime_valid = 0;
451 time_t mtime = 0;
452
453 ctl.page = NULL;
454 ctl.cache = NULL;
455
456 ncp_dbg(2, "reading %pD2, pos=%d\n", file, (int)ctx->pos);
457
458 result = -EIO;
459 /* Do not generate '.' and '..' when server is dead. */
460 if (!ncp_conn_valid(server))
461 goto out;
462
463 result = 0;
464 if (!dir_emit_dots(file, ctx))
465 goto out;
466
467 page = grab_cache_page(&inode->i_data, 0);
468 if (!page)
469 goto read_really;
470
471 ctl.cache = cache = kmap(page);
472 ctl.head = cache->head;
473
474 if (!PageUptodate(page) || !ctl.head.eof)
475 goto init_cache;
476
477 if (ctx->pos == 2) {
478 if (jiffies - ctl.head.time >= NCP_MAX_AGE(server))
479 goto init_cache;
480
481 mtime = ncp_obtain_mtime(dentry);
482 mtime_valid = 1;
483 if ((!mtime) || (mtime != ctl.head.mtime))
484 goto init_cache;
485 }
486
487 if (ctx->pos > ctl.head.end)
488 goto finished;
489
490 ctl.fpos = ctx->pos + (NCP_DIRCACHE_START - 2);
491 ctl.ofs = ctl.fpos / NCP_DIRCACHE_SIZE;
492 ctl.idx = ctl.fpos % NCP_DIRCACHE_SIZE;
493
494 for (;;) {
495 if (ctl.ofs != 0) {
496 ctl.page = find_lock_page(&inode->i_data, ctl.ofs);
497 if (!ctl.page)
498 goto invalid_cache;
499 ctl.cache = kmap(ctl.page);
500 if (!PageUptodate(ctl.page))
501 goto invalid_cache;
502 }
503 while (ctl.idx < NCP_DIRCACHE_SIZE) {
504 struct dentry *dent;
505 bool over;
506
507 dent = ncp_dget_fpos(ctl.cache->dentry[ctl.idx],
508 dentry, ctx->pos);
509 if (!dent)
510 goto invalid_cache;
511 over = !dir_emit(ctx, dent->d_name.name,
512 dent->d_name.len,
513 dent->d_inode->i_ino, DT_UNKNOWN);
514 dput(dent);
515 if (over)
516 goto finished;
517 ctx->pos += 1;
518 ctl.idx += 1;
519 if (ctx->pos > ctl.head.end)
520 goto finished;
521 }
522 if (ctl.page) {
523 kunmap(ctl.page);
524 SetPageUptodate(ctl.page);
525 unlock_page(ctl.page);
526 page_cache_release(ctl.page);
527 ctl.page = NULL;
528 }
529 ctl.idx = 0;
530 ctl.ofs += 1;
531 }
532 invalid_cache:
533 if (ctl.page) {
534 kunmap(ctl.page);
535 unlock_page(ctl.page);
536 page_cache_release(ctl.page);
537 ctl.page = NULL;
538 }
539 ctl.cache = cache;
540 init_cache:
541 ncp_invalidate_dircache_entries(dentry);
542 if (!mtime_valid) {
543 mtime = ncp_obtain_mtime(dentry);
544 mtime_valid = 1;
545 }
546 ctl.head.mtime = mtime;
547 ctl.head.time = jiffies;
548 ctl.head.eof = 0;
549 ctl.fpos = 2;
550 ctl.ofs = 0;
551 ctl.idx = NCP_DIRCACHE_START;
552 ctl.filled = 0;
553 ctl.valid = 1;
554 read_really:
555 if (ncp_is_server_root(inode)) {
556 ncp_read_volume_list(file, ctx, &ctl);
557 } else {
558 ncp_do_readdir(file, ctx, &ctl);
559 }
560 ctl.head.end = ctl.fpos - 1;
561 ctl.head.eof = ctl.valid;
562 finished:
563 if (ctl.page) {
564 kunmap(ctl.page);
565 SetPageUptodate(ctl.page);
566 unlock_page(ctl.page);
567 page_cache_release(ctl.page);
568 }
569 if (page) {
570 cache->head = ctl.head;
571 kunmap(page);
572 SetPageUptodate(page);
573 unlock_page(page);
574 page_cache_release(page);
575 }
576 out:
577 return result;
578 }
579
580 static int
581 ncp_fill_cache(struct file *file, struct dir_context *ctx,
582 struct ncp_cache_control *ctrl, struct ncp_entry_info *entry,
583 int inval_childs)
584 {
585 struct dentry *newdent, *dentry = file->f_path.dentry;
586 struct inode *dir = dentry->d_inode;
587 struct ncp_cache_control ctl = *ctrl;
588 struct qstr qname;
589 int valid = 0;
590 int hashed = 0;
591 ino_t ino = 0;
592 __u8 __name[NCP_MAXPATHLEN + 1];
593
594 qname.len = sizeof(__name);
595 if (ncp_vol2io(NCP_SERVER(dir), __name, &qname.len,
596 entry->i.entryName, entry->i.nameLen,
597 !ncp_preserve_entry_case(dir, entry->i.NSCreator)))
598 return 1; /* I'm not sure */
599
600 qname.name = __name;
601
602 newdent = d_hash_and_lookup(dentry, &qname);
603 if (unlikely(IS_ERR(newdent)))
604 goto end_advance;
605 if (!newdent) {
606 newdent = d_alloc(dentry, &qname);
607 if (!newdent)
608 goto end_advance;
609 } else {
610 hashed = 1;
611
612 /* If case sensitivity changed for this volume, all entries below this one
613 should be thrown away. This entry itself is not affected, as its case
614 sensitivity is controlled by its own parent. */
615 if (inval_childs)
616 shrink_dcache_parent(newdent);
617
618 /*
619 * NetWare's OS2 namespace is case preserving yet case
620 * insensitive. So we update dentry's name as received from
621 * server. Parent dir's i_mutex is locked because we're in
622 * readdir.
623 */
624 dentry_update_name_case(newdent, &qname);
625 }
626
627 if (!newdent->d_inode) {
628 struct inode *inode;
629
630 entry->opened = 0;
631 entry->ino = iunique(dir->i_sb, 2);
632 inode = ncp_iget(dir->i_sb, entry);
633 if (inode) {
634 d_instantiate(newdent, inode);
635 if (!hashed)
636 d_rehash(newdent);
637 }
638 } else {
639 struct inode *inode = newdent->d_inode;
640
641 mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD);
642 ncp_update_inode2(inode, entry);
643 mutex_unlock(&inode->i_mutex);
644 }
645
646 if (newdent->d_inode) {
647 ino = newdent->d_inode->i_ino;
648 newdent->d_fsdata = (void *) ctl.fpos;
649 ncp_new_dentry(newdent);
650 }
651
652 if (ctl.idx >= NCP_DIRCACHE_SIZE) {
653 if (ctl.page) {
654 kunmap(ctl.page);
655 SetPageUptodate(ctl.page);
656 unlock_page(ctl.page);
657 page_cache_release(ctl.page);
658 }
659 ctl.cache = NULL;
660 ctl.idx -= NCP_DIRCACHE_SIZE;
661 ctl.ofs += 1;
662 ctl.page = grab_cache_page(&dir->i_data, ctl.ofs);
663 if (ctl.page)
664 ctl.cache = kmap(ctl.page);
665 }
666 if (ctl.cache) {
667 ctl.cache->dentry[ctl.idx] = newdent;
668 valid = 1;
669 }
670 dput(newdent);
671 end_advance:
672 if (!valid)
673 ctl.valid = 0;
674 if (!ctl.filled && (ctl.fpos == ctx->pos)) {
675 if (!ino)
676 ino = iunique(dir->i_sb, 2);
677 ctl.filled = !dir_emit(ctx, qname.name, qname.len,
678 ino, DT_UNKNOWN);
679 if (!ctl.filled)
680 ctx->pos += 1;
681 }
682 ctl.fpos += 1;
683 ctl.idx += 1;
684 *ctrl = ctl;
685 return (ctl.valid || !ctl.filled);
686 }
687
688 static void
689 ncp_read_volume_list(struct file *file, struct dir_context *ctx,
690 struct ncp_cache_control *ctl)
691 {
692 struct dentry *dentry = file->f_path.dentry;
693 struct inode *inode = dentry->d_inode;
694 struct ncp_server *server = NCP_SERVER(inode);
695 struct ncp_volume_info info;
696 struct ncp_entry_info entry;
697 int i;
698
699 ncp_dbg(1, "pos=%ld\n", (unsigned long)ctx->pos);
700
701 for (i = 0; i < NCP_NUMBER_OF_VOLUMES; i++) {
702 int inval_dentry;
703
704 if (ncp_get_volume_info_with_number(server, i, &info) != 0)
705 return;
706 if (!strlen(info.volume_name))
707 continue;
708
709 ncp_dbg(1, "found vol: %s\n", info.volume_name);
710
711 if (ncp_lookup_volume(server, info.volume_name,
712 &entry.i)) {
713 ncp_dbg(1, "could not lookup vol %s\n",
714 info.volume_name);
715 continue;
716 }
717 inval_dentry = ncp_update_known_namespace(server, entry.i.volNumber, NULL);
718 entry.volume = entry.i.volNumber;
719 if (!ncp_fill_cache(file, ctx, ctl, &entry, inval_dentry))
720 return;
721 }
722 }
723
724 static void
725 ncp_do_readdir(struct file *file, struct dir_context *ctx,
726 struct ncp_cache_control *ctl)
727 {
728 struct dentry *dentry = file->f_path.dentry;
729 struct inode *dir = dentry->d_inode;
730 struct ncp_server *server = NCP_SERVER(dir);
731 struct nw_search_sequence seq;
732 struct ncp_entry_info entry;
733 int err;
734 void* buf;
735 int more;
736 size_t bufsize;
737
738 ncp_dbg(1, "%pD2, fpos=%ld\n", file, (unsigned long)ctx->pos);
739 ncp_vdbg("init %pD, volnum=%d, dirent=%u\n",
740 file, NCP_FINFO(dir)->volNumber, NCP_FINFO(dir)->dirEntNum);
741
742 err = ncp_initialize_search(server, dir, &seq);
743 if (err) {
744 ncp_dbg(1, "init failed, err=%d\n", err);
745 return;
746 }
747 /* We MUST NOT use server->buffer_size handshaked with server if we are
748 using UDP, as for UDP server uses max. buffer size determined by
749 MTU, and for TCP server uses hardwired value 65KB (== 66560 bytes).
750 So we use 128KB, just to be sure, as there is no way how to know
751 this value in advance. */
752 bufsize = 131072;
753 buf = vmalloc(bufsize);
754 if (!buf)
755 return;
756 do {
757 int cnt;
758 char* rpl;
759 size_t rpls;
760
761 err = ncp_search_for_fileset(server, &seq, &more, &cnt, buf, bufsize, &rpl, &rpls);
762 if (err) /* Error */
763 break;
764 if (!cnt) /* prevent endless loop */
765 break;
766 while (cnt--) {
767 size_t onerpl;
768
769 if (rpls < offsetof(struct nw_info_struct, entryName))
770 break; /* short packet */
771 ncp_extract_file_info(rpl, &entry.i);
772 onerpl = offsetof(struct nw_info_struct, entryName) + entry.i.nameLen;
773 if (rpls < onerpl)
774 break; /* short packet */
775 (void)ncp_obtain_nfs_info(server, &entry.i);
776 rpl += onerpl;
777 rpls -= onerpl;
778 entry.volume = entry.i.volNumber;
779 if (!ncp_fill_cache(file, ctx, ctl, &entry, 0))
780 break;
781 }
782 } while (more);
783 vfree(buf);
784 return;
785 }
786
787 int ncp_conn_logged_in(struct super_block *sb)
788 {
789 struct ncp_server* server = NCP_SBP(sb);
790 int result;
791
792 if (ncp_single_volume(server)) {
793 int len;
794 struct dentry* dent;
795 __u32 volNumber;
796 __le32 dirEntNum;
797 __le32 DosDirNum;
798 __u8 __name[NCP_MAXPATHLEN + 1];
799
800 len = sizeof(__name);
801 result = ncp_io2vol(server, __name, &len, server->m.mounted_vol,
802 strlen(server->m.mounted_vol), 1);
803 if (result)
804 goto out;
805 result = -ENOENT;
806 if (ncp_get_volume_root(server, __name, &volNumber, &dirEntNum, &DosDirNum)) {
807 ncp_vdbg("%s not found\n", server->m.mounted_vol);
808 goto out;
809 }
810 dent = sb->s_root;
811 if (dent) {
812 struct inode* ino = dent->d_inode;
813 if (ino) {
814 ncp_update_known_namespace(server, volNumber, NULL);
815 NCP_FINFO(ino)->volNumber = volNumber;
816 NCP_FINFO(ino)->dirEntNum = dirEntNum;
817 NCP_FINFO(ino)->DosDirNum = DosDirNum;
818 result = 0;
819 } else {
820 ncp_dbg(1, "sb->s_root->d_inode == NULL!\n");
821 }
822 } else {
823 ncp_dbg(1, "sb->s_root == NULL!\n");
824 }
825 } else
826 result = 0;
827
828 out:
829 return result;
830 }
831
832 static struct dentry *ncp_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
833 {
834 struct ncp_server *server = NCP_SERVER(dir);
835 struct inode *inode = NULL;
836 struct ncp_entry_info finfo;
837 int error, res, len;
838 __u8 __name[NCP_MAXPATHLEN + 1];
839
840 error = -EIO;
841 if (!ncp_conn_valid(server))
842 goto finished;
843
844 ncp_vdbg("server lookup for %pd2\n", dentry);
845
846 len = sizeof(__name);
847 if (ncp_is_server_root(dir)) {
848 res = ncp_io2vol(server, __name, &len, dentry->d_name.name,
849 dentry->d_name.len, 1);
850 if (!res)
851 res = ncp_lookup_volume(server, __name, &(finfo.i));
852 if (!res)
853 ncp_update_known_namespace(server, finfo.i.volNumber, NULL);
854 } else {
855 res = ncp_io2vol(server, __name, &len, dentry->d_name.name,
856 dentry->d_name.len, !ncp_preserve_case(dir));
857 if (!res)
858 res = ncp_obtain_info(server, dir, __name, &(finfo.i));
859 }
860 ncp_vdbg("looked for %pd2, res=%d\n", dentry, res);
861 /*
862 * If we didn't find an entry, make a negative dentry.
863 */
864 if (res)
865 goto add_entry;
866
867 /*
868 * Create an inode for the entry.
869 */
870 finfo.opened = 0;
871 finfo.ino = iunique(dir->i_sb, 2);
872 finfo.volume = finfo.i.volNumber;
873 error = -EACCES;
874 inode = ncp_iget(dir->i_sb, &finfo);
875
876 if (inode) {
877 ncp_new_dentry(dentry);
878 add_entry:
879 d_add(dentry, inode);
880 error = 0;
881 }
882
883 finished:
884 ncp_vdbg("result=%d\n", error);
885 return ERR_PTR(error);
886 }
887
888 /*
889 * This code is common to create, mkdir, and mknod.
890 */
891 static int ncp_instantiate(struct inode *dir, struct dentry *dentry,
892 struct ncp_entry_info *finfo)
893 {
894 struct inode *inode;
895 int error = -EINVAL;
896
897 finfo->ino = iunique(dir->i_sb, 2);
898 inode = ncp_iget(dir->i_sb, finfo);
899 if (!inode)
900 goto out_close;
901 d_instantiate(dentry,inode);
902 error = 0;
903 out:
904 return error;
905
906 out_close:
907 ncp_vdbg("%pd2 failed, closing file\n", dentry);
908 ncp_close_file(NCP_SERVER(dir), finfo->file_handle);
909 goto out;
910 }
911
912 int ncp_create_new(struct inode *dir, struct dentry *dentry, umode_t mode,
913 dev_t rdev, __le32 attributes)
914 {
915 struct ncp_server *server = NCP_SERVER(dir);
916 struct ncp_entry_info finfo;
917 int error, result, len;
918 int opmode;
919 __u8 __name[NCP_MAXPATHLEN + 1];
920
921 ncp_vdbg("creating %pd2, mode=%hx\n", dentry, mode);
922
923 ncp_age_dentry(server, dentry);
924 len = sizeof(__name);
925 error = ncp_io2vol(server, __name, &len, dentry->d_name.name,
926 dentry->d_name.len, !ncp_preserve_case(dir));
927 if (error)
928 goto out;
929
930 error = -EACCES;
931
932 if (S_ISREG(mode) &&
933 (server->m.flags & NCP_MOUNT_EXTRAS) &&
934 (mode & S_IXUGO))
935 attributes |= aSYSTEM | aSHARED;
936
937 result = ncp_open_create_file_or_subdir(server, dir, __name,
938 OC_MODE_CREATE | OC_MODE_OPEN | OC_MODE_REPLACE,
939 attributes, AR_READ | AR_WRITE, &finfo);
940 opmode = O_RDWR;
941 if (result) {
942 result = ncp_open_create_file_or_subdir(server, dir, __name,
943 OC_MODE_CREATE | OC_MODE_OPEN | OC_MODE_REPLACE,
944 attributes, AR_WRITE, &finfo);
945 if (result) {
946 if (result == 0x87)
947 error = -ENAMETOOLONG;
948 else if (result < 0)
949 error = result;
950 ncp_dbg(1, "%pd2 failed\n", dentry);
951 goto out;
952 }
953 opmode = O_WRONLY;
954 }
955 finfo.access = opmode;
956 if (ncp_is_nfs_extras(server, finfo.volume)) {
957 finfo.i.nfs.mode = mode;
958 finfo.i.nfs.rdev = new_encode_dev(rdev);
959 if (ncp_modify_nfs_info(server, finfo.volume,
960 finfo.i.dirEntNum,
961 mode, new_encode_dev(rdev)) != 0)
962 goto out;
963 }
964
965 error = ncp_instantiate(dir, dentry, &finfo);
966 out:
967 return error;
968 }
969
970 static int ncp_create(struct inode *dir, struct dentry *dentry, umode_t mode,
971 bool excl)
972 {
973 return ncp_create_new(dir, dentry, mode, 0, 0);
974 }
975
976 static int ncp_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
977 {
978 struct ncp_entry_info finfo;
979 struct ncp_server *server = NCP_SERVER(dir);
980 int error, len;
981 __u8 __name[NCP_MAXPATHLEN + 1];
982
983 ncp_dbg(1, "making %pd2\n", dentry);
984
985 ncp_age_dentry(server, dentry);
986 len = sizeof(__name);
987 error = ncp_io2vol(server, __name, &len, dentry->d_name.name,
988 dentry->d_name.len, !ncp_preserve_case(dir));
989 if (error)
990 goto out;
991
992 error = ncp_open_create_file_or_subdir(server, dir, __name,
993 OC_MODE_CREATE, aDIR,
994 cpu_to_le16(0xffff),
995 &finfo);
996 if (error == 0) {
997 if (ncp_is_nfs_extras(server, finfo.volume)) {
998 mode |= S_IFDIR;
999 finfo.i.nfs.mode = mode;
1000 if (ncp_modify_nfs_info(server,
1001 finfo.volume,
1002 finfo.i.dirEntNum,
1003 mode, 0) != 0)
1004 goto out;
1005 }
1006 error = ncp_instantiate(dir, dentry, &finfo);
1007 } else if (error > 0) {
1008 error = -EACCES;
1009 }
1010 out:
1011 return error;
1012 }
1013
1014 static int ncp_rmdir(struct inode *dir, struct dentry *dentry)
1015 {
1016 struct ncp_server *server = NCP_SERVER(dir);
1017 int error, result, len;
1018 __u8 __name[NCP_MAXPATHLEN + 1];
1019
1020 ncp_dbg(1, "removing %pd2\n", dentry);
1021
1022 len = sizeof(__name);
1023 error = ncp_io2vol(server, __name, &len, dentry->d_name.name,
1024 dentry->d_name.len, !ncp_preserve_case(dir));
1025 if (error)
1026 goto out;
1027
1028 result = ncp_del_file_or_subdir(server, dir, __name);
1029 switch (result) {
1030 case 0x00:
1031 error = 0;
1032 break;
1033 case 0x85: /* unauthorized to delete file */
1034 case 0x8A: /* unauthorized to delete file */
1035 error = -EACCES;
1036 break;
1037 case 0x8F:
1038 case 0x90: /* read only */
1039 error = -EPERM;
1040 break;
1041 case 0x9F: /* in use by another client */
1042 error = -EBUSY;
1043 break;
1044 case 0xA0: /* directory not empty */
1045 error = -ENOTEMPTY;
1046 break;
1047 case 0xFF: /* someone deleted file */
1048 error = -ENOENT;
1049 break;
1050 default:
1051 error = result < 0 ? result : -EACCES;
1052 break;
1053 }
1054 out:
1055 return error;
1056 }
1057
1058 static int ncp_unlink(struct inode *dir, struct dentry *dentry)
1059 {
1060 struct inode *inode = dentry->d_inode;
1061 struct ncp_server *server;
1062 int error;
1063
1064 server = NCP_SERVER(dir);
1065 ncp_dbg(1, "unlinking %pd2\n", dentry);
1066
1067 /*
1068 * Check whether to close the file ...
1069 */
1070 if (inode) {
1071 ncp_vdbg("closing file\n");
1072 ncp_make_closed(inode);
1073 }
1074
1075 error = ncp_del_file_or_subdir2(server, dentry);
1076 #ifdef CONFIG_NCPFS_STRONG
1077 /* 9C is Invalid path.. It should be 8F, 90 - read only, but
1078 it is not :-( */
1079 if ((error == 0x9C || error == 0x90) && server->m.flags & NCP_MOUNT_STRONG) { /* R/O */
1080 error = ncp_force_unlink(dir, dentry);
1081 }
1082 #endif
1083 switch (error) {
1084 case 0x00:
1085 ncp_dbg(1, "removed %pd2\n", dentry);
1086 break;
1087 case 0x85:
1088 case 0x8A:
1089 error = -EACCES;
1090 break;
1091 case 0x8D: /* some files in use */
1092 case 0x8E: /* all files in use */
1093 error = -EBUSY;
1094 break;
1095 case 0x8F: /* some read only */
1096 case 0x90: /* all read only */
1097 case 0x9C: /* !!! returned when in-use or read-only by NW4 */
1098 error = -EPERM;
1099 break;
1100 case 0xFF:
1101 error = -ENOENT;
1102 break;
1103 default:
1104 error = error < 0 ? error : -EACCES;
1105 break;
1106 }
1107 return error;
1108 }
1109
1110 static int ncp_rename(struct inode *old_dir, struct dentry *old_dentry,
1111 struct inode *new_dir, struct dentry *new_dentry)
1112 {
1113 struct ncp_server *server = NCP_SERVER(old_dir);
1114 int error;
1115 int old_len, new_len;
1116 __u8 __old_name[NCP_MAXPATHLEN + 1], __new_name[NCP_MAXPATHLEN + 1];
1117
1118 ncp_dbg(1, "%pd2 to %pd2\n", old_dentry, new_dentry);
1119
1120 ncp_age_dentry(server, old_dentry);
1121 ncp_age_dentry(server, new_dentry);
1122
1123 old_len = sizeof(__old_name);
1124 error = ncp_io2vol(server, __old_name, &old_len,
1125 old_dentry->d_name.name, old_dentry->d_name.len,
1126 !ncp_preserve_case(old_dir));
1127 if (error)
1128 goto out;
1129
1130 new_len = sizeof(__new_name);
1131 error = ncp_io2vol(server, __new_name, &new_len,
1132 new_dentry->d_name.name, new_dentry->d_name.len,
1133 !ncp_preserve_case(new_dir));
1134 if (error)
1135 goto out;
1136
1137 error = ncp_ren_or_mov_file_or_subdir(server, old_dir, __old_name,
1138 new_dir, __new_name);
1139 #ifdef CONFIG_NCPFS_STRONG
1140 if ((error == 0x90 || error == 0x8B || error == -EACCES) &&
1141 server->m.flags & NCP_MOUNT_STRONG) { /* RO */
1142 error = ncp_force_rename(old_dir, old_dentry, __old_name,
1143 new_dir, new_dentry, __new_name);
1144 }
1145 #endif
1146 switch (error) {
1147 case 0x00:
1148 ncp_dbg(1, "renamed %pd -> %pd\n",
1149 old_dentry, new_dentry);
1150 break;
1151 case 0x9E:
1152 error = -ENAMETOOLONG;
1153 break;
1154 case 0xFF:
1155 error = -ENOENT;
1156 break;
1157 default:
1158 error = error < 0 ? error : -EACCES;
1159 break;
1160 }
1161 out:
1162 return error;
1163 }
1164
1165 static int ncp_mknod(struct inode * dir, struct dentry *dentry,
1166 umode_t mode, dev_t rdev)
1167 {
1168 if (!new_valid_dev(rdev))
1169 return -EINVAL;
1170 if (ncp_is_nfs_extras(NCP_SERVER(dir), NCP_FINFO(dir)->volNumber)) {
1171 ncp_dbg(1, "mode = 0%ho\n", mode);
1172 return ncp_create_new(dir, dentry, mode, rdev, 0);
1173 }
1174 return -EPERM; /* Strange, but true */
1175 }
1176
1177 /* The following routines are taken directly from msdos-fs */
1178
1179 /* Linear day numbers of the respective 1sts in non-leap years. */
1180
1181 static int day_n[] =
1182 {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 0, 0, 0, 0};
1183 /* Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec */
1184
1185
1186 extern struct timezone sys_tz;
1187
1188 static int utc2local(int time)
1189 {
1190 return time - sys_tz.tz_minuteswest * 60;
1191 }
1192
1193 static int local2utc(int time)
1194 {
1195 return time + sys_tz.tz_minuteswest * 60;
1196 }
1197
1198 /* Convert a MS-DOS time/date pair to a UNIX date (seconds since 1 1 70). */
1199 int
1200 ncp_date_dos2unix(__le16 t, __le16 d)
1201 {
1202 unsigned short time = le16_to_cpu(t), date = le16_to_cpu(d);
1203 int month, year, secs;
1204
1205 /* first subtract and mask after that... Otherwise, if
1206 date == 0, bad things happen */
1207 month = ((date >> 5) - 1) & 15;
1208 year = date >> 9;
1209 secs = (time & 31) * 2 + 60 * ((time >> 5) & 63) + (time >> 11) * 3600 +
1210 86400 * ((date & 31) - 1 + day_n[month] + (year / 4) +
1211 year * 365 - ((year & 3) == 0 && month < 2 ? 1 : 0) + 3653);
1212 /* days since 1.1.70 plus 80's leap day */
1213 return local2utc(secs);
1214 }
1215
1216
1217 /* Convert linear UNIX date to a MS-DOS time/date pair. */
1218 void
1219 ncp_date_unix2dos(int unix_date, __le16 *time, __le16 *date)
1220 {
1221 int day, year, nl_day, month;
1222
1223 unix_date = utc2local(unix_date);
1224 *time = cpu_to_le16(
1225 (unix_date % 60) / 2 + (((unix_date / 60) % 60) << 5) +
1226 (((unix_date / 3600) % 24) << 11));
1227 day = unix_date / 86400 - 3652;
1228 year = day / 365;
1229 if ((year + 3) / 4 + 365 * year > day)
1230 year--;
1231 day -= (year + 3) / 4 + 365 * year;
1232 if (day == 59 && !(year & 3)) {
1233 nl_day = day;
1234 month = 2;
1235 } else {
1236 nl_day = (year & 3) || day <= 59 ? day : day - 1;
1237 for (month = 1; month < 12; month++)
1238 if (day_n[month] > nl_day)
1239 break;
1240 }
1241 *date = cpu_to_le16(nl_day - day_n[month - 1] + 1 + (month << 5) + (year << 9));
1242 }
Linux kernel - Deliverables
This page took 0.055794 seconds and 6 git commands to generate.