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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 传真(Fax)编程 > 查看源码
FileSystem.c++
资源名称：hylafax-5.3.0.tar.gz　[点击查看]
上传用户：weiyuanprp
上传日期：2020-05-20
资源大小：1169k
文件大小：23k
源码类别：

传真(Fax)编程

开发平台：

C/C++

FileSystem.c++：源码内容
  1. /* $Id: FileSystem.c++,v 1.11 2009/06/22 06:26:07 faxguy Exp $ */
  2. /*
  3.  * Copyright (c) 1995-1996 Sam Leffler
  4.  * Copyright (c) 1995-1996 Silicon Graphics, Inc.
  5.  * HylaFAX is a trademark of Silicon Graphics
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and 
  8.  * its documentation for any purpose is hereby granted without fee, provided
  9.  * that (i) the above copyright notices and this permission notice appear in
  10.  * all copies of the software and related documentation, and (ii) the names of
  11.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12.  * publicity relating to the software without the specific, prior written
  13.  * permission of Sam Leffler and Silicon Graphics.
  14.  * 
  15.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  16.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  17.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  18.  * 
  19.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  23.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  24.  * OF THIS SOFTWARE.
  25.  */
  27. /*
  28.  * File commands other than transfer.
  29.  */
  30. #include "HylaFAXServer.h"
  31. #include "Sys.h"
  32. #include "tiffio.h"
  34. #include <limits.h>
  35. #include <ctype.h>
  37. /*
  38.  * Delete a file (submitted document or received facsimile).
  39.  */
  40. void
  41. HylaFAXServer::deleCmd(const char* pathname)
  42. {
  43.     struct stat sb;
  44.     SpoolDir* dir = fileAccess(pathname, W_OK, sb);
  45.     if (dir) {
  46. if (!IS(PRIVILEGED)) {
  47.     if (!S_ISREG(sb.st_mode)) {
  48. reply(550, "%s: not a plain file.", pathname);
  49. return;
  50.     }
  51.     if (!dir->deleAble) {
  52. perror_reply(550, pathname, EPERM);
  53. return;
  54.     }
  55. }
  56. /*
  57.  * XXX must decide what to do with jobs/documents/etc...
  58.  * XXX e.g. should job be treated like jdele; should we
  59.  * XXX cross-check document use for consistency....
  60.  */
  61. if (Sys::unlink(pathname) < 0)
  62.     perror_reply(550, pathname, errno);
  63. else {
  64.     const char* cp = strrchr(pathname, '/');
  65.     logNotice("%s of %s [%s] deleted %s%s"
  66. , (const char*) the_user
  67. , (const char*) remotehost
  68. , (const char*) remoteaddr
  69. , dir->pathname, cp ? cp+1 : pathname
  70.     );
  71.     ack(250, cmdToken(T_DELE));
  72.     FileCache::flush(pathname);
  73. }
  74.     }
  75. }
  77. /*
  78.  * Set ownership of a file.
  79.  */
  80. void
  81. HylaFAXServer::chownCmd(const char* pathname, const char* user)
  82. {
  83.     struct stat sb;
  84.     SpoolDir* dir = fileAccess(pathname, W_OK, sb);
  85.     if (dir) {
  86. u_int id;
  87. if (isdigit(user[0]))
  88.     id = (u_int) atoi(user);
  89. else if (!userID(user, id))
  90.     return;
  91. if (!FileCache::chown(pathname, sb.st_uid, (gid_t) id))
  92.     perror_reply(550, pathname, errno);
  93. else
  94.     ack(250, cmdToken(T_CHOWN));
  95.     }
  96. }
  98. /*
  99.  * Set protection of a file.
  100.  */
  101. void
  102. HylaFAXServer::chmodCmd(const char* pathname, u_int mode)
  103. {
  104.     struct stat sb;
  105.     SpoolDir* dir = fileAccess(pathname, W_OK, sb);
  106.     if (dir) {
  107. mode = 0600 | (mode&066);
  108. if (!FileCache::chmod(pathname, mode))
  109.     perror_reply(550, pathname, errno);
  110. else
  111.     ack(250, cmdToken(T_CHMOD));
  112.     }
  113. }
  115. /*
  116.  * Return the last modification time for a file.
  117.  */
  118. void
  119. HylaFAXServer::mdtmCmd(const char* pathname)
  120. {
  121.     struct stat sb;
  122.     SpoolDir* dir = fileAccess(pathname, X_OK, sb);
  123.     if (dir) {
  124. struct tm* t = cvtTime(sb.st_mtime);
  125. reply(213, "%d%02d%02d%02d%02d%02d"
  126.     , t->tm_year+1900
  127.     , t->tm_mon+1
  128.     , t->tm_mday
  129.     , t->tm_hour
  130.     , t->tm_min
  131.     , t->tm_sec
  132. );
  133.     }
  134. }
  136. /*
  137.  * NB: this array is ordered by expected frequency of access.
  138.  */
  139. SpoolDir HylaFAXServer::dirs[] = {
  140. { "/status/", false, false, false, 0,
  141.   &HylaFAXServer::isVisibletrue,
  142.   &HylaFAXServer::listStatus, &HylaFAXServer::listStatusFile,
  143.   &HylaFAXServer::nlstStatus, &HylaFAXServer::nlstUnixFile, },
  144. { "/sendq/", false, false, false, 0,
  145.   &HylaFAXServer::isVisibleSendQFile,
  146.   &HylaFAXServer::listSendQ, &HylaFAXServer::listSendQFile,
  147.   &HylaFAXServer::nlstSendQ, &HylaFAXServer::nlstSendQFile, },
  148. { "/doneq/", false, false, false, 0,
  149.   &HylaFAXServer::isVisibleSendQFile,
  150.   &HylaFAXServer::listSendQ, &HylaFAXServer::listSendQFile,
  151.   &HylaFAXServer::nlstSendQ, &HylaFAXServer::nlstSendQFile, },
  152. { "/docq/", false,  true,  true, 0,
  153.   &HylaFAXServer::isVisibleDocQFile,
  154.   &HylaFAXServer::listDirectory, &HylaFAXServer::listUnixFile,
  155.   &HylaFAXServer::nlstDirectory, &HylaFAXServer::nlstUnixFile, },
  156. { "/tmp/", false,  true,  true, 0,
  157.   &HylaFAXServer::isVisibletrue,
  158.   &HylaFAXServer::listDirectory, &HylaFAXServer::listUnixFile,
  159.   &HylaFAXServer::nlstDirectory, &HylaFAXServer::nlstUnixFile, },
  160. { "/log/", false, false, false, 0,
  161.   &HylaFAXServer::isVisibletrue,
  162.   &HylaFAXServer::listDirectory, &HylaFAXServer::listUnixFile,
  163.   &HylaFAXServer::nlstDirectory, &HylaFAXServer::nlstUnixFile, },
  164. { "/recvq/", false, false,  true, 0,
  165.   &HylaFAXServer::isVisibleRecvQFile,
  166.   &HylaFAXServer::listRecvQ, &HylaFAXServer::listRecvQFile,
  167.   &HylaFAXServer::nlstDirectory, &HylaFAXServer::nlstUnixFile, },
  168. { "/archive/", false, false, false, 0,
  169.   &HylaFAXServer::isVisibletrue,
  170.   &HylaFAXServer::listDirectory, &HylaFAXServer::listUnixFile,
  171.   &HylaFAXServer::nlstDirectory, &HylaFAXServer::nlstUnixFile, },
  172. { "/pollq/", false,  true,  true, 0,
  173.   &HylaFAXServer::isVisibleRecvQFile,
  174.   &HylaFAXServer::listRecvQ, &HylaFAXServer::listRecvQFile,
  175.   &HylaFAXServer::nlstDirectory, &HylaFAXServer::nlstUnixFile, },
  176. { "/", false, false, false, 0,
  177.   &HylaFAXServer::isVisibleRootFile,
  178.   &HylaFAXServer::listDirectory, &HylaFAXServer::listUnixFile,
  179.   &HylaFAXServer::nlstDirectory, &HylaFAXServer::nlstUnixFile, },
  180. { "/etc/",  true, false, false, 0,
  181.   &HylaFAXServer::isVisibletrue,
  182.   &HylaFAXServer::listDirectory, &HylaFAXServer::listUnixFile,
  183.   &HylaFAXServer::nlstDirectory, &HylaFAXServer::nlstUnixFile, },
  184. { "/info/", false, false, false, 0,
  185.   &HylaFAXServer::isVisibletrue,
  186.   &HylaFAXServer::listDirectory, &HylaFAXServer::listUnixFile,
  187.   &HylaFAXServer::nlstDirectory, &HylaFAXServer::nlstUnixFile, },
  188. { "/bin/",  true, false, false, 0,
  189.   &HylaFAXServer::isVisibletrue,
  190.   &HylaFAXServer::listDirectory, &HylaFAXServer::listUnixFile,
  191.   &HylaFAXServer::nlstDirectory, &HylaFAXServer::nlstUnixFile, },
  192. { "/config/", false, false, false, 0,
  193.   &HylaFAXServer::isVisibletrue,
  194.   &HylaFAXServer::listDirectory, &HylaFAXServer::listUnixFile,
  195.   &HylaFAXServer::nlstDirectory, &HylaFAXServer::nlstUnixFile, },
  196. { "/client/",  true, false, false, 0,
  197.   &HylaFAXServer::isVisibletrue,
  198.   &HylaFAXServer::listDirectory, &HylaFAXServer::listUnixFile,
  199.   &HylaFAXServer::nlstDirectory, &HylaFAXServer::nlstUnixFile, },
  200. };
  201. #define N(a) (sizeof (a) / sizeof (a[0]))
  203. /*
  204.  * Initialize the directory handling.
  205.  */
  206. void
  207. HylaFAXServer::dirSetup(void)
  208. {
  209.     for (u_int i = 0, n = N(dirs); i < n; i++) {
  210. struct stat sb;
  211. if (!FileCache::lookup(dirs[i].pathname, sb) || !S_ISDIR(sb.st_mode)) {
  212.     logError("%s: Not a directory.", dirs[i].pathname);
  213.     continue;
  214. }
  215. dirs[i].ino = sb.st_ino;
  216. if (streq(dirs[i].pathname, "/"))
  217.     cwd = &dirs[i];
  218.     }
  219. }
  221. /*
  222.  * Return a directory handle given a pathname.
  223.  */
  224. SpoolDir*
  225. HylaFAXServer::dirLookup(const char* path)
  226. {
  227.     struct stat sb;
  228.     return (!FileCache::lookup(path, sb) || !S_ISDIR(sb.st_mode) ?
  229. (SpoolDir*) NULL : dirLookup(sb.st_ino));
  230. }
  232. /*
  233.  * Return a directory handle given an inode number.
  234.  */
  235. SpoolDir*
  236. HylaFAXServer::dirLookup(ino_t ino)
  237. {
  238.     for (u_int i = 0, n = N(dirs); i < n; i++)
  239. if (dirs[i].ino == ino)
  240.     return (&dirs[i]);
  241.     return (NULL);
  242. }
  244. /*
  245.  * Check file protection mode; we use the
  246.  * normal ``other'' bits for public access
  247.  * and the group bits for the ``fax uid''.
  248.  */
  249. bool
  250. HylaFAXServer::checkFileRights(int op, const struct stat& sb)
  251. {
  252.     if (IS(PRIVILEGED))
  253. return (true);
  255.     if (sb.st_mode & op) // public access
  256. return (true);
  258.     if ((sb.st_gid==uid) && ((sb.st_mode>>3)&op)) // owner access
  259. return (true);
  260.     return false;
  262. }
  264. /*
  265.  * Check if the client is permitted to do the
  266.  * request operation on the specified file.
  267.  * Operations are: X_OK (list/stat), R_OK (look
  268.  * at the contents), W_OK (write/delete contents).
  269.  *
  270.  * If the operation is permitted the stat result
  271.  * for the target file is returned to the caller
  272.  * for use in futher checks (e.g. type of file).
  273.  */
  274. SpoolDir*
  275. HylaFAXServer::fileAccess(const char* path, int op, struct stat& sb)
  276. {
  277.     if (!FileCache::lookup(path, sb)) { // file not found
  278. if (op != W_OK || errno != ENOENT) {
  279.     perror_reply(550, path, errno);
  280.     return (NULL);
  281. }
  282. /*
  283.  * The file does not exist, fake up the
  284.  * information that would result from a
  285.  * successful file creation--for use below.
  286.  */
  287. sb.st_mode = S_IFREG|S_IRGRP|S_IWGRP;
  288. sb.st_gid = (gid_t) uid;
  289. sb.st_ino = 0; // NB: to be created
  290.     }
  291.     /*
  292.      * Validate containing directory and target file.
  293.      * The directory must exist and the client must
  294.      * have permission to access it.  The target file
  295.      * must not be a directory if the client is about
  296.      * to do a read/write-style operation or the target
  297.      * file must be owned by the client (other checks
  298.      * are left to the caller).
  299.      */
  300.     struct stat db;
  301.     const char* cp = strrchr(path, '/');
  302.     if (cp) {
  303. cp++; // include "/"
  304. if (!FileCache::lookup(fxStr(path, cp-path), db)) {
  305.     perror_reply(550, path, ENOENT);
  306.     return (NULL);
  307. }
  308.     } else {
  309. if (!FileCache::lookup(cwd->pathname, db)) { // implicit ref to "."
  310.     perror_reply(550, path, ENOENT);
  311.     return (NULL);
  312. }
  313. cp = path;
  314.     }
  315.     SpoolDir* dir = dirLookup(db.st_ino);
  316.     if (!dir) { // no containing dir
  317. perror_reply(550, path, ENOENT);
  318. return (NULL);
  319.     } else if (!IS(PRIVILEGED)) { // unprivileged client
  320. if (dir->adminOnly) { // requires admin priv's
  321.     perror_reply(550, path, EPERM);
  322.     return (NULL);
  323. } else if (!fileVisible(*dir, cp, sb)) { // not visible w/o admin
  324.     perror_reply(550, path, EPERM);
  325.     return (NULL);
  326. } else if (op != X_OK) { // client wants to r/w
  327.     if (S_ISDIR(sb.st_mode)) { // cannot r/w directory
  328. reply(550, "%s: not a plain file.", path);
  329. return (NULL);
  330.     } else if (sb.st_ino == 0 && !dir->storAble) {
  331. perror_reply(550, path, EPERM); // cannot stor in dir.
  332. return (NULL);
  333.     }
  334.     if (!checkFileRights(op, sb)) {
  335. perror_reply(550, path, EPERM);
  336. return (NULL);
  337.     }
  338. }
  339.     } else { // privileged client
  340. if (op != X_OK && S_ISDIR(sb.st_mode)) { // cannot r/w directory
  341.     reply(550, "%s: not a plain file.", path);
  342.     return (NULL);
  343. }
  344.     }
  345.     return (dir);
  346. }
  348. /*
  349.  * Like fileAccess, but when the target is a directory.
  350.  * The implicit operation is X_OK and the directory handle
  351.  * returned is for the target, not the containing directory.
  352.  */
  353. SpoolDir*
  354. HylaFAXServer::dirAccess(const char* path)
  355. {
  356.     struct stat sb;
  357.     if (!FileCache::lookup(path, sb)) { // file not found
  358. perror_reply(550, path, errno);
  359. return (NULL);
  360.     }
  361.     if (!S_ISDIR(sb.st_mode)) {
  362. perror_reply(550, path, ENOTDIR);
  363. return (NULL);
  364.     }
  365.     // NB: this assumes all directories are top-level
  366.     SpoolDir* dir = dirLookup(sb.st_ino);
  367.     if (!dir) { // XXX should not happen
  368. perror_reply(550, path, ENOENT);
  369. return (NULL);
  370.     } else if (dir->adminOnly && !IS(PRIVILEGED)) { // requires admin priv's
  371. perror_reply(550, path, EPERM);
  372. return (NULL);
  373.     }
  374.     return (dir);
  375. }
  377. /*
  378.  * Force the specified file to have the GID setup as
  379.  * the effective GID of the process.  On System-V-style
  380.  * filesystems this happens automatically and there is
  381.  * nothing to do.  On BSD-style filesystems however the
  382.  * file's GID is set from the GID of the containing
  383.  * directory so we must explicitly set the value.  Note
  384.  * that we must auto-detect the appropriate semantics
  385.  * because some systems support both styles and the
  386.  * specific scheme is selectable on a per-filesystem
  387.  * basis (e.g. IRIX).
  388.  */
  389. void
  390. HylaFAXServer::setFileOwner(const char* file)
  391. {
  392.     if (IS(CHECKGID)) { // auto-detect how GID handled
  393.         struct stat sb;
  394.         if (!FileCache::lookup(file, sb)) {
  395.             fatal("setFileOwner called for non-existent file (check)");
  396.         }
  397.         if (sb.st_gid != (gid_t) uid) {
  398.             state |= S_SETGID; // not set, must force it
  399.         } else {
  400.             state &= ~S_SETGID; // set by OS, no work to do
  401.         }
  402.         if (TRACE(SERVER)) {
  403.             logDebug("Filesystem has %s-style file creation semantics.",
  404.                 IS(SETGID) ? "BSD" : "SysV");
  405.         }
  406.         state &= ~S_CHECKGID;
  407.     }
  408.     if (IS(SETGID)) {
  409.         struct stat sb;
  410.         if (!FileCache::lookup(file, sb)) {
  411.             fatal("setFileOwner called for non-existent file (set)");
  412.         }
  413.         if (!FileCache::chown(file, sb.st_uid, (gid_t) uid)) {
  414.             logError("%s: chown: %s", file, strerror(errno));
  415.         }
  416.     }
  417. }
  419. /*
  420.  * Is the specified file visible to the client.
  421.  */
  422. bool
  423. HylaFAXServer::fileVisible(const SpoolDir& dir, const char* filename, const struct stat& sb)
  424. {
  425.     return (IS(PRIVILEGED) || (this->*dir.isVisibleFile)(filename, sb));
  426. }
  427. bool
  428. HylaFAXServer::isVisibletrue(const char*, const struct stat&)
  429.     { return (true); }
  430. bool
  431. HylaFAXServer::isVisibleDocQFile(const char* filename, const struct stat&)
  432.     { return (strncmp(filename, "doc", 3) == 0 || strncmp(filename, "cover", 5) == 0 || strncmp(filename, FAX_SEQF, 4) == 0); }
  433. bool
  434. HylaFAXServer::isVisibleRootFile(const char*, const struct stat& sb)
  435.     { return (S_ISREG(sb.st_mode) || S_ISDIR(sb.st_mode)); }
  437. /*
  438.  * Change the working (pseudo) directory.
  439.  */
  440. void
  441. HylaFAXServer::cwdCmd(const char* path)
  442. {
  443.     SpoolDir* dir = dirAccess(path);
  444.     if (dir) {
  445. if (Sys::chdir(path) >= 0) {
  446.     ack(250, cmdToken(T_CWD));
  447.     cwd = dir;
  448. } else
  449.     perror_reply(550, path, errno);
  450.     }
  451. }
  453. /*
  454.  * Return the path of the current working (pseudo) directory.
  455.  */
  456. void
  457. HylaFAXServer::pwdCmd(void)
  458. {
  459.     u_int len = strlen(cwd->pathname)-1; // strip trailing "/"
  460.     reply(257, ""%.*s" is the current directory.",
  461. len ? len : len+1, cwd->pathname);
  462. }
  464. /*
  465.  * LIST a directory.
  466.  */
  467. void
  468. HylaFAXServer::listCmd(const char* pathname)
  469. {
  470.     SpoolDir* sd = dirAccess(pathname);
  471.     if (sd) {
  472. DIR* dir = opendir(pathname);
  473. if (dir != NULL) {
  474.     int code;
  475.     FILE* dout = openDataConn("w", code);
  476.     if (dout != NULL) {
  477. reply(code, "%s for "%s".", dataConnMsg(code), pathname);
  478. if (setjmp(urgcatch) == 0) {
  479.     state |= S_TRANSFER;
  480.     (this->*sd->listDirectory)(dout, *sd, dir);
  481.     fflush(dout);
  482.     reply(226, "Transfer complete.");
  483. }
  484. state &= ~S_TRANSFER;
  485. closeDataConn(dout);
  486.     }
  487.     closedir(dir);
  488. } else if (errno != 0)
  489.     perror_reply(550, pathname, errno);
  490. else
  491.     reply(550, "%s: Cannot open directory.", pathname);
  492.     }
  493. }
  495. void
  496. HylaFAXServer::listDirectory(FILE* fd, const SpoolDir& sd, DIR* dir)
  497. {
  498.     /*
  499.      * Use an absolute pathname when doing file
  500.      * lookups to improve cache locality.
  501.      */
  502.     fxStr path(sd.pathname);
  503.     fxStrArray files;
  504.     struct dirent* dp;
  505.     while ((dp = readdir(dir))) {
  506. files.append(dp->d_name);
  507.     }
  508.     files.qsort();
  509.     for (u_int i = 0, n = files.length(); i < n; i++) {
  510. if (files[i][0] == '.' &&
  511.    (((const char*)files[i])[1] == '' || strcmp(files[i], "..") == 0))
  512.     continue;
  513. struct stat sb;
  514. if (!FileCache::update(path | files[i], sb))
  515.     continue;
  516. if ((this->*sd.isVisibleFile)(files[i], sb)) {
  517.     (this->*sd.listFile)(fd, sd, files[i], sb);
  518.     fputs("rn", fd);
  519. }
  520.     }
  521. }
  523. void
  524. HylaFAXServer::listUnixFile(FILE* fd, const SpoolDir&,
  525.     const char* filename, const struct stat& sb)
  526. {
  527.     Fprintf(fd, fileFormat, filename, sb);
  528. }
  530. static const char fformat[] = {
  531.     's', // a (last access time)
  532.     'b', // b
  533.     's', // c (create time)
  534.     'o', // d (device)
  535.     'e', // e
  536.     's', // f (filename)
  537.     'u', // g (GID of file)
  538.     'h', // h
  539.     'u', // i (inode number)
  540.     'j', // j
  541.     'k', // k
  542.     'u', // l (link count)
  543.     's', // m (last modification time)
  544.     'n', // n
  545.     's', // o (owner based on file GID)
  546.     's', // p (fax-style protection flags, no group bits)
  547.     's', // q (UNIX-style protection flags)
  548.     'o', // r (root device)
  549.     'u', // s (file size in bytes)
  550.     't', // t
  551.     'u', // u (UID of file)
  552.     'v', // v
  553.     'w', // w
  554.     'x', // x
  555.     'y', // y
  556.     'z' // z
  557. };
  559. /*
  560.  * Print a formatted string with fields filled in from
  561.  * a file's stat buffer.  This functionality is
  562.  * used to permit clients to get modem status listings
  563.  * in preferred formats.
  564.  */
  565. void
  566. HylaFAXServer::Fprintf(FILE* fd, const char* fmt,
  567.     const char* filename, const struct stat& sb)
  568. {
  569.     for (const char* cp = fmt; *cp; cp++) {
  570. if (*cp == '%') {
  571. #define MAXSPEC 20
  572.     char fspec[MAXSPEC];
  573.     char* fp = fspec;
  574.     *fp++ = '%';
  575.     char c = *++cp;
  576.     if (c == '-')
  577. *fp++ = c, c = *++cp;
  578.     if (isdigit(c)) {
  579. do {
  580.     *fp++ = c;
  581. } while (isdigit(c = *++cp) && fp < &fspec[MAXSPEC-3]);
  582.     }
  583.     if (c == '.') {
  584. do {
  585.     *fp++ = c;
  586. } while (isdigit(c = *++cp) && fp < &fspec[MAXSPEC-2]);
  587.     }
  588.     if (!islower(c)) {
  589. if (c == '%') // %% -> %
  590.     putc(c, fd);
  591. else
  592.     fprintf(fd, "%.*s%c", fp-fspec, fspec, c);
  593. continue;
  594.     }
  595.     fp[0] = fformat[c-'a']; // printf format string
  596.     fp[1] = '';
  597.     switch (c) {
  598.     case 'a':
  599. fprintf(fd, fspec, asctime(cvtTime(sb.st_atime))+4);
  600. break;
  601.     case 'c':
  602. fprintf(fd, fspec, asctime(cvtTime(sb.st_ctime))+4);
  603. break;
  604.     case 'd':
  605. fprintf(fd, fspec, (u_int) sb.st_dev);
  606. break;
  607.     case 'f':
  608. fprintf(fd, fspec, filename);
  609. break;
  610.     case 'g':
  611. fprintf(fd, fspec, (u_int) sb.st_gid);
  612. break;
  613.     case 'i':
  614. fprintf(fd, fspec, (u_int) sb.st_ino); // XXX
  615. break;
  616.     case 'l':
  617. fprintf(fd, fspec, (u_int) sb.st_nlink);
  618. break;
  619.     case 'm':
  620. fprintf(fd, fspec, asctime(cvtTime(sb.st_mtime))+4);
  621. break;
  622.     case 'o':
  623. fprintf(fd, fspec, userName((u_int) sb.st_gid));
  624. break;
  625.     case 'p':
  626.     case 'q':
  627. { char prot[10]; // XXX HP C++
  628.   makeProt(sb, c == 'q', prot);
  629.   fprintf(fd, fspec, prot);
  630. }
  631. break;
  632.     case 'r':
  633. fprintf(fd, fspec, (u_int) sb.st_rdev);
  634. break;
  635.     case 's':
  636. fprintf(fd, fspec, (u_int) sb.st_size); // XXX
  637. break;
  638.     case 'u':
  639. fprintf(fd, fspec, (u_int) sb.st_uid);
  640. break;
  641.     }
  642. } else
  643.     putc(*cp, fd);
  644.     }
  645. }
  647. void
  648. HylaFAXServer::makeProt(const struct stat& sb, bool withGrp, char prot[10])
  649. {
  650.     char* pp = prot;
  651.     *pp++ = S_ISREG(sb.st_mode)  ? '-' :
  652.     S_ISDIR(sb.st_mode)  ? 'd' :
  653.     S_ISFIFO(sb.st_mode) ? 'p' :
  654. #ifdef S_ISSOCK
  655.     S_ISSOCK(sb.st_mode) ? 's' :
  656. #endif
  657.    '?' ;
  658.     *pp++ = (sb.st_mode&S_IRUSR) ? 'r' : '-';
  659.     *pp++ = (sb.st_mode&S_IWUSR) ? 'w' : '-';
  660.     *pp++ = (sb.st_mode&S_IXUSR) ? 'x' : '-';
  661.     if (withGrp) {
  662. *pp++ = (sb.st_mode&S_IRGRP) ? 'r' : '-';
  663. *pp++ = (sb.st_mode&S_IWGRP) ? 'w' : '-';
  664. *pp++ = (sb.st_mode&S_IXGRP) ? 'x' : '-';
  665.     }
  666.     *pp++ = (sb.st_mode&S_IROTH) ? 'r' : '-';
  667.     *pp++ = (sb.st_mode&S_IWOTH) ? 'w' : '-';
  668.     *pp++ = (sb.st_mode&S_IXOTH) ? 'x' : '-';
  669.     *pp++ = '';
  670. }
  672. void
  673. HylaFAXServer::statFileCmd(const char* pathname)
  674. {
  675.     struct stat sb;
  676.     SpoolDir* dir = fileAccess(pathname, X_OK, sb);
  677.     if (dir) {
  678. (void) FileCache::update(pathname, sb); // insure up to date info
  679. lreply(211, "Status of %s:", pathname);
  680. const char* cp = strrchr(pathname, '/');
  681. (this->*dir->listFile)(stdout, *dir, cp ? cp+1 : pathname, sb);
  682. fputs("rn", stdout);
  683. reply(211, "End of Status");
  684.     }
  685. }
  687. /*
  688.  * NLST a directory.
  689.  */
  690. void
  691. HylaFAXServer::nlstCmd(const char* pathname)
  692. {
  693.     SpoolDir* sd = dirAccess(pathname);
  694.     if (sd) {
  695. DIR* dir = opendir(pathname);
  696. if (dir != NULL) {
  697.     int code;
  698.     FILE* dout = openDataConn("w", code);
  699.     if (dout != NULL) {
  700. reply(code, "%s for "%s".", dataConnMsg(code), pathname);
  701. if (setjmp(urgcatch) == 0) {
  702.     state |= S_TRANSFER;
  703.     (this->*sd->nlstDirectory)(dout, *sd, dir);
  704.     fflush(dout);
  705.     reply(226, "Transfer complete.");
  706. }
  707. state &= ~S_TRANSFER;
  708. closeDataConn(dout);
  709.     }
  710.     closedir(dir);
  711. } else if (errno != 0)
  712.     perror_reply(550, pathname, errno);
  713. else
  714.     reply(550, "%s: Cannot open directory.", pathname);
  715.     }
  716. }
  718. void
  719. HylaFAXServer::nlstDirectory(FILE* fd, const SpoolDir& sd, DIR* dir)
  720. {
  721.     /*
  722.      * Use an absolute pathname when doing file
  723.      * lookups to improve cache locality.
  724.      */
  725.     fxStr path(sd.pathname);
  726.     fxStrArray files;
  727.     struct dirent* dp;
  728.     while ((dp = readdir(dir))) {
  729. files.append(dp->d_name);
  730.     }
  731.     files.qsort();
  732.     for (u_int i = 0, n = files.length(); i < n; i++) {
  733. if (files[i][0] == '.' &&
  734.    (((const char*)files[i])[1] == '' || strcmp(files[i], "..") == 0))
  735.     continue;
  736. struct stat sb;
  737. if (!FileCache::update(path | files[i], sb))
  738.     continue;
  739. if ((this->*sd.isVisibleFile)(files[i], sb)) {
  740.     (this->*sd.nlstFile)(fd, sd, files[i], sb);
  741.     fputs("rn", fd);
  742. }
  743.     }
  744. }
  746. void
  747. HylaFAXServer::nlstUnixFile(FILE* fd, const SpoolDir&,
  748.     const char* filename, const struct stat&)
  749. {
  750.     fprintf(fd, "%s", filename);
  751. }
  753. static bool
  754. isTIFF(const TIFFHeader& h)
  755. {
  756.     if (h.tiff_magic != TIFF_BIGENDIAN && h.tiff_magic != TIFF_LITTLEENDIAN)
  757. return (false);
  758.     union {
  759. int32 i;
  760. char c[4];
  761.     } u;
  762.     u.i = 1;
  763.     uint16 version = h.tiff_version;
  764.     // byte swap version stamp if opposite byte order
  765.     if ((u.c[0] == 0) ^ (h.tiff_magic == TIFF_BIGENDIAN))
  766. TIFFSwabShort(&version);
  767.     return (version == TIFF_VERSION);
  768. }
  770. /*
  771.  * This is used to identify a submitted document type when the client 
  772.  * specified the default (Postscript) or did not make a specification.
  773.  *
  774.  * There is no sure-fire way to type all PCL files.  So this is a best-
  775.  * guess approach on PCL.  It's best if the client specifies the type
  776.  * with PCL.
  777.  */
  778. bool
  779. HylaFAXServer::docType(const char* docname, FaxSendOp& op)
  780. {
  781.     op = FaxRequest::send_unknown;
  782.     int fd = Sys::open(docname, O_RDONLY);
  783.     if (fd >= 0) {
  784. struct stat sb;
  785. if (FileCache::lookup(docname, sb) && S_ISREG(sb.st_mode)) {
  786.     union {
  787. char buf[512];
  788. TIFFHeader h;
  789.     } b;
  790.     ssize_t cc = Sys::read(fd, (char*) &b, sizeof (b));
  791.     if (cc > 2 && b.buf[0] == '%' && b.buf[1] == '!')
  792. op = FaxRequest::send_postscript;
  793.     else if (cc > 2 && b.buf[0] == '%' && b.buf[1] == 'P') {
  794.      logDebug("What we have here is a PDF file");
  795.      op = FaxRequest::send_pdf;
  796.     } else if (cc > 2 && b.buf[0] == 0x1b && (b.buf[1] == 'E' || b.buf[1] == '%' || b.buf[1] == '&' || b.buf[1] == '*')) {
  797.      logDebug("What we have here is a PCL file");
  798.      op = FaxRequest::send_pcl;
  799.     } else if (cc > (ssize_t)sizeof (b.h) && isTIFF(b.h))
  800. op = FaxRequest::send_tiff;
  801.     else if (cc > 3 && b.buf[0] == '@' && b.buf[1] == 'P' && b.buf[2] == 'J' && b.buf[3] == 'L') {
  802.      logDebug("PJL is unsupported");
  803.      op = FaxRequest::send_unknown;
  804.     }
  805.     else
  806. op = FaxRequest::send_data;
  807. }
  808. Sys::close(fd);
  809.     }
  810.     if (op == FaxRequest::send_unknown)
  811.           logError("Don't know what file");
  813.     return (op != FaxRequest::send_unknown);   
  814. }