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 |= SB_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 |= SB_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         timer_setup(&server->timeout_tm, ncpdgram_timeout_call, 0);
 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         }
 654         release_sock(sock->sk);
 655
 656         ncp_lock_server(server);
 657         error = ncp_connect(server);
 658         ncp_unlock_server(server);
 659         if (error < 0)
 660                 goto out_rxbuf;
 661         ncp_dbg(1, "NCP_SBP(sb) = %p\n", NCP_SBP(sb));
 662
 663         error = -EMSGSIZE;      /* -EREMOTESIDEINCOMPATIBLE */
 664 #ifdef CONFIG_NCPFS_PACKET_SIGNING
 665         if (ncp_negotiate_size_and_options(server, default_bufsize,
 666                 NCP_DEFAULT_OPTIONS, &(server->buffer_size), &options) == 0)
 667         {
 668                 if (options != NCP_DEFAULT_OPTIONS)
 669                 {
 670                         if (ncp_negotiate_size_and_options(server,
 671                                 default_bufsize,
 672                                 options & 2,
 673                                 &(server->buffer_size), &options) != 0)
 674
 675                         {
 676                                 goto out_disconnect;
 677                         }
 678                 }
 679                 ncp_lock_server(server);
 680                 if (options & 2)
 681                         server->sign_wanted = 1;
 682                 ncp_unlock_server(server);
 683         }
 684         else
 685 #endif  /* CONFIG_NCPFS_PACKET_SIGNING */
 686         if (ncp_negotiate_buffersize(server, default_bufsize,
 687                                      &(server->buffer_size)) != 0)
 688                 goto out_disconnect;
 689         ncp_dbg(1, "bufsize = %d\n", server->buffer_size);
 690
 691         memset(&finfo, 0, sizeof(finfo));
 692         finfo.i.attributes      = aDIR;
 693         finfo.i.dataStreamSize  = 0;    /* ignored */
 694         finfo.i.dirEntNum       = 0;
 695         finfo.i.DosDirNum       = 0;
 696 #ifdef CONFIG_NCPFS_SMALLDOS
 697         finfo.i.NSCreator       = NW_NS_DOS;
 698 #endif
 699         finfo.volume            = NCP_NUMBER_OF_VOLUMES;
 700         /* set dates of mountpoint to Jan 1, 1986; 00:00 */
 701         finfo.i.creationTime    = finfo.i.modifyTime
 702                                 = cpu_to_le16(0x0000);
 703         finfo.i.creationDate    = finfo.i.modifyDate
 704                                 = finfo.i.lastAccessDate
 705                                 = cpu_to_le16(0x0C21);
 706         finfo.i.nameLen         = 0;
 707         finfo.i.entryName[0]    = '\0';
 708
 709         finfo.opened            = 0;
 710         finfo.ino               = 2;    /* tradition */
 711
 712         server->name_space[finfo.volume] = NW_NS_DOS;
 713
 714         error = -ENOMEM;
 715         root_inode = ncp_iget(sb, &finfo);
 716         if (!root_inode)
 717                 goto out_disconnect;
 718         ncp_dbg(1, "root vol=%d\n", NCP_FINFO(root_inode)->volNumber);
 719         sb->s_root = d_make_root(root_inode);
 720         if (!sb->s_root)
 721                 goto out_disconnect;
 722         return 0;
 723
 724 out_disconnect:
 725         ncp_lock_server(server);
 726         ncp_disconnect(server);
 727         ncp_unlock_server(server);
 728 out_rxbuf:
 729         ncp_stop_tasks(server);
 730         vfree(server->rxbuf);
 731 out_txbuf:
 732         vfree(server->txbuf);
 733 out_packet:
 734         vfree(server->packet);
 735 out_nls:
 736 #ifdef CONFIG_NCPFS_NLS
 737         unload_nls(server->nls_io);
 738         unload_nls(server->nls_vol);
 739 #endif
 740         mutex_destroy(&server->rcv.creq_mutex);
 741         mutex_destroy(&server->root_setup_lock);
 742         mutex_destroy(&server->mutex);
 743 out_fput2:
 744         if (server->info_sock)
 745                 sockfd_put(server->info_sock);
 746 out_fput:
 747         sockfd_put(sock);
 748 out:
 749         put_pid(data.wdog_pid);
 750         sb->s_fs_info = NULL;
 751         kfree(server);
 752         return error;
 753 }
 754
 755 static void delayed_free(struct rcu_head *p)
 756 {
 757         struct ncp_server *server = container_of(p, struct ncp_server, rcu);
 758 #ifdef CONFIG_NCPFS_NLS
 759         /* unload the NLS charsets */
 760         unload_nls(server->nls_vol);
 761         unload_nls(server->nls_io);
 762 #endif /* CONFIG_NCPFS_NLS */
 763         kfree(server);
 764 }
 765
 766 static void ncp_put_super(struct super_block *sb)
 767 {
 768         struct ncp_server *server = NCP_SBP(sb);
 769
 770         ncp_lock_server(server);
 771         ncp_disconnect(server);
 772         ncp_unlock_server(server);
 773
 774         ncp_stop_tasks(server);
 775
 776         mutex_destroy(&server->rcv.creq_mutex);
 777         mutex_destroy(&server->root_setup_lock);
 778         mutex_destroy(&server->mutex);
 779
 780         if (server->info_sock)
 781                 sockfd_put(server->info_sock);
 782         sockfd_put(server->ncp_sock);
 783         kill_pid(server->m.wdog_pid, SIGTERM, 1);
 784         put_pid(server->m.wdog_pid);
 785
 786         kfree(server->priv.data);
 787         kfree(server->auth.object_name);
 788         vfree(server->rxbuf);
 789         vfree(server->txbuf);
 790         vfree(server->packet);
 791         call_rcu(&server->rcu, delayed_free);
 792 }
 793
 794 static int ncp_statfs(struct dentry *dentry, struct kstatfs *buf)
 795 {
 796         struct dentry* d;
 797         struct inode* i;
 798         struct ncp_inode_info* ni;
 799         struct ncp_server* s;
 800         struct ncp_volume_info vi;
 801         struct super_block *sb = dentry->d_sb;
 802         int err;
 803         __u8 dh;
 804
 805         d = sb->s_root;
 806         if (!d) {
 807                 goto dflt;
 808         }
 809         i = d_inode(d);
 810         if (!i) {
 811                 goto dflt;
 812         }
 813         ni = NCP_FINFO(i);
 814         if (!ni) {
 815                 goto dflt;
 816         }
 817         s = NCP_SBP(sb);
 818         if (!s) {
 819                 goto dflt;
 820         }
 821         if (!s->m.mounted_vol[0]) {
 822                 goto dflt;
 823         }
 824
 825         err = ncp_dirhandle_alloc(s, ni->volNumber, ni->DosDirNum, &dh);
 826         if (err) {
 827                 goto dflt;
 828         }
 829         err = ncp_get_directory_info(s, dh, &vi);
 830         ncp_dirhandle_free(s, dh);
 831         if (err) {
 832                 goto dflt;
 833         }
 834         buf->f_type = NCP_SUPER_MAGIC;
 835         buf->f_bsize = vi.sectors_per_block * 512;
 836         buf->f_blocks = vi.total_blocks;
 837         buf->f_bfree = vi.free_blocks;
 838         buf->f_bavail = vi.free_blocks;
 839         buf->f_files = vi.total_dir_entries;
 840         buf->f_ffree = vi.available_dir_entries;
 841         buf->f_namelen = 12;
 842         return 0;
 843
 844         /* We cannot say how much disk space is left on a mounted
 845            NetWare Server, because free space is distributed over
 846            volumes, and the current user might have disk quotas. So
 847            free space is not that simple to determine. Our decision
 848            here is to err conservatively. */
 849
 850 dflt:;
 851         buf->f_type = NCP_SUPER_MAGIC;
 852         buf->f_bsize = NCP_BLOCK_SIZE;
 853         buf->f_blocks = 0;
 854         buf->f_bfree = 0;
 855         buf->f_bavail = 0;
 856         buf->f_namelen = 12;
 857         return 0;
 858 }
 859
 860 int ncp_notify_change(struct dentry *dentry, struct iattr *attr)
 861 {
 862         struct inode *inode = d_inode(dentry);
 863         int result = 0;
 864         __le32 info_mask;
 865         struct nw_modify_dos_info info;
 866         struct ncp_server *server;
 867
 868         result = -EIO;
 869
 870         server = NCP_SERVER(inode);
 871         if (!server)    /* How this could happen? */
 872                 goto out;
 873
 874         result = -EPERM;
 875         if (IS_DEADDIR(d_inode(dentry)))
 876                 goto out;
 877
 878         /* ageing the dentry to force validation */
 879         ncp_age_dentry(server, dentry);
 880
 881         result = setattr_prepare(dentry, attr);
 882         if (result < 0)
 883                 goto out;
 884
 885         result = -EPERM;
 886         if ((attr->ia_valid & ATTR_UID) && !uid_eq(attr->ia_uid, server->m.uid))
 887                 goto out;
 888
 889         if ((attr->ia_valid & ATTR_GID) && !gid_eq(attr->ia_gid, server->m.gid))
 890                 goto out;
 891
 892         if (((attr->ia_valid & ATTR_MODE) &&
 893              (attr->ia_mode &
 894               ~(S_IFREG | S_IFDIR | S_IRWXUGO))))
 895                 goto out;
 896
 897         info_mask = 0;
 898         memset(&info, 0, sizeof(info));
 899
 900 #if 1
 901         if ((attr->ia_valid & ATTR_MODE) != 0)
 902         {
 903                 umode_t newmode = attr->ia_mode;
 904
 905                 info_mask |= DM_ATTRIBUTES;
 906
 907                 if (S_ISDIR(inode->i_mode)) {
 908                         newmode &= server->m.dir_mode;
 909                 } else {
 910 #ifdef CONFIG_NCPFS_EXTRAS
 911                         if (server->m.flags & NCP_MOUNT_EXTRAS) {
 912                                 /* any non-default execute bit set */
 913                                 if (newmode & ~server->m.file_mode & S_IXUGO)
 914                                         info.attributes |= aSHARED | aSYSTEM;
 915                                 /* read for group/world and not in default file_mode */
 916                                 else if (newmode & ~server->m.file_mode & S_IRUGO)
 917                                         info.attributes |= aSHARED;
 918                         } else
 919 #endif
 920                                 newmode &= server->m.file_mode;
 921                 }
 922                 if (newmode & S_IWUGO)
 923                         info.attributes &= ~(aRONLY|aRENAMEINHIBIT|aDELETEINHIBIT);
 924                 else
 925                         info.attributes |=  (aRONLY|aRENAMEINHIBIT|aDELETEINHIBIT);
 926
 927 #ifdef CONFIG_NCPFS_NFS_NS
 928                 if (ncp_is_nfs_extras(server, NCP_FINFO(inode)->volNumber)) {
 929                         result = ncp_modify_nfs_info(server,
 930                                                      NCP_FINFO(inode)->volNumber,
 931                                                      NCP_FINFO(inode)->dirEntNum,
 932                                                      attr->ia_mode, 0);
 933                         if (result != 0)
 934                                 goto out;
 935                         info.attributes &= ~(aSHARED | aSYSTEM);
 936                         {
 937                                 /* mark partial success */
 938                                 struct iattr tmpattr;
 939
 940                                 tmpattr.ia_valid = ATTR_MODE;
 941                                 tmpattr.ia_mode = attr->ia_mode;
 942
 943                                 setattr_copy(inode, &tmpattr);
 944                                 mark_inode_dirty(inode);
 945                         }
 946                 }
 947 #endif
 948         }
 949 #endif
 950
 951         /* Do SIZE before attributes, otherwise mtime together with size does not work...
 952          */
 953         if ((attr->ia_valid & ATTR_SIZE) != 0) {
 954                 int written;
 955
 956                 ncp_dbg(1, "trying to change size to %llu\n", attr->ia_size);
 957
 958                 if ((result = ncp_make_open(inode, O_WRONLY)) < 0) {
 959                         result = -EACCES;
 960                         goto out;
 961                 }
 962                 ncp_write_kernel(NCP_SERVER(inode), NCP_FINFO(inode)->file_handle,
 963                           attr->ia_size, 0, "", &written);
 964
 965                 /* According to ndir, the changes only take effect after
 966                    closing the file */
 967                 ncp_inode_close(inode);
 968                 result = ncp_make_closed(inode);
 969                 if (result)
 970                         goto out;
 971
 972                 if (attr->ia_size != i_size_read(inode)) {
 973                         truncate_setsize(inode, attr->ia_size);
 974                         mark_inode_dirty(inode);
 975                 }
 976         }
 977         if ((attr->ia_valid & ATTR_CTIME) != 0) {
 978                 info_mask |= (DM_CREATE_TIME | DM_CREATE_DATE);
 979                 ncp_date_unix2dos(attr->ia_ctime.tv_sec,
 980                              &info.creationTime, &info.creationDate);
 981         }
 982         if ((attr->ia_valid & ATTR_MTIME) != 0) {
 983                 info_mask |= (DM_MODIFY_TIME | DM_MODIFY_DATE);
 984                 ncp_date_unix2dos(attr->ia_mtime.tv_sec,
 985                                   &info.modifyTime, &info.modifyDate);
 986         }
 987         if ((attr->ia_valid & ATTR_ATIME) != 0) {
 988                 __le16 dummy;
 989                 info_mask |= (DM_LAST_ACCESS_DATE);
 990                 ncp_date_unix2dos(attr->ia_atime.tv_sec,
 991                                   &dummy, &info.lastAccessDate);
 992         }
 993         if (info_mask != 0) {
 994                 result = ncp_modify_file_or_subdir_dos_info(NCP_SERVER(inode),
 995                                       inode, info_mask, &info);
 996                 if (result != 0) {
 997                         if (info_mask == (DM_CREATE_TIME | DM_CREATE_DATE)) {
 998                                 /* NetWare seems not to allow this. I
 999                                    do not know why. So, just tell the
1000                                    user everything went fine. This is
1001                                    a terrible hack, but I do not know
1002                                    how to do this correctly. */
1003                                 result = 0;
1004                         } else
1005                                 goto out;
1006                 }
1007 #ifdef CONFIG_NCPFS_STRONG
1008                 if ((!result) && (info_mask & DM_ATTRIBUTES))
1009                         NCP_FINFO(inode)->nwattr = info.attributes;
1010 #endif
1011         }
1012         if (result)
1013                 goto out;
1014
1015         setattr_copy(inode, attr);
1016         mark_inode_dirty(inode);
1017
1018 out:
1019         if (result > 0)
1020                 result = -EACCES;
1021         return result;
1022 }
1023
1024 static struct dentry *ncp_mount(struct file_system_type *fs_type,
1025         int flags, const char *dev_name, void *data)
1026 {
1027         return mount_nodev(fs_type, flags, data, ncp_fill_super);
1028 }
1029
1030 static struct file_system_type ncp_fs_type = {
1031         .owner          = THIS_MODULE,
1032         .name           = "ncpfs",
1033         .mount          = ncp_mount,
1034         .kill_sb        = kill_anon_super,
1035         .fs_flags       = FS_BINARY_MOUNTDATA,
1036 };
1037 MODULE_ALIAS_FS("ncpfs");
1038
1039 static int __init init_ncp_fs(void)
1040 {
1041         int err;
1042         ncp_dbg(1, "called\n");
1043
1044         err = init_inodecache();
1045         if (err)
1046                 goto out1;
1047         err = register_filesystem(&ncp_fs_type);
1048         if (err)
1049                 goto out;
1050         return 0;
1051 out:
1052         destroy_inodecache();
1053 out1:
1054         return err;
1055 }
1056
1057 static void __exit exit_ncp_fs(void)
1058 {
1059         ncp_dbg(1, "called\n");
1060         unregister_filesystem(&ncp_fs_type);
1061         destroy_inodecache();
1062 }
1063
1064 module_init(init_ncp_fs)
1065 module_exit(exit_ncp_fs)
1066 MODULE_LICENSE("GPL");