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
13 #include <linux/config.h>
15 #include "ncplib_kernel.h"
17 static inline void assert_server_locked(struct ncp_server *server)
19 if (server->lock == 0) {
20 DPRINTK("ncpfs: server not locked!\n");
24 static void ncp_add_byte(struct ncp_server *server, __u8 x)
26 assert_server_locked(server);
27 *(__u8 *) (&(server->packet[server->current_size])) = x;
28 server->current_size += 1;
32 static void ncp_add_word(struct ncp_server *server, __u16 x)
34 assert_server_locked(server);
35 put_unaligned(x, (__u16 *) (&(server->packet[server->current_size])));
36 server->current_size += 2;
40 static void ncp_add_dword(struct ncp_server *server, __u32 x)
42 assert_server_locked(server);
43 put_unaligned(x, (__u32 *) (&(server->packet[server->current_size])));
44 server->current_size += 4;
48 static inline void ncp_add_dword_lh(struct ncp_server *server, __u32 x) {
49 ncp_add_dword(server, cpu_to_le32(x));
52 static void ncp_add_mem(struct ncp_server *server, const void *source, int size)
54 assert_server_locked(server);
55 memcpy(&(server->packet[server->current_size]), source, size);
56 server->current_size += size;
60 static void ncp_add_pstring(struct ncp_server *server, const char *s)
63 assert_server_locked(server);
65 DPRINTK("ncpfs: string too long: %s\n", s);
68 ncp_add_byte(server, len);
69 ncp_add_mem(server, s, len);
73 static inline void ncp_init_request(struct ncp_server *server)
75 ncp_lock_server(server);
77 server->current_size = sizeof(struct ncp_request_header);
78 server->has_subfunction = 0;
81 static inline void ncp_init_request_s(struct ncp_server *server, int subfunction)
83 ncp_lock_server(server);
85 server->current_size = sizeof(struct ncp_request_header) + 2;
86 ncp_add_byte(server, subfunction);
88 server->has_subfunction = 1;
92 ncp_reply_data(struct ncp_server *server, int offset)
94 return &(server->packet[sizeof(struct ncp_reply_header) + offset]);
97 static inline __u8 BVAL(void* data)
99 return get_unaligned((__u8*)data);
103 ncp_reply_byte(struct ncp_server *server, int offset)
105 return get_unaligned((__u8 *) ncp_reply_data(server, offset));
108 static inline __u16 WVAL_LH(void* data)
110 return le16_to_cpu(get_unaligned((__u16*)data));
114 ncp_reply_word(struct ncp_server *server, int offset)
116 return get_unaligned((__u16 *) ncp_reply_data(server, offset));
119 static inline __u32 DVAL_LH(void* data)
121 return le32_to_cpu(get_unaligned((__u32*)data));
125 ncp_reply_dword(struct ncp_server *server, int offset)
127 return get_unaligned((__u32 *) ncp_reply_data(server, offset));
130 static inline __u32 ncp_reply_dword_lh(struct ncp_server* server, int offset) {
131 return le32_to_cpu(ncp_reply_dword(server, offset));
135 ncp_negotiate_buffersize(struct ncp_server *server, int size, int *target)
139 ncp_init_request(server);
140 ncp_add_word(server, htons(size));
142 if ((result = ncp_request(server, 33)) != 0) {
143 ncp_unlock_server(server);
146 *target = min_t(unsigned int, ntohs(ncp_reply_word(server, 0)), size);
148 ncp_unlock_server(server);
155 * bit 1 packet signing
158 ncp_negotiate_size_and_options(struct ncp_server *server,
159 int size, int options, int *ret_size, int *ret_options) {
162 /* there is minimum */
163 if (size < NCP_BLOCK_SIZE) size = NCP_BLOCK_SIZE;
165 ncp_init_request(server);
166 ncp_add_word(server, htons(size));
167 ncp_add_byte(server, options);
169 if ((result = ncp_request(server, 0x61)) != 0)
171 ncp_unlock_server(server);
175 /* NCP over UDP returns 0 (!!!) */
176 result = ntohs(ncp_reply_word(server, 0));
177 if (result >= NCP_BLOCK_SIZE)
178 size = min(result, size);
180 *ret_options = ncp_reply_byte(server, 4);
182 ncp_unlock_server(server);
186 int ncp_get_volume_info_with_number(struct ncp_server* server,
187 int n, struct ncp_volume_info* target) {
191 ncp_init_request_s(server, 44);
192 ncp_add_byte(server, n);
194 if ((result = ncp_request(server, 22)) != 0) {
197 target->total_blocks = ncp_reply_dword_lh(server, 0);
198 target->free_blocks = ncp_reply_dword_lh(server, 4);
199 target->purgeable_blocks = ncp_reply_dword_lh(server, 8);
200 target->not_yet_purgeable_blocks = ncp_reply_dword_lh(server, 12);
201 target->total_dir_entries = ncp_reply_dword_lh(server, 16);
202 target->available_dir_entries = ncp_reply_dword_lh(server, 20);
203 target->sectors_per_block = ncp_reply_byte(server, 28);
205 memset(&(target->volume_name), 0, sizeof(target->volume_name));
208 len = ncp_reply_byte(server, 29);
209 if (len > NCP_VOLNAME_LEN) {
210 DPRINTK("ncpfs: volume name too long: %d\n", len);
213 memcpy(&(target->volume_name), ncp_reply_data(server, 30), len);
216 ncp_unlock_server(server);
220 int ncp_get_directory_info(struct ncp_server* server, __u8 n,
221 struct ncp_volume_info* target) {
225 ncp_init_request_s(server, 45);
226 ncp_add_byte(server, n);
228 if ((result = ncp_request(server, 22)) != 0) {
231 target->total_blocks = ncp_reply_dword_lh(server, 0);
232 target->free_blocks = ncp_reply_dword_lh(server, 4);
233 target->purgeable_blocks = 0;
234 target->not_yet_purgeable_blocks = 0;
235 target->total_dir_entries = ncp_reply_dword_lh(server, 8);
236 target->available_dir_entries = ncp_reply_dword_lh(server, 12);
237 target->sectors_per_block = ncp_reply_byte(server, 20);
239 memset(&(target->volume_name), 0, sizeof(target->volume_name));
242 len = ncp_reply_byte(server, 21);
243 if (len > NCP_VOLNAME_LEN) {
244 DPRINTK("ncpfs: volume name too long: %d\n", len);
247 memcpy(&(target->volume_name), ncp_reply_data(server, 22), len);
250 ncp_unlock_server(server);
255 ncp_close_file(struct ncp_server *server, const char *file_id)
259 ncp_init_request(server);
260 ncp_add_byte(server, 0);
261 ncp_add_mem(server, file_id, 6);
263 result = ncp_request(server, 66);
264 ncp_unlock_server(server);
269 ncp_make_closed(struct inode *inode)
274 down(&NCP_FINFO(inode)->open_sem);
275 if (atomic_read(&NCP_FINFO(inode)->opened) == 1) {
276 atomic_set(&NCP_FINFO(inode)->opened, 0);
277 err = ncp_close_file(NCP_SERVER(inode), NCP_FINFO(inode)->file_handle);
280 PPRINTK("ncp_make_closed: volnum=%d, dirent=%u, error=%d\n",
281 NCP_FINFO(inode)->volNumber,
282 NCP_FINFO(inode)->dirEntNum, err);
284 up(&NCP_FINFO(inode)->open_sem);
288 static void ncp_add_handle_path(struct ncp_server *server, __u8 vol_num,
289 __u32 dir_base, int have_dir_base,
292 ncp_add_byte(server, vol_num);
293 ncp_add_dword(server, dir_base);
294 if (have_dir_base != 0) {
295 ncp_add_byte(server, 1); /* dir_base */
297 ncp_add_byte(server, 0xff); /* no handle */
300 ncp_add_byte(server, 1); /* 1 component */
301 ncp_add_pstring(server, path);
303 ncp_add_byte(server, 0);
307 int ncp_dirhandle_alloc(struct ncp_server* server, __u8 volnum, __u32 dirent,
311 ncp_init_request(server);
312 ncp_add_byte(server, 12); /* subfunction */
313 ncp_add_byte(server, NW_NS_DOS);
314 ncp_add_byte(server, 0);
315 ncp_add_word(server, 0);
316 ncp_add_handle_path(server, volnum, dirent, 1, NULL);
317 if ((result = ncp_request(server, 87)) == 0) {
318 *dirhandle = ncp_reply_byte(server, 0);
320 ncp_unlock_server(server);
324 int ncp_dirhandle_free(struct ncp_server* server, __u8 dirhandle) {
327 ncp_init_request_s(server, 20);
328 ncp_add_byte(server, dirhandle);
329 result = ncp_request(server, 22);
330 ncp_unlock_server(server);
334 void ncp_extract_file_info(void *structure, struct nw_info_struct *target)
337 const int info_struct_size = offsetof(struct nw_info_struct, nameLen);
339 memcpy(target, structure, info_struct_size);
340 name_len = structure + info_struct_size;
341 target->nameLen = *name_len;
342 memcpy(target->entryName, name_len + 1, *name_len);
343 target->entryName[*name_len] = '\0';
344 target->volNumber = le32_to_cpu(target->volNumber);
348 #ifdef CONFIG_NCPFS_NFS_NS
349 static inline void ncp_extract_nfs_info(unsigned char *structure,
350 struct nw_nfs_info *target)
352 target->mode = DVAL_LH(structure);
353 target->rdev = DVAL_LH(structure + 8);
357 int ncp_obtain_nfs_info(struct ncp_server *server,
358 struct nw_info_struct *target)
362 #ifdef CONFIG_NCPFS_NFS_NS
363 __u32 volnum = target->volNumber;
365 if (ncp_is_nfs_extras(server, volnum)) {
366 ncp_init_request(server);
367 ncp_add_byte(server, 19); /* subfunction */
368 ncp_add_byte(server, server->name_space[volnum]);
369 ncp_add_byte(server, NW_NS_NFS);
370 ncp_add_byte(server, 0);
371 ncp_add_byte(server, volnum);
372 ncp_add_dword(server, target->dirEntNum);
373 /* We must retrieve both nlinks and rdev, otherwise some server versions
374 report zeroes instead of valid data */
375 ncp_add_dword_lh(server, NSIBM_NFS_MODE | NSIBM_NFS_NLINKS | NSIBM_NFS_RDEV);
377 if ((result = ncp_request(server, 87)) == 0) {
378 ncp_extract_nfs_info(ncp_reply_data(server, 0), &target->nfs);
380 "ncp_obtain_nfs_info: (%s) mode=0%o, rdev=0x%x\n",
381 target->entryName, target->nfs.mode,
384 target->nfs.mode = 0;
385 target->nfs.rdev = 0;
387 ncp_unlock_server(server);
392 target->nfs.mode = 0;
393 target->nfs.rdev = 0;
399 * Returns information for a (one-component) name relative to
400 * the specified directory.
402 int ncp_obtain_info(struct ncp_server *server, struct inode *dir, char *path,
403 struct nw_info_struct *target)
405 __u8 volnum = NCP_FINFO(dir)->volNumber;
406 __u32 dirent = NCP_FINFO(dir)->dirEntNum;
409 if (target == NULL) {
410 printk(KERN_ERR "ncp_obtain_info: invalid call\n");
413 ncp_init_request(server);
414 ncp_add_byte(server, 6); /* subfunction */
415 ncp_add_byte(server, server->name_space[volnum]);
416 ncp_add_byte(server, server->name_space[volnum]); /* N.B. twice ?? */
417 ncp_add_word(server, htons(0x0680)); /* get all */
418 ncp_add_dword(server, RIM_ALL);
419 ncp_add_handle_path(server, volnum, dirent, 1, path);
421 if ((result = ncp_request(server, 87)) != 0)
423 ncp_extract_file_info(ncp_reply_data(server, 0), target);
424 ncp_unlock_server(server);
426 result = ncp_obtain_nfs_info(server, target);
430 ncp_unlock_server(server);
434 #ifdef CONFIG_NCPFS_NFS_NS
436 ncp_obtain_DOS_dir_base(struct ncp_server *server,
437 __u8 volnum, __u32 dirent,
438 char *path, /* At most 1 component */
443 ncp_init_request(server);
444 ncp_add_byte(server, 6); /* subfunction */
445 ncp_add_byte(server, server->name_space[volnum]);
446 ncp_add_byte(server, server->name_space[volnum]);
447 ncp_add_word(server, htons(0x0680)); /* get all */
448 ncp_add_dword(server, RIM_DIRECTORY);
449 ncp_add_handle_path(server, volnum, dirent, 1, path);
451 if ((result = ncp_request(server, 87)) == 0)
453 if (DOS_dir_base) *DOS_dir_base=ncp_reply_dword(server, 0x34);
455 ncp_unlock_server(server);
458 #endif /* CONFIG_NCPFS_NFS_NS */
461 ncp_get_known_namespace(struct ncp_server *server, __u8 volume)
463 #if defined(CONFIG_NCPFS_OS2_NS) || defined(CONFIG_NCPFS_NFS_NS)
468 ncp_init_request(server);
469 ncp_add_byte(server, 24); /* Subfunction: Get Name Spaces Loaded */
470 ncp_add_word(server, 0);
471 ncp_add_byte(server, volume);
473 if ((result = ncp_request(server, 87)) != 0) {
474 ncp_unlock_server(server);
475 return NW_NS_DOS; /* not result ?? */
479 no_namespaces = le16_to_cpu(ncp_reply_word(server, 0));
480 namespace = ncp_reply_data(server, 2);
482 while (no_namespaces > 0) {
483 DPRINTK("get_namespaces: found %d on %d\n", *namespace, volume);
485 #ifdef CONFIG_NCPFS_NFS_NS
486 if ((*namespace == NW_NS_NFS) && !(server->m.flags&NCP_MOUNT_NO_NFS))
491 #endif /* CONFIG_NCPFS_NFS_NS */
492 #ifdef CONFIG_NCPFS_OS2_NS
493 if ((*namespace == NW_NS_OS2) && !(server->m.flags&NCP_MOUNT_NO_OS2))
497 #endif /* CONFIG_NCPFS_OS2_NS */
501 ncp_unlock_server(server);
503 #else /* neither OS2 nor NFS - only DOS */
505 #endif /* defined(CONFIG_NCPFS_OS2_NS) || defined(CONFIG_NCPFS_NFS_NS) */
509 ncp_ObtainSpecificDirBase(struct ncp_server *server,
510 __u8 nsSrc, __u8 nsDst, __u8 vol_num, __u32 dir_base,
511 char *path, /* At most 1 component */
512 __u32 *dirEntNum, __u32 *DosDirNum)
516 ncp_init_request(server);
517 ncp_add_byte(server, 6); /* subfunction */
518 ncp_add_byte(server, nsSrc);
519 ncp_add_byte(server, nsDst);
520 ncp_add_word(server, htons(0x0680)); /* get all */
521 ncp_add_dword(server, RIM_ALL);
522 ncp_add_handle_path(server, vol_num, dir_base, 1, path);
524 if ((result = ncp_request(server, 87)) != 0)
526 ncp_unlock_server(server);
531 *dirEntNum = ncp_reply_dword(server, 0x30);
533 *DosDirNum = ncp_reply_dword(server, 0x34);
534 ncp_unlock_server(server);
539 ncp_mount_subdir(struct ncp_server *server, struct nw_info_struct *i,
540 __u8 volNumber, __u8 srcNS, __u32 dirEntNum)
547 dstNS = ncp_get_known_namespace(server, volNumber);
548 if ((result = ncp_ObtainSpecificDirBase(server, srcNS, dstNS, volNumber,
549 dirEntNum, NULL, &newDirEnt, &newDosEnt)) != 0)
553 server->name_space[volNumber] = dstNS;
554 i->volNumber = volNumber;
555 i->dirEntNum = newDirEnt;
556 i->DosDirNum = newDosEnt;
557 server->m.mounted_vol[1] = 0;
558 server->m.mounted_vol[0] = 'X';
563 ncp_lookup_volume(struct ncp_server *server, char *volname,
564 struct nw_info_struct *target)
569 DPRINTK("ncp_lookup_volume: looking up vol %s\n", volname);
571 ncp_init_request(server);
572 ncp_add_byte(server, 22); /* Subfunction: Generate dir handle */
573 ncp_add_byte(server, 0); /* DOS namespace */
574 ncp_add_byte(server, 0); /* reserved */
575 ncp_add_byte(server, 0); /* reserved */
576 ncp_add_byte(server, 0); /* reserved */
578 ncp_add_byte(server, 0); /* faked volume number */
579 ncp_add_dword(server, 0); /* faked dir_base */
580 ncp_add_byte(server, 0xff); /* Don't have a dir_base */
581 ncp_add_byte(server, 1); /* 1 path component */
582 ncp_add_pstring(server, volname);
584 if ((result = ncp_request(server, 87)) != 0) {
585 ncp_unlock_server(server);
588 memset(target, 0, sizeof(*target));
589 target->DosDirNum = target->dirEntNum = ncp_reply_dword(server, 4);
590 target->volNumber = volnum = ncp_reply_byte(server, 8);
591 ncp_unlock_server(server);
593 server->name_space[volnum] = ncp_get_known_namespace(server, volnum);
595 DPRINTK("lookup_vol: namespace[%d] = %d\n",
596 volnum, server->name_space[volnum]);
598 target->nameLen = strlen(volname);
599 memcpy(target->entryName, volname, target->nameLen+1);
600 target->attributes = aDIR;
601 /* set dates to Jan 1, 1986 00:00 */
602 target->creationTime = target->modifyTime = cpu_to_le16(0x0000);
603 target->creationDate = target->modifyDate = target->lastAccessDate = cpu_to_le16(0x0C21);
604 target->nfs.mode = 0;
608 int ncp_modify_file_or_subdir_dos_info_path(struct ncp_server *server,
612 const struct nw_modify_dos_info *info)
614 __u8 volnum = NCP_FINFO(dir)->volNumber;
615 __u32 dirent = NCP_FINFO(dir)->dirEntNum;
618 ncp_init_request(server);
619 ncp_add_byte(server, 7); /* subfunction */
620 ncp_add_byte(server, server->name_space[volnum]);
621 ncp_add_byte(server, 0); /* reserved */
622 ncp_add_word(server, htons(0x0680)); /* search attribs: all */
624 ncp_add_dword(server, info_mask);
625 ncp_add_mem(server, info, sizeof(*info));
626 ncp_add_handle_path(server, volnum, dirent, 1, path);
628 result = ncp_request(server, 87);
629 ncp_unlock_server(server);
633 int ncp_modify_file_or_subdir_dos_info(struct ncp_server *server,
636 const struct nw_modify_dos_info *info)
638 return ncp_modify_file_or_subdir_dos_info_path(server, dir, NULL,
642 #ifdef CONFIG_NCPFS_NFS_NS
643 int ncp_modify_nfs_info(struct ncp_server *server, __u8 volnum, __u32 dirent,
644 __u32 mode, __u32 rdev)
649 if (server->name_space[volnum] == NW_NS_NFS) {
650 ncp_init_request(server);
651 ncp_add_byte(server, 25); /* subfunction */
652 ncp_add_byte(server, server->name_space[volnum]);
653 ncp_add_byte(server, NW_NS_NFS);
654 ncp_add_byte(server, volnum);
655 ncp_add_dword(server, dirent);
656 /* we must always operate on both nlinks and rdev, otherwise
658 ncp_add_dword_lh(server, NSIBM_NFS_MODE | NSIBM_NFS_NLINKS | NSIBM_NFS_RDEV);
659 ncp_add_dword_lh(server, mode);
660 ncp_add_dword_lh(server, 1); /* nlinks */
661 ncp_add_dword_lh(server, rdev);
662 result = ncp_request(server, 87);
663 ncp_unlock_server(server);
671 ncp_DeleteNSEntry(struct ncp_server *server,
672 __u8 have_dir_base, __u8 volnum, __u32 dirent,
673 char* name, __u8 ns, int attr)
677 ncp_init_request(server);
678 ncp_add_byte(server, 8); /* subfunction */
679 ncp_add_byte(server, ns);
680 ncp_add_byte(server, 0); /* reserved */
681 ncp_add_word(server, attr); /* search attribs: all */
682 ncp_add_handle_path(server, volnum, dirent, have_dir_base, name);
684 result = ncp_request(server, 87);
685 ncp_unlock_server(server);
690 ncp_del_file_or_subdir2(struct ncp_server *server,
691 struct dentry *dentry)
693 struct inode *inode = dentry->d_inode;
698 #ifdef CONFIG_NCPFS_DEBUGDENTRY
699 PRINTK("ncpfs: ncpdel2: dentry->d_inode == NULL\n");
701 return 0xFF; /* Any error */
703 volnum = NCP_FINFO(inode)->volNumber;
704 dirent = NCP_FINFO(inode)->DosDirNum;
705 return ncp_DeleteNSEntry(server, 1, volnum, dirent, NULL, NW_NS_DOS, htons(0x0680));
709 ncp_del_file_or_subdir(struct ncp_server *server,
710 struct inode *dir, char *name)
712 __u8 volnum = NCP_FINFO(dir)->volNumber;
713 __u32 dirent = NCP_FINFO(dir)->dirEntNum;
715 #ifdef CONFIG_NCPFS_NFS_NS
716 if (server->name_space[volnum]==NW_NS_NFS)
720 result=ncp_obtain_DOS_dir_base(server, volnum, dirent, name, &dirent);
721 if (result) return result;
722 return ncp_DeleteNSEntry(server, 1, volnum, dirent, NULL, NW_NS_DOS, htons(0x0680));
725 #endif /* CONFIG_NCPFS_NFS_NS */
726 return ncp_DeleteNSEntry(server, 1, volnum, dirent, name, server->name_space[volnum], htons(0x0680));
729 static inline void ConvertToNWfromDWORD(__u32 sfd, __u8 ret[6])
731 __u16 *dest = (__u16 *) ret;
732 memcpy(ret + 2, &sfd, 4);
733 dest[0] = cpu_to_le16((le16_to_cpu(dest[1]) + le16_to_cpu(1)));
737 /* If both dir and name are NULL, then in target there's already a
738 looked-up entry that wants to be opened. */
739 int ncp_open_create_file_or_subdir(struct ncp_server *server,
740 struct inode *dir, char *name,
741 int open_create_mode,
742 __u32 create_attributes,
743 int desired_acc_rights,
744 struct ncp_entry_info *target)
746 __u16 search_attribs = ntohs(0x0600);
751 volnum = NCP_FINFO(dir)->volNumber;
752 dirent = NCP_FINFO(dir)->dirEntNum;
754 if ((create_attributes & aDIR) != 0) {
755 search_attribs |= ntohs(0x0080);
757 ncp_init_request(server);
758 ncp_add_byte(server, 1); /* subfunction */
759 ncp_add_byte(server, server->name_space[volnum]);
760 ncp_add_byte(server, open_create_mode);
761 ncp_add_word(server, search_attribs);
762 ncp_add_dword(server, RIM_ALL);
763 ncp_add_dword(server, create_attributes);
764 /* The desired acc rights seem to be the inherited rights mask
766 ncp_add_word(server, desired_acc_rights);
767 ncp_add_handle_path(server, volnum, dirent, 1, name);
769 if ((result = ncp_request(server, 87)) != 0)
771 if (!(create_attributes & aDIR))
774 /* in target there's a new finfo to fill */
775 ncp_extract_file_info(ncp_reply_data(server, 6), &(target->i));
776 target->volume = target->i.volNumber;
777 ConvertToNWfromDWORD(ncp_reply_dword(server, 0), target->file_handle);
779 ncp_unlock_server(server);
781 (void)ncp_obtain_nfs_info(server, &(target->i));
785 ncp_unlock_server(server);
790 ncp_initialize_search(struct ncp_server *server, struct inode *dir,
791 struct nw_search_sequence *target)
793 __u8 volnum = NCP_FINFO(dir)->volNumber;
794 __u32 dirent = NCP_FINFO(dir)->dirEntNum;
797 ncp_init_request(server);
798 ncp_add_byte(server, 2); /* subfunction */
799 ncp_add_byte(server, server->name_space[volnum]);
800 ncp_add_byte(server, 0); /* reserved */
801 ncp_add_handle_path(server, volnum, dirent, 1, NULL);
803 result = ncp_request(server, 87);
806 memcpy(target, ncp_reply_data(server, 0), sizeof(*target));
809 ncp_unlock_server(server);
813 /* Search for everything */
814 int ncp_search_for_file_or_subdir(struct ncp_server *server,
815 struct nw_search_sequence *seq,
816 struct nw_info_struct *target)
820 ncp_init_request(server);
821 ncp_add_byte(server, 3); /* subfunction */
822 ncp_add_byte(server, server->name_space[seq->volNumber]);
823 ncp_add_byte(server, 0); /* data stream (???) */
824 ncp_add_word(server, htons(0x0680)); /* Search attribs */
825 ncp_add_dword(server, RIM_ALL); /* return info mask */
826 ncp_add_mem(server, seq, 9);
827 #ifdef CONFIG_NCPFS_NFS_NS
828 if (server->name_space[seq->volNumber] == NW_NS_NFS) {
829 ncp_add_byte(server, 0); /* 0 byte pattern */
833 ncp_add_byte(server, 2); /* 2 byte pattern */
834 ncp_add_byte(server, 0xff); /* following is a wildcard */
835 ncp_add_byte(server, '*');
838 if ((result = ncp_request(server, 87)) != 0)
840 memcpy(seq, ncp_reply_data(server, 0), sizeof(*seq));
841 ncp_extract_file_info(ncp_reply_data(server, 10), target);
843 ncp_unlock_server(server);
845 result = ncp_obtain_nfs_info(server, target);
849 ncp_unlock_server(server);
853 int ncp_search_for_fileset(struct ncp_server *server,
854 struct nw_search_sequence *seq,
864 ncp_init_request(server);
865 ncp_add_byte(server, 20);
866 ncp_add_byte(server, server->name_space[seq->volNumber]);
867 ncp_add_byte(server, 0); /* datastream */
868 ncp_add_word(server, htons(0x0680));
869 ncp_add_dword(server, RIM_ALL);
870 ncp_add_word(server, 32767); /* max returned items */
871 ncp_add_mem(server, seq, 9);
872 #ifdef CONFIG_NCPFS_NFS_NS
873 if (server->name_space[seq->volNumber] == NW_NS_NFS) {
874 ncp_add_byte(server, 0); /* 0 byte pattern */
878 ncp_add_byte(server, 2); /* 2 byte pattern */
879 ncp_add_byte(server, 0xff); /* following is a wildcard */
880 ncp_add_byte(server, '*');
882 result = ncp_request2(server, 87, buffer, bufsize);
884 ncp_unlock_server(server);
887 if (server->ncp_reply_size < 12) {
888 ncp_unlock_server(server);
891 *rsize = server->ncp_reply_size - 12;
892 ncp_unlock_server(server);
893 buffer = buffer + sizeof(struct ncp_reply_header);
895 *cnt = WVAL_LH(buffer + 10);
896 *more = BVAL(buffer + 9);
897 memcpy(seq, buffer, 9);
902 ncp_RenameNSEntry(struct ncp_server *server,
903 struct inode *old_dir, char *old_name, int old_type,
904 struct inode *new_dir, char *new_name)
906 int result = -EINVAL;
908 if ((old_dir == NULL) || (old_name == NULL) ||
909 (new_dir == NULL) || (new_name == NULL))
912 ncp_init_request(server);
913 ncp_add_byte(server, 4); /* subfunction */
914 ncp_add_byte(server, server->name_space[NCP_FINFO(old_dir)->volNumber]);
915 ncp_add_byte(server, 1); /* rename flag */
916 ncp_add_word(server, old_type); /* search attributes */
918 /* source Handle Path */
919 ncp_add_byte(server, NCP_FINFO(old_dir)->volNumber);
920 ncp_add_dword(server, NCP_FINFO(old_dir)->dirEntNum);
921 ncp_add_byte(server, 1);
922 ncp_add_byte(server, 1); /* 1 source component */
924 /* dest Handle Path */
925 ncp_add_byte(server, NCP_FINFO(new_dir)->volNumber);
926 ncp_add_dword(server, NCP_FINFO(new_dir)->dirEntNum);
927 ncp_add_byte(server, 1);
928 ncp_add_byte(server, 1); /* 1 destination component */
930 /* source path string */
931 ncp_add_pstring(server, old_name);
932 /* dest path string */
933 ncp_add_pstring(server, new_name);
935 result = ncp_request(server, 87);
936 ncp_unlock_server(server);
941 int ncp_ren_or_mov_file_or_subdir(struct ncp_server *server,
942 struct inode *old_dir, char *old_name,
943 struct inode *new_dir, char *new_name)
946 int old_type = htons(0x0600);
948 /* If somebody can do it atomic, call me... vandrove@vc.cvut.cz */
949 result = ncp_RenameNSEntry(server, old_dir, old_name, old_type,
951 if (result == 0xFF) /* File Not Found, try directory */
953 old_type = htons(0x1600);
954 result = ncp_RenameNSEntry(server, old_dir, old_name, old_type,
957 if (result != 0x92) return result; /* All except NO_FILES_RENAMED */
958 result = ncp_del_file_or_subdir(server, new_dir, new_name);
959 if (result != 0) return -EACCES;
960 result = ncp_RenameNSEntry(server, old_dir, old_name, old_type,
966 /* We have to transfer to/from user space */
968 ncp_read_kernel(struct ncp_server *server, const char *file_id,
969 __u32 offset, __u16 to_read, char *target, int *bytes_read)
974 ncp_init_request(server);
975 ncp_add_byte(server, 0);
976 ncp_add_mem(server, file_id, 6);
977 ncp_add_dword(server, htonl(offset));
978 ncp_add_word(server, htons(to_read));
980 if ((result = ncp_request(server, 72)) != 0) {
983 *bytes_read = ntohs(ncp_reply_word(server, 0));
984 source = ncp_reply_data(server, 2 + (offset & 1));
986 memcpy(target, source, *bytes_read);
988 ncp_unlock_server(server);
992 /* There is a problem... egrep and some other silly tools do:
993 x = mmap(NULL, MAP_PRIVATE, PROT_READ|PROT_WRITE, <ncpfs fd>, 32768);
994 read(<ncpfs fd>, x, 32768);
995 Now copying read result by copy_to_user causes pagefault. This pagefault
996 could not be handled because of server was locked due to read. So we have
997 to use temporary buffer. So ncp_unlock_server must be done before
998 copy_to_user (and for write, copy_from_user must be done before
999 ncp_init_request... same applies for send raw packet ioctl). Because of
1000 file is normally read in bigger chunks, caller provides kmalloced
1001 (vmalloced) chunk of memory with size >= to_read...
1004 ncp_read_bounce(struct ncp_server *server, const char *file_id,
1005 __u32 offset, __u16 to_read, char __user *target, int *bytes_read,
1006 void* bounce, __u32 bufsize)
1010 ncp_init_request(server);
1011 ncp_add_byte(server, 0);
1012 ncp_add_mem(server, file_id, 6);
1013 ncp_add_dword(server, htonl(offset));
1014 ncp_add_word(server, htons(to_read));
1015 result = ncp_request2(server, 72, bounce, bufsize);
1016 ncp_unlock_server(server);
1018 int len = be16_to_cpu(get_unaligned((__u16*)((char*)bounce +
1019 sizeof(struct ncp_reply_header))));
1021 if (len <= to_read) {
1024 source = (char*)bounce +
1025 sizeof(struct ncp_reply_header) + 2 +
1029 if (copy_to_user(target, source, len))
1037 ncp_write_kernel(struct ncp_server *server, const char *file_id,
1038 __u32 offset, __u16 to_write,
1039 const char *source, int *bytes_written)
1043 ncp_init_request(server);
1044 ncp_add_byte(server, 0);
1045 ncp_add_mem(server, file_id, 6);
1046 ncp_add_dword(server, htonl(offset));
1047 ncp_add_word(server, htons(to_write));
1048 ncp_add_mem(server, source, to_write);
1050 if ((result = ncp_request(server, 73)) == 0)
1051 *bytes_written = to_write;
1052 ncp_unlock_server(server);
1056 #ifdef CONFIG_NCPFS_IOCTL_LOCKING
1058 ncp_LogPhysicalRecord(struct ncp_server *server, const char *file_id,
1059 __u8 locktype, __u32 offset, __u32 length, __u16 timeout)
1063 ncp_init_request(server);
1064 ncp_add_byte(server, locktype);
1065 ncp_add_mem(server, file_id, 6);
1066 ncp_add_dword(server, htonl(offset));
1067 ncp_add_dword(server, htonl(length));
1068 ncp_add_word(server, htons(timeout));
1070 if ((result = ncp_request(server, 0x1A)) != 0)
1072 ncp_unlock_server(server);
1075 ncp_unlock_server(server);
1080 ncp_ClearPhysicalRecord(struct ncp_server *server, const char *file_id,
1081 __u32 offset, __u32 length)
1085 ncp_init_request(server);
1086 ncp_add_byte(server, 0); /* who knows... lanalyzer says that */
1087 ncp_add_mem(server, file_id, 6);
1088 ncp_add_dword(server, htonl(offset));
1089 ncp_add_dword(server, htonl(length));
1091 if ((result = ncp_request(server, 0x1E)) != 0)
1093 ncp_unlock_server(server);
1096 ncp_unlock_server(server);
1099 #endif /* CONFIG_NCPFS_IOCTL_LOCKING */
1101 #ifdef CONFIG_NCPFS_NLS
1102 /* This are the NLS conversion routines with inspirations and code parts
1103 * from the vfat file system and hints from Petr Vandrovec.
1106 inline unsigned char
1107 ncp__tolower(struct nls_table *t, unsigned char c)
1109 unsigned char nc = t->charset2lower[c];
1114 inline unsigned char
1115 ncp__toupper(struct nls_table *t, unsigned char c)
1117 unsigned char nc = t->charset2upper[c];
1123 ncp__io2vol(struct ncp_server *server, unsigned char *vname, unsigned int *vlen,
1124 const unsigned char *iname, unsigned int ilen, int cc)
1126 struct nls_table *in = server->nls_io;
1127 struct nls_table *out = server->nls_vol;
1128 unsigned char *vname_start;
1129 unsigned char *vname_end;
1130 const unsigned char *iname_end;
1132 iname_end = iname + ilen;
1133 vname_start = vname;
1134 vname_end = vname + *vlen - 1;
1136 while (iname < iname_end) {
1140 if (NCP_IS_FLAG(server, NCP_FLAG_UTF8)) {
1143 k = utf8_mbtowc(&ec, iname, iname_end - iname);
1148 if (*iname == NCP_ESC) {
1151 if (iname_end - iname < 5)
1155 for (k = 1; k < 5; k++) {
1158 nc = iname[k] - '0';
1160 nc -= 'A' - '0' - 10;
1161 if ((nc < 10) || (nc > 15)) {
1165 ec = (ec << 4) | nc;
1170 if ( (chl = in->char2uni(iname, iname_end - iname, &ec)) < 0)
1176 /* unitoupper should be here! */
1178 chl = out->uni2char(ec, vname, vname_end - vname);
1182 /* this is wrong... */
1186 for (chi = 0; chi < chl; chi++){
1187 vname[chi] = ncp_toupper(out, vname[chi]);
1194 *vlen = vname - vname_start;
1199 ncp__vol2io(struct ncp_server *server, unsigned char *iname, unsigned int *ilen,
1200 const unsigned char *vname, unsigned int vlen, int cc)
1202 struct nls_table *in = server->nls_vol;
1203 struct nls_table *out = server->nls_io;
1204 const unsigned char *vname_end;
1205 unsigned char *iname_start;
1206 unsigned char *iname_end;
1207 unsigned char *vname_cc;
1215 /* this is wrong! */
1216 vname_cc = kmalloc(vlen, GFP_KERNEL);
1219 for (i = 0; i < vlen; i++)
1220 vname_cc[i] = ncp_tolower(in, vname[i]);
1224 iname_start = iname;
1225 iname_end = iname + *ilen - 1;
1226 vname_end = vname + vlen;
1228 while (vname < vname_end) {
1232 if ( (chl = in->char2uni(vname, vname_end - vname, &ec)) < 0) {
1238 /* unitolower should be here! */
1240 if (NCP_IS_FLAG(server, NCP_FLAG_UTF8)) {
1243 k = utf8_wctomb(iname, ec, iname_end - iname);
1245 err = -ENAMETOOLONG;
1250 if ( (chl = out->uni2char(ec, iname, iname_end - iname)) >= 0) {
1255 if (iname_end - iname < 5) {
1256 err = -ENAMETOOLONG;
1260 for (k = 4; k > 0; k--) {
1263 v = (ec & 0xF) + '0';
1276 *ilen = iname - iname_start;
1287 ncp__io2vol(unsigned char *vname, unsigned int *vlen,
1288 const unsigned char *iname, unsigned int ilen, int cc)
1293 return -ENAMETOOLONG;
1296 for (i = 0; i < ilen; i++) {
1297 *vname = toupper(*iname);
1302 memmove(vname, iname, ilen);
1312 ncp__vol2io(unsigned char *iname, unsigned int *ilen,
1313 const unsigned char *vname, unsigned int vlen, int cc)
1318 return -ENAMETOOLONG;
1321 for (i = 0; i < vlen; i++) {
1322 *iname = tolower(*vname);
1327 memmove(iname, vname, vlen);
1339 ncp_strnicmp(struct nls_table *t, const unsigned char *s1,
1340 const unsigned char *s2, int n)
1345 if (ncp_tolower(t, s1[i]) != ncp_tolower(t, s2[i]))