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

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

嵌入式Linux

开发平台：

Unix_Linux

proc.c：源码内容
  1. /*
  2.  *  proc.c
  3.  *
  4.  *  Copyright (C) 1995, 1996 by Paal-Kr. Engstad and Volker Lendecke
  5.  *  Copyright (C) 1997 by Volker Lendecke
  6.  *
  7.  *  Please add a note about your changes to smbfs in the ChangeLog file.
  8.  */
  10. #include <linux/types.h>
  11. #include <linux/errno.h>
  12. #include <linux/slab.h>
  13. #include <linux/fs.h>
  14. #include <linux/file.h>
  15. #include <linux/stat.h>
  16. #include <linux/fcntl.h>
  17. #include <linux/dcache.h>
  18. #include <linux/dirent.h>
  19. #include <linux/nls.h>
  21. #include <linux/smb_fs.h>
  22. #include <linux/smbno.h>
  23. #include <linux/smb_mount.h>
  25. #include <asm/string.h>
  26. #include <asm/div64.h>
  28. #include "smb_debug.h"
  29. #include "proto.h"
  32. /* Features. Undefine if they cause problems, this should perhaps be a
  33.    config option. */
  34. #define SMBFS_POSIX_UNLINK 1
  36. /* Allow smb_retry to be interrupted. */
  37. #define SMB_RETRY_INTR
  39. #define SMB_VWV(packet)  ((packet) + SMB_HEADER_LEN)
  40. #define SMB_CMD(packet)  (*(packet+8))
  41. #define SMB_WCT(packet)  (*(packet+SMB_HEADER_LEN - 1))
  42. #define SMB_BCC(packet)  smb_bcc(packet)
  43. #define SMB_BUF(packet)  ((packet) + SMB_HEADER_LEN + SMB_WCT(packet) * 2 + 2)
  45. #define SMB_DIRINFO_SIZE 43
  46. #define SMB_STATUS_SIZE  21
  48. #define SMB_ST_BLKSIZE (PAGE_SIZE)
  49. #define SMB_ST_BLKSHIFT (PAGE_SHIFT)
  51. static int
  52. smb_proc_setattr_ext(struct smb_sb_info *, struct inode *,
  53.      struct smb_fattr *);
  54. static int
  55. smb_proc_setattr_core(struct smb_sb_info *server, struct dentry *dentry,
  56.                       __u16 attr);
  57. static int
  58. smb_proc_do_getattr(struct smb_sb_info *server, struct dentry *dir,
  59.     struct smb_fattr *fattr);
  63. static void
  64. str_upper(char *name, int len)
  65. {
  66. while (len--)
  67. {
  68. if (*name >= 'a' && *name <= 'z')
  69. *name -= ('a' - 'A');
  70. name++;
  71. }
  72. }
  74. #if 0
  75. static void
  76. str_lower(char *name, int len)
  77. {
  78. while (len--)
  79. {
  80. if (*name >= 'A' && *name <= 'Z')
  81. *name += ('a' - 'A');
  82. name++;
  83. }
  84. }
  85. #endif
  87. /* reverse a string inline. This is used by the dircache walking routines */
  88. static void reverse_string(char *buf, int len)
  89. {
  90. char c;
  91. char *end = buf+len-1;
  93. while(buf < end) {
  94. c = *buf;
  95. *(buf++) = *end;
  96. *(end--) = c;
  97. }
  98. }
  100. /* no conversion, just a wrapper for memcpy. */
  101. static int convert_memcpy(char *output, int olen,
  102.   const char *input, int ilen,
  103.   struct nls_table *nls_from,
  104.   struct nls_table *nls_to)
  105. {
  106. if (olen < ilen)
  107. return -ENAMETOOLONG;
  108. memcpy(output, input, ilen);
  109. return ilen;
  110. }
  112. /* convert from one "codepage" to another (possibly being utf8). */
  113. static int convert_cp(char *output, int olen,
  114.       const char *input, int ilen,
  115.       struct nls_table *nls_from,
  116.       struct nls_table *nls_to)
  117. {
  118. int len = 0;
  119. int n;
  120. wchar_t ch;
  122. if (!nls_from || !nls_to) {
  123. PARANOIA("nls_from=%p, nls_to=%pn", nls_from, nls_to);
  124. return convert_memcpy(output, olen, input, ilen, NULL, NULL);
  125. }
  127. while (ilen > 0) {
  128. /* convert by changing to unicode and back to the new cp */
  129. n = nls_from->char2uni((unsigned char *)input, ilen, &ch);
  130. if (n < 0)
  131. goto fail;
  132. input += n;
  133. ilen -= n;
  135. n = nls_to->uni2char(ch, output, olen);
  136. if (n < 0)
  137. goto fail;
  138. output += n;
  139. olen -= n;
  141. len += n;
  142. }
  143. return len;
  144. fail:
  145. return n;
  146. }
  148. static int setcodepage(struct nls_table **p, char *name)
  149. {
  150. struct nls_table *nls;
  152. if (!name || !*name) {
  153. nls = NULL;
  154. } else if ( (nls = load_nls(name)) == NULL) {
  155. printk (KERN_ERR "smbfs: failed to load nls '%s'n", name);
  156. return -EINVAL;
  157. }
  159. /* if already set, unload the previous one. */
  160. if (*p)
  161. unload_nls(*p);
  162. *p = nls;
  164. return 0;
  165. }
  167. /* Handles all changes to codepage settings. */
  168. int smb_setcodepage(struct smb_sb_info *server, struct smb_nls_codepage *cp)
  169. {
  170. int n = 0;
  172. smb_lock_server(server);
  174. /* Don't load any nls_* at all, if no remote is requested */
  175. if (!*cp->remote_name)
  176. goto out;
  178. n = setcodepage(&server->local_nls, cp->local_name);
  179. if (n != 0)
  180. goto out;
  181. n = setcodepage(&server->remote_nls, cp->remote_name);
  182. if (n != 0)
  183. setcodepage(&server->local_nls, NULL);
  185. out:
  186. if (server->local_nls != NULL && server->remote_nls != NULL)
  187. server->convert = convert_cp;
  188. else
  189. server->convert = convert_memcpy;
  191. smb_unlock_server(server);
  192. return n;
  193. }
  196. /*****************************************************************************/
  197. /*                                                                           */
  198. /*  Encoding/Decoding section                                                */
  199. /*                                                                           */
  200. /*****************************************************************************/
  202. static __u8 *
  203. smb_encode_smb_length(__u8 * p, __u32 len)
  204. {
  205. *p = 0;
  206. *(p+1) = 0;
  207. *(p+2) = (len & 0xFF00) >> 8;
  208. *(p+3) = (len & 0xFF);
  209. if (len > 0xFFFF)
  210. {
  211. *(p+1) = 1;
  212. }
  213. return p + 4;
  214. }
  216. /*
  217.  * smb_build_path: build the path to entry and name storing it in buf.
  218.  * The path returned will have the trailing ''.
  219.  */
  220. static int smb_build_path(struct smb_sb_info *server, char * buf, int maxlen,
  221.   struct dentry * entry, struct qstr * name)
  222. {
  223. char *path = buf;
  224. int len;
  226. if (maxlen < 2)
  227. return -ENAMETOOLONG;
  229. if (maxlen > SMB_MAXNAMELEN + 1)
  230. maxlen = SMB_MAXNAMELEN + 1;
  232. if (entry == NULL)
  233. goto test_name_and_out;
  235. /*
  236.  * If IS_ROOT, we have to do no walking at all.
  237.  */
  238. if (IS_ROOT(entry) && !name) {
  239. *path++ = '\';
  240. *path++ = '';
  241. return 2;
  242. }
  244. /*
  245.  * Build the path string walking the tree backward from end to ROOT
  246.  * and store it in reversed order [see reverse_string()]
  247.  */
  248. while (!IS_ROOT(entry)) {
  249. if (maxlen < 3)
  250. return -ENAMETOOLONG;
  252. len = server->convert(path, maxlen-2, 
  253.       entry->d_name.name, entry->d_name.len,
  254.       server->local_nls, server->remote_nls);
  255. if (len < 0)
  256. return len;
  257. reverse_string(path, len);
  258. path += len;
  259. *path++ = '\';
  260. maxlen -= len+1;
  262. entry = entry->d_parent;
  263. if (IS_ROOT(entry))
  264. break;
  265. }
  266. reverse_string(buf, path-buf);
  268. /* maxlen is at least 1 */
  269. test_name_and_out:
  270. if (name) {
  271. if (maxlen < 3)
  272. return -ENAMETOOLONG;
  273. *path++ = '\';
  274. len = server->convert(path, maxlen-2, 
  275.       name->name, name->len,
  276.       server->local_nls, server->remote_nls);
  277. if (len < 0)
  278. return len;
  279. path += len;
  280. maxlen -= len+1;
  281. }
  282. /* maxlen is at least 1 */
  283. *path++ = '';
  284. return path-buf;
  285. }
  287. static int smb_encode_path(struct smb_sb_info *server, char *buf, int maxlen,
  288.    struct dentry *dir, struct qstr *name)
  289. {
  290. int result;
  292. result = smb_build_path(server, buf, maxlen, dir, name);
  293. if (result < 0)
  294. goto out;
  295. if (server->opt.protocol <= SMB_PROTOCOL_COREPLUS)
  296. str_upper(buf, result);
  297. out:
  298. return result;
  299. }
  301. static int smb_simple_encode_path(struct smb_sb_info *server, char **p,
  302.   struct dentry * entry, struct qstr * name)
  303. {
  304. char *s = *p;
  305. int res;
  306. int maxlen = ((char *)server->packet + server->packet_size) - s;
  308. if (!maxlen)
  309. return -ENAMETOOLONG;
  310. *s++ = 4;
  311. res = smb_encode_path(server, s, maxlen-1, entry, name);
  312. if (res < 0)
  313. return res;
  314. *p = s + res;
  315. return 0;
  316. }
  318. /* The following are taken directly from msdos-fs */
  320. /* Linear day numbers of the respective 1sts in non-leap years. */
  322. static int day_n[] =
  323. {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 0, 0, 0, 0};
  324.   /* JanFebMarApr May Jun Jul Aug Sep Oct Nov Dec */
  327. static time_t
  328. utc2local(struct smb_sb_info *server, time_t time)
  329. {
  330. return time - server->opt.serverzone*60;
  331. }
  333. static time_t
  334. local2utc(struct smb_sb_info *server, time_t time)
  335. {
  336. return time + server->opt.serverzone*60;
  337. }
  339. /* Convert a MS-DOS time/date pair to a UNIX date (seconds since 1 1 70). */
  341. static time_t
  342. date_dos2unix(struct smb_sb_info *server, __u16 date, __u16 time)
  343. {
  344. int month, year;
  345. time_t secs;
  347. /* first subtract and mask after that... Otherwise, if
  348.    date == 0, bad things happen */
  349. month = ((date >> 5) - 1) & 15;
  350. year = date >> 9;
  351. secs = (time & 31) * 2 + 60 * ((time >> 5) & 63) + (time >> 11) * 3600 + 86400 *
  352.     ((date & 31) - 1 + day_n[month] + (year / 4) + year * 365 - ((year & 3) == 0 &&
  353.    month < 2 ? 1 : 0) + 3653);
  354. /* days since 1.1.70 plus 80's leap day */
  355. return local2utc(server, secs);
  356. }
  359. /* Convert linear UNIX date to a MS-DOS time/date pair. */
  361. static void
  362. date_unix2dos(struct smb_sb_info *server,
  363.       int unix_date, __u16 *date, __u16 *time)
  364. {
  365. int day, year, nl_day, month;
  367. unix_date = utc2local(server, unix_date);
  368. if (unix_date < 315532800)
  369. unix_date = 315532800;
  371. *time = (unix_date % 60) / 2 +
  372. (((unix_date / 60) % 60) << 5) +
  373. (((unix_date / 3600) % 24) << 11);
  375. day = unix_date / 86400 - 3652;
  376. year = day / 365;
  377. if ((year + 3) / 4 + 365 * year > day)
  378. year--;
  379. day -= (year + 3) / 4 + 365 * year;
  380. if (day == 59 && !(year & 3)) {
  381. nl_day = day;
  382. month = 2;
  383. } else {
  384. nl_day = (year & 3) || day <= 59 ? day : day - 1;
  385. for (month = 0; month < 12; month++)
  386. if (day_n[month] > nl_day)
  387. break;
  388. }
  389. *date = nl_day - day_n[month - 1] + 1 + (month << 5) + (year << 9);
  390. }
  392. /* The following are taken from fs/ntfs/util.c */
  394. #define NTFS_TIME_OFFSET ((u64)(369*365 + 89) * 24 * 3600 * 10000000)
  396. /*
  397.  * Convert the NT UTC (based 1601-01-01, in hundred nanosecond units)
  398.  * into Unix UTC (based 1970-01-01, in seconds).
  399.  */
  400. static time_t
  401. smb_ntutc2unixutc(u64 ntutc)
  402. {
  403. /* FIXME: what about the timezone difference? */
  404. /* Subtract the NTFS time offset, then convert to 1s intervals. */
  405. u64 t = ntutc - NTFS_TIME_OFFSET;
  406. do_div(t, 10000000);
  407. return (time_t)t;
  408. }
  410. #if 0
  411. /* Convert the Unix UTC into NT time */
  412. static u64
  413. smb_unixutc2ntutc(struct smb_sb_info *server, time_t t)
  414. {
  415. /* Note: timezone conversion is probably wrong. */
  416. return ((u64)utc2local(server, t)) * 10000000 + NTFS_TIME_OFFSET;
  417. }
  418. #endif
  421. /*****************************************************************************/
  422. /*                                                                           */
  423. /*  Support section.                                                         */
  424. /*                                                                           */
  425. /*****************************************************************************/
  427. __u32
  428. smb_len(__u8 * p)
  429. {
  430. return ((*(p+1) & 0x1) << 16L) | (*(p+2) << 8L) | *(p+3);
  431. }
  433. static __u16
  434. smb_bcc(__u8 * packet)
  435. {
  436. int pos = SMB_HEADER_LEN + SMB_WCT(packet) * sizeof(__u16);
  437. return WVAL(packet, pos);
  438. }
  440. /* smb_valid_packet: We check if packet fulfills the basic
  441.    requirements of a smb packet */
  443. static int
  444. smb_valid_packet(__u8 * packet)
  445. {
  446. return (packet[4] == 0xff
  447. && packet[5] == 'S'
  448. && packet[6] == 'M'
  449. && packet[7] == 'B'
  450. && (smb_len(packet) + 4 == SMB_HEADER_LEN
  451.     + SMB_WCT(packet) * 2 + SMB_BCC(packet)));
  452. }
  454. /* smb_verify: We check if we got the answer we expected, and if we
  455.    got enough data. If bcc == -1, we don't care. */
  457. static int
  458. smb_verify(__u8 * packet, int command, int wct, int bcc)
  459. {
  460. if (SMB_CMD(packet) != command)
  461. goto bad_command;
  462. if (SMB_WCT(packet) < wct)
  463. goto bad_wct;
  464. if (bcc != -1 && SMB_BCC(packet) < bcc)
  465. goto bad_bcc;
  466. return 0;
  468. bad_command:
  469. printk(KERN_ERR "smb_verify: command=%x, SMB_CMD=%x??n",
  470.        command, SMB_CMD(packet));
  471. goto fail;
  472. bad_wct:
  473. printk(KERN_ERR "smb_verify: command=%x, wct=%d, SMB_WCT=%d??n",
  474.        command, wct, SMB_WCT(packet));
  475. goto fail;
  476. bad_bcc:
  477. printk(KERN_ERR "smb_verify: command=%x, bcc=%d, SMB_BCC=%d??n",
  478.        command, bcc, SMB_BCC(packet));
  479. fail:
  480. return -EIO;
  481. }
  483. /*
  484.  * Returns the maximum read or write size for the "payload". Making all of the
  485.  * packet fit within the negotiated max_xmit size.
  486.  *
  487.  * N.B. Since this value is usually computed before locking the server,
  488.  * the server's packet size must never be decreased!
  489.  */
  490. static inline int
  491. smb_get_xmitsize(struct smb_sb_info *server, int overhead)
  492. {
  493. return server->opt.max_xmit - overhead;
  494. }
  496. /*
  497.  * Calculate the maximum read size
  498.  */
  499. int
  500. smb_get_rsize(struct smb_sb_info *server)
  501. {
  502. int overhead = SMB_HEADER_LEN + 5 * sizeof(__u16) + 2 + 1 + 2;
  503. int size = smb_get_xmitsize(server, overhead);
  505. VERBOSE("packet=%d, xmit=%d, size=%dn",
  506. server->packet_size, server->opt.max_xmit, size);
  508. return size;
  509. }
  511. /*
  512.  * Calculate the maximum write size
  513.  */
  514. int
  515. smb_get_wsize(struct smb_sb_info *server)
  516. {
  517. int overhead = SMB_HEADER_LEN + 5 * sizeof(__u16) + 2 + 1 + 2;
  518. int size = smb_get_xmitsize(server, overhead);
  520. VERBOSE("packet=%d, xmit=%d, size=%dn",
  521. server->packet_size, server->opt.max_xmit, size);
  523. return size;
  524. }
  526. /*
  527.  * Convert SMB error codes to -E... errno values.
  528.  */
  529. int
  530. smb_errno(struct smb_sb_info *server)
  531. {
  532. int errcls = server->rcls;
  533. int error  = server->err;
  534. char *class = "Unknown";
  536. VERBOSE("errcls %d  code %d  from command 0x%xn",
  537. errcls, error, SMB_CMD(server->packet));
  539. if (errcls == ERRDOS) {
  540. switch (error) {
  541. case ERRbadfunc:
  542. return -EINVAL;
  543. case ERRbadfile:
  544. case ERRbadpath:
  545. return -ENOENT;
  546. case ERRnofids:
  547. return -EMFILE;
  548. case ERRnoaccess:
  549. return -EACCES;
  550. case ERRbadfid:
  551. return -EBADF;
  552. case ERRbadmcb:
  553. return -EREMOTEIO;
  554. case ERRnomem:
  555. return -ENOMEM;
  556. case ERRbadmem:
  557. return -EFAULT;
  558. case ERRbadenv:
  559. case ERRbadformat:
  560. return -EREMOTEIO;
  561. case ERRbadaccess:
  562. return -EACCES;
  563. case ERRbaddata:
  564. return -E2BIG;
  565. case ERRbaddrive:
  566. return -ENXIO;
  567. case ERRremcd:
  568. return -EREMOTEIO;
  569. case ERRdiffdevice:
  570. return -EXDEV;
  571. case ERRnofiles:
  572. return -ENOENT;
  573. case ERRbadshare:
  574. return -ETXTBSY;
  575. case ERRlock:
  576. return -EDEADLK;
  577. case ERRfilexists:
  578. return -EEXIST;
  579. case ERROR_INVALID_PARAMETER:
  580. return -EINVAL;
  581. case ERROR_DISK_FULL:
  582. return -ENOSPC;
  583. case ERROR_INVALID_NAME:
  584. return -ENOENT;
  585. case ERROR_DIR_NOT_EMPTY:
  586. return -ENOTEMPTY;
  587. case ERROR_NOT_LOCKED:
  588.                        return -ENOLCK;
  589. case ERROR_ALREADY_EXISTS:
  590. return -EEXIST;
  591. default:
  592. class = "ERRDOS";
  593. goto err_unknown;
  594. }
  595. } else if (errcls == ERRSRV) {
  596. switch (error) {
  597. /* N.B. This is wrong ... EIO ? */
  598. case ERRerror:
  599. return -ENFILE;
  600. case ERRbadpw:
  601. return -EINVAL;
  602. case ERRbadtype:
  603. return -EIO;
  604. case ERRaccess:
  605. return -EACCES;
  606. /*
  607.  * This is a fatal error, as it means the "tree ID"
  608.  * for this connection is no longer valid. We map
  609.  * to a special error code and get a new connection.
  610.  */
  611. case ERRinvnid:
  612. return -EBADSLT;
  613. default:
  614. class = "ERRSRV";
  615. goto err_unknown;
  616. }
  617. } else if (errcls == ERRHRD) {
  618. switch (error) {
  619. case ERRnowrite:
  620. return -EROFS;
  621. case ERRbadunit:
  622. return -ENODEV;
  623. case ERRnotready:
  624. return -EUCLEAN;
  625. case ERRbadcmd:
  626. case ERRdata:
  627. return -EIO;
  628. case ERRbadreq:
  629. return -ERANGE;
  630. case ERRbadshare:
  631. return -ETXTBSY;
  632. case ERRlock:
  633. return -EDEADLK;
  634. case ERRdiskfull:
  635. return -ENOSPC;
  636. default:
  637. class = "ERRHRD";
  638. goto err_unknown;
  639. }
  640. } else if (errcls == ERRCMD) {
  641. class = "ERRCMD";
  642. } else if (errcls == SUCCESS) {
  643. return 0; /* This is the only valid 0 return */
  644. }
  646. err_unknown:
  647. printk(KERN_ERR "smb_errno: class %s, code %d from command 0x%xn",
  648.        class, error, SMB_CMD(server->packet));
  649. return -EIO;
  650. }
  652. /*
  653.  * smb_retry: This function should be called when smb_request_ok has
  654.  * indicated an error. If the error was indicated because the
  655.  * connection was killed, we try to reconnect. If smb_retry returns 0,
  656.  * the error was indicated for another reason, so a retry would not be
  657.  * of any use.
  658.  * N.B. The server must be locked for this call.
  659.  */
  660. static int
  661. smb_retry(struct smb_sb_info *server)
  662. {
  663. pid_t pid = server->conn_pid;
  664. int error, result = 0;
  666. if (server->state == CONN_VALID || server->state == CONN_RETRYING)
  667. goto out;
  669. smb_close_socket(server);
  671. if (pid == 0) {
  672. printk(KERN_ERR "smb_retry: no connection processn");
  673. server->state = CONN_RETRIED;
  674. goto out;
  675. }
  677. /*
  678.  * Change state so that only one retry per server will be started.
  679.  */
  680. server->state = CONN_RETRYING;
  682. /*
  683.  * Note: use the "priv" flag, as a user process may need to reconnect.
  684.  */
  685. error = kill_proc(pid, SIGUSR1, 1);
  686. if (error) {
  687. /* FIXME: this is fatal */
  688. printk(KERN_ERR "smb_retry: signal failed, error=%dn", error);
  689. goto out;
  690. }
  691. VERBOSE("signalled pid %d, waiting for new connectionn", pid);
  693. /*
  694.  * Wait for the new connection.
  695.  */
  696. #ifdef SMB_RETRY_INTR
  697. smb_unlock_server(server);
  698. interruptible_sleep_on_timeout(&server->wait,  30*HZ);
  699. smb_lock_server(server);
  700. if (signal_pending(current))
  701. printk(KERN_INFO "smb_retry: caught signaln");
  702. #else
  703. /*
  704.  * We don't want to be interrupted. For example, what if 'current'
  705.  * already has received a signal? sleep_on would terminate immediately
  706.  * and smbmount would not be able to re-establish connection.
  707.  *
  708.  * smbmount should be able to reconnect later, but it can't because
  709.  * it will get an -EIO on attempts to open the mountpoint!
  710.  *
  711.  * FIXME: go back to the interruptable version now that smbmount
  712.  * can avoid -EIO on the mountpoint when reconnecting?
  713.  */
  714. smb_unlock_server(server);
  715. sleep_on_timeout(&server->wait, 30*HZ);
  716. smb_lock_server(server);
  717. #endif
  719. /*
  720.  * Check for a valid connection.
  721.  */
  722. if (server->state == CONN_VALID) {
  723. /* This should be changed to VERBOSE, except many smbfs
  724.    problems is with the userspace daemon not reconnecting. */
  725. PARANOIA("successful, new pid=%d, generation=%dn",
  726.  server->conn_pid, server->generation);
  727. result = 1;
  728. } else if (server->state == CONN_RETRYING) {
  729. /* allow further attempts later */
  730. server->state = CONN_RETRIED;
  731. }
  733. out:
  734. return result;
  735. }
  737. /* smb_request_ok: We expect the server to be locked. Then we do the
  738.    request and check the answer completely. When smb_request_ok
  739.    returns 0, you can be quite sure that everything went well. When
  740.    the answer is <=0, the returned number is a valid unix errno. */
  742. static int
  743. smb_request_ok(struct smb_sb_info *s, int command, int wct, int bcc)
  744. {
  745. int result = -EIO;
  747. s->rcls = 0;
  748. s->err = 0;
  750. /* Make sure we have a connection */
  751. if (s->state != CONN_VALID) {
  752. if (!smb_retry(s))
  753. goto out;
  754. }
  756. if (smb_request(s) < 0) {
  757. DEBUG1("smb_request failedn");
  758. goto out;
  759. }
  760. if (smb_valid_packet(s->packet) != 0) {
  761. PARANOIA("invalid packet!n");
  762. goto out;
  763. }
  765. /*
  766.  * Check for server errors.
  767.  */
  768. if (s->rcls != 0) {
  769. result = smb_errno(s);
  770. if (!result)
  771. printk(KERN_DEBUG "smb_request_ok: rcls=%d, err=%d mapped to 0n",
  772. s->rcls, s->err);
  773. /*
  774.  * Exit now even if the error was squashed ...
  775.  * packet verify will fail anyway.
  776.  */
  777. goto out;
  778. }
  779. result = smb_verify(s->packet, command, wct, bcc);
  781. out:
  782. return result;
  783. }
  785. /*
  786.  * This implements the NEWCONN ioctl. It installs the server pid,
  787.  * sets server->state to CONN_VALID, and wakes up the waiting process.
  788.  */
  789. int
  790. smb_newconn(struct smb_sb_info *server, struct smb_conn_opt *opt)
  791. {
  792. struct file *filp;
  793. int error;
  795. VERBOSE("fd=%d, pid=%dn", opt->fd, current->pid);
  797. smb_lock_server(server);
  799. /*
  800.  * Make sure we don't already have a valid connection ...
  801.  */
  802. error = -EINVAL;
  803. if (server->state == CONN_VALID)
  804. goto out;
  806. error = -EACCES;
  807. if (current->uid != server->mnt->mounted_uid && 
  808.     !capable(CAP_SYS_ADMIN))
  809. goto out;
  811. error = -EBADF;
  812. filp = fget(opt->fd);
  813. if (!filp)
  814. goto out;
  815. if (!smb_valid_socket(filp->f_dentry->d_inode))
  816. goto out_putf;
  818. server->sock_file = filp;
  819. server->conn_pid = current->pid;
  820. smb_catch_keepalive(server);
  821. server->opt = *opt;
  822. server->generation += 1;
  823. server->state = CONN_VALID;
  824. error = 0;
  826. /* check if we have an old smbmount that uses seconds for the 
  827.    serverzone */
  828. if (server->opt.serverzone > 12*60 || server->opt.serverzone < -12*60)
  829. server->opt.serverzone /= 60;
  831. /* now that we have an established connection we can detect the server
  832.    type and enable bug workarounds */
  833. if (server->opt.protocol == SMB_PROTOCOL_NT1 &&
  834.     (server->opt.max_xmit < 0x1000) &&
  835.     !(server->opt.capabilities & SMB_CAP_NT_SMBS)) {
  836. server->mnt->flags |= SMB_MOUNT_WIN95;
  837. VERBOSE("smb_newconn: detected WIN95 servern");
  838. }
  840. VERBOSE("protocol=%d, max_xmit=%d, pid=%d capabilities=0x%xn",
  841. server->opt.protocol, server->opt.max_xmit, server->conn_pid,
  842. server->opt.capabilities);
  844. /* Make sure we can fit a message of the negotiated size in our
  845.    packet buffer. */
  846. if (server->opt.max_xmit > server->packet_size) {
  847. int len = smb_round_length(server->opt.max_xmit);
  848. char *buf = smb_vmalloc(len);
  849. if (buf) {
  850. if (server->packet)
  851. smb_vfree(server->packet);
  852. server->packet = buf;
  853. server->packet_size = len;
  854. } else {
  855. /* else continue with the too small buffer? */
  856. PARANOIA("Failed to allocate new packet buffer: "
  857.  "max_xmit=%d, packet_size=%dn",
  858.  server->opt.max_xmit, server->packet_size);
  859. server->opt.max_xmit = server->packet_size;
  860. }
  861. }
  863. out:
  864. smb_unlock_server(server);
  865. smb_wakeup(server);
  866. return error;
  868. out_putf:
  869. fput(filp);
  870. goto out;
  871. }
  873. int
  874. smb_wakeup(struct smb_sb_info *server)
  875. {
  876. #ifdef SMB_RETRY_INTR
  877. wake_up_interruptible(&server->wait);
  878. #else
  879. wake_up(&server->wait);
  880. #endif
  881. return 0;
  882. }
  884. /* smb_setup_header: We completely set up the packet. You only have to
  885.    insert the command-specific fields */
  887. __u8 *
  888. smb_setup_header(struct smb_sb_info * server, __u8 command, __u16 wct, __u16 bcc)
  889. {
  890. __u32 xmit_len = SMB_HEADER_LEN + wct * sizeof(__u16) + bcc + 2;
  891. __u8 *p = server->packet;
  892. __u8 *buf = server->packet;
  894. if (xmit_len > server->packet_size)
  895. printk(KERN_DEBUG "smb_setup_header: "
  896.        "Aieee, xmit len > packet! len=%d, size=%dn",
  897.        xmit_len, server->packet_size);
  899. p = smb_encode_smb_length(p, xmit_len - 4);
  901. *p++ = 0xff;
  902. *p++ = 'S';
  903. *p++ = 'M';
  904. *p++ = 'B';
  905. *p++ = command;
  907. memset(p, '', 19);
  908. p += 19;
  909. p += 8;
  911. WSET(buf, smb_tid, server->opt.tid);
  912. WSET(buf, smb_pid, 1);
  913. WSET(buf, smb_uid, server->opt.server_uid);
  914. WSET(buf, smb_mid, 1);
  916. if (server->opt.protocol > SMB_PROTOCOL_CORE)
  917. {
  918. *(buf+smb_flg) = 0x8;
  919. WSET(buf, smb_flg2, 0x3);
  920. }
  921. *p++ = wct; /* wct */
  922. p += 2 * wct;
  923. WSET(p, 0, bcc);
  924. return p + 2;
  925. }
  927. static void
  928. smb_setup_bcc(struct smb_sb_info *server, __u8 * p)
  929. {
  930. __u8 *packet = server->packet;
  931. __u8 *pbcc = packet + SMB_HEADER_LEN + 2 * SMB_WCT(packet);
  932. __u16 bcc = p - (pbcc + 2);
  934. WSET(pbcc, 0, bcc);
  935. smb_encode_smb_length(packet,
  936.       SMB_HEADER_LEN + 2 * SMB_WCT(packet) - 2 + bcc);
  937. }
  939. /*
  940.  * Called with the server locked
  941.  */
  942. static int
  943. smb_proc_seek(struct smb_sb_info *server, __u16 fileid,
  944.       __u16 mode, off_t offset)
  945. {
  946. int result;
  948. smb_setup_header(server, SMBlseek, 4, 0);
  949. WSET(server->packet, smb_vwv0, fileid);
  950. WSET(server->packet, smb_vwv1, mode);
  951. DSET(server->packet, smb_vwv2, offset);
  953. result = smb_request_ok(server, SMBlseek, 2, 0);
  954. if (result < 0) {
  955. result = 0;
  956. goto out;
  957. }
  959. result = DVAL(server->packet, smb_vwv0);
  960. out:
  961. return result;
  962. }
  964. /*
  965.  * We're called with the server locked, and we leave it that way.
  966.  */
  967. static int
  968. smb_proc_open(struct smb_sb_info *server, struct dentry *dentry, int wish)
  969. {
  970. struct inode *ino = dentry->d_inode;
  971. int mode, read_write = 0x42, read_only = 0x40;
  972. int res;
  973. char *p;
  975. /*
  976.  * Attempt to open r/w, unless there are no write privileges.
  977.  */
  978. mode = read_write;
  979. if (!(ino->i_mode & (S_IWUSR | S_IWGRP | S_IWOTH)))
  980. mode = read_only;
  981. #if 0
  982. /* FIXME: why is this code not in? below we fix it so that a caller
  983.    wanting RO doesn't get RW. smb_revalidate_inode does some 
  984.    optimization based on access mode. tail -f needs it to be correct.
  986.    We must open rw since we don't do the open if called a second time
  987.    with different 'wish'. Is that not supported by smb servers? */
  988. if (!(wish & (O_WRONLY | O_RDWR)))
  989. mode = read_only;
  990. #endif
  992.       retry:
  993. p = smb_setup_header(server, SMBopen, 2, 0);
  994. WSET(server->packet, smb_vwv0, mode);
  995. WSET(server->packet, smb_vwv1, aSYSTEM | aHIDDEN | aDIR);
  996. res = smb_simple_encode_path(server, &p, dentry, NULL);
  997. if (res < 0)
  998. goto out;
  999. smb_setup_bcc(server, p);
  1001. res = smb_request_ok(server, SMBopen, 7, 0);
  1002. if (res != 0) {
  1003. if (smb_retry(server))
  1004. goto retry;
  1006. if (mode == read_write &&
  1007.     (res == -EACCES || res == -ETXTBSY || res == -EROFS))
  1008. {
  1009. VERBOSE("%s/%s R/W failed, error=%d, retrying R/On",
  1010. DENTRY_PATH(dentry), res);
  1011. mode = read_only;
  1012. goto retry;
  1013. }
  1014. goto out;
  1015. }
  1016. /* We should now have data in vwv[0..6]. */
  1018. ino->u.smbfs_i.fileid = WVAL(server->packet, smb_vwv0);
  1019. ino->u.smbfs_i.attr   = WVAL(server->packet, smb_vwv1);
  1020. /* smb_vwv2 has mtime */
  1021. /* smb_vwv4 has size  */
  1022. ino->u.smbfs_i.access = (WVAL(server->packet, smb_vwv6) & SMB_ACCMASK);
  1023. ino->u.smbfs_i.open = server->generation;
  1025. out:
  1026. return res;
  1027. }
  1029. /*
  1030.  * Make sure the file is open, and check that the access
  1031.  * is compatible with the desired access.
  1032.  */
  1033. int
  1034. smb_open(struct dentry *dentry, int wish)
  1035. {
  1036. struct inode *inode = dentry->d_inode;
  1037. int result;
  1039. result = -ENOENT;
  1040. if (!inode) {
  1041. printk(KERN_ERR "smb_open: no inode for dentry %s/%sn",
  1042.        DENTRY_PATH(dentry));
  1043. goto out;
  1044. }
  1046. if (!smb_is_open(inode)) {
  1047. struct smb_sb_info *server = server_from_inode(inode);
  1048. smb_lock_server(server);
  1049. result = 0;
  1050. if (!smb_is_open(inode))
  1051. result = smb_proc_open(server, dentry, wish);
  1052. smb_unlock_server(server);
  1053. if (result) {
  1054. PARANOIA("%s/%s open failed, result=%dn",
  1055.  DENTRY_PATH(dentry), result);
  1056. goto out;
  1057. }
  1058. /*
  1059.  * A successful open means the path is still valid ...
  1060.  */
  1061. smb_renew_times(dentry);
  1062. }
  1064. /*
  1065.  * Check whether the access is compatible with the desired mode.
  1066.  */
  1067. result = 0;
  1068. if (inode->u.smbfs_i.access != wish && 
  1069.     inode->u.smbfs_i.access != SMB_O_RDWR)
  1070. {
  1071. PARANOIA("%s/%s access denied, access=%x, wish=%xn",
  1072.  DENTRY_PATH(dentry), inode->u.smbfs_i.access, wish);
  1073. result = -EACCES;
  1074. }
  1075. out:
  1076. return result;
  1077. }
  1079. /* We're called with the server locked */
  1081. static int 
  1082. smb_proc_close(struct smb_sb_info *server, __u16 fileid, __u32 mtime)
  1083. {
  1084. smb_setup_header(server, SMBclose, 3, 0);
  1085. WSET(server->packet, smb_vwv0, fileid);
  1086. DSET(server->packet, smb_vwv1, utc2local(server, mtime));
  1087. return smb_request_ok(server, SMBclose, 0, 0);
  1088. }
  1090. /*
  1091.  * Called with the server locked.
  1092.  *
  1093.  * Win NT 4.0 has an apparent bug in that it fails to update the
  1094.  * modify time when writing to a file. As a workaround, we update
  1095.  * both modify and access time locally, and post the times to the
  1096.  * server when closing the file.
  1097.  */
  1098. static int 
  1099. smb_proc_close_inode(struct smb_sb_info *server, struct inode * ino)
  1100. {
  1101. int result = 0;
  1102. if (smb_is_open(ino))
  1103. {
  1104. /*
  1105.  * We clear the open flag in advance, in case another
  1106.    * process observes the value while we block below.
  1107.  */
  1108. ino->u.smbfs_i.open = 0;
  1110. /*
  1111.  * Kludge alert: SMB timestamps are accurate only to
  1112.  * two seconds ... round the times to avoid needless
  1113.  * cache invalidations!
  1114.  */
  1115. if (ino->i_mtime & 1)
  1116. ino->i_mtime--;
  1117. if (ino->i_atime & 1)
  1118. ino->i_atime--;
  1119. /*
  1120.  * If the file is open with write permissions,
  1121.  * update the time stamps to sync mtime and atime.
  1122.  */
  1123. if ((server->opt.protocol >= SMB_PROTOCOL_LANMAN2) &&
  1124.     !(ino->u.smbfs_i.access == SMB_O_RDONLY))
  1125. {
  1126. struct smb_fattr fattr;
  1127. smb_get_inode_attr(ino, &fattr);
  1128. smb_proc_setattr_ext(server, ino, &fattr);
  1129. }
  1131. result = smb_proc_close(server, ino->u.smbfs_i.fileid,
  1132. ino->i_mtime);
  1133. /*
  1134.  * Force a revalidation after closing ... some servers
  1135.  * don't post the size until the file has been closed.
  1136.  */
  1137. if (server->opt.protocol < SMB_PROTOCOL_NT1)
  1138. ino->u.smbfs_i.oldmtime = 0;
  1139. ino->u.smbfs_i.closed = jiffies;
  1140. }
  1141. return result;
  1142. }
  1144. int
  1145. smb_close(struct inode *ino)
  1146. {
  1147. int result = 0;
  1149. if (smb_is_open(ino)) {
  1150. struct smb_sb_info *server = server_from_inode(ino);
  1151. smb_lock_server(server);
  1152. result = smb_proc_close_inode(server, ino);
  1153. smb_unlock_server(server);
  1154. }
  1155. return result;
  1156. }
  1158. /*
  1159.  * This is used to close a file following a failed instantiate.
  1160.  * Since we don't have an inode, we can't use any of the above.
  1161.  */
  1162. int
  1163. smb_close_fileid(struct dentry *dentry, __u16 fileid)
  1164. {
  1165. struct smb_sb_info *server = server_from_dentry(dentry);
  1166. int result;
  1168. smb_lock_server(server);
  1169. result = smb_proc_close(server, fileid, CURRENT_TIME);
  1170. smb_unlock_server(server);
  1171. return result;
  1172. }
  1174. /* In smb_proc_read and smb_proc_write we do not retry, because the
  1175.    file-id would not be valid after a reconnection. */
  1177. int
  1178. smb_proc_read(struct inode *inode, off_t offset, int count, char *data)
  1179. {
  1180. struct smb_sb_info *server = server_from_inode(inode);
  1181. __u16 returned_count, data_len;
  1182. unsigned char *buf;
  1183. int result;
  1185. smb_lock_server(server);
  1186. smb_setup_header(server, SMBread, 5, 0);
  1187. buf = server->packet;
  1188. WSET(buf, smb_vwv0, inode->u.smbfs_i.fileid);
  1189. WSET(buf, smb_vwv1, count);
  1190. DSET(buf, smb_vwv2, offset);
  1191. WSET(buf, smb_vwv4, 0);
  1193. result = smb_request_ok(server, SMBread, 5, -1);
  1194. if (result < 0)
  1195. goto out;
  1196. returned_count = WVAL(server->packet, smb_vwv0);
  1198. buf = SMB_BUF(server->packet);
  1199. data_len = WVAL(buf, 1);
  1201. /* we can NOT simply trust the data_len given by the server ... */
  1202. if (data_len > server->packet_size - (buf+3 - server->packet)) {
  1203. printk(KERN_ERR "smb_proc_read: invalid data length!! "
  1204.        "%d > %d - (%p - %p)n",
  1205.        data_len, server->packet_size, buf+3, server->packet);
  1206. result = -EIO;
  1207. goto out;
  1208. }
  1210. memcpy(data, buf+3, data_len);
  1212. if (returned_count != data_len) {
  1213. printk(KERN_NOTICE "smb_proc_read: returned != data_lenn");
  1214. printk(KERN_NOTICE "smb_proc_read: ret_c=%d, data_len=%dn",
  1215.        returned_count, data_len);
  1216. }
  1217. result = data_len;
  1219. out:
  1220. VERBOSE("ino=%ld, fileid=%d, count=%d, result=%dn",
  1221. inode->i_ino, inode->u.smbfs_i.fileid, count, result);
  1222. smb_unlock_server(server);
  1223. return result;
  1224. }
  1226. int
  1227. smb_proc_write(struct inode *inode, off_t offset, int count, const char *data)
  1228. {
  1229. struct smb_sb_info *server = server_from_inode(inode);
  1230. int result;
  1231. __u8 *p;
  1232. __u16 fileid = inode->u.smbfs_i.fileid;
  1234. VERBOSE("ino=%ld, fileid=%d, count=%d@%ld, packet_size=%dn",
  1235. inode->i_ino, inode->u.smbfs_i.fileid, count, offset,
  1236. server->packet_size);
  1238. smb_lock_server(server);
  1239. p = smb_setup_header(server, SMBwrite, 5, count + 3);
  1240. WSET(server->packet, smb_vwv0, fileid);
  1241. WSET(server->packet, smb_vwv1, count);
  1242. DSET(server->packet, smb_vwv2, offset);
  1243. WSET(server->packet, smb_vwv4, 0);
  1245. *p++ = 1;
  1246. WSET(p, 0, count);
  1247. memcpy(p+2, data, count);
  1249. result = smb_request_ok(server, SMBwrite, 1, 0);
  1250. if (result >= 0)
  1251. result = WVAL(server->packet, smb_vwv0);
  1253. smb_unlock_server(server);
  1254. return result;
  1255. }
  1257. int
  1258. smb_proc_create(struct dentry *dentry, __u16 attr, time_t ctime, __u16 *fileid)
  1259. {
  1260. struct smb_sb_info *server = server_from_dentry(dentry);
  1261. char *p;
  1262. int result;
  1264. smb_lock_server(server);
  1266.       retry:
  1267. p = smb_setup_header(server, SMBcreate, 3, 0);
  1268. WSET(server->packet, smb_vwv0, attr);
  1269. DSET(server->packet, smb_vwv1, utc2local(server, ctime));
  1270. result = smb_simple_encode_path(server, &p, dentry, NULL);
  1271. if (result < 0)
  1272. goto out;
  1273. smb_setup_bcc(server, p);
  1275. result = smb_request_ok(server, SMBcreate, 1, 0);
  1276. if (result < 0) {
  1277. if (smb_retry(server))
  1278. goto retry;
  1279. goto out;
  1280. }
  1281. *fileid = WVAL(server->packet, smb_vwv0);
  1282. result = 0;
  1284. out:
  1285. smb_unlock_server(server);
  1286. return result;
  1287. }
  1289. int
  1290. smb_proc_mv(struct dentry *old_dentry, struct dentry *new_dentry)
  1291. {
  1292. struct smb_sb_info *server = server_from_dentry(old_dentry);
  1293. char *p;
  1294. int result;
  1296. smb_lock_server(server);
  1298.       retry:
  1299. p = smb_setup_header(server, SMBmv, 1, 0);
  1300. WSET(server->packet, smb_vwv0, aSYSTEM | aHIDDEN | aDIR);
  1301. result = smb_simple_encode_path(server, &p, old_dentry, NULL);
  1302. if (result < 0)
  1303. goto out;
  1304. result = smb_simple_encode_path(server, &p, new_dentry, NULL);
  1305. if (result < 0)
  1306. goto out;
  1307. smb_setup_bcc(server, p);
  1309. if ((result = smb_request_ok(server, SMBmv, 0, 0)) < 0) {
  1310. if (smb_retry(server))
  1311. goto retry;
  1312. goto out;
  1313. }
  1314. result = 0;
  1315. out:
  1316. smb_unlock_server(server);
  1317. return result;
  1318. }
  1320. /*
  1321.  * Code common to mkdir and rmdir.
  1322.  */
  1323. static int
  1324. smb_proc_generic_command(struct dentry *dentry, __u8 command)
  1325. {
  1326. struct smb_sb_info *server = server_from_dentry(dentry);
  1327. char *p;
  1328. int result;
  1330. smb_lock_server(server);
  1332.       retry:
  1333. p = smb_setup_header(server, command, 0, 0);
  1334. result = smb_simple_encode_path(server, &p, dentry, NULL);
  1335. if (result < 0)
  1336. goto out;
  1337. smb_setup_bcc(server, p);
  1339. result = smb_request_ok(server, command, 0, 0);
  1340. if (result < 0) {
  1341. if (smb_retry(server))
  1342. goto retry;
  1343. goto out;
  1344. }
  1345. result = 0;
  1346. out:
  1347. smb_unlock_server(server);
  1348. return result;
  1349. }
  1351. int
  1352. smb_proc_mkdir(struct dentry *dentry)
  1353. {
  1354. return smb_proc_generic_command(dentry, SMBmkdir);
  1355. }
  1357. int
  1358. smb_proc_rmdir(struct dentry *dentry)
  1359. {
  1360. return smb_proc_generic_command(dentry, SMBrmdir);
  1361. }
  1363. #if SMBFS_POSIX_UNLINK
  1364. /*
  1365.  * Removes readonly attribute from a file. Used by unlink to give posix
  1366.  * semantics.
  1367.  * Note: called with the server locked.
  1368.  */
  1369. static int
  1370. smb_set_rw(struct dentry *dentry,struct smb_sb_info *server)
  1371. {
  1372. int result;
  1373. struct smb_fattr fattr;
  1375. /* first get current attribute */
  1376. result = smb_proc_do_getattr(server, dentry, &fattr);
  1377. if (result < 0)
  1378. return result;
  1380. /* if RONLY attribute is set, remove it */
  1381. if (fattr.attr & aRONLY) {  /* read only attribute is set */
  1382. fattr.attr &= ~aRONLY;
  1383. result = smb_proc_setattr_core(server, dentry, fattr.attr);
  1384. }
  1385. return result;
  1386. }
  1387. #endif
  1389. int
  1390. smb_proc_unlink(struct dentry *dentry)
  1391. {
  1392. struct smb_sb_info *server = server_from_dentry(dentry);
  1393. int flag = 0;
  1394. char *p;
  1395. int result;
  1397. smb_lock_server(server);
  1399.       retry:
  1400. p = smb_setup_header(server, SMBunlink, 1, 0);
  1401. WSET(server->packet, smb_vwv0, aSYSTEM | aHIDDEN);
  1402. result = smb_simple_encode_path(server, &p, dentry, NULL);
  1403. if (result < 0)
  1404. goto out;
  1405. smb_setup_bcc(server, p);
  1407. if ((result = smb_request_ok(server, SMBunlink, 0, 0)) < 0) {
  1408. #if SMBFS_POSIX_UNLINK
  1409. if (result == -EACCES && !flag) {
  1410. /* Posix semantics is for the read-only state
  1411.    of a file to be ignored in unlink(). In the
  1412.    SMB world a unlink() is refused on a
  1413.    read-only file. To make things easier for
  1414.    unix users we try to override the files
  1415.    permission if the unlink fails with the
  1416.    right error.
  1417.    This introduces a race condition that could
  1418.    lead to a file being written by someone who
  1419.    shouldn't have access, but as far as I can
  1420.    tell that is unavoidable */
  1422. /* remove RONLY attribute and try again */
  1423. result = smb_set_rw(dentry,server);
  1424. if (result == 0) {
  1425. flag = 1;
  1426. goto retry;
  1427. }
  1428. }
  1429. #endif
  1430. if (smb_retry(server))
  1431. goto retry;
  1432. goto out;
  1433. }
  1434. result = 0;
  1435. out:
  1436. smb_unlock_server(server);
  1437. return result;
  1438. }
  1440. /*
  1441.  * Called with the server locked
  1442.  */
  1443. int
  1444. smb_proc_flush(struct smb_sb_info *server, __u16 fileid)
  1445. {
  1446. smb_setup_header(server, SMBflush, 1, 0);
  1447. WSET(server->packet, smb_vwv0, fileid);
  1448. return smb_request_ok(server, SMBflush, 0, 0);
  1449. }
  1451. int
  1452. smb_proc_trunc(struct smb_sb_info *server, __u16 fid, __u32 length)
  1453. {
  1454. char *p;
  1455. int result;
  1457. smb_lock_server(server);
  1459. retry:
  1460. p = smb_setup_header(server, SMBwrite, 5, 3);
  1461. WSET(server->packet, smb_vwv0, fid);
  1462. WSET(server->packet, smb_vwv1, 0);
  1463. DSET(server->packet, smb_vwv2, length);
  1464. WSET(server->packet, smb_vwv4, 0);
  1465. *p++ = 1;
  1466. WSET(p, 0, 0);
  1468. if ((result = smb_request_ok(server, SMBwrite, 1, 0)) < 0) {
  1469. if (smb_retry(server))
  1470. goto retry;
  1471. goto out;
  1472. }
  1474. /*
  1475.  * win9x doesn't appear to update the size immediately.
  1476.  * It will return the old file size after the truncate,
  1477.  * confusing smbfs.
  1478.  * NT and Samba return the new value immediately.
  1479.  */
  1480. if (server->mnt->flags & SMB_MOUNT_WIN95)
  1481. smb_proc_flush(server, fid);
  1482. out:
  1483. smb_unlock_server(server);
  1484. return result;
  1485. }
  1487. static void
  1488. smb_init_dirent(struct smb_sb_info *server, struct smb_fattr *fattr)
  1489. {
  1490. memset(fattr, 0, sizeof(*fattr));
  1492. fattr->f_nlink = 1;
  1493. fattr->f_uid = server->mnt->uid;
  1494. fattr->f_gid = server->mnt->gid;
  1495. fattr->f_blksize = SMB_ST_BLKSIZE;
  1496. }
  1498. static void
  1499. smb_finish_dirent(struct smb_sb_info *server, struct smb_fattr *fattr)
  1500. {
  1501. fattr->f_mode = server->mnt->file_mode;
  1502. if (fattr->attr & aDIR)
  1503. {
  1504. fattr->f_mode = server->mnt->dir_mode;
  1505. fattr->f_size = SMB_ST_BLKSIZE;
  1506. }
  1507. /* Check the read-only flag */
  1508. if (fattr->attr & aRONLY)
  1509. fattr->f_mode &= ~(S_IWUSR | S_IWGRP | S_IWOTH);
  1511. /* How many 512 byte blocks do we need for this file? */
  1512. fattr->f_blocks = 0;
  1513. if (fattr->f_size != 0)
  1514. fattr->f_blocks = 1 + ((fattr->f_size-1) >> 9);
  1515. return;
  1516. }
  1518. void
  1519. smb_init_root_dirent(struct smb_sb_info *server, struct smb_fattr *fattr)
  1520. {
  1521. smb_init_dirent(server, fattr);
  1522. fattr->attr = aDIR;
  1523. fattr->f_ino = 2; /* traditional root inode number */
  1524. fattr->f_mtime = CURRENT_TIME;
  1525. smb_finish_dirent(server, fattr);
  1526. }
  1528. /*
  1529.  * Decode a dirent for old protocols
  1530.  *
  1531.  * qname is filled with the decoded, and possibly translated, name.
  1532.  * fattr receives decoded attributes
  1533.  *
  1534.  * Bugs Noted:
  1535.  * (1) Pathworks servers may pad the name with extra spaces.
  1536.  */
  1537. static char *
  1538. smb_decode_short_dirent(struct smb_sb_info *server, char *p,
  1539. struct qstr *qname, struct smb_fattr *fattr)
  1540. {
  1541. int len;
  1543. /*
  1544.  * SMB doesn't have a concept of inode numbers ...
  1545.  */
  1546. smb_init_dirent(server, fattr);
  1547. fattr->f_ino = 0; /* FIXME: do we need this? */
  1549. p += SMB_STATUS_SIZE; /* reserved (search_status) */
  1550. fattr->attr = *p;
  1551. fattr->f_mtime = date_dos2unix(server, WVAL(p, 3), WVAL(p, 1));
  1552. fattr->f_size = DVAL(p, 5);
  1553. fattr->f_ctime = fattr->f_mtime;
  1554. fattr->f_atime = fattr->f_mtime;
  1555. qname->name = p + 9;
  1556. len = strnlen(qname->name, 12);
  1558. /*
  1559.  * Trim trailing blanks for Pathworks servers
  1560.  */
  1561. while (len > 2 && qname->name[len-1] == ' ')
  1562. len--;
  1563. qname->len = len;
  1565. smb_finish_dirent(server, fattr);
  1567. #if 0
  1568. /* FIXME: These only work for ascii chars, and recent smbmount doesn't
  1569.    allow the flag to be set anyway. It kills const. Remove? */
  1570. switch (server->opt.case_handling) {
  1571. case SMB_CASE_UPPER:
  1572. str_upper(entry->name, len);
  1573. break;
  1574. case SMB_CASE_LOWER:
  1575. str_lower(entry->name, len);
  1576. break;
  1577. default:
  1578. break;
  1579. }
  1580. #endif
  1582. qname->len = server->convert(server->name_buf, SMB_MAXNAMELEN,
  1583.      qname->name, len,
  1584.      server->remote_nls, server->local_nls);
  1585. qname->name = server->name_buf;
  1587. DEBUG1("len=%d, name=%.*sn", qname->len, qname->len, qname->name);
  1588. return p + 22;
  1589. }
  1591. /*
  1592.  * This routine is used to read in directory entries from the network.
  1593.  * Note that it is for short directory name seeks, i.e.: protocol <
  1594.  * SMB_PROTOCOL_LANMAN2
  1595.  */
  1596. static int
  1597. smb_proc_readdir_short(struct file *filp, void *dirent, filldir_t filldir,
  1598.        struct smb_cache_control *ctl)
  1599. {
  1600. struct dentry *dir = filp->f_dentry;
  1601. struct smb_sb_info *server = server_from_dentry(dir);
  1602. struct qstr qname;
  1603. struct smb_fattr fattr;
  1604. char *p;
  1605. int result;
  1606. int i, first, entries_seen, entries;
  1607. int entries_asked = (server->opt.max_xmit - 100) / SMB_DIRINFO_SIZE;
  1608. __u16 bcc;
  1609. __u16 count;
  1610. char status[SMB_STATUS_SIZE];
  1611. static struct qstr mask = { "*.*", 3, 0 };
  1612. unsigned char *last_status;
  1614. VERBOSE("%s/%sn", DENTRY_PATH(dir));
  1616. smb_lock_server(server);
  1618. first = 1;
  1619. entries = 0;
  1620. entries_seen = 2; /* implicit . and .. */
  1622. while (1) {
  1623. p = smb_setup_header(server, SMBsearch, 2, 0);
  1624. WSET(server->packet, smb_vwv0, entries_asked);
  1625. WSET(server->packet, smb_vwv1, aDIR);
  1626. if (first == 1) {
  1627. result = smb_simple_encode_path(server, &p, dir, &mask);
  1628. if (result < 0)
  1629. goto unlock_return;
  1630. if (p + 3 > (char*)server->packet+server->packet_size) {
  1631. result = -ENAMETOOLONG;
  1632. goto unlock_return;
  1633. }
  1634. *p++ = 5;
  1635. WSET(p, 0, 0);
  1636. p += 2;
  1637. first = 0;
  1638. } else {
  1639. if (p + 5 + SMB_STATUS_SIZE >
  1640.     (char*)server->packet + server->packet_size) {
  1641. result = -ENAMETOOLONG;
  1642. goto unlock_return;
  1643. }
  1645. *p++ = 4;
  1646. *p++ = 0;
  1647. *p++ = 5;
  1648. WSET(p, 0, SMB_STATUS_SIZE);
  1649. p += 2;
  1650. memcpy(p, status, SMB_STATUS_SIZE);
  1651. p += SMB_STATUS_SIZE;
  1652. }
  1654. smb_setup_bcc(server, p);
  1656. result = smb_request_ok(server, SMBsearch, 1, -1);
  1657. if (result < 0) {
  1658. if ((server->rcls == ERRDOS) && 
  1659.     (server->err  == ERRnofiles))
  1660. break;
  1661. if (smb_retry(server)) {
  1662. ctl->idx = -1; /* retry */
  1663. result = 0;
  1664. }
  1665. goto unlock_return;
  1666. }
  1667. p = SMB_VWV(server->packet);
  1668. count = WVAL(p, 0);
  1669. if (count <= 0)
  1670. break;
  1672. result = -EIO;
  1673. bcc = WVAL(p, 2);
  1674. if (bcc != count * SMB_DIRINFO_SIZE + 3)
  1675. goto unlock_return;
  1676. p += 7;
  1679. /* Make sure the response fits in the buffer. Fixed sized 
  1680.    entries means we don't have to check in the decode loop. */
  1682. last_status = SMB_BUF(server->packet) + 3 + (count - 1) *
  1683. SMB_DIRINFO_SIZE;
  1685. if (last_status + SMB_DIRINFO_SIZE >=
  1686.     server->packet + server->packet_size) {
  1687. printk(KERN_ERR "smb_proc_readdir_short: "
  1688.        "last dir entry outside buffer! "
  1689.        "%d@%p  %d@%pn", SMB_DIRINFO_SIZE, last_status,
  1690.        server->packet_size, server->packet);
  1691. goto unlock_return;
  1692. }
  1694. /* Read the last entry into the status field. */
  1695. memcpy(status, last_status, SMB_STATUS_SIZE);
  1698. /* Now we are ready to parse smb directory entries. */
  1700. for (i = 0; i < count; i++) {
  1701. p = smb_decode_short_dirent(server, p, 
  1702.     &qname, &fattr);
  1704. if (entries_seen == 2 && qname.name[0] == '.') {
  1705. if (qname.len == 1)
  1706. continue;
  1707. if (qname.name[1] == '.' && qname.len == 2)
  1708. continue;
  1709. }
  1710. if (!smb_fill_cache(filp, dirent, filldir, ctl, 
  1711.     &qname, &fattr))
  1712. ; /* stop reading? */
  1713. entries_seen++;
  1714. }
  1715. }
  1716. result = entries;
  1718. unlock_return:
  1719. smb_unlock_server(server);
  1720. return result;
  1721. }
  1723. /*
  1724.  * Interpret a long filename structure using the specified info level:
  1725.  *   level 1 for anything below NT1 protocol
  1726.  *   level 260 for NT1 protocol
  1727.  *
  1728.  * qname is filled with the decoded, and possibly translated, name
  1729.  * fattr receives decoded attributes.
  1730.  *
  1731.  * Bugs Noted:
  1732.  * (1) Win NT 4.0 appends a null byte to names and counts it in the length!
  1733.  */
  1734. static char *
  1735. smb_decode_long_dirent(struct smb_sb_info *server, char *p, int level,
  1736.        struct qstr *qname, struct smb_fattr *fattr)
  1737. {
  1738. char *result;
  1739. unsigned int len = 0;
  1740. __u16 date, time;
  1742. /*
  1743.  * SMB doesn't have a concept of inode numbers ...
  1744.  */
  1745. smb_init_dirent(server, fattr);
  1746. fattr->f_ino = 0; /* FIXME: do we need this? */
  1748. switch (level) {
  1749. case 1:
  1750. len = *((unsigned char *) p + 22);
  1751. qname->name = p + 23;
  1752. result = p + 24 + len;
  1754. date = WVAL(p, 0);
  1755. time = WVAL(p, 2);
  1756. fattr->f_ctime = date_dos2unix(server, date, time);
  1758. date = WVAL(p, 4);
  1759. time = WVAL(p, 6);
  1760. fattr->f_atime = date_dos2unix(server, date, time);
  1762. date = WVAL(p, 8);
  1763. time = WVAL(p, 10);
  1764. fattr->f_mtime = date_dos2unix(server, date, time);
  1765. fattr->f_size = DVAL(p, 12);
  1766. /* ULONG allocation size */
  1767. fattr->attr = WVAL(p, 20);
  1769. VERBOSE("info 1 at %p, len=%d, name=%.*sn",
  1770. p, len, len, qname->name);
  1771. break;
  1772. case 260:
  1773. result = p + WVAL(p, 0);
  1774. len = DVAL(p, 60);
  1775. if (len > 255) len = 255;
  1776. /* NT4 null terminates */
  1777. qname->name = p + 94;
  1778. if (len && qname->name[len-1] == '')
  1779. len--;
  1781. fattr->f_ctime = smb_ntutc2unixutc(LVAL(p, 8));
  1782. fattr->f_atime = smb_ntutc2unixutc(LVAL(p, 16));
  1783. fattr->f_mtime = smb_ntutc2unixutc(LVAL(p, 24));
  1784. /* change time (32) */
  1785. fattr->f_size = DVAL(p, 40);
  1786. /* alloc size (48) */
  1787. fattr->attr = DVAL(p, 56);
  1789. VERBOSE("info 260 at %p, len=%d, name=%.*sn",
  1790. p, len, len, qname->name);
  1791. break;
  1792. default:
  1793. PARANOIA("Unknown info level %dn", level);
  1794. result = p + WVAL(p, 0);
  1795. goto out;
  1796. }
  1798. smb_finish_dirent(server, fattr);
  1800. #if 0
  1801. /* FIXME: These only work for ascii chars, and recent smbmount doesn't
  1802.    allow the flag to be set anyway. Remove? */
  1803. switch (server->opt.case_handling) {
  1804. case SMB_CASE_UPPER:
  1805. str_upper(qname->name, len);
  1806. break;
  1807. case SMB_CASE_LOWER:
  1808. str_lower(qname->name, len);
  1809. break;
  1810. default:
  1811. break;
  1812. }
  1813. #endif
  1815. qname->len = server->convert(server->name_buf, SMB_MAXNAMELEN,
  1816.      qname->name, len,
  1817.      server->remote_nls, server->local_nls);
  1818. qname->name = server->name_buf;
  1820. out:
  1821. return result;
  1822. }
  1824. /* findfirst/findnext flags */
  1825. #define SMB_CLOSE_AFTER_FIRST (1<<0)
  1826. #define SMB_CLOSE_IF_END (1<<1)
  1827. #define SMB_REQUIRE_RESUME_KEY (1<<2)
  1828. #define SMB_CONTINUE_BIT (1<<3)
  1830. /*
  1831.  * Note: samba-2.0.7 (at least) has a very similar routine, cli_list, in
  1832.  * source/libsmb/clilist.c. When looking for smb bugs in the readdir code,
  1833.  * go there for advise.
  1834.  *
  1835.  * Bugs Noted:
  1836.  * (1) When using Info Level 1 Win NT 4.0 truncates directory listings 
  1837.  * for certain patterns of names and/or lengths. The breakage pattern
  1838.  * is completely reproducible and can be toggled by the creation of a
  1839.  * single file. (E.g. echo hi >foo breaks, rm -f foo works.)
  1840.  */
  1841. static int
  1842. smb_proc_readdir_long(struct file *filp, void *dirent, filldir_t filldir,
  1843.       struct smb_cache_control *ctl)
  1844. {
  1845. struct dentry *dir = filp->f_dentry;
  1846. struct smb_sb_info *server = server_from_dentry(dir);
  1847. struct qstr qname;
  1848. struct smb_fattr fattr;
  1850. unsigned char *p, *lastname;
  1851. char *mask, *param = server->temp_buf;
  1852. __u16 command;
  1853. int first, entries_seen;
  1855. /* Both NT and OS/2 accept info level 1 (but see note below). */
  1856. int info_level = 260;
  1857. const int max_matches = 512;
  1859. unsigned char *resp_data = NULL;
  1860. unsigned char *resp_param = NULL;
  1861. int resp_data_len = 0;
  1862. int resp_param_len = 0;
  1863. int ff_searchcount = 0;
  1864. int ff_eos = 0;
  1865. int ff_lastname = 0;
  1866. int ff_dir_handle = 0;
  1867. int loop_count = 0;
  1868. int mask_len, i, result;
  1869. static struct qstr star = { "*", 1, 0 };
  1871. /*
  1872.  * use info level 1 for older servers that don't do 260
  1873.  */
  1874. if (server->opt.protocol < SMB_PROTOCOL_NT1)
  1875. info_level = 1;
  1877. smb_lock_server(server);
  1879. /*
  1880.  * Encode the initial path
  1881.  */
  1882. mask = param + 12;
  1884. mask_len = smb_encode_path(server, mask, SMB_MAXNAMELEN+1, dir, &star);
  1885. if (mask_len < 0) {
  1886. result = mask_len;
  1887. goto unlock_return;
  1888. }
  1889. mask_len--; /* mask_len is strlen, not #bytes */
  1890. first = 1;
  1891. VERBOSE("starting mask_len=%d, mask=%sn", mask_len, mask);
  1893. result = 0;
  1894. entries_seen = 2;
  1895. ff_eos = 0;
  1897. while (ff_eos == 0) {
  1898. loop_count += 1;
  1899. if (loop_count > 10) {
  1900. printk(KERN_WARNING "smb_proc_readdir_long: "
  1901.        "Looping in FIND_NEXT??n");
  1902. result = -EIO;
  1903. break;
  1904. }
  1906. if (first != 0) {
  1907. command = TRANSACT2_FINDFIRST;
  1908. WSET(param, 0, aSYSTEM | aHIDDEN | aDIR);
  1909. WSET(param, 2, max_matches); /* max count */
  1910. WSET(param, 4, SMB_CLOSE_IF_END);
  1911. WSET(param, 6, info_level);
  1912. DSET(param, 8, 0);
  1913. } else {
  1914. command = TRANSACT2_FINDNEXT;
  1916. VERBOSE("handle=0x%X, lastname=%d, mask=%sn",
  1917. ff_dir_handle, ff_lastname, mask);
  1919. WSET(param, 0, ff_dir_handle); /* search handle */
  1920. WSET(param, 2, max_matches); /* max count */
  1921. WSET(param, 4, info_level);
  1922. DSET(param, 6, 0);
  1923. WSET(param, 10, SMB_CONTINUE_BIT|SMB_CLOSE_IF_END);
  1924. }
  1926. result = smb_trans2_request(server, command,
  1927.     0, NULL, 12 + mask_len + 1, param,
  1928.     &resp_data_len, &resp_data,
  1929.     &resp_param_len, &resp_param);
  1931. if (result < 0) {
  1932. if (smb_retry(server)) {
  1933. PARANOIA("error=%d, retryingn", result);
  1934. ctl->idx = -1; /* retry */
  1935. result = 0;
  1936. goto unlock_return;
  1937. }
  1938. PARANOIA("error=%d, breakingn", result);
  1939. break;
  1940. }
  1942. if (server->rcls == ERRSRV && server->err == ERRerror) {
  1943. /* a damn Win95 bug - sometimes it clags if you 
  1944.    ask it too fast */
  1945. current->state = TASK_INTERRUPTIBLE;
  1946. schedule_timeout(HZ/5);
  1947. continue;
  1948.                 }
  1950. if (server->rcls != 0) {
  1951. result = smb_errno(server);
  1952. PARANOIA("name=%s, result=%d, rcls=%d, err=%dn",
  1953.  mask, result, server->rcls, server->err);
  1954. break;
  1955. }
  1957. /* parse out some important return info */
  1958. if (first != 0) {
  1959. ff_dir_handle = WVAL(resp_param, 0);
  1960. ff_searchcount = WVAL(resp_param, 2);
  1961. ff_eos = WVAL(resp_param, 4);
  1962. ff_lastname = WVAL(resp_param, 8);
  1963. } else {
  1964. ff_searchcount = WVAL(resp_param, 0);
  1965. ff_eos = WVAL(resp_param, 2);
  1966. ff_lastname = WVAL(resp_param, 6);
  1967. }
  1969. if (ff_searchcount == 0)
  1970. break;
  1972. /*
  1973.  * We might need the lastname for continuations.
  1974.  *
  1975.  * Note that some servers (win95?) point to the filename and
  1976.  * others (NT4, Samba using NT1) to the dir entry. We assume
  1977.  * here that those who do not point to a filename do not need
  1978.  * this info to continue the listing.
  1979.  *
  1980.  * OS/2 needs this and talks infolevel 1
  1981.  * NetApps want lastname with infolevel 260
  1982.  *
  1983.  * Both are happy if we return the data they point to. So we do.
  1984.  */
  1985. mask_len = 0;
  1986. if (ff_lastname > 0 && ff_lastname < resp_data_len) {
  1987. lastname = resp_data + ff_lastname;
  1989. switch (info_level) {
  1990. case 260:
  1991. mask_len = resp_data_len - ff_lastname;
  1992. break;
  1993. case 1:
  1994. /* lastname points to a length byte */
  1995. mask_len = *lastname++;
  1996. if (ff_lastname + 1 + mask_len > resp_data_len)
  1997. mask_len = resp_data_len - ff_lastname - 1;
  1998. break;
  1999. }
  2001. /*
  2002.  * Update the mask string for the next message.
  2003.  */
  2004. if (mask_len < 0)
  2005. mask_len = 0;
  2006. if (mask_len > 255)
  2007. mask_len = 255;
  2008. if (mask_len)
  2009. strncpy(mask, lastname, mask_len);
  2010. }
  2011. mask_len = strnlen(mask, mask_len);
  2012. VERBOSE("new mask, len=%d@%d of %d, mask=%.*sn",
  2013. mask_len, ff_lastname, resp_data_len, mask_len, mask);
  2015. /* Now we are ready to parse smb directory entries. */
  2017. /* point to the data bytes */
  2018. p = resp_data;
  2019. for (i = 0; i < ff_searchcount; i++) {
  2020. /* make sure we stay within the buffer */
  2021. if (p >= resp_data + resp_data_len) {
  2022. printk(KERN_ERR "smb_proc_readdir_long: "
  2023.        "dirent pointer outside buffer! "
  2024.        "%p  %d@%p  %d@%pn",
  2025.        p, resp_data_len, resp_data,
  2026.        server->packet_size, server->packet);
  2027. result = -EIO; /* always a comm. error? */
  2028. goto unlock_return;
  2029. }
  2031. p = smb_decode_long_dirent(server, p, info_level,
  2032.    &qname, &fattr);
  2034. /* ignore . and .. from the server */
  2035. if (entries_seen == 2 && qname.name[0] == '.') {
  2036. if (qname.len == 1)
  2037. continue;
  2038. if (qname.name[1] == '.' && qname.len == 2)
  2039. continue;
  2040. }
  2042. if (!smb_fill_cache(filp, dirent, filldir, ctl, 
  2043.     &qname, &fattr))
  2044. ; /* stop reading? */
  2045. entries_seen++;
  2046. }
  2048. VERBOSE("received %d entries, eos=%dn", ff_searchcount,ff_eos);
  2050. first = 0;
  2051. loop_count = 0;
  2052. }
  2054. unlock_return:
  2055. smb_unlock_server(server);
  2056. return result;
  2057. }
  2059. int
  2060. smb_proc_readdir(struct file *filp, void *dirent, filldir_t filldir,
  2061.  struct smb_cache_control *ctl)
  2062. {
  2063. struct smb_sb_info *server = server_from_dentry(filp->f_dentry);
  2065. if (server->opt.protocol >= SMB_PROTOCOL_LANMAN2)
  2066. return smb_proc_readdir_long(filp, dirent, filldir, ctl);
  2067. else
  2068. return smb_proc_readdir_short(filp, dirent, filldir, ctl);
  2069. }
  2071. /*
  2072.  * This version uses the trans2 TRANSACT2_FINDFIRST message 
  2073.  * to get the attribute data.
  2074.  * Note: called with the server locked.
  2075.  *
  2076.  * Bugs Noted:
  2077.  */
  2078. static int
  2079. smb_proc_getattr_ff(struct smb_sb_info *server, struct dentry *dentry,
  2080. struct smb_fattr *fattr)
  2081. {
  2082. char *param = server->temp_buf, *mask = param + 12;
  2083. __u16 date, time;
  2084. unsigned char *resp_data = NULL;
  2085. unsigned char *resp_param = NULL;
  2086. int resp_data_len = 0;
  2087. int resp_param_len = 0;
  2088. int mask_len, result;
  2090. retry:
  2091. mask_len = smb_encode_path(server, mask, SMB_MAXNAMELEN+1, dentry, NULL);
  2092. if (mask_len < 0) {
  2093. result = mask_len;
  2094. goto out;
  2095. }
  2096. VERBOSE("name=%s, len=%dn", mask, mask_len);
  2097. WSET(param, 0, aSYSTEM | aHIDDEN | aDIR);
  2098. WSET(param, 2, 1); /* max count */
  2099. WSET(param, 4, 1); /* close after this call */
  2100. WSET(param, 6, 1); /* info_level */
  2101. DSET(param, 8, 0);
  2103. result = smb_trans2_request(server, TRANSACT2_FINDFIRST,
  2104.     0, NULL, 12 + mask_len, param,
  2105.     &resp_data_len, &resp_data,
  2106.     &resp_param_len, &resp_param);
  2107. if (result < 0)
  2108. {
  2109. if (smb_retry(server))
  2110. goto retry;
  2111. goto out;
  2112. }
  2113. if (server->rcls != 0)
  2114. { 
  2115. result = smb_errno(server);
  2116. #ifdef SMBFS_PARANOIA
  2117. if (result != -ENOENT)
  2118. PARANOIA("error for %s, rcls=%d, err=%dn",
  2119.  mask, server->rcls, server->err);
  2120. #endif
  2121. goto out;
  2122. }
  2123. /* Make sure we got enough data ... */
  2124. result = -EINVAL;
  2125. if (resp_data_len < 22 || WVAL(resp_param, 2) != 1)
  2126. {
  2127. PARANOIA("bad result for %s, len=%d, count=%dn",
  2128.  mask, resp_data_len, WVAL(resp_param, 2));
  2129. goto out;
  2130. }
  2132. /*
  2133.  * Decode the response into the fattr ...
  2134.  */
  2135. date = WVAL(resp_data, 0);
  2136. time = WVAL(resp_data, 2);
  2137. fattr->f_ctime = date_dos2unix(server, date, time);
  2139. date = WVAL(resp_data, 4);
  2140. time = WVAL(resp_data, 6);
  2141. fattr->f_atime = date_dos2unix(server, date, time);
  2143. date = WVAL(resp_data, 8);
  2144. time = WVAL(resp_data, 10);
  2145. fattr->f_mtime = date_dos2unix(server, date, time);
  2146. VERBOSE("name=%s, date=%x, time=%x, mtime=%ldn",
  2147. mask, date, time, fattr->f_mtime);
  2148. fattr->f_size = DVAL(resp_data, 12);
  2149. /* ULONG allocation size */
  2150. fattr->attr = WVAL(resp_data, 20);
  2151. result = 0;
  2153. out:
  2154. return result;
  2155. }
  2157. /*
  2158.  * Note: called with the server locked.
  2159.  */
  2160. static int
  2161. smb_proc_getattr_core(struct smb_sb_info *server, struct dentry *dir,
  2162.       struct smb_fattr *fattr)
  2163. {
  2164. int result;
  2165. char *p;
  2167.       retry:
  2168. p = smb_setup_header(server, SMBgetatr, 0, 0);
  2169. result = smb_simple_encode_path(server, &p, dir, NULL);
  2170. if (result < 0)
  2171. goto out;
  2172. smb_setup_bcc(server, p);
  2174. if ((result = smb_request_ok(server, SMBgetatr, 10, 0)) < 0)
  2175. {
  2176. if (smb_retry(server))
  2177. goto retry;
  2178. goto out;
  2179. }
  2180. fattr->attr    = WVAL(server->packet, smb_vwv0);
  2181. fattr->f_mtime = local2utc(server, DVAL(server->packet, smb_vwv1));
  2182. fattr->f_size  = DVAL(server->packet, smb_vwv3);
  2183. fattr->f_ctime = fattr->f_mtime; 
  2184. fattr->f_atime = fattr->f_mtime; 
  2185. #ifdef SMBFS_DEBUG_TIMESTAMP
  2186. printk("getattr_core: %s/%s, mtime=%ldn",
  2187.        DENTRY_PATH(dir), fattr->f_mtime);
  2188. #endif
  2189. result = 0;
  2191. out:
  2192. return result;
  2193. }
  2195. /*
  2196.  * Note: called with the server locked.
  2197.  *
  2198.  * Bugs Noted:
  2199.  * (1) Win 95 swaps the date and time fields in the standard info level.
  2200.  */
  2201. static int
  2202. smb_proc_getattr_trans2(struct smb_sb_info *server, struct dentry *dir,
  2203. struct smb_fattr *attr)
  2204. {
  2205. char *p, *param = server->temp_buf;
  2206. __u16 date, time;
  2207. int off_date = 0, off_time = 2;
  2208. unsigned char *resp_data = NULL;
  2209. unsigned char *resp_param = NULL;
  2210. int resp_data_len = 0;
  2211. int resp_param_len = 0;
  2212. int result;
  2214.       retry:
  2215. WSET(param, 0, 1); /* Info level SMB_INFO_STANDARD */
  2216. DSET(param, 2, 0);
  2217. result = smb_encode_path(server, param+6, SMB_MAXNAMELEN+1, dir, NULL);
  2218. if (result < 0)
  2219. goto out;
  2220. p = param + 6 + result;
  2222. result = smb_trans2_request(server, TRANSACT2_QPATHINFO,
  2223.     0, NULL, p - param, param,
  2224.     &resp_data_len, &resp_data,
  2225.     &resp_param_len, &resp_param);
  2226. if (result < 0)
  2227. {
  2228. if (smb_retry(server))
  2229. goto retry;
  2230. goto out;
  2231. }
  2232. if (server->rcls != 0)
  2233. {
  2234. VERBOSE("for %s: result=%d, rcls=%d, err=%dn",
  2235. &param[6], result, server->rcls, server->err);
  2236. result = smb_errno(server);
  2237. goto out;
  2238. }
  2239. result = -ENOENT;
  2240. if (resp_data_len < 22)
  2241. {
  2242. PARANOIA("not enough data for %s, len=%dn",
  2243.  &param[6], resp_data_len);
  2244. goto out;
  2245. }
  2247. /*
  2248.  * Kludge alert: Win 95 swaps the date and time field,
  2249.  * contrary to the CIFS docs and Win NT practice.
  2250.  */
  2251. if (server->mnt->flags & SMB_MOUNT_WIN95) {
  2252. off_date = 2;
  2253. off_time = 0;
  2254. }
  2255. date = WVAL(resp_data, off_date);
  2256. time = WVAL(resp_data, off_time);
  2257. attr->f_ctime = date_dos2unix(server, date, time);
  2259. date = WVAL(resp_data, 4 + off_date);
  2260. time = WVAL(resp_data, 4 + off_time);
  2261. attr->f_atime = date_dos2unix(server, date, time);
  2263. date = WVAL(resp_data, 8 + off_date);
  2264. time = WVAL(resp_data, 8 + off_time);
  2265. attr->f_mtime = date_dos2unix(server, date, time);
  2266. #ifdef SMBFS_DEBUG_TIMESTAMP
  2267. printk(KERN_DEBUG "getattr_trans2: %s/%s, date=%x, time=%x, mtime=%ldn",
  2268.        DENTRY_PATH(dir), date, time, attr->f_mtime);
  2269. #endif
  2270. attr->f_size = DVAL(resp_data, 12);
  2271. attr->attr = WVAL(resp_data, 20);
  2272. result = 0;
  2274. out:
  2275. return result;
  2276. }
  2278. /*
  2279.  * Note: called with the server locked
  2280.  */
  2281. static int
  2282. smb_proc_do_getattr(struct smb_sb_info *server, struct dentry *dir,
  2283.     struct smb_fattr *fattr)
  2284. {
  2285. int result;
  2286. struct inode *inode = dir->d_inode;
  2288. smb_init_dirent(server, fattr);
  2290. /*
  2291.  * Select whether to use core or trans2 getattr.
  2292.  * Win 95 appears to break with the trans2 getattr.
  2293.    */
  2294. if (server->opt.protocol < SMB_PROTOCOL_LANMAN2 ||
  2295.     (server->mnt->flags & (SMB_MOUNT_OLDATTR|SMB_MOUNT_WIN95)) ) {
  2296. result = smb_proc_getattr_core(server, dir, fattr);
  2297. } else {
  2298. if (server->mnt->flags & SMB_MOUNT_DIRATTR)
  2299. result = smb_proc_getattr_ff(server, dir, fattr);
  2300. else
  2301. result = smb_proc_getattr_trans2(server, dir, fattr);
  2302. }
  2304. /*
  2305.  * None of the getattr versions here can make win9x return the right
  2306.  * filesize if there are changes made to an open file.
  2307.  * A seek-to-end does return the right size, but we only need to do
  2308.  * that on files we have written.
  2309.  */
  2310. if (server->mnt->flags & SMB_MOUNT_WIN95 &&
  2311.     inode &&
  2312.     inode->u.smbfs_i.flags & SMB_F_LOCALWRITE &&
  2313.     smb_is_open(inode))
  2314. {
  2315. __u16 fileid = inode->u.smbfs_i.fileid;
  2316. fattr->f_size = smb_proc_seek(server, fileid, 2, 0);
  2317. }
  2319. smb_finish_dirent(server, fattr);
  2320. return result;
  2321. }
  2323. int
  2324. smb_proc_getattr(struct dentry *dir, struct smb_fattr *fattr)
  2325. {
  2326. struct smb_sb_info *server = server_from_dentry(dir);
  2327. int result;
  2329. smb_lock_server(server);
  2330. result = smb_proc_do_getattr(server, dir, fattr);
  2331. smb_unlock_server(server);
  2332. return result;
  2333. }
  2336. /*
  2337.  * Called with the server locked. Because of bugs in the
  2338.  * core protocol, we use this only to set attributes. See
  2339.  * smb_proc_settime() below for timestamp handling.
  2340.  *
  2341.  * Bugs Noted:
  2342.  * (1) If mtime is non-zero, both Win 3.1 and Win 95 fail
  2343.  * with an undocumented error (ERRDOS code 50). Setting
  2344.  * mtime to 0 allows the attributes to be set.
  2345.  * (2) The extra parameters following the name string aren't
  2346.  * in the CIFS docs, but seem to be necessary for operation.
  2347.  */
  2348. static int
  2349. smb_proc_setattr_core(struct smb_sb_info *server, struct dentry *dentry,
  2350.       __u16 attr)
  2351. {
  2352. char *p;
  2353. int result;
  2355.       retry:
  2356. p = smb_setup_header(server, SMBsetatr, 8, 0);
  2357. WSET(server->packet, smb_vwv0, attr);
  2358. DSET(server->packet, smb_vwv1, 0); /* mtime */
  2359. WSET(server->packet, smb_vwv3, 0); /* reserved values */
  2360. WSET(server->packet, smb_vwv4, 0);
  2361. WSET(server->packet, smb_vwv5, 0);
  2362. WSET(server->packet, smb_vwv6, 0);
  2363. WSET(server->packet, smb_vwv7, 0);
  2364. result = smb_simple_encode_path(server, &p, dentry, NULL);
  2365. if (result < 0)
  2366. goto out;
  2367. if (p + 2 > (char *)server->packet + server->packet_size) {
  2368. result = -ENAMETOOLONG;
  2369. goto out;
  2370. }
  2371. *p++ = 4;
  2372. *p++ = 0;
  2373. smb_setup_bcc(server, p);
  2375. result = smb_request_ok(server, SMBsetatr, 0, 0);
  2376. if (result < 0) {
  2377. if (smb_retry(server))
  2378. goto retry;
  2379. goto out;
  2380. }
  2381. result = 0;
  2382. out:
  2383. return result;
  2384. }
  2386. /*
  2387.  * Because of bugs in the trans2 setattr messages, we must set
  2388.  * attributes and timestamps separately. The core SMBsetatr
  2389.  * message seems to be the only reliable way to set attributes.
  2390.  */
  2391. int
  2392. smb_proc_setattr(struct dentry *dir, struct smb_fattr *fattr)
  2393. {
  2394. struct smb_sb_info *server = server_from_dentry(dir);
  2395. int result;
  2397. VERBOSE("setting %s/%s, open=%dn", 
  2398. DENTRY_PATH(dir), smb_is_open(dir->d_inode));
  2399. smb_lock_server(server);
  2400. result = smb_proc_setattr_core(server, dir, fattr->attr);
  2401. smb_unlock_server(server);
  2402. return result;
  2403. }
  2405. /*
  2406.  * Called with the server locked. Sets the timestamps for an
  2407.  * file open with write permissions.
  2408.  */
  2409. static int
  2410. smb_proc_setattr_ext(struct smb_sb_info *server,
  2411.       struct inode *inode, struct smb_fattr *fattr)
  2412. {
  2413. __u16 date, time;
  2414. int result;
  2416.       retry:
  2417. smb_setup_header(server, SMBsetattrE, 7, 0);
  2418. WSET(server->packet, smb_vwv0, inode->u.smbfs_i.fileid);
  2419. /* We don't change the creation time */
  2420. WSET(server->packet, smb_vwv1, 0);
  2421. WSET(server->packet, smb_vwv2, 0);
  2422. date_unix2dos(server, fattr->f_atime, &date, &time);
  2423. WSET(server->packet, smb_vwv3, date);
  2424. WSET(server->packet, smb_vwv4, time);
  2425. date_unix2dos(server, fattr->f_mtime, &date, &time);
  2426. WSET(server->packet, smb_vwv5, date);
  2427. WSET(server->packet, smb_vwv6, time);
  2428. #ifdef SMBFS_DEBUG_TIMESTAMP
  2429. printk(KERN_DEBUG "smb_proc_setattr_ext: date=%d, time=%d, mtime=%ldn",
  2430.        date, time, fattr->f_mtime);
  2431. #endif
  2433. result = smb_request_ok(server, SMBsetattrE, 0, 0);
  2434. if (result < 0) {
  2435. if (smb_retry(server))
  2436. goto retry;
  2437. goto out;
  2438. }
  2439. result = 0;
  2440. out:
  2441. return result;
  2442. }
  2444. /*
  2445.  * Note: called with the server locked.
  2446.  *
  2447.  * Bugs Noted:
  2448.  * (1) The TRANSACT2_SETPATHINFO message under Win NT 4.0 doesn't
  2449.  * set the file's attribute flags.
  2450.  */
  2451. static int
  2452. smb_proc_setattr_trans2(struct smb_sb_info *server,
  2453. struct dentry *dir, struct smb_fattr *fattr)
  2454. {
  2455. __u16 date, time;
  2456. char *p, *param = server->temp_buf;
  2457. unsigned char *resp_data = NULL;
  2458. unsigned char *resp_param = NULL;
  2459. int resp_data_len = 0;
  2460. int resp_param_len = 0;
  2461. int result;
  2462. char data[26];
  2464.       retry:
  2465. WSET(param, 0, 1); /* Info level SMB_INFO_STANDARD */
  2466. DSET(param, 2, 0);
  2467. result = smb_encode_path(server, param+6, SMB_MAXNAMELEN+1, dir, NULL);
  2468. if (result < 0)
  2469. goto out;
  2470. p = param + 6 + result;
  2472. WSET(data, 0, 0); /* creation time */
  2473. WSET(data, 2, 0);
  2474. date_unix2dos(server, fattr->f_atime, &date, &time);
  2475. WSET(data, 4, date);
  2476. WSET(data, 6, time);
  2477. date_unix2dos(server, fattr->f_mtime, &date, &time);
  2478. WSET(data, 8, date);
  2479. WSET(data, 10, time);
  2480. #ifdef SMBFS_DEBUG_TIMESTAMP
  2481. printk(KERN_DEBUG "setattr_trans2: %s/%s, date=%x, time=%x, mtime=%ldn", 
  2482.        DENTRY_PATH(dir), date, time, fattr->f_mtime);
  2483. #endif
  2484. DSET(data, 12, 0); /* size */
  2485. DSET(data, 16, 0); /* blksize */
  2486. WSET(data, 20, 0); /* attr */
  2487. DSET(data, 22, 0); /* ULONG EA size */
  2489. result = smb_trans2_request(server, TRANSACT2_SETPATHINFO,
  2490.     26, data, p - param, param,
  2491.     &resp_data_len, &resp_data,
  2492.     &resp_param_len, &resp_param);
  2493. if (result < 0)
  2494. {
  2495. if (smb_retry(server))
  2496. goto retry;
  2497. goto out;
  2498. }
  2499. result = 0;
  2500. if (server->rcls != 0)
  2501. result = smb_errno(server);
  2503. out:
  2504. return result;
  2505. }
  2507. /*
  2508.  * Set the modify and access timestamps for a file.
  2509.  *
  2510.  * Incredibly enough, in all of SMB there is no message to allow
  2511.  * setting both attributes and timestamps at once. 
  2512.  *
  2513.  * Bugs Noted:
  2514.  * (1) Win 95 doesn't support the TRANSACT2_SETFILEINFO message 
  2515.  * with info level 1 (INFO_STANDARD).
  2516.  * (2) Win 95 seems not to support setting directory timestamps.
  2517.  * (3) Under the core protocol apparently the only way to set the
  2518.  * timestamp is to open and close the file.
  2519.  */
  2520. int
  2521. smb_proc_settime(struct dentry *dentry, struct smb_fattr *fattr)
  2522. {
  2523. struct smb_sb_info *server = server_from_dentry(dentry);
  2524. struct inode *inode = dentry->d_inode;
  2525. int result;
  2527. VERBOSE("setting %s/%s, open=%dn",
  2528. DENTRY_PATH(dentry), smb_is_open(inode));
  2530. smb_lock_server(server);
  2531. /* setting the time on a Win95 server fails (tridge) */
  2532. if (server->opt.protocol >= SMB_PROTOCOL_LANMAN2 && 
  2533.     !(server->mnt->flags & SMB_MOUNT_WIN95)) {
  2534. if (smb_is_open(inode) &&
  2535.     inode->u.smbfs_i.access != SMB_O_RDONLY)
  2536. result = smb_proc_setattr_ext(server, inode, fattr);
  2537. else
  2538. result = smb_proc_setattr_trans2(server, dentry, fattr);
  2539. } else {
  2540. /*
  2541.  * Fail silently on directories ... timestamp can't be set?
  2542.  */
  2543. result = 0;
  2544. if (S_ISREG(inode->i_mode)) {
  2545. /*
  2546.  * Set the mtime by opening and closing the file.
  2547.  * Note that the file is opened read-only, but this
  2548.  * still allows us to set the date (tridge)
  2549.  */
  2550. result = -EACCES;
  2551. if (!smb_is_open(inode))
  2552. smb_proc_open(server, dentry, SMB_O_RDONLY);
  2553. if (smb_is_open(inode)) {
  2554. inode->i_mtime = fattr->f_mtime;
  2555. result = smb_proc_close_inode(server, inode);
  2556. }
  2557. }
  2558. }
  2560. smb_unlock_server(server);
  2561. return result;
  2562. }
  2564. int
  2565. smb_proc_dskattr(struct super_block *sb, struct statfs *attr)
  2566. {
  2567. struct smb_sb_info *server = &(sb->u.smbfs_sb);
  2568. int result;
  2569. char *p;
  2570. long unit;
  2572. smb_lock_server(server);
  2574.       retry:
  2575. smb_setup_header(server, SMBdskattr, 0, 0);
  2577. if ((result = smb_request_ok(server, SMBdskattr, 5, 0)) < 0) {
  2578. if (smb_retry(server))
  2579. goto retry;
  2580. goto out;
  2581. }
  2582. p = SMB_VWV(server->packet);
  2583. unit = (WVAL(p, 2) * WVAL(p, 4)) >> SMB_ST_BLKSHIFT;
  2584. attr->f_blocks = WVAL(p, 0) * unit;
  2585. attr->f_bsize  = SMB_ST_BLKSIZE;
  2586. attr->f_bavail = attr->f_bfree = WVAL(p, 6) * unit;
  2587. result = 0;
  2589. out:
  2590. smb_unlock_server(server);
  2591. return result;
  2592. }