blob: 42039fe0653c0c3afc546748e060b005ca882fd8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * ioctl.c
3 *
4 * Copyright (C) 1995, 1996 by Volker Lendecke
5 * Modified 1997 Peter Waltenberg, Bill Hawes, David Woodhouse for 2.1 dcache
6 * Modified 1998, 1999 Wolfram Pienkoss for NLS
7 *
8 */
9
Linus Torvalds1da177e2005-04-16 15:20:36 -070010
11#include <asm/uaccess.h>
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080012#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/errno.h>
14#include <linux/fs.h>
15#include <linux/ioctl.h>
16#include <linux/time.h>
17#include <linux/mm.h>
18#include <linux/highuid.h>
19#include <linux/vmalloc.h>
20
21#include <linux/ncp_fs.h>
22
23#include "ncplib_kernel.h"
24
25/* maximum limit for ncp_objectname_ioctl */
26#define NCP_OBJECT_NAME_MAX_LEN 4096
27/* maximum limit for ncp_privatedata_ioctl */
28#define NCP_PRIVATE_DATA_MAX_LEN 8192
29/* maximum negotiable packet size */
30#define NCP_PACKET_SIZE_INTERNAL 65536
31
32static int
Christoph Hellwig8c744fb2005-11-08 21:35:04 -080033ncp_get_fs_info(struct ncp_server * server, struct file *file,
34 struct ncp_fs_info __user *arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -070035{
Christoph Hellwig8c744fb2005-11-08 21:35:04 -080036 struct inode *inode = file->f_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 struct ncp_fs_info info;
38
Christoph Hellwig8c744fb2005-11-08 21:35:04 -080039 if ((file_permission(file, MAY_WRITE) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 && (current->uid != server->m.mounted_uid)) {
41 return -EACCES;
42 }
43 if (copy_from_user(&info, arg, sizeof(info)))
44 return -EFAULT;
45
46 if (info.version != NCP_GET_FS_INFO_VERSION) {
47 DPRINTK("info.version invalid: %d\n", info.version);
48 return -EINVAL;
49 }
50 /* TODO: info.addr = server->m.serv_addr; */
51 SET_UID(info.mounted_uid, server->m.mounted_uid);
52 info.connection = server->connection;
53 info.buffer_size = server->buffer_size;
54 info.volume_number = NCP_FINFO(inode)->volNumber;
55 info.directory_id = NCP_FINFO(inode)->DosDirNum;
56
57 if (copy_to_user(arg, &info, sizeof(info)))
58 return -EFAULT;
59 return 0;
60}
61
62static int
Christoph Hellwig8c744fb2005-11-08 21:35:04 -080063ncp_get_fs_info_v2(struct ncp_server * server, struct file *file,
64 struct ncp_fs_info_v2 __user * arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -070065{
Christoph Hellwig8c744fb2005-11-08 21:35:04 -080066 struct inode *inode = file->f_dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070067 struct ncp_fs_info_v2 info2;
68
Christoph Hellwig8c744fb2005-11-08 21:35:04 -080069 if ((file_permission(file, MAY_WRITE) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 && (current->uid != server->m.mounted_uid)) {
71 return -EACCES;
72 }
73 if (copy_from_user(&info2, arg, sizeof(info2)))
74 return -EFAULT;
75
76 if (info2.version != NCP_GET_FS_INFO_VERSION_V2) {
77 DPRINTK("info.version invalid: %d\n", info2.version);
78 return -EINVAL;
79 }
80 info2.mounted_uid = server->m.mounted_uid;
81 info2.connection = server->connection;
82 info2.buffer_size = server->buffer_size;
83 info2.volume_number = NCP_FINFO(inode)->volNumber;
84 info2.directory_id = NCP_FINFO(inode)->DosDirNum;
85 info2.dummy1 = info2.dummy2 = info2.dummy3 = 0;
86
87 if (copy_to_user(arg, &info2, sizeof(info2)))
88 return -EFAULT;
89 return 0;
90}
91
92#ifdef CONFIG_NCPFS_NLS
93/* Here we are select the iocharset and the codepage for NLS.
94 * Thanks Petr Vandrovec for idea and many hints.
95 */
96static int
97ncp_set_charsets(struct ncp_server* server, struct ncp_nls_ioctl __user *arg)
98{
99 struct ncp_nls_ioctl user;
100 struct nls_table *codepage;
101 struct nls_table *iocharset;
102 struct nls_table *oldset_io;
103 struct nls_table *oldset_cp;
104
105 if (!capable(CAP_SYS_ADMIN))
106 return -EACCES;
107 if (server->root_setuped)
108 return -EBUSY;
109
110 if (copy_from_user(&user, arg, sizeof(user)))
111 return -EFAULT;
112
113 codepage = NULL;
114 user.codepage[NCP_IOCSNAME_LEN] = 0;
115 if (!user.codepage[0] || !strcmp(user.codepage, "default"))
116 codepage = load_nls_default();
117 else {
118 codepage = load_nls(user.codepage);
119 if (!codepage) {
120 return -EBADRQC;
121 }
122 }
123
124 iocharset = NULL;
125 user.iocharset[NCP_IOCSNAME_LEN] = 0;
126 if (!user.iocharset[0] || !strcmp(user.iocharset, "default")) {
127 iocharset = load_nls_default();
128 NCP_CLR_FLAG(server, NCP_FLAG_UTF8);
129 } else if (!strcmp(user.iocharset, "utf8")) {
130 iocharset = load_nls_default();
131 NCP_SET_FLAG(server, NCP_FLAG_UTF8);
132 } else {
133 iocharset = load_nls(user.iocharset);
134 if (!iocharset) {
135 unload_nls(codepage);
136 return -EBADRQC;
137 }
138 NCP_CLR_FLAG(server, NCP_FLAG_UTF8);
139 }
140
141 oldset_cp = server->nls_vol;
142 server->nls_vol = codepage;
143 oldset_io = server->nls_io;
144 server->nls_io = iocharset;
145
146 if (oldset_cp)
147 unload_nls(oldset_cp);
148 if (oldset_io)
149 unload_nls(oldset_io);
150
151 return 0;
152}
153
154static int
155ncp_get_charsets(struct ncp_server* server, struct ncp_nls_ioctl __user *arg)
156{
157 struct ncp_nls_ioctl user;
158 int len;
159
160 memset(&user, 0, sizeof(user));
161 if (server->nls_vol && server->nls_vol->charset) {
162 len = strlen(server->nls_vol->charset);
163 if (len > NCP_IOCSNAME_LEN)
164 len = NCP_IOCSNAME_LEN;
165 strncpy(user.codepage, server->nls_vol->charset, len);
166 user.codepage[len] = 0;
167 }
168
169 if (NCP_IS_FLAG(server, NCP_FLAG_UTF8))
170 strcpy(user.iocharset, "utf8");
171 else if (server->nls_io && server->nls_io->charset) {
172 len = strlen(server->nls_io->charset);
173 if (len > NCP_IOCSNAME_LEN)
174 len = NCP_IOCSNAME_LEN;
175 strncpy(user.iocharset, server->nls_io->charset, len);
176 user.iocharset[len] = 0;
177 }
178
179 if (copy_to_user(arg, &user, sizeof(user)))
180 return -EFAULT;
181 return 0;
182}
183#endif /* CONFIG_NCPFS_NLS */
184
185int ncp_ioctl(struct inode *inode, struct file *filp,
186 unsigned int cmd, unsigned long arg)
187{
188 struct ncp_server *server = NCP_SERVER(inode);
189 int result;
190 struct ncp_ioctl_request request;
191 char* bouncebuffer;
192 void __user *argp = (void __user *)arg;
193
194 switch (cmd) {
195 case NCP_IOC_NCPREQUEST:
196
Christoph Hellwig8c744fb2005-11-08 21:35:04 -0800197 if ((file_permission(filp, MAY_WRITE) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198 && (current->uid != server->m.mounted_uid)) {
199 return -EACCES;
200 }
201 if (copy_from_user(&request, argp, sizeof(request)))
202 return -EFAULT;
203
204 if ((request.function > 255)
205 || (request.size >
206 NCP_PACKET_SIZE - sizeof(struct ncp_request_header))) {
207 return -EINVAL;
208 }
209 bouncebuffer = vmalloc(NCP_PACKET_SIZE_INTERNAL);
210 if (!bouncebuffer)
211 return -ENOMEM;
212 if (copy_from_user(bouncebuffer, request.data, request.size)) {
213 vfree(bouncebuffer);
214 return -EFAULT;
215 }
216 ncp_lock_server(server);
217
218 /* FIXME: We hack around in the server's structures
219 here to be able to use ncp_request */
220
221 server->has_subfunction = 0;
222 server->current_size = request.size;
223 memcpy(server->packet, bouncebuffer, request.size);
224
225 result = ncp_request2(server, request.function,
226 bouncebuffer, NCP_PACKET_SIZE_INTERNAL);
227 if (result < 0)
228 result = -EIO;
229 else
230 result = server->reply_size;
231 ncp_unlock_server(server);
232 DPRINTK("ncp_ioctl: copy %d bytes\n",
233 result);
234 if (result >= 0)
235 if (copy_to_user(request.data, bouncebuffer, result))
236 result = -EFAULT;
237 vfree(bouncebuffer);
238 return result;
239
240 case NCP_IOC_CONN_LOGGED_IN:
241
242 if (!capable(CAP_SYS_ADMIN))
243 return -EACCES;
244 if (!(server->m.int_flags & NCP_IMOUNT_LOGGEDIN_POSSIBLE))
245 return -EINVAL;
246 if (server->root_setuped)
247 return -EBUSY;
248 server->root_setuped = 1;
249 return ncp_conn_logged_in(inode->i_sb);
250
251 case NCP_IOC_GET_FS_INFO:
Christoph Hellwig8c744fb2005-11-08 21:35:04 -0800252 return ncp_get_fs_info(server, filp, argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253
254 case NCP_IOC_GET_FS_INFO_V2:
Christoph Hellwig8c744fb2005-11-08 21:35:04 -0800255 return ncp_get_fs_info_v2(server, filp, argp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
257 case NCP_IOC_GETMOUNTUID2:
258 {
259 unsigned long tmp = server->m.mounted_uid;
260
Christoph Hellwig8c744fb2005-11-08 21:35:04 -0800261 if ((file_permission(filp, MAY_READ) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 && (current->uid != server->m.mounted_uid))
263 {
264 return -EACCES;
265 }
266 if (put_user(tmp, (unsigned long __user *)argp))
267 return -EFAULT;
268 return 0;
269 }
270
271 case NCP_IOC_GETROOT:
272 {
273 struct ncp_setroot_ioctl sr;
274
Christoph Hellwig8c744fb2005-11-08 21:35:04 -0800275 if ((file_permission(filp, MAY_READ) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 && (current->uid != server->m.mounted_uid))
277 {
278 return -EACCES;
279 }
280 if (server->m.mounted_vol[0]) {
281 struct dentry* dentry = inode->i_sb->s_root;
282
283 if (dentry) {
284 struct inode* inode = dentry->d_inode;
285
286 if (inode) {
287 sr.volNumber = NCP_FINFO(inode)->volNumber;
288 sr.dirEntNum = NCP_FINFO(inode)->dirEntNum;
289 sr.namespace = server->name_space[sr.volNumber];
290 } else
291 DPRINTK("ncpfs: s_root->d_inode==NULL\n");
292 } else
293 DPRINTK("ncpfs: s_root==NULL\n");
294 } else {
295 sr.volNumber = -1;
296 sr.namespace = 0;
297 sr.dirEntNum = 0;
298 }
299 if (copy_to_user(argp, &sr, sizeof(sr)))
300 return -EFAULT;
301 return 0;
302 }
303 case NCP_IOC_SETROOT:
304 {
305 struct ncp_setroot_ioctl sr;
306 __u32 vnum;
307 __le32 de;
308 __le32 dosde;
309 struct dentry* dentry;
310
311 if (!capable(CAP_SYS_ADMIN))
312 {
313 return -EACCES;
314 }
315 if (server->root_setuped) return -EBUSY;
316 if (copy_from_user(&sr, argp, sizeof(sr)))
317 return -EFAULT;
318 if (sr.volNumber < 0) {
319 server->m.mounted_vol[0] = 0;
320 vnum = NCP_NUMBER_OF_VOLUMES;
321 de = 0;
322 dosde = 0;
323 } else if (sr.volNumber >= NCP_NUMBER_OF_VOLUMES) {
324 return -EINVAL;
325 } else if (ncp_mount_subdir(server, sr.volNumber,
326 sr.namespace, sr.dirEntNum,
327 &vnum, &de, &dosde)) {
328 return -ENOENT;
329 }
330
331 dentry = inode->i_sb->s_root;
332 server->root_setuped = 1;
333 if (dentry) {
334 struct inode* inode = dentry->d_inode;
335
336 if (inode) {
337 NCP_FINFO(inode)->volNumber = vnum;
338 NCP_FINFO(inode)->dirEntNum = de;
339 NCP_FINFO(inode)->DosDirNum = dosde;
340 } else
341 DPRINTK("ncpfs: s_root->d_inode==NULL\n");
342 } else
343 DPRINTK("ncpfs: s_root==NULL\n");
344
345 return 0;
346 }
347
348#ifdef CONFIG_NCPFS_PACKET_SIGNING
349 case NCP_IOC_SIGN_INIT:
Christoph Hellwig8c744fb2005-11-08 21:35:04 -0800350 if ((file_permission(filp, MAY_WRITE) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 && (current->uid != server->m.mounted_uid))
352 {
353 return -EACCES;
354 }
355 if (argp) {
356 if (server->sign_wanted)
357 {
358 struct ncp_sign_init sign;
359
360 if (copy_from_user(&sign, argp, sizeof(sign)))
361 return -EFAULT;
362 memcpy(server->sign_root,sign.sign_root,8);
363 memcpy(server->sign_last,sign.sign_last,16);
364 server->sign_active = 1;
365 }
366 /* ignore when signatures not wanted */
367 } else {
368 server->sign_active = 0;
369 }
370 return 0;
371
372 case NCP_IOC_SIGN_WANTED:
Christoph Hellwig8c744fb2005-11-08 21:35:04 -0800373 if ((file_permission(filp, MAY_READ) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 && (current->uid != server->m.mounted_uid))
375 {
376 return -EACCES;
377 }
378
379 if (put_user(server->sign_wanted, (int __user *)argp))
380 return -EFAULT;
381 return 0;
382 case NCP_IOC_SET_SIGN_WANTED:
383 {
384 int newstate;
385
Christoph Hellwig8c744fb2005-11-08 21:35:04 -0800386 if ((file_permission(filp, MAY_WRITE) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 && (current->uid != server->m.mounted_uid))
388 {
389 return -EACCES;
390 }
391 /* get only low 8 bits... */
392 if (get_user(newstate, (unsigned char __user *)argp))
393 return -EFAULT;
394 if (server->sign_active) {
395 /* cannot turn signatures OFF when active */
396 if (!newstate) return -EINVAL;
397 } else {
398 server->sign_wanted = newstate != 0;
399 }
400 return 0;
401 }
402
403#endif /* CONFIG_NCPFS_PACKET_SIGNING */
404
405#ifdef CONFIG_NCPFS_IOCTL_LOCKING
406 case NCP_IOC_LOCKUNLOCK:
Christoph Hellwig8c744fb2005-11-08 21:35:04 -0800407 if ((file_permission(filp, MAY_WRITE) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 && (current->uid != server->m.mounted_uid))
409 {
410 return -EACCES;
411 }
412 {
413 struct ncp_lock_ioctl rqdata;
414 int result;
415
416 if (copy_from_user(&rqdata, argp, sizeof(rqdata)))
417 return -EFAULT;
418 if (rqdata.origin != 0)
419 return -EINVAL;
420 /* check for cmd */
421 switch (rqdata.cmd) {
422 case NCP_LOCK_EX:
423 case NCP_LOCK_SH:
424 if (rqdata.timeout == 0)
425 rqdata.timeout = NCP_LOCK_DEFAULT_TIMEOUT;
426 else if (rqdata.timeout > NCP_LOCK_MAX_TIMEOUT)
427 rqdata.timeout = NCP_LOCK_MAX_TIMEOUT;
428 break;
429 case NCP_LOCK_LOG:
430 rqdata.timeout = NCP_LOCK_DEFAULT_TIMEOUT; /* has no effect */
431 case NCP_LOCK_CLEAR:
432 break;
433 default:
434 return -EINVAL;
435 }
436 /* locking needs both read and write access */
437 if ((result = ncp_make_open(inode, O_RDWR)) != 0)
438 {
439 return result;
440 }
441 result = -EIO;
442 if (!ncp_conn_valid(server))
443 goto outrel;
444 result = -EISDIR;
445 if (!S_ISREG(inode->i_mode))
446 goto outrel;
447 if (rqdata.cmd == NCP_LOCK_CLEAR)
448 {
449 result = ncp_ClearPhysicalRecord(NCP_SERVER(inode),
450 NCP_FINFO(inode)->file_handle,
451 rqdata.offset,
452 rqdata.length);
453 if (result > 0) result = 0; /* no such lock */
454 }
455 else
456 {
457 int lockcmd;
458
459 switch (rqdata.cmd)
460 {
461 case NCP_LOCK_EX: lockcmd=1; break;
462 case NCP_LOCK_SH: lockcmd=3; break;
463 default: lockcmd=0; break;
464 }
465 result = ncp_LogPhysicalRecord(NCP_SERVER(inode),
466 NCP_FINFO(inode)->file_handle,
467 lockcmd,
468 rqdata.offset,
469 rqdata.length,
470 rqdata.timeout);
471 if (result > 0) result = -EAGAIN;
472 }
473outrel:
474 ncp_inode_close(inode);
475 return result;
476 }
477#endif /* CONFIG_NCPFS_IOCTL_LOCKING */
478
479 case NCP_IOC_GETOBJECTNAME:
480 if (current->uid != server->m.mounted_uid) {
481 return -EACCES;
482 }
483 {
484 struct ncp_objectname_ioctl user;
485 size_t outl;
486
487 if (copy_from_user(&user, argp, sizeof(user)))
488 return -EFAULT;
489 user.auth_type = server->auth.auth_type;
490 outl = user.object_name_len;
491 user.object_name_len = server->auth.object_name_len;
492 if (outl > user.object_name_len)
493 outl = user.object_name_len;
494 if (outl) {
495 if (copy_to_user(user.object_name,
496 server->auth.object_name,
497 outl)) return -EFAULT;
498 }
499 if (copy_to_user(argp, &user, sizeof(user)))
500 return -EFAULT;
501 return 0;
502 }
503 case NCP_IOC_SETOBJECTNAME:
504 if (current->uid != server->m.mounted_uid) {
505 return -EACCES;
506 }
507 {
508 struct ncp_objectname_ioctl user;
509 void* newname;
510 void* oldname;
511 size_t oldnamelen;
512 void* oldprivate;
513 size_t oldprivatelen;
514
515 if (copy_from_user(&user, argp, sizeof(user)))
516 return -EFAULT;
517 if (user.object_name_len > NCP_OBJECT_NAME_MAX_LEN)
518 return -ENOMEM;
519 if (user.object_name_len) {
Pekka Enberg44db77f2006-01-14 13:21:12 -0800520 newname = kmalloc(user.object_name_len, GFP_USER);
521 if (!newname)
522 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 if (copy_from_user(newname, user.object_name, user.object_name_len)) {
Pekka Enberg44db77f2006-01-14 13:21:12 -0800524 kfree(newname);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 return -EFAULT;
526 }
527 } else {
528 newname = NULL;
529 }
530 /* enter critical section */
531 /* maybe that kfree can sleep so do that this way */
532 /* it is at least more SMP friendly (in future...) */
533 oldname = server->auth.object_name;
534 oldnamelen = server->auth.object_name_len;
535 oldprivate = server->priv.data;
536 oldprivatelen = server->priv.len;
537 server->auth.auth_type = user.auth_type;
538 server->auth.object_name_len = user.object_name_len;
539 server->auth.object_name = newname;
540 server->priv.len = 0;
541 server->priv.data = NULL;
542 /* leave critical section */
Pekka Enberg44db77f2006-01-14 13:21:12 -0800543 kfree(oldprivate);
544 kfree(oldname);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 return 0;
546 }
547 case NCP_IOC_GETPRIVATEDATA:
548 if (current->uid != server->m.mounted_uid) {
549 return -EACCES;
550 }
551 {
552 struct ncp_privatedata_ioctl user;
553 size_t outl;
554
555 if (copy_from_user(&user, argp, sizeof(user)))
556 return -EFAULT;
557 outl = user.len;
558 user.len = server->priv.len;
559 if (outl > user.len) outl = user.len;
560 if (outl) {
561 if (copy_to_user(user.data,
562 server->priv.data,
563 outl)) return -EFAULT;
564 }
565 if (copy_to_user(argp, &user, sizeof(user)))
566 return -EFAULT;
567 return 0;
568 }
569 case NCP_IOC_SETPRIVATEDATA:
570 if (current->uid != server->m.mounted_uid) {
571 return -EACCES;
572 }
573 {
574 struct ncp_privatedata_ioctl user;
575 void* new;
576 void* old;
577 size_t oldlen;
578
579 if (copy_from_user(&user, argp, sizeof(user)))
580 return -EFAULT;
581 if (user.len > NCP_PRIVATE_DATA_MAX_LEN)
582 return -ENOMEM;
583 if (user.len) {
Pekka Enberg44db77f2006-01-14 13:21:12 -0800584 new = kmalloc(user.len, GFP_USER);
585 if (!new)
586 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 if (copy_from_user(new, user.data, user.len)) {
Pekka Enberg44db77f2006-01-14 13:21:12 -0800588 kfree(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589 return -EFAULT;
590 }
591 } else {
592 new = NULL;
593 }
594 /* enter critical section */
595 old = server->priv.data;
596 oldlen = server->priv.len;
597 server->priv.len = user.len;
598 server->priv.data = new;
599 /* leave critical section */
Pekka Enberg44db77f2006-01-14 13:21:12 -0800600 kfree(old);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 return 0;
602 }
603
604#ifdef CONFIG_NCPFS_NLS
605 case NCP_IOC_SETCHARSETS:
606 return ncp_set_charsets(server, argp);
607
608 case NCP_IOC_GETCHARSETS:
609 return ncp_get_charsets(server, argp);
610
611#endif /* CONFIG_NCPFS_NLS */
612
613 case NCP_IOC_SETDENTRYTTL:
Christoph Hellwig8c744fb2005-11-08 21:35:04 -0800614 if ((file_permission(filp, MAY_WRITE) != 0) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 (current->uid != server->m.mounted_uid))
616 return -EACCES;
617 {
618 u_int32_t user;
619
620 if (copy_from_user(&user, argp, sizeof(user)))
621 return -EFAULT;
622 /* 20 secs at most... */
623 if (user > 20000)
624 return -EINVAL;
625 user = (user * HZ) / 1000;
626 server->dentry_ttl = user;
627 return 0;
628 }
629
630 case NCP_IOC_GETDENTRYTTL:
631 {
632 u_int32_t user = (server->dentry_ttl * 1000) / HZ;
633 if (copy_to_user(argp, &user, sizeof(user)))
634 return -EFAULT;
635 return 0;
636 }
637
638 }
639/* #ifdef CONFIG_UID16 */
640 /* NCP_IOC_GETMOUNTUID may be same as NCP_IOC_GETMOUNTUID2,
641 so we have this out of switch */
642 if (cmd == NCP_IOC_GETMOUNTUID) {
643 __kernel_uid_t uid = 0;
Christoph Hellwig8c744fb2005-11-08 21:35:04 -0800644 if ((file_permission(filp, MAY_READ) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 && (current->uid != server->m.mounted_uid)) {
646 return -EACCES;
647 }
648 SET_UID(uid, server->m.mounted_uid);
649 if (put_user(uid, (__kernel_uid_t __user *)argp))
650 return -EFAULT;
651 return 0;
652 }
653/* #endif */
654 return -EINVAL;
655}