开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
ncplib_kernel.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：27k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

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