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