?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge with Linux 2.4.0-test5-pre3.
[linux-2.6/linux-mips.git] / fs / ncpfs / ncplib_kernel.c
blob9272822a4f5eea5c681a0a01896da4c6a98b1df6
1 /*
2 * ncplib_kernel.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 1999 Wolfram Pienkoss for NLS
8 *
9 */
10
11
12 #include <linux/config.h>
13
14 #include "ncplib_kernel.h"
15
16 static inline int min(int a, int b)
17 {
18 return a < b ? a : b;
19 }
20
21 static inline void assert_server_locked(struct ncp_server *server)
22 {
23 if (server->lock == 0) {
24 DPRINTK("ncpfs: server not locked!\n");
25 }
26 }
27
28 static void ncp_add_byte(struct ncp_server *server, __u8 x)
29 {
30 assert_server_locked(server);
31 *(__u8 *) (&(server->packet[server->current_size])) = x;
32 server->current_size += 1;
33 return;
34 }
35
36 static void ncp_add_word(struct ncp_server *server, __u16 x)
37 {
38 assert_server_locked(server);
39 put_unaligned(x, (__u16 *) (&(server->packet[server->current_size])));
40 server->current_size += 2;
41 return;
42 }
43
44 static void ncp_add_dword(struct ncp_server *server, __u32 x)
45 {
46 assert_server_locked(server);
47 put_unaligned(x, (__u32 *) (&(server->packet[server->current_size])));
48 server->current_size += 4;
49 return;
50 }
51
52 static void ncp_add_mem(struct ncp_server *server, const void *source, int size)
53 {
54 assert_server_locked(server);
55 memcpy(&(server->packet[server->current_size]), source, size);
56 server->current_size += size;
57 return;
58 }
59
60 static void ncp_add_mem_fromfs(struct ncp_server *server, const char *source, int size)
61 {
62 assert_server_locked(server);
63 copy_from_user(&(server->packet[server->current_size]), source, size);
64 server->current_size += size;
65 return;
66 }
67
68 static void ncp_add_pstring(struct ncp_server *server, const char *s)
69 {
70 int len = strlen(s);
71 assert_server_locked(server);
72 if (len > 255) {
73 DPRINTK("ncpfs: string too long: %s\n", s);
74 len = 255;
75 }
76 ncp_add_byte(server, len);
77 ncp_add_mem(server, s, len);
78 return;
79 }
80
81 static inline void ncp_init_request(struct ncp_server *server)
82 {
83 ncp_lock_server(server);
84
85 server->current_size = sizeof(struct ncp_request_header);
86 server->has_subfunction = 0;
87 }
88
89 static inline void ncp_init_request_s(struct ncp_server *server, int subfunction)
90 {
91 ncp_lock_server(server);
92
93 server->current_size = sizeof(struct ncp_request_header) + 2;
94 ncp_add_byte(server, subfunction);
95
96 server->has_subfunction = 1;
97 }
98
99 static inline char *
100 ncp_reply_data(struct ncp_server *server, int offset)
101 {
102 return &(server->packet[sizeof(struct ncp_reply_header) + offset]);
103 }
104
105 static __u8
106 ncp_reply_byte(struct ncp_server *server, int offset)
107 {
108 return get_unaligned((__u8 *) ncp_reply_data(server, offset));
109 }
110
111 static __u16
112 ncp_reply_word(struct ncp_server *server, int offset)
113 {
114 return get_unaligned((__u16 *) ncp_reply_data(server, offset));
115 }
116
117 static __u32
118 ncp_reply_dword(struct ncp_server *server, int offset)
119 {
120 return get_unaligned((__u32 *) ncp_reply_data(server, offset));
121 }
122
123 int
124 ncp_negotiate_buffersize(struct ncp_server *server, int size, int *target)
125 {
126 int result;
127
128 ncp_init_request(server);
129 ncp_add_word(server, htons(size));
130
131 if ((result = ncp_request(server, 33)) != 0) {
132 ncp_unlock_server(server);
133 return result;
134 }
135 *target = min(ntohs(ncp_reply_word(server, 0)), size);
136
137 ncp_unlock_server(server);
138 return 0;
139 }
140
141
142 /* options:
143 * bit 0 ipx checksum
144 * bit 1 packet signing
145 */
146 int
147 ncp_negotiate_size_and_options(struct ncp_server *server,
148 int size, int options, int *ret_size, int *ret_options) {
149 int result;
150
151 /* there is minimum */
152 if (size < NCP_BLOCK_SIZE) size = NCP_BLOCK_SIZE;
153
154 ncp_init_request(server);
155 ncp_add_word(server, htons(size));
156 ncp_add_byte(server, options);
157
158 if ((result = ncp_request(server, 0x61)) != 0)
159 {
160 ncp_unlock_server(server);
161 return result;
162 }
163
164 /* NCP over UDP returns 0 (!!!) */
165 result = ntohs(ncp_reply_word(server, 0));
166 if (result >= NCP_BLOCK_SIZE) size=min(result, size);
167 *ret_size = size;
168 *ret_options = ncp_reply_byte(server, 4);
169
170 ncp_unlock_server(server);
171 return 0;
172 }
173
174 int
175 ncp_get_volume_info_with_number(struct ncp_server *server, int n,
176 struct ncp_volume_info *target)
177 {
178 int result;
179 int len;
180
181 ncp_init_request_s(server, 44);
182 ncp_add_byte(server, n);
183
184 if ((result = ncp_request(server, 22)) != 0) {
185 goto out;
186 }
187 target->total_blocks = ncp_reply_dword(server, 0);
188 target->free_blocks = ncp_reply_dword(server, 4);
189 target->purgeable_blocks = ncp_reply_dword(server, 8);
190 target->not_yet_purgeable_blocks = ncp_reply_dword(server, 12);
191 target->total_dir_entries = ncp_reply_dword(server, 16);
192 target->available_dir_entries = ncp_reply_dword(server, 20);
193 target->sectors_per_block = ncp_reply_byte(server, 28);
194
195 memset(&(target->volume_name), 0, sizeof(target->volume_name));
196
197 result = -EIO;
198 len = ncp_reply_byte(server, 29);
199 if (len > NCP_VOLNAME_LEN) {
200 DPRINTK("ncpfs: volume name too long: %d\n", len);
201 goto out;
202 }
203 memcpy(&(target->volume_name), ncp_reply_data(server, 30), len);
204 result = 0;
205 out:
206 ncp_unlock_server(server);
207 return result;
208 }
209
210 int
211 ncp_close_file(struct ncp_server *server, const char *file_id)
212 {
213 int result;
214
215 ncp_init_request(server);
216 ncp_add_byte(server, 0);
217 ncp_add_mem(server, file_id, 6);
218
219 result = ncp_request(server, 66);
220 ncp_unlock_server(server);
221 return result;
222 }
223
224 int
225 ncp_make_closed(struct inode *inode)
226 {
227 int err;
228
229 err = 0;
230 down(&NCP_FINFO(inode)->open_sem);
231 if (atomic_read(&NCP_FINFO(inode)->opened) == 1) {
232 atomic_set(&NCP_FINFO(inode)->opened, 0);
233 err = ncp_close_file(NCP_SERVER(inode), NCP_FINFO(inode)->file_handle);
234
235 if (!err)
236 PPRINTK("ncp_make_closed: volnum=%d, dirent=%u, error=%d\n",
237 NCP_FINFO(inode)->volNumber,
238 NCP_FINFO(inode)->dirEntNum, err);
239 }
240 up(&NCP_FINFO(inode)->open_sem);
241 return err;
242 }
243
244 static void ncp_add_handle_path(struct ncp_server *server, __u8 vol_num,
245 __u32 dir_base, int have_dir_base,
246 const char *path)
247 {
248 ncp_add_byte(server, vol_num);
249 ncp_add_dword(server, dir_base);
250 if (have_dir_base != 0) {
251 ncp_add_byte(server, 1); /* dir_base */
252 } else {
253 ncp_add_byte(server, 0xff); /* no handle */
254 }
255 if (path != NULL) {
256 ncp_add_byte(server, 1); /* 1 component */
257 ncp_add_pstring(server, path);
258 } else {
259 ncp_add_byte(server, 0);
260 }
261 }
262
263 static void ncp_extract_file_info(void *structure, struct nw_info_struct *target)
264 {
265 __u8 *name_len;
266 const int info_struct_size = sizeof(struct nw_info_struct) - 257;
267
268 memcpy(target, structure, info_struct_size);
269 name_len = structure + info_struct_size;
270 target->nameLen = *name_len;
271 memcpy(target->entryName, name_len + 1, *name_len);
272 target->entryName[*name_len] = '\0';
273 return;
274 }
275
276 /*
277 * Returns information for a (one-component) name relative to
278 * the specified directory.
279 */
280 int ncp_obtain_info(struct ncp_server *server, struct inode *dir, char *path,
281 struct nw_info_struct *target)
282 {
283 __u8 volnum = NCP_FINFO(dir)->volNumber;
284 __u32 dirent = NCP_FINFO(dir)->dirEntNum;
285 int result;
286
287 if (target == NULL) {
288 printk(KERN_ERR "ncp_obtain_info: invalid call\n");
289 return -EINVAL;
290 }
291 ncp_init_request(server);
292 ncp_add_byte(server, 6); /* subfunction */
293 ncp_add_byte(server, server->name_space[volnum]);
294 ncp_add_byte(server, server->name_space[volnum]); /* N.B. twice ?? */
295 ncp_add_word(server, htons(0x0680)); /* get all */
296 ncp_add_dword(server, RIM_ALL);
297 ncp_add_handle_path(server, volnum, dirent, 1, path);
298
299 if ((result = ncp_request(server, 87)) != 0)
300 goto out;
301 ncp_extract_file_info(ncp_reply_data(server, 0), target);
302
303 out:
304 ncp_unlock_server(server);
305 return result;
306 }
307
308 #ifdef CONFIG_NCPFS_NFS_NS
309 static int
310 ncp_obtain_DOS_dir_base(struct ncp_server *server,
311 __u8 volnum, __u32 dirent,
312 char *path, /* At most 1 component */
313 __u32 *DOS_dir_base)
314 {
315 int result;
316
317 ncp_init_request(server);
318 ncp_add_byte(server, 6); /* subfunction */
319 ncp_add_byte(server, server->name_space[volnum]);
320 ncp_add_byte(server, server->name_space[volnum]);
321 ncp_add_word(server, htons(0x0680)); /* get all */
322 ncp_add_dword(server, RIM_DIRECTORY);
323 ncp_add_handle_path(server, volnum, dirent, 1, path);
324
325 if ((result = ncp_request(server, 87)) == 0)
326 {
327 if (DOS_dir_base) *DOS_dir_base=ncp_reply_dword(server, 0x34);
328 }
329 ncp_unlock_server(server);
330 return result;
331 }
332 #endif /* CONFIG_NCPFS_NFS_NS */
333
334 static inline int
335 ncp_get_known_namespace(struct ncp_server *server, __u8 volume)
336 {
337 #if defined(CONFIG_NCPFS_OS2_NS) || defined(CONFIG_NCPFS_NFS_NS)
338 int result;
339 __u8 *namespace;
340 __u16 no_namespaces;
341
342 ncp_init_request(server);
343 ncp_add_byte(server, 24); /* Subfunction: Get Name Spaces Loaded */
344 ncp_add_word(server, 0);
345 ncp_add_byte(server, volume);
346
347 if ((result = ncp_request(server, 87)) != 0) {
348 ncp_unlock_server(server);
349 return NW_NS_DOS; /* not result ?? */
350 }
351
352 result = NW_NS_DOS;
353 no_namespaces = ncp_reply_word(server, 0);
354 namespace = ncp_reply_data(server, 2);
355
356 while (no_namespaces > 0) {
357 DPRINTK("get_namespaces: found %d on %d\n", *namespace, volume);
358
359 #ifdef CONFIG_NCPFS_NFS_NS
360 if ((*namespace == NW_NS_NFS) && !(server->m.flags&NCP_MOUNT_NO_NFS))
361 {
362 result = NW_NS_NFS;
363 break;
364 }
365 #endif /* CONFIG_NCPFS_NFS_NS */
366 #ifdef CONFIG_NCPFS_OS2_NS
367 if ((*namespace == NW_NS_OS2) && !(server->m.flags&NCP_MOUNT_NO_OS2))
368 {
369 result = NW_NS_OS2;
370 }
371 #endif /* CONFIG_NCPFS_OS2_NS */
372 namespace += 1;
373 no_namespaces -= 1;
374 }
375 ncp_unlock_server(server);
376 return result;
377 #else /* neither OS2 nor NFS - only DOS */
378 return NW_NS_DOS;
379 #endif /* defined(CONFIG_NCPFS_OS2_NS) || defined(CONFIG_NCPFS_NFS_NS) */
380 }
381
382 static int
383 ncp_ObtainSpecificDirBase(struct ncp_server *server,
384 __u8 nsSrc, __u8 nsDst, __u8 vol_num, __u32 dir_base,
385 char *path, /* At most 1 component */
386 __u32 *dirEntNum, __u32 *DosDirNum)
387 {
388 int result;
389
390 ncp_init_request(server);
391 ncp_add_byte(server, 6); /* subfunction */
392 ncp_add_byte(server, nsSrc);
393 ncp_add_byte(server, nsDst);
394 ncp_add_word(server, htons(0x0680)); /* get all */
395 ncp_add_dword(server, RIM_ALL);
396 ncp_add_handle_path(server, vol_num, dir_base, 1, path);
397
398 if ((result = ncp_request(server, 87)) != 0)
399 {
400 ncp_unlock_server(server);
401 return result;
402 }
403
404 if (dirEntNum)
405 *dirEntNum = ncp_reply_dword(server, 0x30);
406 if (DosDirNum)
407 *DosDirNum = ncp_reply_dword(server, 0x34);
408 ncp_unlock_server(server);
409 return 0;
410 }
411
412 int
413 ncp_mount_subdir(struct ncp_server *server, struct nw_info_struct *i,
414 __u8 volNumber, __u8 srcNS, __u32 dirEntNum)
415 {
416 int dstNS;
417 int result;
418 __u32 newDirEnt;
419 __u32 newDosEnt;
420
421 dstNS = ncp_get_known_namespace(server, volNumber);
422 if ((result = ncp_ObtainSpecificDirBase(server, srcNS, dstNS, volNumber,
423 dirEntNum, NULL, &newDirEnt, &newDosEnt)) != 0)
424 {
425 return result;
426 }
427 server->name_space[volNumber] = dstNS;
428 i->volNumber = volNumber;
429 i->dirEntNum = newDirEnt;
430 i->DosDirNum = newDosEnt;
431 server->m.mounted_vol[1] = 0;
432 server->m.mounted_vol[0] = 'X';
433 return 0;
434 }
435
436 int
437 ncp_lookup_volume(struct ncp_server *server, char *volname,
438 struct nw_info_struct *target)
439 {
440 int result;
441 int volnum;
442
443 DPRINTK("ncp_lookup_volume: looking up vol %s\n", volname);
444
445 ncp_init_request(server);
446 ncp_add_byte(server, 22); /* Subfunction: Generate dir handle */
447 ncp_add_byte(server, 0); /* DOS namespace */
448 ncp_add_byte(server, 0); /* reserved */
449 ncp_add_byte(server, 0); /* reserved */
450 ncp_add_byte(server, 0); /* reserved */
451
452 ncp_add_byte(server, 0); /* faked volume number */
453 ncp_add_dword(server, 0); /* faked dir_base */
454 ncp_add_byte(server, 0xff); /* Don't have a dir_base */
455 ncp_add_byte(server, 1); /* 1 path component */
456 ncp_add_pstring(server, volname);
457
458 if ((result = ncp_request(server, 87)) != 0) {
459 ncp_unlock_server(server);
460 return result;
461 }
462 memset(target, 0, sizeof(*target));
463 target->DosDirNum = target->dirEntNum = ncp_reply_dword(server, 4);
464 target->volNumber = volnum = ncp_reply_byte(server, 8);
465 ncp_unlock_server(server);
466
467 server->name_space[volnum] = ncp_get_known_namespace(server, volnum);
468
469 DPRINTK("lookup_vol: namespace[%d] = %d\n",
470 volnum, server->name_space[volnum]);
471
472 target->nameLen = strlen(volname);
473 memcpy(target->entryName, volname, target->nameLen+1);
474 target->attributes = aDIR;
475 /* set dates to Jan 1, 1986 00:00 */
476 target->creationTime = target->modifyTime = cpu_to_le16(0x0000);
477 target->creationDate = target->modifyDate = target->lastAccessDate = cpu_to_le16(0x0C21);
478 return 0;
479 }
480
481 int ncp_modify_file_or_subdir_dos_info_path(struct ncp_server *server,
482 struct inode *dir,
483 const char *path,
484 __u32 info_mask,
485 const struct nw_modify_dos_info *info)
486 {
487 __u8 volnum = NCP_FINFO(dir)->volNumber;
488 __u32 dirent = NCP_FINFO(dir)->dirEntNum;
489 int result;
490
491 ncp_init_request(server);
492 ncp_add_byte(server, 7); /* subfunction */
493 ncp_add_byte(server, server->name_space[volnum]);
494 ncp_add_byte(server, 0); /* reserved */
495 ncp_add_word(server, htons(0x0680)); /* search attribs: all */
496
497 ncp_add_dword(server, info_mask);
498 ncp_add_mem(server, info, sizeof(*info));
499 ncp_add_handle_path(server, volnum, dirent, 1, path);
500
501 result = ncp_request(server, 87);
502 ncp_unlock_server(server);
503 return result;
504 }
505
506 int ncp_modify_file_or_subdir_dos_info(struct ncp_server *server,
507 struct inode *dir,
508 __u32 info_mask,
509 const struct nw_modify_dos_info *info)
510 {
511 return ncp_modify_file_or_subdir_dos_info_path(server, dir, NULL,
512 info_mask, info);
513 }
514
515 static int
516 ncp_DeleteNSEntry(struct ncp_server *server,
517 __u8 have_dir_base, __u8 volnum, __u32 dirent,
518 char* name, __u8 ns, int attr)
519 {
520 int result;
521
522 ncp_init_request(server);
523 ncp_add_byte(server, 8); /* subfunction */
524 ncp_add_byte(server, ns);
525 ncp_add_byte(server, 0); /* reserved */
526 ncp_add_word(server, attr); /* search attribs: all */
527 ncp_add_handle_path(server, volnum, dirent, have_dir_base, name);
528
529 result = ncp_request(server, 87);
530 ncp_unlock_server(server);
531 return result;
532 }
533
534 int
535 ncp_del_file_or_subdir2(struct ncp_server *server,
536 struct dentry *dentry)
537 {
538 struct inode *inode = dentry->d_inode;
539 __u8 volnum;
540 __u32 dirent;
541
542 if (!inode) {
543 #if CONFIG_NCPFS_DEBUGDENTRY
544 PRINTK("ncpfs: ncpdel2: dentry->d_inode == NULL\n");
545 #endif
546 return 0xFF; /* Any error */
547 }
548 volnum = NCP_FINFO(inode)->volNumber;
549 dirent = NCP_FINFO(inode)->DosDirNum;
550 return ncp_DeleteNSEntry(server, 1, volnum, dirent, NULL, NW_NS_DOS, htons(0x0680));
551 }
552
553 int
554 ncp_del_file_or_subdir(struct ncp_server *server,
555 struct inode *dir, char *name)
556 {
557 __u8 volnum = NCP_FINFO(dir)->volNumber;
558 __u32 dirent = NCP_FINFO(dir)->dirEntNum;
559
560 #ifdef CONFIG_NCPFS_NFS_NS
561 if (server->name_space[volnum]==NW_NS_NFS)
562 {
563 int result;
564
565 result=ncp_obtain_DOS_dir_base(server, volnum, dirent, name, &dirent);
566 if (result) return result;
567 return ncp_DeleteNSEntry(server, 1, volnum, dirent, NULL, NW_NS_DOS, htons(0x0680));
568 }
569 else
570 #endif /* CONFIG_NCPFS_NFS_NS */
571 return ncp_DeleteNSEntry(server, 1, volnum, dirent, name, server->name_space[volnum], htons(0x0680));
572 }
573
574 static inline void ConvertToNWfromDWORD(__u32 sfd, __u8 ret[6])
575 {
576 __u16 *dest = (__u16 *) ret;
577 memcpy(ret + 2, &sfd, 4);
578 dest[0] = cpu_to_le16((le16_to_cpu(dest[1]) + le16_to_cpu(1)));
579 return;
580 }
581
582 /* If both dir and name are NULL, then in target there's already a
583 looked-up entry that wants to be opened. */
584 int ncp_open_create_file_or_subdir(struct ncp_server *server,
585 struct inode *dir, char *name,
586 int open_create_mode,
587 __u32 create_attributes,
588 int desired_acc_rights,
589 struct ncp_entry_info *target)
590 {
591 __u16 search_attribs = ntohs(0x0600);
592 __u8 volnum = target->i.volNumber;
593 __u32 dirent = target->i.dirEntNum;
594 int result;
595
596 if (dir)
597 {
598 volnum = NCP_FINFO(dir)->volNumber;
599 dirent = NCP_FINFO(dir)->dirEntNum;
600 }
601
602 if ((create_attributes & aDIR) != 0) {
603 search_attribs |= ntohs(0x0080);
604 }
605 ncp_init_request(server);
606 ncp_add_byte(server, 1); /* subfunction */
607 ncp_add_byte(server, server->name_space[volnum]);
608 ncp_add_byte(server, open_create_mode);
609 ncp_add_word(server, search_attribs);
610 ncp_add_dword(server, RIM_ALL);
611 ncp_add_dword(server, create_attributes);
612 /* The desired acc rights seem to be the inherited rights mask
613 for directories */
614 ncp_add_word(server, desired_acc_rights);
615 ncp_add_handle_path(server, volnum, dirent, 1, name);
616
617 if ((result = ncp_request(server, 87)) != 0)
618 goto out;
619 if (!(create_attributes & aDIR))
620 target->opened = 1;
621 target->server_file_handle = ncp_reply_dword(server, 0);
622 target->open_create_action = ncp_reply_byte(server, 4);
623
624 /* in target there's a new finfo to fill */
625 ncp_extract_file_info(ncp_reply_data(server, 6), &(target->i));
626 ConvertToNWfromDWORD(target->server_file_handle, target->file_handle);
627
628 out:
629 ncp_unlock_server(server);
630 return result;
631 }
632
633 int
634 ncp_initialize_search(struct ncp_server *server, struct inode *dir,
635 struct nw_search_sequence *target)
636 {
637 __u8 volnum = NCP_FINFO(dir)->volNumber;
638 __u32 dirent = NCP_FINFO(dir)->dirEntNum;
639 int result;
640
641 ncp_init_request(server);
642 ncp_add_byte(server, 2); /* subfunction */
643 ncp_add_byte(server, server->name_space[volnum]);
644 ncp_add_byte(server, 0); /* reserved */
645 ncp_add_handle_path(server, volnum, dirent, 1, NULL);
646
647 result = ncp_request(server, 87);
648 if (result)
649 goto out;
650 memcpy(target, ncp_reply_data(server, 0), sizeof(*target));
651
652 out:
653 ncp_unlock_server(server);
654 return result;
655 }
656
657 /* Search for everything */
658 int ncp_search_for_file_or_subdir(struct ncp_server *server,
659 struct nw_search_sequence *seq,
660 struct nw_info_struct *target)
661 {
662 int result;
663
664 ncp_init_request(server);
665 ncp_add_byte(server, 3); /* subfunction */
666 ncp_add_byte(server, server->name_space[seq->volNumber]);
667 ncp_add_byte(server, 0); /* data stream (???) */
668 ncp_add_word(server, htons(0x0680)); /* Search attribs */
669 ncp_add_dword(server, RIM_ALL); /* return info mask */
670 ncp_add_mem(server, seq, 9);
671 #ifdef CONFIG_NCPFS_NFS_NS
672 if (server->name_space[seq->volNumber] == NW_NS_NFS) {
673 ncp_add_byte(server, 0); /* 0 byte pattern */
674 } else
675 #endif
676 {
677 ncp_add_byte(server, 2); /* 2 byte pattern */
678 ncp_add_byte(server, 0xff); /* following is a wildcard */
679 ncp_add_byte(server, '*');
680 }
681
682 if ((result = ncp_request(server, 87)) != 0)
683 goto out;
684 memcpy(seq, ncp_reply_data(server, 0), sizeof(*seq));
685 ncp_extract_file_info(ncp_reply_data(server, 10), target);
686
687 out:
688 ncp_unlock_server(server);
689 return result;
690 }
691
692 int
693 ncp_RenameNSEntry(struct ncp_server *server,
694 struct inode *old_dir, char *old_name, int old_type,
695 struct inode *new_dir, char *new_name)
696 {
697 int result = -EINVAL;
698
699 if ((old_dir == NULL) || (old_name == NULL) ||
700 (new_dir == NULL) || (new_name == NULL))
701 goto out;
702
703 ncp_init_request(server);
704 ncp_add_byte(server, 4); /* subfunction */
705 ncp_add_byte(server, server->name_space[NCP_FINFO(old_dir)->volNumber]);
706 ncp_add_byte(server, 1); /* rename flag */
707 ncp_add_word(server, old_type); /* search attributes */
708
709 /* source Handle Path */
710 ncp_add_byte(server, NCP_FINFO(old_dir)->volNumber);
711 ncp_add_dword(server, NCP_FINFO(old_dir)->dirEntNum);
712 ncp_add_byte(server, 1);
713 ncp_add_byte(server, 1); /* 1 source component */
714
715 /* dest Handle Path */
716 ncp_add_byte(server, NCP_FINFO(new_dir)->volNumber);
717 ncp_add_dword(server, NCP_FINFO(new_dir)->dirEntNum);
718 ncp_add_byte(server, 1);
719 ncp_add_byte(server, 1); /* 1 destination component */
720
721 /* source path string */
722 ncp_add_pstring(server, old_name);
723 /* dest path string */
724 ncp_add_pstring(server, new_name);
725
726 result = ncp_request(server, 87);
727 ncp_unlock_server(server);
728 out:
729 return result;
730 }
731
732 int ncp_ren_or_mov_file_or_subdir(struct ncp_server *server,
733 struct inode *old_dir, char *old_name,
734 struct inode *new_dir, char *new_name)
735 {
736 int result;
737 int old_type = htons(0x0600);
738
739 /* If somebody can do it atomic, call me... vandrove@vc.cvut.cz */
740 result = ncp_RenameNSEntry(server, old_dir, old_name, old_type,
741 new_dir, new_name);
742 if (result == 0xFF) /* File Not Found, try directory */
743 {
744 old_type = htons(0x1600);
745 result = ncp_RenameNSEntry(server, old_dir, old_name, old_type,
746 new_dir, new_name);
747 }
748 if (result != 0x92) return result; /* All except NO_FILES_RENAMED */
749 result = ncp_del_file_or_subdir(server, new_dir, new_name);
750 if (result != 0) return -EACCES;
751 result = ncp_RenameNSEntry(server, old_dir, old_name, old_type,
752 new_dir, new_name);
753 return result;
754 }
755
756
757 /* We have to transfer to/from user space */
758 int
759 ncp_read_kernel(struct ncp_server *server, const char *file_id,
760 __u32 offset, __u16 to_read, char *target, int *bytes_read)
761 {
762 char *source;
763 int result;
764
765 ncp_init_request(server);
766 ncp_add_byte(server, 0);
767 ncp_add_mem(server, file_id, 6);
768 ncp_add_dword(server, htonl(offset));
769 ncp_add_word(server, htons(to_read));
770
771 if ((result = ncp_request(server, 72)) != 0) {
772 goto out;
773 }
774 *bytes_read = ntohs(ncp_reply_word(server, 0));
775 source = ncp_reply_data(server, 2 + (offset & 1));
776
777 memcpy(target, source, *bytes_read);
778 out:
779 ncp_unlock_server(server);
780 return result;
781 }
782
783 /* There is a problem... egrep and some other silly tools do:
784 x = mmap(NULL, MAP_PRIVATE, PROT_READ|PROT_WRITE, <ncpfs fd>, 32768);
785 read(<ncpfs fd>, x, 32768);
786 Now copying read result by copy_to_user causes pagefault. This pagefault
787 could not be handled because of server was locked due to read. So we have
788 to use temporary buffer. So ncp_unlock_server must be done before
789 copy_to_user (and for write, copy_from_user must be done before
790 ncp_init_request... same applies for send raw packet ioctl). Because of
791 file is normally read in bigger chunks, caller provides kmalloced
792 (vmalloced) chunk of memory with size >= to_read...
793 */
794 int
795 ncp_read_bounce(struct ncp_server *server, const char *file_id,
796 __u32 offset, __u16 to_read, char *target, int *bytes_read,
797 void* bounce, __u32 bufsize)
798 {
799 int result;
800
801 ncp_init_request(server);
802 ncp_add_byte(server, 0);
803 ncp_add_mem(server, file_id, 6);
804 ncp_add_dword(server, htonl(offset));
805 ncp_add_word(server, htons(to_read));
806 result = ncp_request2(server, 72, bounce, bufsize);
807 ncp_unlock_server(server);
808 if (!result) {
809 int len = be16_to_cpu(get_unaligned((__u16*)((char*)bounce +
810 sizeof(struct ncp_reply_header))));
811 result = -EIO;
812 if (len <= to_read) {
813 char* source;
814
815 source = (char*)bounce +
816 sizeof(struct ncp_reply_header) + 2 +
817 (offset & 1);
818 *bytes_read = len;
819 result = 0;
820 if (copy_to_user(target, source, len))
821 result = -EFAULT;
822 }
823 }
824 return result;
825 }
826
827 int
828 ncp_write_kernel(struct ncp_server *server, const char *file_id,
829 __u32 offset, __u16 to_write,
830 const char *source, int *bytes_written)
831 {
832 int result;
833
834 ncp_init_request(server);
835 ncp_add_byte(server, 0);
836 ncp_add_mem(server, file_id, 6);
837 ncp_add_dword(server, htonl(offset));
838 ncp_add_word(server, htons(to_write));
839 ncp_add_mem(server, source, to_write);
840
841 if ((result = ncp_request(server, 73)) == 0)
842 *bytes_written = to_write;
843 ncp_unlock_server(server);
844 return result;
845 }
846
847 #ifdef CONFIG_NCPFS_IOCTL_LOCKING
848 int
849 ncp_LogPhysicalRecord(struct ncp_server *server, const char *file_id,
850 __u8 locktype, __u32 offset, __u32 length, __u16 timeout)
851 {
852 int result;
853
854 ncp_init_request(server);
855 ncp_add_byte(server, locktype);
856 ncp_add_mem(server, file_id, 6);
857 ncp_add_dword(server, htonl(offset));
858 ncp_add_dword(server, htonl(length));
859 ncp_add_word(server, htons(timeout));
860
861 if ((result = ncp_request(server, 0x1A)) != 0)
862 {
863 ncp_unlock_server(server);
864 return result;
865 }
866 ncp_unlock_server(server);
867 return 0;
868 }
869
870 int
871 ncp_ClearPhysicalRecord(struct ncp_server *server, const char *file_id,
872 __u32 offset, __u32 length)
873 {
874 int result;
875
876 ncp_init_request(server);
877 ncp_add_byte(server, 0); /* who knows... lanalyzer says that */
878 ncp_add_mem(server, file_id, 6);
879 ncp_add_dword(server, htonl(offset));
880 ncp_add_dword(server, htonl(length));
881
882 if ((result = ncp_request(server, 0x1E)) != 0)
883 {
884 ncp_unlock_server(server);
885 return result;
886 }
887 ncp_unlock_server(server);
888 return 0;
889 }
890 #endif /* CONFIG_NCPFS_IOCTL_LOCKING */
891
892 #ifdef CONFIG_NCPFS_NLS
893 /* This are the NLS conversion routines with inspirations and code parts
894 * from the vfat file system and hints from Petr Vandrovec.
895 */
896
897 inline unsigned char
898 ncp__tolower(struct nls_table *t, unsigned char c)
899 {
900 unsigned char nc = t->charset2lower[c];
901
902 return nc ? nc : c;
903 }
904
905 inline unsigned char
906 ncp__toupper(struct nls_table *t, unsigned char c)
907 {
908 unsigned char nc = t->charset2upper[c];
909
910 return nc ? nc : c;
911 }
912
913 int
914 ncp__io2vol(struct ncp_server *server, unsigned char *vname, unsigned int *vlen,
915 const unsigned char *iname, unsigned int ilen, int cc)
916 {
917 struct nls_table *in = server->nls_io;
918 struct nls_table *out = server->nls_vol;
919 unsigned char *vname_start;
920 unsigned char *vname_end;
921 const unsigned char *iname_end;
922
923 iname_end = iname + ilen;
924 vname_start = vname;
925 vname_end = vname + *vlen - 1;
926
927 while (iname < iname_end) {
928 int chl;
929 wchar_t ec;
930
931 if (NCP_IS_FLAG(server, NCP_FLAG_UTF8)) {
932 int k;
933
934 k = utf8_mbtowc(&ec, iname, iname_end - iname);
935 if (k < 0)
936 return -EINVAL;
937 iname += k;
938 } else {
939 if (*iname == NCP_ESC) {
940 int k;
941
942 if (iname_end - iname < 5)
943 goto nospec;
944
945 ec = 0;
946 for (k = 1; k < 5; k++) {
947 unsigned char nc;
948
949 nc = iname[k] - '0';
950 if (nc >= 10) {
951 nc -= 'A' - '0' - 10;
952 if ((nc < 10) || (nc > 15)) {
953 goto nospec;
954 }
955 }
956 ec = (ec << 4) | nc;
957 }
958 iname += 5;
959 } else {
960 nospec:;
961 if ( (chl = in->char2uni(iname, iname_end - iname, &ec)) < 0)
962 return chl;
963 iname += chl;
964 }
965 }
966
967 /* unitoupper should be here! */
968
969 chl = out->uni2char(ec, vname, vname_end - vname);
970 if (chl < 0)
971 return chl;
972
973 /* this is wrong... */
974 if (cc) {
975 int chi;
976
977 for (chi = 0; chi < chl; chi++){
978 vname[chi] = ncp_toupper(out, vname[chi]);
979 }
980 }
981 vname += chl;
982 }
983
984 *vname = 0;
985 *vlen = vname - vname_start;
986 return 0;
987 }
988
989 int
990 ncp__vol2io(struct ncp_server *server, unsigned char *iname, unsigned int *ilen,
991 const unsigned char *vname, unsigned int vlen, int cc)
992 {
993 struct nls_table *in = server->nls_vol;
994 struct nls_table *out = server->nls_io;
995 const unsigned char *vname_end;
996 unsigned char *iname_start;
997 unsigned char *iname_end;
998 unsigned char *vname_cc;
999 int err;
1000
1001 vname_cc = NULL;
1002
1003 if (cc) {
1004 int i;
1005
1006 /* this is wrong! */
1007 vname_cc = kmalloc(vlen, GFP_KERNEL);
1008 for (i = 0; i < vlen; i++)
1009 vname_cc[i] = ncp_tolower(in, vname[i]);
1010 vname = vname_cc;
1011 }
1012
1013 iname_start = iname;
1014 iname_end = iname + *ilen - 1;
1015 vname_end = vname + vlen;
1016
1017 while (vname < vname_end) {
1018 wchar_t ec;
1019 int chl;
1020
1021 if ( (chl = in->char2uni(vname, vname_end - vname, &ec)) < 0) {
1022 err = chl;
1023 goto quit;
1024 }
1025 vname += chl;
1026
1027 /* unitolower should be here! */
1028
1029 if (NCP_IS_FLAG(server, NCP_FLAG_UTF8)) {
1030 int k;
1031
1032 k = utf8_wctomb(iname, ec, iname_end - iname);
1033 if (k < 0) {
1034 err = -ENAMETOOLONG;
1035 goto quit;
1036 }
1037 iname += k;
1038 } else {
1039 if ( (chl = out->uni2char(ec, iname, iname_end - iname)) >= 0) {
1040 iname += chl;
1041 } else {
1042 int k;
1043
1044 if (iname_end - iname < 5) {
1045 err = -ENAMETOOLONG;
1046 goto quit;
1047 }
1048 *iname = NCP_ESC;
1049 for (k = 4; k > 0; k--) {
1050 unsigned char v;
1051
1052 v = (ec & 0xF) + '0';
1053 if (v > '9') {
1054 v += 'A' - '9' - 1;
1055 }
1056 iname[k] = v;
1057 ec >>= 4;
1058 }
1059 iname += 5;
1060 }
1061 }
1062 }
1063
1064 *iname = 0;
1065 *ilen = iname - iname_start;
1066 err = 0;
1067 quit:;
1068 if (cc)
1069 kfree(vname_cc);
1070 return err;
1071 }
1072
1073 #else
1074
1075 int
1076 ncp__io2vol(unsigned char *vname, unsigned int *vlen,
1077 const unsigned char *iname, unsigned int ilen, int cc)
1078 {
1079 int i;
1080
1081 if (*vlen <= ilen)
1082 return -ENAMETOOLONG;
1083
1084 if (cc)
1085 for (i = 0; i < ilen; i++) {
1086 *vname = toupper(*iname);
1087 vname++;
1088 iname++;
1089 }
1090 else {
1091 memmove(vname, iname, ilen);
1092 vname += ilen;
1093 }
1094
1095 *vlen = ilen;
1096 *vname = 0;
1097 return 0;
1098 }
1099
1100 int
1101 ncp__vol2io(unsigned char *iname, unsigned int *ilen,
1102 const unsigned char *vname, unsigned int vlen, int cc)
1103 {
1104 int i;
1105
1106 if (*ilen <= vlen)
1107 return -ENAMETOOLONG;
1108
1109 if (cc)
1110 for (i = 0; i < vlen; i++) {
1111 *iname = tolower(*vname);
1112 iname++;
1113 vname++;
1114 }
1115 else {
1116 memmove(iname, vname, vlen);
1117 iname += vlen;
1118 }
1119
1120 *ilen = vlen;
1121 *iname = 0;
1122 return 0;
1123 }
1124
1125 #endif
1126
1127 inline int
1128 ncp_strnicmp(struct nls_table *t, const unsigned char *s1,
1129 const unsigned char *s2, int n)
1130 {
1131 int i;
1132
1133 for (i=0; i<n; i++)
1134 if (ncp_tolower(t, s1[i]) != ncp_tolower(t, s2[i]))
1135 return 1;
1136
1137 return 0;
1138 }
Mirror of the linux-mips.org kernel tree