projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'v3.19-rockchip-dtsfixes1' of git://git.kernel.org/pub/scm/linux/kernel...
[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 is_root_inode(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
392 if (d_validate(dent, parent)) {
393 if (dent->d_name.len <= NCP_MAXPATHLEN &&
394 (unsigned long)dent->d_fsdata == fpos) {
395 if (!dent->d_inode) {
396 dput(dent);
397 dent = NULL;
398 }
399 return dent;
400 }
401 dput(dent);
402 }
403
404 /* If a pointer is invalid, we search the dentry. */
405 spin_lock(&parent->d_lock);
406 list_for_each_entry(dent, &parent->d_subdirs, d_child) {
407 if ((unsigned long)dent->d_fsdata == fpos) {
408 if (dent->d_inode)
409 dget(dent);
410 else
411 dent = NULL;
412 spin_unlock(&parent->d_lock);
413 goto out;
414 }
415 }
416 spin_unlock(&parent->d_lock);
417 return NULL;
418
419 out:
420 return dent;
421 }
422
423 static time_t ncp_obtain_mtime(struct dentry *dentry)
424 {
425 struct inode *inode = dentry->d_inode;
426 struct ncp_server *server = NCP_SERVER(inode);
427 struct nw_info_struct i;
428
429 if (!ncp_conn_valid(server) || ncp_is_server_root(inode))
430 return 0;
431
432 if (ncp_obtain_info(server, inode, NULL, &i))
433 return 0;
434
435 return ncp_date_dos2unix(i.modifyTime, i.modifyDate);
436 }
437
438 static int ncp_readdir(struct file *file, struct dir_context *ctx)
439 {
440 struct dentry *dentry = file->f_path.dentry;
441 struct inode *inode = dentry->d_inode;
442 struct page *page = NULL;
443 struct ncp_server *server = NCP_SERVER(inode);
444 union ncp_dir_cache *cache = NULL;
445 struct ncp_cache_control ctl;
446 int result, mtime_valid = 0;
447 time_t mtime = 0;
448
449 ctl.page = NULL;
450 ctl.cache = NULL;
451
452 ncp_dbg(2, "reading %pD2, pos=%d\n", file, (int)ctx->pos);
453
454 result = -EIO;
455 /* Do not generate '.' and '..' when server is dead. */
456 if (!ncp_conn_valid(server))
457 goto out;
458
459 result = 0;
460 if (!dir_emit_dots(file, ctx))
461 goto out;
462
463 page = grab_cache_page(&inode->i_data, 0);
464 if (!page)
465 goto read_really;
466
467 ctl.cache = cache = kmap(page);
468 ctl.head = cache->head;
469
470 if (!PageUptodate(page) || !ctl.head.eof)
471 goto init_cache;
472
473 if (ctx->pos == 2) {
474 if (jiffies - ctl.head.time >= NCP_MAX_AGE(server))
475 goto init_cache;
476
477 mtime = ncp_obtain_mtime(dentry);
478 mtime_valid = 1;
479 if ((!mtime) || (mtime != ctl.head.mtime))
480 goto init_cache;
481 }
482
483 if (ctx->pos > ctl.head.end)
484 goto finished;
485
486 ctl.fpos = ctx->pos + (NCP_DIRCACHE_START - 2);
487 ctl.ofs = ctl.fpos / NCP_DIRCACHE_SIZE;
488 ctl.idx = ctl.fpos % NCP_DIRCACHE_SIZE;
489
490 for (;;) {
491 if (ctl.ofs != 0) {
492 ctl.page = find_lock_page(&inode->i_data, ctl.ofs);
493 if (!ctl.page)
494 goto invalid_cache;
495 ctl.cache = kmap(ctl.page);
496 if (!PageUptodate(ctl.page))
497 goto invalid_cache;
498 }
499 while (ctl.idx < NCP_DIRCACHE_SIZE) {
500 struct dentry *dent;
501 bool over;
502
503 dent = ncp_dget_fpos(ctl.cache->dentry[ctl.idx],
504 dentry, ctx->pos);
505 if (!dent)
506 goto invalid_cache;
507 over = !dir_emit(ctx, dent->d_name.name,
508 dent->d_name.len,
509 dent->d_inode->i_ino, DT_UNKNOWN);
510 dput(dent);
511 if (over)
512 goto finished;
513 ctx->pos += 1;
514 ctl.idx += 1;
515 if (ctx->pos > ctl.head.end)
516 goto finished;
517 }
518 if (ctl.page) {
519 kunmap(ctl.page);
520 SetPageUptodate(ctl.page);
521 unlock_page(ctl.page);
522 page_cache_release(ctl.page);
523 ctl.page = NULL;
524 }
525 ctl.idx = 0;
526 ctl.ofs += 1;
527 }
528 invalid_cache:
529 if (ctl.page) {
530 kunmap(ctl.page);
531 unlock_page(ctl.page);
532 page_cache_release(ctl.page);
533 ctl.page = NULL;
534 }
535 ctl.cache = cache;
536 init_cache:
537 ncp_invalidate_dircache_entries(dentry);
538 if (!mtime_valid) {
539 mtime = ncp_obtain_mtime(dentry);
540 mtime_valid = 1;
541 }
542 ctl.head.mtime = mtime;
543 ctl.head.time = jiffies;
544 ctl.head.eof = 0;
545 ctl.fpos = 2;
546 ctl.ofs = 0;
547 ctl.idx = NCP_DIRCACHE_START;
548 ctl.filled = 0;
549 ctl.valid = 1;
550 read_really:
551 if (ncp_is_server_root(inode)) {
552 ncp_read_volume_list(file, ctx, &ctl);
553 } else {
554 ncp_do_readdir(file, ctx, &ctl);
555 }
556 ctl.head.end = ctl.fpos - 1;
557 ctl.head.eof = ctl.valid;
558 finished:
559 if (ctl.page) {
560 kunmap(ctl.page);
561 SetPageUptodate(ctl.page);
562 unlock_page(ctl.page);
563 page_cache_release(ctl.page);
564 }
565 if (page) {
566 cache->head = ctl.head;
567 kunmap(page);
568 SetPageUptodate(page);
569 unlock_page(page);
570 page_cache_release(page);
571 }
572 out:
573 return result;
574 }
575
576 static int
577 ncp_fill_cache(struct file *file, struct dir_context *ctx,
578 struct ncp_cache_control *ctrl, struct ncp_entry_info *entry,
579 int inval_childs)
580 {
581 struct dentry *newdent, *dentry = file->f_path.dentry;
582 struct inode *dir = dentry->d_inode;
583 struct ncp_cache_control ctl = *ctrl;
584 struct qstr qname;
585 int valid = 0;
586 int hashed = 0;
587 ino_t ino = 0;
588 __u8 __name[NCP_MAXPATHLEN + 1];
589
590 qname.len = sizeof(__name);
591 if (ncp_vol2io(NCP_SERVER(dir), __name, &qname.len,
592 entry->i.entryName, entry->i.nameLen,
593 !ncp_preserve_entry_case(dir, entry->i.NSCreator)))
594 return 1; /* I'm not sure */
595
596 qname.name = __name;
597
598 newdent = d_hash_and_lookup(dentry, &qname);
599 if (unlikely(IS_ERR(newdent)))
600 goto end_advance;
601 if (!newdent) {
602 newdent = d_alloc(dentry, &qname);
603 if (!newdent)
604 goto end_advance;
605 } else {
606 hashed = 1;
607
608 /* If case sensitivity changed for this volume, all entries below this one
609 should be thrown away. This entry itself is not affected, as its case
610 sensitivity is controlled by its own parent. */
611 if (inval_childs)
612 shrink_dcache_parent(newdent);
613
614 /*
615 * NetWare's OS2 namespace is case preserving yet case
616 * insensitive. So we update dentry's name as received from
617 * server. Parent dir's i_mutex is locked because we're in
618 * readdir.
619 */
620 dentry_update_name_case(newdent, &qname);
621 }
622
623 if (!newdent->d_inode) {
624 struct inode *inode;
625
626 entry->opened = 0;
627 entry->ino = iunique(dir->i_sb, 2);
628 inode = ncp_iget(dir->i_sb, entry);
629 if (inode) {
630 d_instantiate(newdent, inode);
631 if (!hashed)
632 d_rehash(newdent);
633 }
634 } else {
635 struct inode *inode = newdent->d_inode;
636
637 mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD);
638 ncp_update_inode2(inode, entry);
639 mutex_unlock(&inode->i_mutex);
640 }
641
642 if (newdent->d_inode) {
643 ino = newdent->d_inode->i_ino;
644 newdent->d_fsdata = (void *) ctl.fpos;
645 ncp_new_dentry(newdent);
646 }
647
648 if (ctl.idx >= NCP_DIRCACHE_SIZE) {
649 if (ctl.page) {
650 kunmap(ctl.page);
651 SetPageUptodate(ctl.page);
652 unlock_page(ctl.page);
653 page_cache_release(ctl.page);
654 }
655 ctl.cache = NULL;
656 ctl.idx -= NCP_DIRCACHE_SIZE;
657 ctl.ofs += 1;
658 ctl.page = grab_cache_page(&dir->i_data, ctl.ofs);
659 if (ctl.page)
660 ctl.cache = kmap(ctl.page);
661 }
662 if (ctl.cache) {
663 ctl.cache->dentry[ctl.idx] = newdent;
664 valid = 1;
665 }
666 dput(newdent);
667 end_advance:
668 if (!valid)
669 ctl.valid = 0;
670 if (!ctl.filled && (ctl.fpos == ctx->pos)) {
671 if (!ino)
672 ino = iunique(dir->i_sb, 2);
673 ctl.filled = !dir_emit(ctx, qname.name, qname.len,
674 ino, DT_UNKNOWN);
675 if (!ctl.filled)
676 ctx->pos += 1;
677 }
678 ctl.fpos += 1;
679 ctl.idx += 1;
680 *ctrl = ctl;
681 return (ctl.valid || !ctl.filled);
682 }
683
684 static void
685 ncp_read_volume_list(struct file *file, struct dir_context *ctx,
686 struct ncp_cache_control *ctl)
687 {
688 struct inode *inode = file_inode(file);
689 struct ncp_server *server = NCP_SERVER(inode);
690 struct ncp_volume_info info;
691 struct ncp_entry_info entry;
692 int i;
693
694 ncp_dbg(1, "pos=%ld\n", (unsigned long)ctx->pos);
695
696 for (i = 0; i < NCP_NUMBER_OF_VOLUMES; i++) {
697 int inval_dentry;
698
699 if (ncp_get_volume_info_with_number(server, i, &info) != 0)
700 return;
701 if (!strlen(info.volume_name))
702 continue;
703
704 ncp_dbg(1, "found vol: %s\n", info.volume_name);
705
706 if (ncp_lookup_volume(server, info.volume_name,
707 &entry.i)) {
708 ncp_dbg(1, "could not lookup vol %s\n",
709 info.volume_name);
710 continue;
711 }
712 inval_dentry = ncp_update_known_namespace(server, entry.i.volNumber, NULL);
713 entry.volume = entry.i.volNumber;
714 if (!ncp_fill_cache(file, ctx, ctl, &entry, inval_dentry))
715 return;
716 }
717 }
718
719 static void
720 ncp_do_readdir(struct file *file, struct dir_context *ctx,
721 struct ncp_cache_control *ctl)
722 {
723 struct inode *dir = file_inode(file);
724 struct ncp_server *server = NCP_SERVER(dir);
725 struct nw_search_sequence seq;
726 struct ncp_entry_info entry;
727 int err;
728 void* buf;
729 int more;
730 size_t bufsize;
731
732 ncp_dbg(1, "%pD2, fpos=%ld\n", file, (unsigned long)ctx->pos);
733 ncp_vdbg("init %pD, volnum=%d, dirent=%u\n",
734 file, NCP_FINFO(dir)->volNumber, NCP_FINFO(dir)->dirEntNum);
735
736 err = ncp_initialize_search(server, dir, &seq);
737 if (err) {
738 ncp_dbg(1, "init failed, err=%d\n", err);
739 return;
740 }
741 /* We MUST NOT use server->buffer_size handshaked with server if we are
742 using UDP, as for UDP server uses max. buffer size determined by
743 MTU, and for TCP server uses hardwired value 65KB (== 66560 bytes).
744 So we use 128KB, just to be sure, as there is no way how to know
745 this value in advance. */
746 bufsize = 131072;
747 buf = vmalloc(bufsize);
748 if (!buf)
749 return;
750 do {
751 int cnt;
752 char* rpl;
753 size_t rpls;
754
755 err = ncp_search_for_fileset(server, &seq, &more, &cnt, buf, bufsize, &rpl, &rpls);
756 if (err) /* Error */
757 break;
758 if (!cnt) /* prevent endless loop */
759 break;
760 while (cnt--) {
761 size_t onerpl;
762
763 if (rpls < offsetof(struct nw_info_struct, entryName))
764 break; /* short packet */
765 ncp_extract_file_info(rpl, &entry.i);
766 onerpl = offsetof(struct nw_info_struct, entryName) + entry.i.nameLen;
767 if (rpls < onerpl)
768 break; /* short packet */
769 (void)ncp_obtain_nfs_info(server, &entry.i);
770 rpl += onerpl;
771 rpls -= onerpl;
772 entry.volume = entry.i.volNumber;
773 if (!ncp_fill_cache(file, ctx, ctl, &entry, 0))
774 break;
775 }
776 } while (more);
777 vfree(buf);
778 return;
779 }
780
781 int ncp_conn_logged_in(struct super_block *sb)
782 {
783 struct ncp_server* server = NCP_SBP(sb);
784 int result;
785
786 if (ncp_single_volume(server)) {
787 int len;
788 struct dentry* dent;
789 __u32 volNumber;
790 __le32 dirEntNum;
791 __le32 DosDirNum;
792 __u8 __name[NCP_MAXPATHLEN + 1];
793
794 len = sizeof(__name);
795 result = ncp_io2vol(server, __name, &len, server->m.mounted_vol,
796 strlen(server->m.mounted_vol), 1);
797 if (result)
798 goto out;
799 result = -ENOENT;
800 if (ncp_get_volume_root(server, __name, &volNumber, &dirEntNum, &DosDirNum)) {
801 ncp_vdbg("%s not found\n", server->m.mounted_vol);
802 goto out;
803 }
804 dent = sb->s_root;
805 if (dent) {
806 struct inode* ino = dent->d_inode;
807 if (ino) {
808 ncp_update_known_namespace(server, volNumber, NULL);
809 NCP_FINFO(ino)->volNumber = volNumber;
810 NCP_FINFO(ino)->dirEntNum = dirEntNum;
811 NCP_FINFO(ino)->DosDirNum = DosDirNum;
812 result = 0;
813 } else {
814 ncp_dbg(1, "sb->s_root->d_inode == NULL!\n");
815 }
816 } else {
817 ncp_dbg(1, "sb->s_root == NULL!\n");
818 }
819 } else
820 result = 0;
821
822 out:
823 return result;
824 }
825
826 static struct dentry *ncp_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
827 {
828 struct ncp_server *server = NCP_SERVER(dir);
829 struct inode *inode = NULL;
830 struct ncp_entry_info finfo;
831 int error, res, len;
832 __u8 __name[NCP_MAXPATHLEN + 1];
833
834 error = -EIO;
835 if (!ncp_conn_valid(server))
836 goto finished;
837
838 ncp_vdbg("server lookup for %pd2\n", dentry);
839
840 len = sizeof(__name);
841 if (ncp_is_server_root(dir)) {
842 res = ncp_io2vol(server, __name, &len, dentry->d_name.name,
843 dentry->d_name.len, 1);
844 if (!res)
845 res = ncp_lookup_volume(server, __name, &(finfo.i));
846 if (!res)
847 ncp_update_known_namespace(server, finfo.i.volNumber, NULL);
848 } else {
849 res = ncp_io2vol(server, __name, &len, dentry->d_name.name,
850 dentry->d_name.len, !ncp_preserve_case(dir));
851 if (!res)
852 res = ncp_obtain_info(server, dir, __name, &(finfo.i));
853 }
854 ncp_vdbg("looked for %pd2, res=%d\n", dentry, res);
855 /*
856 * If we didn't find an entry, make a negative dentry.
857 */
858 if (res)
859 goto add_entry;
860
861 /*
862 * Create an inode for the entry.
863 */
864 finfo.opened = 0;
865 finfo.ino = iunique(dir->i_sb, 2);
866 finfo.volume = finfo.i.volNumber;
867 error = -EACCES;
868 inode = ncp_iget(dir->i_sb, &finfo);
869
870 if (inode) {
871 ncp_new_dentry(dentry);
872 add_entry:
873 d_add(dentry, inode);
874 error = 0;
875 }
876
877 finished:
878 ncp_vdbg("result=%d\n", error);
879 return ERR_PTR(error);
880 }
881
882 /*
883 * This code is common to create, mkdir, and mknod.
884 */
885 static int ncp_instantiate(struct inode *dir, struct dentry *dentry,
886 struct ncp_entry_info *finfo)
887 {
888 struct inode *inode;
889 int error = -EINVAL;
890
891 finfo->ino = iunique(dir->i_sb, 2);
892 inode = ncp_iget(dir->i_sb, finfo);
893 if (!inode)
894 goto out_close;
895 d_instantiate(dentry,inode);
896 error = 0;
897 out:
898 return error;
899
900 out_close:
901 ncp_vdbg("%pd2 failed, closing file\n", dentry);
902 ncp_close_file(NCP_SERVER(dir), finfo->file_handle);
903 goto out;
904 }
905
906 int ncp_create_new(struct inode *dir, struct dentry *dentry, umode_t mode,
907 dev_t rdev, __le32 attributes)
908 {
909 struct ncp_server *server = NCP_SERVER(dir);
910 struct ncp_entry_info finfo;
911 int error, result, len;
912 int opmode;
913 __u8 __name[NCP_MAXPATHLEN + 1];
914
915 ncp_vdbg("creating %pd2, mode=%hx\n", dentry, mode);
916
917 ncp_age_dentry(server, dentry);
918 len = sizeof(__name);
919 error = ncp_io2vol(server, __name, &len, dentry->d_name.name,
920 dentry->d_name.len, !ncp_preserve_case(dir));
921 if (error)
922 goto out;
923
924 error = -EACCES;
925
926 if (S_ISREG(mode) &&
927 (server->m.flags & NCP_MOUNT_EXTRAS) &&
928 (mode & S_IXUGO))
929 attributes |= aSYSTEM | aSHARED;
930
931 result = ncp_open_create_file_or_subdir(server, dir, __name,
932 OC_MODE_CREATE | OC_MODE_OPEN | OC_MODE_REPLACE,
933 attributes, AR_READ | AR_WRITE, &finfo);
934 opmode = O_RDWR;
935 if (result) {
936 result = ncp_open_create_file_or_subdir(server, dir, __name,
937 OC_MODE_CREATE | OC_MODE_OPEN | OC_MODE_REPLACE,
938 attributes, AR_WRITE, &finfo);
939 if (result) {
940 if (result == 0x87)
941 error = -ENAMETOOLONG;
942 else if (result < 0)
943 error = result;
944 ncp_dbg(1, "%pd2 failed\n", dentry);
945 goto out;
946 }
947 opmode = O_WRONLY;
948 }
949 finfo.access = opmode;
950 if (ncp_is_nfs_extras(server, finfo.volume)) {
951 finfo.i.nfs.mode = mode;
952 finfo.i.nfs.rdev = new_encode_dev(rdev);
953 if (ncp_modify_nfs_info(server, finfo.volume,
954 finfo.i.dirEntNum,
955 mode, new_encode_dev(rdev)) != 0)
956 goto out;
957 }
958
959 error = ncp_instantiate(dir, dentry, &finfo);
960 out:
961 return error;
962 }
963
964 static int ncp_create(struct inode *dir, struct dentry *dentry, umode_t mode,
965 bool excl)
966 {
967 return ncp_create_new(dir, dentry, mode, 0, 0);
968 }
969
970 static int ncp_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
971 {
972 struct ncp_entry_info finfo;
973 struct ncp_server *server = NCP_SERVER(dir);
974 int error, len;
975 __u8 __name[NCP_MAXPATHLEN + 1];
976
977 ncp_dbg(1, "making %pd2\n", dentry);
978
979 ncp_age_dentry(server, dentry);
980 len = sizeof(__name);
981 error = ncp_io2vol(server, __name, &len, dentry->d_name.name,
982 dentry->d_name.len, !ncp_preserve_case(dir));
983 if (error)
984 goto out;
985
986 error = ncp_open_create_file_or_subdir(server, dir, __name,
987 OC_MODE_CREATE, aDIR,
988 cpu_to_le16(0xffff),
989 &finfo);
990 if (error == 0) {
991 if (ncp_is_nfs_extras(server, finfo.volume)) {
992 mode |= S_IFDIR;
993 finfo.i.nfs.mode = mode;
994 if (ncp_modify_nfs_info(server,
995 finfo.volume,
996 finfo.i.dirEntNum,
997 mode, 0) != 0)
998 goto out;
999 }
1000 error = ncp_instantiate(dir, dentry, &finfo);
1001 } else if (error > 0) {
1002 error = -EACCES;
1003 }
1004 out:
1005 return error;
1006 }
1007
1008 static int ncp_rmdir(struct inode *dir, struct dentry *dentry)
1009 {
1010 struct ncp_server *server = NCP_SERVER(dir);
1011 int error, result, len;
1012 __u8 __name[NCP_MAXPATHLEN + 1];
1013
1014 ncp_dbg(1, "removing %pd2\n", dentry);
1015
1016 len = sizeof(__name);
1017 error = ncp_io2vol(server, __name, &len, dentry->d_name.name,
1018 dentry->d_name.len, !ncp_preserve_case(dir));
1019 if (error)
1020 goto out;
1021
1022 result = ncp_del_file_or_subdir(server, dir, __name);
1023 switch (result) {
1024 case 0x00:
1025 error = 0;
1026 break;
1027 case 0x85: /* unauthorized to delete file */
1028 case 0x8A: /* unauthorized to delete file */
1029 error = -EACCES;
1030 break;
1031 case 0x8F:
1032 case 0x90: /* read only */
1033 error = -EPERM;
1034 break;
1035 case 0x9F: /* in use by another client */
1036 error = -EBUSY;
1037 break;
1038 case 0xA0: /* directory not empty */
1039 error = -ENOTEMPTY;
1040 break;
1041 case 0xFF: /* someone deleted file */
1042 error = -ENOENT;
1043 break;
1044 default:
1045 error = result < 0 ? result : -EACCES;
1046 break;
1047 }
1048 out:
1049 return error;
1050 }
1051
1052 static int ncp_unlink(struct inode *dir, struct dentry *dentry)
1053 {
1054 struct inode *inode = dentry->d_inode;
1055 struct ncp_server *server;
1056 int error;
1057
1058 server = NCP_SERVER(dir);
1059 ncp_dbg(1, "unlinking %pd2\n", dentry);
1060
1061 /*
1062 * Check whether to close the file ...
1063 */
1064 if (inode) {
1065 ncp_vdbg("closing file\n");
1066 ncp_make_closed(inode);
1067 }
1068
1069 error = ncp_del_file_or_subdir2(server, dentry);
1070 #ifdef CONFIG_NCPFS_STRONG
1071 /* 9C is Invalid path.. It should be 8F, 90 - read only, but
1072 it is not :-( */
1073 if ((error == 0x9C || error == 0x90) && server->m.flags & NCP_MOUNT_STRONG) { /* R/O */
1074 error = ncp_force_unlink(dir, dentry);
1075 }
1076 #endif
1077 switch (error) {
1078 case 0x00:
1079 ncp_dbg(1, "removed %pd2\n", dentry);
1080 break;
1081 case 0x85:
1082 case 0x8A:
1083 error = -EACCES;
1084 break;
1085 case 0x8D: /* some files in use */
1086 case 0x8E: /* all files in use */
1087 error = -EBUSY;
1088 break;
1089 case 0x8F: /* some read only */
1090 case 0x90: /* all read only */
1091 case 0x9C: /* !!! returned when in-use or read-only by NW4 */
1092 error = -EPERM;
1093 break;
1094 case 0xFF:
1095 error = -ENOENT;
1096 break;
1097 default:
1098 error = error < 0 ? error : -EACCES;
1099 break;
1100 }
1101 return error;
1102 }
1103
1104 static int ncp_rename(struct inode *old_dir, struct dentry *old_dentry,
1105 struct inode *new_dir, struct dentry *new_dentry)
1106 {
1107 struct ncp_server *server = NCP_SERVER(old_dir);
1108 int error;
1109 int old_len, new_len;
1110 __u8 __old_name[NCP_MAXPATHLEN + 1], __new_name[NCP_MAXPATHLEN + 1];
1111
1112 ncp_dbg(1, "%pd2 to %pd2\n", old_dentry, new_dentry);
1113
1114 ncp_age_dentry(server, old_dentry);
1115 ncp_age_dentry(server, new_dentry);
1116
1117 old_len = sizeof(__old_name);
1118 error = ncp_io2vol(server, __old_name, &old_len,
1119 old_dentry->d_name.name, old_dentry->d_name.len,
1120 !ncp_preserve_case(old_dir));
1121 if (error)
1122 goto out;
1123
1124 new_len = sizeof(__new_name);
1125 error = ncp_io2vol(server, __new_name, &new_len,
1126 new_dentry->d_name.name, new_dentry->d_name.len,
1127 !ncp_preserve_case(new_dir));
1128 if (error)
1129 goto out;
1130
1131 error = ncp_ren_or_mov_file_or_subdir(server, old_dir, __old_name,
1132 new_dir, __new_name);
1133 #ifdef CONFIG_NCPFS_STRONG
1134 if ((error == 0x90 || error == 0x8B || error == -EACCES) &&
1135 server->m.flags & NCP_MOUNT_STRONG) { /* RO */
1136 error = ncp_force_rename(old_dir, old_dentry, __old_name,
1137 new_dir, new_dentry, __new_name);
1138 }
1139 #endif
1140 switch (error) {
1141 case 0x00:
1142 ncp_dbg(1, "renamed %pd -> %pd\n",
1143 old_dentry, new_dentry);
1144 break;
1145 case 0x9E:
1146 error = -ENAMETOOLONG;
1147 break;
1148 case 0xFF:
1149 error = -ENOENT;
1150 break;
1151 default:
1152 error = error < 0 ? error : -EACCES;
1153 break;
1154 }
1155 out:
1156 return error;
1157 }
1158
1159 static int ncp_mknod(struct inode * dir, struct dentry *dentry,
1160 umode_t mode, dev_t rdev)
1161 {
1162 if (!new_valid_dev(rdev))
1163 return -EINVAL;
1164 if (ncp_is_nfs_extras(NCP_SERVER(dir), NCP_FINFO(dir)->volNumber)) {
1165 ncp_dbg(1, "mode = 0%ho\n", mode);
1166 return ncp_create_new(dir, dentry, mode, rdev, 0);
1167 }
1168 return -EPERM; /* Strange, but true */
1169 }
1170
1171 /* The following routines are taken directly from msdos-fs */
1172
1173 /* Linear day numbers of the respective 1sts in non-leap years. */
1174
1175 static int day_n[] =
1176 {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 0, 0, 0, 0};
1177 /* Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec */
1178
1179 static int utc2local(int time)
1180 {
1181 return time - sys_tz.tz_minuteswest * 60;
1182 }
1183
1184 static int local2utc(int time)
1185 {
1186 return time + sys_tz.tz_minuteswest * 60;
1187 }
1188
1189 /* Convert a MS-DOS time/date pair to a UNIX date (seconds since 1 1 70). */
1190 int
1191 ncp_date_dos2unix(__le16 t, __le16 d)
1192 {
1193 unsigned short time = le16_to_cpu(t), date = le16_to_cpu(d);
1194 int month, year, secs;
1195
1196 /* first subtract and mask after that... Otherwise, if
1197 date == 0, bad things happen */
1198 month = ((date >> 5) - 1) & 15;
1199 year = date >> 9;
1200 secs = (time & 31) * 2 + 60 * ((time >> 5) & 63) + (time >> 11) * 3600 +
1201 86400 * ((date & 31) - 1 + day_n[month] + (year / 4) +
1202 year * 365 - ((year & 3) == 0 && month < 2 ? 1 : 0) + 3653);
1203 /* days since 1.1.70 plus 80's leap day */
1204 return local2utc(secs);
1205 }
1206
1207
1208 /* Convert linear UNIX date to a MS-DOS time/date pair. */
1209 void
1210 ncp_date_unix2dos(int unix_date, __le16 *time, __le16 *date)
1211 {
1212 int day, year, nl_day, month;
1213
1214 unix_date = utc2local(unix_date);
1215 *time = cpu_to_le16(
1216 (unix_date % 60) / 2 + (((unix_date / 60) % 60) << 5) +
1217 (((unix_date / 3600) % 24) << 11));
1218 day = unix_date / 86400 - 3652;
1219 year = day / 365;
1220 if ((year + 3) / 4 + 365 * year > day)
1221 year--;
1222 day -= (year + 3) / 4 + 365 * year;
1223 if (day == 59 && !(year & 3)) {
1224 nl_day = day;
1225 month = 2;
1226 } else {
1227 nl_day = (year & 3) || day <= 59 ? day : day - 1;
1228 for (month = 1; month < 12; month++)
1229 if (day_n[month] > nl_day)
1230 break;
1231 }
1232 *date = cpu_to_le16(nl_day - day_n[month - 1] + 1 + (month << 5) + (year << 9));
1233 }
Linux kernel - Deliverables
This page took 0.080423 seconds and 5 git commands to generate.