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
14 #include <linux/time.h>
15 #include <linux/errno.h>
16 #include <linux/stat.h>
17 #include <linux/kernel.h>
18 #include <linux/slab.h>
19 #include <linux/vmalloc.h>
21 #include <asm/uaccess.h>
22 #include <asm/byteorder.h>
23 #include <linux/smp_lock.h>
25 #include <linux/ncp_fs.h>
27 #include "ncplib_kernel.h"
29 static void ncp_read_volume_list(struct file
*, void *, filldir_t
,
30 struct ncp_cache_control
*);
31 static void ncp_do_readdir(struct file
*, void *, filldir_t
,
32 struct ncp_cache_control
*);
34 static int ncp_readdir(struct file
*, void *, filldir_t
);
36 static int ncp_create(struct inode
*, struct dentry
*, int, struct nameidata
*);
37 static struct dentry
*ncp_lookup(struct inode
*, struct dentry
*, struct nameidata
*);
38 static int ncp_unlink(struct inode
*, struct dentry
*);
39 static int ncp_mkdir(struct inode
*, struct dentry
*, int);
40 static int ncp_rmdir(struct inode
*, struct dentry
*);
41 static int ncp_rename(struct inode
*, struct dentry
*,
42 struct inode
*, struct dentry
*);
43 static int ncp_mknod(struct inode
* dir
, struct dentry
*dentry
,
44 int mode
, dev_t rdev
);
45 #if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
46 extern int ncp_symlink(struct inode
*, struct dentry
*, const char *);
48 #define ncp_symlink NULL
51 const struct file_operations ncp_dir_operations
=
53 .read
= generic_read_dir
,
54 .readdir
= ncp_readdir
,
57 .compat_ioctl
= ncp_compat_ioctl
,
61 struct inode_operations ncp_dir_inode_operations
=
66 .symlink
= ncp_symlink
,
71 .setattr
= ncp_notify_change
,
75 * Dentry operations routines
77 static int ncp_lookup_validate(struct dentry
*, struct nameidata
*);
78 static int ncp_hash_dentry(struct dentry
*, struct qstr
*);
79 static int ncp_compare_dentry (struct dentry
*, struct qstr
*, struct qstr
*);
80 static int ncp_delete_dentry(struct dentry
*);
82 static struct dentry_operations ncp_dentry_operations
=
84 .d_revalidate
= ncp_lookup_validate
,
85 .d_hash
= ncp_hash_dentry
,
86 .d_compare
= ncp_compare_dentry
,
87 .d_delete
= ncp_delete_dentry
,
90 struct dentry_operations ncp_root_dentry_operations
=
92 .d_hash
= ncp_hash_dentry
,
93 .d_compare
= ncp_compare_dentry
,
94 .d_delete
= ncp_delete_dentry
,
99 * Note: leave the hash unchanged if the directory
103 ncp_hash_dentry(struct dentry
*dentry
, struct qstr
*this)
109 t
= NCP_IO_TABLE(dentry
);
111 if (!ncp_case_sensitive(dentry
->d_inode
)) {
112 hash
= init_name_hash();
113 for (i
=0; i
<this->len
; i
++)
114 hash
= partial_name_hash(ncp_tolower(t
, this->name
[i
]),
116 this->hash
= end_name_hash(hash
);
122 ncp_compare_dentry(struct dentry
*dentry
, struct qstr
*a
, struct qstr
*b
)
124 if (a
->len
!= b
->len
)
127 if (ncp_case_sensitive(dentry
->d_inode
))
128 return strncmp(a
->name
, b
->name
, a
->len
);
130 return ncp_strnicmp(NCP_IO_TABLE(dentry
), a
->name
, b
->name
, a
->len
);
134 * This is the callback from dput() when d_count is going to 0.
135 * We use this to unhash dentries with bad inodes.
136 * Closing files can be safely postponed until iput() - it's done there anyway.
139 ncp_delete_dentry(struct dentry
* dentry
)
141 struct inode
*inode
= dentry
->d_inode
;
144 if (is_bad_inode(inode
))
148 /* N.B. Unhash negative dentries? */
154 ncp_single_volume(struct ncp_server
*server
)
156 return (server
->m
.mounted_vol
[0] != '\0');
159 static inline int ncp_is_server_root(struct inode
*inode
)
161 return (!ncp_single_volume(NCP_SERVER(inode
)) &&
162 inode
== inode
->i_sb
->s_root
->d_inode
);
167 * This is the callback when the dcache has a lookup hit.
171 #ifdef CONFIG_NCPFS_STRONG
172 /* try to delete a readonly file (NW R bit set) */
175 ncp_force_unlink(struct inode
*dir
, struct dentry
* dentry
)
178 struct nw_modify_dos_info info
;
182 memset(&info
, 0, sizeof(info
));
184 /* remove the Read-Only flag on the NW server */
185 inode
= dentry
->d_inode
;
187 old_nwattr
= NCP_FINFO(inode
)->nwattr
;
188 info
.attributes
= old_nwattr
& ~(aRONLY
|aDELETEINHIBIT
|aRENAMEINHIBIT
);
189 res2
= ncp_modify_file_or_subdir_dos_info_path(NCP_SERVER(inode
), inode
, NULL
, DM_ATTRIBUTES
, &info
);
193 /* now try again the delete operation */
194 res
= ncp_del_file_or_subdir2(NCP_SERVER(dir
), dentry
);
196 if (res
) /* delete failed, set R bit again */
198 info
.attributes
= old_nwattr
;
199 res2
= ncp_modify_file_or_subdir_dos_info_path(NCP_SERVER(inode
), inode
, NULL
, DM_ATTRIBUTES
, &info
);
206 #endif /* CONFIG_NCPFS_STRONG */
208 #ifdef CONFIG_NCPFS_STRONG
210 ncp_force_rename(struct inode
*old_dir
, struct dentry
* old_dentry
, char *_old_name
,
211 struct inode
*new_dir
, struct dentry
* new_dentry
, char *_new_name
)
213 struct nw_modify_dos_info info
;
215 struct inode
*old_inode
= old_dentry
->d_inode
;
216 __le32 old_nwattr
= NCP_FINFO(old_inode
)->nwattr
;
217 __le32 new_nwattr
= 0; /* shut compiler warning */
218 int old_nwattr_changed
= 0;
219 int new_nwattr_changed
= 0;
221 memset(&info
, 0, sizeof(info
));
223 /* remove the Read-Only flag on the NW server */
225 info
.attributes
= old_nwattr
& ~(aRONLY
|aRENAMEINHIBIT
|aDELETEINHIBIT
);
226 res2
= ncp_modify_file_or_subdir_dos_info_path(NCP_SERVER(old_inode
), old_inode
, NULL
, DM_ATTRIBUTES
, &info
);
228 old_nwattr_changed
= 1;
229 if (new_dentry
&& new_dentry
->d_inode
) {
230 new_nwattr
= NCP_FINFO(new_dentry
->d_inode
)->nwattr
;
231 info
.attributes
= new_nwattr
& ~(aRONLY
|aRENAMEINHIBIT
|aDELETEINHIBIT
);
232 res2
= ncp_modify_file_or_subdir_dos_info_path(NCP_SERVER(new_dir
), new_dir
, _new_name
, DM_ATTRIBUTES
, &info
);
234 new_nwattr_changed
= 1;
236 /* now try again the rename operation */
237 /* but only if something really happened */
238 if (new_nwattr_changed
|| old_nwattr_changed
) {
239 res
= ncp_ren_or_mov_file_or_subdir(NCP_SERVER(old_dir
),
245 /* file was successfully renamed, so:
246 do not set attributes on old file - it no longer exists
247 copy attributes from old file to new */
248 new_nwattr_changed
= old_nwattr_changed
;
249 new_nwattr
= old_nwattr
;
250 old_nwattr_changed
= 0;
253 if (old_nwattr_changed
) {
254 info
.attributes
= old_nwattr
;
255 res2
= ncp_modify_file_or_subdir_dos_info_path(NCP_SERVER(old_inode
), old_inode
, NULL
, DM_ATTRIBUTES
, &info
);
258 if (new_nwattr_changed
) {
259 info
.attributes
= new_nwattr
;
260 res2
= ncp_modify_file_or_subdir_dos_info_path(NCP_SERVER(new_dir
), new_dir
, _new_name
, DM_ATTRIBUTES
, &info
);
265 #endif /* CONFIG_NCPFS_STRONG */
269 __ncp_lookup_validate(struct dentry
* dentry
, struct nameidata
*nd
)
271 struct ncp_server
*server
;
272 struct dentry
*parent
;
274 struct ncp_entry_info finfo
;
275 int res
, val
= 0, len
;
276 __u8 __name
[NCP_MAXPATHLEN
+ 1];
278 parent
= dget_parent(dentry
);
279 dir
= parent
->d_inode
;
281 if (!dentry
->d_inode
)
284 server
= NCP_SERVER(dir
);
286 if (!ncp_conn_valid(server
))
291 * The default validation is based on dentry age:
292 * We set the max age at mount time. (But each
293 * successful server lookup renews the timestamp.)
295 val
= NCP_TEST_AGE(server
, dentry
);
299 DDPRINTK("ncp_lookup_validate: %s/%s not valid, age=%ld, server lookup\n",
300 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
,
301 NCP_GET_AGE(dentry
));
303 len
= sizeof(__name
);
304 if (ncp_is_server_root(dir
)) {
305 res
= ncp_io2vol(server
, __name
, &len
, dentry
->d_name
.name
,
306 dentry
->d_name
.len
, 1);
308 res
= ncp_lookup_volume(server
, __name
, &(finfo
.i
));
310 res
= ncp_io2vol(server
, __name
, &len
, dentry
->d_name
.name
,
311 dentry
->d_name
.len
, !ncp_preserve_case(dir
));
313 res
= ncp_obtain_info(server
, dir
, __name
, &(finfo
.i
));
315 finfo
.volume
= finfo
.i
.volNumber
;
316 DDPRINTK("ncp_lookup_validate: looked for %s/%s, res=%d\n",
317 dentry
->d_parent
->d_name
.name
, __name
, res
);
319 * If we didn't find it, or if it has a different dirEntNum to
320 * what we remember, it's not valid any more.
323 if (finfo
.i
.dirEntNum
== NCP_FINFO(dentry
->d_inode
)->dirEntNum
) {
324 ncp_new_dentry(dentry
);
327 DDPRINTK("ncp_lookup_validate: found, but dirEntNum changed\n");
329 ncp_update_inode2(dentry
->d_inode
, &finfo
);
333 DDPRINTK("ncp_lookup_validate: result=%d\n", val
);
339 ncp_lookup_validate(struct dentry
* dentry
, struct nameidata
*nd
)
343 res
= __ncp_lookup_validate(dentry
, nd
);
348 static struct dentry
*
349 ncp_dget_fpos(struct dentry
*dentry
, struct dentry
*parent
, unsigned long fpos
)
351 struct dentry
*dent
= dentry
;
352 struct list_head
*next
;
354 if (d_validate(dent
, parent
)) {
355 if (dent
->d_name
.len
<= NCP_MAXPATHLEN
&&
356 (unsigned long)dent
->d_fsdata
== fpos
) {
357 if (!dent
->d_inode
) {
366 /* If a pointer is invalid, we search the dentry. */
367 spin_lock(&dcache_lock
);
368 next
= parent
->d_subdirs
.next
;
369 while (next
!= &parent
->d_subdirs
) {
370 dent
= list_entry(next
, struct dentry
, d_u
.d_child
);
371 if ((unsigned long)dent
->d_fsdata
== fpos
) {
376 spin_unlock(&dcache_lock
);
381 spin_unlock(&dcache_lock
);
388 static time_t ncp_obtain_mtime(struct dentry
*dentry
)
390 struct inode
*inode
= dentry
->d_inode
;
391 struct ncp_server
*server
= NCP_SERVER(inode
);
392 struct nw_info_struct i
;
394 if (!ncp_conn_valid(server
) || ncp_is_server_root(inode
))
397 if (ncp_obtain_info(server
, inode
, NULL
, &i
))
400 return ncp_date_dos2unix(i
.modifyTime
, i
.modifyDate
);
403 static int ncp_readdir(struct file
*filp
, void *dirent
, filldir_t filldir
)
405 struct dentry
*dentry
= filp
->f_path
.dentry
;
406 struct inode
*inode
= dentry
->d_inode
;
407 struct page
*page
= NULL
;
408 struct ncp_server
*server
= NCP_SERVER(inode
);
409 union ncp_dir_cache
*cache
= NULL
;
410 struct ncp_cache_control ctl
;
411 int result
, mtime_valid
= 0;
419 DDPRINTK("ncp_readdir: reading %s/%s, pos=%d\n",
420 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
,
424 if (!ncp_conn_valid(server
))
428 if (filp
->f_pos
== 0) {
429 if (filldir(dirent
, ".", 1, 0, inode
->i_ino
, DT_DIR
))
433 if (filp
->f_pos
== 1) {
434 if (filldir(dirent
, "..", 2, 1, parent_ino(dentry
), DT_DIR
))
439 page
= grab_cache_page(&inode
->i_data
, 0);
443 ctl
.cache
= cache
= kmap(page
);
444 ctl
.head
= cache
->head
;
446 if (!PageUptodate(page
) || !ctl
.head
.eof
)
449 if (filp
->f_pos
== 2) {
450 if (jiffies
- ctl
.head
.time
>= NCP_MAX_AGE(server
))
453 mtime
= ncp_obtain_mtime(dentry
);
455 if ((!mtime
) || (mtime
!= ctl
.head
.mtime
))
459 if (filp
->f_pos
> ctl
.head
.end
)
462 ctl
.fpos
= filp
->f_pos
+ (NCP_DIRCACHE_START
- 2);
463 ctl
.ofs
= ctl
.fpos
/ NCP_DIRCACHE_SIZE
;
464 ctl
.idx
= ctl
.fpos
% NCP_DIRCACHE_SIZE
;
468 ctl
.page
= find_lock_page(&inode
->i_data
, ctl
.ofs
);
471 ctl
.cache
= kmap(ctl
.page
);
472 if (!PageUptodate(ctl
.page
))
475 while (ctl
.idx
< NCP_DIRCACHE_SIZE
) {
479 dent
= ncp_dget_fpos(ctl
.cache
->dentry
[ctl
.idx
],
480 dentry
, filp
->f_pos
);
483 res
= filldir(dirent
, dent
->d_name
.name
,
484 dent
->d_name
.len
, filp
->f_pos
,
485 dent
->d_inode
->i_ino
, DT_UNKNOWN
);
491 if (filp
->f_pos
> ctl
.head
.end
)
496 SetPageUptodate(ctl
.page
);
497 unlock_page(ctl
.page
);
498 page_cache_release(ctl
.page
);
507 unlock_page(ctl
.page
);
508 page_cache_release(ctl
.page
);
513 ncp_invalidate_dircache_entries(dentry
);
515 mtime
= ncp_obtain_mtime(dentry
);
518 ctl
.head
.mtime
= mtime
;
519 ctl
.head
.time
= jiffies
;
523 ctl
.idx
= NCP_DIRCACHE_START
;
527 if (ncp_is_server_root(inode
)) {
528 ncp_read_volume_list(filp
, dirent
, filldir
, &ctl
);
530 ncp_do_readdir(filp
, dirent
, filldir
, &ctl
);
532 ctl
.head
.end
= ctl
.fpos
- 1;
533 ctl
.head
.eof
= ctl
.valid
;
536 cache
->head
= ctl
.head
;
538 SetPageUptodate(page
);
540 page_cache_release(page
);
544 SetPageUptodate(ctl
.page
);
545 unlock_page(ctl
.page
);
546 page_cache_release(ctl
.page
);
554 ncp_fill_cache(struct file
*filp
, void *dirent
, filldir_t filldir
,
555 struct ncp_cache_control
*ctrl
, struct ncp_entry_info
*entry
)
557 struct dentry
*newdent
, *dentry
= filp
->f_path
.dentry
;
558 struct inode
*newino
, *inode
= dentry
->d_inode
;
559 struct ncp_cache_control ctl
= *ctrl
;
564 __u8 __name
[NCP_MAXPATHLEN
+ 1];
566 qname
.len
= sizeof(__name
);
567 if (ncp_vol2io(NCP_SERVER(inode
), __name
, &qname
.len
,
568 entry
->i
.entryName
, entry
->i
.nameLen
,
569 !ncp_preserve_entry_case(inode
, entry
->i
.NSCreator
)))
570 return 1; /* I'm not sure */
573 qname
.hash
= full_name_hash(qname
.name
, qname
.len
);
575 if (dentry
->d_op
&& dentry
->d_op
->d_hash
)
576 if (dentry
->d_op
->d_hash(dentry
, &qname
) != 0)
579 newdent
= d_lookup(dentry
, &qname
);
582 newdent
= d_alloc(dentry
, &qname
);
587 memcpy((char *) newdent
->d_name
.name
, qname
.name
,
588 newdent
->d_name
.len
);
591 if (!newdent
->d_inode
) {
593 entry
->ino
= iunique(inode
->i_sb
, 2);
594 newino
= ncp_iget(inode
->i_sb
, entry
);
596 newdent
->d_op
= &ncp_dentry_operations
;
597 d_instantiate(newdent
, newino
);
602 ncp_update_inode2(newdent
->d_inode
, entry
);
604 if (newdent
->d_inode
) {
605 ino
= newdent
->d_inode
->i_ino
;
606 newdent
->d_fsdata
= (void *) ctl
.fpos
;
607 ncp_new_dentry(newdent
);
610 if (ctl
.idx
>= NCP_DIRCACHE_SIZE
) {
613 SetPageUptodate(ctl
.page
);
614 unlock_page(ctl
.page
);
615 page_cache_release(ctl
.page
);
618 ctl
.idx
-= NCP_DIRCACHE_SIZE
;
620 ctl
.page
= grab_cache_page(&inode
->i_data
, ctl
.ofs
);
622 ctl
.cache
= kmap(ctl
.page
);
625 ctl
.cache
->dentry
[ctl
.idx
] = newdent
;
632 if (!ctl
.filled
&& (ctl
.fpos
== filp
->f_pos
)) {
634 ino
= find_inode_number(dentry
, &qname
);
636 ino
= iunique(inode
->i_sb
, 2);
637 ctl
.filled
= filldir(dirent
, qname
.name
, qname
.len
,
638 filp
->f_pos
, ino
, DT_UNKNOWN
);
645 return (ctl
.valid
|| !ctl
.filled
);
649 ncp_read_volume_list(struct file
*filp
, void *dirent
, filldir_t filldir
,
650 struct ncp_cache_control
*ctl
)
652 struct dentry
*dentry
= filp
->f_path
.dentry
;
653 struct inode
*inode
= dentry
->d_inode
;
654 struct ncp_server
*server
= NCP_SERVER(inode
);
655 struct ncp_volume_info info
;
656 struct ncp_entry_info entry
;
659 DPRINTK("ncp_read_volume_list: pos=%ld\n",
660 (unsigned long) filp
->f_pos
);
662 for (i
= 0; i
< NCP_NUMBER_OF_VOLUMES
; i
++) {
664 if (ncp_get_volume_info_with_number(server
, i
, &info
) != 0)
666 if (!strlen(info
.volume_name
))
669 DPRINTK("ncp_read_volume_list: found vol: %s\n",
672 if (ncp_lookup_volume(server
, info
.volume_name
,
674 DPRINTK("ncpfs: could not lookup vol %s\n",
678 entry
.volume
= entry
.i
.volNumber
;
679 if (!ncp_fill_cache(filp
, dirent
, filldir
, ctl
, &entry
))
685 ncp_do_readdir(struct file
*filp
, void *dirent
, filldir_t filldir
,
686 struct ncp_cache_control
*ctl
)
688 struct dentry
*dentry
= filp
->f_path
.dentry
;
689 struct inode
*dir
= dentry
->d_inode
;
690 struct ncp_server
*server
= NCP_SERVER(dir
);
691 struct nw_search_sequence seq
;
692 struct ncp_entry_info entry
;
698 DPRINTK("ncp_do_readdir: %s/%s, fpos=%ld\n",
699 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
,
700 (unsigned long) filp
->f_pos
);
701 PPRINTK("ncp_do_readdir: init %s, volnum=%d, dirent=%u\n",
702 dentry
->d_name
.name
, NCP_FINFO(dir
)->volNumber
,
703 NCP_FINFO(dir
)->dirEntNum
);
705 err
= ncp_initialize_search(server
, dir
, &seq
);
707 DPRINTK("ncp_do_readdir: init failed, err=%d\n", err
);
710 /* We MUST NOT use server->buffer_size handshaked with server if we are
711 using UDP, as for UDP server uses max. buffer size determined by
712 MTU, and for TCP server uses hardwired value 65KB (== 66560 bytes).
713 So we use 128KB, just to be sure, as there is no way how to know
714 this value in advance. */
716 buf
= vmalloc(bufsize
);
724 err
= ncp_search_for_fileset(server
, &seq
, &more
, &cnt
, buf
, bufsize
, &rpl
, &rpls
);
727 if (!cnt
) /* prevent endless loop */
732 if (rpls
< offsetof(struct nw_info_struct
, entryName
))
733 break; /* short packet */
734 ncp_extract_file_info(rpl
, &entry
.i
);
735 onerpl
= offsetof(struct nw_info_struct
, entryName
) + entry
.i
.nameLen
;
737 break; /* short packet */
738 (void)ncp_obtain_nfs_info(server
, &entry
.i
);
741 entry
.volume
= entry
.i
.volNumber
;
742 if (!ncp_fill_cache(filp
, dirent
, filldir
, ctl
, &entry
))
750 int ncp_conn_logged_in(struct super_block
*sb
)
752 struct ncp_server
* server
= NCP_SBP(sb
);
755 if (ncp_single_volume(server
)) {
761 __u8 __name
[NCP_MAXPATHLEN
+ 1];
763 len
= sizeof(__name
);
764 result
= ncp_io2vol(server
, __name
, &len
, server
->m
.mounted_vol
,
765 strlen(server
->m
.mounted_vol
), 1);
769 if (ncp_get_volume_root(server
, __name
, &volNumber
, &dirEntNum
, &DosDirNum
)) {
770 PPRINTK("ncp_conn_logged_in: %s not found\n",
771 server
->m
.mounted_vol
);
776 struct inode
* ino
= dent
->d_inode
;
778 NCP_FINFO(ino
)->volNumber
= volNumber
;
779 NCP_FINFO(ino
)->dirEntNum
= dirEntNum
;
780 NCP_FINFO(ino
)->DosDirNum
= DosDirNum
;
782 DPRINTK("ncpfs: sb->s_root->d_inode == NULL!\n");
785 DPRINTK("ncpfs: sb->s_root == NULL!\n");
794 static struct dentry
*ncp_lookup(struct inode
*dir
, struct dentry
*dentry
, struct nameidata
*nd
)
796 struct ncp_server
*server
= NCP_SERVER(dir
);
797 struct inode
*inode
= NULL
;
798 struct ncp_entry_info finfo
;
800 __u8 __name
[NCP_MAXPATHLEN
+ 1];
804 if (!ncp_conn_valid(server
))
807 PPRINTK("ncp_lookup: server lookup for %s/%s\n",
808 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
);
810 len
= sizeof(__name
);
811 if (ncp_is_server_root(dir
)) {
812 res
= ncp_io2vol(server
, __name
, &len
, dentry
->d_name
.name
,
813 dentry
->d_name
.len
, 1);
815 res
= ncp_lookup_volume(server
, __name
, &(finfo
.i
));
817 res
= ncp_io2vol(server
, __name
, &len
, dentry
->d_name
.name
,
818 dentry
->d_name
.len
, !ncp_preserve_case(dir
));
820 res
= ncp_obtain_info(server
, dir
, __name
, &(finfo
.i
));
822 PPRINTK("ncp_lookup: looked for %s/%s, res=%d\n",
823 dentry
->d_parent
->d_name
.name
, __name
, res
);
825 * If we didn't find an entry, make a negative dentry.
831 * Create an inode for the entry.
834 finfo
.ino
= iunique(dir
->i_sb
, 2);
835 finfo
.volume
= finfo
.i
.volNumber
;
837 inode
= ncp_iget(dir
->i_sb
, &finfo
);
840 ncp_new_dentry(dentry
);
842 dentry
->d_op
= &ncp_dentry_operations
;
843 d_add(dentry
, inode
);
848 PPRINTK("ncp_lookup: result=%d\n", error
);
850 return ERR_PTR(error
);
854 * This code is common to create, mkdir, and mknod.
856 static int ncp_instantiate(struct inode
*dir
, struct dentry
*dentry
,
857 struct ncp_entry_info
*finfo
)
862 finfo
->ino
= iunique(dir
->i_sb
, 2);
863 inode
= ncp_iget(dir
->i_sb
, finfo
);
866 d_instantiate(dentry
,inode
);
872 PPRINTK("ncp_instantiate: %s/%s failed, closing file\n",
873 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
);
874 ncp_close_file(NCP_SERVER(dir
), finfo
->file_handle
);
878 int ncp_create_new(struct inode
*dir
, struct dentry
*dentry
, int mode
,
879 dev_t rdev
, __le32 attributes
)
881 struct ncp_server
*server
= NCP_SERVER(dir
);
882 struct ncp_entry_info finfo
;
883 int error
, result
, len
;
885 __u8 __name
[NCP_MAXPATHLEN
+ 1];
887 PPRINTK("ncp_create_new: creating %s/%s, mode=%x\n",
888 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
, mode
);
892 if (!ncp_conn_valid(server
))
895 ncp_age_dentry(server
, dentry
);
896 len
= sizeof(__name
);
897 error
= ncp_io2vol(server
, __name
, &len
, dentry
->d_name
.name
,
898 dentry
->d_name
.len
, !ncp_preserve_case(dir
));
905 (server
->m
.flags
& NCP_MOUNT_EXTRAS
) &&
907 attributes
|= aSYSTEM
| aSHARED
;
909 result
= ncp_open_create_file_or_subdir(server
, dir
, __name
,
910 OC_MODE_CREATE
| OC_MODE_OPEN
| OC_MODE_REPLACE
,
911 attributes
, AR_READ
| AR_WRITE
, &finfo
);
914 result
= ncp_open_create_file_or_subdir(server
, dir
, __name
,
915 OC_MODE_CREATE
| OC_MODE_OPEN
| OC_MODE_REPLACE
,
916 attributes
, AR_WRITE
, &finfo
);
919 error
= -ENAMETOOLONG
;
920 DPRINTK("ncp_create: %s/%s failed\n",
921 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
);
926 finfo
.access
= opmode
;
927 if (ncp_is_nfs_extras(server
, finfo
.volume
)) {
928 finfo
.i
.nfs
.mode
= mode
;
929 finfo
.i
.nfs
.rdev
= new_encode_dev(rdev
);
930 if (ncp_modify_nfs_info(server
, finfo
.volume
,
932 mode
, new_encode_dev(rdev
)) != 0)
936 error
= ncp_instantiate(dir
, dentry
, &finfo
);
942 static int ncp_create(struct inode
*dir
, struct dentry
*dentry
, int mode
,
943 struct nameidata
*nd
)
945 return ncp_create_new(dir
, dentry
, mode
, 0, 0);
948 static int ncp_mkdir(struct inode
*dir
, struct dentry
*dentry
, int mode
)
950 struct ncp_entry_info finfo
;
951 struct ncp_server
*server
= NCP_SERVER(dir
);
953 __u8 __name
[NCP_MAXPATHLEN
+ 1];
955 DPRINTK("ncp_mkdir: making %s/%s\n",
956 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
);
960 if (!ncp_conn_valid(server
))
963 ncp_age_dentry(server
, dentry
);
964 len
= sizeof(__name
);
965 error
= ncp_io2vol(server
, __name
, &len
, dentry
->d_name
.name
,
966 dentry
->d_name
.len
, !ncp_preserve_case(dir
));
971 if (ncp_open_create_file_or_subdir(server
, dir
, __name
,
972 OC_MODE_CREATE
, aDIR
,
976 if (ncp_is_nfs_extras(server
, finfo
.volume
)) {
978 finfo
.i
.nfs
.mode
= mode
;
979 if (ncp_modify_nfs_info(server
,
985 error
= ncp_instantiate(dir
, dentry
, &finfo
);
992 static int ncp_rmdir(struct inode
*dir
, struct dentry
*dentry
)
994 struct ncp_server
*server
= NCP_SERVER(dir
);
995 int error
, result
, len
;
996 __u8 __name
[NCP_MAXPATHLEN
+ 1];
998 DPRINTK("ncp_rmdir: removing %s/%s\n",
999 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
);
1003 if (!ncp_conn_valid(server
))
1007 if (!d_unhashed(dentry
))
1010 len
= sizeof(__name
);
1011 error
= ncp_io2vol(server
, __name
, &len
, dentry
->d_name
.name
,
1012 dentry
->d_name
.len
, !ncp_preserve_case(dir
));
1016 result
= ncp_del_file_or_subdir(server
, dir
, __name
);
1021 case 0x85: /* unauthorized to delete file */
1022 case 0x8A: /* unauthorized to delete file */
1026 case 0x90: /* read only */
1029 case 0x9F: /* in use by another client */
1032 case 0xA0: /* directory not empty */
1035 case 0xFF: /* someone deleted file */
1047 static int ncp_unlink(struct inode
*dir
, struct dentry
*dentry
)
1049 struct inode
*inode
= dentry
->d_inode
;
1050 struct ncp_server
*server
;
1054 server
= NCP_SERVER(dir
);
1055 DPRINTK("ncp_unlink: unlinking %s/%s\n",
1056 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
);
1059 if (!ncp_conn_valid(server
))
1063 * Check whether to close the file ...
1066 PPRINTK("ncp_unlink: closing file\n");
1067 ncp_make_closed(inode
);
1070 error
= ncp_del_file_or_subdir2(server
, dentry
);
1071 #ifdef CONFIG_NCPFS_STRONG
1072 /* 9C is Invalid path.. It should be 8F, 90 - read only, but
1074 if ((error
== 0x9C || error
== 0x90) && server
->m
.flags
& NCP_MOUNT_STRONG
) { /* R/O */
1075 error
= ncp_force_unlink(dir
, dentry
);
1080 DPRINTK("ncp: removed %s/%s\n",
1081 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
);
1087 case 0x8D: /* some files in use */
1088 case 0x8E: /* all files in use */
1091 case 0x8F: /* some read only */
1092 case 0x90: /* all read only */
1093 case 0x9C: /* !!! returned when in-use or read-only by NW4 */
1109 static int ncp_rename(struct inode
*old_dir
, struct dentry
*old_dentry
,
1110 struct inode
*new_dir
, struct dentry
*new_dentry
)
1112 struct ncp_server
*server
= NCP_SERVER(old_dir
);
1114 int old_len
, new_len
;
1115 __u8 __old_name
[NCP_MAXPATHLEN
+ 1], __new_name
[NCP_MAXPATHLEN
+ 1];
1117 DPRINTK("ncp_rename: %s/%s to %s/%s\n",
1118 old_dentry
->d_parent
->d_name
.name
, old_dentry
->d_name
.name
,
1119 new_dentry
->d_parent
->d_name
.name
, new_dentry
->d_name
.name
);
1123 if (!ncp_conn_valid(server
))
1126 ncp_age_dentry(server
, old_dentry
);
1127 ncp_age_dentry(server
, new_dentry
);
1129 old_len
= sizeof(__old_name
);
1130 error
= ncp_io2vol(server
, __old_name
, &old_len
,
1131 old_dentry
->d_name
.name
, old_dentry
->d_name
.len
,
1132 !ncp_preserve_case(old_dir
));
1136 new_len
= sizeof(__new_name
);
1137 error
= ncp_io2vol(server
, __new_name
, &new_len
,
1138 new_dentry
->d_name
.name
, new_dentry
->d_name
.len
,
1139 !ncp_preserve_case(new_dir
));
1143 error
= ncp_ren_or_mov_file_or_subdir(server
, old_dir
, __old_name
,
1144 new_dir
, __new_name
);
1145 #ifdef CONFIG_NCPFS_STRONG
1146 if ((error
== 0x90 || error
== 0x8B || error
== -EACCES
) &&
1147 server
->m
.flags
& NCP_MOUNT_STRONG
) { /* RO */
1148 error
= ncp_force_rename(old_dir
, old_dentry
, __old_name
,
1149 new_dir
, new_dentry
, __new_name
);
1154 DPRINTK("ncp renamed %s -> %s.\n",
1155 old_dentry
->d_name
.name
,new_dentry
->d_name
.name
);
1158 error
= -ENAMETOOLONG
;
1172 static int ncp_mknod(struct inode
* dir
, struct dentry
*dentry
,
1173 int mode
, dev_t rdev
)
1175 if (!new_valid_dev(rdev
))
1177 if (ncp_is_nfs_extras(NCP_SERVER(dir
), NCP_FINFO(dir
)->volNumber
)) {
1178 DPRINTK(KERN_DEBUG
"ncp_mknod: mode = 0%o\n", mode
);
1179 return ncp_create_new(dir
, dentry
, mode
, rdev
, 0);
1181 return -EPERM
; /* Strange, but true */
1184 /* The following routines are taken directly from msdos-fs */
1186 /* Linear day numbers of the respective 1sts in non-leap years. */
1188 static int day_n
[] =
1189 {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 0, 0, 0, 0};
1190 /* Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec */
1193 extern struct timezone sys_tz
;
1195 static int utc2local(int time
)
1197 return time
- sys_tz
.tz_minuteswest
* 60;
1200 static int local2utc(int time
)
1202 return time
+ sys_tz
.tz_minuteswest
* 60;
1205 /* Convert a MS-DOS time/date pair to a UNIX date (seconds since 1 1 70). */
1207 ncp_date_dos2unix(__le16 t
, __le16 d
)
1209 unsigned short time
= le16_to_cpu(t
), date
= le16_to_cpu(d
);
1210 int month
, year
, secs
;
1212 /* first subtract and mask after that... Otherwise, if
1213 date == 0, bad things happen */
1214 month
= ((date
>> 5) - 1) & 15;
1216 secs
= (time
& 31) * 2 + 60 * ((time
>> 5) & 63) + (time
>> 11) * 3600 +
1217 86400 * ((date
& 31) - 1 + day_n
[month
] + (year
/ 4) +
1218 year
* 365 - ((year
& 3) == 0 && month
< 2 ? 1 : 0) + 3653);
1219 /* days since 1.1.70 plus 80's leap day */
1220 return local2utc(secs
);
1224 /* Convert linear UNIX date to a MS-DOS time/date pair. */
1226 ncp_date_unix2dos(int unix_date
, __le16
*time
, __le16
*date
)
1228 int day
, year
, nl_day
, month
;
1230 unix_date
= utc2local(unix_date
);
1231 *time
= cpu_to_le16(
1232 (unix_date
% 60) / 2 + (((unix_date
/ 60) % 60) << 5) +
1233 (((unix_date
/ 3600) % 24) << 11));
1234 day
= unix_date
/ 86400 - 3652;
1236 if ((year
+ 3) / 4 + 365 * year
> day
)
1238 day
-= (year
+ 3) / 4 + 365 * year
;
1239 if (day
== 59 && !(year
& 3)) {
1243 nl_day
= (year
& 3) || day
<= 59 ? day
: day
- 1;
1244 for (month
= 0; month
< 12; month
++)
1245 if (day_n
[month
] > nl_day
)
1248 *date
= cpu_to_le16(nl_day
- day_n
[month
- 1] + 1 + (month
<< 5) + (year
<< 9));