fs/ncpfs/inode.c

   1 /*
   2  *  inode.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 Wolfram Pienkoss for NLS
   8  *  Modified 2000 Ben Harris, University of Cambridge for NFS NS meta-info
   9  *
  10  */
  11
  12 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  13
  14 #include <linux/module.h>
  15
  16 #include <linux/uaccess.h>
  17 #include <asm/byteorder.h>
  18
  19 #include <linux/time.h>
  20 #include <linux/kernel.h>
  21 #include <linux/mm.h>
  22 #include <linux/string.h>
  23 #include <linux/stat.h>
  24 #include <linux/errno.h>
  25 #include <linux/file.h>
  26 #include <linux/fcntl.h>
  27 #include <linux/slab.h>
  28 #include <linux/vmalloc.h>
  29 #include <linux/init.h>
  30 #include <linux/vfs.h>
  31 #include <linux/mount.h>
  32 #include <linux/seq_file.h>
  33 #include <linux/namei.h>
  34
  35 #include <net/sock.h>
  36
  37 #include "ncp_fs.h"
  38 #include "getopt.h"
  39
  40 #define NCP_DEFAULT_FILE_MODE 0600
  41 #define NCP_DEFAULT_DIR_MODE 0700
  42 #define NCP_DEFAULT_TIME_OUT 10
  43 #define NCP_DEFAULT_RETRY_COUNT 20
  44
  45 static void ncp_evict_inode(struct inode *);
  46 static void ncp_put_super(struct super_block *);
  47 static int  ncp_statfs(struct dentry *, struct kstatfs *);
  48 static int  ncp_show_options(struct seq_file *, struct dentry *);
  49
  50 static struct kmem_cache * ncp_inode_cachep;
  51
  52 static struct inode *ncp_alloc_inode(struct super_block *sb)
  53 {
  54         struct ncp_inode_info *ei;
  55         ei = (struct ncp_inode_info *)kmem_cache_alloc(ncp_inode_cachep, GFP_KERNEL);
  56         if (!ei)
  57                 return NULL;
  58         return &ei->vfs_inode;
  59 }
  60
  61 static void ncp_i_callback(struct rcu_head *head)
  62 {
  63         struct inode *inode = container_of(head, struct inode, i_rcu);
  64         kmem_cache_free(ncp_inode_cachep, NCP_FINFO(inode));
  65 }
  66
  67 static void ncp_destroy_inode(struct inode *inode)
  68 {
  69         call_rcu(&inode->i_rcu, ncp_i_callback);
  70 }
  71
  72 static void init_once(void *foo)
  73 {
  74         struct ncp_inode_info *ei = (struct ncp_inode_info *) foo;
  75
  76         mutex_init(&ei->open_mutex);
  77         inode_init_once(&ei->vfs_inode);
  78 }
  79
  80 static int init_inodecache(void)
  81 {
  82         ncp_inode_cachep = kmem_cache_create("ncp_inode_cache",
  83                                              sizeof(struct ncp_inode_info),
  84                                              0, (SLAB_RECLAIM_ACCOUNT|
  85                                                 SLAB_MEM_SPREAD|SLAB_ACCOUNT),
  86                                              init_once);
  87         if (ncp_inode_cachep == NULL)
  88                 return -ENOMEM;
  89         return 0;
  90 }
  91
  92 static void destroy_inodecache(void)
  93 {
  94         /*
  95          * Make sure all delayed rcu free inodes are flushed before we
  96          * destroy cache.
  97          */
  98         rcu_barrier();
  99         kmem_cache_destroy(ncp_inode_cachep);
 100 }
 101
 102 static int ncp_remount(struct super_block *sb, int *flags, char* data)
 103 {
 104         sync_filesystem(sb);
 105         *flags |= MS_NODIRATIME;
 106         return 0;
 107 }
 108
 109 static const struct super_operations ncp_sops =
 110 {
 111         .alloc_inode    = ncp_alloc_inode,
 112         .destroy_inode  = ncp_destroy_inode,
 113         .drop_inode     = generic_delete_inode,
 114         .evict_inode    = ncp_evict_inode,
 115         .put_super      = ncp_put_super,
 116         .statfs         = ncp_statfs,
 117         .remount_fs     = ncp_remount,
 118         .show_options   = ncp_show_options,
 119 };
 120
 121 /*
 122  * Fill in the ncpfs-specific information in the inode.
 123  */
 124 static void ncp_update_dirent(struct inode *inode, struct ncp_entry_info *nwinfo)
 125 {
 126         NCP_FINFO(inode)->DosDirNum = nwinfo->i.DosDirNum;
 127         NCP_FINFO(inode)->dirEntNum = nwinfo->i.dirEntNum;
 128         NCP_FINFO(inode)->volNumber = nwinfo->volume;
 129 }
 130
 131 void ncp_update_inode(struct inode *inode, struct ncp_entry_info *nwinfo)
 132 {
 133         ncp_update_dirent(inode, nwinfo);
 134         NCP_FINFO(inode)->nwattr = nwinfo->i.attributes;
 135         NCP_FINFO(inode)->access = nwinfo->access;
 136         memcpy(NCP_FINFO(inode)->file_handle, nwinfo->file_handle,
 137                         sizeof(nwinfo->file_handle));
 138         ncp_dbg(1, "updated %s, volnum=%d, dirent=%u\n",
 139                 nwinfo->i.entryName, NCP_FINFO(inode)->volNumber,
 140                 NCP_FINFO(inode)->dirEntNum);
 141 }
 142
 143 static void ncp_update_dates(struct inode *inode, struct nw_info_struct *nwi)
 144 {
 145         /* NFS namespace mode overrides others if it's set. */
 146         ncp_dbg(1, "(%s) nfs.mode=0%o\n", nwi->entryName, nwi->nfs.mode);
 147         if (nwi->nfs.mode) {
 148                 /* XXX Security? */
 149                 inode->i_mode = nwi->nfs.mode;
 150         }
 151
 152         inode->i_blocks = (i_size_read(inode) + NCP_BLOCK_SIZE - 1) >> NCP_BLOCK_SHIFT;
 153
 154         inode->i_mtime.tv_sec = ncp_date_dos2unix(nwi->modifyTime, nwi->modifyDate);
 155         inode->i_ctime.tv_sec = ncp_date_dos2unix(nwi->creationTime, nwi->creationDate);
 156         inode->i_atime.tv_sec = ncp_date_dos2unix(0, nwi->lastAccessDate);
 157         inode->i_atime.tv_nsec = 0;
 158         inode->i_mtime.tv_nsec = 0;
 159         inode->i_ctime.tv_nsec = 0;
 160 }
 161
 162 static void ncp_update_attrs(struct inode *inode, struct ncp_entry_info *nwinfo)
 163 {
 164         struct nw_info_struct *nwi = &nwinfo->i;
 165         struct ncp_server *server = NCP_SERVER(inode);
 166
 167         if (nwi->attributes & aDIR) {
 168                 inode->i_mode = server->m.dir_mode;
 169                 /* for directories dataStreamSize seems to be some
 170                    Object ID ??? */
 171                 i_size_write(inode, NCP_BLOCK_SIZE);
 172         } else {
 173                 u32 size;
 174
 175                 inode->i_mode = server->m.file_mode;
 176                 size = le32_to_cpu(nwi->dataStreamSize);
 177                 i_size_write(inode, size);
 178 #ifdef CONFIG_NCPFS_EXTRAS
 179                 if ((server->m.flags & (NCP_MOUNT_EXTRAS|NCP_MOUNT_SYMLINKS))
 180                  && (nwi->attributes & aSHARED)) {
 181                         switch (nwi->attributes & (aHIDDEN|aSYSTEM)) {
 182                                 case aHIDDEN:
 183                                         if (server->m.flags & NCP_MOUNT_SYMLINKS) {
 184                                                 if (/* (size >= NCP_MIN_SYMLINK_SIZE)
 185                                                  && */ (size <= NCP_MAX_SYMLINK_SIZE)) {
 186                                                         inode->i_mode = (inode->i_mode & ~S_IFMT) | S_IFLNK;
 187                                                         NCP_FINFO(inode)->flags |= NCPI_KLUDGE_SYMLINK;
 188                                                         break;
 189                                                 }
 190                                         }
 191                                         /* FALLTHROUGH */
 192                                 case 0:
 193                                         if (server->m.flags & NCP_MOUNT_EXTRAS)
 194                                                 inode->i_mode |= S_IRUGO;
 195                                         break;
 196                                 case aSYSTEM:
 197                                         if (server->m.flags & NCP_MOUNT_EXTRAS)
 198                                                 inode->i_mode |= (inode->i_mode >> 2) & S_IXUGO;
 199                                         break;
 200                                 /* case aSYSTEM|aHIDDEN: */
 201                                 default:
 202                                         /* reserved combination */
 203                                         break;
 204                         }
 205                 }
 206 #endif
 207         }
 208         if (nwi->attributes & aRONLY) inode->i_mode &= ~S_IWUGO;
 209 }
 210
 211 void ncp_update_inode2(struct inode* inode, struct ncp_entry_info *nwinfo)
 212 {
 213         NCP_FINFO(inode)->flags = 0;
 214         if (!atomic_read(&NCP_FINFO(inode)->opened)) {
 215                 NCP_FINFO(inode)->nwattr = nwinfo->i.attributes;
 216                 ncp_update_attrs(inode, nwinfo);
 217         }
 218
 219         ncp_update_dates(inode, &nwinfo->i);
 220         ncp_update_dirent(inode, nwinfo);
 221 }
 222
 223 /*
 224  * Fill in the inode based on the ncp_entry_info structure.  Used only for brand new inodes.
 225  */
 226 static void ncp_set_attr(struct inode *inode, struct ncp_entry_info *nwinfo)
 227 {
 228         struct ncp_server *server = NCP_SERVER(inode);
 229
 230         NCP_FINFO(inode)->flags = 0;
 231
 232         ncp_update_attrs(inode, nwinfo);
 233
 234         ncp_dbg(2, "inode->i_mode = %u\n", inode->i_mode);
 235
 236         set_nlink(inode, 1);
 237         inode->i_uid = server->m.uid;
 238         inode->i_gid = server->m.gid;
 239
 240         ncp_update_dates(inode, &nwinfo->i);
 241         ncp_update_inode(inode, nwinfo);
 242 }
 243
 244 #if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
 245 static const struct inode_operations ncp_symlink_inode_operations = {
 246         .get_link       = page_get_link,
 247         .setattr        = ncp_notify_change,
 248 };
 249 #endif
 250
 251 /*
 252  * Get a new inode.
 253  */
 254 struct inode *
 255 ncp_iget(struct super_block *sb, struct ncp_entry_info *info)
 256 {
 257         struct inode *inode;
 258
 259         if (info == NULL) {
 260                 pr_err("%s: info is NULL\n", __func__);
 261                 return NULL;
 262         }
 263
 264         inode = new_inode(sb);
 265         if (inode) {
 266                 atomic_set(&NCP_FINFO(inode)->opened, info->opened);
 267
 268                 inode->i_ino = info->ino;
 269                 ncp_set_attr(inode, info);
 270                 if (S_ISREG(inode->i_mode)) {
 271                         inode->i_op = &ncp_file_inode_operations;
 272                         inode->i_fop = &ncp_file_operations;
 273                 } else if (S_ISDIR(inode->i_mode)) {
 274                         inode->i_op = &ncp_dir_inode_operations;
 275                         inode->i_fop = &ncp_dir_operations;
 276 #ifdef CONFIG_NCPFS_NFS_NS
 277                 } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) || S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
 278                         init_special_inode(inode, inode->i_mode,
 279                                 new_decode_dev(info->i.nfs.rdev));
 280 #endif
 281 #if defined(CONFIG_NCPFS_EXTRAS) || defined(CONFIG_NCPFS_NFS_NS)
 282                 } else if (S_ISLNK(inode->i_mode)) {
 283                         inode->i_op = &ncp_symlink_inode_operations;
 284                         inode_nohighmem(inode);
 285                         inode->i_data.a_ops = &ncp_symlink_aops;
 286 #endif
 287                 } else {
 288                         make_bad_inode(inode);
 289                 }
 290                 insert_inode_hash(inode);
 291         } else
 292                 pr_err("%s: iget failed!\n", __func__);
 293         return inode;
 294 }
 295
 296 static void
 297 ncp_evict_inode(struct inode *inode)
 298 {
 299         truncate_inode_pages_final(&inode->i_data);
 300         clear_inode(inode);
 301
 302         if (S_ISDIR(inode->i_mode)) {
 303                 ncp_dbg(2, "put directory %ld\n", inode->i_ino);
 304         }
 305
 306         if (ncp_make_closed(inode) != 0) {
 307                 /* We can't do anything but complain. */
 308                 pr_err("%s: could not close\n", __func__);
 309         }
 310 }
 311
 312 static void ncp_stop_tasks(struct ncp_server *server) {
 313         struct sock* sk = server->ncp_sock->sk;
 314
 315         lock_sock(sk);
 316         sk->sk_error_report = server->error_report;
 317         sk->sk_data_ready   = server->data_ready;
 318         sk->sk_write_space  = server->write_space;
 319         release_sock(sk);
 320         del_timer_sync(&server->timeout_tm);
 321
 322         flush_work(&server->rcv.tq);
 323         if (sk->sk_socket->type == SOCK_STREAM)
 324                 flush_work(&server->tx.tq);
 325         else
 326                 flush_work(&server->timeout_tq);
 327 }
 328
 329 static int  ncp_show_options(struct seq_file *seq, struct dentry *root)
 330 {
 331         struct ncp_server *server = NCP_SBP(root->d_sb);
 332         unsigned int tmp;
 333
 334         if (!uid_eq(server->m.uid, GLOBAL_ROOT_UID))
 335                 seq_printf(seq, ",uid=%u",
 336                            from_kuid_munged(&init_user_ns, server->m.uid));
 337         if (!gid_eq(server->m.gid, GLOBAL_ROOT_GID))
 338                 seq_printf(seq, ",gid=%u",
 339                            from_kgid_munged(&init_user_ns, server->m.gid));
 340         if (!uid_eq(server->m.mounted_uid, GLOBAL_ROOT_UID))
 341                 seq_printf(seq, ",owner=%u",
 342                            from_kuid_munged(&init_user_ns, server->m.mounted_uid));
 343         tmp = server->m.file_mode & S_IALLUGO;
 344         if (tmp != NCP_DEFAULT_FILE_MODE)
 345                 seq_printf(seq, ",mode=0%o", tmp);
 346         tmp = server->m.dir_mode & S_IALLUGO;
 347         if (tmp != NCP_DEFAULT_DIR_MODE)
 348                 seq_printf(seq, ",dirmode=0%o", tmp);
 349         if (server->m.time_out != NCP_DEFAULT_TIME_OUT * HZ / 100) {
 350                 tmp = server->m.time_out * 100 / HZ;
 351                 seq_printf(seq, ",timeout=%u", tmp);
 352         }
 353         if (server->m.retry_count != NCP_DEFAULT_RETRY_COUNT)
 354                 seq_printf(seq, ",retry=%u", server->m.retry_count);
 355         if (server->m.flags != 0)
 356                 seq_printf(seq, ",flags=%lu", server->m.flags);
 357         if (server->m.wdog_pid != NULL)
 358                 seq_printf(seq, ",wdogpid=%u", pid_vnr(server->m.wdog_pid));
 359
 360         return 0;
 361 }
 362
 363 static const struct ncp_option ncp_opts[] = {
 364         { "uid",        OPT_INT,        'u' },
 365         { "gid",        OPT_INT,        'g' },
 366         { "owner",      OPT_INT,        'o' },
 367         { "mode",       OPT_INT,        'm' },
 368         { "dirmode",    OPT_INT,        'd' },
 369         { "timeout",    OPT_INT,        't' },
 370         { "retry",      OPT_INT,        'r' },
 371         { "flags",      OPT_INT,        'f' },
 372         { "wdogpid",    OPT_INT,        'w' },
 373         { "ncpfd",      OPT_INT,        'n' },
 374         { "infofd",     OPT_INT,        'i' },  /* v5 */
 375         { "version",    OPT_INT,        'v' },
 376         { NULL,         0,              0 } };
 377
 378 static int ncp_parse_options(struct ncp_mount_data_kernel *data, char *options) {
 379         int optval;
 380         char *optarg;
 381         unsigned long optint;
 382         int version = 0;
 383         int ret;
 384
 385         data->flags = 0;
 386         data->int_flags = 0;
 387         data->mounted_uid = GLOBAL_ROOT_UID;
 388         data->wdog_pid = NULL;
 389         data->ncp_fd = ~0;
 390         data->time_out = NCP_DEFAULT_TIME_OUT;
 391         data->retry_count = NCP_DEFAULT_RETRY_COUNT;
 392         data->uid = GLOBAL_ROOT_UID;
 393         data->gid = GLOBAL_ROOT_GID;
 394         data->file_mode = NCP_DEFAULT_FILE_MODE;
 395         data->dir_mode = NCP_DEFAULT_DIR_MODE;
 396         data->info_fd = -1;
 397         data->mounted_vol[0] = 0;
 398
 399         while ((optval = ncp_getopt("ncpfs", &options, ncp_opts, NULL, &optarg, &optint)) != 0) {
 400                 ret = optval;
 401                 if (ret < 0)
 402                         goto err;
 403                 switch (optval) {
 404                         case 'u':
 405                                 data->uid = make_kuid(current_user_ns(), optint);
 406                                 if (!uid_valid(data->uid)) {
 407                                         ret = -EINVAL;
 408                                         goto err;
 409                                 }
 410                                 break;
 411                         case 'g':
 412                                 data->gid = make_kgid(current_user_ns(), optint);
 413                                 if (!gid_valid(data->gid)) {
 414                                         ret = -EINVAL;
 415                                         goto err;
 416                                 }
 417                                 break;
 418                         case 'o':
 419                                 data->mounted_uid = make_kuid(current_user_ns(), optint);
 420                                 if (!uid_valid(data->mounted_uid)) {
 421                                         ret = -EINVAL;
 422                                         goto err;
 423                                 }
 424                                 break;
 425                         case 'm':
 426                                 data->file_mode = optint;
 427                                 break;
 428                         case 'd':
 429                                 data->dir_mode = optint;
 430                                 break;
 431                         case 't':
 432                                 data->time_out = optint;
 433                                 break;
 434                         case 'r':
 435                                 data->retry_count = optint;
 436                                 break;
 437                         case 'f':
 438                                 data->flags = optint;
 439                                 break;
 440                         case 'w':
 441                                 data->wdog_pid = find_get_pid(optint);
 442                                 break;
 443                         case 'n':
 444                                 data->ncp_fd = optint;
 445                                 break;
 446                         case 'i':
 447                                 data->info_fd = optint;
 448                                 break;
 449                         case 'v':
 450                                 ret = -ECHRNG;
 451                                 if (optint < NCP_MOUNT_VERSION_V4)
 452                                         goto err;
 453                                 if (optint > NCP_MOUNT_VERSION_V5)
 454                                         goto err;
 455                                 version = optint;
 456                                 break;
 457
 458                 }
 459         }
 460         return 0;
 461 err:
 462         put_pid(data->wdog_pid);
 463         data->wdog_pid = NULL;
 464         return ret;
 465 }
 466
 467 static int ncp_fill_super(struct super_block *sb, void *raw_data, int silent)
 468 {
 469         struct ncp_mount_data_kernel data;
 470         struct ncp_server *server;
 471         struct inode *root_inode;
 472         struct socket *sock;
 473         int error;
 474         int default_bufsize;
 475 #ifdef CONFIG_NCPFS_PACKET_SIGNING
 476         int options;
 477 #endif
 478         struct ncp_entry_info finfo;
 479
 480         memset(&data, 0, sizeof(data));
 481         server = kzalloc(sizeof(struct ncp_server), GFP_KERNEL);
 482         if (!server)
 483                 return -ENOMEM;
 484         sb->s_fs_info = server;
 485
 486         error = -EFAULT;
 487         if (raw_data == NULL)
 488                 goto out;
 489         switch (*(int*)raw_data) {
 490                 case NCP_MOUNT_VERSION:
 491                         {
 492                                 struct ncp_mount_data* md = (struct ncp_mount_data*)raw_data;
 493
 494                                 data.flags = md->flags;
 495                                 data.int_flags = NCP_IMOUNT_LOGGEDIN_POSSIBLE;
 496                                 data.mounted_uid = make_kuid(current_user_ns(), md->mounted_uid);
 497                                 data.wdog_pid = find_get_pid(md->wdog_pid);
 498                                 data.ncp_fd = md->ncp_fd;
 499                                 data.time_out = md->time_out;
 500                                 data.retry_count = md->retry_count;
 501                                 data.uid = make_kuid(current_user_ns(), md->uid);
 502                                 data.gid = make_kgid(current_user_ns(), md->gid);
 503                                 data.file_mode = md->file_mode;
 504                                 data.dir_mode = md->dir_mode;
 505                                 data.info_fd = -1;
 506                                 memcpy(data.mounted_vol, md->mounted_vol,
 507                                         NCP_VOLNAME_LEN+1);
 508                         }
 509                         break;
 510                 case NCP_MOUNT_VERSION_V4:
 511                         {
 512                                 struct ncp_mount_data_v4* md = (struct ncp_mount_data_v4*)raw_data;
 513
 514                                 data.flags = md->flags;
 515                                 data.mounted_uid = make_kuid(current_user_ns(), md->mounted_uid);
 516                                 data.wdog_pid = find_get_pid(md->wdog_pid);
 517                                 data.ncp_fd = md->ncp_fd;
 518                                 data.time_out = md->time_out;
 519                                 data.retry_count = md->retry_count;
 520                                 data.uid = make_kuid(current_user_ns(), md->uid);
 521                                 data.gid = make_kgid(current_user_ns(), md->gid);
 522                                 data.file_mode = md->file_mode;
 523                                 data.dir_mode = md->dir_mode;
 524                                 data.info_fd = -1;
 525                         }
 526                         break;
 527                 default:
 528                         error = -ECHRNG;
 529                         if (memcmp(raw_data, "vers", 4) == 0) {
 530                                 error = ncp_parse_options(&data, raw_data);
 531                         }
 532                         if (error)
 533                                 goto out;
 534                         break;
 535         }
 536         error = -EINVAL;
 537         if (!uid_valid(data.mounted_uid) || !uid_valid(data.uid) ||
 538             !gid_valid(data.gid))
 539                 goto out;
 540         sock = sockfd_lookup(data.ncp_fd, &error);
 541         if (!sock)
 542                 goto out;
 543
 544         if (sock->type == SOCK_STREAM)
 545                 default_bufsize = 0xF000;
 546         else
 547                 default_bufsize = 1024;
 548
 549         sb->s_flags |= MS_NODIRATIME;   /* probably even noatime */
 550         sb->s_maxbytes = 0xFFFFFFFFU;
 551         sb->s_blocksize = 1024; /* Eh...  Is this correct? */
 552         sb->s_blocksize_bits = 10;
 553         sb->s_magic = NCP_SUPER_MAGIC;
 554         sb->s_op = &ncp_sops;
 555         sb->s_d_op = &ncp_dentry_operations;
 556         sb->s_bdi = &server->bdi;
 557
 558         server = NCP_SBP(sb);
 559         memset(server, 0, sizeof(*server));
 560
 561         error = bdi_setup_and_register(&server->bdi, "ncpfs");
 562         if (error)
 563                 goto out_fput;
 564
 565         server->ncp_sock = sock;
 566
 567         if (data.info_fd != -1) {
 568                 struct socket *info_sock = sockfd_lookup(data.info_fd, &error);
 569                 if (!info_sock)
 570                         goto out_bdi;
 571                 server->info_sock = info_sock;
 572                 error = -EBADFD;
 573                 if (info_sock->type != SOCK_STREAM)
 574                         goto out_fput2;
 575         }
 576
 577 /*      server->lock = 0;       */
 578         mutex_init(&server->mutex);
 579         server->packet = NULL;
 580 /*      server->buffer_size = 0;        */
 581 /*      server->conn_status = 0;        */
 582 /*      server->root_dentry = NULL;     */
 583 /*      server->root_setuped = 0;       */
 584         mutex_init(&server->root_setup_lock);
 585 #ifdef CONFIG_NCPFS_PACKET_SIGNING
 586 /*      server->sign_wanted = 0;        */
 587 /*      server->sign_active = 0;        */
 588 #endif
 589         init_rwsem(&server->auth_rwsem);
 590         server->auth.auth_type = NCP_AUTH_NONE;
 591 /*      server->auth.object_name_len = 0;       */
 592 /*      server->auth.object_name = NULL;        */
 593 /*      server->auth.object_type = 0;           */
 594 /*      server->priv.len = 0;                   */
 595 /*      server->priv.data = NULL;               */
 596
 597         server->m = data;
 598         /* Although anything producing this is buggy, it happens
 599            now because of PATH_MAX changes.. */
 600         if (server->m.time_out < 1) {
 601                 server->m.time_out = 10;
 602                 pr_info("You need to recompile your ncpfs utils..\n");
 603         }
 604         server->m.time_out = server->m.time_out * HZ / 100;
 605         server->m.file_mode = (server->m.file_mode & S_IRWXUGO) | S_IFREG;
 606         server->m.dir_mode = (server->m.dir_mode & S_IRWXUGO) | S_IFDIR;
 607
 608 #ifdef CONFIG_NCPFS_NLS
 609         /* load the default NLS charsets */
 610         server->nls_vol = load_nls_default();
 611         server->nls_io = load_nls_default();
 612 #endif /* CONFIG_NCPFS_NLS */
 613
 614         atomic_set(&server->dentry_ttl, 0);     /* no caching */
 615
 616         INIT_LIST_HEAD(&server->tx.requests);
 617         mutex_init(&server->rcv.creq_mutex);
 618         server->tx.creq         = NULL;
 619         server->rcv.creq        = NULL;
 620
 621         init_timer(&server->timeout_tm);
 622 #undef NCP_PACKET_SIZE
 623 #define NCP_PACKET_SIZE 131072
 624         error = -ENOMEM;
 625         server->packet_size = NCP_PACKET_SIZE;
 626         server->packet = vmalloc(NCP_PACKET_SIZE);
 627         if (server->packet == NULL)
 628                 goto out_nls;
 629         server->txbuf = vmalloc(NCP_PACKET_SIZE);
 630         if (server->txbuf == NULL)
 631                 goto out_packet;
 632         server->rxbuf = vmalloc(NCP_PACKET_SIZE);
 633         if (server->rxbuf == NULL)
 634                 goto out_txbuf;
 635
 636         lock_sock(sock->sk);
 637         server->data_ready      = sock->sk->sk_data_ready;
 638         server->write_space     = sock->sk->sk_write_space;
 639         server->error_report    = sock->sk->sk_error_report;
 640         sock->sk->sk_user_data  = server;
 641         sock->sk->sk_data_ready   = ncp_tcp_data_ready;
 642         sock->sk->sk_error_report = ncp_tcp_error_report;
 643         if (sock->type == SOCK_STREAM) {
 644                 server->rcv.ptr = (unsigned char*)&server->rcv.buf;
 645                 server->rcv.len = 10;
 646                 server->rcv.state = 0;
 647                 INIT_WORK(&server->rcv.tq, ncp_tcp_rcv_proc);
 648                 INIT_WORK(&server->tx.tq, ncp_tcp_tx_proc);
 649                 sock->sk->sk_write_space = ncp_tcp_write_space;
 650         } else {
 651                 INIT_WORK(&server->rcv.tq, ncpdgram_rcv_proc);
 652                 INIT_WORK(&server->timeout_tq, ncpdgram_timeout_proc);
 653                 server->timeout_tm.data = (unsigned long)server;
 654                 server->timeout_tm.function = ncpdgram_timeout_call;
 655         }
 656         release_sock(sock->sk);
 657
 658         ncp_lock_server(server);
 659         error = ncp_connect(server);
 660         ncp_unlock_server(server);
 661         if (error < 0)
 662                 goto out_rxbuf;
 663         ncp_dbg(1, "NCP_SBP(sb) = %p\n", NCP_SBP(sb));
 664
 665         error = -EMSGSIZE;      /* -EREMOTESIDEINCOMPATIBLE */
 666 #ifdef CONFIG_NCPFS_PACKET_SIGNING
 667         if (ncp_negotiate_size_and_options(server, default_bufsize,
 668                 NCP_DEFAULT_OPTIONS, &(server->buffer_size), &options) == 0)
 669         {
 670                 if (options != NCP_DEFAULT_OPTIONS)
 671                 {
 672                         if (ncp_negotiate_size_and_options(server,
 673                                 default_bufsize,
 674                                 options & 2,
 675                                 &(server->buffer_size), &options) != 0)
 676
 677                         {
 678                                 goto out_disconnect;
 679                         }
 680                 }
 681                 ncp_lock_server(server);
 682                 if (options & 2)
 683                         server->sign_wanted = 1;
 684                 ncp_unlock_server(server);
 685         }
 686         else
 687 #endif  /* CONFIG_NCPFS_PACKET_SIGNING */
 688         if (ncp_negotiate_buffersize(server, default_bufsize,
 689                                      &(server->buffer_size)) != 0)
 690                 goto out_disconnect;
 691         ncp_dbg(1, "bufsize = %d\n", server->buffer_size);
 692
 693         memset(&finfo, 0, sizeof(finfo));
 694         finfo.i.attributes      = aDIR;
 695         finfo.i.dataStreamSize  = 0;    /* ignored */
 696         finfo.i.dirEntNum       = 0;
 697         finfo.i.DosDirNum       = 0;
 698 #ifdef CONFIG_NCPFS_SMALLDOS
 699         finfo.i.NSCreator       = NW_NS_DOS;
 700 #endif
 701         finfo.volume            = NCP_NUMBER_OF_VOLUMES;
 702         /* set dates of mountpoint to Jan 1, 1986; 00:00 */
 703         finfo.i.creationTime    = finfo.i.modifyTime
 704                                 = cpu_to_le16(0x0000);
 705         finfo.i.creationDate    = finfo.i.modifyDate
 706                                 = finfo.i.lastAccessDate
 707                                 = cpu_to_le16(0x0C21);
 708         finfo.i.nameLen         = 0;
 709         finfo.i.entryName[0]    = '\0';
 710
 711         finfo.opened            = 0;
 712         finfo.ino               = 2;    /* tradition */
 713
 714         server->name_space[finfo.volume] = NW_NS_DOS;
 715
 716         error = -ENOMEM;
 717         root_inode = ncp_iget(sb, &finfo);
 718         if (!root_inode)
 719                 goto out_disconnect;
 720         ncp_dbg(1, "root vol=%d\n", NCP_FINFO(root_inode)->volNumber);
 721         sb->s_root = d_make_root(root_inode);
 722         if (!sb->s_root)
 723                 goto out_disconnect;
 724         return 0;
 725
 726 out_disconnect:
 727         ncp_lock_server(server);
 728         ncp_disconnect(server);
 729         ncp_unlock_server(server);
 730 out_rxbuf:
 731         ncp_stop_tasks(server);
 732         vfree(server->rxbuf);
 733 out_txbuf:
 734         vfree(server->txbuf);
 735 out_packet:
 736         vfree(server->packet);
 737 out_nls:
 738 #ifdef CONFIG_NCPFS_NLS
 739         unload_nls(server->nls_io);
 740         unload_nls(server->nls_vol);
 741 #endif
 742         mutex_destroy(&server->rcv.creq_mutex);
 743         mutex_destroy(&server->root_setup_lock);
 744         mutex_destroy(&server->mutex);
 745 out_fput2:
 746         if (server->info_sock)
 747                 sockfd_put(server->info_sock);
 748 out_bdi:
 749         bdi_destroy(&server->bdi);
 750 out_fput:
 751         sockfd_put(sock);
 752 out:
 753         put_pid(data.wdog_pid);
 754         sb->s_fs_info = NULL;
 755         kfree(server);
 756         return error;
 757 }
 758
 759 static void delayed_free(struct rcu_head *p)
 760 {
 761         struct ncp_server *server = container_of(p, struct ncp_server, rcu);
 762 #ifdef CONFIG_NCPFS_NLS
 763         /* unload the NLS charsets */
 764         unload_nls(server->nls_vol);
 765         unload_nls(server->nls_io);
 766 #endif /* CONFIG_NCPFS_NLS */
 767         kfree(server);
 768 }
 769
 770 static void ncp_put_super(struct super_block *sb)
 771 {
 772         struct ncp_server *server = NCP_SBP(sb);
 773
 774         ncp_lock_server(server);
 775         ncp_disconnect(server);
 776         ncp_unlock_server(server);
 777
 778         ncp_stop_tasks(server);
 779
 780         mutex_destroy(&server->rcv.creq_mutex);
 781         mutex_destroy(&server->root_setup_lock);
 782         mutex_destroy(&server->mutex);
 783
 784         if (server->info_sock)
 785                 sockfd_put(server->info_sock);
 786         sockfd_put(server->ncp_sock);
 787         kill_pid(server->m.wdog_pid, SIGTERM, 1);
 788         put_pid(server->m.wdog_pid);
 789
 790         bdi_destroy(&server->bdi);
 791         kfree(server->priv.data);
 792         kfree(server->auth.object_name);
 793         vfree(server->rxbuf);
 794         vfree(server->txbuf);
 795         vfree(server->packet);
 796         call_rcu(&server->rcu, delayed_free);
 797 }
 798
 799 static int ncp_statfs(struct dentry *dentry, struct kstatfs *buf)
 800 {
 801         struct dentry* d;
 802         struct inode* i;
 803         struct ncp_inode_info* ni;
 804         struct ncp_server* s;
 805         struct ncp_volume_info vi;
 806         struct super_block *sb = dentry->d_sb;
 807         int err;
 808         __u8 dh;
 809
 810         d = sb->s_root;
 811         if (!d) {
 812                 goto dflt;
 813         }
 814         i = d_inode(d);
 815         if (!i) {
 816                 goto dflt;
 817         }
 818         ni = NCP_FINFO(i);
 819         if (!ni) {
 820                 goto dflt;
 821         }
 822         s = NCP_SBP(sb);
 823         if (!s) {
 824                 goto dflt;
 825         }
 826         if (!s->m.mounted_vol[0]) {
 827                 goto dflt;
 828         }
 829
 830         err = ncp_dirhandle_alloc(s, ni->volNumber, ni->DosDirNum, &dh);
 831         if (err) {
 832                 goto dflt;
 833         }
 834         err = ncp_get_directory_info(s, dh, &vi);
 835         ncp_dirhandle_free(s, dh);
 836         if (err) {
 837                 goto dflt;
 838         }
 839         buf->f_type = NCP_SUPER_MAGIC;
 840         buf->f_bsize = vi.sectors_per_block * 512;
 841         buf->f_blocks = vi.total_blocks;
 842         buf->f_bfree = vi.free_blocks;
 843         buf->f_bavail = vi.free_blocks;
 844         buf->f_files = vi.total_dir_entries;
 845         buf->f_ffree = vi.available_dir_entries;
 846         buf->f_namelen = 12;
 847         return 0;
 848
 849         /* We cannot say how much disk space is left on a mounted
 850            NetWare Server, because free space is distributed over
 851            volumes, and the current user might have disk quotas. So
 852            free space is not that simple to determine. Our decision
 853            here is to err conservatively. */
 854
 855 dflt:;
 856         buf->f_type = NCP_SUPER_MAGIC;
 857         buf->f_bsize = NCP_BLOCK_SIZE;
 858         buf->f_blocks = 0;
 859         buf->f_bfree = 0;
 860         buf->f_bavail = 0;
 861         buf->f_namelen = 12;
 862         return 0;
 863 }
 864
 865 int ncp_notify_change(struct dentry *dentry, struct iattr *attr)
 866 {
 867         struct inode *inode = d_inode(dentry);
 868         int result = 0;
 869         __le32 info_mask;
 870         struct nw_modify_dos_info info;
 871         struct ncp_server *server;
 872
 873         result = -EIO;
 874
 875         server = NCP_SERVER(inode);
 876         if (!server)    /* How this could happen? */
 877                 goto out;
 878
 879         result = -EPERM;
 880         if (IS_DEADDIR(d_inode(dentry)))
 881                 goto out;
 882
 883         /* ageing the dentry to force validation */
 884         ncp_age_dentry(server, dentry);
 885
 886         result = setattr_prepare(dentry, attr);
 887         if (result < 0)
 888                 goto out;
 889
 890         result = -EPERM;
 891         if ((attr->ia_valid & ATTR_UID) && !uid_eq(attr->ia_uid, server->m.uid))
 892                 goto out;
 893
 894         if ((attr->ia_valid & ATTR_GID) && !gid_eq(attr->ia_gid, server->m.gid))
 895                 goto out;
 896
 897         if (((attr->ia_valid & ATTR_MODE) &&
 898              (attr->ia_mode &
 899               ~(S_IFREG | S_IFDIR | S_IRWXUGO))))
 900                 goto out;
 901
 902         info_mask = 0;
 903         memset(&info, 0, sizeof(info));
 904
 905 #if 1
 906         if ((attr->ia_valid & ATTR_MODE) != 0)
 907         {
 908                 umode_t newmode = attr->ia_mode;
 909
 910                 info_mask |= DM_ATTRIBUTES;
 911
 912                 if (S_ISDIR(inode->i_mode)) {
 913                         newmode &= server->m.dir_mode;
 914                 } else {
 915 #ifdef CONFIG_NCPFS_EXTRAS
 916                         if (server->m.flags & NCP_MOUNT_EXTRAS) {
 917                                 /* any non-default execute bit set */
 918                                 if (newmode & ~server->m.file_mode & S_IXUGO)
 919                                         info.attributes |= aSHARED | aSYSTEM;
 920                                 /* read for group/world and not in default file_mode */
 921                                 else if (newmode & ~server->m.file_mode & S_IRUGO)
 922                                         info.attributes |= aSHARED;
 923                         } else
 924 #endif
 925                                 newmode &= server->m.file_mode;
 926                 }
 927                 if (newmode & S_IWUGO)
 928                         info.attributes &= ~(aRONLY|aRENAMEINHIBIT|aDELETEINHIBIT);
 929                 else
 930                         info.attributes |=  (aRONLY|aRENAMEINHIBIT|aDELETEINHIBIT);
 931
 932 #ifdef CONFIG_NCPFS_NFS_NS
 933                 if (ncp_is_nfs_extras(server, NCP_FINFO(inode)->volNumber)) {
 934                         result = ncp_modify_nfs_info(server,
 935                                                      NCP_FINFO(inode)->volNumber,
 936                                                      NCP_FINFO(inode)->dirEntNum,
 937                                                      attr->ia_mode, 0);
 938                         if (result != 0)
 939                                 goto out;
 940                         info.attributes &= ~(aSHARED | aSYSTEM);
 941                         {
 942                                 /* mark partial success */
 943                                 struct iattr tmpattr;
 944
 945                                 tmpattr.ia_valid = ATTR_MODE;
 946                                 tmpattr.ia_mode = attr->ia_mode;
 947
 948                                 setattr_copy(inode, &tmpattr);
 949                                 mark_inode_dirty(inode);
 950                         }
 951                 }
 952 #endif
 953         }
 954 #endif
 955
 956         /* Do SIZE before attributes, otherwise mtime together with size does not work...
 957          */
 958         if ((attr->ia_valid & ATTR_SIZE) != 0) {
 959                 int written;
 960
 961                 ncp_dbg(1, "trying to change size to %llu\n", attr->ia_size);
 962
 963                 if ((result = ncp_make_open(inode, O_WRONLY)) < 0) {
 964                         result = -EACCES;
 965                         goto out;
 966                 }
 967                 ncp_write_kernel(NCP_SERVER(inode), NCP_FINFO(inode)->file_handle,
 968                           attr->ia_size, 0, "", &written);
 969
 970                 /* According to ndir, the changes only take effect after
 971                    closing the file */
 972                 ncp_inode_close(inode);
 973                 result = ncp_make_closed(inode);
 974                 if (result)
 975                         goto out;
 976
 977                 if (attr->ia_size != i_size_read(inode)) {
 978                         truncate_setsize(inode, attr->ia_size);
 979                         mark_inode_dirty(inode);
 980                 }
 981         }
 982         if ((attr->ia_valid & ATTR_CTIME) != 0) {
 983                 info_mask |= (DM_CREATE_TIME | DM_CREATE_DATE);
 984                 ncp_date_unix2dos(attr->ia_ctime.tv_sec,
 985                              &info.creationTime, &info.creationDate);
 986         }
 987         if ((attr->ia_valid & ATTR_MTIME) != 0) {
 988                 info_mask |= (DM_MODIFY_TIME | DM_MODIFY_DATE);
 989                 ncp_date_unix2dos(attr->ia_mtime.tv_sec,
 990                                   &info.modifyTime, &info.modifyDate);
 991         }
 992         if ((attr->ia_valid & ATTR_ATIME) != 0) {
 993                 __le16 dummy;
 994                 info_mask |= (DM_LAST_ACCESS_DATE);
 995                 ncp_date_unix2dos(attr->ia_atime.tv_sec,
 996                                   &dummy, &info.lastAccessDate);
 997         }
 998         if (info_mask != 0) {
 999                 result = ncp_modify_file_or_subdir_dos_info(NCP_SERVER(inode),
1000                                       inode, info_mask, &info);
1001                 if (result != 0) {
1002                         if (info_mask == (DM_CREATE_TIME | DM_CREATE_DATE)) {
1003                                 /* NetWare seems not to allow this. I
1004                                    do not know why. So, just tell the
1005                                    user everything went fine. This is
1006                                    a terrible hack, but I do not know
1007                                    how to do this correctly. */
1008                                 result = 0;
1009                         } else
1010                                 goto out;
1011                 }
1012 #ifdef CONFIG_NCPFS_STRONG
1013                 if ((!result) && (info_mask & DM_ATTRIBUTES))
1014                         NCP_FINFO(inode)->nwattr = info.attributes;
1015 #endif
1016         }
1017         if (result)
1018                 goto out;
1019
1020         setattr_copy(inode, attr);
1021         mark_inode_dirty(inode);
1022
1023 out:
1024         if (result > 0)
1025                 result = -EACCES;
1026         return result;
1027 }
1028
1029 static struct dentry *ncp_mount(struct file_system_type *fs_type,
1030         int flags, const char *dev_name, void *data)
1031 {
1032         return mount_nodev(fs_type, flags, data, ncp_fill_super);
1033 }
1034
1035 static struct file_system_type ncp_fs_type = {
1036         .owner          = THIS_MODULE,
1037         .name           = "ncpfs",
1038         .mount          = ncp_mount,
1039         .kill_sb        = kill_anon_super,
1040         .fs_flags       = FS_BINARY_MOUNTDATA,
1041 };
1042 MODULE_ALIAS_FS("ncpfs");
1043
1044 static int __init init_ncp_fs(void)
1045 {
1046         int err;
1047         ncp_dbg(1, "called\n");
1048
1049         err = init_inodecache();
1050         if (err)
1051                 goto out1;
1052         err = register_filesystem(&ncp_fs_type);
1053         if (err)
1054                 goto out;
1055         return 0;
1056 out:
1057         destroy_inodecache();
1058 out1:
1059         return err;
1060 }
1061
1062 static void __exit exit_ncp_fs(void)
1063 {
1064         ncp_dbg(1, "called\n");
1065         unregister_filesystem(&ncp_fs_type);
1066         destroy_inodecache();
1067 }
1068
1069 module_init(init_ncp_fs)
1070 module_exit(exit_ncp_fs)
1071 MODULE_LICENSE("GPL");