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