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