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