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