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