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