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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
proc.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：62k
源码类别：

Linux/Unix编程

开发平台：

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